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