def test_basic(self): code = 'switch ("blue") do {case "blue": {true}; case "red": {false}}' interpreter, outcome = interpret(code) self.assertEqual(Boolean(True), outcome) code = 'switch ("red") do {case "blue": {true}; case "red": {false}}' interpreter, outcome = interpret(code) self.assertEqual(Boolean(False), outcome)
def test_in(self): _, outcome = interpret('2 in [1, 2]') self.assertEqual(Boolean(True), outcome) _, outcome = interpret('0 in [1, 2]') self.assertEqual(Boolean(False), outcome) _, outcome = interpret('[0, 1] in [1, [0, 1]]') self.assertEqual(Boolean(True), outcome)
def test_boolean(self): code = "y = true || x" analyzer = Analyzer() scope = analyzer.get_scope('x') scope['x'] = Boolean() analyze(parse(code), analyzer) self.assertEqual(analyzer.exceptions, []) self.assertEqual(analyzer['y'], Boolean())
def test_is_server(self): sim = Simulation() id0 = sim.add_client(Client(sim)) # client sim.clients[id0].execute('_x = isServer;') self.assertEqual(Boolean(False), sim.clients[id0]._interpreter['_x']) # server sim.server.execute('_x = isServer;') self.assertEqual(Boolean(True), sim.server._interpreter['_x']) sim.server.execute('_x = isDedicated;') self.assertEqual(Boolean(True), sim.server._interpreter['_x'])
def identify_token(token): """ The function that converts a token from tokenize to a BaseType. """ if isinstance(token, (Comment, String)): return token if token == ' ': return Space() if token == '\t': return Tab() if token == '\\\n': return BrokenEndOfLine() if token in ('(', ')', '[', ']', '{', '}', ',', ';'): return ParserKeyword(token) if token in ('\n', '\r\n'): return EndOfLine(token) if token in ('true', 'false'): return Boolean(token == 'true') try: return Number(int(token)) except ValueError: pass try: return Number(float(token)) except ValueError: pass if token in PREPROCESSORS: return Preprocessor(token) if token.lower() in NAMESPACES: return Namespace(token) elif token.lower() in KEYWORDS: return Keyword(token) else: return Variable(token)
def execute_switch(interpreter, result, conditions): try: default = next(o for c, o in conditions if c == 'default') except StopIteration: default = None final_outcome = None execute_next = False for condition, outcome in conditions: if condition == 'default': continue condition_outcome = interpreter.value(condition) if outcome is not None and execute_next: final_outcome = interpreter.execute_code(outcome) break elif condition_outcome == result: if outcome is not None: final_outcome = interpreter.execute_code(outcome) break else: execute_next = True if final_outcome is None: if default is not None: final_outcome = interpreter.execute_code(default) else: final_outcome = Boolean(True) return final_outcome
def execute_token(self, token): """ Given a single token, recursively evaluate it and return its value. """ # interpret the statement recursively if isinstance(token, Statement): result = self.execute_single(statement=token) elif isinstance(token, Array): # empty statements are ignored result = Array( [self.execute_token(s)[1] for s in token.value if s]) elif token == Keyword('isServer'): result = Boolean(self.client.is_server) elif token == Keyword('isDedicated'): result = Boolean(self.client.is_dedicated) else: result = token result.position = token.position return result, self.value(result)
def test_forspec_exit_with_bool(self): test = ''' a = 0; b = true; for [{_i = 0}, {_i < 10 && b}, {_i = _i + 1}] do { a = a + 1; if (a >= 7) then {b = false} } ''' interpreter, outcome = interpret(test) self.assertEqual(Boolean(False), outcome) self.assertEqual(N(7), interpreter['a'])
def test_private_eq1(self): interpreter, outcome = interpret('private _x = 1 < 2;') self.assertEqual(Boolean(True), interpreter['_x'])
def test_leq(self): _, outcome = interpret('_x = 10; _x <= 10') self.assertEqual(Boolean(True), outcome)
def test_one_statement1(self): test = '_y = 2; (_y == 3)' interpreter, outcome = interpret(test) self.assertEqual(Boolean(False), outcome)
def test_code_dont_execute(self): interpreter, outcome = interpret('_x = true; {_x = false};') self.assertEqual(Boolean(True), interpreter['_x']) self.assertEqual(Nothing(), outcome)
def test_return_true(self): code = 'switch (0) do {case (1): {"one"};}' interpreter, outcome = interpret(code) self.assertEqual(Boolean(True), outcome)
def test_bool(self): self.assertEqual('true', str(Boolean(True))) self.assertEqual('false', str(Boolean(False)))
def __init__(self, condition=None): if condition is None: condition = Boolean() super().__init__(condition)
def test_one_statement(self): test = '_y = 2; _x = (_y == 3);' interpreter, outcome = interpret(test) self.assertEqual(Boolean(False), interpreter['_x']) self.assertEqual(Nothing(), outcome)
def test_define_expression(self): code = '#define X (1 == 2)\n x = X' analyzer = analyze(parse(code)) errors = analyzer.exceptions self.assertEqual(len(errors), 0) self.assertEqual(Boolean(), analyzer['x'])
def test_one_statement2(self): test = '(3 - 1) == (3 + 1)' interpreter, outcome = interpret(test) self.assertEqual(Boolean(False), outcome)