Tests for Array<string> and Array<Shared<T>> under every model

tests/array_class_shared.ts

@@ -0,0 +1,60 @@
+// The Array<T> class (not T[]) of Shared<T> handles: the way to keep objects in an Array<T> under
+// -mm=own. A walk over the handles counts each one it reads, so it frees nothing the array holds,
+// and a callback is given a count of its own for the call.
+
+class Item {
+    constructor(public name: string) {
+    }
+
+    get toStringTag(): string {
+        return "Item";
+    }
+
+    toString() {
+        return this.name;
+    }
+}
+
+function item(name: string) {
+    return new Shared<Item>(new Item(name));
+}
+
+function names(a: Array<Shared<Item>>) {
+    let s = "";
+    for (const v of a) s += v.value.name;
+    return s;
+}
+
+function main() {
+    const a = new Array<Shared<Item>>();
+    a.push(item("a"), item("bb"), item("ccc"));
+    assert(a.length == 3 && names(a) == "abbccc");
+    assert(a.at(1).value.name == "bb");
+
+    assert(a.every((v) => v.value.name.length > 0));
+    assert(a.some((v) => v.value.name == "bb"));
+    assert(a.find((v) => v.value.name.length == 3).value.name == "ccc");
+    assert(a.findIndex((v) => v.value.name == "bb") == 1);
+    assert(a.filter((v) => v.value.name.length > 1).length == 2);
+
+    let longer = "";
+    for (const v of a.filter2((v) => v.value.name.length > 1)) longer += v.value.name;
+    assert(longer == "bbccc");
+
+    let each = "";
+    a.forEach((v) => {
+        each += v.value.name;
+    });
+    assert(each == "abbccc");
+
+    const removed = a.splice(1, 1, item("x"), item("y"));
+    assert(removed.length == 1 && removed[0].value.name == "bb");
+    assert(names(a) == "axyccc");
+
+    a.unshift(item("p"));
+    const first = a.shift();
+    assert(first.value.name == "p" && names(a) == "axyccc");
+    assert(a.pop().value.name == "ccc" && names(a) == "axy");
+
+    console.log("ALL DONE");
+}

tests/array_class_string.ts

@@ -0,0 +1,55 @@
+// The Array<T> class (not T[]) of strings: every method that walks, copies or fills the elements.
+// Under -mm=own a string is copied where it is stored again, so `fill` gives each element its own.
+
+function main() {
+    const a = new Array<string>();
+    assert(a.push("a", "bb", "ccc") == 3);
+    assert(a.join("-") == "a-bb-ccc");
+    assert(a.at(1) == "bb" && a.get(2) == "ccc");
+
+    a.set(0, "x");
+    assert(a.toString() == "x,bb,ccc");
+
+    assert(a.every((v) => v.length > 0));
+    assert(a.some((v) => v == "bb"));
+    assert(a.find((v) => v.length == 3) == "ccc");
+    assert(a.findIndex((v) => v == "bb") == 1);
+    assert(a.findLast((v) => v.length < 3) == "bb");
+    assert(a.findLastIndex((v) => v.length > 5) == -1);
+    assert(a.includes("ccc") && a.indexOf("bb") == 1 && a.lastIndexOf("x") == 0);
+
+    assert(a.filter((v) => v.length > 1).join() == "bb,ccc");
+    let longer = "";
+    for (const v of a.filter2((v) => v.length > 1)) longer += v;
+    assert(longer == "bbccc");
+
+    assert(a.map<string>((v) => v + "!").join() == "x!,bb!,ccc!");
+    assert(a.reduce<string>((s, v) => s + v, "") == "xbbccc");
+
+    let each = "";
+    a.forEach((v) => {
+        each += v;
+    });
+    assert(each == "xbbccc");
+
+    let walked = "";
+    for (const v of a) walked += v;
+    assert(walked == "xbbccc");
+
+    assert(a.slice(1).join() == "bb,ccc");
+    assert(a.concat(["d"]).join() == "x,bb,ccc,d");
+    assert(a.toReversed().join() == "ccc,bb,x");
+    assert(a.toSorted().join() == "bb,ccc,x");
+
+    const filled = a.fill("z", 1);
+    assert(filled.join() == "x,z,z");
+
+    assert(a.pop() == "ccc" && a.shift() == "x" && a.length == 1);
+    a.unshift("p", "q");
+    assert(a.join() == "p,q,bb");
+
+    const removed = a.splice(1, 1, "r", "s");
+    assert(removed.join() == "q" && a.join() == "p,r,s,bb");
+
+    console.log("ALL DONE");
+}