old_contents: 
  from nose.tools import *
  
  from libeeyore.builtins import *
  from libeeyore.environment import EeyEnvironment
  from libeeyore.values import *
  
  def test_true():
      env = EeyEnvironment( None )
      add_builtins( env )
  
      value = EeySymbol( "True" )
      ans = value.evaluate( env )
  
      assert_equal( ans.__class__, EeyBool )
      assert_equal( ans.value, True )
  
  
  def test_false():
      env = EeyEnvironment( None )
      add_builtins( env )
  
      value = EeySymbol( "False" )
      ans = value.evaluate( env )
  
      assert_equal( ans.__class__, EeyBool )
      assert_equal( ans.value, False )
  
  def test_len():
      env = EeyEnvironment( None )
      add_builtins( env )
  
      value = EeySymbol( "len" )
      ans = value.evaluate( env )
  
      assert_equal( ans.__class__, EeyLen )
  
  def test_print():
      env = EeyEnvironment( None )
      add_builtins( env )
  
      value = EeySymbol( "print" )
      ans = value.evaluate( env )
  
      assert_equal( ans.__class__, EeyPrint )
  
  
  def test_int():
      env = EeyEnvironment( None )
      add_builtins( env )
  
      value = EeySymbol( "int" )
      ans = value.evaluate( env )
  
      assert_equal( ans.__class__, EeyType )
      assert_equal( ans.value, EeyInt )
  
  
  def test_float():
      env = EeyEnvironment( None )
      add_builtins( env )
  
      value = EeySymbol( "float" )
      ans = value.evaluate( env )
  
      assert_equal( ans.__class__, EeyType )
      assert_equal( ans.value, EeyFloat )
  
  
  def test_string():
      env = EeyEnvironment( None )
      add_builtins( env )
  
      value = EeySymbol( "string" )
      ans = value.evaluate( env )
  
      assert_equal( ans.__class__, EeyType )
      assert_equal( ans.value, EeyString )
  
  
  def test_bool():
      env = EeyEnvironment( None )
      add_builtins( env )
  
      value = EeySymbol( "bool" )
      ans = value.evaluate( env )
  
      assert_equal( ans.__class__, EeyType )
      assert_equal( ans.value, EeyBool )
  
  def test_print_return_type_is_none():
      assert_equal( EeyPrint().return_type( None, () ), EeyType( EeyNoneType ) )
  
  def test_len_return_type_is_int():
      assert_equal( EeyLen().return_type( None, () ), EeyType( EeyInt ) )
  
  
  def test_void():
      env = EeyEnvironment( None )
      add_builtins( env )
  
      value = EeySymbol( "void" )
      ans = value.evaluate( env )
  
      assert_equal( ans.__class__, EeyType )
      assert_equal( ans.value, EeyVoid )
  
  
  
  def test_pass():
      env = EeyEnvironment( None )
      add_builtins( env )
  
      value = EeySymbol( "pass" )
      ans = value.evaluate( env )
  
      assert_equal( ans.__class__, EeyPass )
  
  
  
  def test_type():
      env = EeyEnvironment( None )
      add_builtins( env )
  
      value = EeySymbol( "type" )
      ans = value.evaluate( env )
  
      assert_equal( ans.__class__, EeyType )
  
  
  
  
new_contents: 
  from nose.tools import *
  
  from libeeyore.builtins import *
  from libeeyore.environment import EeyEnvironment
  from libeeyore.values import *
  
  def assert_defined( name, expected_class, expected_value = None ):
      env = EeyEnvironment( None )
      add_builtins( env )
  
      value = EeySymbol( name )
      ans = value.evaluate( env )
  
      assert_equal( ans.__class__, expected_class )
  
      if expected_value != None:
          assert_equal( ans.value, expected_value )
  
  # Statements
  def test_pass():
      assert_defined( "pass", EeyPass )
  
  # Values
  def test_False():
      assert_defined( "False", EeyBool, False )
  
  def test_True():
      assert_defined( "True", EeyBool, True )
  
  # Types
  def test_bool():
      assert_defined( "bool", EeyType, EeyBool )
  
  def test_float():
      assert_defined( "float", EeyType, EeyFloat )
  
  def test_int():
      assert_defined( "int", EeyType, EeyInt )
  
  def test_string():
      assert_defined( "string", EeyType, EeyString )
  
  def test_void():
      assert_defined( "void", EeyType, EeyVoid )
  
  def test_type():
      assert_defined( "type", EeyType, EeyType )
  
  # Functions
  def test_len():
      assert_defined( "len", EeyLen )
  
  def test_len_return_type_is_int():
      assert_equal( EeyLen().return_type( None, () ), EeyType( EeyInt ) )
  
  def test_print():
      assert_defined( "print", EeyPrint )
  
  def test_print_return_type_is_none():
      assert_equal( EeyPrint().return_type( None, () ), EeyType( EeyNoneType ) )
  
  
  
subject: Refactor testbuiltins to reduce repetitive code and re-arrange into the same order as builtins.