discombobulator 1.0.0

package/src/test/set.mjs

@@ -0,0 +1,1081 @@
+// set.mjs
+//
+// Tests for set.mjs.
+
+import { expect, expectException } from './testing.mjs'
+
+import { Instrument, Instruments } from '../instrument.mjs'
+import { Articulations } from '../articulation.mjs'
+import { Set } from '../set.mjs'
+import { ArticulationSet } from '../articulationset.mjs'
+import { InstrumentSet } from '../instrumentset.mjs'
+import { Note } from '../note.mjs'
+import { NoteSet } from '../noteset.mjs'
+import { Chord } from '../chord.mjs'
+import { Pattern } from '../pattern.mjs'
+import { PatternSet } from '../patternset.mjs'
+import { Schedule } from '../schedule.mjs'
+import { Group } from '../group.mjs'
+import { RegularGroupSet } from '../regulargroupset.mjs'
+
+export const test = {
+  tests: [ 
+    {
+      title: "default constructor results in correct set",
+      test: () => {
+        let set = new Set();
+
+        expect(set.isAbstract, false);
+        expect(set.allowDuplicates, false);
+        expect(set.size, 0);
+      },
+    },
+    {
+      title: "constructor correctly initialises isAbstract",
+      test: () => {
+        let set = new Set({ isAbstract: true });
+
+        expect(set.isAbstract, true);
+      },
+    },
+    {
+      title: "constructor correctly initialises allowDuplicates",
+      test: () => {
+        let set = new Set({ allowDuplicates: true });
+
+        expect(set.allowDuplicates, true);
+      },
+    },
+
+    {
+      title: "isElementAllowed returns undefined for undefined element",
+      test: () => {
+        const set = new Set();
+        
+        expect(set.isElementAllowed(), (result) => { return result === undefined; });
+      },
+    },
+    {
+      title: "isElementAllowed returns undefined for non-Element based object",
+      test: () => {
+        const set = new Set();
+        const element = new Error();
+        
+        expect(set.isElementAllowed(element), (result) => { return result === undefined; });
+      },
+    },
+    {
+      title: "isElementAllowed allows any element type if allowedElements is undefined",
+      test: () => {
+        const set = new Set();
+        const element = new Instrument();
+        
+        expect(set.isElementAllowed(element), (result) => { return result === element; });
+      },
+    },
+    {
+      title: "isElementAllowed allows any element type from defined allowedElements",
+      test: () => {
+        const set = new Schedule();
+        const element = new Pattern();
+        const other = new PatternSet();
+        
+        expect(set.isElementAllowed(element), (result) => { return result === element; });
+        expect(set.isElementAllowed(other), (result) => { return result === other; });
+      },
+    },
+    {
+      title: "isElementAllowed undefined for element type that can't be promoted",
+      test: () => {
+        const set = new Schedule();
+        const element = new Group(1, 1);
+        
+        expect(set.isElementAllowed(element), (result) => { return result === undefined; });
+      },
+    },
+    {
+      title: "isElementAllowed correctly allows element that can be promoted",
+      test: () => {
+        const set = new Chord();
+        
+        expect(set.isElementAllowed(Instruments.Snare), (result) => { return result !== undefined && result instanceof Note; });
+      },
+    },
+
+    {
+      title: "add element fails on an immutable set",
+      test: () => {
+        let set = new RegularGroupSet();
+        let group = new Group(1, 1);
+
+        expectException(() => { set.add(group) }, Error);
+      },
+    },
+    {
+      title: "add element succeeds adding single element to a mutable set (without promotion)",
+      test: () => {
+        let set = new InstrumentSet();
+
+        expect(set.add(Instruments.Snare), (result) => { return result === set; });
+        expect(set.size, 1);
+      },
+    },
+    {
+      title: "add element succeeds adding multiple elements to a mutable set (without promotion)",
+      test: () => {
+        let set = new InstrumentSet({ add: Instruments.Bass1});
+
+        expect(set.add(Instruments.Snare), (result) => { return result === set; });
+        expect(set.size, 2);
+      },
+    },
+    {
+      title: "add element succeeds adding single element array of elements to a mutable set (without promotion)",
+      test: () => {
+        let set = new InstrumentSet();
+
+        expect(set.add([ Instruments.Snare ]), (result) => { return result === set; });
+        expect(set.size, 1);
+      },
+    },
+    {
+      title: "add element succeeds adding multiple element array of elements to a mutable set (without promotion)",
+      test: () => {
+        let set = new InstrumentSet();
+
+        expect(set.add([ Instruments.Snare, Instruments.Bass1 ]), (result) => { return result === set; });
+        expect(set.size, 2);
+      },
+    },
+    {
+      title: "add element succeeds adding single element to a mutable set (with promotion)",
+      test: () => {
+        let set = new Chord();
+
+        expect(set.add(Instruments.Snare), (result) => { return result === set; });
+        expect(set.size, 1);
+        expect(set.elements[0], (result) => { return result instanceof Note; });
+      },
+    },
+    {
+      title: "add element succeeds adding multiple elements to a mutable set (with promotion)",
+      test: () => {
+        let set = new Chord({ add: Instruments.Bass1});
+
+        expect(set.add(Instruments.Snare), (result) => { return result === set; });
+        expect(set.size, 2);
+        expect(set.elements[0], (result) => { return result instanceof Note; });
+        expect(set.elements[1], (result) => { return result instanceof Note; });
+      },
+    },
+    {
+      title: "add element succeeds adding single element array of elements to a mutable set (with promotion)",
+      test: () => {
+        let set = new Chord();
+
+        expect(set.add([ Instruments.Snare ]), (result) => { return result === set; });
+        expect(set.size, 1);
+        expect(set.elements[0], (result) => { return result instanceof Note; });
+      },
+    },
+    {
+      title: "add element succeeds adding multiple element array of elements to a mutable set (with promotion)",
+      test: () => {
+        let set = new Chord();
+
+        expect(set.add([ Instruments.Snare, Instruments.Bass1 ]), (result) => { return result === set; });
+        expect(set.size, 2);
+        expect(set.elements[0], (result) => { return result instanceof Note; });
+        expect(set.elements[1], (result) => { return result instanceof Note; });
+      },
+    },
+
+    {
+      title: "constructor correctly adds a single element",
+      test: () => {
+        let set = new Set({ add: new Instrument("test") });
+
+        expect(set.size, 1);
+        expect(set.elements[0] instanceof Instrument, true);
+        expect(set.elements[0].symbol === Symbol.for("test"), true);
+      },
+    },
+    {
+      title: "constructor correctly adds multiple unique elements",
+      test: () => {
+        let set = new Set({ add: [ new Instrument("test"), new Instrument("other") ] });
+
+        expect(set.size, 2);
+        expect(set.elements[0] instanceof Instrument, true);
+        expect(set.elements[0].symbol === Symbol.for("test"), true);
+        expect(set.elements[1] instanceof Instrument, true);
+        expect(set.elements[1].symbol === Symbol.for("other"), true);
+      },
+    },
+    {
+      title: "constructor correctly adds multiple equal elements",
+      test: () => {
+        let set = new Set({ add: [ new Instrument("test"), new Instrument("test") ] });
+
+        expect(set.size, 1);
+        expect(set.elements[0] instanceof Instrument, true);
+        expect(set.elements[0].symbol === Symbol.for("test"), true);
+      },
+    },
+    {
+      title: "constructor correctly adds multiple equal elements with allowDuplicates",
+      test: () => {
+        let set = new Set({ allowDuplicates: true, add: [ new Instrument("test"), new Instrument("test") ] });
+
+        expect(set.size, 2);
+        expect(set.elements[0] instanceof Instrument, true);
+        expect(set.elements[0].symbol === Symbol.for("test"), true);
+        expect(set.elements[1] instanceof Instrument, true);
+        expect(set.elements[1].symbol === Symbol.for("test"), true);
+      },
+    },
+    {
+      title: "constructor correctly adds multiple unique elements with allowDuplicates",
+      test: () => {
+        let set = new Set({ allowDuplicates: true, add: [ new Instrument("test"), new Instrument("other") ] });
+
+        expect(set.size, 2);
+        expect(set.elements[0] instanceof Instrument, true);
+        expect(set.elements[0].symbol === Symbol.for("test"), true);
+        expect(set.elements[1] instanceof Instrument, true);
+        expect(set.elements[1].symbol === Symbol.for("other"), true);
+      },
+    },
+    
+    {
+      title: "promote succeeds for self",
+      test: () => {
+        const set = new Set();
+
+        expect(set.promote(set), (result) => { return result === set; });
+      },
+    },
+    {
+      title: "promote succeeds for two different element instances",
+      test: () => {
+        const set = new Set();
+        const other = new Set();
+
+        expect(set.promote(other), (result) => { return result === other; });
+      },
+    },
+    {
+      title: "promote succeeds for different (element-derived) class when no allowedElements defined",
+      test: () => {
+        const set = new Set();
+        const other = new Instrument();
+
+        expect(set.promote(other), (result) => { return result === other; });
+      },
+    },
+    
+    {
+      title: "isEqual fails when compared with set of different size",
+      test: () => {
+        const set = new Set({add: [ Instruments.Snare ]});
+        const other = new Set({add: [ Instruments.Snare, Instruments.Bass1 ]});
+
+        expect(set.isEqual(other), false);
+      },
+    },
+    {
+      title: "isEqual succeeds when comparing identical sets",
+      test: () => {
+        const set = new InstrumentSet({add: [ Instruments.Snare, Instruments.Bass1 ]});
+        const other = new InstrumentSet({add: [ Instruments.Snare, Instruments.Bass1 ]});
+
+        expect(set.isEqual(other), true);
+      },
+    },
+    {
+      title: "isEqual fails when comparing different sets of the same size",
+      test: () => {
+        const set = new InstrumentSet({add: [ Instruments.Snare, Instruments.Bass1 ]});
+        const other = new InstrumentSet({add: [ Instruments.Snare, Instruments.Claves ]});
+
+        expect(set.isEqual(other), false);
+      },
+    },
+
+    {
+      title: "iterator yields nothing for an empty set",
+      test: () => {
+        const set = new Set();
+        let count = 0;
+
+        for (const e of set) { ++count; }
+
+        expect(count, 0);
+      },
+    },
+    {
+      title: "iterator yields correct results for a non-empty set",
+      test: () => {
+        const elements = [ Instruments.Snare, Instruments.Bass1 ];
+        const set = new Set({add: elements});
+        let count = 0;
+
+        for (const e of set) {
+          expect(e, (result) => { return result === elements[count++]; });
+        }
+
+        expect(count, 2);
+      },
+    },
+
+    {
+      title: "SetOf throws error with undefined argument",
+      test: () => {
+        let setof;
+
+        expectException(() => new Set.SetOf(), Error);
+      },
+    },
+    {
+      title: "SetOf constructs throws Error with non-Element derived argument",
+      test: () => {
+        let setof = undefined;
+
+        expectException(() => { setof = new Set.SetOf(Error); }, Error);
+      },
+    },
+    {
+      title: "SetOf correctly constructs with single Element-derived type (shallow)",
+      test: () => {
+        let setof = new Set.SetOf(Pattern);
+
+        expect(setof.setof.length, 1);
+        expect(setof.setof[0] === Pattern, true);
+      },
+    },
+    {
+      title: "SetOf correctly constructs with single Element-derived type (deep)",
+      test: () => {
+        let setof = new Set.SetOf(Pattern, true);
+
+        expect(setof.setof.length, 1);
+        expect(setof.setof[0] instanceof Set.SetOf, true);
+        expect(setof.setof[0].setof.length, 1);
+        expect(setof.setof[0].setof[0] instanceof Set.SetOf, true);
+        expect(setof.setof[0].setof[0].setof.length, 1);
+        expect(setof.setof[0].setof[0].setof[0] === Note, true);
+      },
+    },
+    {
+      title: "SetOf correctly constructs with array of Element-derived types (shallow)",
+      test: () => {
+        let setof = new Set.SetOf([ Instrument, Pattern ]);
+
+        expect(setof.setof.length, 2);
+        expect(setof.setof[0] === Instrument, true);
+        expect(setof.setof[1] === Pattern, true);
+      },
+    },
+    {
+      title: "SetOf correctly constructs with array of Element-derived types (deep)",
+      test: () => {
+        let setof = new Set.SetOf([ Instrument, Pattern ], true);
+
+        expect(setof.setof.length, 2);
+        expect(setof.setof[0] === Instrument, true);
+        expect(setof.setof[1] instanceof Set.SetOf, true);
+        expect(setof.setof[1].setof.length, 1);
+        expect(setof.setof[1].setof[0] instanceof Set.SetOf, true);
+        expect(setof.setof[1].setof[0].setof.length, 1);
+        expect(setof.setof[1].setof[0].setof[0] === Note, true);
+      },
+    },
+
+    {
+      title: "SetOf.equals fails with setofs of different lengths",
+      test: () => {
+        let setof = new Set.SetOf(Instrument);
+        let other = new Set.SetOf([ Instrument, Pattern ]);
+
+        expect(setof.equals(other), false);
+      },
+    },
+    {
+      title: "SetOf.equals fails with different single-element setofs (shallow)",
+      test: () => {
+        let setof = new Set.SetOf(Instrument);
+        let other = new Set.SetOf(Pattern);
+
+        expect(setof.equals(other), false);
+      },
+    },
+    {
+      title: "SetOf.equals succeeds with same single-element setofs (shallow)",
+      test: () => {
+        let setof = new Set.SetOf(Instrument);
+        let other = new Set.SetOf(Instrument);
+
+        expect(setof.equals(other), true);
+      },
+    },
+    {
+      title: "SetOf.equals fails with different multiple-element setofs (shallow)",
+      test: () => {
+        let setof = new Set.SetOf([ Instrument, Pattern ]);
+        let other = new Set.SetOf([ Note, Pattern ]);
+
+        expect(setof.equals(other), false);
+      },
+    },
+    {
+      title: "SetOf.equals succeeds with same multiple-element setofs (shallow)",
+      test: () => {
+        let setof = new Set.SetOf([ Instrument, Pattern ]);
+        let other = new Set.SetOf([ Instrument, Pattern ]);
+
+        expect(setof.equals(other), true);
+      },
+    },
+
+    {
+      title: "SetOf.equals fails with different single-element setofs (deep)",
+      test: () => {
+        let setof = new Set.SetOf(Instrument, true);
+        let other = new Set.SetOf(Pattern, true);
+
+        expect(setof.equals(other), false);
+      },
+    },
+    {
+      title: "SetOf.equals succeeds with same single-element setofs (deep)",
+      test: () => {
+        let setof = new Set.SetOf(Instrument, true);
+        let other = new Set.SetOf(Instrument, true);
+
+        expect(setof.equals(other), true);
+      },
+    },
+    {
+      title: "SetOf.equals fails with different multiple-element setofs (deep)",
+      test: () => {
+        let setof = new Set.SetOf([ Pattern, Instrument ], true);
+        let other = new Set.SetOf([ Pattern, Note ], true);
+
+        expect(setof.equals(other), false);
+      },
+    },
+    {
+      title: "SetOf.equals succeeds with same multiple-element setofs (deep)",
+      test: () => {
+        let setof = new Set.SetOf([ Instrument, Pattern ], true);
+        let other = new Set.SetOf([ Instrument, Pattern ], true);
+
+        expect(setof.equals(other), true);
+      },
+    },
+
+    {
+      title: "validateOther succeeds for equivalent sets",
+      test: () => {
+        const noteset = new NoteSet();
+        const chord = new Chord();
+        
+        expect(noteset.validateOther(chord), true);
+      },
+    },
+    {
+      title: "validateOther fails for different sets",
+      test: () => {
+        const noteset = new NoteSet();
+        const instrumentset = new InstrumentSet();
+        
+        expect(noteset.validateOther(instrumentset), false);
+      },
+    },
+
+
+    {
+      title: "append fails on an immutable set",
+      test: () => {
+        let set = new RegularGroupSet();
+        let other = new RegularGroupSet();
+
+        expectException(() => { set.append(other) }, Error);
+      },
+    },
+    {
+      title: "append throws error appending different set type",
+      test: () => {
+        let set = new InstrumentSet();
+        let other = new ArticulationSet();
+
+        expectException(() => { set.append(other); }, Error);
+      },
+    },
+    {
+      title: "append throws error appending undefined set",
+      test: () => {
+        let set = new InstrumentSet();
+
+        expectException(() => { set.append(); }, Error);
+      },
+    },
+    {
+      title: "append succeeds appending empty set to empty set",
+      test: () => {
+        let set = new InstrumentSet();
+        let other = new InstrumentSet();
+
+        expect(set.append(other), (result) => { return result === set; });
+        expect(set.size, 0);
+        expect(other.size, 0);
+      },
+    },
+    {
+      title: "append succeeds appending empty set to non-empty set",
+      test: () => {
+        let set = new InstrumentSet({ add: Instruments.Snare });
+        let other = new InstrumentSet();
+
+        expect(set.append(other), (result) => { return result === set; });
+        expect(set.size, 1);
+        expect(other.size, 0);
+      },
+    },
+    {
+      title: "append succeeds appending non-empty set to empty set",
+      test: () => {
+        let set = new InstrumentSet();
+        let other = new InstrumentSet({ add: Instruments.Snare });
+
+        expect(set.append(other), (result) => { return result === set; });
+        expect(set.size, 1);
+        expect(other.size, 1);
+        expect(set.elements[0] === other.elements[0], true);
+      },
+    },
+    {
+      title: "append succeeds appending non-empty set to non-empty set",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Bass1, Instruments.Bass2 ] });
+        let other = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves ] });
+
+        expect(set.append(other), (result) => { return result === set; });
+        expect(set.size, 4);
+        expect(other.size, 2);
+        expect(set.elements[2] === other.elements[0], true);
+        expect(set.elements[3] === other.elements[1], true);
+      },
+    },
+
+    {
+      title: "clear fails on an immutable set",
+      test: () => {
+        let set = new RegularGroupSet();
+
+        expectException(() => { set.clear() }, Error);
+      },
+    },
+    {
+      title: "clear correctly empties a set",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Bass1, Instruments.Bass2 ] });
+
+        expect(set.clear(), (result) => { return result === set; });
+        expect(set.size, 0);
+      },
+    },
+
+    {
+      title: "clone succeeds on an immutable set by cloning properties only",
+      test: () => {
+        const TestClass = class extends Set {
+          constructor() {
+            super({ isAbstract: true });
+          }
+        }
+
+        const set = new TestClass();
+        const clone = set.clone();
+
+        expect(clone.isAbstract, true);
+        expect(clone.allowDuplicates, false);
+        expect(clone.isStrict, true);
+      },
+    },
+    {
+      title: "clone correctly clones an empty set",
+      test: () => {
+        let set = new InstrumentSet();
+        let clone;
+
+        expect(clone = set.clone(), (result) => { return result instanceof InstrumentSet; });
+        expect(clone !== set, true)
+        expect(clone.size, 0);
+      },
+    },
+    {
+      title: "clone correctly clones a non-empty set (shallow)",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Bass1, Instruments.Bass2 ] });
+        let clone;
+
+        expect(clone = set.clone(), (result) => { return result instanceof InstrumentSet; });
+        expect(clone !== set, true)
+        expect(clone.size, 2);
+        expect(clone.elements[0] === set.elements[0], true);
+        expect(clone.elements[1] === set.elements[1], true);
+      },
+    },
+    {
+      title: "clone correctly clones a non-empty set (deep)",
+      test: () => {
+        let set = new Pattern(
+          { add: [ 
+            new Chord(
+              { add: [ 
+                new Note({ add: [ Instruments.Snare, undefined ] })
+              ]}
+            ) 
+          ]}
+        );
+        let clone;
+
+        expect(clone = set.clone(true), (result) => { return result instanceof Pattern; });
+        expect(clone !== set, true)
+        expect(clone.size, 1);
+        expect(clone.elements[0] !== set.elements[0], true);
+        expect(clone.elements[0].elements[0] !== set.elements[0].elements[0], true);
+      },
+    },
+
+    {
+      title: "delete fails on an immutable set",
+      test: () => {
+        let set = new RegularGroupSet();
+
+        expectException(() => { set.delete() }, Error);
+      },
+    },
+    {
+      title: "delete fails to remove element from empty set",
+      test: () => {
+        let set = new InstrumentSet();
+
+        expect(set.delete(Instruments.Bass1), false);
+      },
+    },
+    {
+      title: "delete fails to remove element not in set",
+      test: () => {
+        let set = new InstrumentSet({ add: Instruments.Snare });
+
+        expect(set.delete(Instruments.Bass1), false);
+      },
+    },
+    {
+      title: "delete succeeds in removing element last element from set",
+      test: () => {
+        let set = new InstrumentSet({ add: Instruments.Bass1 });
+
+        expect(set.delete(Instruments.Bass1), true);
+        expect(set.size, 0)
+      },
+    },
+    {
+      title: "delete succeeds in removing element not last element from set",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Bass1, Instruments.Snare ]});
+
+        expect(set.delete(Instruments.Bass1), true);
+        expect(set.size, 1)
+        expect(set.elements[0] === Instruments.Snare, true);
+      },
+    },
+
+    {
+      title: "elementAt throws error for index < 0",
+      test: () => {
+        let set = new InstrumentSet();
+
+        expectException(() => { set.elementAt(-1); }, Error);
+      },
+    },
+    {
+      title: "elementAt throws error for empty set",
+      test: () => {
+        let set = new InstrumentSet();
+
+        expectException(() => { set.elementAt(0); }, Error);
+      },
+    },
+    {
+      title: "elementAt throws error for index >= set size",
+      test: () => {
+        let set = new InstrumentSet({ add: Instruments.Snare });
+
+        expectException(() => { set.elementAt(1); }, Error);
+      },
+    },
+    {
+      title: "elementAt succeeds for element in valid index",
+      test: () => {
+        let set = new InstrumentSet({ add: Instruments.Snare });
+
+        expect(set.elementAt(0), (result) => { return result === Instruments.Snare; });
+      },
+    },
+
+    {
+      title: "forEach does nothing for empty set",
+      test: () => {
+        let set = new InstrumentSet();
+        let count = 0;
+
+        set.forEach((element) => { ++count; });
+
+        expect(count, 0);
+      },
+    },
+    {
+      title: "forEach correctly processes elements for non-empty set",
+      test: () => {
+        const elements = [ Instruments.Snare, Instruments.Bass1 ];
+        let set = new InstrumentSet({ add: elements });
+        let count = 0;
+
+        set.forEach(
+          (element) => {
+            expect(element === elements[count++], true);
+          }
+        );
+
+        expect(count, 2);
+      },
+    },
+
+    {
+      title: "isDisjointFrom throws error for elements of different types",
+      test: () => {
+        let set = new InstrumentSet();
+        let other = new NoteSet();
+
+        expectException(() => { set.isDisjointFrom(other); }, Error);
+      },
+    },
+    {
+      title: "isDisjointFrom succeeds for empty sets",
+      test: () => {
+        let set = new InstrumentSet();
+        let other = new InstrumentSet();
+
+        expect(set.isDisjointFrom(other), true);
+      },
+    },
+    {
+      title: "isDisjointFrom succeeds for disjoint single-element set and empty set",
+      test: () => {
+        let set = new InstrumentSet({ add: Instruments.Snare });
+        let other = new InstrumentSet();
+
+        expect(set.isDisjointFrom(other), true);
+      },
+    },
+    {
+      title: "isDisjointFrom succeeds for disjoint empty set and single-element set",
+      test: () => {
+        let set = new InstrumentSet();
+        let other = new InstrumentSet({ add: Instruments.Snare });
+
+        expect(set.isDisjointFrom(other), true);
+      },
+    },
+    {
+      title: "isDisjointFrom succeeds for disjoint multi-element set and empty set",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
+        let other = new InstrumentSet();
+
+        expect(set.isDisjointFrom(other), true);
+      },
+    },
+    {
+      title: "isDisjointFrom succeeds for disjoint empty set and multi-element set",
+      test: () => {
+        let set = new InstrumentSet();
+        let other = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ]});
+
+        expect(set.isDisjointFrom(other), true);
+      },
+    },
+    {
+      title: "isDisjointFrom succeeds for disjoint single-element sets",
+      test: () => {
+        let set = new InstrumentSet({ add: Instruments.Snare });
+        let other = new InstrumentSet({ add: Instruments.Bass1 });
+
+        expect(set.isDisjointFrom(other), true);
+      },
+    },
+    {
+      title: "isDisjointFrom fails for non-disjoint single-element sets",
+      test: () => {
+        let set = new InstrumentSet({ add: Instruments.Snare });
+        let other = new InstrumentSet({ add: Instruments.Snare });
+
+        expect(set.isDisjointFrom(other), false);
+      },
+    },
+    {
+      title: "isDisjointFrom succeeds for disjoint multi-element sets",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves ] });
+        let other = new InstrumentSet({ add: [ Instruments.Bass1, Instruments.Crash ] });
+
+        expect(set.isDisjointFrom(other), true);
+      },
+    },
+    {
+      title: "isDisjointFrom fails for non-disjoint multi-element sets",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves ] });
+        let other = new InstrumentSet({ add: [ Instruments.Bass1, Instruments.Claves ] });
+
+        expect(set.isDisjointFrom(other), false);
+      },
+    },
+
+    {
+      title: "isSubsetOf throws error for elements of different types",
+      test: () => {
+        let set = new InstrumentSet();
+        let other = new NoteSet();
+
+        expectException(() => { set.isSubsetOf(other); }, Error);
+      },
+    },
+    {
+      title: "isSubsetOf fails for empty sets",
+      test: () => {
+        let set = new InstrumentSet();
+        let other = new InstrumentSet();
+
+        expect(set.isSubsetOf(other), false);
+      },
+    },
+    {
+      title: "isSubsetOf fails for single-element set and empty set",
+      test: () => {
+        let set = new InstrumentSet({ add: Instruments.Snare });
+        let other = new InstrumentSet();
+
+        expect(set.isSubsetOf(other), false);
+      },
+    },
+    {
+      title: "isSubsetOf fails for empty set and single-element set",
+      test: () => {
+        let set = new InstrumentSet();
+        let other = new InstrumentSet({ add: Instruments.Snare });
+
+        expect(set.isSubsetOf(other), false);
+      },
+    },
+    {
+      title: "isSubsetOf fails for multi-element set and empty set",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
+        let other = new InstrumentSet();
+
+        expect(set.isSubsetOf(other), false);
+      },
+    },
+    {
+      title: "isSubsetOf fails for empty set and multi-element set",
+      test: () => {
+        let set = new InstrumentSet();
+        let other = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ]});
+
+        expect(set.isSubsetOf(other), false);
+      },
+    },
+    {
+      title: "isSubsetOf fails for different single-element sets",
+      test: () => {
+        let set = new InstrumentSet({ add: Instruments.Snare });
+        let other = new InstrumentSet({ add: Instruments.Bass1 });
+
+        expect(set.isSubsetOf(other), false);
+      },
+    },
+    {
+      title: "isSubsetOf succeeds for equal single-element sets",
+      test: () => {
+        let set = new InstrumentSet({ add: Instruments.Snare });
+        let other = new InstrumentSet({ add: Instruments.Snare });
+
+        expect(set.isSubsetOf(other), true);
+      },
+    },
+    {
+      title: "isSubsetOf fails for disjoint multi-element sets",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves ] });
+        let other = new InstrumentSet({ add: [ Instruments.Bass1, Instruments.Crash ] });
+
+        expect(set.isSubsetOf(other), false);
+      },
+    },
+    {
+      title: "isSubsetOf fails for non-disjoint, but non-subset multi-element sets",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves ] });
+        let other = new InstrumentSet({ add: [ Instruments.Bass1, Instruments.Claves, Instruments.Crash ] });
+
+        expect(set.isSubsetOf(other), false);
+      },
+    },
+    {
+      title: "isSubsetOf succeeds for non-disjoint, multi-element subset",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves ] });
+        let other = new InstrumentSet({ add: [ Instruments.Bass1, Instruments.Claves, Instruments.Snare ] });
+
+        expect(set.isSubsetOf(other), true);
+      },
+    },
+
+    {
+      title: "has fails when empty",
+      test: () => {
+        let set = new InstrumentSet();
+        let other = new InstrumentSet({ add: Instruments.Snare });
+
+        expect(set.has(other), false);
+      },
+    },
+    {
+      title: "has fails for other set that is not a subset",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
+        let other = new InstrumentSet({ add: [ Instruments.Claves ] });
+
+        expect(set.has(other), false);
+      },
+    },
+    {
+      title: "has succeeds for other set that is a subset",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
+        let other = new InstrumentSet({ add: [ Instruments.Bass1 ] });
+
+        expect(set.has(other), true);
+      },
+    },
+    {
+      title: "has fails for element not in set",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
+
+        expect(set.has(Instruments.Claves), false);
+      },
+    },
+    {
+      title: "has succeeds for element in the set",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
+
+        expect(set.has(Instruments.Bass1), true);
+      },
+    },
+    {
+      title: "has succeeds for element that can be promoted",
+      test: () => {
+        let set = new NoteSet({ add: [ new Note({add: Instruments.Snare}), new Note({add: Instruments.Bass1}) ] });
+        let other = Instruments.Bass1;
+
+        expect(set.has(other), true);
+      },
+    },
+    {
+      title: "has fails for element that can't be promoted",
+      test: () => {
+        let set = new NoteSet({ add: [ new Note({add: Instruments.Snare}), new Note({add: Instruments.Bass1}) ] });
+        let other = Articulations.Accent;
+
+        expect(set.has(other), false);
+      },
+    },
+
+    {
+      title: "indexOf throws error for undefined element",
+      test: () => {
+        let set = new Set();
+
+        expectException(() => { set.indexOf(); }, Error);
+      },
+    },
+    {
+      title: "indexOf throws error for argument not derived from Element",
+      test: () => {
+        let set = new Set();
+
+        expectException(() => { set.indexOf(new Error()); }, Error);
+      },
+    },
+    {
+      title: "indexOf fails to find non-existant element",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
+
+        expect(set.indexOf(Instruments.Claves), -1);
+      },
+    },
+    {
+      title: "indexOf fails for empty set",
+      test: () => {
+        let set = new InstrumentSet();
+
+        expect(set.indexOf(Instruments.Bass1), -1);
+      },
+    },
+    {
+      title: "indexOf succeeds for element in the set",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
+
+        expect(set.indexOf(Instruments.Snare), 0);
+        expect(set.indexOf(Instruments.Bass1), 1);
+      },
+    },
+    {
+      title: "indexOf fails for element in the set prior to after",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
+
+        expect(set.indexOf(Instruments.Snare, 0), -1);
+      },
+    },
+    {
+      title: "indexOf succeeds for element in the set later than after",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
+
+        expect(set.indexOf(Instruments.Bass1, 0), 1);
+      },
+    },
+    {
+      title: "indexOf fails if after >= size-1",
+      test: () => {
+        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
+
+        expect(set.size === 2, true);
+        expect(set.indexOf(Instruments.Snare, 1), -1);
+        expect(set.indexOf(Instruments.Bass1, 1), -1);
+        expect(set.indexOf(Instruments.Bass1, 2), -1);
+        expect(set.indexOf(Instruments.Bass1, 3), -1);
+      },
+    },
+
+  ],
+}