discombobulator 1.0.0

package/src/test/rotation.mjs

@@ -0,0 +1,753 @@
+// rotation.mjs
+//
+// Tests for rotation.mjs.
+
+import { expect, expectException } from "./testing.mjs";
+
+import { Element } from "../element.mjs";
+import { Instruments } from "../instrument.mjs";
+import { Set } from "../set.mjs";
+import { InstrumentSet } from "../instrumentset.mjs";
+
+export const test = {
+  tests: [
+    {
+      title: "default constructor throws if setClass invalid",
+      test: () => {
+        let operator;
+
+        expectException(() => (operator = new Set.Rotation()), Error);
+        expectException(() => (operator = new Set.Rotation(5)), Error);
+      },
+    },
+    {
+      title: "default constructor throws if set invalid",
+      test: () => {
+        let operator;
+
+        expectException(
+          () => (operator = new Set.Rotation({ setClass: InstrumentSet })),
+          Error
+        );
+        expectException(
+          () =>
+            (operator = new Set.Rotation({
+              setClass: InstrumentSet,
+              set: new Element(),
+            })),
+          Error
+        );
+      },
+    },
+    {
+      title: "minimal constructor results in correct set",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        let operator = new Set.Rotation(set, InstrumentSet);
+
+        expect(operator.isAbstract, true);
+        expect(operator.allowDuplicates, false);
+        expect(operator.set === set, true);
+        expect(operator.rotateLeft, true);
+      },
+    },
+    {
+      title: "constructor with rotateLeft option results in correct set",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        let operator = new Set.Rotation(set, InstrumentSet, {
+          rotateLeft: false,
+        });
+
+        expect(operator.isAbstract, true);
+        expect(operator.allowDuplicates, false);
+        expect(operator.set === set, true);
+        expect(operator.rotateLeft, false);
+      },
+    },
+
+    {
+      title: "add element fails because rotation is an immutable set",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        let operator = new Set.Rotation(set, InstrumentSet);
+
+        expectException(() => {
+          operator.add(Instruments.Snare);
+        }, Error);
+      },
+    },
+
+    {
+      title: "iterator yields nothing for an empty set",
+      test: () => {
+        let operator = new Set.Rotation(
+          new InstrumentSet(),
+          InstrumentSet,
+        );
+
+        expect(operator.size, 0);
+
+        let count = 0;
+
+        for (const e of operator) {
+          ++count;
+        }
+
+        expect(count, 0);
+      },
+    },
+    {
+      title: "iterator yields correct results for a non-empty set",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+        const size = set.size;
+
+        let operator = new Set.Rotation(set, InstrumentSet);
+
+        expect(size === operator.size, true);
+
+        let offset = 0;
+        let index,
+          count = 0;
+
+        for (const e of operator) {
+          expect(e.size === size, true);
+
+          index = offset;
+          count = 0;
+
+          for (let i of e) {
+            expect(i, (result) => {
+              result = result === set.elements[index];
+              index = (index + 1) % size;
+              return result;
+            });
+
+            ++count;
+          }
+
+          expect(count, 3);
+
+          offset = (offset + 1) % size;
+        }
+      },
+    },
+
+    {
+      title: "size returns correct size with no rotation elements",
+      test: () => {
+        const set = new InstrumentSet();
+
+        let operator = new Set.Rotation(set, InstrumentSet);
+
+        expect(operator.size === 0, true);
+      },
+    },
+    {
+      title: "size returns correct size with a single rotation element",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash],
+        });
+        const size = set.size;
+
+        let operator = new Set.Rotation(set, InstrumentSet);
+
+        expect(operator.size === 1, true);
+      },
+    },
+    {
+      title: "size returns correct size with multiple different elements",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        let operator = new Set.Rotation(set, InstrumentSet);
+
+        expect(operator.size === 3, true);
+      },
+    },
+
+    {
+      title: "has fails when empty",
+      test: () => {
+        const set = new InstrumentSet();
+
+        let operator = new Set.Rotation(set, InstrumentSet);
+
+        expect(operator.size === 0, true);
+        expect(operator.has(new InstrumentSet()), false);
+      },
+    },
+    {
+      title: "has succeeds for element that is in rotation",
+      test: () => {
+        const set1 = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+        const set2 = new InstrumentSet({
+          add: [Instruments.Snare, Instruments.Bass1, Instruments.Crash],
+        });
+        const set3 = new InstrumentSet({
+          add: [Instruments.Bass1, Instruments.Crash, Instruments.Snare],
+        });
+
+        let operator = new Set.Rotation(set1, InstrumentSet);
+
+        expect(operator.size === 3, true);
+        expect(operator.has(set1), true);
+        expect(operator.has(set2), true);
+        expect(operator.has(set3), true);
+      },
+    },
+    {
+      title: "has fails for element that is not in rotation",
+      test: () => {
+        const set1 = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+        const set2 = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass2],
+        });
+
+        let operator = new Set.Rotation(set1, InstrumentSet);
+
+        expect(operator.size === 3, true);
+        expect(operator.has(set2), false);
+      },
+    },
+    {
+      title: "has succeeds for set that is in rotation",
+      test: () => {
+        const set1 = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+        const set2 = new InstrumentSet({
+          add: [Instruments.Snare, Instruments.Bass1, Instruments.Crash],
+        });
+        const set3 = new InstrumentSet({
+          add: [Instruments.Bass1, Instruments.Crash, Instruments.Snare],
+        });
+
+        const subset = new Set({
+          add: [set2, set3],
+          allowedElements: [InstrumentSet],
+        });
+
+        let operator = new Set.Rotation(set1, InstrumentSet);
+
+        expect(operator.size === 3, true);
+        expect(operator.has(subset), true);
+      },
+    },
+    {
+      title: "has fails for other set that is not in rotation",
+      test: () => {
+        const set1 = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+        const set2 = new InstrumentSet({
+          add: [Instruments.Snare, Instruments.Bass1, Instruments.Crash],
+        });
+        const set3 = new InstrumentSet({
+          add: [Instruments.Bass1, Instruments.China, Instruments.Snare],
+        });
+
+        const subset = new Set({
+          add: [set2, set3],
+          allowedElements: [InstrumentSet],
+        });
+
+        let operator = new Set.Rotation(set1, InstrumentSet);
+
+        expect(operator.size === 3, true);
+        expect(operator.has(subset), false);
+      },
+    },
+
+    {
+      title: "indexOf throws error for undefined element",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        let operator = new Set.Rotation(set, InstrumentSet);
+
+        expect(operator.size === 3, true);
+        expectException(() => {
+          operator.indexOf();
+        }, Error);
+      },
+    },
+    {
+      title: "indexOf throws error for argument not derived from Element",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        let operator = new Set.Rotation(set, InstrumentSet);
+
+        expect(operator.size === 3, true);
+        expectException(() => {
+          operator.indexOf(new Error());
+        }, Error);
+      },
+    },
+    {
+      title: "indexOf fails to find non-existant element",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        const other = new InstrumentSet({
+          add: [Instruments.China, Instruments.Snare, Instruments.Bass1],
+        });
+
+        let operator = new Set.Rotation(set, InstrumentSet);
+
+        expect(operator.size === 3, true);
+        expect(operator.indexOf(other), -1);
+      },
+    },
+    {
+      title: "indexOf fails for empty set",
+      test: () => {
+        const set = new InstrumentSet();
+
+        const other = new InstrumentSet({
+          add: [Instruments.China, Instruments.Snare, Instruments.Bass1],
+        });
+
+        let operator = new Set.Rotation(set, InstrumentSet);
+
+        expect(operator.size === 0, true);
+        expect(operator.indexOf(other), -1);
+      },
+    },
+    {
+      title: "indexOf succeeds for element in the set",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        const others = [
+          new InstrumentSet({
+            add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+          }),
+          new InstrumentSet({
+            add: [Instruments.Snare, Instruments.Bass1, Instruments.Crash],
+          }),
+          new InstrumentSet({
+            add: [Instruments.Bass1, Instruments.Crash, Instruments.Snare],
+          }),
+        ];
+
+        let operator = new Set.Rotation(set, InstrumentSet);
+
+        expect(operator.size === 3, true);
+
+        let count = 0;
+
+        for (let other of others) {
+          expect(operator.indexOf(other), count++);
+        }
+
+        expect(count, 3);
+      },
+    },
+    {
+      title: "indexOf fails for element in the set prior to after",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        const other = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        let operator = new Set.Rotation(set, InstrumentSet);
+
+        expect(operator.size === 3, true);
+        expect(operator.indexOf(other, 0), -1);
+      },
+    },
+    {
+      title: "indexOf succeeds for element in the set later than after",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        const other = new InstrumentSet({
+          add: [Instruments.Snare, Instruments.Bass1, Instruments.Crash],
+        });
+
+        let operator = new Set.Rotation(set, InstrumentSet);
+
+        expect(operator.size === 3, true);
+        expect(operator.indexOf(other, 0), 1);
+      },
+    },
+    {
+      title: "indexOf fails if after >= size-1",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        const other = new InstrumentSet({
+          add: [Instruments.China, Instruments.Snare, Instruments.Bass1],
+        });
+
+        let operator = new Set.Rotation(set, InstrumentSet);
+
+        expect(operator.size === 3, true);
+        expect(operator.indexOf(other, 2), -1);
+        expect(operator.indexOf(other, 3), -1);
+      },
+    },
+
+    {
+      title: "elementAt throws error for index < 0",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        let operator = new Set.Rotation(set, InstrumentSet);
+
+        expect(operator.size === 3, true);
+        expectException(() => {
+          operator.elementAt(-1);
+        }, Error);
+      },
+    },
+    {
+      title: "elementAt throws error for empty set",
+      test: () => {
+        const set = new InstrumentSet();
+
+        let operator = new Set.Rotation(set, InstrumentSet);
+
+        expect(operator.size === 0, true);
+        expectException(() => {
+          operator.elementAt(0);
+        }, Error);
+      },
+    },
+    {
+      title: "elementAt throws error for index >= set size",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        const other = new InstrumentSet({
+          add: [Instruments.China, Instruments.Snare, Instruments.Bass1],
+        });
+
+        let operator = new Set.Rotation(set, InstrumentSet);
+
+        expect(operator.size === 3, true);
+        expectException(() => {
+          operator.elementAt(3);
+        }, Error);
+      },
+    },
+    {
+      title: "elementAt succeeds for element in valid index",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        const others = [
+          new InstrumentSet({
+            add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+          }),
+          new InstrumentSet({
+            add: [Instruments.Snare, Instruments.Bass1, Instruments.Crash],
+          }),
+          new InstrumentSet({
+            add: [Instruments.Bass1, Instruments.Crash, Instruments.Snare],
+          }),
+        ];
+
+        let operator = new Set.Rotation(set, InstrumentSet);
+
+        expect(operator.size === 3, true);
+
+        let count = 0;
+
+        for (let other of others) {
+          expect(operator.elementAt(count++), (result) => {
+            return result.isEqual(other);
+          });
+        }
+
+        expect(count, 3);
+      },
+    },
+
+    {
+      title: "clone succeeds on a rotation operator (Shallow)",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        const operator = new Set.Rotation(set, InstrumentSet);
+
+        expect(operator.size === 3, true);
+
+        const clone = operator.clone();
+
+        expect(clone.isAbstract, true);
+        expect(clone.allowDuplicates, false);
+        expect(clone.isStrict, true);
+        expect(clone.setClass === InstrumentSet, true);
+        expect(clone.set === set, true);
+
+        let index = 0;
+
+        for (let e of operator) {
+          expect(e.isEqual(clone.elementAt(index++)), true);
+        }
+      },
+    },
+    {
+      title: "clone succeeds on a rotation operator (Deep)",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        const operator = new Set.Rotation(set, InstrumentSet);
+
+        expect(operator.size === 3, true);
+
+        const clone = operator.clone(true);
+
+        expect(clone.isAbstract, true);
+        expect(clone.allowDuplicates, false);
+        expect(clone.isStrict, true);
+        expect(clone.setClass === InstrumentSet, true);
+        expect(clone.set !== set, true);
+
+        let index = 0;
+
+        for (let e of operator) {
+          expect(e.isEqual(clone.elementAt(index++)), true);
+        }
+      },
+    },
+
+    {
+      title:
+        "isDisjointFrom fails for rotation set that is not disjoint from another set",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        const operator = new Set.Rotation(set, InstrumentSet);
+
+        let other = new Set({
+          add: new InstrumentSet({
+            add: [Instruments.Snare, Instruments.Bass1, Instruments.Crash],
+          }),
+          allowedElements: [InstrumentSet],
+        });
+
+        expect(operator.isDisjointFrom(other), false);
+      },
+    },
+    {
+      title:
+        "isDisjointFrom succeeds for rotation set that is disjoint from another set",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        const operator = new Set.Rotation(set, InstrumentSet);
+
+        let other = new Set({
+          add: new InstrumentSet({
+            add: [Instruments.Snare, Instruments.Bass1, Instruments.Claves],
+          }),
+          allowedElements: [InstrumentSet],
+        });
+
+        expect(operator.isDisjointFrom(other), true);
+      },
+    },
+    {
+      title:
+        "isDisjointFrom fails for a set that is not disjoint from a rotation set",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        const operator = new Set.Rotation(set, InstrumentSet);
+
+        let other = new Set({
+          add: new InstrumentSet({
+            add: [Instruments.Snare, Instruments.Bass1, Instruments.Crash],
+          }),
+          allowedElements: [InstrumentSet],
+        });
+
+        expect(other.isDisjointFrom(operator), false);
+      },
+    },
+    {
+      title:
+        "isDisjointFrom succeeds for a set that is disjoint from a rotation set",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        const operator = new Set.Rotation(set, InstrumentSet);
+
+        let other = new Set({
+          add: new InstrumentSet({
+            add: [Instruments.Snare, Instruments.Bass1, Instruments.Claves],
+          }),
+          allowedElements: [InstrumentSet],
+        });
+
+        expect(other.isDisjointFrom(operator), true);
+      },
+    },
+
+    {
+      title:
+        "isSubsetOf fails for rotation set that is not a subset of another set",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        const operator = new Set.Rotation(set, InstrumentSet);
+
+        let other = new Set({
+          add: new InstrumentSet({
+            add: [Instruments.Snare, Instruments.Bass1, Instruments.Crash],
+          }),
+          add: new InstrumentSet({
+            add: [Instruments.Bass1, Instruments.Crash, Instruments.Snare],
+          }),
+          add: new InstrumentSet({
+            add: [Instruments.Claves, Instruments.Snare, Instruments.Bass1],
+          }),
+          add: new InstrumentSet({
+            add: [Instruments.Snare, Instruments.Claves, Instruments.Crash],
+          }),
+          allowedElements: [InstrumentSet],
+        });
+
+        expect(operator.isSubsetOf(other), false);
+      },
+    },
+    {
+      title:
+        "isSubsetOf succeeds for rotation set that is subset of another set",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        const operator = new Set.Rotation(set, InstrumentSet);
+
+        let other = new Set({
+          add: [
+            new InstrumentSet({
+              add: [Instruments.Snare, Instruments.Bass1, Instruments.Crash],
+            }),
+            new InstrumentSet({
+              add: [Instruments.Bass1, Instruments.Crash, Instruments.Snare],
+            }),
+            new InstrumentSet({
+              add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+            }),
+            new InstrumentSet({
+              add: [Instruments.Snare, Instruments.Claves, Instruments.Crash],
+            }),
+          ],
+          allowedElements: [InstrumentSet],
+        });
+
+        expect(operator.isSubsetOf(other), true);
+      },
+    },
+    {
+      title: "isSubsetOf fails for a set that is not a subset of an rotation set",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        const operator = new Set.Rotation(set, InstrumentSet);
+
+        let other = new Set({
+          add: [
+            new InstrumentSet({
+              add: [Instruments.Snare, Instruments.Bass1, Instruments.Crash],
+            }),
+            new InstrumentSet({
+              add: [Instruments.Claves, Instruments.Snare, Instruments.Bass1],
+            }),
+          ],
+          allowedElements: [InstrumentSet],
+        });
+
+        expect(other.isSubsetOf(operator), false);
+      },
+    },
+    {
+      title: "isSubsetOf succeeds for a set that is a subset of an rotation set",
+      test: () => {
+        const set = new InstrumentSet({
+          add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+        });
+
+        const operator = new Set.Rotation(set, InstrumentSet);
+
+        let other = new Set({
+          add: [
+            new InstrumentSet({
+              add: [Instruments.Snare, Instruments.Bass1, Instruments.Crash],
+            }),
+            new InstrumentSet({
+              add: [Instruments.Crash, Instruments.Snare, Instruments.Bass1],
+            }),
+          ],
+          allowedElements: [InstrumentSet],
+        });
+
+        expect(other.isSubsetOf(operator), true);
+      },
+    },
+  ],
+};