discombobulator 1.0.1 → 1.0.2

package/src/test/schedule.mjs

@@ -1,275 +0,0 @@
-// schedule.mjs
-//
-// Tests for schedule.mjs.
-
-import { expect } from './testing.mjs'
-
-import { Schedule } from '../schedule.mjs'
-import { Pattern } from '../pattern.mjs'
-import { PatternSet } from '../patternset.mjs'
-
-export const test = {
-  tests: [ 
-    {
-      title: "default constructor results in undefined symbol",
-      test: () => {
-        const set = new Schedule();
-
-        expect(set.isAbstract, false);
-        expect(set.allowDuplicates, true);
-        expect(set.size, 0);
-      },
-    },
-    
-    {
-      title: "length returns correct length when empty",
-      test: () => {
-        const set = new Schedule();
-
-        expect(set.length, 0);
-      },
-    },
-    {
-      title: "length returns correct length with one pattern",
-      test: () => {
-        const set = new Schedule({
-          add: new Pattern()
-        });
-
-        expect(set.length, 1);
-      },
-    },
-    {
-      title: "length returns correct length with two patterns",
-      test: () => {
-        const set = new Schedule({
-          add: [ new Pattern(), new Pattern() ]
-        });
-
-        expect(set.length, 2);
-      },
-    },
-    {
-      title: "length returns correct length with one pattern set containing no patterns",
-      test: () => {
-        const set = new Schedule({
-          add: new PatternSet()
-        });
-
-        expect(set.length, 0);
-      },
-    },
-    {
-      title: "length returns correct length with one pattern set containing one pattern",
-      test: () => {
-        const set = new Schedule({
-          add: new PatternSet({
-            add: new Pattern()
-          })
-        });
-
-        expect(set.length, 1);
-      },
-    },
-    {
-      title: "length returns correct length with one pattern set containing two patterns",
-      test: () => {
-        const set = new Schedule({
-          add: new PatternSet({
-            add: [ new Pattern(), new Pattern() ],
-            allowDuplicates: true // To make things a little easier for testing
-          })
-        });
-
-        expect(set.length, 2);
-      },
-    },
-    {
-      title: "length returns correct length with one pattern and one pattern set containing no patterns",
-      test: () => {
-        const set = new Schedule({
-          add: [ new Pattern(), new PatternSet()]
-        });
-
-        expect(set.length, 1);
-      },
-    },
-    {
-      title: "length returns correct length with one pattern and one pattern set containing one pattern",
-      test: () => {
-        const set = new Schedule({
-          add: [ new Pattern(), new PatternSet({
-            add: [ new Pattern() ]
-          })]
-        });
-
-        expect(set.length, 2);
-      },
-    },
-    {
-      title: "length returns correct length with two pattern sets",
-      test: () => {
-        const set = new Schedule({
-          add: [ new PatternSet({
-            add: [ new Pattern(), new Pattern() ],
-            allowDuplicates: true
-          }),
-          new PatternSet({
-            add: [ new Pattern(), new Pattern() ],
-            allowDuplicates: true
-          }),
-        ]
-        });
-
-        expect(set.length, 4);
-      },
-    },
-
-    {
-      title: "patterns yields nothing when empty",
-      test: () => {
-        const set = new Schedule();
-
-        let count = 0;
-
-        for (let pattern of set.patterns) {
-          ++count;
-        }
-
-        expect(count, 0);
-      },
-    },
-    {
-      title: "patterns yields correct patterns with one pattern",
-      test: () => {
-        const patterns = [ new Pattern() ];
-        const set = new Schedule({ add: patterns });
-
-        let count = 0;
-
-        for (let pattern of set.patterns) {
-          expect(pattern === patterns[count], true);
-          ++count;
-        }
-
-        expect(count, 1);
-      },
-    },
-    {
-      title: "patterns yields correct patterns with two patterns",
-      test: () => {
-        const patterns = [ new Pattern(), new Pattern() ];
-        const set = new Schedule({ add: patterns });
-
-        let count = 0;
-
-        for (let pattern of set.patterns) {
-          expect(pattern === patterns[count], true);
-          ++count;
-        }
-
-        expect(count, 2);
-      },
-    },
-    {
-      title: "patterns yields correct patterns with one pattern set containing no patterns",
-      test: () => {
-        const patterns = [ new PatternSet() ];
-        const set = new Schedule({ add: patterns });
-
-        let count = 0;
-
-        for (let pattern of set.patterns) {
-          ++count;
-        }
-
-        expect(count, 0);
-      },
-    },
-    {
-      title: "patterns yields correct patterns with one pattern set containing one pattern",
-      test: () => {
-        const patterns = [ new PatternSet({
-          add: new Pattern()
-        }) ];
-        const set = new Schedule({ add: patterns });
-
-        let count = 0;
-
-        for (let pattern of set.patterns) {
-          expect(pattern === patterns[0].elementAt(count), true);
-          ++count;
-        }
-
-        expect(count, 1);
-      },
-    },
-    {
-      title: "patterns yields correct patterns with one pattern set containing two patterns",
-      test: () => {
-        const patterns = [ new PatternSet({
-          add: [ new Pattern(), new Pattern() ],
-          allowDuplicates: true,
-        }) ];
-        const set = new Schedule({ add: patterns });
-
-        let count = 0;
-
-        for (let pattern of set.patterns) {
-          expect(pattern === patterns[0].elementAt(count), true);
-          ++count;
-        }
-
-        expect(count, 2);
-      },
-    },
-    {
-      title: "patterns yields correct patterns with two pattern sets containing one pattern each",
-      test: () => {
-        const patterns = [
-          new PatternSet({
-            add: [ new Pattern() ]
-          }),
-          new PatternSet({
-            add: [ new Pattern() ]
-          })
-        ];
-        const set = new Schedule({ add: patterns });
-
-        let count = 0;
-
-        for (let pattern of set.patterns) {
-          expect(pattern === patterns[count].elementAt(0), true);
-          ++count;
-        }
-
-        expect(count, 2);
-      },
-    },
-    {
-      title: "patterns yields correct patterns with two pattern sets containing two patterns each",
-      test: () => {
-        const patterns = [
-          new PatternSet({
-            add: [ new Pattern(), new Pattern() ],
-            allowDuplicates: true,
-          }),
-          new PatternSet({
-            add: [ new Pattern(), new Pattern() ],
-            allowDuplicates: true,
-          })
-        ];
-        const set = new Schedule({ add: patterns });
-
-        let count = 0;
-
-        for (let pattern of set.patterns) {
-          expect(pattern === patterns[count >> 1].elementAt(count % 2), true);
-          ++count;
-        }
-
-        expect(count, 4);
-      },
-    },
-  ],
-}

package/src/test/schema.mjs

@@ -1,333 +0,0 @@
-// schema.mjs
-//
-// Tests for schema.mjs.
-
-import { expect } from "./testing.mjs";
-
-import { Schema } from "../schema.mjs";
-import { Schedule } from "../schedule.mjs";
-import { Pattern } from "../pattern.mjs";
-import { Instruments } from "../instrument.mjs";
-import { Chord } from "../chord.mjs";
-
-export const test = {
-  tests: [
-    {
-      title: "default constructor results in undefined symbol",
-      test: () => {
-        const set = new Schedule();
-
-        expect(set.isAbstract, false);
-        expect(set.allowDuplicates, true);
-        expect(set.size, 0);
-      },
-    },
-
-    {
-      title: "length returns correct length with when empty",
-      test: () => {
-        const set = new Schema({
-          add: new Schedule(),
-        });
-
-        expect(set.length, 0);
-      },
-    },
-    {
-      title: "length returns correct length with a single-pattern schedule",
-      test: () => {
-        const set = new Schema({
-          add: new Schedule({
-            add: new Pattern(),
-          }),
-        });
-
-        expect(set.size, 1);
-        expect(set.length, 1);
-      },
-    },
-    {
-      title: "length returns correct length with two one-pattern schedules",
-      test: () => {
-        const set = new Schema({
-          add: [
-            new Schedule({
-              add: new Pattern(),
-            }),
-            new Schedule({
-              add: new Pattern(),
-            }),
-          ],
-        });
-
-        expect(set.size, 2);
-        expect(set.length, 1);
-      },
-    },
-    {
-      title: "length returns correct length with two two-pattern schedules",
-      test: () => {
-        const set = new Schema({
-          add: [
-            new Schedule({
-              add: [new Pattern(), new Pattern()],
-            }),
-            new Schedule({
-              add: [new Pattern(), new Pattern()],
-            }),
-          ],
-        });
-
-        expect(set.size, 2);
-        expect(set.length, 4);
-      },
-    },
-
-    {
-      title: "expressions yields nothing when empty",
-      test: () => {
-        const set = new Schema();
-
-        let count = 0;
-
-        for (let expression of set.expressions) {
-          ++count;
-        }
-
-        expect(count, 0);
-      },
-    },
-    {
-      title:
-        "expressions yields nothing with one schedule containing no patterns",
-      test: () => {
-        const set = new Schema({
-          add: new Schedule(),
-        });
-
-        let count = 0;
-
-        for (let expression of set.expressions) {
-          ++count;
-        }
-
-        expect(count, 0);
-      },
-    },
-    {
-      title:
-        "expressions yields correct results with one schedule containing one pattern",
-      test: () => {
-        const chords = [
-          [
-            new Chord({ add: Instruments.Snare }),
-            new Chord({ add: Instruments.Bass1 }),
-          ],
-        ];
-
-        const set = new Schema({
-          add: new Schedule({
-            add: [
-              new Pattern({
-                add: chords[0],
-              }),
-            ],
-          }),
-        });
-
-        let expressionCount = 0;
-
-        for (let expression of set.expressions) {
-          let chordCount = 0;
-
-          for (let { chord, duration } of expression) {
-            expect(chord === chords[expressionCount][chordCount], true);
-
-            ++chordCount;
-          }
-
-          expect(chordCount, 2);
-
-          ++expressionCount;
-        }
-
-        expect(expressionCount, 1);
-      },
-    },
-    {
-      title:
-        "expressions yields correct results with one schedule containing two patterns",
-      test: () => {
-        const chords = [
-          [
-            new Chord({ add: Instruments.Snare }),
-            new Chord({ add: Instruments.Bass1 }),
-          ],
-          [
-            new Chord({ add: Instruments.Claves }),
-            new Chord({ add: Instruments.Crash }),
-          ],
-        ];
-
-        const set = new Schema({
-          add: new Schedule({
-            add: [
-              new Pattern({
-                add: chords[0],
-              }),
-              new Pattern({
-                add: chords[1],
-              }),
-            ],
-          }),
-        });
-
-        let expressionCount = 0;
-
-        for (let expression of set.expressions) {
-          let chordCount = 0;
-
-          for (let { chord, duration } of expression) {
-            expect(chord === chords[expressionCount][chordCount], true);
-
-            ++chordCount;
-          }
-
-          expect(chordCount, 2);
-
-          ++expressionCount;
-        }
-
-        expect(expressionCount, 2);
-      },
-    },
-    {
-      title:
-        "expressions yields correct results with two schedules containing one pattern each",
-      test: () => {
-        const chords = [
-          [
-            new Chord({ add: Instruments.Snare }),
-            new Chord({ add: Instruments.Bass1 }),
-          ],
-          [
-            new Chord({ add: Instruments.Claves }),
-            new Chord({ add: Instruments.Crash }),
-          ],
-        ];
-
-        const set = new Schema({
-          add: [
-            new Schedule({
-              add: [
-                new Pattern({
-                  add: chords[0],
-                }),
-              ],
-            }),
-            new Schedule({
-              add: [
-                new Pattern({
-                  add: chords[1],
-                }),
-              ],
-            }),
-          ],
-        });
-
-        let expressionCount = 0;
-
-        for (let expression of set.expressions) {
-          let chordCount = 0;
-
-          for (let { chord, duration } of expression) {
-            expect(
-              chord === chords[Math.floor(chordCount / 2)][chordCount % 2],
-              true
-            );
-
-            ++chordCount;
-          }
-
-          expect(chordCount, 4);
-
-          ++expressionCount;
-        }
-
-        expect(expressionCount, 1);
-      },
-    },
-    {
-      title:
-        "expressions yields correct results with two schedules containing two patterns each",
-      test: () => {
-        const chords = [
-          [
-            new Chord({ add: Instruments.Snare }),
-            new Chord({ add: Instruments.Bass1 }),
-          ],
-          [
-            new Chord({ add: Instruments.Claves }),
-            new Chord({ add: Instruments.Crash }),
-          ],
-          [
-            new Chord({ add: Instruments.Casaba}),
-            new Chord({ add: Instruments.China }),
-          ],
-          [
-            new Chord({ add: Instruments.HandClap }),
-            new Chord({ add: Instruments.HighHat }),
-          ],
-        ];
-
-        const set = new Schema({
-          add: [
-            new Schedule({
-              add: [
-                new Pattern({
-                  add: chords[0],
-                }),
-                new Pattern({
-                  add: chords[1],
-                }),
-              ],
-            }),
-            new Schedule({
-              add: [
-                new Pattern({
-                  add: chords[2],
-                }),
-                new Pattern({
-                  add: chords[3],
-                }),
-              ],
-            }),
-          ],
-        });
-
-        let expressionCount = 0;
-
-        for (let expression of set.expressions) {
-          let chordCount = 0;
-
-          for (let { chord, duration } of expression) {
-            const index = chordCount < 2 ? Math.floor(expressionCount / 2) : expressionCount % 2 + 2;
-
-            expect(
-              chord === chords[index][chordCount % 2],
-              true
-            );
-
-            ++chordCount;
-          }
-
-          expect(chordCount, 4);
-
-          ++expressionCount;
-        }
-
-        expect(expressionCount, 4);
-      },
-    },
-  ],
-};