jssm 5.45.2 → 5.46.0

package/src/ts/tests/compile.spec.ts

@@ -1,79 +0,0 @@
-
-/* eslint-disable max-len */
-
-import * as jssm from '../jssm';
-
-const sm = jssm.sm;
-
-
-
-
-
-describe('compile/1', () => {
-
-  describe('a->b;', () => {
-    const a_to_b_str = `a->b;`;
-    test('doesn\'t throw', () => expect( () => {
-      jssm.compile(jssm.parse(a_to_b_str));
-    }).not.toThrow() );
-  });
-
-  describe('a->b->c;', () => {
-    const a_to_b_to_c_str = `a->b->c;`;
-    test('doesn\'t throw', () => expect( () => {
-      jssm.compile(jssm.parse(a_to_b_to_c_str));
-    }).not.toThrow() );
-  });
-
-  describe('template tokens', () => {
-    const a_through_e_token_str = `a->${'b'}->c->${'d'}->e;`;
-    test('doesn\'t throw', () => expect( () => {
-      jssm.compile(jssm.parse(a_through_e_token_str));
-    }).not.toThrow() );
-  });
-
-  describe('all arrows', () => {
-    const all_arrows = `a -> b => c ~> d <-> e <=> f <~> g <-=> h <=-> i <~-> j <-~> k <=~> l <~=> m <- n <= o <~ p;`;
-    test('doesn\'t throw', () => expect( () => {
-      jssm.compile(jssm.parse(all_arrows));
-    }).not.toThrow() );
-  });
-
-  describe('all unicode arrows', () => {
-    const all_arrows = `a ← b ⇐ c ↚ d → e ⇒ f ↛ g ↔ h ⇔ i ↮ j ←⇒ k ⇐→ l ←↛ m ↚→ n ⇐↛ o ↚⇒ p;`;
-    test('doesn\'t throw', () => expect( () => {
-      jssm.compile(jssm.parse(all_arrows));
-    }).not.toThrow() );
-  });
-
-});
-
-
-
-
-
-describe('error catchery', () => {
-
-  test.todo('uncomment the compile spec tests once they\'re understood');
-
-  describe('unknown rule', () => {
-    test('throws', () => expect( () => {
-      jssm.compile( [{"key":"FAKE_RULE","from":"a","se":{"kind":"->","to":"b"}}] as any );
-    } ).toThrow() );
-  });
-
-  describe('unnamed state_declaration', () => {
-    test('throws', () => expect( () => {
-      jssm.compile( [{"key":"state_declaration"}] as any );
-    } ).toThrow() );
-  });
-
-  describe('unknown state property', () => {
-    test('throws', () => expect( () => {
-      sm`a->b; c: { foo: red; };`;
-    } ).toThrow() );
-  });
-
-});
-
-// stochable

package/src/ts/tests/constants.spec.ts

@@ -1,98 +0,0 @@
-
-/* In general, this shouldn't import anything, because this is both run and
-   partially imported by other things. */
-
-/* We make an exception for arr_uniq_p() from util */
-
-import { arr_uniq_p } from '../jssm_util';
-
-
-
-
-
-/* constant lists for tests */
-
-test.todo('These constants should be derived from the source and compared');
-
-const Shapes = ["box", "polygon", "ellipse", "oval", "circle", "point", "egg", "triangle", "plaintext", "plain",
-  "diamond", "trapezium", "parallelogram", "house", "pentagon", "hexagon", "septagon", "octagon", "doublecircle",
-  "doubleoctagon", "tripleoctagon", "invtriangle", "invtrapezium", "invhouse", "Mdiamond", "Msquare", "Mcircle", "rect",
-  "rectangle", "square", "star", "none", "underline", "cylinder", "note", "tab", "folder", "box3d", "component",
-  "promoter", "cds", "terminator", "utr", "primersite", "restrictionsite", "fivepoverhang", "threepoverhang",
-  "noverhang", "assembly", "signature", "insulator", "ribosite", "rnastab", "proteasesite", "proteinstab", "rpromoter",
-  "rarrow", "larrow", "lpromoter", "record"];
-
-
-
-
-
-const NamedColors = ["AliceBlue", "AntiqueWhite", "Aqua", "Aquamarine", "Azure", "Beige", "Bisque", "Black",
-  "BlanchedAlmond", "Blue", "BlueViolet", "Brown", "BurlyWood", "CadetBlue", "Chartreuse", "Chocolate", "Coral",
-  "CornflowerBlue", "Cornsilk", "Crimson", "Cyan", "DarkBlue", "DarkCyan", "DarkGoldenRod", "DarkGray", "DarkGrey",
-  "DarkGreen", "DarkKhaki", "DarkMagenta", "DarkOliveGreen", "Darkorange", "DarkOrchid", "DarkRed", "DarkSalmon",
-  "DarkSeaGreen", "DarkSlateBlue", "DarkSlateGray", "DarkSlateGrey", "DarkTurquoise", "DarkViolet", "DeepPink",
-  "DeepSkyBlue", "DimGray", "DimGrey", "DodgerBlue", "FireBrick", "FloralWhite", "ForestGreen", "Fuchsia", "Gainsboro",
-  "GhostWhite", "Gold", "GoldenRod", "Gray", "Grey", "Green", "GreenYellow", "HoneyDew", "HotPink", "IndianRed",
-  "Indigo", "Ivory", "Khaki", "Lavender", "LavenderBlush", "LawnGreen", "LemonChiffon", "LightBlue", "LightCoral",
-  "LightCyan", "LightGoldenRodYellow", "LightGray", "LightGrey", "LightGreen", "LightPink", "LightSalmon",
-  "LightSeaGreen", "LightSkyBlue", "LightSlateGray", "LightSlateGrey", "LightSteelBlue", "LightYellow", "Lime",
-  "LimeGreen", "Linen", "Magenta", "Maroon", "MediumAquaMarine", "MediumBlue", "MediumOrchid", "MediumPurple",
-  "MediumSeaGreen", "MediumSlateBlue", "MediumSpringGreen", "MediumTurquoise", "MediumVioletRed", "MidnightBlue",
-  "MintCream", "MistyRose", "Moccasin", "NavajoWhite", "Navy", "OldLace", "Olive", "OliveDrab", "Orange", "OrangeRed",
-  "Orchid", "PaleGoldenRod", "PaleGreen", "PaleTurquoise", "PaleVioletRed", "PapayaWhip", "PeachPuff", "Peru", "Pink",
-  "Plum", "PowderBlue", "Purple", "Red", "RosyBrown", "RoyalBlue", "SaddleBrown", "Salmon", "SandyBrown", "SeaGreen",
-  "SeaShell", "Sienna", "Silver", "SkyBlue", "SlateBlue", "SlateGray", "SlateGrey", "Snow", "SpringGreen", "SteelBlue",
-  "Tan", "Teal", "Thistle", "Tomato", "Turquoise", "Violet", "Wheat", "White", "WhiteSmoke", "Yellow", "YellowGreen"];
-
-
-
-
-
-const Themes         = ['default', 'ocean', 'none', 'modern'],
-      FlowDirections = ['up','down','left','right'],
-      LineStyles     = ['solid', 'dotted', 'dashed'];
-
-
-
-
-
-// for coverage, and because ava throws on no-test files in its test directory
-
-describe('Constants test lists', () => {
-
-  const testdata: [ string, string[] ][] = [
-    [ 'Shapes',         Shapes         ],
-    [ 'NamedColors',    NamedColors    ],
-    [ 'Themes',         Themes         ],
-    [ 'FlowDirections', FlowDirections ]
-  ];
-
-  testdata.map(datum => {
-
-    test(`List "${datum[0]}" is an array`, () =>
-      expect( Array.isArray(datum[1]) ).toBe(true) );
-
-    test(`List "${datum[0]}" isn't empty`, () =>
-      expect( datum[1].length > 1 ).toBe(true) );
-
-    test(`List "${datum[0]}" contains no null, undefined, or holes`, () =>
-      // eslint-disable-next-line no-eq-null, eqeqeq
-      expect( datum[1].length == null ).toBe(false) );  // LEAVE THIS DOUBLE-EQUALS
-
-    test(`List "${datum[0]}" contains no empty strings`, () =>
-      expect( datum[1].every(s => s !== '') ).toBe(true) );
-
-    test(`List "${datum[0]}" contains no repetitions`, () => {
-      const deduped = datum[1].filter(arr_uniq_p);
-      expect( datum[1].length ).toBe(deduped.length);
-    });
-
-  });
-
-});
-
-
-
-
-
-export { NamedColors, Shapes, Themes, FlowDirections, LineStyles };

package/src/ts/tests/cycles.spec.ts

@@ -1,153 +0,0 @@
-
-/* eslint-disable max-len */
-
-import * as jssm from '../jssm';
-
-
-
-
-
-const testdata = [
-
-  [
-    'basic cycle',
-    '[a b c] -> +1;',
-    [{from: ['a','b','c'], key: 'transition', se: {kind: '->', to: {key: 'cycle', value: 1}}}]
-  ],
-
-  [
-    'negative cycle',
-    '[a b c] -> -1;',
-    [{from: ['a','b','c'], key: 'transition', se: {kind: '->', to: {key: 'cycle', value: -1}}}]
-  ],
-
-  [
-    'nullary cycle',
-    '[a b c] -> +0;',
-    [{from: ['a','b','c'], key: 'transition', se: {kind: '->', to: {key: 'cycle', value: 0}}}]
-  ],
-
-  [
-    'wide cycle',
-    '[a b c] -> +2;',
-    [{from: ['a','b','c'], key: 'transition', se: {kind: '->', to: {key: 'cycle', value: 2}}}]
-  ],
-
-  [
-    'reverse basic cycle',
-    '+1 <- [a b c];',
-    [{from: {key: 'cycle', value: 1}, key: 'transition', se: {kind: '<-', to: ['a','b','c']}}]
-  ],
-
-  [
-    'reverse negative cycle',
-    '-1 <- [a b c];',
-    [{from: {key: 'cycle', value: -1}, key: 'transition', se: {kind: '<-', to: ['a','b','c']}}]
-  ],
-
-  [
-    'reverse nullary cycle',
-    '+0 <- [a b c];',
-    [{from: {key: 'cycle', value: 0}, key: 'transition', se: {kind: '<-', to: ['a','b','c']}}]
-  ],
-
-  [
-    'reverse wide cycle',
-    '+2 <- [a b c];',
-    [{from: {key: 'cycle', value: 2}, key: 'transition', se: {kind: '<-', to: ['a','b','c']}}]
-  ],
-
-  [
-    'bidi basic cycle',
-    '+1 <- [a b c] -> +1;',
-    [{from: {key: 'cycle', value:  1}, key: 'transition', se: {kind: '<-', se: {kind: '->', to: {key: 'cycle', value:  1}}, to: ['a','b','c']}}]
-  ],
-
-  [
-    'bidi negative cycle',
-    '-1 <- [a b c] -> -1;',
-    [{from: {key: 'cycle', value: -1}, key: 'transition', se: {kind: '<-', se: {kind: '->', to: {key: 'cycle', value: -1}}, to: ['a','b','c']}}]
-  ],
-
-  [
-    'bidi basic/negative cycle',
-    '+1 <- [a b c] -> -1;',
-    [{from: {key: 'cycle', value:  1}, key: 'transition', se: {kind: '<-', se: {kind: '->', to: {key: 'cycle', value: -1}}, to: ['a','b','c']}}]
-  ],
-
-  [
-    'bidi nullary cycle',
-    '+0 <- [a b c] -> +0;',
-    [{from: {key: 'cycle', value:  0}, key: 'transition', se: {kind: '<-', se: {kind: '->', to: {key: 'cycle', value:  0}}, to: ['a','b','c']}}]
-  ],
-
-  [
-    'bidi wide cycle',
-    '+2 <- [a b c] -> -2;',
-    [{from: {key: 'cycle', value:  2}, key: 'transition', se: {kind: '<-', se: {kind: '->', to: {key: 'cycle', value: -2}}, to: ['a','b','c']}}]
-  ]
-
-];
-
-
-
-
-
-describe('cycle strategies', () => {
-
-
-  const is_v = (label, str, v) =>
-    test(`${label} (strategy ${str})`, () =>
-      expect( jssm.parse(str) ).toEqual(v) );
-
-  testdata.map( ([ label, code, res ]) => is_v(label, code, res) );
-
-  test.todo('cycle full parses');
-
-/*
-  describe('full parse of 2-step cycle', () => {
-    it('[a b] -> +1;', t => t.deepEqual(
-      sm`[a b] -> +1;`.list_edges(),
-      [{"from":"a","to":"b","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"b","to":"a","kind":"legal","forced_only":false,"main_path":false}]
-    ));
-  });
-
-  describe('full parse of 5-step cycle', () => {
-    it('[a b c d e] -> +1;', t => t.deepEqual(
-      sm`[a b] -> +1;`.list_edges(),
-      [{"from":"a","to":"b","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"b","to":"c","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"c","to":"d","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"d","to":"e","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"e","to":"a","kind":"legal","forced_only":false,"main_path":false}]
-    ));
-
-  describe('full parse of 5-step reverse cycle', () => {
-    it('[a b c d e] -> -1;', t => t.deepEqual(
-      sm`[a b] -> +1;`.list_edges(),
-      [{"from":"a","to":"e","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"b","to":"a","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"c","to":"b","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"d","to":"c","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"e","to":"d","kind":"legal","forced_only":false,"main_path":false}]
-    ));
-  });
-
-  describe('full parse of 5-step two-step cycle (star)', () => {
-    it('[a b c d e] -> +2;', t => t.deepEqual(
-      sm`[a b] -> +1;`.list_edges(),
-      [{"from":"a","to":"c","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"b","to":"d","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"c","to":"e","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"d","to":"a","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"e","to":"b","kind":"legal","forced_only":false,"main_path":false}]
-    ));
-  });
-*/
-
-});
-
-test('illegal fractional cycle throws', () => {
-  expect( () => jssm.parse('[a b c] -> +2.5;') ).toThrow();
-});

package/src/ts/tests/dot_preamble.spec.ts

@@ -1,16 +0,0 @@
-
-import { sm } from '../jssm';
-
-
-
-
-
-describe('Dot preamble', () => {
-
-  test(`doesn't throw`, () =>
-    expect( () => { const _foo = sm`dot_preamble: "x -> y;"; a-> b;`; }).not.toThrow() );
-
-  test('parses correctly', () =>
-    expect( sm`dot_preamble: "x -> y;"; a-> b;`.dot_preamble() ).toBe('x -> y;') );
-
-});

package/src/ts/tests/embedded_sm.spec.ts

@@ -1,36 +0,0 @@
-
-import { sm } from '../jssm';
-
-
-
-
-
-const testdata = [
-  'a -> b;',
-  'flow: right; a -> b -> c -> d -> a;'
-];
-
-const host = sm`x -> y;`;
-
-
-
-
-
-describe('Embedded sm parses the same as regular sm', () => {
-
-  testdata.map(code => {
-
-    test(`Self-match of \`${code}\``, () => {
-      expect( sm`${code}` ).toEqual( host.sm`${code}` );
-    });
-
-  });
-
-});
-
-
-
-
-
-test.todo('Boy is this embedded sm matching thing ever a candidate for stochastics');
-// stochable

package/src/ts/tests/flow.spec.ts

@@ -1,22 +0,0 @@
-
-import { FlowDirections } from './constants.spec';
-import { sm }             from '../jssm';
-
-
-
-
-
-describe('Flow directions', () => {
-
-  FlowDirections.map( thisDir =>
-    test(`Direction "${thisDir}" parses as a flow direction`, () =>
-      expect( () => { const _foo = sm`flow: ${thisDir}; a-> b;`; }).not.toThrow() ) );
-
-  FlowDirections.map( thisDir =>
-    test(`Direction "${thisDir}" parses correctly`, () =>
-      expect( sm`flow: ${thisDir}; a-> b;`.flow() ).toBe(thisDir) ) );
-
-  test('Fake flow direction throws', () =>
-    expect( () => { const _foo = sm`flow: yourFlowIsWhackSon; a-> b;`; } ).toThrow() );
-
-});

package/src/ts/tests/forced transitions.spec.ts

@@ -1,26 +0,0 @@
-
-/* eslint-disable max-len */
-
-import { sm } from '../jssm';
-
-
-
-
-
-describe('reject and accept correctly', () => {
-
-  const machine = sm` a ~> b -> c; `;
-
-  test('starts in a',                    () => expect( machine.state()               ).toBe('a')   );
-  test('rejects transition to b',        () => expect( machine.transition('b')       ).toBe(false) );
-  test('still in a',                     () => expect( machine.state()               ).toBe('a')   );
-  test('rejects transition to c',        () => expect( machine.transition('c')       ).toBe(false) );
-  test('still in a 2',                   () => expect( machine.state()               ).toBe('a')   );
-  test('rejects forced transition to c', () => expect( machine.force_transition('c') ).toBe(false) );
-  test('still in a 3',                   () => expect( machine.state()               ).toBe('a')   );
-  test('accepts forced transition to b', () => expect( machine.force_transition('b') ).toBe(true)  );
-  test('now in b',                       () => expect( machine.state()               ).toBe('b')   );
-  test('accepts transition to c',        () => expect( machine.transition('c')       ).toBe(true)  );
-  test('now in c',                       () => expect( machine.state()               ).toBe('c')   );
-
-});