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')
