def testReadBody(self): ctx = Context.createFromMemory('class Hello') ctx.readLine() module = WppModule('test') result = module.readBody(ctx) self.assertIsNotNone(result) self.assertEqual(result.type, 'Class')
def testExport(self): inCtx = Context.createFromMemory(['']) txif = WppIf() txif.addItem(WppExpression.parse('first', inCtx)) txBody = txif.addItem(WppBody()) txRet = txBody.addItem(WppReturn()) txRet.addItem(WppExpression.parse('1', inCtx)) txif.addItem(WppExpression.parse('second', inCtx)) txBody = txif.addItem(WppBody()) txRet = txBody.addItem(WppReturn()) txRet.addItem(WppExpression.parse('2', inCtx)) txBody = txif.addItem(WppBody()) txRet = txBody.addItem(WppReturn()) txRet.addItem(WppExpression.parse('0', inCtx)) outCtx = OutContextMemoryStream() txif.export(outCtx) expected = """ if first return 1 elif second return 2 else return 0 """ self.assertEqual(str(outCtx), expected.strip())
def testParse(self): source = 'super(1)' ctx = Context.createFromMemory(source, 'parseSuper.wpp') expr = WppExpression.parse(source, ctx) self.assertEqual(expr.type, 'call') caller = expr.getCaller() self.assertEqual(caller.type, 'super')
def testConst(self): ctx = Context.createFromMemory('', 'fake') taxon = WppExpression.create('2019', ctx) self.assertEqual(taxon.type, 'Const') self.assertEqual(taxon.constType, 'int') self.assertEqual(taxon.value, '2019') self.assertEqual(taxon.exportString(), '2019') taxon = WppExpression.create('-3.14', ctx) self.assertEqual(taxon.constType, 'fixed') self.assertEqual(taxon.value, '-3.14') self.assertEqual(taxon.exportString(), '-3.14') taxon = WppExpression.create('1.111e-06', ctx) self.assertEqual(taxon.constType, 'float') self.assertEqual(taxon.exportString(), '1.111E-06') taxon = WppExpression.create('"Hello!"', ctx) self.assertEqual(taxon.constType, 'string') self.assertEqual(taxon.exportString(), '"Hello!"') taxon = WppExpression.create('"First\\nSecond"', ctx) self.assertEqual(taxon.constType, 'string') self.assertEqual(taxon.value, 'First\nSecond') self.assertEqual(taxon.exportString(), '"First\\nSecond"') with self.assertRaises(ErrorTaxon) as ex: taxon = WppExpression.create('"Not closed', ctx) with self.assertRaises(ErrorTaxon) as ex: taxon = WppExpression.create('"Invalid slash\\"', ctx)
def testLocalVar(self): source = """ func localVar var tmp: int = 222 var second: int = tmp + 1 """ core = WppCore() module = core.createRootModule(Context.createFromMemory(source, 'localVar.fake')) over = module.dictionary['localVar'] func = over.items[0] block = func.getBody() self.assertEqual(len(block.items), 2) cmd1 = block.items[0] self.assertEqual(cmd1.type, 'Var') outContext = OutContextMemory() cmd1.export(outContext) self.assertEqual(str(outContext), 'var tmp: int = 222') cmd2 = block.items[1] self.assertEqual(cmd2.type, 'Var') self.assertEqual(cmd2.name, 'second') val = cmd2.getValueTaxon() self.assertEqual(val.type, 'BinOp') varExpr = val.getLeft() self.assertEqual(varExpr.type, 'IdExpr') self.assertEqual(varExpr.id, 'tmp') self.assertEqual(varExpr.name, '') d1 = varExpr.getDeclaration() self.assertEqual(d1, cmd1)
def testFieldInClass(self): source = """ class public simple Point class public Rect field public a: Point # this is a field b: Point # this is b """ core = WppCore() module = core.createRootModule( Context.createFromMemory(source, 'First.memory')) classPoint = module.dictionary['Point'] classRect = module.dictionary['Rect'] self.assertIn('a', classRect.dictionary) self.assertIn('b', classRect.dictionary) a = classRect.dictionary['a'] self.assertEqual(a.type, 'Field') self.assertEqual(a.name, 'a') self.assertEqual(a.getLocalType().getTypeTaxon(), classPoint) self.assertEqual(a.getAccessLevel(), 'public') b = classRect.dictionary['b'] self.assertEqual(b.name, 'b') self.assertEqual(b.getAccessLevel(), 'private') outContext = OutContextMemory() b.export(outContext) self.assertEqual(str(outContext), 'field b: Point\n\t# this is b')
def testFuncWithParams(self): source = """ func func03: double # with params param in x: double = 0 param in y: double = -1 """ core = WppCore() module = core.createRootModule( Context.createFromMemory(source, 'func03.fake')) over = module.dictionary['func03'] func = over.items[0] params = func.getParams() self.assertEqual(len(params), 2) self.assertIn('x', func.dictionary) self.assertEqual(params[1].name, 'y') self.assertEqual(params[1].type, 'Param') outContext = OutContextMemory() params[0].export(outContext) self.assertEqual(str(outContext), 'param in x: double = 0') outContext = OutContextMemoryStream() module.export(outContext) self.assertEqual(str(outContext), source.strip())
def testStrings(self): ctx = Context.createFromMemory('', 'fake') res = parseExpr('"Abcd"', ctx) self.assertEqual(len(res), 2) self.assertEqual(res[0], ('Abcd', 'const', 'string')) self.assertEqual(res[1], ('end', 'cmd', None)) res = parseExpr('"First\\nSecond"', ctx) self.assertEqual(len(res), 2) self.assertEqual(res[0], ('First\nSecond', 'const', 'string')) res = parseExpr('"\\t\\\\"', ctx) self.assertEqual(len(res), 2) self.assertEqual(res[0], ('\t\\', 'const', 'string')) res = parseExpr('"D\\\'Artagnan"', ctx) self.assertEqual(len(res), 2) self.assertEqual(res[0], ('D\'Artagnan', 'const', 'string')) res = parseExpr('"Say: \\"Hello!\\""', ctx) self.assertEqual(len(res), 2) self.assertEqual(res[0], ('Say: "Hello!"', 'const', 'string')) # Invalid cases with self.assertRaises(ErrorTaxon) as ex: res = parseExpr('"Hello', ctx) self.assertEqual(ex.exception.args[0], 'String is not closed') with self.assertRaises(ErrorTaxon) as ex: res = parseExpr('"abc\\"', ctx) self.assertEqual(ex.exception.args[0], 'String is not closed') with self.assertRaises(ErrorTaxon) as ex: res = parseExpr('"\\Z"', ctx) self.assertEqual(ex.exception.args[0], 'Invalid escape char: Z')
def testReadHead(self): src = """ class First class simple abstract Second class """ ctx = Context.createFromMemory(src, 'testClass') ctx.readLine() # class First class1 = WppClass() class1.readHead(ctx) self.assertEqual(class1.type, 'Class') self.assertEqual(class1.name, 'First') fileName, n, line = class1.location self.assertEqual(fileName, 'testClass') self.assertEqual(n, 2) self.assertEqual(line, '\t\tclass First') ctx.readLine() # class simple abstract Second class2 = WppClass() class2.readHead(ctx) self.assertEqual(class2.name, 'Second') self.assertIn('simple', class2.attrs) self.assertIn('abstract', class2.attrs) ctx.readLine() # class class3 = WppClass() with self.assertRaises(ErrorTaxon) as ex: class3.readHead(ctx) msg = ex.exception.args[0] self.assertEqual(msg, 'Required class name') fileName, n, line = ex.exception.args[1] self.assertEqual(n, 4)
def testCvt(code): """ parse and convert to debud string """ ctx = Context.createFromMemory(code) lexems = parseLexems(code, ctx) lexems.append(('END', 'cmd')) node, pos = buildNodes(lexems, 0, {'END'}, ctx) return str(node)
def testExtends(self): source = """ class public A class public B extends A class public C extends B """ ctx = Context.createFromMemory(source, 'textExt.memory') core = WppCore() module = core.createRootModule(ctx) self.assertEqual(module.type, 'Module') self.assertEqual(module.name, 'textExt') self.assertIn('A', module.dictionary) self.assertIn('B', module.dictionary) self.assertIn('C', module.dictionary) a = module.dictionary['A'] b = module.dictionary['B'] c = module.dictionary['C'] self.assertEqual(b.getParent(), a) outCtx = OutContextMemory() b.export(outCtx) text = '\n'.join(outCtx.lines) self.assertEqual(text, 'class public B\n\textends A') outCtx = OutContextMemory() c.export(outCtx) text = '\n'.join(outCtx.lines) self.assertEqual(text, 'class public C\n\textends B')
def testIds(self): ctx = Context.createFromMemory('', 'fake') res = parseExpr('A Abc Size640x480', ctx) self.assertEqual(len(res), 4) self.assertEqual(res[0], ('A', 'id', None)) self.assertEqual(res[1], ('Abc', 'id', None)) self.assertEqual(res[2], ('Size640x480', 'id', None))
def testMethod(self): source = """ class A method static first method const second: int param a: A param x: double """ core = WppCore() module = core.createRootModule( Context.createFromMemory(source, 'A.memory')) a = module.dictionary['A'] self.assertIn('first', a.dictionary) over1 = a.dictionary['first'] self.assertEqual(over1.name, 'first') self.assertIn('static', over1.attrs) self.assertIn('second', a.dictionary) over2 = a.dictionary['second'] self.assertEqual(over2.name, 'second') self.assertEqual(over2.attrs, {'public'}) fn2 = over2.items[0] self.assertEqual(fn2.name, 'second') self.assertIn('const', fn2.attrs) self.assertIn('a', fn2.dictionary) self.assertIn('x', fn2.dictionary) paramA = fn2.getParams()[0] self.assertEqual(paramA.name, 'a') self.assertEqual(paramA.getLocalType().type, 'TypeName') self.assertEqual(paramA.getLocalType().getTypeTaxon(), a)
def testMinusChange(self): ctx = Context.createFromMemory('', 'fake') lexems = [('-', 'cmd', None), ('3.14', 'const', 'float'), ('end', 'cmd', None)] node, pos = scanLexems(lexems, 0, {'end'}, ctx) self.assertEqual(node.type, 'arg') self.assertEqual(node.value, '-3.14')
def testMinus(self): ctx = Context.createFromMemory('', 'fake') res = parseExpr('A-1', ctx) self.assertEqual(len(res), 4) self.assertEqual(res[0], ('A', 'id', None)) self.assertEqual(res[1], ('-', 'cmd', None)) self.assertEqual(res[2], ('1', 'const', 'int'))
def testSimpleName(self): context = Context.createFromMemory('unsigned int') taxon = WppTypeExpr.parse(context.readLine(), context) self.assertEqual(taxon.type, '@typeExprName') self.assertEqual(taxon.typeName, 'int') self.assertEqual(taxon.attrs, set(['unsigned']))
def testMap(self): ctx = Context.createFromMemory('', 'A.memory') source = 'const Map String, double' t = WppType.create(source, ctx) self.assertEqual(t.type, 'TypeMap') self.assertIn('const', t.attrs) self.assertEqual(t.getKeyType().type, 'TypeName') self.assertEqual(t.getValueType().type, 'TypeName')
def testArray(self): context = Context.createFromMemory('Array String') taxon = WppTypeExpr.parse(context.readLine(), context) self.assertEqual(taxon.type, '@typeExprArray') itemTaxon = taxon.getItemTaxon() self.assertEqual(itemTaxon.type, '@typeExprName') self.assertEqual(itemTaxon.typeName, 'String')
def init(self): content = """ field length: unsigned long """ ctx = Context.createFromMemory(content) readWpp(ctx, self) length = self.dictionary['length'] length.cloneScheme = 'Owner'
def testArrayIndex(self): ctx = Context.createFromMemory('', 'fake') lexems = [('vector', 'id', None), ('[', 'cmd', None), ('N', 'id', None), ('-', 'cmd', None), ('1', 'const', 'int'), (']', 'cmd', None), ('end', 'cmd', None)] node, pos = scanLexems(lexems, 0, {'end'}, ctx) self.assertEqual(node.type, 'index') self.assertEqual(node.export(), 'vector[N - 1]')
def testAttributes(self): core = WppCore() # Error - Incompatible attributes used ctx = Context.createFromMemory('class public private A', 'A.memory') with self.assertRaises(ErrorTaxon) as ex: module = core.createRootModule(ctx) ctx = Context.createFromMemory('class static abstract B', 'B.memory') with self.assertRaises(ErrorTaxon) as ex: module = core.createRootModule(ctx) ctx = Context.createFromMemory('class protected C', 'C.memory') with self.assertRaises(ErrorTaxon) as ex: module = core.createRootModule(ctx) ctx = Context.createFromMemory('class static D', 'D.memory') module = core.createRootModule(ctx) self.assertIn('D', module.dictionary) d = module.dictionary['D'] # Квалификатор доступа должен автоматически установиться в public self.assertEqual(d.getAccessLevel(), 'public')
def testArrayIndexDouble(self): """ 2D Array access - table[i][j] """ ctx = Context.createFromMemory('', 'fake') lexems = [('table', 'id', None), ('[', 'cmd', None), ('i', 'id', None), (']', 'cmd', None), ('[', 'cmd', None), ('j', 'id', None), (']', 'cmd', None), ('end', 'cmd', None)] node, pos = scanLexems(lexems, 0, {'end'}, ctx) self.assertEqual(node.type, 'index') self.assertEqual(node.export(), 'table[i][j]')
def init(self): content = """ field length: unsigned long cloneScheme Owner method push cloneScheme Owner param item: const ref @Item """ ctx = Context.createFromMemory(content) readWpp(ctx, self)
def testWrongLocalVar(self): source = """ func localVar var tmp: int = 222 var second: int = tmp1 + 1 """ core = WppCore() with self.assertRaises(ErrorTaxon) as ex: module = core.createRootModule(Context.createFromMemory(source, 'localVar.fake')) self.assertEqual(ex.exception.args[0], 'Name "tmp1" is not defined')
def testOffsetError(self): lines = """ module A class B """ context = Context.createFromMemory(lines, 'main') core = Core() with self.assertRaises(ErrorTaxon) as cm: readWpp(context, core) self.assertEqual(cm.exception.args[0], 'Invalid offset')
def init(self): content = """ field length: unsigned long method push param item: Array.TItem method pop: Array.TItem """ titem = self.addNamedItem(ArrayItemType(name='TItem')) titem.attrs.add('public') ctx = Context.createFromMemory(content) readWpp(ctx, self)
def testTernaryOp(self): ctx = Context.createFromMemory('', 'fake') # a == -1 ? str(n + 42) : "Hello!" lexems = [('a', 'id', None), ('==', 'cmd', None), ('-', 'cmd', None), ('1', 'const', 'int'), ('?', 'cmd', None), ('str', 'id', None), ('(', 'cmd', None), ('n', 'id', None), ('+', 'cmd', None), ('42', 'const', 'int'), (')', 'cmd', None), (':', 'cmd', None), ('Hello!', 'const', 'string'), ('end', 'cmd', None)] node, pos = scanLexems(lexems, 0, {'end'}, ctx) self.assertEqual(node.export(), 'a == -1 ? str(n + 42) : "Hello!"')
def testCommands(self): ctx = Context.createFromMemory('', 'fake') res = parseExpr('( && )\t*[/] <=', ctx) self.assertEqual(len(res), 9) self.assertEqual(res[0], ('(', 'cmd', None)) self.assertEqual(res[1], ('&&', 'cmd', None)) self.assertEqual(res[2], (')', 'cmd', None)) self.assertEqual(res[3], ('*', 'cmd', None)) self.assertEqual(res[4], ('[', 'cmd', None)) self.assertEqual(res[5], ('/', 'cmd', None)) self.assertEqual(res[6], (']', 'cmd', None)) self.assertEqual(res[7], ('<=', 'cmd', None))
def testInvalidLexems(self): ctx = Context.createFromMemory('', 'fake') # (x lexems = [('(', 'const', None), ('x', 'id', None), ('end', 'cmd', None)] with self.assertRaises(ErrorTaxon) as ex: node, pos = scanLexems(lexems, 0, {'end'}, ctx) # 22) lexems = [('22', 'const', 'int'), (')', 'cmd', None), ('end', 'cmd', None)] with self.assertRaises(ErrorTaxon) as ex: node, pos = scanLexems(lexems, 0, {'end'}, ctx) self.assertEqual(ex.exception.args[0], 'Invalid binary operation ")"')
def testInitValue(self): source = """ class A field counter: int = -1 """ core = WppCore() module = core.createRootModule( Context.createFromMemory(source, 'First.memory')) classA = module.dictionary['A'] counter = classA.dictionary['counter'] self.assertEqual(counter.getLocalType().exportString(), 'int') v = counter.getValueTaxon() self.assertIsNotNone(v) self.assertEqual(v.exportString(), '-1')