def test_PrimitiveIntObject_as_primitive_string(): o = PrimitiveIntObject(2) plus_slot = o.slot_lookup("asString") assert plus_slot.map.primitive_code result = plus_slot.map.primitive_code(None, o, []) assert result == PrimitiveStrObject("2")
def test_parallelism(): one_plus_one_ast = lex_and_parse("""(| add = (|| 1 + 1) |) add""") two_plus_two_ast = lex_and_parse("""(| add = (|| 2 + 2) |) add""") one_plus_one_ctx = one_plus_one_ast[0].compile(CodeContext()) two_plus_two_ctx = two_plus_two_ast[0].compile(CodeContext()) interpreter = Interpreter(universe=get_primitives()) one_plus_one_process = interpreter.add_process(one_plus_one_ctx) two_plus_two_process = interpreter.add_process(two_plus_two_ctx) assert not one_plus_one_process.finished assert not one_plus_one_process.result assert not two_plus_two_process.finished assert not two_plus_two_process.result interpreter.interpret() assert one_plus_one_process.finished assert one_plus_one_process.result == PrimitiveIntObject(2) assert two_plus_two_process.finished assert two_plus_two_process.result == PrimitiveIntObject(4)
def call_primitive_int_binary_op(first, op, second, equals): o = PrimitiveIntObject(first) if isinstance(equals, (int, long)): equals = PrimitiveIntObject(equals) primitive_slot = o.slot_lookup(op) assert primitive_slot.map.primitive_code result = primitive_slot.map.primitive_code(None, o, [PrimitiveIntObject(second)]) assert result == equals
def test_mirror(): o = Object() m = Mirror(o) assert not o.slot_lookup("v") add_primitive = m.slot_lookup("toSlot:Add:") assert add_primitive.map.primitive_code result = add_primitive.map.primitive_code( None, m, [PrimitiveStrObject("v"), PrimitiveIntObject(1)]) assert result == o assert o.slot_lookup("v") == PrimitiveIntObject(1)
def _do_push_literal(self, bc_index, code_obj): literal_type = ord(code_obj.bytecodes[bc_index + 1]) literal_index = ord(code_obj.bytecodes[bc_index + 2]) boxed_literal = code_obj.literals[literal_index] if literal_type == LITERAL_TYPE_NIL: obj = NIL elif literal_type == LITERAL_TYPE_ASSIGNMENT: obj = AssignmentPrimitive() elif literal_type == LITERAL_TYPE_INT: assert isinstance(boxed_literal, IntBox) obj = PrimitiveIntObject(boxed_literal.value) elif literal_type == LITERAL_TYPE_FLOAT: assert isinstance(boxed_literal, FloatBox) obj = PrimitiveFloatObject(boxed_literal.value) elif literal_type == LITERAL_TYPE_STR: assert isinstance(boxed_literal, StrBox) obj = PrimitiveStrObject(boxed_literal.value) elif literal_type == LITERAL_TYPE_OBJ: assert isinstance(boxed_literal, ObjBox) obj = boxed_literal.value.clone() if self.process.frame.self is None: self.process.frame.self = obj elif literal_type == LITERAL_TYPE_BLOCK: assert isinstance(boxed_literal, ObjBox) block = boxed_literal.value.clone() obj = add_block_trait(block) block.is_block = True block.scope_parent = self.process.frame.pop() else: raise ValueError("Unknown literal type; %s" % literal_type) self.process.frame.push(obj) return THREE_BYTECODES_LONG
def test_interpreter(): ast = lex_and_parse("""(| a <- 1. add: b = (|| (a + 1) + b ) |) add: 2""") context = ast[0].compile(CodeContext()) interpreter = Interpreter(universe=get_primitives(), code_context=context) interpreter.interpret() assert interpreter.process.result == PrimitiveIntObject(4)
def test_resend_keyword(): ast = lex_and_parse("""(| p* = (| xex: a = (|| 1). |). q* = (| xex: a = (|| a). |). fetchXex = (|| q.xex: 2) |) fetchXex""") context = ast[0].compile(CodeContext()) interpreter = Interpreter(universe=get_primitives(), code_context=context) interpreter.interpret() assert interpreter.process.result == PrimitiveIntObject(2)
def test_PrimitiveNilObject_equals(): o = PrimitiveNilObject() eq_slot = o.slot_lookup("==") result = eq_slot.map.primitive_code(None, o, [PrimitiveNilObject()]) assert result == PrimitiveTrueObject() eq_slot = o.slot_lookup("==") result = eq_slot.map.primitive_code(None, o, [PrimitiveIntObject(3)]) assert result == PrimitiveFalseObject() eq_slot = o.slot_lookup("==") result = eq_slot.map.primitive_code(None, o, [PrimitiveTrueObject()]) assert result == PrimitiveFalseObject()
def test_PrimitiveFalseObject_is(): o = PrimitiveFalseObject() is_slot = o.slot_lookup("is:") result = is_slot.map.primitive_code(None, o, [PrimitiveFalseObject()]) assert result == PrimitiveTrueObject() is_slot = o.slot_lookup("is:") result = is_slot.map.primitive_code(None, o, [PrimitiveIntObject(3)]) assert result == PrimitiveFalseObject() is_slot = o.slot_lookup("is:") result = is_slot.map.primitive_code(None, o, [PrimitiveTrueObject()]) assert result == PrimitiveFalseObject()
def test_assignment_primitive(): ast = lex_and_parse("""(| a <- 0. incA = (|| a: 1. ^a ) |) incA""") context = ast[0].compile(CodeContext()) interpreter = Interpreter(universe=get_primitives(), code_context=context) interpreter.interpret() assert interpreter.process.result == PrimitiveIntObject(1)
def test_set_error_handler_and_handle_error(): ast = lex_and_parse("""(| raiseError = (|| primitives interpreter error: 'Test'.). test = (|| primitives interpreter setErrorHandler: [:msg. :err | primitives interpreter restoreProcess: err With: 1. ]. ^ 1 + raiseError. ) |) test""") context = ast[0].compile(CodeContext()) interpreter = Interpreter(universe=get_primitives(), code_context=context) interpreter.interpret() assert interpreter.process.finished assert not interpreter.process.finished_with_error result = interpreter.process.result assert result == PrimitiveIntObject(2)
def test_block_with_argument(): ast = lex_and_parse("""(| a <- 0. giveOneToBlock: blk = (|| blk with: 1 ). shouldBeThree = (| tmp = 1. block. | block: [| :x | a + tmp + x]. a: 1. giveOneToBlock: block. ) |) shouldBeThree""") context = ast[0].compile(CodeContext()) interpreter = Interpreter(universe=get_primitives(), code_context=context) interpreter.interpret() assert interpreter.process.result == PrimitiveIntObject(3)
def test_block(): ast = lex_and_parse("""(| a <- 0. addTenToBlk: blk = (|| 10 + (blk value). ). add = (| tmp = 3. tmp_block. | tmp_block: [a + tmp]. a: 1. # block should reflect current scopes 2 + addTenToBlk: tmp_block. ) |) add""") context = ast[0].compile(CodeContext()) interpreter = Interpreter(universe=get_primitives(), code_context=context) interpreter.interpret() assert interpreter.process.result == PrimitiveIntObject(16)
def test_method_stack(): f = MethodStack() f.push(PrimitiveIntObject(1)) f.push(PrimitiveIntObject(2)) assert f.pop() == PrimitiveIntObject(2) assert f.pop() == PrimitiveIntObject(1) with raises(IndexError): f.pop() assert f.pop_or_nil() == NIL f.push(PrimitiveIntObject(1)) assert f.pop_or_nil() == PrimitiveIntObject(1) assert f.pop_or_nil() == NIL
def test_process_stack_push_frame_behavior(): ps = ProcessStack() ps.frame.push(PrimitiveIntObject(1)) assert not ps.is_nested_call() cc = CodeContext() method = Object() ps.push_frame(cc, method) assert ps.is_nested_call() assert ps.frame.code_context == cc retval = Object() ps.frame.push(retval) assert ps._length == 2 assert ps.frame._stack.obj == retval assert ps.frame.prev_stack._stack.obj != retval ps.pop_down_and_cleanup_frame() assert ps._length == 1 assert ps.frame._stack.obj == retval assert ps.frame.prev_stack is None
def _get_number_of_stack_frames(interpreter, _, parameters): return PrimitiveIntObject(interpreter.process._length)
def _get_number_of_processes(interpreter, _, parameters): return PrimitiveIntObject(len(interpreter.processes))