discombobulator 1.0.0 → 1.0.2

package/src/test/instrument.mjs

@@ -1,66 +0,0 @@
-// instrument.mjs
-//
-// Tests for instrument.mjs.
-
-import { expect } from './testing.mjs'
-
-import { Element } from '../element.mjs'
-import { Instrument } from '../instrument.mjs'
-
-export const test = {
-  tests: [ 
-    {
-      title: "default constructor results in undefined symbol",
-      test: () => {
-        const instrument = new Instrument();
-
-        expect(instrument.symbol, undefined);
-      },
-    },
-    {
-      title: "constructor correctly initialises valid symbol",
-      test: () => {
-        const instrument = new Instrument("test");
-        const symbol = Symbol.for("test");
-
-        expect(instrument.symbol, (result) => { return result === symbol; });
-      },
-    },
-    
-    {
-      title: "isEqual succeeds when comparing with self",
-      test: () => {
-        const instrument = new Instrument("test");
-
-        expect(instrument.isEqual(instrument), true);
-      },
-    },
-    {
-      title: "isEqual succeeds when comparing instruments with the same symbol",
-      test: () => {
-        const instrument = new Instrument("test");
-        const other = new Instrument("test");
-
-        expect(instrument.isEqual(other), true);
-      },
-    },
-    {
-      title: "isEqual fails when comparing instruments with different symbols",
-      test: () => {
-        const instrument = new Instrument("test");
-        const other = new Instrument("other");
-
-        expect(instrument.isEqual(other), false);
-      },
-    },
-    {
-      title: "isEqual fails when comparing against a non-instrument class",
-      test: () => {
-        const instrument = new Instrument();
-        const other = new Element();
-
-        expect(instrument.isEqual(other), false);
-      },
-    },
-  ],
-}

package/src/test/instrumentset.mjs

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

package/src/test/intersection.mjs

@@ -1,493 +0,0 @@
-// intersection.mjs
-//
-// Tests for intersection.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.Intersection(set1, set2);
-
-        expect(operator.isAbstract, true);
-        expect(operator.allowDuplicates, false);
-        expect(operator.isStrict, true);
-      },
-    },
-
-    {
-      title: "add element fails because intersection is an immutable set",
-      test: () => {
-        const set1 = new InstrumentSet();
-        const set2 = new InstrumentSet();
-
-        let operator = new Set.Intersection(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.Bass1 });
-
-        const operator = new Set.Intersection(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.Crash,
-          Instruments.Snare,
-          Instruments.Bass1,
-          Instruments.Claves,
-        ];
-        const set1 = new InstrumentSet({
-          add: instruments,
-        });
-        const set2 = new InstrumentSet({
-          add: [Instruments.Snare, Instruments.Bass1],
-        });
-
-        const operator = new Set.Intersection(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 intersection elements",
-      test: () => {
-        const set1 = new InstrumentSet({ add: Instruments.Snare });
-        const set2 = new InstrumentSet({ add: Instruments.Bass1 });
-
-        const operator = new Set.Intersection(set1, set2);
-
-        expect(operator.size === 0, true);
-      },
-    },
-    {
-      title: "size returns correct size with a single intersection element",
-      test: () => {
-        const set1 = new InstrumentSet({
-          add: [Instruments.Snare, Instruments.Bass1],
-        });
-        const set2 = new InstrumentSet({ add: Instruments.Snare });
-
-        const operator = new Set.Intersection(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.Intersection(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.Bass1 });
-
-        const operator = new Set.Intersection(set1, set2);
-
-        expect(operator.size === 0, true);
-        expect(operator.has(Instruments.Snare), false);
-      },
-    },
-    {
-      title: "has succeeds for element that is in intersection",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Bass1 ] });
-
-        const operator = new Set.Intersection(set1, set2);
-
-        expect(operator.size === 1, true);
-        expect(operator.has(Instruments.Bass1), true);
-      },
-    },
-    {
-      title: "has fails for element that is not in intersection",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Bass1 ] });
-
-        const operator = new Set.Intersection(set1, set2);
-
-        expect(operator.size === 1, true);
-        expect(operator.has(Instruments.Snare), false);
-      },
-    },
-    {
-      title: "has succeeds for set that is in intersection",
-      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.Bass1, Instruments.Crash, Instruments.Snare ] });
-
-        const operator = new Set.Intersection(set1, set2);
-
-        expect(operator.size === 2, true);
-        expect(operator.has(subset), true);
-      },
-    },
-    {
-      title: "has fails for other set that is not in intersection",
-      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.Bass1, Instruments.Crash, Instruments.Snare ] });
-
-        const operator = new Set.Intersection(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.Intersection(set1, set2);
-
-        expect(operator.size === 1, 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.Intersection(set1, set2);
-
-        expect(operator.size === 1, 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.Bass1, Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.Intersection(set1, set2);
-
-        expect(operator.size === 2, true);
-        expect(operator.indexOf(Instruments.Crash), -1);
-      },
-    },
-    {
-      title: "indexOf fails for empty set",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.Intersection(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, Instruments.Snare ] });
-
-        const operator = new Set.Intersection(set1, set2);
-
-        expect(operator.size === 2, true);
-        expect(operator.indexOf(Instruments.Snare), 0);
-        expect(operator.indexOf(Instruments.Claves), 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.Snare, Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.Intersection(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.Snare, Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.Intersection(set1, set2);
-
-        expect(operator.size === 2, true);
-        expect(operator.indexOf(Instruments.Claves, 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.Snare, Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.Intersection(set1, set2);
-
-        expect(operator.size === 2, true);
-        expect(operator.indexOf(Instruments.Claves, 1), -1);
-        expect(operator.indexOf(Instruments.Claves, 2), -1);
-        expect(operator.indexOf(Instruments.Claves, 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.Intersection(set1, set2);
-
-        expect(operator.size === 1, true);
-        expectException(() => { operator.elementAt(-1); }, Error);
-      },
-    },
-    {
-      title: "elementAt throws error for empty set",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.Intersection(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.Bass1, Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.Intersection(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.Bass1, Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.Intersection(set1, set2);
-
-        expect(operator.size === 2, true);
-        expect(operator.elementAt(0), (result) => { return result === Instruments.Claves; });
-        expect(operator.elementAt(1), (result) => { return result === Instruments.Bass1; });
-      },
-    },
-
-    {
-      title: "clone succeeds on an intersection operator (Shallow)",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Bass1, Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.Intersection(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 an intersection operator (Deep)",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Bass1, Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.Intersection(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 intersection 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.Intersection(set1, set2);
-
-        expect(operator.isDisjointFrom(set), false);
-      },
-    },
-    {
-      title: "isDisjointFrom succeeds for intersection 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.Snare, Instruments.Bass1 ] });
-
-        const operator = new Set.Intersection(set1, set2);
-
-        expect(operator.isDisjointFrom(set), true);
-      },
-    },
-    {
-      title: "isDisjointFrom fails for a set that is not disjoint from a intersection 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.Intersection(set1, set2);
-
-        expect(set.isDisjointFrom(operator), false);
-      },
-    },
-    {
-      title: "isDisjointFrom succeeds for a set that is disjoint from a intersection 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.Bass1, Instruments.Crash ] });
-
-        const operator = new Set.Intersection(set1, set2);
-
-        expect(set.isDisjointFrom(operator), true);
-      },
-    },
-
-    {
-      title: "isSubsetOf fails for intersection 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, Instruments.Bass1 ] });
-
-        const operator = new Set.Intersection(set1, set2);
-
-        expect(operator.isSubsetOf(set), false);
-      },
-    },
-    {
-      title: "isSubsetOf succeeds for intersection 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, Instruments.Bass1 ] });
-
-        const operator = new Set.Intersection(set1, set2);
-
-        expect(operator.isSubsetOf(set), true);
-      },
-    },
-    {
-      title: "isSubsetOf fails for a set that is not a subset of an intesection 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, Instruments.Bass1 ] });
-
-        const operator = new Set.Intersection(set1, set2);
-
-        expect(set.isSubsetOf(operator), false);
-      },
-    },
-    {
-      title: "isSubsetOf succeeds for a set that is a subset of an intersection set",
-      test: () => {
-        let set = new InstrumentSet({ add: [ Instruments.Bass1, Instruments.Snare ]});
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Crash, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-
-        const operator = new Set.Intersection(set1, set2);
-
-        expect(set.isSubsetOf(operator), true);
-      },
-    },
-
-  ],
-};