discombobulator 1.0.0 → 1.0.2

package/src/test/irregulargroupset.mjs

@@ -1,461 +0,0 @@
-// irregulargroupset.mjs
-//
-// Tests for irregulargroupset.mjs.
-
-import { expect, expectException } from "./testing.mjs";
-
-import { bitCount } from "../util.mjs";
-
-import { combinations, ithBinaryCombination } from "../permute.mjs";
-
-import { IrregularGroupSet } from "../irregulargroupset.mjs";
-import { Group } from "../group.mjs";
-
-const quickIteratorTestGroupSizeMax = 20;
-const quickElementAtTestGroupSizeMax = 20;
-const quickHasTestGroupSizeMax = 20;
-
-function testIterator(groupSizeMax) {
-  const actualMax = (groupSet, length) => {
-    return Math.max(
-      groupSet.min,
-      groupSet.max === undefined
-        ? length
-        : groupSet.reverseMax
-        ? length - groupSet.max
-        : Math.min(length, groupSet.max)
-    );
-  };
-
-  for (let stepping = 1; stepping <= Group.MAX_LENGTH; ++stepping) {
-    const set = new IrregularGroupSet({
-      start: 1,
-      end: groupSizeMax,
-      step: 1,
-      min: 1,
-      max: undefined,
-      stepping: stepping,
-    });
-
-    let size = 0;
-
-    for (let length = set.start; length <= set.end; length += set.step) {
-      let max = actualMax(set, length);
-
-      for (let active = set.min; active <= max; active += set.stepping) {
-        size += combinations(length, active);
-      }
-    }
-
-    expect(set.size, size);
-
-    let length = set.start;
-    let active = set.min;
-    let index = 0;
-    let test;
-    let count = 0;
-
-    let max = actualMax(set, length);
-
-    for (let group of set) {
-      test = ithBinaryCombination(length, active, index++);
-
-      while (test === undefined) {
-        active += set.stepping;
-        index = 0;
-
-        if (active > max) {
-          length += set.step;
-
-          if (length > set.end) {
-            break;
-          }
-
-          max = actualMax(set, length);
-          active = set.min;
-        }
-
-        test = ithBinaryCombination(length, active, index++);
-      }
-
-      if (length > set.end) {
-        break;
-      }
-
-      expect(group.group, test);
-
-      ++count;
-    }
-
-    expect(count, set.size);
-  }
-}
-
-function testElementAt(groupSize) {
-  for (let stepping = 1; stepping <= Group.MAX_LENGTH; ++stepping) {
-    const set = new IrregularGroupSet({
-      start: 1,
-      end: groupSize,
-      step: 1,
-      min: 1,
-      max: undefined,
-      stepping: stepping,
-    });
-
-    let index = 0;
-    let elementAt;
-
-    for (let group of set) {
-      elementAt = set.elementAt(index++);
-      expect(elementAt.group === group.group, true);
-    }
-
-    expect(index, set.size);
-  }
-}
-
-function testHas(groupSize) {
-  for (let stepping = 1; stepping < Group.MAX_LENGTH; ++stepping) {
-    let set = new IrregularGroupSet({
-      start: 1,
-      end: groupSize,
-      step: 1,
-      min: 1,
-      max: undefined,
-      stepping: stepping,
-    });
-    let other;
-
-    for (let length = 1; length < set.end; length += set.step) {
-      const upperLimit = 1 << length;
-
-      for (let group = 1; group < upperLimit; ++group) {
-        const active = bitCount(group);
-
-        if (((active-1) % set.stepping) === 0) {
-          other = new Group(group, length);
-
-          expect(set.has(other), true);
-        }
-      }
-    }
-  }
-}
-
-export const test = {
-  tests: [
-    {
-      title: "default constructor results in correct set",
-      test: () => {
-        let set = new IrregularGroupSet();
-
-        expect(set.isAbstract, true);
-        expect(set.allowDuplicates, false);
-        expect(set.size, 1);
-        expect(set.start, 1);
-        expect(set.end, 1);
-        expect(set.step, 1);
-        expect(set.min, 1);
-        expect(() => {
-          return set.max === undefined;
-        }, true);
-        expect(set.stepping, 1);
-        expect(set.reverseMax, false);
-      },
-    },
-    {
-      title: "constructor throws error when min < 1",
-      test: () => {
-        let set;
-
-        expectException(() => {
-          set = new IrregularGroupSet({ min: 0 });
-        }, Error);
-      },
-    },
-    {
-      title: `constructor throws error when max is defined but less than min > ${Group.MAX_LENGTH}`,
-      test: () => {
-        let set;
-
-        expectException(() => {
-          set = new IrregularGroupSet({ min: 2, max: 1 });
-        }, Error);
-      },
-    },
-    {
-      title: "constructor throws error when stepping < 1",
-      test: () => {
-        let set;
-
-        expectException(() => {
-          set = new IrregularGroupSet({ stepping: 0 });
-        }, Error);
-      },
-    },
-    {
-      title: `constructor throws error when stepping > ${Group.MAX_LENGTH}`,
-      test: () => {
-        let set;
-
-        expectException(() => {
-          set = new IrregularGroupSet({ stepping: Group.MAX_LENGTH + 1 });
-        }, Error);
-      },
-    },
-    {
-      title: `constructor succeeds when stepping in [1..${Group.MAX_LENGTH}]`,
-      test: () => {
-        let set;
-
-        for (let value = 1; value <= Group.MAX_LENGTH; ++value) {
-          set = new IrregularGroupSet({ stepping: value });
-          expect(set.stepping, value);
-        }
-      },
-    },
-
-    {
-      title: "clone correctly clones set",
-      test: () => {
-        const set = new IrregularGroupSet({
-          start: 1,
-          end: 2,
-          step: 3,
-          min: 4,
-          max: 5,
-          stepping: 6,
-        });
-        const clone = set.clone();
-
-        expect(clone !== undefined, true);
-        expect(clone.start, 1);
-        expect(clone.end, 2);
-        expect(clone.step, 3);
-        expect(clone.min, 4);
-        expect(clone.max, 5);
-        expect(clone.stepping, 6);
-      },
-    },
-
-    {
-      title: `iterator correctly returns groups with group size in [1..${quickIteratorTestGroupSizeMax}] (Quick)`,
-      test: () => {
-        testIterator(quickIteratorTestGroupSizeMax);
-      },
-    },
-    {
-      title: `iterator correctly returns groups with stepping in [1..${Group.MAX_LENGTH}] (Exhaustive)`,
-      slow: true,
-      test: () => {
-        testIterator(Group.MAX_LENGTH);
-      },
-    },
-
-    {
-      title: "elementAt throws error for index < 0",
-      test: () => {
-        let set = new IrregularGroupSet();
-
-        expectException(() => {
-          set.elementAt(-1);
-        }, Error);
-      },
-    },
-    {
-      title: "elementAt throws error for index higher than set size",
-      test: () => {
-        let set = new IrregularGroupSet({ start: 1, end: 1, step: 1 });
-
-        expect(set.size, 1);
-
-        expectException(() => {
-          set.elementAt(1);
-        }, Error);
-      },
-    },
-    {
-      title: `elementAt correctly returns groups with group size in [1..${quickElementAtTestGroupSizeMax}] (Quick)`,
-      test: () => {
-        testElementAt(quickElementAtTestGroupSizeMax);
-      },
-    },
-    {
-      title: `elementAt correctly returns groups with step in [1..${Group.MAX_LENGTH}] (Exhaustive)`,
-      slow: true,
-      test: () => {
-        testElementAt(Group.MAX_LENGTH);
-      },
-    },
-
-    {
-      title: "has throws error when argument is undefined",
-      test: () => {
-        let set = new IrregularGroupSet();
-
-        expectException(() => {
-          set.has();
-        }, Error);
-      },
-    },
-    {
-      title: "has throws error when argument is not a group",
-      test: () => {
-        let set = new IrregularGroupSet();
-
-        expectException(() => {
-          set.has(Instruments.Snare);
-        }, Error);
-      },
-    },
-    {
-      title: "has fails for group smaller than smallest in set",
-      test: () => {
-        let set = new IrregularGroupSet({ start: 2, end: 2, step: 1 });
-        let other = new Group(1, 1);
-
-        expect(set.has(other), false);
-      },
-    },
-    {
-      title: "has fails for group larger than largest in set",
-      test: () => {
-        let set = new IrregularGroupSet({ start: 2, end: 2, step: 1 });
-        let other = new Group(7, 3);
-
-        expect(set.has(other), false);
-      },
-    },
-    {
-      title: "has fails for group with fewer active chords than exist in set",
-      test: () => {
-        let set = new IrregularGroupSet({
-          start: 2,
-          end: 2,
-          step: 1,
-          min: 2,
-          max: 2,
-          stepping: 1,
-        });
-        let other = new Group(1, 2);
-
-        expect(set.has(other), false);
-      },
-    },
-    {
-      title: "has fails for group with more active chords than exist in set",
-      test: () => {
-        let set = new IrregularGroupSet({
-          start: 3,
-          end: 3,
-          step: 1,
-          min: 2,
-          max: 2,
-          stepping: 1,
-        });
-        let other = new Group(7, 3);
-
-        expect(set.has(other), false);
-      },
-    },
-    {
-      title: "has fails for groups with length missed by step",
-      test: () => {
-        for (let step = 1; step <= Group.MAX_LENGTH; ++step) {
-          let set = new IrregularGroupSet({
-            start: 1,
-            end: Group.MAX_LENGTH,
-            step: step,
-            min: 1,
-            max: undefined,
-            stepping: 1,
-          });
-          let other;
-
-          for (let length = 1; length < set.end; length += set.step) {
-            if (((length-1) % set.step) !== 0) {
-              other = new Group(1, length);
-
-              expect(set.has(other), false);
-            }
-          }
-        }
-      },
-    },
-    {
-      title: "has fails for groups with active chords missed by stepping (Quick)",
-      test: () => {
-        for (let stepping = 2; stepping < Group.MAX_LENGTH; ++stepping) {
-          let set = new IrregularGroupSet({
-            start: 2,
-            end: quickHasTestGroupSizeMax,
-            step: 1,
-            min: 1,
-            max: undefined,
-            stepping: stepping,
-          });
-          let other;
-
-          for (let length = 2; length < set.end; length += set.step) {
-            const upperLimit = 1 << length;
-
-            for (let group = 1; group < upperLimit; ++group) {
-              const active = bitCount(group);
-
-              if (((active-1) % set.stepping) !== 0) {
-                other = new Group(group, length);
-
-                expect(set.has(other), false);
-              }
-            }
-          }
-        }
-      },
-    },
-    {
-      title: "has fails for groups with active chords missed by stepping (Exhaustive)",
-      slow: true,
-      test: () => {
-        for (let stepping = 2; stepping < Group.MAX_LENGTH; ++stepping) {
-          let set = new IrregularGroupSet({
-            start: 2,
-            end: Group.MAX_LENGTH,
-            step: 1,
-            min: 1,
-            max: undefined,
-            stepping: stepping,
-          });
-          let other;
-
-          for (let length = 2; length < set.end; length += set.step) {
-            const upperLimit = 1 << length;
-
-            for (let group = 1; group < upperLimit; ++group) {
-              const active = bitCount(group);
-
-              if (((active-1) % set.stepping) !== 0) {
-                other = new Group(group, length);
-
-                expect(set.has(other), false);
-              }
-            }
-          }
-        }
-      },
-    },
-    {
-      title: "has succeeds for groups with active chords hit by stepping (Quick)",
-      // slow: true,
-      test: () => {
-        testHas(quickHasTestGroupSizeMax);
-      },
-    },
-   {
-      title: "has succeeds for groups with active chords hit by stepping (Exhaustive)",
-      slow: true,
-      test: () => {
-        testHas(Group.MAX_LENGTH);
-      },
-    },
-  ],
-};