def testArrayReplace(self): source = """ class public A typedef replace Collection: Array String class public B typedef Coll: A.Collection field public a: Coll method init param c: Coll a = c """ expected = """ export class A { } export class B { public a: string[]; public init(c: string[]) { this.a = c; } } """ srcModule = WppCore.createMemModule(source, 'simple.fake') dstModule = srcModule.cloneRoot(TsCore()) outContext = OutContextMemoryStream() dstModule.export(outContext) self.assertEqual(str(outContext), WppCore.strPack(expected))
def testInClass(self): source = """ class public Point typedef replace Value: double field public x: Value class public Rect typedef replace Value: Point.Value field public x1: Value """ expected = """ export class Point { public x: number; } export class Rect { public x1: number; } """ srcModule = WppCore.createMemModule(source, 'simple.fake') dstModule = srcModule.cloneRoot(TsCore()) Rect = dstModule.dictionary['Rect'] Value = Rect.dictionary['Value'] self.assertEqual(Value.type, 'Typedef') locType = Value.getTypeTaxon() self.assertEqual(locType.type, 'TypePath') outContext = OutContextMemoryStream() dstModule.export(outContext) self.assertEqual(str(outContext), WppCore.strPack(expected))
def testUnary(self): source = """ class public Unary field public first: int field public second: int method public init param value: int first = -value * -10 second = -first method public cloneNeg param src: Unary first = -src.first + 1 second = -(src.second + 1) """ expected0 = '' expected = """ class Unary: __slots__ = ('first', 'second') def __init__(self): self.first = 0 self.second = 0 def init(self, value): self.first = -value * -10 self.second = -self.first def cloneNeg(self, src): self.first = -src.first + 1 self.second = -(src.second + 1) """ srcModule = WppCore.createMemModule(source, 'unary.fake') dstModule = srcModule.cloneRoot(PyCore()) outStream = OutContextMemoryStream() dstModule.export(outStream) self.assertEqual(str(outStream), WppCore.strPack(expected))
def testParent(self): source = """ class public A class public B # Class B extends A """ expected = """ class A: pass class B(A): \"\"\" Class B \"\"\" pass """ srcModule = WppCore.createMemModule(source, 'ext.fake') pyCore = PyCore() dstModule = srcModule.clone(pyCore) dstModule.updateRefs() classA = dstModule.dictionary['A'] classB = dstModule.dictionary['B'] self.assertEqual(classB.type, 'Class') self.assertTrue(classB.canBeStatic) self.assertEqual(classB.name, 'B') self.assertEqual(classB.core, pyCore) self.assertEqual(classB.getParent(), classA) outContext = OutContextMemoryStream() dstModule.export(outContext) self.assertEqual(str(outContext).strip(), WppCore.strPack(expected))
def testFunc(self): source = """ func public func1 altName first return func public func2: int altName second param a: int return a """ module = WppCore.createMemModule(source, 'func.wpp') func1 = module.findItem('func1') self.assertEqual(func1.type, 'func') self.assertEqual(func1.getName(), 'func1') self.assertEqual(TaxonAltName.getAltName(func1), 'first') func2 = module.findItem('func2') self.assertEqual(func2.type, 'func') self.assertEqual(func2.getName(), 'func2') self.assertEqual(TaxonAltName.getAltName(func2), 'second') ctx = OutContextMemoryStream() module.export(ctx) self.assertEqual(str(ctx), WppCore.strPack(source))
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 testSuper(self): source = """ class public A field public index: int constructor public param init index class public B extends A field public mass: double constructor public param index: int param init mass super(index) """ srcModule = WppCore.createMemModule(source, 'binOp.fake') dstModule = srcModule.cloneRoot(PyCore()) outStream = OutContextMemoryStream() dstModule.export(outStream) expected = """ class A: __slots__ = ('index') def __init__(self, index): self.index = index class B(A): __slots__ = ('mass') def __init__(self, index, mass): super().__init__(index) self.mass = mass """ self.assertEqual(str(outStream), WppCore.strPack(expected))
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 testStatic(self): source = """ class static MyMath field public Pi: double = 3.1415926 method abs: double param x: double x < 0 ? -x : x func public main var const x: double = MyMath.abs(MyMath.Pi * 123) """ expected = """ class MyMath { public static Pi: number = 3.1415926; public static abs(x: number): number { return x < 0 ? -x : x; } } export function main() { const x: number = MyMath.abs(MyMath.Pi * 123); } """ srcModule = WppCore.createMemModule(source, 'static.fake') dstModule = srcModule.cloneRoot(TsCore()) outContext = OutContextMemoryStream() dstModule.export(outContext) self.assertEqual(str(outContext), WppCore.strPack(expected))
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 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 testOverloads(self): self.maxDiff = None source = """ class Point field public x: double field public y: double constructor param init x param init y class public Rect field public A: Point field public B: Point constructor altname fromNums param x1: double param y1: double param x2: double param y2: double A = Point(x1, y1) B = Point(x2, y2) constructor altname fromPoints param init A param init B func public main var const r1: Rect = Rect(10, 10, 60, 40) var const r2: Rect = Rect(Point(10, 10), Point(60, 40)) """ expected = '' srcModule = WppCore.createMemModule(source, 'over.fake') dstModule = srcModule.cloneRoot(TsCore()) outContext = OutContextMemoryStream() dstModule.export(outContext) self.assertEqual(str(outContext), WppCore.strPack(expected))
def testCast(self): source = """ class A field name: String constructor param init name cast const: String name func public main var const a: A = A("Hello!") var const s: String = String(a) """ expected = """ class A { private name: string; public constructor(name: string) { this.name = name; } public toString(): string { return this.name; } } export function main() { const a: A = new A('Hello!'); const s: string = String(a); } """ srcModule = WppCore.createMemModule(source, 'simple.fake') dstModule = srcModule.cloneRoot(TsCore()) outContext = OutContextMemoryStream() dstModule.export(outContext) self.assertEqual(str(outContext), WppCore.strPack(expected))
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 testExtern(self): source = """ class public A typedef extern Collection: Array String class public B typedef Coll: A.Collection field a: Coll method init param c: Coll a = c """ expected = """ export type ACollection = string[]; export class A { } export class B { private a: ACollection; public init(c: ACollection) { this.a = c; } } """ srcModule = WppCore.createMemModule(source, 'sextern.fake') dstModule = srcModule.cloneRoot(TsCore()) outContext = OutContextMemoryStream() dstModule.export(outContext) self.assertEqual(str(outContext), WppCore.strPack(expected))
def testSimple(self): source = """ func public funcIf: double param cond: bool param positive: double param negative: double if cond return positive return negative var const good: double = funcIf(true, 1.1, 3.3) var const bad: double = funcIf(false, -1, -100) """ module = WppCore.createMemModule(source, 'simpleCall.wpp') good = module.findItem('good') self.assertEqual(good.type, 'var') goodVal = good.getValueTaxon() self.assertEqual(goodVal.type, 'call') goodCallQT = goodVal.buildQuasiType() self.assertEqual(goodCallQT.type, 'scalar') self.assertEqual(goodCallQT.taxon.name, 'double') outCtx = OutContextMemoryStream() module.export(outCtx) self.assertEqual(str(outCtx), WppCore.strPack(source))
def testInvalidType(self): source = """ var valueF: float = 1.11 var public valueL: long = valueF """ with self.assertRaises(ErrorTaxon) as cm: WppCore.createMemModule(source, 'root.fake') self.assertEqual(cm.exception.args[0], 'Cannot convert from "valueF:float" to "long"')
def testBase(self): source = """ class Point field x: double field y: double constructor param init x param init y operator +=: ref Point param pt: const ref Point x += pt.x y += pt.y this operator const +: Point param pt: const ref Point Point(x + pt.x, y + pt.y) operator const right *: Point param k: double Point(k * x, k * y) operator const -: Point Point(-x, -y) """ expected = """ export class Point { private x: number; private y: number; public constructor(x: number, y: number) { this.x = x; this.y = y; } public iadd(pt: Point): Point { this.x += pt.x; this.y += pt.y; return this; } public add(pt: Point): Point { return new Point(this.x + pt.x, this.y + pt.y); } public rmul(k: number): Point { return new Point(k * this.x, k * this.y); } public neg(): Point { return new Point(-this.x, -this.y); } } """ srcModule = WppCore.createMemModule(source, 'simple.fake') dstModule = srcModule.cloneRoot(TsCore()) outContext = OutContextMemoryStream() dstModule.export(outContext) self.assertEqual(str(outContext), WppCore.strPack(expected))
def testSimple(self): source = """ typedef TSize: unsigned long """ expected = 'export type TSize = number;' srcModule = WppCore.createMemModule(source, 'simple.fake') dstModule = srcModule.cloneRoot(TsCore()) outContext = OutContextMemoryStream() dstModule.export(outContext) self.assertEqual(str(outContext), WppCore.strPack(expected))
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 testPI(self): source = """var a : double = Math.PI * 0.75""" expected = """ import math a = math.pi * 0.75 """ srcModule = WppCore.createMemModule(source, 'pi.fake') dstModule = srcModule.cloneRoot(PyCore()) outContext = OutContextMemoryStream() dstModule.export(outContext) self.assertEqual(str(outContext), WppCore.strPack(expected))
def testArrayValue(self): source = """ var const myList: Array String = ["First", "Second", "Third"] """ expected = """ export const myList: string[] = ['First', 'Second', 'Third']; """ srcModule = WppCore.createMemModule(source, 'arrayValue.fake') dstModule = srcModule.cloneRoot(TsCore()) outContext = OutContextMemoryStream() dstModule.export(outContext) self.assertEqual(str(outContext), WppCore.strPack(expected))
def testConst(self): source = """ var public curYear: int = 2019 """ srcModule = WppCore.createMemModule(source, 'const.fake') dstModule = srcModule.cloneRoot(PyCore()) outStream = OutContextMemoryStream() dstModule.export(outStream) expected = """ curYear = 2019 """ self.assertEqual(str(outStream), WppCore.strPack(expected))
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')
def testAbs(self): source = """ func public testAbs: double param x: double Math.abs(x - 10) """ expected = """ def testAbs(x): return abs(x - 10) """ srcModule = WppCore.createMemModule(source, 'abs.fake') dstModule = srcModule.cloneRoot(PyCore()) outContext = OutContextMemoryStream() dstModule.export(outContext) self.assertEqual(str(outContext), WppCore.strPack(expected))
def testTernary(self): source = """ func public isGood: int param value: double value < 1.0 ? 0 : 1 """ expected = """ def isGood(value): return 0 if value < 1.0 else 1 """ srcModule = WppCore.createMemModule(source, 'ternary.fake') dstModule = srcModule.cloneRoot(PyCore()) outStream = OutContextMemoryStream() dstModule.export(outStream) self.assertEqual(str(outStream), WppCore.strPack(expected))
def testTypeName(self): source = """class public A""" core = WppCore() ctx = Context.createFromMemory(source, 'A.memory') module = core.createRootModule(ctx) classA = module.dictionary['A'] self.assertEqual(classA.type, 'Class') # Создать таксон типа из строкового описания. Со ссылкой на класс внутри модуля typeTaxon = WppType.create('const ref A', ctx) self.assertEqual(typeTaxon.type, 'TypeName') # Хотя это бессмысленно, но добавить тип в модуль.Чтобы в процессе update была найдена ссылка на класс A module.addItem(typeTaxon) typeTaxon.fullUpdate() declA = typeTaxon.getTypeTaxon() self.assertEqual(classA, declA)
def testComments(self): source = """ class public MyClass # This is comment """ core = WppCore() module = core.createRootModule( Context.createFromMemory(source, 'MyClass.memory')) myClass = module.dictionary['MyClass'] self.assertEqual(myClass.getComment(), ' This is comment') outCtx = OutContextMemory() myClass.export(outCtx) self.assertEqual(str(outCtx), 'class public MyClass\n\t# This is comment')
def testBinOp(self): source = """ var first: double = 2.2 var public second: double = (first + 1.1) / 3.3 """ srcModule = WppCore.createMemModule(source, 'binOp.fake') dstModule = srcModule.cloneRoot(PyCore()) outStream = OutContextMemoryStream() dstModule.export(outStream) expected = """ __first = 2.2 second = (__first + 1.1) / 3.3 """ self.assertEqual(str(outStream), WppCore.strPack(expected))
def testDefaultParam(self): source = """ func public funcIf: double param cond: bool param positive: double = 1 param negative: double = -1 if cond return positive return negative var result: double = funcIf(true) """ module = WppCore.createMemModule(source, 'defaultParam.wpp') outCtx = OutContextMemoryStream() module.export(outCtx) self.assertEqual(str(outCtx), WppCore.strPack(source))