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