@machinemetrics/io-adapter-lib 2.32.0

package/test/transform/fromBuffer.test.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const Buffer = require('buffer/').Buffer;
+const FromBuffer = require('../../lib/transform').fromBuffer;
+const testUtils = require('../util/testUtils');
+
+describe('from-buffer transform tests', async function () {
+  const setupFilter = (spec) => {
+    return new FromBuffer(spec);
+  };
+
+  it('parses different formats', async function () {
+    const filters = [
+      setupFilter('4 int32le'),
+      setupFilter('4 int32 LE'),
+      setupFilter('4 type=int32 LE'),
+      setupFilter('4 int32, order=LE'),
+      setupFilter('offset=4 int32 order=LE'),
+    ];
+
+    const buf = Buffer.from([43, 153, 23, 0, 255, 201, 154, 59, 0, 0, 0, 0]);
+
+    await Promise.all(filters.map(f => testUtils.testValue(f, buf, 999999999)));
+  });
+
+  it('reads data of different types', async function () {
+    const buf = Buffer.from([43, 153, 23, 0, 255, 201, 154, 59, 0, 0, 0, 0]);
+
+    await testUtils.testValue(setupFilter('4 int8'), buf, -1);
+    await testUtils.testValue(setupFilter('4 uint8'), buf, 255);
+    await testUtils.testValue(setupFilter('4 int16 le'), buf, -13825);
+    await testUtils.testValue(setupFilter('4 uint16 le'), buf, 51711);
+    await testUtils.testValue(setupFilter('4 int32 le'), buf, 999999999);
+    await testUtils.testValue(setupFilter('4 uint32 le'), buf, 999999999);
+    await testUtils.testValue(setupFilter('4 int64 le'), buf, BigInt(999999999)); // eslint-disable-line
+    await testUtils.testValue(setupFilter('4 uint64 le'), buf, BigInt(999999999)); // eslint-disable-line
+    await testUtils.testValue(setupFilter('4 int16 be'), buf, -55);
+    await testUtils.testValue(setupFilter('4 uint16 be'), buf, 65481);
+    await testUtils.testValue(setupFilter('4 int32 be'), buf, -3564997);
+    await testUtils.testValue(setupFilter('4 uint32 be'), buf, 4291402299);
+    await testUtils.testValue(setupFilter('4 int64 be'), buf, BigInt(-15311545525338112)); // eslint-disable-line
+    await testUtils.testValue(setupFilter('4 uint64 be'), buf, BigInt(18431432528184213504)); // eslint-disable-line
+
+    const buf2 = Buffer.from([0xc2, 0x28, 0, 0, 0xc0, 0xc8, 0x1c, 0x80, 0, 0, 0, 0]);
+    const buf3 = Buffer.from([0, 0, 0x28, 0xc2, 0, 0, 0, 0, 0x80, 0x1c, 0xc8, 0xc0]);
+
+    await testUtils.testValue(setupFilter('0 float be'), buf2, -42);
+    await testUtils.testValue(setupFilter('0 float le'), buf3, -42);
+    await testUtils.testValue(setupFilter('4 double be'), buf2, -12345);
+    await testUtils.testValue(setupFilter('4 double le'), buf3, -12345);
+
+    const buf4 = Buffer.from([
+      0x71, 0x75, 0x69, 0x63, 0x6b, 0x20, 0x62, 0x72, 0x6f, 0x77, 0x6e, 0x20, 0x66, 0x6f, 0x78
+    ]);
+
+    await testUtils.testValue(setupFilter('0 string 15'), buf4, 'quick brown fox');
+    await testUtils.testValue(setupFilter('0 string length=15'), buf4, 'quick brown fox');
+    await testUtils.testValue(setupFilter('0 string 5'), buf4, 'quick');
+  });
+});

package/test/transform/hash.test.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const Hash = require('../../lib/transform').hash;
+const testUtils = require('../util/testUtils');
+
+describe('hash transform tests', function () {
+  it('hash md5', function () {
+    const filter = new Hash('md5');
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      ['bulbasaur', 2], ['charmander', 4.5], ['squirtle', 11],
+    ]);
+    filter.validate([
+      ['164e304daed9e2142a6d84681e3ba669', 2],
+      ['f0eb43ee186dc087bda60ba3441a0b30', 4.5],
+      ['7577f859913b3b22763a174e2848e65a', 11],
+    ]);
+  });
+
+  it('hash sha1', function () {
+    const filter = new Hash('sha1');
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      ['bulbasaur', 2], ['charmander', 4.5], ['squirtle', 11],
+    ]);
+    filter.validate([
+      ['7d24951a1ca265d9032b543992baca78c7e15fa1', 2],
+      ['838971bc69ae6a984a2547d998b6657cfba808b8', 4.5],
+      ['0d2ddb9232576370351b3e298847770c54f2f381', 11],
+    ]);
+  });
+});

package/test/transform/ignoreValue.test.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const Builder = require('../../lib/engine/transformBuilderV2');
+const EngineV2 = require('../../lib/engine/engineV2');
+const testUtils = require('../util/testUtils');
+
+describe('ignore-value config file tests', async function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('transform/ignoreValue.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('ignores constant value', async function () {
+    const { source, engine } = makeSourceEngine('test1');
+
+    source.sendValues('program', [
+      ['O1001', 0],
+      ['warmup', 2],
+      ['O9999', 4],
+    ]);
+
+    engine.validateFilter([
+      ['O1001', 0],
+      ['O1001', 2],
+      ['O9999', 4],
+    ]);
+  });
+
+  it('ignores empty string', async function () {
+    const { source, engine } = makeSourceEngine('test2');
+
+    source.sendValues('program', [
+      ['O1001', 0],
+      ['', 2],
+      ['O9999', 4],
+    ]);
+
+    engine.validateFilter([
+      ['O1001', 0],
+      ['O1001', 2],
+      ['O9999', 4],
+    ]);
+  });
+
+  it('ignores pattern', async function () {
+    const { source, engine } = makeSourceEngine('test3');
+
+    source.sendValues('program', [
+      ['O1001', 0],
+      ['warmup', 2],
+      ['O9999', 4],
+      ['warmup12', 6],
+    ]);
+
+    engine.validateFilter([
+      ['O1001', 0],
+      ['O1001', 2],
+      ['O9999', 4],
+      ['O9999', 6],
+    ]);
+  });
+
+  it('ignores expression', async function () {
+    const { source, engine } = makeSourceEngine('test4');
+
+    source.sendValues('program', [
+      ['O1001', 0],
+      ['warmup', 2],
+      ['O9999', 4],
+    ]);
+
+    engine.validateFilter([
+      ['O1001', 0],
+      ['O1001', 2],
+      ['O9999', 4],
+    ]);
+  });
+
+  it('ignores expression', async function () {
+    const { source, engine } = makeSourceEngine('test5');
+
+    source.sendValue('pmode', 1, 0);
+    source.sendValue('program', 'O1001', 0);
+    source.sendValue('pmode', 5, 2);
+    source.sendValue('program', 'warmup', 2);
+    source.sendValue('pmode', 1, 4);
+    source.sendValue('program', 'O9999', 6);
+
+    engine.validateFilter([
+      ['O1001', 0],
+      ['O1001', 2],
+      ['warmup', 4],
+      ['O9999', 6],
+    ]);
+  });
+
+  it('ignores constant value with default', async function () {
+    const { source, engine } = makeSourceEngine('test6');
+
+    source.sendValues('program', [
+      ['warmup', 0],
+      ['warmup', 2],
+      ['O9999', 4],
+    ]);
+
+    engine.validateFilter([
+      [null, 0],
+      [null, 2],
+      ['O9999', 4],
+    ]);
+  });
+});

package/test/transform/invert.test.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const Invert = require('../../lib/transform').invert;
+const testUtils = require('../util/testUtils');
+
+describe('invert transform tests', function () {
+  it('invert regular', function () {
+    const filter = new Invert();
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^_^___^^^', 1);
+    filter.valdDigital('^^__^_^^^___', 1);
+  });
+
+  it('invert irregular', function () {
+    const filter = new Invert();
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [true, 2], [true, 4.5], [false, 11], [true, 12],
+    ]);
+    filter.validate([
+      [false, 2], [false, 4.5], [true, 11], [false, 12],
+    ]);
+  });
+});

package/test/transform/latch.test.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const EngineV2 = require('../../lib/engine/engineV2');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const testUtils = require('../util/testUtils');
+
+describe('latch full engine config file tests', function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('transform/latch.yml');
+  });
+
+  it('basic latch test', 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('counter', [[1, 0], [2, 1], [3, 2]]);
+    source.sendValue('execution', 'ACTIVE', 3);
+    source.sendValues('counter', [[4, 4], [5, 5], [6, 6]]);
+    source.sendValue('execution', 'READY', 7);
+    source.sendValues('counter', [[7, 8], [8, 9], [9, 10]]);
+    source.sendValue('execution', 'ACTIVE', 11);
+    source.sendValues('counter', [[10, 12]]);
+
+    engine.validateFilter([
+      [3, 3], [4, 4], [5, 5], [6, 6], [6, 7], [6, 8], [6, 9], [6, 10], [9, 11], [10, 12]
+    ]);
+  });
+});

package/test/transform/latchValue.test.js

@@ -0,0 +1,126 @@
+'use strict';
+
+const Builder = require('../../lib/engine/transformBuilderV2');
+const EngineV2 = require('../../lib/engine/engineV2');
+const testUtils = require('../util/testUtils');
+
+describe('latch-value config file tests', async function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('transform/latchValue.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 };
+  };
+
+  const sendTestData = (source) => {
+    source.sendValue('pmode', 1, 0);
+    source.sendValue('program', 'O1001', 0);
+    source.sendValue('program', 'O1009', 2);
+    source.sendValue('pmode', 5, 3);
+    source.sendValue('program', 'O9999', 4);
+    source.sendValue('pmode', 1, 4);
+    source.sendValue('program', 'O1234', 6);
+    source.sendValue('pmode', 5, 7);
+    source.sendValue('program', 'O1234', 8);
+    source.sendValue('pmode', 1, 9);
+    source.sendValue('program', 'O9999', 10);
+  };
+
+  it('latches first value', async function () {
+    const { source, engine } = makeSourceEngine('test1');
+
+    source.sendValues('program', [
+      ['O1001', 0],
+      ['warmup', 2],
+      ['O9999', 4],
+    ]);
+
+    engine.validateFilter([
+      ['O1001', 0],
+      ['O1001', 2],
+      ['O1001', 4],
+    ]);
+  });
+
+  it('resets latch', async function () {
+    const { source, engine } = makeSourceEngine('test2');
+
+    sendTestData(source);
+
+    engine.validateFilter([
+      ['O1001', 0],
+      ['O1001', 2],
+      ['O1009', 3],
+      ['O9999', 4],
+      ['O9999', 6],
+      ['O1234', 7],
+      ['O1234', 8],
+      ['O1234', 9],
+      ['O1234', 10],
+    ]);
+  });
+
+  it('resets latch on change', async function () {
+    const { source, engine } = makeSourceEngine('test3');
+
+    sendTestData(source);
+
+    engine.validateFilter([
+      ['O1001', 0],
+      ['O1001', 2],
+      ['O1009', 3],
+      ['O9999', 4],
+      ['O1234', 6],
+      ['O1234', 7],
+      ['O1234', 8],
+      ['O1234', 9],
+      ['O9999', 10],
+    ]);
+  });
+
+  it('resets latch with reset value', async function () {
+    const { source, engine } = makeSourceEngine('test4');
+
+    sendTestData(source);
+
+    engine.validateFilter([
+      ['O1001', 0],
+      ['O1001', 2],
+      ['O0000', 3],
+      ['O0000', 4],
+      ['O9999', 4],
+      ['O9999', 6],
+      ['O0000', 7],
+      ['O0000', 8],
+      ['O1234', 9],
+      ['O1234', 10],
+    ]);
+  });
+
+  it('resets latch with reset value and latch on change', async function () {
+    const { source, engine } = makeSourceEngine('test5');
+
+    sendTestData(source);
+
+    engine.validateFilter([
+      ['O1001', 0],
+      ['O1001', 2],
+      ['O0000', 3],
+      ['O0000', 4],
+      ['O1234', 6],
+      ['O0000', 7],
+      ['O0000', 8],
+      ['O0000', 9],
+      ['O9999', 10],
+    ]);
+  });
+});

package/test/transform/logicAnd.test.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const EventEmitter = require('eventemitter3');
+const LogicAnd = require('../../lib/transform').logicAnd;
+const EngineV2 = require('../../lib/engine/engineV2');
+const testUtils = require('../util/testUtils');
+const math = require('../../lib/math');
+
+describe('logic-and transform tests', function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('transform/logicAnd.yml');
+  });
+
+  it('logic-and regular 1', function () {
+    const engine = new EngineV2(config);
+    const source = new ValueSource();
+    engine.addValueSource(source);
+
+    const filter = new LogicAnd({
+      engine,
+      path: 'variables.var2.1.and',
+      args: { compiledExpression: math.compile('true') },
+    });
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^_', 1);
+    filter.valdDigital('__^^__^^^^____^_^^^^^_', 1);
+  });
+
+  it('logic-and regular 2', function () {
+    const engine = new EngineV2(config);
+    const source = new ValueSource();
+    engine.addValueSource(source);
+
+    source.sendValue('counter', 0, 0);
+
+    const filter = new LogicAnd({
+      engine,
+      path: 'variables.var1.1.and',
+      args: { compiledExpression: math.compile('counter % 2 == 0') },
+    });
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^_', 1, {
+      itemPreProcess: (value, time) => { engine.getState('counter').value = time; },
+    });
+    filter.valdDigital('__^___^_^_____^_^_^_^_', 1);
+  });
+
+  it('logic-and irregular', function () {
+    const engine = new EngineV2(config);
+    const source = new ValueSource();
+    engine.addValueSource(source);
+
+    source.sendValue('counter', 0, 0);
+
+    const filter = new LogicAnd({
+      engine,
+      path: 'variables.var1.1.and',
+      args: { compiledExpression: math.compile('counter > 10') },
+    });
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [true, 1], [false, 2], [true, 5], [false, 8], [true, 10], [false, 11], [true, 12], [false, 15], [true, 18],
+    ], {
+      itemPreProcess: (value, time) => { engine.getState('counter').value = time; },
+    });
+    filter.validate([
+      [false, 1], [false, 2], [false, 5], [false, 8], [false, 10], [false, 11], [true, 12], [false, 15], [true, 18],
+    ]);
+  });
+});
+
+class ValueSource extends EventEmitter {
+  sendValue(name, value, time) {
+    this.emit('update', name, value, time);
+  }
+}

package/test/transform/logicOr.test.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const EventEmitter = require('eventemitter3');
+const LogicOr = require('../../lib/transform').logicOr;
+const EngineV2 = require('../../lib/engine/engineV2');
+const testUtils = require('../util/testUtils');
+const math = require('../../lib/math');
+
+describe('logic-or transform tests', function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('transform/logicOr.yml');
+  });
+
+  it('logic-or regular 1', function () {
+    const engine = new EngineV2(config);
+    const source = new ValueSource();
+    engine.addValueSource(source);
+
+    const filter = new LogicOr({
+      engine,
+      path: 'variables.var2.1.or',
+      args: { compiledExpression: math.compile('false') },
+    });
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^_', 1);
+    filter.valdDigital('__^^__^^^^____^_^^^^^_', 1);
+  });
+
+  it('logic-or regular 2', function () {
+    const engine = new EngineV2(config);
+    const source = new ValueSource();
+    engine.addValueSource(source);
+
+    source.sendValue('counter', 0, 0);
+
+    const filter = new LogicOr({
+      engine,
+      path: 'variables.var1.1.or',
+      args: { compiledExpression: math.compile('counter % 2 == 0') },
+    });
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^_', 1, {
+      itemPreProcess: (value, time) => { engine.getState('counter').value = time; },
+    });
+    filter.valdDigital('^_^^^_^^^^^_^_^_^^^^^_', 1);
+  });
+
+  it('logic-or irregular', function () {
+    const engine = new EngineV2(config);
+    const source = new ValueSource();
+    engine.addValueSource(source);
+
+    source.sendValue('counter', 0, 0);
+
+    const filter = new LogicOr({
+      engine,
+      path: 'variables.var1.1.or',
+      args: { compiledExpression: math.compile('counter > 10') },
+    });
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [true, 1], [false, 2], [true, 5], [false, 8], [true, 10], [false, 11], [true, 12], [false, 15], [true, 18],
+    ], {
+      itemPreProcess: (value, time) => { engine.getState('counter').value = time; },
+    });
+    filter.validate([
+      [true, 1], [false, 2], [true, 5], [false, 8], [true, 10], [true, 11], [true, 12], [true, 15], [true, 18],
+    ]);
+  });
+});
+
+class ValueSource extends EventEmitter {
+  sendValue(name, value, time) {
+    this.emit('update', name, value, time);
+  }
+}

package/test/transform/map.test.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const EngineV2 = require('../../lib/engine/engineV2');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const testUtils = require('../util/testUtils');
+
+describe('map full engine config file tests', function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('transform/map.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('counter', [[[1, 2, 3], 0], [[2, 3, 4], 2], [[3, 3, 4], 4], [[4, 3, 5], 6]]);
+
+    engine.validateFilter([
+      [[0, 0, 0], 0], [[1, 1, 1], 2], [[2, 1, 1], 4], [[3, 1, 2], 6],
+    ]);
+  });
+
+  it('subkey map', 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.sendValue('complex', [{ subkey: 10, xx: 15 }, { subkey: 20, xx: 30 }], 0);
+
+    engine.validateFilter([
+      [[10, 20], 0],
+    ]);
+  });
+});

package/test/transform/max.test.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const Max = require('../../lib/transform').max;
+const testUtils = require('../util/testUtils');
+
+describe('max transform tests', function () {
+  it('max regular 1', function () {
+    const filter = new Max(1);
+    testUtils.attachTransformValidator(filter);
+
+    filter.testAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 1);
+    filter.valdAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 1);
+  });
+
+  it('max regular 2', function () {
+    const filter = new Max(2);
+    testUtils.attachTransformValidator(filter);
+
+    filter.testAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 1);
+    filter.valdAnalog([1, 3, 5, 7, 9, 9, 4, 6, 8, 8], 1);
+  });
+
+  it('max regular 5', function () {
+    const filter = new Max(5);
+    testUtils.attachTransformValidator(filter);
+
+    filter.testAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 1);
+    filter.valdAnalog([1, 3, 5, 7, 9, 9, 9, 9, 9, 8], 1);
+  });
+});

package/test/transform/maxLength.test.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const MaxLength = require('../../lib/transform').maxLength;
+const testUtils = require('../util/testUtils');
+
+describe('max-length transform tests', async function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('transform/maxLength.yml');
+  });
+
+  const setupFilter = (transform) => {
+    return new MaxLength(transform.args.count);
+  };
+
+  it('max length strings', async function () {
+    const filter = setupFilter(config.engine.variables.test1.transform[1]);
+
+    await testUtils.testValue(filter, 'xatu', 'xatu');
+    await testUtils.testValue(filter, 'scyther', 'scyther');
+    await testUtils.testValue(filter, 'bulbasaur', 'bulbasa');
+  });
+
+  it('max length arrays', async function () {
+    const filter = setupFilter(config.engine.variables.test2.transform[1]);
+
+    await testUtils.testValue(filter, [], []);
+    await testUtils.testValue(filter, [0, 1], [0, 1]);
+    await testUtils.testValue(filter, [0, 1, 2], [0, 1, 2]);
+    await testUtils.testValue(filter, [0, 1, 2, 4, 5, 6], [0, 1, 2]);
+  });
+});