test.lx

fun Test(name, assertion) {
    print name + " => " + assertion();
}

fun assertEq(a, b) {
    fun inner() {
        return a == b;
    }
    return inner;
}
fun bool(a) {
    if(a) {
        return true;
    }
    return false;
}
fun assertTrue(a) {
    return assertEq(bool(a), true);
}

var arithmetic = 1 + 2 - 3 * 4;
Test("Basic arithmetic", assertEq(arithmetic, -9));

var conditionExpected;
if ("string is true") {
    conditionExpected = true;
}
Test("Basic condition", assertEq(conditionExpected, true));

var global = "global";
{
    var local = "local";
    Test("Access global from scope", assertEq(global, "global"));
    Test("Access local from scope", assertEq(local, "local"));
}

var whileCounter = 1;
while (whileCounter < 5) {whileCounter = whileCounter + 1;}
Test("While loop", assertEq(whileCounter, 5));

var forCounter;
for (forCounter = 0; forCounter < 3; forCounter = forCounter + 1 ) { true;}
Test("For loop", assertEq(forCounter, 3));

Test("Native function", assertTrue(clock()));

var closureSetter;
var closureFirst;
var closureSecond;
fun PoorClass() {
    var first_ = "first";
    var second_ = "second";

    fun set(param) { second_ = param; }
    fun first() {return first_;}
    fun second() {return second_;}
    fun get() {
        print first;
        print second;
        print third;
    }

    closureSetter = set;
    closureFirst = first;
    closureSecond = second;
}
PoorClass();
Test("PoorClass: before update", assertEq(closureSecond(), "second"));
closureSetter("third");
Test("PoorClass: after update", assertEq(closureSecond(), "third"));
Test("PoorClass: static getter ", assertEq(closureFirst(), "first"));


class TestClass {
  testMethod() { return "testMethod"; }
  setField(value) { this.field = value; }
  getField() { return this.field; }
} 

var TestInstance = TestClass();
TestInstance.testField = "testValue";
Test("Set class property", assertEq(TestInstance.testField, "testValue"));
Test("Call class method", assertEq(TestInstance.testMethod(), "testMethod"));
TestInstance.setField("setField");
Test("Class this", assertEq(TestInstance.getField(), "setField"));

class Initialized {
    init(value) {
        this.field = value;
    }
}
Test("Class initializer", assertEq(Initialized("value").field, "value"));

class FieldInvoke {
    init() {
        fun f() {
            return "invoke";
        }
        this.field = f;
    }
}
var fi = FieldInvoke();
Test("Class Field handling method", assertEq(fi.field(), "invoke"));

class ChainCall {
    init() {

        class Inner {
            init() {
                this.inner = "inner";
            }
        }

        this.outer = Inner();
    }
}
var chain = ChainCall();
Test("Class chain call", assertEq(chain.outer.inner, "inner"));

class Parent {
    parent() {
        return "parent";
    }
}

class Child < Parent {
    child() {
        return super.parent();
    }
}
Test("Class inheritance", assertEq(Child().child(), "parent"));