def test_parent_lookup_from_parent_tree():
"""
Based on real case.
"""
value = PrimitiveStrObject("value")
o1 = Object()
o2 = Object()
o3 = o2.clone()
o4 = Object()
o5 = Object()
o1.scope_parent = o2
o2.scope_parent = o3
o2.meta_add_parent("*", o5)
o3.scope_parent = o4
o3.meta_add_parent("*", o5)
o4.scope_parent = o5
o4.meta_add_slot("value", value)
assert o1.get_slot("value") is None
assert o1.parent_lookup("value") is value
def test_loop(self):
source = """
(|
benchmark = (| i <- 0. |
[i < 1000] whileTrue: [
i: i + 1.
].
).
|) benchmark.
"""
universe = Object()
universe.meta_add_slot("primitives", get_primitives())
interpreter = Interpreter(universe)
run_stdlib(interpreter, stdlib_source)
ast = lex_and_parse_as_root(source)
if not ast:
return None, interpreter
code = ast.compile(CodeContext())
interpreter.add_process(code.finalize())
def f():
interpreter.interpret()
return 0
#res = f()
#assert res == 0
res = self.meta_interp(f, [],
listops=True,
listcomp=True,
backendopt=True)
assert res == 0
def test_meta_add_slot():
val = PrimitiveStrObject("xe")
o = Object()
assert not o._slot_values
o.meta_add_slot("test", val)
assert o._slot_values[0] == val
def test_slot_lookup_from_scope_parent():
p = Object()
val = PrimitiveStrObject("it is xex!")
p.meta_add_slot("xex", val)
o = Object()
o.scope_parent = p
assert o.get_slot("xex") is None
assert o.slot_lookup("xex") is val
def test_meta_remove_slot():
o = Object()
assert not o._slot_values
o.meta_add_slot("test", Object())
assert o._slot_values
assert "test" in o.map._slots
o.meta_remove_slot("test")
assert not o._slot_values
assert "test" not in o.map._slots
def test_get_slot_from_one_parent():
val = PrimitiveStrObject("it is xex!")
p = Object()
p.meta_add_slot("xex", val)
o = Object()
o.meta_add_parent("p", p)
assert o.get_slot("xex") is None
assert o.parent_lookup("xex") is val
def test_slot_lookup_from_scope_parent_and_then_parents():
p = Object()
val = PrimitiveStrObject("it is xex!")
p.meta_add_slot("a", val)
interobj = Object()
interobj.scope_parent = p
o = Object()
o.scope_parent = Object()
o.scope_parent.meta_add_parent("*", interobj)
assert o.slot_lookup("a") is val
def _add_reflection_to_universe(self):
self.universe.meta_add_slot("universe", self.universe)
primitives = self.universe.get_slot("primitives")
if primitives is None:
primitives = Object()
self.universe.meta_add_slot("primitives", primitives)
# transport values from primitives to global level
for slot in primitives.slot_keys:
self.universe.meta_add_slot(slot, primitives.get_slot(slot))
primitives.meta_add_slot("interpreter", gen_interpreter_primitives(self))
def test_meta_add_slot_do_check_duplicates():
xx = PrimitiveStrObject("xx")
zz = PrimitiveStrObject("zz")
o = Object()
assert not o._slot_values
o.meta_add_slot("xx", xx)
o.meta_add_slot("zz", zz)
assert len(o._slot_values) == 2
o.meta_add_slot("xx2", xx, check_duplicates=True)
assert len(o._slot_values) == 2
def slot_lookup():
val = PrimitiveStrObject("it is xex!")
flat = PrimitiveStrObject("it is flat")
p = Object()
p.meta_add_slot("xex", val)
o = Object()
o.meta_add_parent("p", p)
o.meta_add_parent("p", flat)
assert o.get_slot("xex") is None
assert o.slot_lookup("xex") is val
assert o.slot_lookup("flat") is flat
def test_get_slot_from_several_parents():
"""
o.parents
|
|-- p <-- cycle, yay --,
| |-- x -> Object() |
| |-- y -> Object() |
| `-- z -> p --------'
|
`-- p3
`-- x -> p2
|
`-- xex
"""
val = PrimitiveStrObject("it is xex!")
p = Object()
p.meta_add_slot("x", Object())
p.meta_add_slot("y", Object())
p.meta_add_slot("z", p) # cycle, yay!
p2 = Object()
p.meta_add_slot("xex", val)
p3 = Object()
p.meta_add_slot("x", p2)
o = Object()
o.meta_add_parent("p", p)
o.meta_add_parent("p3", p3)
assert o.get_slot("xex") is None
assert o.parent_lookup("xex") is val
def test_running_self_unittest_file():
universe = Object()
universe.meta_add_slot("primitives", get_primitives())
dirname = os.path.dirname(__file__)
source_file_path = os.path.join(dirname, "..", "scripts", "unittest.self")
with open(source_file_path) as source_file:
ast = lex_and_parse(source_file.read())
interpreter = Interpreter(universe)
for item in ast:
process = interpreter.add_process(item.compile(CodeContext()))
interpreter.interpret()
assert process.finished
assert not process.finished_with_error
def _create_block_trait_prototype():
obj = Object()
placer = PrimitiveNilObject()
obj.meta_add_slot("value", placer, check_duplicates=True)
obj.meta_add_slot("with:", placer, check_duplicates=True)
obj.meta_add_slot("with:With:", placer, check_duplicates=True)
obj.meta_add_slot("with:With:With:", placer, check_duplicates=True)
obj.meta_add_slot("with:With:With:With:", placer, check_duplicates=True)
obj.meta_add_slot("withAll:", placer, check_duplicates=True)
add_primitive_fn(obj, "asString", _print_block_source, [])
add_primitive_fn(obj, "getLineNumber", _get_lineno, [])
obj.scope_parent = _USER_EDITABLE_BLOCK_TRAIT
return obj
def test_clone():
o = Object()
o.meta_add_slot("test", Object())
# clones share same map
clone = o.clone()
assert clone.map is o.map
assert clone._slot_values == o._slot_values
# clones with updated slot value share same map
clone.set_slot("test", Object())
assert clone.map is o.map
assert clone._slot_values != o._slot_values
# clones with different structure don't share maps
clone.meta_add_slot("another", Object())
assert clone.map is not o.map
assert clone._slot_values != o._slot_values
def virtual_machine(source, stdlib_source=""):
universe = Object()
universe.meta_add_slot("primitives", get_primitives())
interpreter = Interpreter(universe)
if stdlib_source:
if not run_stdlib(interpreter, stdlib_source):
return None, interpreter
ast = lex_and_parse_as_root(source)
if not ast:
return None, interpreter
code = ast.compile(CodeContext())
process = interpreter.add_process(code.finalize())
interpreter.interpret()
return process, interpreter
def test_meta_insert_slot():
first = PrimitiveStrObject("first")
second = PrimitiveStrObject("second")
third = PrimitiveStrObject("third")
o = Object()
assert not o._slot_values
o.meta_add_slot("first", first)
o.meta_add_slot("third", third)
assert o.get_slot("first") is first
assert o.get_slot("third") is third
o.meta_insert_slot(1, "second", second)
assert o.map._slots.keys() == ["first", "second", "third"]
# make sure that objects didn't shifted
assert o.get_slot("first") is first
assert o.get_slot("second") is second
assert o.get_slot("third") is third
def test_meta_remove_slot_shift_map_pointers():
first = PrimitiveStrObject("first")
second = PrimitiveStrObject("second")
third = PrimitiveStrObject("third")
o = Object()
assert not o._slot_values
o.meta_add_slot("first", first)
o.meta_add_slot("second", second)
o.meta_add_slot("third", third)
assert o.get_slot("first") is first
assert o.get_slot("second") is second
assert o.get_slot("third") is third
o.meta_remove_slot("first")
assert len(o._slot_values) == 2
assert len(o.map._slots) == 2
assert o.map._slots["second"] == 0
assert o.map._slots["third"] == 1
assert o.get_slot("first") is None
assert o.get_slot("second") == second
assert o.get_slot("third") == third
def get_primitives():
"""
Return object with primitive functions mapped to its slots.
Returns:
obj: Instance of tinySelf's Object.
"""
primitives = Object()
# add_primitive_fn(primitives, "primitiveInt", lambda x: PrimitiveIntObject(x), ["literal"])
# add_primitive_fn(primitives, "primitiveStr", lambda x: PrimitiveStrObject(x), ["literal"])
primitives.meta_add_slot("nil", PrimitiveNilObject())
primitives.meta_add_slot("true", PrimitiveTrueObject())
primitives.meta_add_slot("false", PrimitiveFalseObject())
primitives.meta_add_slot("block_traits", _USER_EDITABLE_BLOCK_TRAIT)
primitives.meta_add_slot("time", get_primitive_time_object())
add_primitive_fn(primitives, "mirrorOn:", _create_mirror, ["obj"])
return primitives
def _create_intermediate_params_obj(self, scope_parent, method_obj,
parameters, prev_scope_parent=None):
# do not create empty intermediate objects
if not method_obj.parameters:
# this is used to remember in what context is the block executed,
# so in case of indirect return, it is possible to return from
# this context and not just block
if prev_scope_parent:
method_obj.meta_add_parent("*", prev_scope_parent)
if not method_obj.is_block and method_obj.has_code:
return scope_parent
return prev_scope_parent
return scope_parent
if method_obj.code_context._params_cache is None:
intermediate_obj = Object()
intermediate_obj.meta_add_slot("ThisIsIntermediateObj", intermediate_obj)
else:
intermediate_obj = method_obj.code_context._params_cache.clone()
if scope_parent.has_parents or scope_parent.scope_parent or scope_parent.has_slots:
intermediate_obj.scope_parent = None if scope_parent == method_obj else scope_parent
if prev_scope_parent is not None:
prev_scope_parents_parent = prev_scope_parent.meta_get_parent("*", None)
if prev_scope_parents_parent and \
prev_scope_parent.scope_parent == prev_scope_parents_parent.scope_parent:
parent = prev_scope_parents_parent
else:
parent = prev_scope_parent
intermediate_obj.meta_add_parent("*", parent)
parameter_pairs = self._put_together_parameters(
parameter_names=method_obj.parameters,
parameters=parameters
)
for name, value in parameter_pairs:
intermediate_obj.meta_add_slot(name, value)
intermediate_obj.meta_add_slot(
name + ":",
AssignmentPrimitive(intermediate_obj)
)
if method_obj.code_context._params_cache is None:
method_obj.code_context._params_cache = intermediate_obj
return intermediate_obj
def test_set_slot():
o = Object()
o.meta_add_slot("test", PrimitiveStrObject("xe"))
assert o.set_slot("test", PrimitiveStrObject("xax"))
assert not o.set_slot("bad_slot", PrimitiveStrObject("x"))
def test_get_slot():
o = Object()
val = PrimitiveStrObject("xe")
o.meta_add_slot("test", val)
assert o.get_slot("test") is val
def test_meta_remove_missing_slot():
o = Object()
o.meta_add_slot("test", Object())
assert not o.meta_remove_slot("x")
