You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
248 lines
3.6 KiB
248 lines
3.6 KiB
/*
|
|
* Unit tests
|
|
*/
|
|
|
|
test_call = fn () {
|
|
ret = fn(){[1,fn(){[4,5,6]},3]}()[1]()[1]
|
|
assert(ret == 5)
|
|
}
|
|
|
|
test_return = fn () {
|
|
f = fn (x) {
|
|
if x % 2 {
|
|
return 'odd'
|
|
}
|
|
'even'
|
|
}
|
|
assert(f(3) == 'odd')
|
|
assert(f(4) == 'even')
|
|
|
|
mut val = 0
|
|
f2 = fn () {
|
|
val = 1
|
|
return // comment
|
|
val = 2
|
|
}
|
|
f2()
|
|
assert(val == 1)
|
|
}
|
|
|
|
test_nil = fn () {
|
|
assert(nil == nil)
|
|
assert(!(nil != nil))
|
|
|
|
a = nil
|
|
assert(a == nil)
|
|
assert(!(a != nil))
|
|
assert(!(a <= nil))
|
|
assert(!(a < nil))
|
|
assert(!(a >= nil))
|
|
assert(!(a > nil))
|
|
assert(nil == a)
|
|
assert(!(nil != a))
|
|
assert(!(nil <= a))
|
|
assert(!(nil < a))
|
|
assert(!(nil >= a))
|
|
assert(!(nil > a))
|
|
}
|
|
|
|
test_closure = fn () {
|
|
make_func = fn (mut x) {
|
|
mut n = 100
|
|
fn () {
|
|
n = n + 1
|
|
x = x + 1 + n
|
|
}
|
|
}
|
|
|
|
f = make_func(10)
|
|
f()
|
|
f()
|
|
ret = f()
|
|
|
|
assert(ret == 319)
|
|
}
|
|
|
|
test_array = fn () {
|
|
a = [1,2,3]
|
|
assert(a.size() == 3)
|
|
|
|
a.push(4)
|
|
assert(a.size() == 4)
|
|
|
|
b = []
|
|
assert(b.size() == 0)
|
|
|
|
c = [1]
|
|
assert(c.size() == 1)
|
|
|
|
d = [1,2,3](5, 0)
|
|
assert(d.size() == 5 && d[-1] == 0)
|
|
|
|
e = [1,2,3](2)
|
|
assert(e.size() == 3 && e[-1] == 3)
|
|
|
|
f = [1,2,3](5)
|
|
assert(f.size() == 5 && f[-1] == nil)
|
|
}
|
|
|
|
g_ = 1
|
|
|
|
test_function = fn () {
|
|
a = 1
|
|
make = fn () {
|
|
b = 1
|
|
fn (c) {
|
|
g_ + a + b + c
|
|
}
|
|
}
|
|
f = make()
|
|
assert(f(1) == 4)
|
|
}
|
|
|
|
test_object = fn () {
|
|
n = 1
|
|
o = {
|
|
n: 123,
|
|
s: 'str',
|
|
f1: fn (x) { x + this.n },
|
|
f2: fn (x) { x + n }
|
|
}
|
|
assert(o.size() == 4)
|
|
assert(o.f1(10) == 133)
|
|
assert(o.f2(10) == 11)
|
|
|
|
a = {}
|
|
a.b = 1
|
|
assert(a.a == nil)
|
|
assert(a.b == 1)
|
|
assert(a.size() == 1)
|
|
}
|
|
|
|
test_object_factory = fn () {
|
|
ctor = fn (init) {
|
|
mut n = init
|
|
|
|
{
|
|
add: fn (x) {
|
|
n = n + x
|
|
},
|
|
sub: fn (x) {
|
|
n = n - x
|
|
},
|
|
val: fn () {
|
|
n
|
|
}
|
|
}
|
|
}
|
|
|
|
calc = ctor(10)
|
|
|
|
assert(calc.val() == 10)
|
|
assert(calc.add(1) == 11)
|
|
assert(calc.sub(1) == 10)
|
|
}
|
|
|
|
test_class = fn () {
|
|
// TODO: support 'prototype' property
|
|
Car = {
|
|
new: fn(miles_per_run) {
|
|
mut total_miles = 0
|
|
|
|
{
|
|
run: fn (times) {
|
|
total_miles = total_miles + miles_per_run * times
|
|
},
|
|
total: fn () {
|
|
total_miles
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
car = Car.new(5)
|
|
car.run(1)
|
|
car.run(2)
|
|
|
|
assert(car.total() == 15)
|
|
}
|
|
|
|
test_sum = fn () {
|
|
mut i = 1
|
|
mut ret = 0
|
|
while i <= 10 {
|
|
ret = ret + i
|
|
i = i + 1
|
|
}
|
|
|
|
assert(ret == 55)
|
|
}
|
|
|
|
test_fib = fn () {
|
|
fib = fn (x) {
|
|
if x < 2 {
|
|
x
|
|
} else {
|
|
self(x - 2) + self(x -1)
|
|
}
|
|
}
|
|
|
|
ret = fib(15)
|
|
|
|
assert(ret == 610)
|
|
}
|
|
|
|
test_interpolated_string = fn () {
|
|
hello = "Hello"
|
|
world = "World!"
|
|
ret = "{hello} {world}"
|
|
assert(ret == 'Hello World!')
|
|
}
|
|
|
|
test_lexical_scope = fn () {
|
|
a = 0
|
|
{
|
|
let a = 1;
|
|
assert(a == 1)
|
|
}
|
|
assert(a == 0)
|
|
|
|
mut b = 0
|
|
{
|
|
b = 1;
|
|
assert(b == 1)
|
|
}
|
|
assert(b == 1)
|
|
|
|
c = 0
|
|
{
|
|
let mut c = 0;
|
|
c = 1
|
|
assert(c == 1)
|
|
}
|
|
assert(c == 0)
|
|
|
|
obj = {
|
|
name: 'object'
|
|
}
|
|
|
|
assert(obj.name == 'object')
|
|
}
|
|
|
|
debugger
|
|
test_call()
|
|
test_return()
|
|
test_closure()
|
|
test_nil()
|
|
test_array()
|
|
test_function()
|
|
test_object()
|
|
test_object_factory()
|
|
test_class()
|
|
debugger
|
|
test_sum()
|
|
test_fib()
|
|
test_interpolated_string()
|
|
test_lexical_scope()
|
|
|
|
return // end
|
|
|