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)
