@machinemetrics/io-adapter-lib 2.32.0

package/test/transform/source.test.js

@@ -0,0 +1,137 @@
+'use strict';
+
+const expect = require('chai').expect;
+const EventEmitter = require('eventemitter3');
+const EngineV2 = require('../../lib/engine/engineV2');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const testUtils = require('../util/testUtils');
+
+describe('source full engine config file tests', async function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('transform/source.yml');
+  });
+
+  const makeSourceEngine = (varName) => {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool[varName], source);
+
+    return { source, engine };
+  };
+
+  it('emits updates for all vars correctly', async function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = new ValueSource();
+    engine.addValueSource(source);
+
+    let callMask = 0;
+    engine.on('update', (name, value, time) => {
+      if (time === 100 && name === 'var1') {
+        expect(value).to.eq(15);
+        callMask |= 0x1;
+      }
+      if (time === 100 && name === 'var2') {
+        expect(value).to.eq(25);
+        callMask |= 0x2;
+      }
+      if (time === 100 && (name === 'var3' || name === 'var4')) {
+        expect.fail(`Did not expect to emit ${name} update (100)`);
+      }
+
+      if (time === 110 && (name === 'var1' || name === 'var2')) {
+        expect.fail(`Did not expect to emit ${name} update (110)`);
+      }
+      if (time === 110 && name === 'var3') {
+        expect(value).to.eq(22);
+        callMask |= 0x04;
+      }
+      if (time === 110 && name === 'var4') {
+        expect(value).to.eq(22);
+        callMask |= 0x08;
+      }
+    });
+
+    source.sendValue('xact', 15, 100);
+    source.sendValue('yact', 7, 110);
+    expect(callMask).to.eq(0xF);
+  });
+
+  it('emits unavailable for all vars correctly', async function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = new ValueSource();
+    engine.addValueSource(source);
+
+    let callMask = 0;
+    engine.on('update', (name, value, time) => {
+      if (time !== 105) {
+        expect.fail(`Did not expect to emit ${name} update`);
+      }
+    });
+
+    engine.on('unavailable', (name, time) => {
+      if (time === 100 && (name === 'var1' || name === 'var2')) {
+        expect.fail(`Did not expect to emit ${name} unavailable (100)`);
+      }
+      if (time === 100 && name === 'var3') {
+        callMask |= 0x1;
+      }
+      if (time === 100 && name === 'var4') {
+        callMask |= 0x2;
+      }
+      if (time === 105 && (name === 'var1' || name === 'var2')) {
+        expect.fail(`Did not expect to emit ${name} unavailable (105)`);
+      }
+      if (time === 105 && name === 'var3') {
+        callMask |= 0x40;
+      }
+      if (time === 105 && name === 'var4') {
+        callMask |= 0x80;
+      }
+      if (time === 110 && name === 'var1') {
+        callMask |= 0x4;
+      }
+      if (time === 110 && name === 'var2') {
+        callMask |= 0x8;
+      }
+      if (time === 110 && name === 'var3') {
+        callMask |= 0x10;
+      }
+      if (time === 110 && name === 'var4') {
+        callMask |= 0x20;
+      }
+    });
+
+    source.sendValue('yact', 'UNAVAILABLE', 100);
+    source.sendValue('xact', 5, 105);
+    source.sendValue('xact', 'UNAVAILABLE', 110);
+    expect(callMask).to.eq(0xFF);
+  });
+
+  it('handles source with string compare', async function () {
+    const { source, engine } = makeSourceEngine('var5');
+
+    source.sendValues('execution', [
+      ['AUTOMATIC', 0],
+    ]);
+
+    engine.validateFilter([
+      [true, 0],
+    ]);
+  });
+});
+
+class ValueSource extends EventEmitter {
+  sendValue(name, value, time) {
+    this.emit('update', name, value, time);
+  }
+}

package/test/transform/state.test.js

@@ -0,0 +1,248 @@
+'use strict';
+
+const expect = require('chai').expect;
+const Builder = require('../../lib/engine/transformBuilderV2');
+const EngineV2 = require('../../lib/engine/engineV2');
+const testUtils = require('../util/testUtils');
+
+describe('expression transform tests', function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('transform/state.yml');
+  });
+
+  it('state test 1', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.test1, source);
+
+    source.sendValue('exec', 'ACTIVE', 0);
+    source.sendValue('in-fault', false, 2);
+    source.sendValue('in-fault', false, 4);
+    source.sendValue('in-fault', true, 6);
+    source.sendValue('exec', 'READY', 8);
+    source.sendValue('in-fault', false, 10);
+
+    engine.validateFilter([
+      ['ACTIVE', 0],
+      ['ACTIVE', 2],
+      ['ACTIVE', 4],
+      ['STOPPED', 6],
+      ['READY', 8],
+      ['READY', 10],
+    ]);
+  });
+
+  it('state test 1 (order swap)', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.test1, source);
+
+    source.sendValue('in-fault', false, 0);
+    source.sendValue('exec', 'ACTIVE', 2);
+    source.sendValue('in-fault', false, 4);
+    source.sendValue('in-fault', true, 6);
+
+    engine.validateFilter([
+      ['ACTIVE', 2],
+      ['ACTIVE', 4],
+      ['STOPPED', 6],
+    ]);
+  });
+
+  it('state test 2', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.test2, source);
+
+    source.sendValue('exec', 'ACTIVE', 0);
+    source.sendValue('in-fault', false, 2);
+    source.sendValue('in-fault', false, 4);
+    source.sendValue('in-fault', true, 6);
+    source.sendValue('exec', 'READY', 8);
+    source.sendValue('in-fault', false, 10);
+
+    engine.validateFilter([
+      ['ACTIVE', 0],
+      ['ACTIVE', 2],
+      ['ACTIVE', 4],
+      ['STOPPED', 6],
+      ['READY', 8],
+      ['READY', 10],
+    ]);
+  });
+
+  it('state test 3', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.test3, source);
+
+    source.sendValue('is-running', true, 2);
+    source.sendValue('irrelevant', true, 3);
+    source.sendValue('is-running', false, 4);
+
+    engine.validateFilter([
+      ['ACTIVE', 2],
+      ['READY', 4],
+    ]);
+  });
+
+  it('state test 4', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.test4, source);
+
+    source.sendValue('exec', 'ACTIVE', 0);
+    source.sendValue('in-fault', false, 2);
+    source.sendValue('in-fault', false, 4);
+    source.sendValue('in-fault', true, 6);
+    source.sendValue('exec', 'READY', 8);
+    source.sendValue('in-fault', false, 10);
+
+    const msg1 = 'This is a long active message';
+    const msg2 = 'This is a long stop message';
+    const msg3 = 'This is a default message';
+
+    engine.validateFilter([
+      [msg3, 0],
+      [msg1, 2],
+      [msg1, 4],
+      [msg2, 6],
+      [msg3, 8],
+      [msg3, 10],
+    ]);
+  });
+
+  it('state test 5', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.test5, source);
+
+    source.sendValue('exec', 'ACTIVE', 0);
+    source.sendValue('in-fault', false, 2);
+    source.sendValue('in-fault', false, 4);
+    source.sendValue('in-fault', true, 6);
+    source.sendValue('exec', 'READY', 8);
+    source.sendValue('in-fault', false, 10);
+
+    engine.validateFilter([
+      ['READY', 0],
+      ['ACTIVE', 2],
+      ['ACTIVE', 4],
+      ['STOPPED', 6],
+      ['READY', 8],
+      ['READY', 10],
+    ]);
+  });
+
+  it('state test 6', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.test6, source);
+
+    source.sendValue('exec', 'ACTIVE', 0);
+    source.sendValue('in-fault', false, 2);
+    source.sendValue('in-fault', false, 4);
+    source.sendValue('in-fault', true, 6);
+    source.sendValue('exec', 'READY', 8);
+    source.sendValue('in-fault', false, 10);
+
+    engine.validateFilter([
+      ['READY', 0],
+      ['ACTIVE', 2],
+      ['ACTIVE', 4],
+      ['STOPPED', 6],
+      ['READY', 8],
+      ['READY', 10],
+    ]);
+  });
+
+  it('state test 7', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.test7, source);
+
+    source.sendValue('exec', 'ACTIVE', 0);
+    source.sendValue('in-fault', false, 2);
+    source.sendValue('in-fault', false, 4);
+    source.sendValue('in-fault', true, 6);
+    source.sendValue('exec', 'READY', 8);
+    source.sendValue('in-fault', false, 10);
+
+    engine.validateFilter([
+      ['READY', 2],
+      ['READY', 4],
+      ['READY', 6],
+      ['READY', 10],
+    ]);
+  });
+
+  it('state test 8', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.test8, source);
+
+    expect(engine.variablePool.test8.available).to.eq(false);
+    source.sendValue('is-running', true, 2);
+    expect(engine.variablePool.test8.available).to.eq(true);
+    source.sendValue('irrelevant', true, 3);
+    expect(engine.variablePool.test8.available).to.eq(true);
+    source.sendValue('is-running', false, 4);
+    expect(engine.variablePool.test8.available).to.eq(false);
+
+    engine.validateFilter([
+      ['ACTIVE', 2],
+    ]);
+  });
+
+  it('state test 9', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.test9, source);
+
+    source.sendValue('exec', 30, 0);
+    source.sendValue('in-fault', false, 2);
+    source.sendValue('in-fault', false, 4);
+    source.sendValue('in-fault', true, 6);
+    source.sendValue('exec', 40, 8);
+    source.sendValue('in-fault', false, 10);
+
+    engine.validateFilter([
+      [40, 2],
+      [40, 4],
+      [50, 6],
+      [60, 8],
+      [50, 10],
+    ]);
+  });
+});

package/test/transform/threshold.test.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const Threshold = require('../../lib/transform').threshold;
+const testUtils = require('../util/testUtils');
+
+describe('threshold transform tests', function () {
+  it('thresholds regular', function () {
+    const filter = new Threshold({ args: { threshold: 3 } });
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [1.0, 0], [1.5, 1], [1.2, 2], [2.5, 3], [3.5, 4], [5.0, 5], [2.1, 6], [3.0, 7], [3.1, 8], [-5, 9],
+    ]);
+    filter.valdDigital('____^^_^^_', 1);
+  });
+
+  it('thresholds irregular', function () {
+    const filter = new Threshold({ args: { threshold: 3 } });
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [1.5, 1], [1.6, 4], [1.5, 5], [4.9, 10], [5.0, 11], [4.9, 15], [1.5, 16],
+    ]);
+    filter.validate([
+      [false, 1], [false, 4], [false, 5], [true, 10], [true, 11], [true, 15], [false, 16],
+    ]);
+  });
+
+  it('thresholds below', function () {
+    const filter = new Threshold({ args: { threshold: 3, direction: 'below' } });
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [1.0, 0], [1.5, 1], [1.2, 2], [2.5, 3], [3.5, 4], [5.0, 5], [2.1, 6], [3.0, 7], [3.1, 8], [-5, 9],
+    ]);
+    filter.valdDigital('^^^^__^^_^', 1);
+  });
+
+  it('thresholds strings 1', function () {
+    const filter = new Threshold({ args: { threshold: 3 } });
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      ['1.0', 0], ['1.5', 1], ['1.2', 2], ['2.5', 3], ['3.5', 4], ['5.0', 5], ['2.1', 6], ['3.0', 7], ['3.1', 8], ['-5', 9],
+    ]);
+    filter.valdDigital('____^^_^^_', 1);
+  });
+
+  it('thresholds strings 2', function () {
+    const filter = new Threshold({ args: { threshold: 1 } });
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      ['true', 0], ['false', 1], ['false', 2], ['true', 3],
+    ]);
+    filter.valdDigital('^__^', 1);
+  });
+
+  it('thresholds boolean', function () {
+    const filter = new Threshold({ args: { threshold: 1 } });
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [true, 0], [false, 1], [false, 2], [true, 3],
+    ]);
+    filter.valdDigital('^__^', 1);
+  });
+
+  it('thresholds trash', function () {
+    const filter = new Threshold({ args: { threshold: 1 } });
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      ['trash', 0], [NaN, 1], ['90XX', 2],
+    ]);
+    filter.valdDigital('___', 1);
+  });
+});

package/test/transform/toBuffer.test.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const Buffer = require('buffer/').Buffer;
+const ToBuffer = require('../../lib/transform').toBuffer;
+const testUtils = require('../util/testUtils');
+
+describe('to-buffer transform tests', async function () {
+  const setupFilter = (spec) => {
+    return new ToBuffer(spec);
+  };
+
+  it('parses different formats', async function () {
+    const filters = [
+      setupFilter('int32le'),
+      setupFilter('int32 LE'),
+      setupFilter('type=int32 LE'),
+      setupFilter('int32, order=LE'),
+      setupFilter('int32 order=LE'),
+    ];
+
+    const expectedBuf = Buffer.from([255, 201, 154, 59]);
+
+    await Promise.all(filters.map(f => testUtils.testValue(f, 999999999, expectedBuf)));
+  });
+
+  it('converts values to buffers of different types', async function () {
+    await testUtils.testValue(setupFilter('int32 le'), Buffer.from([255, 201, 154, 59]), Buffer.from([255, 201, 154, 59]));
+
+    await testUtils.testValue(setupFilter('int8'), -1, Buffer.from([255]));
+    await testUtils.testValue(setupFilter('uint8'), 255, Buffer.from([255]));
+    await testUtils.testValue(setupFilter('int16 le'), -13825, Buffer.from([255, 201]));
+    await testUtils.testValue(setupFilter('uint16 le'), 51711, Buffer.from([255, 201]));
+    await testUtils.testValue(setupFilter('int32 le'), 999999999, Buffer.from([255, 201, 154, 59]));
+    await testUtils.testValue(setupFilter('uint32 le'), 999999999, Buffer.from([255, 201, 154, 59]));
+    await testUtils.testValue(setupFilter('int64 le'), BigInt(999999999), Buffer.from([255, 201, 154, 59, 0, 0, 0, 0]));
+    await testUtils.testValue(setupFilter('uint64 le'), BigInt(999999999), Buffer.from([255, 201, 154, 59, 0, 0, 0, 0]));
+    await testUtils.testValue(setupFilter('int16 be'), -55, Buffer.from([255, 201]));
+    await testUtils.testValue(setupFilter('uint16 be'), 65481, Buffer.from([255, 201]));
+    await testUtils.testValue(setupFilter('int32 be'), -3564997, Buffer.from([255, 201, 154, 59]));
+    await testUtils.testValue(setupFilter('uint32 be'), 4291402299, Buffer.from([255, 201, 154, 59]));
+    await testUtils.testValue(setupFilter('int64 be'), BigInt(-15311545525338112), Buffer.from([255, 201, 154, 59, 0, 0, 0, 0]));
+    await testUtils.testValue(setupFilter('uint64 be'), BigInt(18431432528184213504), Buffer.from([255, 201, 154, 59, 0, 0, 0, 0]));
+
+    await testUtils.testValue(setupFilter('float be'), -42, Buffer.from([0xc2, 0x28, 0, 0]));
+    await testUtils.testValue(setupFilter('float le'), -42, Buffer.from([0, 0, 0x28, 0xc2]));
+    await testUtils.testValue(setupFilter('double be'), -12345, Buffer.from([0xc0, 0xc8, 0x1c, 0x80, 0, 0, 0, 0]));
+    await testUtils.testValue(setupFilter('double le'), -12345, Buffer.from([0, 0, 0, 0, 0x80, 0x1c, 0xc8, 0xc0]));
+
+    await testUtils.testValue(setupFilter('string'), 'quick brown fox', Buffer.from([
+      0x71, 0x75, 0x69, 0x63, 0x6b, 0x20, 0x62, 0x72, 0x6f, 0x77, 0x6e, 0x20, 0x66, 0x6f, 0x78
+    ]));
+
+    await testUtils.testValue(setupFilter('int32 le'), '999999999', Buffer.from([255, 201, 154, 59]));
+  });
+
+  it('converts arrays of values to buffers', async function () {
+    await testUtils.testValue(setupFilter('int32 le'), [999999999, 0], Buffer.from([255, 201, 154, 59, 0, 0, 0, 0]));
+    await testUtils.testValue(setupFilter('int32 le'), [Buffer.from([12, 13]), 999999999], Buffer.from([12, 13, 255, 201, 154, 59]));
+  });
+});

package/test/transform/toggle.test.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const Toggle = require('../../lib/transform').toggle;
+const EngineV2 = require('../../lib/engine/engineV2');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const testUtils = require('../util/testUtils');
+
+describe('toggle transform tests', function () {
+  it('toggle regular', function () {
+    const filter = new Toggle(testUtils.standardBuilderArgs(null, 'test1'));
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^____', 1);
+    filter.valdDigital('__^^^^________^^^^^', 1);
+  });
+
+  it('toggle regular default high', function () {
+    const filter = new Toggle(testUtils.standardBuilderArgs(null, 'test1', { init: true }));
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^____', 1);
+    filter.valdDigital('^^____^^^^^^^^_____', 1);
+  });
+});
+
+describe('rising-edge-counter full engine config file tests', function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('transform/toggle.yml');
+  });
+
+  it('no reset expression', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.var1, source);
+
+    source.sendValues('active', [[false, 0], [true, 2], [false, 4], [true, 6]]);
+    source.sendValues('active', [[false, 8], [true, 10], [false, 12], [true, 14]]);
+
+    engine.validateFilter([
+      [false, 0], [true, 2], [true, 4], [false, 6],
+      [false, 8], [true, 10], [true, 12], [false, 14],
+    ]);
+  });
+
+  it('default expression', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.var2, source);
+
+    source.sendValues('active', [[false, 0], [true, 2], [false, 4], [true, 6]]);
+    source.sendValues('active', [[false, 8], [true, 10], [false, 12], [true, 14]]);
+
+    engine.validateFilter([
+      [true, 0], [false, 2], [false, 4], [true, 6],
+      [true, 8], [false, 10], [false, 12], [true, 14],
+    ]);
+  });
+
+  it('reset expression referencing data source', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.var3, source);
+
+    source.sendValues('active', [[false, 0], [true, 2], [false, 4], [false, 6]]);
+    source.sendValue('program', 5, 7);
+    source.sendValues('active', [[false, 8], [true, 10], [false, 12], [true, 14]]);
+    source.sendValue('program', 10, 15);
+    source.sendValues('active', [[false, 16], [true, 18], [false, 20], [true, 22]]);
+    source.sendValue('program', 5, 23);
+    source.sendValues('active', [[false, 24], [true, 26], [false, 28], [true, 30]]);
+
+    engine.validateFilter([
+      [false, 0], [true, 2], [true, 4], [true, 6],
+      [true, 7],
+      [true, 8], [false, 10], [false, 12], [true, 14],
+      [false, 15],
+      [false, 16], [false, 18], [false, 20], [false, 22],
+      [false, 23],
+      [false, 24], [true, 26], [true, 28], [false, 30],
+    ]);
+  });
+});

package/test/transform/trim.test.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const Trim = require('../../lib/transform').trim;
+const testUtils = require('../util/testUtils');
+
+describe('trim transform tests', function () {
+  it('trim irregular', function () {
+    const filter = new Trim();
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      ['simple test', 0],
+      ['  another test', 2],
+      ['trailing test  ', 4],
+      ['  lead and trail ', 6],
+      ['\nnewline test\r\n', 8],
+      [' control codes', 10],
+      [123, 12],
+    ]);
+    filter.validate([
+      ['simple test', 0],
+      ['another test', 2],
+      ['trailing test', 4],
+      ['lead and trail', 6],
+      ['newline test', 8],
+      ['control codes', 10],
+      [123, 12],
+    ]);
+  });
+});

package/test/transform/valueChange.test.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const ValueChange = require('../../lib/transform').valueChange;
+const testUtils = require('../util/testUtils');
+
+describe('value-change transform tests', function () {
+  it('value-change regular digital', function () {
+    const filter = new ValueChange();
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^_', 1);
+    filter.valdDigital('|_|_|_|___|___|||____|', 1);
+  });
+});

package/test/transform/valueDecrease.test.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const ValueDecrease = require('../../lib/transform').valueDecrease;
+const testUtils = require('../util/testUtils');
+
+describe('value-decrease transform tests', function () {
+  it('value-decreases irregular digital', function () {
+    const filter = new ValueDecrease();
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [1, 2], [1, 4], [2, 6], [4, 10], [0, 14], [1, 15], [3, 16], [1, 21],
+    ]);
+    filter.validate([
+      [true, 2], [false, 2], [false, 4], [false, 6], [false, 10], [true, 14], [false, 14],
+      [false, 15], [false, 16], [true, 21], [false, 21],
+    ]);
+  });
+
+  it('value-decreases string', function () {
+    const filter = new ValueDecrease();
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      ['1', 2], ['1', 4], ['2', 6], ['10', 10], ['0', 14], ['1', 15], ['3', 16], ['1', 21],
+    ]);
+    filter.validate([
+      [true, 2], [false, 2], [false, 4], [false, 6], [false, 10], [true, 14], [false, 14],
+      [false, 15], [false, 16], [true, 21], [false, 21],
+    ]);
+  });
+});