def testFieldExpKey(self):
p = get_parser('[1] = 2')
node = p._field()
self.assertIsNotNone(node)
self.assertEqual(7, p._pos)
self.assertTrue(isinstance(node, parser.FieldExpKey))
self.assertTrue(node.key_exp.value.matches(lexer.TokNumber('1')))
self.assertTrue(node.exp.value.matches(lexer.TokNumber('2')))
def testPrefixExpParenExp(self):
p = get_parser('(2 + 3)')
node = p._prefixexp()
self.assertIsNotNone(node)
self.assertEqual(7, p._pos)
self.assertTrue(isinstance(node, parser.ExpBinOp))
self.assertTrue(node.exp1.value.matches(lexer.TokNumber('2')))
self.assertEqual('+', node.binop.value)
self.assertTrue(node.exp2.value.matches(lexer.TokNumber('3')))
def testStatForStep(self):
p = get_parser('for foo=1,3,10 do break end')
node = p._stat()
self.assertIsNotNone(node)
self.assertEqual(15, p._pos)
self.assertEqual('foo', node.name.value)
self.assertTrue(node.exp_init.value.matches(lexer.TokNumber('1')))
self.assertTrue(node.exp_end.value.matches(lexer.TokNumber('3')))
self.assertTrue(node.exp_step.value.matches(lexer.TokNumber('10')))
self.assertEqual(1, len(node.block.stats))
self.assertTrue(isinstance(node.block.stats[0], parser.StatBreak))
def testPrefixExpIndex(self):
p = get_parser('foo[4 + 5]')
node = p._prefixexp()
self.assertIsNotNone(node)
self.assertEqual(8, p._pos)
self.assertTrue(isinstance(node, parser.VarIndex))
self.assertEqual('foo', node.exp_prefix.name.value)
self.assertTrue(node.exp_index.exp1.value.matches(
lexer.TokNumber('4')))
self.assertEqual('+', node.exp_index.binop.value)
self.assertTrue(node.exp_index.exp2.value.matches(
lexer.TokNumber('5')))
def testStatFunctionCall(self):
p = get_parser('foo(1, 2, 3)')
node = p._stat()
self.assertIsNotNone(node)
self.assertEqual(10, p._pos)
self.assertEqual('foo', node.functioncall.exp_prefix.name.value)
self.assertEqual(3, len(node.functioncall.args.explist.exps))
self.assertTrue(node.functioncall.args.explist.exps[0].value.matches(
lexer.TokNumber('1')))
self.assertTrue(node.functioncall.args.explist.exps[1].value.matches(
lexer.TokNumber('2')))
self.assertTrue(node.functioncall.args.explist.exps[2].value.matches(
lexer.TokNumber('3')))
def testExpBinOpChain(self):
p = get_parser('1 + 2 * 3 - 4 / 5..6^7 > 8 != foo')
node = p._exp()
self.assertIsNotNone(node)
self.assertEqual(29, p._pos)
self.assertEqual('foo', node.exp2.value.name.value)
self.assertEqual('!=', node.binop.value)
self.assertTrue(node.exp1.exp2.value.matches(lexer.TokNumber('8')))
self.assertEqual('>', node.exp1.binop.value)
self.assertTrue(node.exp1.exp1.exp2.value.matches(
lexer.TokNumber('7')))
self.assertEqual('^', node.exp1.exp1.binop.value)
self.assertTrue(
node.exp1.exp1.exp1.exp2.value.matches(lexer.TokNumber('6')))
self.assertEqual('..', node.exp1.exp1.exp1.binop.value)
self.assertTrue(
node.exp1.exp1.exp1.exp1.exp2.value.matches(lexer.TokNumber('5')))
self.assertEqual('/', node.exp1.exp1.exp1.exp1.binop.value)
self.assertTrue(
node.exp1.exp1.exp1.exp1.exp1.exp2.value.matches(
lexer.TokNumber('4')))
self.assertEqual('-', node.exp1.exp1.exp1.exp1.exp1.binop.value)
self.assertTrue(
node.exp1.exp1.exp1.exp1.exp1.exp1.exp2.value.matches(
lexer.TokNumber('3')))
self.assertEqual('*', node.exp1.exp1.exp1.exp1.exp1.exp1.binop.value)
self.assertTrue(
node.exp1.exp1.exp1.exp1.exp1.exp1.exp1.exp2.value.matches(
lexer.TokNumber('2')))
self.assertEqual('+',
node.exp1.exp1.exp1.exp1.exp1.exp1.exp1.binop.value)
self.assertTrue(
node.exp1.exp1.exp1.exp1.exp1.exp1.exp1.exp1.value.matches(
lexer.TokNumber('1')))
def testStatForIn(self):
p = get_parser('for foo, bar in 1, 3 do\n break\nend\n')
node = p._stat()
self.assertIsNotNone(node)
self.assertEqual(20, p._pos)
self.assertEqual(2, len(node.namelist.names))
self.assertEqual('foo', node.namelist.names[0].value)
self.assertEqual('bar', node.namelist.names[1].value)
self.assertEqual(2, len(node.explist.exps))
self.assertTrue(node.explist.exps[0].value.matches(
lexer.TokNumber('1')))
self.assertTrue(node.explist.exps[1].value.matches(
lexer.TokNumber('3')))
self.assertEqual(1, len(node.block.stats))
self.assertTrue(isinstance(node.block.stats[0], parser.StatBreak))
def testArgsTableConstructor(self):
p = get_parser('{5,}')
node = p._args()
self.assertIsNotNone(node)
self.assertEqual(4, p._pos)
self.assertEqual(1, len(node.fields))
self.assertTrue(node.fields[0].exp.value.matches(lexer.TokNumber('5')))
def testVarIndex(self):
p = get_parser('bar[7]')
node = p._var()
self.assertIsNotNone(node)
self.assertEqual(4, p._pos)
self.assertEqual('bar', node.exp_prefix.name.value)
self.assertTrue(node.exp_index.value.matches(lexer.TokNumber('7')))
def testStatLocalAssignmentWithValues(self):
p = get_parser('local foo, bar, baz = 1, 2, 3')
node = p._stat()
self.assertIsNotNone(node)
self.assertEqual(19, p._pos)
self.assertEqual(3, len(node.namelist.names))
self.assertEqual('foo', node.namelist.names[0].value)
self.assertEqual('bar', node.namelist.names[1].value)
self.assertEqual('baz', node.namelist.names[2].value)
self.assertEqual(3, len(node.explist.exps))
self.assertTrue(node.explist.exps[0].value.matches(
lexer.TokNumber('1')))
self.assertTrue(node.explist.exps[1].value.matches(
lexer.TokNumber('2')))
self.assertTrue(node.explist.exps[2].value.matches(
lexer.TokNumber('3')))
def testStatAssignment(self):
p = get_parser('foo, bar, baz = 1, 2, 3')
node = p._stat()
self.assertIsNotNone(node)
self.assertEqual(17, p._pos)
self.assertEqual(3, len(node.varlist.vars))
self.assertEqual('foo', node.varlist.vars[0].name.value)
self.assertEqual('bar', node.varlist.vars[1].name.value)
self.assertEqual('baz', node.varlist.vars[2].name.value)
self.assertTrue(node.assignop.matches(lexer.TokSymbol('=')))
self.assertEqual(3, len(node.explist.exps))
self.assertTrue(node.explist.exps[0].value.matches(
lexer.TokNumber('1')))
self.assertTrue(node.explist.exps[1].value.matches(
lexer.TokNumber('2')))
self.assertTrue(node.explist.exps[2].value.matches(
lexer.TokNumber('3')))
def testExpList(self):
p = get_parser(b'1, 2, 3 - 4, a..b^7, foo')
node = p._explist()
self.assertIsNotNone(node)
self.assertEqual(21, p._pos)
self.assertEqual(5, len(node.exps))
self.assertTrue(node.exps[0].value.matches(lexer.TokNumber(b'1')))
self.assertTrue(node.exps[1].value.matches(lexer.TokNumber(b'2')))
self.assertTrue(node.exps[2].exp1.value.matches(lexer.TokNumber(b'3')))
self.assertEqual(b'-', node.exps[2].binop.value)
self.assertTrue(node.exps[2].exp2.value.matches(lexer.TokNumber(b'4')))
self.assertEqual(b'a', node.exps[3].exp1.exp1.value.name.value)
self.assertEqual(b'..', node.exps[3].exp1.binop.value)
self.assertEqual(b'b', node.exps[3].exp1.exp2.value.name.value)
self.assertEqual(b'^', node.exps[3].binop.value)
self.assertTrue(node.exps[3].exp2.value.matches(lexer.TokNumber(b'7')))
self.assertEqual(b'foo', node.exps[4].value.name.value)
def testNegatedNumber(self):
lxr = lexer.Lexer(version=4)
lxr._process_line(b'-1.234567890e-6\n')
self.assertEqual(3, len(lxr._tokens))
self.assertEqual(lexer.TokSymbol(b'-'),
lxr._tokens[0])
self.assertEqual(lexer.TokNumber(b'1.234567890e-6'),
lxr._tokens[1])
def testExpUnOpMinus(self):
p = get_parser('-45')
node = p._exp()
self.assertIsNotNone(node)
self.assertTrue(isinstance(node, parser.ExpUnOp))
self.assertEqual('-', node.unop.value)
self.assertTrue(isinstance(node.exp, parser.ExpValue))
self.assertTrue(node.exp.value.matches(lexer.TokNumber('45')))
def testTableConstructorTrailingSep(self):
p = get_parser(b'{5,}')
node = p._tableconstructor()
self.assertIsNotNone(node)
self.assertEqual(4, p._pos)
self.assertEqual(1, len(node.fields))
self.assertTrue(node.fields[0].exp.value.matches(
lexer.TokNumber(b'5')))
def testFieldNamedKey(self):
p = get_parser('foo = 3')
node = p._field()
self.assertIsNotNone(node)
self.assertEqual(5, p._pos)
self.assertTrue(isinstance(node, parser.FieldNamedKey))
self.assertEqual('foo', node.key_name.value)
self.assertTrue(node.exp.value.matches(lexer.TokNumber('3')))
def testTableConstructor(self):
p = get_parser('{[1]=2,foo=3;4}')
node = p._tableconstructor()
self.assertIsNotNone(node)
self.assertEqual(13, p._pos)
self.assertTrue(isinstance(node, parser.TableConstructor))
self.assertEqual(3, len(node.fields))
self.assertTrue(isinstance(node.fields[0], parser.FieldExpKey))
self.assertTrue(node.fields[0].key_exp.value.matches(
lexer.TokNumber('1')))
self.assertTrue(node.fields[0].exp.value.matches(lexer.TokNumber('2')))
self.assertTrue(isinstance(node.fields[1], parser.FieldNamedKey))
self.assertEqual('foo', node.fields[1].key_name.value)
self.assertTrue(node.fields[1].exp.value.matches(lexer.TokNumber('3')))
self.assertTrue(isinstance(node.fields[2], parser.FieldExp))
self.assertTrue(node.fields[2].exp.value.matches(lexer.TokNumber('4')))
def testVarList(self):
p = get_parser('foo, bar[7], baz.bat')
node = p._varlist()
self.assertIsNotNone(node)
self.assertEqual(12, p._pos)
self.assertEqual(3, len(node.vars))
self.assertEqual('foo', node.vars[0].name.value)
self.assertEqual('bar', node.vars[1].exp_prefix.name.value)
self.assertTrue(node.vars[1].exp_index.value.matches(
lexer.TokNumber('7')))
self.assertEqual('baz', node.vars[2].exp_prefix.name.value)
self.assertEqual('bat', node.vars[2].attr_name.value)
def testPrefixExpChain(self):
p = get_parser('(1+2)[foo].bar.baz')
node = p._prefixexp()
self.assertIsNotNone(node)
self.assertEqual(12, p._pos)
self.assertTrue(isinstance(node, parser.VarAttribute))
self.assertEqual('baz', node.attr_name.value)
self.assertTrue(isinstance(node.exp_prefix, parser.VarAttribute))
self.assertEqual('bar', node.exp_prefix.attr_name.value)
self.assertTrue(isinstance(node.exp_prefix.exp_prefix,
parser.VarIndex))
self.assertEqual('foo',
node.exp_prefix.exp_prefix.exp_index.value.name.value)
self.assertTrue(
isinstance(node.exp_prefix.exp_prefix.exp_prefix, parser.ExpBinOp))
self.assertTrue(
node.exp_prefix.exp_prefix.exp_prefix.exp1.value.matches(
lexer.TokNumber('1')))
self.assertEqual('+',
node.exp_prefix.exp_prefix.exp_prefix.binop.value)
self.assertTrue(
node.exp_prefix.exp_prefix.exp_prefix.exp2.value.matches(
lexer.TokNumber('2')))
def testNumberInteger(self):
lxr = lexer.Lexer(version=4)
lxr._process_line(b'1234567890\n')
self.assertEqual(2, len(lxr._tokens))
self.assertEqual(lexer.TokNumber(b'1234567890'),
lxr._tokens[0])
def testNumberDecimalNoRightPart(self):
lxr = lexer.Lexer(version=4)
lxr._process_line(b'1.\n')
self.assertEqual(2, len(lxr._tokens))
self.assertEqual(lexer.TokNumber(b'1.'),
lxr._tokens[0])
def testNumberDecimalWithExp(self):
lxr = lexer.Lexer(version=4)
lxr._process_line(b'1.234567890e-6\n')
self.assertEqual(2, len(lxr._tokens))
self.assertEqual(lexer.TokNumber(b'1.234567890e-6'),
lxr._tokens[0])
def testExpValueNumber(self):
p = get_parser('123.45')
node = p._exp()
self.assertIsNotNone(node)
self.assertTrue(isinstance(node, parser.ExpValue))
self.assertTrue(node.value.matches(lexer.TokNumber('123.45')))
def testNumberBinaryWithFrac(self):
lxr = lexer.Lexer(version=4)
lxr._process_line(b'0b01101101.0011\n')
self.assertEqual(2, len(lxr._tokens))
self.assertEqual(lexer.TokNumber(b'0b01101101.0011'), lxr._tokens[0])
def testNumberHexWithFrac(self):
lxr = lexer.Lexer(version=4)
lxr._process_line(b'0x1234567890abcdef.1bbf\n')
self.assertEqual(2, len(lxr._tokens))
self.assertEqual(lexer.TokNumber(b'0x1234567890abcdef.1bbf'),
lxr._tokens[0])
