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 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 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 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 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 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 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 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 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 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 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 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 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))
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 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 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 testReadonly(self): source = """ class public Atom readonly mass: double constructor param init mass func public main var H: Atom = Atom(1.008) var O: Atom = Atom(15.999) var waterMass: double = H.mass * 2 + O.mass """ expected = """ class Atom: __slots__ = ('_mass') @property def mass(self): return self._mass def __init__(self, mass): self._mass = mass def main(): H = Atom(1.008) O = Atom(15.999) waterMass = H.mass * 2 + O.mass """ srcModule = WppCore.createMemModule(source, 'readonly.fake') dstModule = srcModule.cloneRoot(PyCore()) classAtom = dstModule.dictionary['Atom'] self.assertEqual(classAtom.type, 'Class') conOver = classAtom.findConstructor() self.assertEqual(conOver.type, 'Overloads') con = conOver.items[0] self.assertEqual(con.type, 'Constructor') cmd = con.getBody().items[0] self.assertEqual(cmd.type, 'BinOp') self.assertEqual(cmd.opCode, '=') pt = cmd.getLeft() self.assertEqual(pt.type, 'BinOp') self.assertEqual(pt.opCode, '.') field = pt.getRight() self.assertEqual(field.type, 'FieldExpr') self.assertIsNotNone(field.findOwner('Constructor')) outContext = OutContextMemoryStream() dstModule.export(outContext) self.assertEqual(str(outContext), WppCore.strPack(expected))
def testVarExternal(self): """ Variable - member of module """ source = """ var hidden: bool var public visible: double = 1.5 """ expected = """ let hidden: boolean; export let visible: number = 1.5; """ srcModule = WppCore.createMemModule(source, 'var.fake') dstModule = srcModule.cloneRoot(TsCore()) outContext = OutContextMemoryStream() dstModule.export(outContext) self.assertEqual(str(outContext), WppCore.strPack(expected))
def testTranslation(self): source = """ func public And: bool param a: bool param b: bool a && b """ expected = """ def And(a, b): return a and b """ srcModule = WppCore.createMemModule(source, 'unary.fake') dstModule = srcModule.cloneRoot(PyCore()) outStream = OutContextMemoryStream() dstModule.export(outStream) self.assertEqual(str(outStream), WppCore.strPack(expected))
def testMath(self): source = """ func public main var const a: double = Math.sin(Math.PI * 0.3) var const b: double = Math.min(a, 1) """ expected = """ export function main() { const a: number = Math.sin(Math.PI * 0.3); const b: number = Math.min(a, 1); } """ srcModule = WppCore.createMemModule(source, 'math.fake') dstModule = srcModule.cloneRoot(TsCore()) outContext = OutContextMemoryStream() dstModule.export(outContext) self.assertEqual(str(outContext), WppCore.strPack(expected))
def testMethod(self): source = """ class Norm method mul: double param coeff: double coeff * 10.0 """ expected = """ class Norm: def mul(self, coeff): return coeff * 10.0 """ srcModule = WppCore.createMemModule(source, 'method.fake') dstModule = srcModule.cloneRoot(PyCore()) outContext = OutContextMemoryStream() dstModule.export(outContext) self.assertEqual(str(outContext).strip(), WppCore.strPack(expected))
def testNew(self): source = """ class public Uno func public createUno: Uno Uno() """ expected = """ class Uno: pass def createUno(): return Uno() """ srcModule = WppCore.createMemModule(source, 'new.fake') dstModule = srcModule.cloneRoot(PyCore()) outStream = OutContextMemoryStream() dstModule.export(outStream) self.assertEqual(str(outStream), WppCore.strPack(expected))
def testAngles(self): source = """ func public main var const deg: double = Math.degrees(Math.PI / 2) var const rad: double = Math.radians(270) var const rad2: double = Math.radians(deg + 15) """ expected = """ export function main() { const deg: number = Math.PI / 2 * 57.29577951308232; const rad: number = 4.71238898038469; const rad2: number = (deg + 15) * 0.017453292519943295; } """ srcModule = WppCore.createMemModule(source, 'angles.fake') dstModule = srcModule.cloneRoot(TsCore()) outContext = OutContextMemoryStream() dstModule.export(outContext) self.assertEqual(str(outContext), WppCore.strPack(expected))
def testField(self): source = """ class Hello field count: unsigned long field public value: String = "Hello!" field public static inst: Hello """ expected = """ export class Hello { private count: number; public value: string = 'Hello!'; public static inst: Hello; } """ srcModule = WppCore.createMemModule(source, 'var.fake') dstModule = srcModule.cloneRoot(TsCore()) outContext = OutContextMemoryStream() dstModule.export(outContext) self.assertEqual(str(outContext), WppCore.strPack(expected))
def testFields(self): source = """ class public Parent class public Test field public first: Parent field private second: Parent field public x: int = 1 field public y: int """ srcModule = WppCore.createMemModule(source, 'fields.fake') dstModule = srcModule.cloneRoot(PyCore()) classTest = dstModule.dictionary['Test'] first = classTest.dictionary['first'] self.assertTrue(first.canBeStatic) conOver = classTest.findConstructor() self.assertEqual(conOver.type, 'Overloads') con = conOver.items[0] self.assertEqual(con.type, 'Constructor') cmd2 = con.getBody().items[1] self.assertEqual(cmd2.type, 'BinOp') self.assertEqual(cmd2.opCode, '=') pt = cmd2.getLeft() self.assertEqual(pt.type, 'BinOp') self.assertEqual(pt.opCode, '.') field = pt.getRight() self.assertEqual(field.type, 'FieldExpr') self.assertEqual(field.id, 'second') expected = """ class Parent: pass class Test: __slots__ = ('first', '__second', 'x', 'y') def __init__(self): self.first = None self.__second = None self.x = 1 self.y = 0 """ outContext = OutContextMemoryStream() dstModule.export(outContext) self.assertEqual(str(outContext).strip(), WppCore.strPack(expected))
def testStaticFields(self): source = """ class public A class public B field static public ok: A field static hidden: A """ srcModule = WppCore.createMemModule(source, 'staticFields.fake') dstModule = srcModule.cloneRoot(PyCore()) expected = """ class A: pass class B: ok = None __hidden = None """ outContext = OutContextMemoryStream() dstModule.export(outContext) self.assertEqual(str(outContext).strip(), WppCore.strPack(expected))