def test_PyBuiltin_types(self) -> None:
p = parser.Parser(vocabulary=parser.PyBuiltin())
peval: AnyOp = lambda expr, *args: p.parse(expr).eval(*args)
# Builtin Number Types
self.assertCaseEqual(peval, [
Case(('bool(x)', 1), {}, True),
Case(('complex(x)', 1), {}, 1 + 0j),
Case(('float(x)', 1), {}, 1.),
Case(('int(x)', 1.), {}, 1.)
])
# Builtin Container Types
self.assertCaseEqual(peval, [
Case(('bytearray(x)', 1), {}, bytearray(b'\x00')),
Case(('bytearray(x, e)', 'x', 'utf8'), {}, bytearray(b'x')),
Case(('bytes(x)', 1), {}, b'\x00'),
Case(('bytes(x, e)', 'x', 'utf8'), {}, b'x'),
Case(('dict(s)', [(1, 1)]), {}, {1: 1}),
Case(('frozenset(l)', [1, 2]), {}, frozenset([1, 2])),
Case(('list(a)', (1, 2, 3)), {}, [1, 2, 3]),
Case(('list(memoryview(x))', b'x'), {}, [120]),
Case(('str(o)', list()), {}, '[]'),
Case(('set(l)', [1, 2, 3]), {}, {1, 2, 3}),
Case(('tuple(l)', [1, 2, 3]), {}, (1, 2, 3))
])
# Further Builtin Types
# Note: object and type are tested within test_PyBuiltin_oop()
self.assertCaseEqual(peval, [Case(('slice(n)', 3), {}, slice(3))])
def test_PyBuiltin_constants(self) -> None:
p = parser.Parser(vocabulary=parser.PyBuiltin())
peval: AnyOp = lambda expr, *args: p.parse(expr).eval(*args)
# Builtin Constants
self.assertCaseEqual(peval, [
Case(('True', ), {}, True),
Case(('False', ), {}, False),
Case(('None', ), {}, None),
Case(('Ellipsis', ), {}, Ellipsis)
])
def test_PyBuiltin_runtime(self) -> None:
p = parser.Parser(vocabulary=parser.PyBuiltin())
peval: AnyOp = lambda expr, *args: p.parse(expr).eval(*args)
# Runtime Evaluation and Meta Programming
# TODO: Untested functions: breakpoint(), help(), input(), print()
self.assertCaseEqual(peval, [
Case(('bool(compile(a, b, c))', '1', '1', 'eval'), {}, True),
Case(('eval(e)', 'True'), {}, True),
Case(('exec(e)', 'True'), {}, None),
Case(('bool(globals())', ), {}, True),
Case(('id(x)', None), {}, id(None)),
Case(('bool(locals())', ), {}, True)
])
def test_PyBuiltin_math(self) -> None:
p = parser.Parser(vocabulary=parser.PyBuiltin())
peval: AnyOp = lambda expr, *args: p.parse(expr).eval(*args)
# Simple mathematical functions
self.assertCaseEqual(peval, [
Case(('abs(x)', -1), {}, 1),
Case(('divmod(a, b)', 2, 1), {}, (2, 0)),
Case(('max(l)', [1, 2, 3]), {}, 3),
Case(('min(l)', [1, 2, 3]), {}, 1),
Case(('pow(x, y)', 2, 2), {}, 4),
Case(('round(x)', .6), {}, 1),
Case(('sum(l)', [1, 2, 3]), {}, 6)
])
def test_PyBuiltin_conversion(self) -> None:
p = parser.Parser(vocabulary=parser.PyBuiltin())
peval: AnyOp = lambda expr, *args: p.parse(expr).eval(*args)
# Conversion
self.assertCaseEqual(peval, [
Case(('ascii(x)', 1), {}, '1'),
Case(('bin(x)', 1), {}, '0b1'),
Case(('chr(x)', 65), {}, 'A'),
Case(('format(x)', 'A'), {}, 'A'),
Case(('hex(x)', 1), {}, '0x1'),
Case(('oct(x)', 1), {}, '0o1'),
Case(('ord(x)', 'A'), {}, 65)
])
def test_PyBuiltin_functional(self) -> None:
p = parser.Parser(vocabulary=parser.PyBuiltin())
peval: AnyOp = lambda expr, *args: p.parse(expr).eval(*args)
# Functional Programming and Iterator functions
self.assertCaseEqual(peval, [
Case(('all(l)', [1, 1, 0]), {}, False),
Case(('any(l)', [1, 1, 0]), {}, True),
Case(('list(enumerate(l))', [1, 2]), {}, [(0, 1), (1, 2)]),
Case(('list(filter(None, l))', []), {}, []),
Case(('list(iter(l))', [1, 2, 3]), {}, [1, 2, 3]),
Case(('list(map(f, l))', bool, [0]), {}, [False]),
Case(('next(iter(l))', [1, 2, 3]), {}, 1),
Case(('list(range(n))', 3), {}, [0, 1, 2]),
Case(('sorted(l)', [3, 2, 1]), {}, [1, 2, 3]),
Case(('list(zip(l, l))', range(2)), {}, [(0, 0), (1, 1)])
])
def test_PyBuiltin_oop(self) -> None:
p = parser.Parser(vocabulary=parser.PyBuiltin())
peval: AnyOp = lambda expr, *args: p.parse(expr).eval(*args)
# Builtin Types for Object Oriented Programming
self.assertCaseEqual(peval, [
Case(('isinstance(object(), c)', object), {}, True),
Case(('type(o)', object), {}, type)
])
# Builtin functions for Object and Class Tree Organisation
self.assertCaseEqual(peval, [
Case(('isinstance(a, b)', 1, int), {}, True),
Case(('issubclass(a, b)', int, int), {}, True)
])
# Builtin functions for Attribute Organisation
self.assertCaseEqual(peval, [
Case(('delattr(o, a)', mock.Mock(), 'a'), {}, None),
Case(('dir(o)', object), {}, dir(object)),
Case(('getattr(o, a)', 1j, 'imag'), {}, 1.),
Case(('hasattr(o, a)', 1j, 'imag'), {}, True),
Case(('setattr(o, a, v)', mock.Mock(), 'a', 0), {}, None)
])
# Builtin functions for special Methods
self.assertCaseEqual(peval, [
Case(('bool(classmethod(o))', object), {}, True),
Case(("hasattr(property(), 'getter')", ), {}, True),
Case(("hasattr(staticmethod(f), '__func__')", list), {}, True)
])
# Builtin functions for special Attributes
self.assertCaseEqual(peval, [
Case(('callable(o)', object), {}, True),
Case(('hash(o)', 1), {}, 1),
Case(('len(o)', [1, 2, 3]), {}, 3),
Case(('repr(o)', 'x'), {}, "'x'"),
Case(('sorted(vars(o))', type), {}, sorted(vars(type)))
])