// Creating and reading
var a = [1, 2, 3];
assert(len(a) == 3);
assert(a[0] == 1 && a[2] == 3);
assert(len([]) == 0);
var nested = [[1, 2], [3, [4, 5]]];
assert(nested[1][1][0] == 4);
assert(len(nested[1]) == 2);

// Writing, assigning at the end appends
a[1] = 20;
assert(a[1] == 20);
a[3] = 4;
assert(len(a) == 4 && a[3] == 4);

// push, pop, shift, unshift return and remove as expected
var q = [];
assert(push(q, "a") == 1);
assert(push(q, "b") == 2);
assert(unshift(q, "z") == 3);
assert(q[0] == "z" && q[1] == "a" && q[2] == "b");
assert(pop(q) == "b");
assert(shift(q) == "z");
assert(len(q) == 1 && q[0] == "a");
assert(pop(q) == "a");
assert(isundefined(pop(q)));
assert(isundefined(shift(q)));
assert(len(q) == 0);

// insert, insertarr, splice
var b = [1, 2, 5];
assert(insert(b, 2, 3) == 4);
assert(deepequal(b, [1, 2, 3, 5]));
insert(b, 3, 4);
assert(deepequal(b, [1, 2, 3, 4, 5]));
insert(b, 0, 0);
assert(deepequal(b, [0, 1, 2, 3, 4, 5]));
insert(b, 6, 6);
assert(deepequal(b, [0, 1, 2, 3, 4, 5, 6]));
var c = [1, 4];
assert(insertarr(c, 1, [2, 3]) == 4);
assert(deepequal(c, [1, 2, 3, 4]));
var d = [1, 2, 3, 4, 5];
var removed = splice(d, 1, 2);
assert(deepequal(removed, [2, 3]));
assert(deepequal(d, [1, 4, 5]));
removed = splice(d, 2);
assert(deepequal(removed, [5]));
assert(deepequal(d, [1, 4]));
removed = splice(d, 0, 100);
assert(deepequal(removed, [1, 4]));
assert(len(d) == 0);
removed = splice(d, 0, 0);
assert(len(removed) == 0);

// subarr copies a range
var e = [10, 20, 30, 40];
assert(deepequal(subarr(e, 1, 3), [20, 30]));
assert(deepequal(subarr(e, 2), [30, 40]));
assert(deepequal(subarr(e, 0, 0), []));
assert(deepequal(subarr(e, 4), []));
var slice = subarr(e, 0, 2);
slice[0] = 99;
assert(e[0] == 10);

// indexof, lastindexof
var f = [1, 2, 3, 2, 1];
assert(indexof(f, 2) == 1);
assert(lastindexof(f, 2) == 3);
assert(indexof(f, 9) == -1);
assert(lastindexof(f, 9) == -1);
assert(indexof(["a", "b"], "b") == 1);
assert(indexof([null, 1], null) == 0);

// reverse and sort
var g = [1, 2, 3, 4];
reverse(g);
assert(deepequal(g, [4, 3, 2, 1]));
var odd = [1, 2, 3];
reverse(odd);
assert(deepequal(odd, [3, 2, 1]));
reverse([]);
var h = [3, 1, 2, 10, -5, 2.5];
sort(h);
assert(deepequal(h, [-5, 1, 2, 2.5, 3, 10]));
sort(h, true);
assert(deepequal(h, [10, 3, 2.5, 2, 1, -5]));
var words = ["banana", "Apple", "cherry", "apple"];
sort(words);
assert(words[0] == "Apple" || words[0] == "apple");
assert(words[3] == "cherry");
assert(words[2] == "banana");
var byLength = ["ccc", "a", "bb"];
sort(byLength, false, function(x, y) { return len(x) - len(y); });
assert(deepequal(byLength, ["a", "bb", "ccc"]));
var one = [7];
sort(one);
assert(one[0] == 7);
var emptySort = [];
sort(emptySort);
// sort is stable: equal keys keep their order
var records = [{k: 1, n: "a"}, {k: 0, n: "b"}, {k: 1, n: "c"}, {k: 0, n: "d"}];
sort(records, false, function(x, y) { return x.k - y.k; });
assert(records[0].n == "b" && records[1].n == "d" && records[2].n == "a" && records[3].n == "c");
// a long sort
var big = [];
for(var i = 0; i < 100; i++) push(big, (i * 37) % 101);
sort(big);
var ordered = true;
for(var j = 1; j < len(big); j++) {
  if(big[j - 1] > big[j]) ordered = false;
}
assert(ordered);

// fill, merge, empty
var filled = [];
fill(filled, 7, 3);
assert(deepequal(filled, [7, 7, 7]));
fill(filled, "x", 1);
assert(deepequal(filled, ["x"]));
fill(filled, 0, 0);
assert(len(filled) == 0);
var m1 = [1, 2];
assert(merge(m1, [3, 4]) == 4);
assert(deepequal(m1, [1, 2, 3, 4]));
merge(m1, []);
assert(len(m1) == 4);
merge(m1, m1);
assert(len(m1) == 8);
var toEmpty = [1, 2, 3];
empty(toEmpty);
assert(len(toEmpty) == 0);
push(toEmpty, "fresh");
assert(toEmpty[0] == "fresh");

// filter, map, reduce
var nums = [1, 2, 3, 4, 5, 6];
var evens = clone(nums);
filter(evens, function(v) { return v % 2 == 0; });
assert(deepequal(evens, [2, 4, 6]));
assert(len(nums) == 6);
var withNulls = [1, null, 2, null];
filter(withNulls);
assert(deepequal(withNulls, [1, 2]));
var indexes = clone(nums);
filter(indexes, function(v, idx) { return idx < 2; });
assert(deepequal(indexes, [1, 2]));
assert(deepequal(map(nums, function(v) { return v * 10; }), [10, 20, 30, 40, 50, 60]));
assert(deepequal(map(nums, function(v, idx) { return idx; }), [0, 1, 2, 3, 4, 5]));
assert(len(map([], function(v) { return v; })) == 0);
assert(reduce(nums, function(acc, v) { return acc + v; }, 0) == 21);
assert(reduce(nums, function(acc, v) { return acc * v; }, 1) == 720);
assert(reduce([], function(acc, v) { return acc + v; }, "start") == "start");
assert(reduce(["a", "b"], function(acc, v) { return acc + v; }, "") == "ab");

// flatten and join
assert(deepequal(flatten([[1], [2, 3], []]), [1, 2, 3]));
assert(len(flatten([])) == 0);
assert(deepequal(flatten([[[1]], [2]]), [[1], 2]));
assert(join([1, 2, 3], ", ") == "1, 2, 3");

// Arrays are shared, clone is shallow, deepclone is not
var original = [1, [2, 3]];
var alias = original;
alias[0] = 100;
assert(original[0] == 100);
var shallow = clone(original);
shallow[0] = 5;
assert(original[0] == 100);
shallow[1][0] = 22;
assert(original[1][0] == 22);
var deep = deepclone(original);
deep[1][0] = 33;
assert(original[1][0] == 22);
assert(deep[1][0] == 33);
assert(deepequal(deepclone(original), original));
assert(clone(original) != original);

// deepequal
assert(deepequal([], []));
assert(deepequal([1, "a", [true, null]], [1, "a", [true, null]]));
assert(!deepequal([1, 2], [1, 3]));
assert(!deepequal([1, 2], [1, 2, 3]));
assert(!deepequal([1], ["1"]));
assert(deepequal(1, 1));
assert(!deepequal(1, 2));
assert(deepequal({a: 1, b: [1]}, {b: [1], a: 1}));
assert(!deepequal({a: 1}, {a: 2}));
assert(!deepequal({a: 1}, {b: 1}));
assert(!deepequal([], {}));

// Growing past the first capacity
var grown = [];
for(var n = 0; n < 200; n++) push(grown, n);
assert(len(grown) == 200);
assert(grown[0] == 0 && grown[199] == 199 && grown[100] == 100);
var shrunk = 0;
while(len(grown) > 0) {
  pop(grown);
  shrunk++;
}
assert(shrunk == 200);

// Many shifts
var queue = [];
for(var k = 0; k < 50; k++) push(queue, k);
var taken = 0;
while(len(queue) > 0) {
  assert(shift(queue) == taken);
  taken++;
}
assert(taken == 50);

// Looping while modifying a copy
var source = [1, 2, 3];
var copy = clone(source);
foreach(var item : source) push(copy, item * 2);
assert(deepequal(copy, [1, 2, 3, 2, 4, 6]));