discombobulator 1.0.0

package/src/test/difference.mjs

@@ -0,0 +1,492 @@
+// difference.mjs
+//
+// Tests for difference.mjs.
+
+import { expect, expectException } from "./testing.mjs";
+
+import { Instruments } from "../instrument.mjs";
+import { Set } from "../set.mjs";
+import { InstrumentSet } from "../instrumentset.mjs";
+
+export const test = {
+  tests: [
+    {
+      title: "default constructor results in correct set",
+      test: () => {
+        const set1 = new InstrumentSet();
+        const set2 = new InstrumentSet();
+
+        let operator = new Set.Difference(set1, set2);
+
+        expect(operator.isAbstract, true);
+        expect(operator.allowDuplicates, false);
+      },
+    },
+
+    {
+      title: "add element fails because difference is an immutable set",
+      test: () => {
+        const set1 = new InstrumentSet();
+        const set2 = new InstrumentSet();
+
+        let operator = new Set.Difference(set1, set2);
+
+        expectException(() => {
+          operator.add(Instruments.Snare);
+        }, Error);
+      },
+    },
+
+    {
+      title: "iterator yields nothing for an empty set",
+      test: () => {
+        const set1 = new InstrumentSet({ add: Instruments.Snare });
+        const set2 = new InstrumentSet({ add: Instruments.Snare });
+
+        const operator = new Set.Difference(set1, set2);
+
+        let count = 0;
+
+        for (const e of operator) { ++count; }
+
+        expect(count, 0);
+      },
+    },
+    {
+      title: "iterator yields correct results for a non-empty set",
+      test: () => {
+        const instruments = [
+          Instruments.Snare,
+          Instruments.Crash,
+          Instruments.Claves,
+          Instruments.Bass1,
+        ];
+        const set1 = new InstrumentSet({
+          add: instruments,
+        });
+        const set2 = new InstrumentSet({
+          add: [Instruments.Snare, Instruments.Bass1],
+        });
+
+        const operator = new Set.Difference(set1, set2);
+        let count = 0;
+
+        for (const e of operator) {
+          expect(e, (result) => { return result === instruments[1+count++]; });
+        }
+
+        expect(count, 2);
+      },
+    },
+
+    {
+      title: "size returns correct size with no different elements",
+      test: () => {
+        const set1 = new InstrumentSet({ add: Instruments.Snare });
+        const set2 = new InstrumentSet({ add: Instruments.Snare });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 0, true);
+      },
+    },
+    {
+      title: "size returns correct size with a single different element",
+      test: () => {
+        const set1 = new InstrumentSet({
+          add: [Instruments.Snare, Instruments.Bass1],
+        });
+        const set2 = new InstrumentSet({ add: Instruments.Snare });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 1, true);
+      },
+    },
+    {
+      title: "size returns correct size with multiple different elements",
+      test: () => {
+        const set1 = new InstrumentSet({
+          add: [
+            Instruments.Snare,
+            Instruments.Crash,
+            Instruments.Claves,
+            Instruments.Bass1,
+          ],
+        });
+        const set2 = new InstrumentSet({
+          add: [Instruments.Snare, Instruments.Bass1],
+        });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 2, true);
+      },
+    },
+
+    {
+      title: "has fails when empty",
+      test: () => {
+        const set1 = new InstrumentSet({ add: Instruments.Snare });
+        const set2 = new InstrumentSet({ add: Instruments.Snare });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 0, true);
+        expect(operator.has(Instruments.Snare), false);
+      },
+    },
+    {
+      title: "has succeeds for element that is in difference",
+      test: () => {
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Bass1 ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 1, true);
+        expect(operator.has(Instruments.Snare), true);
+      },
+    },
+    {
+      title: "has fails for element that is not in difference",
+      test: () => {
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Bass1 ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 1, true);
+        expect(operator.has(Instruments.Bass1), false);
+      },
+    },
+    {
+      title: "has succeeds for set that is in difference",
+      test: () => {
+        let subset = new InstrumentSet({ add: [ Instruments.Bass1, Instruments.Snare ]});
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 2, true);
+        expect(operator.has(subset), true);
+      },
+    },
+    {
+      title: "has fails for other set that is not in difference",
+      test: () => {
+        let subset = new InstrumentSet({ add: [ Instruments.Claves, Instruments.Crash ]});
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 2, true);
+        expect(operator.has(subset), false);
+      },
+    },
+
+    {
+      title: "indexOf throws error for undefined element",
+      test: () => {
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 2, true);
+        expectException(() => { operator.indexOf(); }, Error);
+      },
+    },
+    {
+      title: "indexOf throws error for argument not derived from Element",
+      test: () => {
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 2, true);
+        expectException(() => { operator.indexOf(new Error()); }, Error);
+      },
+    },
+    {
+      title: "indexOf fails to find non-existant element",
+      test: () => {
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 2, true);
+        expect(operator.indexOf(Instruments.Claves), -1);
+      },
+    },
+    {
+      title: "indexOf fails for empty set",
+      test: () => {
+        let set1 = new InstrumentSet({ add: [ Instruments.Claves, Instruments.Crash ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 0, true);
+        expect(operator.indexOf(Instruments.Bass1), -1);
+      },
+    },
+    {
+      title: "indexOf succeeds for element in the set",
+      test: () => {
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 2, true);
+        expect(operator.indexOf(Instruments.Snare), 0);
+        expect(operator.indexOf(Instruments.Bass1), 1);
+      },
+    },
+    {
+      title: "indexOf fails for element in the set prior to after",
+      test: () => {
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 2, true);
+        expect(operator.indexOf(Instruments.Snare, 0), -1);
+      },
+    },
+    {
+      title: "indexOf succeeds for element in the set later than after",
+      test: () => {
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 2, true);
+        expect(operator.indexOf(Instruments.Bass1, 0), 1);
+      },
+    },
+    {
+      title: "indexOf fails if after >= size-1",
+      test: () => {
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 2, true);
+        expect(operator.indexOf(Instruments.Bass1, 1), -1);
+        expect(operator.indexOf(Instruments.Bass1, 2), -1);
+        expect(operator.indexOf(Instruments.Bass1, 3), -1);
+      },
+    },
+
+    {
+      title: "elementAt throws error for index < 0",
+      test: () => {
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 2, true);
+        expectException(() => { operator.elementAt(-1); }, Error);
+      },
+    },
+    {
+      title: "elementAt throws error for empty set",
+      test: () => {
+        let set1 = new InstrumentSet({ add: [ Instruments.Claves ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 0, true);
+        expectException(() => { operator.elementAt(0); }, Error);
+      },
+    },
+    {
+      title: "elementAt throws error for index >= set size",
+      test: () => {
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 2, true);
+        expectException(() => { operator.elementAt(2); }, Error);
+      },
+    },
+    {
+      title: "elementAt succeeds for element in valid index",
+      test: () => {
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 2, true);
+        expect(operator.elementAt(0), (result) => { return result === Instruments.Snare; });
+        expect(operator.elementAt(1), (result) => { return result === Instruments.Bass1; });
+      },
+    },
+
+    {
+      title: "clone succeeds a difference operator (Shallow)",
+      test: () => {
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 2, true);
+
+        const clone = operator.clone();
+
+        expect(clone.isAbstract, true);
+        expect(clone.allowDuplicates, false);
+        expect(clone.isStrict, true);
+        expect(clone.skipValidation, false);
+        expect(clone.elements[0] === set1, true);
+        expect(clone.elements[1] === set2, true);
+
+        let index = 0;
+
+        for (let e of operator) {
+          expect(e.isEqual(clone.elementAt(index++)), true);
+        }
+      },
+    },
+    {
+      title: "clone succeeds on a difference operator (Deep)",
+      test: () => {
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.size === 2, true);
+
+        const clone = operator.clone(true);
+
+        expect(clone.isAbstract, true);
+        expect(clone.allowDuplicates, false);
+        expect(clone.isStrict, true);
+        expect(clone.skipValidation, false);
+        expect(clone.elements[0] !== set1, true);
+        expect(clone.elements[1] !== set2, true);
+
+        let index = 0;
+
+        for (let e of operator) {
+          expect(e.isEqual(clone.elementAt(index++)), true);
+        }
+      },
+    },
+
+    {
+      title: "isDisjointFrom fails for difference set that is not disjoint from another set",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Crash ]});
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.isDisjointFrom(set), false);
+      },
+    },
+    {
+      title: "isDisjointFrom succeeds for difference set that is disjoint from another set",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Claves, Instruments.Crash ]});
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.isDisjointFrom(set), true);
+      },
+    },
+    {
+      title: "isDisjointFrom fails for a set that is not disjoint from a difference set",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Crash ]});
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(set.isDisjointFrom(operator), false);
+      },
+    },
+    {
+      title: "isDisjointFrom succeeds for a set that is disjoint from a difference set",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves ]});
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Crash, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(set.isDisjointFrom(operator), true);
+      },
+    },
+
+    {
+      title: "isSubsetOf fails for difference set that is not a subset of another set",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Crash ]});
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.isSubsetOf(set), false);
+      },
+    },
+    {
+      title: "isSubsetOf succeeds for difference set that is subset of another set",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Crash, Instruments.Bass1 ]});
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(operator.isSubsetOf(set), true);
+      },
+    },
+    {
+      title: "isSubsetOf fails for a set that is not a subset of a difference set",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Crash ]});
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(set.isSubsetOf(operator), false);
+      },
+    },
+    {
+      title: "isSubsetOf succeeds for a set that is a subset of a difference set",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Bass1, Instruments.Crash ]});
+        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Crash, Instruments.Bass1 ] });
+        let set2 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves ] });
+
+        const operator = new Set.Difference(set1, set2);
+
+        expect(set.isSubsetOf(operator), true);
+      },
+    },
+
+  ],
+};

package/src/test/element.mjs

@@ -0,0 +1,66 @@
+// element.mjs
+//
+// Tests for element.mjs.
+
+import { expect } from './testing.mjs'
+
+import { Element } from '../element.mjs'
+import { Instrument } from '../instrument.mjs'
+
+export const test = {
+  tests: [ 
+    {
+      title: "isEqual succeeds when comparing with self",
+      test: () => {
+        const element = new Element();
+
+        expect(element.isEqual(element), true);
+      },
+    },
+    {
+      title: "isEqual succeeds when comparing two different element instances",
+      test: () => {
+        const element = new Element();
+        const other = new Element();
+
+        expect(element.isEqual(other), true);
+      },
+    },
+    {
+      title: "isEqual fails when comparing against a different (element-derived) class",
+      test: () => {
+        const element = new Element();
+        const other = new Instrument();
+
+        expect(element.isEqual(other), false);
+      },
+    },
+    
+    {
+      title: "promote succeeds for self",
+      test: () => {
+        const element = new Element();
+
+        expect(element.promote(element), (result) => { return result === element; });
+      },
+    },
+    {
+      title: "promote succeeds for two different element instances",
+      test: () => {
+        const element = new Element();
+        const other = new Element();
+
+        expect(element.promote(other), (result) => { return result === other; });
+      },
+    },
+    {
+      title: "promote fails for different (element-derived) classes",
+      test: () => {
+        const element = new Element();
+        const other = new Instrument();
+
+        expect(element.promote(other), (result) => { return result === undefined; });
+      },
+    },
+  ],
+}

package/src/test/group.mjs

@@ -0,0 +1,79 @@
+// group.mjs
+//
+// Tests for group.mjs.
+
+import { expect, expectException } from './testing.mjs'
+
+import { Group } from '../group.mjs'
+import { Instrument } from '../instrument.mjs'
+
+export const test = {
+  tests: [ 
+    {
+      title: "default constructor results in Error exception",
+      test: () => {
+        expectException(() => { new Group(); }, Error);
+      },
+    },
+    {
+      title: "constructor throws Error when length < 1",
+      test: () => {
+        expectException(() => { new Group(0); }, Error);
+      },
+    },
+    {
+      title: `constructor throws Error when length > ${Group.MAX_LENGTH}`,
+      test: () => {
+        expectException(() => { new Group(Group.MAX_LENGTH); }, Error);
+      },
+    },
+    {
+      title: `constructor succeeds when length in [1..${Group.MAX_LENGTH}]`,
+      test: () => {
+        const lengths = [...Array(Group.MAX_LENGTH).keys()];
+
+        lengths.forEach((length) => {
+          const group = new Group(0, length + 1);
+
+          expect(group.length, length + 1);
+        });
+      },
+    },
+    
+    {
+      title: "isEqual succeeds when comparing with self",
+      test: () => {
+        const group = new Group(1, 1);
+
+        expect(group.isEqual(group), true);
+      },
+    },
+    {
+      title: "isEqual succeeds when comparing identical groups",
+      test: () => {
+        const group = new Group(1, 1);
+        const other = new Group(1, 1);
+
+        expect(group.isEqual(other), true);
+      },
+    },
+    {
+      title: "isEqual fails when comparing articulations with different symbols",
+      test: () => {
+        const group = new Group(1, 1);
+        const other = new Group(3, 2);
+
+        expect(group.isEqual(other), false);
+      },
+    },
+    {
+      title: "isEqual fails when comparing against a non-group class",
+      test: () => {
+        const group = new Group(1, 1);
+        const other = new Instrument();
+
+        expect(group.isEqual(other), false);
+      },
+    },
+  ],
+}

package/src/test/groupset.mjs

@@ -0,0 +1,43 @@
+// groupset.mjs
+//
+// Tests for groupset.mjs.
+
+import { expect, expectException } from './testing.mjs'
+
+import { GroupSet } from '../groupset.mjs'
+import { Note } from '../note.mjs'
+import { Group } from '../group.mjs'
+
+export const test = {
+  tests: [ 
+    {
+      title: "default constructor results in correct set",
+      test: () => {
+        let set = new GroupSet();
+
+        expect(set.isAbstract, false);
+        expect(set.allowDuplicates, false);
+        expect(set.size, 0);
+      },
+    },
+    {
+      title: "add throws error when adding non-group",
+      test: () => {
+        let set = new GroupSet();
+        let element = new Note();
+
+        expectException(() => { set.add(element); }, Error);
+      },
+    },
+    {
+      title: "add succeeds adding group",
+      test: () => {
+        let set = new GroupSet();
+        let element = new Group(1, 1);
+
+        expect(set.add(element), (result) => { return result === set; });
+      },
+    },
+
+  ],
+}