tests.dlg

# Language feature tests

assertEqual: fn a, b {
    if a == b, {print "Passed".}
    else {error "Failed".}.
}

assertEqual(1, 1)

testFunctions: fn anonymous, defined, called, called_anonymous {
    anonymous().
    defined().
    print called.
    print called_anonymous.
}

testFunctionsWithArgs: fn anonymous, defined, called, called_anonymous {
    anonymous(1).
    defined(1).
    print called.
    print called_anonymous.
}


_definedFunction: fn {print "Passed".}
testFunctions(fn {print "Passed".}, _definedFunction, _definedFunction(), fn {print "Passed".}())

# also testing calling with square brackets
_definedFunctionWithArgs: fn a {print a.}
testFunctionsWithArgs(fn a {print a.}, _definedFunctionWithArgs, _definedFunctionWithArgs(1), fn a {print a.}(1))

# testing order of operations and arithmetic
testOrderOfOps: fn {
    assertEqual(2, 1 + 1).
    assertEqual(2, 1 + 2 - 1).
    assertEqual(3, 1 + 2 - 1 + 1).
    assertEqual(8, 1 + 2 * 4 - 1).
    assertEqual(7, 1 + 2 * (4 - 1)).
    assertEqual(5.5, 1.0 + (2.0 + 3.0 * -(1.0/2.0)) + 2.0 * (1.0 * 2.0)).
    assertEqual(3.0, 1.0 + 2.0 * (5.0 - 1.0) / 2.0 ^ 2.0).
    assertEqual(-0.25, 3.0 ^ 2.0 / 2.0 ^ 2.0 - 3.0 + 2.0/4.0 %3.0).
}

testOrderOfOps()

testIfStatements: fn {
    if 1 == 1, {print "Passed".}
    else {error "Failed".}.
    if 1 == 2, {error "Failed".}
    else {print "Passed".}.
    if true && 2 == 2, {print "Passed".}
    else {error "Failed".}.
    if 1 == 1 || 2 == 3, {print "Passed".}
    else {error "Failed".}.
    if 1 == 3, {error "Failed".}
    elif 2 == 2, {print "Passed".}
    else {error "Failed".}.
    if 1 == 1 && 2 == 3, {error "Failed".}
    elif 2 == 3, {error "Failed".}
    else {print "Passed".}.
}

testIfStatements()

testLoops: fn {
    i: 0.
    while i < 10, {i: i + 1.}.
    assertEqual(10, i).
    i: 0.
    while i < 7, {i: i + 1. if i == 5, {i: 10.}.}.
    assertEqual(10, i).
    i: 0.
    for i < 10, {}, i: i + 3.
    assertEqual(12, i).
}

testLoops()

testFunctionScope: fn {
    x: 1.
    y: 2.
    f: fn x {assertEqual(x + y, 3).}.
    f2: fn x {x: 7. y: 3. assertEqual(x + y, 10).}.
    f(1).
    f2(1).
    assertEqual(x, 1).
    assertEqual(y, 2).
}

testFunctionScope()

# testFunctionDoubleCall: fn {
#     # TODO once we have function returns
#     x: 1.
#     f: fn x {x: x + 1.}.
#     f(1)().
# }

# testFunctionDoubleCall()

testBooleans: fn {
    assertEqual(true, true).
    assertEqual(false, false).
    assertEqual(true, 1 == 1).
    assertEqual(false, 1 == 2).
    x: false.
    x |= true.
    assertEqual(true, x).
    x: false.
    x |= false.
    assertEqual(false, x).
    x: false.
    x |= true.
    assertEqual(true, x).
    x: false.
    x &= true.
    assertEqual(false, x).
    x: true.
    x &= false.
    assertEqual(false, x).
    x: true.
    x &= true.
    assertEqual(true, x).
    x: true.
    assertEqual(true, x != false).
    assertEqual(false, x != true).
}

testBooleans()

testTypes: fn {
    assertEqual("integer", typeof 1).
    assertEqual("string", typeof "string").
    assertEqual("boolean", typeof true).
    assertEqual("function", typeof fn {print "Passed".}).
    assertEqual("1", 1 as "string").
    assertEqual(1.0, 1.0 as "float").
    assertEqual(true, 1 as "boolean").
    assertEqual("string", "string" as "string").
    assertEqual(true, "string" as "boolean").
    assertEqual("true", true as "string").
    assertEqual(true, true as "boolean").
    assertEqual(1, true as "integer").
}

testTypes()

testCoreLib: fn {
    assertEqual(3, pi).
}

testCoreLib()

import "testImport.dlg".
testImports: fn {
    assertEqual(3, importTest).
}

testImports()

testArray: fn {
    assertEqual(1, 1 @ [1, 2, 3] @ [0, 7, 1]). 
    assertEqual(2, 2 @ [0, 1, 2]).
    x: [1, 2, 3, "string"].
    x push 4.
    assertEqual(4, 4 @ x).
}

testArray()