def setUp(self):
self.symbol = Symbol(Object(None), "test")
unary_signature_strings = [
"size", "addTwo", "use", "call",
"parse", "hash", "notify", "setUp",
"weight", "isOk", "isNotOk", "create"
]
self.unary_signature_symbols = [Symbol(Object(None),string) for string in unary_signature_strings]
binary_signature_chars = [
"~", "&", "|", "*", "/",
"@", "+", "-", "=", ">",
"<", ",", "%", "\\"
]
self.binary_signature_symbols = [Symbol(Object(None),char) for char in binary_signature_chars]
keyword2_signature_strings = [
"at:put:", "remove:from:", "add:withKey:",
"choose:from:", "add:from:", "choose:and:"
]
self.keyword2_signature_symbols = [Symbol(Object(None),string) for string in keyword2_signature_strings]
keyword3_signature_strings = [
"at:put:and:", "choose:divide:andAddTo:",
"add:to:andNotify:", "parse:addTo:export:"
]
self.keyword3_signature_symbols = [Symbol(Object(None),string) for string in keyword3_signature_strings]
def setUp(self):
# Universe definition
self.universe = Universe()
# Array definition, 5 strings "bar"
self.array = Array(Object(None), 5)
for i in range(4):
self.array.set_indexable_field(i, "bar")
# Extended array definition, 5 strings "bar" followed by a string "foo"
self.extended_array = Array(Object(None), 6)
for i in range(4):
self.extended_array.set_indexable_field(i, "bar")
self.extended_array.set_indexable_field(5, "foo")
def test_copy_indexable_fields_to(self):
# Populate a destination array with erroneous data to ensure it is overwritten
destination = Array(Object(None), 5)
for i in range(4):
destination.set_indexable_field(i, "foo")
self.array._copy_indexable_fields_to(destination)
self.assertEqual(self.array, destination)
def new_instance(self, instance_class):
# Allocate a new instance and set its class to be the given class
result = Object(self._nilObject,
instance_class.get_number_of_instance_fields())
result.set_class(instance_class)
# Return the freshly allocated instance
return result
def new_instance(self, instance_class):
return Object(self.nilObject, instance_class.get_number_of_instance_fields(), instance_class)
def _initialize_object_system(self):
# Allocate the nil object
self.nilObject = Object(None)
# Allocate the Metaclass classes
self.metaclassClass = self.new_metaclass_class()
# Allocate the rest of the system classes
self.objectClass = self.new_system_class()
self.nilClass = self.new_system_class()
self.classClass = self.new_system_class()
self.arrayClass = self.new_system_class()
self.symbolClass = self.new_system_class()
self.methodClass = self.new_system_class()
self.integerClass = self.new_system_class()
self.primitiveClass = self.new_system_class()
self.stringClass = self.new_system_class()
self.doubleClass = self.new_system_class()
# Setup the class reference for the nil object
self.nilObject.set_class(self.nilClass)
# Initialize the system classes
self._initialize_system_class(self.objectClass, None, "Object")
self._initialize_system_class(self.classClass, self.objectClass, "Class")
self._initialize_system_class(self.metaclassClass, self.classClass, "Metaclass")
self._initialize_system_class(self.nilClass, self.objectClass, "Nil")
self._initialize_system_class(self.arrayClass, self.objectClass, "Array")
self._initialize_system_class(self.methodClass, self.arrayClass, "Method")
self._initialize_system_class(self.symbolClass, self.objectClass, "Symbol")
self._initialize_system_class(self.integerClass, self.objectClass, "Integer")
self._initialize_system_class(self.primitiveClass, self.objectClass, "Primitive")
self._initialize_system_class(self.stringClass, self.objectClass, "String")
self._initialize_system_class(self.doubleClass, self.objectClass, "Double")
# Load methods and fields into the system classes
self._load_system_class(self.objectClass)
self._load_system_class(self.classClass)
self._load_system_class(self.metaclassClass)
self._load_system_class(self.nilClass)
self._load_system_class(self.arrayClass)
self._load_system_class(self.methodClass)
self._load_system_class(self.symbolClass)
self._load_system_class(self.integerClass)
self._load_system_class(self.primitiveClass)
self._load_system_class(self.stringClass)
self._load_system_class(self.doubleClass)
# Load the generic block class
self.blockClass = self.load_class(self.symbol_for("Block"))
# Setup the true and false objects
trueClassName = self.symbol_for("True")
trueClass = self.load_class(trueClassName)
self.trueObject = self.new_instance(trueClass)
falseClassName = self.symbol_for("False")
falseClass = self.load_class(falseClassName)
self.falseObject = self.new_instance(falseClass)
# Load the system class and create an instance of it
self.systemClass = self.load_class(self.symbol_for("System"))
system_object = self.new_instance(self.systemClass)
# Put special objects and classes into the dictionary of globals
self.set_global(self.symbol_for("nil"), self.nilObject)
self.set_global(self.symbol_for("true"), self.trueObject)
self.set_global(self.symbol_for("false"), self.falseObject)
self.set_global(self.symbol_for("system"), system_object)
self.set_global(self.symbol_for("System"), self.systemClass)
self.set_global(self.symbol_for("Block"), self.blockClass)
self.set_global(self.symbol_for("Nil"), self.nilClass)
self.set_global( trueClassName, trueClass)
self.set_global(falseClassName, falseClass)
self.blockClasses = [self.blockClass] + \
[self._make_block_class(i) for i in [1, 2, 3]]
self._interpreter.initialize_known_quick_sends()
return system_object
def setUp(self):
self.string = String(Object(None), "test")
def setUp(self):
self.table = SymbolTable()
self.symbol = Symbol(nilObject=Object(None), value="foo")
def setUp(self):
self.big_integer = BigInteger(Object(None), 30000000000)
self.integer = Integer(Object(None), 3)
def test_get_class(self):
integer_class = Class(self.universe)
integer_class.set_name(Symbol(Object(None), "Integer"))
self.assertEqual(integer_class, self.object_integer.get_class())
def setUp(self):
self.universe = Universe
self.object_integer = Object(None)
self.integer_class = Class(self.universe)
self.integer_class.set_name(Symbol(Object(None), "Integer"))
self.object_integer._class = self.integer_class
def new_instance(self, instance_class):
num_fields = instance_class.get_number_of_instance_fields()
if num_fields == 0:
return ObjectWithoutFields(instance_class)
else:
return Object(instance_class, num_fields)
def setUp(self):
self.double = Double(Object(None), 5.5)
def setUp(self):
self.method = 0
self.context = 0
self.block = Block(Object(None), )
