discombobulator 1.0.0 → 1.0.2

package/src/test/testing.mjs

@@ -1,63 +0,0 @@
-// testing.mjs
-//
-// Functions and definitions used by test modules.
-
-export class TestExpectationFailed extends Error {
-  constructor(result, expectedValue) { 
-    super(`Failed expectation: ${result.toString()} != ${expectedValue}`);
-  }
-}
-
-export class TestExceptionFailed extends Error {
-  constructor(expectedExceptionType, actualException = undefined) { 
-    let message = `Failed exception: expected ${expectedExceptionType.name} to be thrown but it wasn't`;
-
-    if (!!actualException) {
-      message += ` ('${actualException}' was thrown instead)`;
-    }
-
-    super(message);
-  }
-}
-
-// Check that the given result is equal (loosely) to the expectedValue.
-// Throws TestExpectationFailed if the expected value does not match.
-//
-// result may be a concrete value, or a function whose return value should 
-// be taken as the actual result.
-export const expect = (result, expectedValue) => {
-  const isFunction = typeof expectedValue === 'function';
-
-  if (typeof result === 'function') {
-    result = result();
-  }
-
-  if ((isFunction && !expectedValue(result)) || (!isFunction && result != expectedValue)) {
-    throw new TestExpectationFailed(result, expectedValue);
-  }
-}
-
-// Check that the given function results in a particular exception type being thrown.
-// Throws TestExceptionFailed if the function throws a different exception to .
-// expectedExceptionType, or none at all.
-//
-// fn must be a function whose execution is expected to throw an exception of expectedExceptionType.
-export const expectException = (fn, expectedExceptionType) => {
-  if (typeof fn !== 'function') {
-    throw `expectException requires a function as its first argument`;
-  }
-
-  let failureException = undefined;
-
-  try {
-    fn();
-
-    failureException = new TestExceptionFailed(expectedExceptionType);
-  } catch (e) {
-    if (!(e instanceof expectedExceptionType)) {
-      failureException = new TestExceptionFailed(expectedExceptionType, e);
-    }
-  }
-
-  if (!!failureException) throw failureException;
-}

package/src/test/union.mjs

@@ -1,495 +0,0 @@
-// union.mjs
-//
-// Tests for union.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.Union(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.Union(set1, set2);
-
-        expectException(() => {
-          operator.add(Instruments.Snare);
-        }, Error);
-      },
-    },
-
-    {
-      title: "iterator yields nothing for an empty set",
-      test: () => {
-        const set1 = new InstrumentSet();
-        const set2 = new InstrumentSet();
-
-        const operator = new Set.Union(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.Claves,
-          Instruments.Snare,
-          Instruments.Bass1,
-        ];
-        const set1 = new InstrumentSet({
-          add: [Instruments.Crash, Instruments.Claves],
-        });
-        const set2 = new InstrumentSet({
-          add: [Instruments.Snare, Instruments.Bass1],
-        });
-
-        const operator = new Set.Union(set1, set2);
-        let count = 0;
-
-        for (const e of operator) {
-          expect(e, (result) => { return result === instruments[count++]; });
-        }
-
-        expect(count, 4);
-      },
-    },
-
-    {
-      title: "size returns correct size with no union elements",
-      test: () => {
-        const set1 = new InstrumentSet();
-        const set2 = new InstrumentSet();
-
-        const operator = new Set.Union(set1, set2);
-
-        expect(operator.size === 0, true);
-      },
-    },
-    {
-      title: "size returns correct size with a single union element",
-      test: () => {
-        const set1 = new InstrumentSet();
-        const set2 = new InstrumentSet({ add: Instruments.Snare });
-
-        const operator = new Set.Union(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.Union(set1, set2);
-
-        expect(operator.size === 4, true);
-      },
-    },
-
-    {
-      title: "has fails when empty",
-      test: () => {
-        const set1 = new InstrumentSet();
-        const set2 = new InstrumentSet();
-
-        const operator = new Set.Union(set1, set2);
-
-        expect(operator.size === 0, true);
-        expect(operator.has(Instruments.Snare), false);
-      },
-    },
-    {
-      title: "has succeeds for element that is in union",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Bass1 ] });
-
-        const operator = new Set.Union(set1, set2);
-
-        expect(operator.size === 2, true);
-        expect(operator.has(Instruments.Bass1), true);
-      },
-    },
-    {
-      title: "has fails for element that is not in union",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Bass1 ] });
-
-        const operator = new Set.Union(set1, set2);
-
-        expect(operator.size === 2, true);
-        expect(operator.has(Instruments.Crash), false);
-      },
-    },
-    {
-      title: "has succeeds for set that is in union",
-      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.Union(set1, set2);
-
-        expect(operator.size === 4, true);
-        expect(operator.has(subset), true);
-      },
-    },
-    {
-      title: "has fails for other set that is not in union",
-      test: () => {
-        let subset = new InstrumentSet({ add: [ Instruments.Claves, Instruments.China ]});
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Bass1, Instruments.Crash, Instruments.Snare ] });
-
-        const operator = new Set.Union(set1, set2);
-
-        expect(operator.size === 3, 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.Union(set1, set2);
-
-        expect(operator.size === 4, 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.Union(set1, set2);
-
-        expect(operator.size === 4, 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.Claves ] });
-
-        const operator = new Set.Union(set1, set2);
-
-        expect(operator.size === 3, true);
-        expect(operator.indexOf(Instruments.Crash), -1);
-      },
-    },
-    {
-      title: "indexOf fails for empty set",
-      test: () => {
-        let set1 = new InstrumentSet();
-        let set2 = new InstrumentSet();
-
-        const operator = new Set.Union(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.Union(set1, set2);
-
-        expect(operator.size === 4, true);
-        expect(operator.indexOf(Instruments.Snare), 0);
-        expect(operator.indexOf(Instruments.Claves), 1);
-        expect(operator.indexOf(Instruments.Bass1), 2);
-        expect(operator.indexOf(Instruments.Crash), 3);
-      },
-    },
-    {
-      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.Union(set1, set2);
-
-        expect(operator.size === 4, 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.Union(set1, set2);
-
-        expect(operator.size === 4, 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.Union(set1, set2);
-
-        expect(operator.size === 4, true);
-        expect(operator.indexOf(Instruments.Claves, 3), -1);
-        expect(operator.indexOf(Instruments.Claves, 4), -1);
-        expect(operator.indexOf(Instruments.Claves, 5), -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.Union(set1, set2);
-
-        expect(operator.size === 4, true);
-        expectException(() => { operator.elementAt(-1); }, Error);
-      },
-    },
-    {
-      title: "elementAt throws error for empty set",
-      test: () => {
-        let set1 = new InstrumentSet();
-        let set2 = new InstrumentSet();
-
-        const operator = new Set.Union(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.Union(set1, set2);
-
-        expect(operator.size === 4, true);
-        expectException(() => { operator.elementAt(5); }, 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.Union(set1, set2);
-
-        expect(operator.size === 4, true);
-        expect(operator.elementAt(0), (result) => { return result === Instruments.Snare; });
-        expect(operator.elementAt(1), (result) => { return result === Instruments.Claves; });
-        expect(operator.elementAt(2), (result) => { return result === Instruments.Bass1; });
-        expect(operator.elementAt(3), (result) => { return result === Instruments.Crash; });
-      },
-    },
-
-    {
-      title: "clone succeeds on a union 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.Union(set1, set2);
-
-        expect(operator.size === 4, 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 union 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.Union(set1, set2);
-
-        expect(operator.size === 4, 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 union 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.Union(set1, set2);
-
-        expect(operator.isDisjointFrom(set), false);
-      },
-    },
-    {
-      title: "isDisjointFrom succeeds for union 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.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.China, Instruments.Bass2 ] });
-
-        const operator = new Set.Union(set1, set2);
-
-        expect(operator.isDisjointFrom(set), true);
-      },
-    },
-    {
-      title: "isDisjointFrom fails for a set that is not disjoint from a union set",
-      test: () => {
-        let set = new InstrumentSet({ add: [ Instruments.China, Instruments.Crash ]});
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.Union(set1, set2);
-
-        expect(set.isDisjointFrom(operator), false);
-      },
-    },
-    {
-      title: "isDisjointFrom succeeds for a set that is disjoint from a union set",
-      test: () => {
-        let set = new InstrumentSet({ add: [ Instruments.China, Instruments.Claves ]});
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Bass1, Instruments.Crash ] });
-
-        const operator = new Set.Union(set1, set2);
-
-        expect(set.isDisjointFrom(operator), true);
-      },
-    },
-
-    {
-      title: "isSubsetOf fails for union set that is not a subset of another set",
-      test: () => {
-        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1, Instruments.Claves ]});
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash ] });
-
-        const operator = new Set.Union(set1, set2);
-
-        expect(operator.isSubsetOf(set), false);
-      },
-    },
-    {
-      title: "isSubsetOf succeeds for union set that is 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 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.Union(set1, set2);
-
-        expect(operator.isSubsetOf(set), true);
-      },
-    },
-    {
-      title: "isSubsetOf fails for a set that is not a subset of an union set",
-      test: () => {
-        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.China ]});
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Bass1 ] });
-
-        const operator = new Set.Union(set1, set2);
-
-        expect(set.isSubsetOf(operator), false);
-      },
-    },
-    {
-      title: "isSubsetOf succeeds for a set that is a subset of an union 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.Union(set1, set2);
-
-        expect(set.isSubsetOf(operator), true);
-      },
-    },
-
-  ],
-};