discombobulator 1.0.0 → 1.0.2

package/src/test/note.mjs

@@ -1,367 +0,0 @@
-// articulationset.mjs
-//
-// Tests for articulationset.mjs.
-
-import { expect, expectException } from './testing.mjs'
-
-import { Instruments } from '../instrument.mjs'
-import { Articulations } from '../articulation.mjs'
-import { ArticulationSet } from '../articulationset.mjs'
-import { Note } from '../note.mjs'
-
-export const test = {
-  tests: [ 
-    {
-      title: "default constructor results in correct set",
-      test: () => {
-        let note = new Note();
-
-        expect(note.instrument === undefined, true);
-        expect(note.articulations === undefined, true);
-      },
-    },
-    {
-      title: "constructor correctly constructs from instrument",
-      test: () => {
-        let note = new Note({ add: Instruments.Snare });
-
-        expect(note.instrument === Instruments.Snare, true);
-        expect(note.articulations === undefined, true);
-      },
-    },
-    {
-      title: "constructor correctly constructs from articulation set",
-      test: () => {
-        const articulations = new ArticulationSet({ add: [ Articulations.Accent, Articulations.Fermata ] });
-        let note = new Note({ add: [ undefined, articulations ] });
-
-        expect(note.instrument === undefined, true);
-        expect(note.articulations === articulations, true);
-      },
-    },
-    {
-      title: "constructor correctly constructs from instrument and articulation set",
-      test: () => {
-        const articulations = new ArticulationSet({ add: [ Articulations.Accent, Articulations.Fermata ] });
-        let note = new Note({ add: [ Instruments.Snare, articulations ] });
-
-        expect(note.instrument === Instruments.Snare, true);
-        expect(note.articulations === articulations, true);
-      },
-    },
-    {
-      title: "constructor correctly constructs from instrument and articulation (promoted to set)",
-      test: () => {
-        let note = new Note({ add: [ Instruments.Snare, Articulations.Accent ] });
-
-        expect(note.instrument === Instruments.Snare, true);
-        expect(note.articulations instanceof ArticulationSet, true);
-        expect(note.articulations.size, 1);
-        expect(note.articulations.elementAt(0) === Articulations.Accent, true);
-      },
-    },
-    {
-      title: "constructor throws error if instrument wrong type",
-      test: () => {
-        let note;
-        
-        expectException(() => { note = new Note({ add: Articulations.Accent }); }, Error);
-      },
-    },
-    {
-      title: "constructor throws error if articulation set wrong type",
-      test: () => {
-        let note;
-        
-        expectException(() => { note = new Note({ add: [ undefined, new Error() ] }); }, Error);
-      },
-    },
-
-    {
-      title: "clone correctly clones note (shallow)",
-      test: () => {
-        const articulations = new ArticulationSet({ add: [ Articulations.Accent, Articulations.Fermata ] });
-        const note = new Note({ add: [ Instruments.Snare, articulations ] });
-
-        let other = note.clone(false);
-
-        expect(other !== note, true);
-        expect(other.instrument === Instruments.Snare, true);
-        expect(other.articulations === articulations, true);
-      },
-    },
-    {
-      title: "clone correctly clones note (deep)",
-      test: () => {
-        const articulations = new ArticulationSet({ add: [ Articulations.Accent, Articulations.Fermata ] });
-        const note = new Note({ add: [ Instruments.Snare, articulations ] });
-
-        let other = note.clone(true);
-
-        expect(other !== note, true);
-        expect(other.instrument === Instruments.Snare, true);
-        expect(other.articulations !== articulations, true);
-      },
-    },
-
-    {
-      title: "elementAt returns instrument at 0",
-      test: () => {
-        const note = new Note({ add: Instruments.Snare });
-
-        expect(note.elementAt(0) === Instruments.Snare, true);
-      },
-    },
-    {
-      title: "elementAt returns articulation set at 1",
-      test: () => {
-        const articulations = new ArticulationSet({ add: [ Articulations.Accent, Articulations.Fermata ] });
-        const note = new Note({ add: [ undefined, articulations ] });
-
-        expect(note.elementAt(1) === articulations, true);
-      },
-    },
-
-    {
-      title: "promote returns argument if passed another note",
-      test: () => {
-        const note = new Note();
-
-        expect((new Note()).promote(note) === note, true);
-      },
-    },
-    {
-      title: "promote correctly promotes instrument",
-      test: () => {
-        const note = new Note();
-
-        expect(note.promote(Instruments.Snare) === note, true);
-        expect(note.instrument === Instruments.Snare, true);
-        expect(note.articulations === undefined, true);
-      },
-    },
-    {
-      title: "promote correctly promotes articulation set",
-      test: () => {
-        const articulations = new ArticulationSet({ add: [ Articulations.Accent, Articulations.Fermata ] });
-        const note = new Note();
-
-        expect(note.promote(articulations) === note, true);
-        expect(note.instrument === undefined, true);
-        expect(note.articulations === articulations, true);
-      },
-    },
-    {
-      title: "promote correctly promotes articulation",
-      test: () => {
-        const note = new Note();
-
-        expect(note.promote(Articulations.Accent) === note, true);
-        expect(note.instrument === undefined, true);
-        expect(note.articulations !== undefined, true);
-        expect(note.articulations.elementAt(0) === Articulations.Accent, true);
-      },
-    },
-    {
-      title: "promote returns undefined for unknown promotion",
-      test: () => {
-        const note = new Note();
-
-        expect(note.promote(Error) === undefined, true);
-        expect(note.instrument === undefined, true);
-        expect(note.articulations === undefined, true);
-      },
-    },
-
-    {
-      title: "isEqual fails comparing note with not-note",
-      test: () => {
-        const note = new Note();
-
-        expect(note.isEqual(Instruments.Snare), false);
-      },
-    },
-    {
-      title: "isEqual succeeds comparing undefined notes (loose)",
-      test: () => {
-        const note = new Note();
-
-        expect(note.isEqual(new Note(), false), true);
-      },
-    },
-    {
-      title: "isEqual succeeds comparing undefined notes (strict)",
-      test: () => {
-        const note = new Note();
-
-        expect(note.isEqual(new Note(), true), true);
-      },
-    },
-    {
-      title: "isEqual succeeds comparing notes with same instrument and no articulations (loose)",
-      test: () => {
-        const note = new Note({ add: Instruments.Snare });
-
-        expect(note.isEqual(new Note({ add: Instruments.Snare }), false), true);
-      },
-    },
-    {
-      title: "isEqual succeeds comparing notes with same instrument and no articulations (strict)",
-      test: () => {
-        const note = new Note({ add: Instruments.Snare });
-
-        expect(note.isEqual(new Note({ add: Instruments.Snare }), true), true);
-      },
-    },
-    {
-      title: "isEqual fails comparing notes with different instrument and no articulations (loose)",
-      test: () => {
-        const note = new Note({ add: Instruments.Snare });
-
-        expect(note.isEqual(new Note({ add: Instruments.Bass1 }), false), false);
-      },
-    },
-    {
-      title: "isEqual fails comparing notes with different instrument and no articulations (strict)",
-      test: () => {
-        const note = new Note({ add: Instruments.Snare });
-
-        expect(note.isEqual(new Note({ add: Instruments.Bass1 }), true), false);
-      },
-    },
-    {
-      title: "isEqual succeeds comparing notes with no instrument and same articulations (loose)",
-      test: () => {
-        const articulations = new ArticulationSet({ add: [ Articulations.Accent, Articulations.Fermata ] });
-        const note = new Note({ add: [ undefined, articulations] });
-
-        expect(note.isEqual(new Note({ add: [ undefined, articulations ] }), false), true);
-      },
-    },
-    {
-      title: "isEqual succeeds comparing notes with no instrument and same articulations (strict)",
-      test: () => {
-        const articulations = new ArticulationSet({ add: [ Articulations.Accent, Articulations.Fermata ] });
-        const note = new Note({ add: [ undefined, articulations] });
-
-        expect(note.isEqual(new Note({ add: [ undefined, articulations ] }), true), true);
-      },
-    },
-    {
-      title: "isEqual succeeds comparing notes with same instrument and same articulations (loose)",
-      test: () => {
-        const articulations = new ArticulationSet({ add: [ Articulations.Accent, Articulations.Fermata ] });
-        const note = new Note({ add: [ Instruments.Snare, articulations] });
-
-        expect(note.isEqual(new Note({ add: [ Instruments.Snare, articulations ] }), false), true);
-      },
-    },
-    {
-      title: "isEqual succeeds comparing notes with same instrument and same articulations (strict)",
-      test: () => {
-        const articulations = new ArticulationSet({ add: [ Articulations.Accent, Articulations.Fermata ] });
-        const note = new Note({ add: [ Instruments.Snare, articulations] });
-
-        expect(note.isEqual(new Note({ add: [ Instruments.Snare, articulations ] }), true), true);
-      },
-    },
-    {
-      title: "isEqual succeeds comparing notes with same instrument and different articulations (loose)",
-      test: () => {
-        const articulations = new ArticulationSet({ add: [ Articulations.Accent, Articulations.Fermata ] });
-        const note = new Note({ add: [ Instruments.Snare, articulations] });
-
-        expect(note.isEqual(new Note({ add: [ Instruments.Snare, articulations ] }), false), true);
-      },
-    },
-    {
-      title: "isEqual fails comparing notes with same instrument and different articulations (strict)",
-      test: () => {
-        const note = new Note(
-          { add: [ 
-            Instruments.Snare, 
-            new ArticulationSet({ add: [ Articulations.Accent, Articulations.Fermata ] })
-          ] }
-        );
-
-        expect(
-          note.isEqual(
-            new Note(
-              { add: [ 
-                Instruments.Snare, 
-                new ArticulationSet({ add: [ Articulations.Accent, Articulations.Staccato ] }) 
-              ] }
-            ), 
-            true
-          ), 
-          false
-        );
-      },
-    },
-
-    {
-      title: "merge throws error if passed non-note",
-      test: () => {
-        const note = new Note();
-
-        expectException(() => { note.merge(Instruments.Snare)}, Error);
-      },
-    },
-    {
-      title: "merge throws error if instruments don't match",
-      test: () => {
-        const note = new Note({ add: Instruments.Snare });
-
-        expectException(() => { note.merge(new Note({ add: Instruments.Bass1 }))}, Error);
-      },
-    },
-    {
-      title: "merge correctly merges if neither note has articulations",
-      test: () => {
-        const note = new Note({ add: Instruments.Snare });
-
-        expect(note.merge(new Note({ add: Instruments.Snare })), (result) => { return result === note; });
-        expect(note.instrument === Instruments.Snare, true);
-        expect(note.articulations === undefined, true);
-      },
-    },
-    {
-      title: "merge correctly merges if target has no articulations",
-      test: () => {
-        const note = new Note({ add: Instruments.Snare });
-
-        expect(note.merge(new Note({ add: [ Instruments.Snare, Articulations.Accent ] })), (result) => { return result === note; });
-        expect(note.instrument === Instruments.Snare, true);
-        expect(note.articulations !== undefined, true);
-        expect(note.articulations.elementAt(0) === Articulations.Accent, true);
-      },
-    },
-    {
-      title: "merge correctly merges if source has no articulations",
-      test: () => {
-        const note = new Note({ add: [ Instruments.Snare, Articulations.Accent ] });
-
-        expect(note.merge(new Note({ add: Instruments.Snare })), (result) => { return result === note; });
-        expect(note.instrument === Instruments.Snare, true);
-        expect(note.articulations !== undefined, true);
-        expect(note.articulations.elementAt(0) === Articulations.Accent, true);
-      },
-    },
-    {
-      title: "merge correctly merges if source and target have articulations",
-      test: () => {
-        const articulations = new ArticulationSet({ add: [ Articulations.Accent, Articulations.Fermata ] });
-        const note = new Note({ add: [ Instruments.Snare, articulations ] });
-
-        expect(note.merge(new Note({ add: [ Instruments.Snare, new ArticulationSet({ add: [ Articulations.Staccato, Articulations.Accent ] }) ] })), (result) => { return result === note; });
-        expect(note.instrument === Instruments.Snare, true);
-        expect(note.articulations !== undefined, true);
-        expect(note.articulations.size, 3);
-        expect(note.articulations.elementAt(0) === Articulations.Accent, true);
-        expect(note.articulations.elementAt(1) === Articulations.Fermata, true);
-        expect(note.articulations.elementAt(2) === Articulations.Staccato, true);
-      },
-    },
-
-  ],
-}

package/src/test/noteset.mjs

@@ -1,43 +0,0 @@
-// noteset.mjs
-//
-// Tests for noteset.mjs.
-
-import { expect, expectException } from './testing.mjs'
-
-import { NoteSet } from '../noteset.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 NoteSet();
-
-        expect(set.isAbstract, false);
-        expect(set.allowDuplicates, false);
-        expect(set.size, 0);
-      },
-    },
-    {
-      title: "add throws error when adding non-note",
-      test: () => {
-        let set = new NoteSet();
-        let element = new Group(1, 1);
-
-        expectException(() => { set.add(element); }, Error);
-      },
-    },
-    {
-      title: "add succeeds adding note",
-      test: () => {
-        let set = new NoteSet();
-        let element = new Note();
-
-        expect(set.add(element), (result) => { return result === set; });
-      },
-    },
-
-  ],
-}

package/src/test/operator.mjs

@@ -1,63 +0,0 @@
-// operator.mjs
-//
-// Tests for operator.mjs.
-
-import { expect, expectException } from "./testing.mjs";
-
-import { Set } from "../set.mjs";
-import { Instruments } from "../instrument.mjs";
-import { InstrumentSet } from "../instrumentset.mjs";
-import { ArticulationSet } from "../articulationset.mjs";
-
-export const test = {
-  tests: [
-    {
-      title: "default constructor results in correct set",
-      test: () => {
-        let operator = new Set.Operator();
-
-        expect(operator.isAbstract, true);
-      },
-    },
-
-    {
-      title:
-        "size throws error (Operator not derived)",
-      test: () => {
-        const set1 = new InstrumentSet();
-        const set2 = new InstrumentSet();
-
-        const operator = new Set.Operator(set1, set2);
-
-        expectException(() => operator.size, Error);
-      },
-    },
-
-    {
-      title:
-        "elementAt throws error because size throws",
-      test: () => {
-        const set1 = new InstrumentSet();
-        const set2 = new InstrumentSet();
-
-        const operator = new Set.Operator(set1, set2);
-
-        expectException(() => operator.elementAt(0), Error);
-      },
-    },
-
-    {
-      title:
-        "has throws error (Operator not derived)",
-      test: () => {
-        const set1 = new InstrumentSet();
-        const set2 = new InstrumentSet();
-
-        const operator = new Set.Operator(set1, set2);
-
-        expectException(() => operator.has(), Error);
-      },
-    },
-
-  ],
-};

package/src/test/pattern.mjs

@@ -1,113 +0,0 @@
-// pattern.mjs
-//
-// Tests for pattern.mjs.
-
-import { expect, expectException } from "./testing.mjs";
-
-import { Pattern } from "../pattern.mjs";
-import { Instruments } from "../instrument.mjs";
-import { Chord } from "../chord.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 Pattern();
-
-        expect(set.isAbstract, false);
-        expect(set.allowDuplicates, true);
-        expect(set.size, 0);
-      },
-    },
-    {
-      title: "add throws error when adding non-pattern",
-      test: () => {
-        let set = new Pattern();
-        let element = new Group(1, 1);
-
-        expectException(() => {
-          set.add(element);
-        }, Error);
-      },
-    },
-    {
-      title: "add succeeds adding note",
-      test: () => {
-        let set = new Pattern();
-        let element = new Note();
-
-        expect(set.add(element), (result) => {
-          return result === set;
-        });
-      },
-    },
-
-    {
-      title:
-        "isEqual fails when compared with pattern with different numbers of chords",
-      test: () => {
-        const pattern = new Pattern({ 
-          add: new Chord({ add: [Instruments.Snare] }) 
-        });
-        const other = new Pattern({ 
-          add: [
-            new Chord({add: Instruments.Snare}), 
-            new Chord({add: Instruments.Bass1})
-          ] 
-        });
-
-        expect(pattern.isEqual(other), false);
-      },
-    },
-    {
-      title:
-        "isEqual succeeds when comparing chords with same chord",
-      test: () => {
-        const pattern = new Pattern({ 
-          add: new Chord({ add: [Instruments.Snare] }) 
-        });
-        const other = new Pattern({ 
-          add: new Chord({ add: [Instruments.Snare] }) 
-        });
-
-        expect(pattern.isEqual(other), true);
-      },
-    },
-    {
-      title:
-        "isEqual succeeds when comparing chords with same chords",
-      test: () => {
-        const pattern = new Pattern({ 
-          add: new Chord({ add: [Instruments.Snare] }),
-          add: new Chord({ add: [Instruments.Bass1] }) 
-        });
-        const other = new Pattern({ 
-          add: new Chord({ add: [Instruments.Snare] }),
-          add: new Chord({ add: [Instruments.Bass1] }) 
-        });
-
-        expect(pattern.isEqual(other), true);
-      },
-    },
-    {
-      title:
-        "isEqual fails when comparing chords with same chords but different order",
-      test: () => {
-        const pattern = new Pattern({ 
-          add: new Chord({ add: [Instruments.Bass1] }),
-          add: new Chord({ add: [Instruments.Snare] }) 
-        });
-        const other = new Pattern({ 
-          add: new Chord({ add: [Instruments.Snare] }),
-          add: new Chord({ add: [Instruments.Bass1] }) 
-        });
-
-        expect(pattern.isEqual(other), false);
-      },
-    },
-
-  ],
-};

package/src/test/patternset.mjs

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

package/src/test/patternsource.mjs

@@ -1,43 +0,0 @@
-// patternsource.mjs
-//
-// Tests for patternsource.mjs.
-
-import { expect, expectException } from './testing.mjs'
-
-import { PatternSource } from '../patternsource.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 PatternSource();
-
-        expect(set.isAbstract, false);
-        expect(set.allowDuplicates, false);
-        expect(set.size, 0);
-      },
-    },
-    {
-      title: "add throws error when adding non-note",
-      test: () => {
-        let set = new PatternSource();
-        let element = new Group(1, 1);
-
-        expectException(() => { set.add(element); }, Error);
-      },
-    },
-    {
-      title: "add succeeds adding note",
-      test: () => {
-        let set = new PatternSource();
-        let element = new Note();
-
-        expect(set.add(element), (result) => { return result === set; });
-      },
-    },
-
-  ],
-}