jssm 5.35.4 → 5.42.0

package/src/ts/tests/sample_select.spec.ts

@@ -1,173 +1,173 @@
-
-import * as jssm from '../jssm';
-
-const sm = jssm.sm;
-
-
-
-
-
-describe('weighted_sample_select/1', () => {
-
-  test.todo('wow is this hard to meaningfully test');
-  it('(0) generates []', () =>
-    expect( jssm.weighted_sample_select(0, [{item:'a',probability:2},{item:'a',probability:3}]) )
-      .toEqual( [] )
-  );
-
-
-
-  describe('has reasonable unweighted distribution', () => {
-
-    const unweighted = new jssm.Machine({
-
-      start_states: ['a'],
-
-      transitions: [
-
-        { from: 'a', to: 'b', kind: 'legal', forced_only: false, main_path: false },
-        { from: 'a', to: 'c', kind: 'legal', forced_only: false, main_path: false },
-
-        { from: 'b', to: 'a', kind: 'legal', forced_only: false, main_path: false },
-        { from: 'b', to: 'c', kind: 'legal', forced_only: false, main_path: false },
-
-        { from: 'c', to: 'a', kind: 'legal', forced_only: false, main_path: false },
-        { from: 'c', to: 'b', kind: 'legal', forced_only: false, main_path: false }
-
-      ]
-
-    });
-
-    const res = unweighted.probabilistic_histo_walk(1500);
-
-    // statistically each should be around 500.  raise alarms if they aren't 300.
-    test('a expects 500 requires 300', () =>
-      expect(res.get('a') >= 300)
-        .toBe(true) );
-
-    test('b expects 500 requires 300', () =>
-      expect(res.get('b') >= 300)
-        .toBe(true) );
-
-    test('c expects 500 requires 300', () =>
-      expect(res.get('c') >= 300)
-        .toBe(true) );
-
-  });
-
-
-
-  describe('has reasonable weighted distribution', () => {
-
-    const weighted = new jssm.Machine({
-
-      start_states: ['a'],
-
-      transitions: [
-
-        { from: 'a', to: 'b', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
-        { from: 'a', to: 'c', probability: 4,   kind: 'legal', forced_only: false, main_path: false },
-        { from: 'a', to: 'd', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
-        { from: 'a', to: 'e', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
-
-        { from: 'b', to: 'a', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
-        { from: 'b', to: 'c', probability: 4,   kind: 'legal', forced_only: false, main_path: false },
-        { from: 'b', to: 'd', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
-        { from: 'b', to: 'e', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
-
-        { from: 'c', to: 'a', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
-        { from: 'c', to: 'b', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
-        { from: 'c', to: 'd', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
-        { from: 'c', to: 'e', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
-
-        { from: 'd', to: 'a', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
-        { from: 'd', to: 'b', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
-        { from: 'd', to: 'c', probability: 4,   kind: 'legal', forced_only: false, main_path: false },
-        { from: 'd', to: 'e', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
-
-        { from: 'e', to: 'a', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
-        { from: 'e', to: 'b', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
-        { from: 'e', to: 'c', probability: 4,   kind: 'legal', forced_only: false, main_path: false },
-        { from: 'e', to: 'd', probability: 0.5, kind: 'legal', forced_only: false, main_path: false }
-
-      ]
-
-    });
-
-    const res = weighted.probabilistic_histo_walk(2500);
-
-    // statistically each should be around 375, or 1050 for c.  raise alarms if they aren't 250, or 800 for c.
-    test('a expects 375 requires 250',  () =>
-      expect(res.get('a') >= 250)
-        .toBe(true) );
-
-    test('b expects 375 requires 250',  () =>
-      expect(res.get('b') >= 250)
-        .toBe(true) );
-
-    test('c expects 1050 requires 800', () =>
-      expect(res.get('c') >= 800)
-        .toBe(true) );
-
-    test('d expects 375 requires 250',  () =>
-      expect(res.get('c') >= 250)
-        .toBe(true) );
-
-    test('e expects 375 requires 250',  () =>
-      expect(res.get('c') >= 250)
-        .toBe(true) );
-
-  });
-
-
-
-
-
-  describe('has reasonable weighted distribution in DSL', () => {
-
-    const weighted = sm`
-      a 0.5% -> [b d e];
-      b 0.5% -> [a d e];
-      c 0.5% -> [a b d e];
-      d 0.5% -> [a b e];
-      [a b d] <- 0.5% e;
-      [a b d e] 4% -> c;
-    `;
-
-    const res = weighted.probabilistic_histo_walk(2500);
-
-    // statistically each should be around 375, or 1050 for c.  raise alarms if they aren't 250, or 800 for c.
-    test('a expects 375 requires 250',  () =>
-      expect(res.get('a') >= 250)
-        .toBe(true) );
-
-    test('b expects 375 requires 250',  () =>
-      expect(res.get('b') >= 250)
-        .toBe(true) );
-
-    test('c expects 1050 requires 800', () =>
-      expect(res.get('c') >= 800)
-        .toBe(true) );
-
-    test('d expects 375 requires 250',  () =>
-      expect(res.get('c') >= 250)
-        .toBe(true) );
-
-    test('e expects 375 requires 250',  () =>
-      expect(res.get('c') >= 250)
-        .toBe(true) );
-
-  });
-
-  // stochastics would help, eg "every returned item is a member" and "in a
-  // sufficient list any positive sample size is reasonable" and "always
-  // returns the right sample size" - whargarbl todo
-
-
-});
-
-
-
-
-
-// stochable
+
+import * as jssm from '../jssm';
+
+const sm = jssm.sm;
+
+
+
+
+
+describe('weighted_sample_select/1', () => {
+
+  test.todo('wow is this hard to meaningfully test');
+  it('(0) generates []', () =>
+    expect( jssm.weighted_sample_select(0, [{item:'a',probability:2},{item:'a',probability:3}]) )
+      .toEqual( [] )
+  );
+
+
+
+  describe('has reasonable unweighted distribution', () => {
+
+    const unweighted = new jssm.Machine({
+
+      start_states: ['a'],
+
+      transitions: [
+
+        { from: 'a', to: 'b', kind: 'legal', forced_only: false, main_path: false },
+        { from: 'a', to: 'c', kind: 'legal', forced_only: false, main_path: false },
+
+        { from: 'b', to: 'a', kind: 'legal', forced_only: false, main_path: false },
+        { from: 'b', to: 'c', kind: 'legal', forced_only: false, main_path: false },
+
+        { from: 'c', to: 'a', kind: 'legal', forced_only: false, main_path: false },
+        { from: 'c', to: 'b', kind: 'legal', forced_only: false, main_path: false }
+
+      ]
+
+    });
+
+    const res = unweighted.probabilistic_histo_walk(1500);
+
+    // statistically each should be around 500.  raise alarms if they aren't 300.
+    test('a expects 500 requires 300', () =>
+      expect(res.get('a') >= 300)
+        .toBe(true) );
+
+    test('b expects 500 requires 300', () =>
+      expect(res.get('b') >= 300)
+        .toBe(true) );
+
+    test('c expects 500 requires 300', () =>
+      expect(res.get('c') >= 300)
+        .toBe(true) );
+
+  });
+
+
+
+  describe('has reasonable weighted distribution', () => {
+
+    const weighted = new jssm.Machine({
+
+      start_states: ['a'],
+
+      transitions: [
+
+        { from: 'a', to: 'b', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
+        { from: 'a', to: 'c', probability: 4,   kind: 'legal', forced_only: false, main_path: false },
+        { from: 'a', to: 'd', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
+        { from: 'a', to: 'e', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
+
+        { from: 'b', to: 'a', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
+        { from: 'b', to: 'c', probability: 4,   kind: 'legal', forced_only: false, main_path: false },
+        { from: 'b', to: 'd', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
+        { from: 'b', to: 'e', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
+
+        { from: 'c', to: 'a', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
+        { from: 'c', to: 'b', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
+        { from: 'c', to: 'd', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
+        { from: 'c', to: 'e', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
+
+        { from: 'd', to: 'a', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
+        { from: 'd', to: 'b', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
+        { from: 'd', to: 'c', probability: 4,   kind: 'legal', forced_only: false, main_path: false },
+        { from: 'd', to: 'e', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
+
+        { from: 'e', to: 'a', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
+        { from: 'e', to: 'b', probability: 0.5, kind: 'legal', forced_only: false, main_path: false },
+        { from: 'e', to: 'c', probability: 4,   kind: 'legal', forced_only: false, main_path: false },
+        { from: 'e', to: 'd', probability: 0.5, kind: 'legal', forced_only: false, main_path: false }
+
+      ]
+
+    });
+
+    const res = weighted.probabilistic_histo_walk(2500);
+
+    // statistically each should be around 375, or 1050 for c.  raise alarms if they aren't 250, or 800 for c.
+    test('a expects 375 requires 250',  () =>
+      expect(res.get('a') >= 250)
+        .toBe(true) );
+
+    test('b expects 375 requires 250',  () =>
+      expect(res.get('b') >= 250)
+        .toBe(true) );
+
+    test('c expects 1050 requires 800', () =>
+      expect(res.get('c') >= 800)
+        .toBe(true) );
+
+    test('d expects 375 requires 250',  () =>
+      expect(res.get('c') >= 250)
+        .toBe(true) );
+
+    test('e expects 375 requires 250',  () =>
+      expect(res.get('c') >= 250)
+        .toBe(true) );
+
+  });
+
+
+
+
+
+  describe('has reasonable weighted distribution in DSL', () => {
+
+    const weighted = sm`
+      a 0.5% -> [b d e];
+      b 0.5% -> [a d e];
+      c 0.5% -> [a b d e];
+      d 0.5% -> [a b e];
+      [a b d] <- 0.5% e;
+      [a b d e] 4% -> c;
+    `;
+
+    const res = weighted.probabilistic_histo_walk(2500);
+
+    // statistically each should be around 375, or 1050 for c.  raise alarms if they aren't 250, or 800 for c.
+    test('a expects 375 requires 250',  () =>
+      expect(res.get('a') >= 250)
+        .toBe(true) );
+
+    test('b expects 375 requires 250',  () =>
+      expect(res.get('b') >= 250)
+        .toBe(true) );
+
+    test('c expects 1050 requires 800', () =>
+      expect(res.get('c') >= 800)
+        .toBe(true) );
+
+    test('d expects 375 requires 250',  () =>
+      expect(res.get('c') >= 250)
+        .toBe(true) );
+
+    test('e expects 375 requires 250',  () =>
+      expect(res.get('c') >= 250)
+        .toBe(true) );
+
+  });
+
+  // stochastics would help, eg "every returned item is a member" and "in a
+  // sufficient list any positive sample size is reasonable" and "always
+  // returns the right sample size" - whargarbl todo
+
+
+});
+
+
+
+
+
+// stochable

package/src/ts/tests/seq.spec.ts

@@ -1,16 +1,14 @@
-
-import * as jssm from '../jssm';
-
-
-
-
-
-describe('seq/1', () => {
-
-  test('(0) generates []',    () => expect( jssm.seq(0) ).toEqual( []    ) );
-  test('(1) generates [0]',   () => expect( jssm.seq(1) ).toEqual( [0]   ) );
-  test('(2) generates [0,1]', () => expect( jssm.seq(2) ).toEqual( [0,1] ) );
-
-});
-
-// stochable
+
+import * as jssm from '../jssm';
+
+
+
+
+
+describe('seq/1', () => {
+
+  test('(0) generates []',    () => expect( jssm.seq(0) ).toEqual( []    ) );
+  test('(1) generates [0]',   () => expect( jssm.seq(1) ).toEqual( [0]   ) );
+  test('(2) generates [0,1]', () => expect( jssm.seq(2) ).toEqual( [0,1] ) );
+
+});

package/src/ts/tests/seq.stoch.ts

@@ -0,0 +1,83 @@
+
+import * as assert from 'assert';
+import * as fc     from 'fast-check';
+import * as jssm   from '../jssm';
+
+const rand_cap = 10_000;
+
+
+
+
+
+describe(`seq/1 over random sizes 0 - ${rand_cap.toLocaleString()}`, () => {
+
+  test(`Any non-negative size will create safely`, () => {
+
+     fc.assert(
+       fc.property(fc.integer(0, rand_cap), Size =>
+         expect( () => jssm.seq(Size) ).not.toThrow()
+       )
+     );
+
+  });
+
+  test(`Length will match the requested size`, () => {
+
+     fc.assert(
+       fc.property(fc.integer(0, rand_cap), Size =>
+         expect( jssm.seq(Size).length ).toBe(Size)
+       )
+     );
+
+  });
+
+  test(`The type will be object`, () => {
+
+     fc.assert(
+       fc.property(fc.integer(0, rand_cap), Size =>
+         expect( typeof jssm.seq(Size) ).toBe('object')
+       )
+     );
+
+  });
+
+  test(`Array.isArray will be yes`, () => {
+
+     fc.assert(
+       fc.property(fc.integer(0, rand_cap), Size =>
+         expect( Array.isArray(jssm.seq(Size)) ).toBe(true)
+       )
+     );
+
+  });
+
+});
+
+
+
+
+
+describe('seq/1 over wrong sizes', () => {
+
+  test(`Non-integer sizes must throw`, () => {
+
+     fc.assert(
+       fc.property(fc.nat(), Size => {
+         const useSize = Number.isInteger(Size)? Size + 0.5 : Size;
+         expect( () => jssm.seq(useSize) ).toThrow()
+       } )
+     );
+
+  });
+
+  test(`Negative sizes must throw`, () => {
+
+     fc.assert(
+       fc.property(fc.integer(-1 * rand_cap, -1), Size => {
+         expect( () => jssm.seq(Size) ).toThrow()
+       } )
+     );
+
+  });
+
+});

package/src/ts/tests/shapes.spec.ts

@@ -1,63 +1,63 @@
-
-import { Shapes } from './constants.spec';
-
-import { sm } from '../jssm';
-
-
-
-
-
-describe('GraphViz Shapes', () => {
-
-  Shapes.map(shape => {
-
-    let mach = undefined;
-
-    test(`Shape "${shape}" parses as a shape`, () =>
-      expect( () => { mach = sm`state c: { shape: ${shape}; }; a -> b;`; }).not.toThrow() );
-
-    test(`Result shape ${shape} is what it's supposed to be`, () =>
-      expect( mach.state_declaration("c").shape ).toBe( shape ) );
-
-  });
-
-  test('handles parse end', () =>
-    expect( () => {
-      const _foo = sm`state c: { shape: thisIsNotAShapeSoItShouldThrow; }; a -> b;`;
-    }).toThrow() );
-
-});
-
-
-
-
-
-describe('Corners', () => {
-
-  test('rounded', () =>
-    expect(sm`state a: { corners: rounded; }; a->b;`.state_declaration("a").corners).toBe("rounded"));
-
-  test('lined', () =>
-    expect(sm`state a: { corners: lined; }; a->b;`.state_declaration("a").corners).toBe("lined"));
-
-  test('regular', () =>
-    expect(sm`state a: { corners: regular; }; a->b;`.state_declaration("a").corners).toBe("regular"));
-
-});
-
-
-
-
-
-describe('Line style', () => {
-
-  test('solid', () =>
-    expect(sm`state a: { linestyle: solid; }; a->b;`.state_declaration("a").linestyle).toBe("solid"));
-
-  test('dashed', () =>
-    expect(sm`state a: { linestyle: dashed; }; a->b;`.state_declaration("a").linestyle).toBe("dashed"));
-
-  test('dotted', () =>
-    expect(sm`state a: { linestyle: dotted; }; a->b;`.state_declaration("a").linestyle).toBe("dotted"));
-
-});
+
+import { Shapes } from './constants.spec';
+
+import { sm } from '../jssm';
+
+
+
+
+
+describe('GraphViz Shapes', () => {
+
+  Shapes.map(shape => {
+
+    let mach = undefined;
+
+    test(`Shape "${shape}" parses as a shape`, () =>
+      expect( () => { mach = sm`state c: { shape: ${shape}; }; a -> b;`; }).not.toThrow() );
+
+    test(`Result shape ${shape} is what it's supposed to be`, () =>
+      expect( mach.state_declaration("c").shape ).toBe( shape ) );
+
+  });
+
+  test('handles parse end', () =>
+    expect( () => {
+      const _foo = sm`state c: { shape: thisIsNotAShapeSoItShouldThrow; }; a -> b;`;
+    }).toThrow() );
+
+});
+
+
+
+
+
+describe('Corners', () => {
+
+  test('rounded', () =>
+    expect(sm`state a: { corners: rounded; }; a->b;`.state_declaration("a").corners).toBe("rounded"));
+
+  test('lined', () =>
+    expect(sm`state a: { corners: lined; }; a->b;`.state_declaration("a").corners).toBe("lined"));
+
+  test('regular', () =>
+    expect(sm`state a: { corners: regular; }; a->b;`.state_declaration("a").corners).toBe("regular"));
+
+});
+
+
+
+
+
+describe('Line style', () => {
+
+  test('solid', () =>
+    expect(sm`state a: { linestyle: solid; }; a->b;`.state_declaration("a").linestyle).toBe("solid"));
+
+  test('dashed', () =>
+    expect(sm`state a: { linestyle: dashed; }; a->b;`.state_declaration("a").linestyle).toBe("dashed"));
+
+  test('dotted', () =>
+    expect(sm`state a: { linestyle: dotted; }; a->b;`.state_declaration("a").linestyle).toBe("dotted"));
+
+});

package/src/ts/tests/sm_tag.spec.ts

@@ -1,37 +1,37 @@
-
-/* eslint-disable max-len */
-
-import { sm } from '../jssm';
-
-
-
-
-
-describe('sm``', () => {
-
-    describe('simple sm`a->b;`', () => {
-      it('doesn\'t throw', () =>
-        expect(() => {
-          const _foo = sm`a -> b;`;
-        }).not.toThrow() );
-    });
-
-    describe('long and chain sm`a->b;c->d;e->f->g;h->i;`', () => {
-      it('doesn\'t throw', () =>
-        expect(() => {
-          const _foo = sm`a->b;c->d;e->f->g;h->i;`;
-        }).not.toThrow() );
-    });
-
-    describe('template tags`', () => {
-      it('doesn\'t throw', () =>
-        expect(() => {
-          const bar = 'c->d',
-                baz = 'b->h->i;f->h',
-               _foo = sm`a->b;${bar};e->f->g;${baz};`;
-        }).not.toThrow() );
-    });
-
-});
-
-// stochable
+
+/* eslint-disable max-len */
+
+import { sm } from '../jssm';
+
+
+
+
+
+describe('sm``', () => {
+
+    describe('simple sm`a->b;`', () => {
+      it('doesn\'t throw', () =>
+        expect(() => {
+          const _foo = sm`a -> b;`;
+        }).not.toThrow() );
+    });
+
+    describe('long and chain sm`a->b;c->d;e->f->g;h->i;`', () => {
+      it('doesn\'t throw', () =>
+        expect(() => {
+          const _foo = sm`a->b;c->d;e->f->g;h->i;`;
+        }).not.toThrow() );
+    });
+
+    describe('template tags`', () => {
+      it('doesn\'t throw', () =>
+        expect(() => {
+          const bar = 'c->d',
+                baz = 'b->h->i;f->h',
+               _foo = sm`a->b;${bar};e->f->g;${baz};`;
+        }).not.toThrow() );
+    });
+
+});
+
+// stochable