/*
 * 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