@machinemetrics/io-adapter-lib 2.32.0

package/test/engine-v2-tests.js

@@ -0,0 +1,284 @@
+'use strict';
+
+const _ = require('lodash');
+const EventEmitter = require('eventemitter3');
+const expect = require('chai').expect;
+const Transform = require('../lib/transform');
+const EngineV2 = require('../lib/engine/engineV2');
+const ExpressionService = require('../lib/expressionService');
+
+describe('EngineV2 tests', function () {
+  describe('Pin source tests', function () {
+    it('adds 0 reffed pin sources', function () {
+      const exprsvc = new ExpressionService();
+      const source = new ValueSource(exprsvc);
+      const pool = new EngineV2({ expressionService: exprsvc });
+      pool.addValueSource(source);
+
+      expect(_.size(pool.pool)).to.eq(0);
+    });
+
+    it('adds 3 reffed pin sources', function () {
+      const exprsvc = new ExpressionService();
+      const source = new ValueSource(exprsvc);
+      const pool = new EngineV2({ expressionService: exprsvc });
+
+      exprsvc.addExpression({ expression: 'pin-0', path: 'test1' });
+      exprsvc.addExpression({ expression: 'pin-1', path: 'test2' });
+      exprsvc.addExpression({ expression: 'pin-4', path: 'test3' });
+      pool.addValueSource(source);
+
+      expect(_.size(pool.pool)).to.eq(3);
+      expect(pool.pool['pin-0'].name).to.eq('pin-0');
+      expect(pool.pool['pin-1'].name).to.eq('pin-1');
+      expect(pool.pool['pin-4'].name).to.eq('pin-4');
+    });
+
+    it('emits direct pin-source events', function () {
+      const exprsvc = new ExpressionService();
+      const source = new ValueSource(exprsvc);
+      const pool = new EngineV2({ expressionService: exprsvc });
+      exprsvc.addExpression({ expression: 'pin-1', path: 'test2' });
+
+      pool.addValueSource(source);
+
+      const updates = [];
+      pool.on('update', (name, value, valueTime) => {
+        expect(name).to.eq('pin-1');
+        updates.push([value, valueTime]);
+      });
+
+      source.sendValues('pin-1', [
+        [1, 1], [3, 2], [3, 3], [5, 4], [2, 5],
+      ]);
+      expect(updates).to.deep.equal([
+        [1, 1], [3, 2], [5, 4], [2, 5],
+      ]);
+    });
+  });
+
+  describe('Array tests', function () {
+    it('passes through arrays', function () {
+      const exprsvc = new ExpressionService();
+      const source = new ValueSource(exprsvc);
+      const pool = new EngineV2({ expressionService: exprsvc });
+      exprsvc.addExpression({ expression: 'pin-1', path: 'test2' });
+
+      pool.addValueSource(source);
+
+      const updates = [];
+      pool.on('update', (name, value, valueTime) => {
+        expect(name).to.eq('pin-1');
+        updates.push([value, valueTime]);
+      });
+
+      source.sendValues('pin-1', [
+        [[1, 0], 1], [[3, 0], 2], [[3, 0], 3], [[5, 0], 4], [[2, 0], 5],
+      ]);
+      expect(updates).to.deep.equal([
+        [[1, 0], 1], [[3, 0], 2], [[5, 0], 4], [[2, 0], 5],
+      ]);
+    });
+  });
+
+  describe('Variable tests', function () {
+    it('pin -> variable -> out', function () {
+      const exprsvc = new ExpressionService();
+      const source = new ValueSource(exprsvc);
+      const engine = new EngineV2({ expressionService: exprsvc });
+
+      const sourceExpression = 'pin-1';
+      exprsvc.addExpression({ expression: sourceExpression, path: 'test1' });
+      engine.addValueSource(source);
+
+      const filter = new Transform.source({
+        engine,
+        path: 'test1',
+        rootPath: 'test1',
+        baseTransform: true,
+        args: {
+          expression: sourceExpression,
+        },
+      }).chain(new Transform.threshold({ args: { threshold: 3 } }));
+      engine.addVariable('exec', filter);
+
+      const updates = [];
+      engine.on('update', (name, value, valueTime) => {
+        if (name === 'exec') {
+          updates.push([value, valueTime]);
+        }
+      });
+
+      source.sendValues('pin-1', [
+        [1, 1], [3, 2], [3, 3], [5, 4], [2, 5],
+      ]);
+      expect(updates).to.deep.equal([
+        [false, 1], [true, 2], [false, 5],
+      ]);
+    });
+
+    it('pin -> variable -> out (reverse attach)', function () {
+      const exprsvc = new ExpressionService();
+      const engine = new EngineV2({ expressionService: exprsvc });
+
+      const sourceExpression = 'pin-1';
+      exprsvc.addName({ name: 'pin-1', channel: 'device', defaultValue: 0 });
+      exprsvc.addExpression({ expression: sourceExpression, path: 'test1' });
+
+      const filter = new Transform.source({
+        engine,
+        path: 'test1',
+        rootPath: 'test1',
+        baseTransform: true,
+        args: {
+          expression: sourceExpression,
+        },
+      }).chain(new Transform.threshold({ args: { threshold: 3 } }));
+      engine.addVariable('exec', filter);
+
+      const source = new ValueSource(exprsvc);
+      engine.addValueSource(source);
+
+      const updates = [];
+      engine.on('update', (name, value, valueTime) => {
+        if (name === 'exec') {
+          updates.push([value, valueTime]);
+        }
+      });
+
+      source.sendValues('pin-1', [
+        [1, 1], [3, 2], [3, 3], [5, 4], [2, 5],
+      ]);
+      expect(updates).to.deep.equal([
+        [false, 1], [true, 2], [false, 5],
+      ]);
+    });
+
+    it('pin -> variable -> variable -> out', function () {
+      const exprsvc = new ExpressionService();
+      const source = new ValueSource(exprsvc);
+      const engine = new EngineV2({ expressionService: exprsvc });
+
+      const sourceExpression1 = 'pin-1';
+      const sourceExpression2 = 'exec';
+      exprsvc.addName({ name: 'exec', defaultValue: 0, channel: 'engine' });
+      exprsvc.addExpression({ expression: sourceExpression1, path: 'test1' });
+      exprsvc.addExpression({ expression: sourceExpression2, path: 'test2' });
+      engine.addValueSource(source);
+
+      const filter = new Transform.source({
+        engine,
+        path: 'test1',
+        rootPath: 'test1',
+        baseTransform: true,
+        args: {
+          expression: sourceExpression1,
+        },
+      }).chain(new Transform.threshold({ args: { threshold: 3 } }));
+      engine.addVariable('exec', filter);
+
+      const filter2 = new Transform.source({
+        engine,
+        path: 'test2',
+        rootPath: 'test2',
+        baseTransform: true,
+        args: {
+          expression: sourceExpression2,
+        },
+      }).chain(new Transform.risingEdgeCounter({
+        engine,
+        path: 'test3',
+        rootPath: 'test2',
+        args: {},
+      }));
+      engine.addVariable('count', filter2);
+
+      const updates = [];
+      engine.on('update', (name, value, valueTime) => {
+        if (name === 'count') {
+          updates.push([value, valueTime]);
+        }
+      });
+
+      source.sendValues('pin-1', [
+        [1, 1], [3, 2], [3, 3], [5, 4], [2, 5],
+      ]);
+      expect(updates).to.deep.equal([
+        [0, 1], [1, 2],
+      ]);
+    });
+  });
+
+  describe('Pending tests', function () {
+    it('Pending change updates happen before state updates', function () {
+      const exprsvc = new ExpressionService();
+      const source = new ValueSource(exprsvc);
+      const engine = new EngineV2({ expressionService: exprsvc });
+
+      const sourceExpression = 'pin-1';
+      exprsvc.addExpression({ expression: sourceExpression, path: 'test1' });
+      engine.addValueSource(source);
+
+      const filter = new Transform.source({
+        engine,
+        path: 'test1',
+        rootPath: 'test1',
+        baseTransform: true,
+        args: {
+          expression: sourceExpression,
+        },
+      }).chain(new Transform.threshold({ args: { threshold: 2 } }))
+        .chain(new Transform.offDelay(2));
+      engine.addVariable('test', filter);
+
+      const updates = [];
+      engine.on('update', (name, value, valueTime) => {
+        if (name === 'test') {
+          updates.push([value, valueTime]);
+        }
+      });
+
+      expect(filter.chainSupportsPendingChange()).to.eq(true);
+      expect(filter.chainNextPendingChange()).to.eq(null);
+
+      source.sendValues('pin-1', [
+        [5, 1], [1.5, 2],
+      ]);
+      expect(filter.chainNextPendingChange()).to.eq(4);
+
+      source.sendValues('pin-1', [
+        [3, 3], [1.5, 6], [3, 9],
+      ]);
+
+      expect(updates).to.deep.equal([
+        [true, 1], [false, 8], [true, 9],
+      ]);
+    });
+  });
+});
+
+class ValueSource extends EventEmitter {
+  constructor(expressionService) {
+    super();
+    this.config = {};
+    this.config.pins = {
+      0: { pin: 0, mode: 'analog' },
+      1: { pin: 1, mode: 'analog' },
+      4: { pin: 4, mode: 'digital' },
+    };
+
+    _.each(this.config.pins, (pin) => {
+      expressionService.addName({
+        name: `pin-${pin.pin}`,
+        defaultValue: 0,
+        channel: 'device',
+      });
+    });
+  }
+
+  sendValues(pin, arr) {
+    _.each(arr, ([value, time]) => {
+      this.emit('update', pin, value, time);
+    });
+  }
+}

package/test/expression-tests.js

@@ -0,0 +1,171 @@
+'use strict';
+
+const expect = require('chai').expect;
+const math = require('../lib/math');
+
+describe('Expression tests', function () {
+  it('flags', function () {
+    expect(math.compile('flag(17, 0)').evaluate({})).to.eq(true);
+    expect(math.compile('flag(17, 1)').evaluate({})).to.eq(false);
+    expect(math.compile('flag(17, 4)').evaluate({})).to.eq(true);
+    expect(math.compile('flag(xx, 4)').evaluate({ xx: 17 })).to.eq(true);
+    expect(math.compile('flag([true, false, true, false], 0)').evaluate({})).to.eq(true);
+    expect(math.compile('flag([true, false, true, false], 1)').evaluate({})).to.eq(false);
+    expect(math.compile('flag([true, false, true, false], 6)').evaluate({})).to.eq(false);
+    expect(math.compile('flag(xx, 2)').evaluate({ xx: [true, false, true] })).to.eq(true);
+  });
+
+  it('string equality', function () {
+    expect(math.compile('equalText("abc", "abc")').evaluate({})).to.eq(true);
+    expect(math.compile('equalText("abc", "def")').evaluate({})).to.eq(false);
+    expect(math.compile('equalText(xx, "def")').evaluate({ xx: 'abc' })).to.eq(false);
+    expect(math.compile('equalText(xx, "abc")').evaluate({ xx: 'abc' })).to.eq(true);
+    expect(math.compile('equalText(xx, "abc")').evaluate({ xx: 25 })).to.eq(false);
+  });
+
+  it('string concat', function () {
+    expect(math.compile('concat("abc", "def")').evaluate({})).to.eq('abcdef');
+    expect(math.compile('concat("abc", 123)').evaluate({})).to.eq('abc123');
+    expect(math.compile('concat(456, 123)').evaluate({})).to.eq('456123');
+    expect(math.compile('concat("abc", "def", "ghi")').evaluate({})).to.eq('abcdefghi');
+    expect(math.compile('concat(xx, yy)').evaluate({ xx: 'abc', yy: 25 })).to.eq('abc25');
+  });
+
+  it('compound expressions', function () {
+    expect(math.compile('xx + 5').evaluate({ xx: 7 })).to.eq(12);
+    expect(math.compile('(xx + 5)').evaluate({ xx: 7 })).to.eq(12);
+    expect(math.compile('(5 + xx)').evaluate({ xx: 7 })).to.eq(12);
+    expect(math.compile('(xx + yy)').evaluate({ xx: 7, yy: 5 })).to.eq(12);
+    expect(math.compile('min(xx, yy)').evaluate({ xx: 7, yy: 5 })).to.eq(5);
+  });
+
+  it('equality override', function () {
+    expect(math.compile('"abc" == "abc"').evaluate({})).to.eq(true);
+    expect(math.compile('"abc" == "def"').evaluate({})).to.eq(false);
+    expect(math.compile('4 == 4').evaluate({})).to.eq(true);
+    expect(math.compile('4 == 5').evaluate({})).to.eq(false);
+    expect(math.compile('4 == "4"').evaluate({})).to.eq(true);
+    expect(math.compile('4 == "5"').evaluate({})).to.eq(false);
+    expect(math.compile('"4" == 4').evaluate({})).to.eq(true);
+    expect(math.compile('"5" == 4').evaluate({})).to.eq(false);
+    expect(math.compile('xx == "abc"').evaluate({ xx: 'abc' })).to.eq(true);
+    expect(math.compile('xx == "abc"').evaluate({ xx: 'def' })).to.eq(false);
+    expect(math.compile('xx == 4').evaluate({ xx: 4 })).to.eq(true);
+    expect(math.compile('xx == 4').evaluate({ xx: '4' })).to.eq(true);
+    expect(math.compile('xx == "4"').evaluate({ xx: '4' })).to.eq(true);
+    expect(math.compile('xx == "4"').evaluate({ xx: 4 })).to.eq(true);
+  });
+
+  it('string start', function () {
+    expect(math.compile('startsWith("abcdef", "abc")').evaluate({})).to.eq(true);
+    expect(math.compile('startsWith("abcdef", "bcd")').evaluate({})).to.eq(false);
+    expect(math.compile('startsWith(42, "abc")').evaluate({})).to.eq(false);
+    expect(math.compile('startsWith(xx, "abc")').evaluate({ xx: 'abcdef' })).to.eq(true);
+    expect(math.compile('startsWith(xx, "bcd")').evaluate({ xx: 'abcdef' })).to.eq(false);
+    expect(math.compile('startsWith(xx, yy)').evaluate({ xx: 'abcdef', yy: 'abc' })).to.eq(true);
+    expect(math.compile('startsWith(xx, yy)').evaluate({ xx: 'abcdef', yy: 'bcd' })).to.eq(false);
+    expect(math.compile('startsWith(xx, yy)').evaluate({ xx: 42, yy: 'bcd' })).to.eq(false);
+  });
+
+  it('string end', function () {
+    expect(math.compile('endsWith("abcdef", "def")').evaluate({})).to.eq(true);
+    expect(math.compile('endsWith("abcdef", "cde")').evaluate({})).to.eq(false);
+    expect(math.compile('endsWith(42, "def")').evaluate({})).to.eq(false);
+    expect(math.compile('endsWith(xx, "def")').evaluate({ xx: 'abcdef' })).to.eq(true);
+    expect(math.compile('endsWith(xx, "cde")').evaluate({ xx: 'abcdef' })).to.eq(false);
+    expect(math.compile('endsWith(xx, yy)').evaluate({ xx: 'abcdef', yy: 'def' })).to.eq(true);
+    expect(math.compile('endsWith(xx, yy)').evaluate({ xx: 'abcdef', yy: 'cde' })).to.eq(false);
+    expect(math.compile('endsWith(xx, yy)').evaluate({ xx: 42, yy: 'def' })).to.eq(false);
+  });
+
+  it('string contains', function () {
+    expect(math.compile('contains("abcdef", "bcd")').evaluate({})).to.eq(true);
+    expect(math.compile('contains("abcdef", "abcdef")').evaluate({})).to.eq(true);
+    expect(math.compile('contains("abcdef", "")').evaluate({})).to.eq(true);
+    expect(math.compile('contains("abcdef", "efg")').evaluate({})).to.eq(false);
+    expect(math.compile('contains(42, "abc")').evaluate({})).to.eq(false);
+    expect(math.compile('contains(xx, "bcd")').evaluate({ xx: 'abcdef' })).to.eq(true);
+    expect(math.compile('contains(xx, "efg")').evaluate({ xx: 'abcdef' })).to.eq(false);
+    expect(math.compile('contains(xx, yy)').evaluate({ xx: 'abcdef', yy: 'bcd' })).to.eq(true);
+    expect(math.compile('contains(xx, yy)').evaluate({ xx: 'abcdef', yy: 'efg' })).to.eq(false);
+    expect(math.compile('contains(xx, yy)').evaluate({ xx: 42, yy: 'bcd' })).to.eq(false);
+  });
+
+  it('array contains', function () {
+    expect(math.compile('contains(["a", "b", "c"], "a")').evaluate({})).to.eq(true);
+    expect(math.compile('contains(["a", "b", "c"], "f")').evaluate({})).to.eq(false);
+    expect(math.compile('contains([1, 2, 3], 2)').evaluate({})).to.eq(true);
+    expect(math.compile('contains([1, 2, 3], "2")').evaluate({})).to.eq(true);
+    expect(math.compile('contains([], 0)').evaluate({})).to.eq(false);
+    expect(math.compile('contains(xx, "2")').evaluate({ xx: [1, 2, 3] })).to.eq(true);
+    expect(math.compile('contains(xx, yy)').evaluate({ xx: [1, 2, 3], yy: '2' })).to.eq(true);
+    expect(math.compile('contains(xx, yy)').evaluate({ xx: [1, 2, 3], yy: 4 })).to.eq(false);
+  });
+
+  it('string test', function () {
+    // Parsing limitation probably means we need to double-escape (or quad-escape?) any regex character class
+    expect(math.compile('test("port9001", "port")').evaluate({})).to.eq(true);
+    expect(math.compile('test("port9001", "\\\\d+$")').evaluate({})).to.eq(true);
+    expect(math.compile('test("port9001", "^port\\\\d+$")').evaluate({})).to.eq(true);
+    expect(math.compile('test("port9001x", "^port\\\\d+$")').evaluate({})).to.eq(false);
+    expect(math.compile('test(xx, "\\\\d+$")').evaluate({ xx: 'port9001' })).to.eq(true);
+    expect(math.compile('test(xx, "^port\\\\d+$")').evaluate({ xx: 'port9001' })).to.eq(true);
+  });
+
+  it('string match', function () {
+    expect(math.compile('match("port9001", "port")').evaluate({})).to.eq('port');
+    expect(math.compile('match("port9001", "\\\\d+$")').evaluate({})).to.eq('9001');
+    expect(math.compile('match("port9001", "^port\\\\d+$")').evaluate({})).to.eq('port9001');
+    expect(math.compile('match("port9001x", "^port\\\\d+$")').evaluate({})).to.eq('');
+    expect(math.compile('match("port9001", "^port(\\\\d+)$", 0)').evaluate({})).to.eq('port9001');
+    expect(math.compile('match("port9001", "^port(\\\\d+)$", 1)').evaluate({})).to.eq('9001');
+    expect(math.compile('match(xx, "\\\\d+$")').evaluate({ xx: 'port9001' })).to.eq('9001');
+    expect(math.compile('match(xx, "^port\\\\d+$")').evaluate({ xx: 'port9001' })).to.eq('port9001');
+  });
+
+  it('string replace', function () {
+    expect(math.compile('replace("port9001", "9002", "")').evaluate({})).to.eq('port9001');
+    expect(math.compile('replace("port9001", ".*", "")').evaluate({})).to.eq('');
+    expect(math.compile('replace("port9001", "port", "")').evaluate({})).to.eq('9001');
+    expect(math.compile('replace("port9001", "port(\\\\d+)$", "$1")').evaluate({})).to.eq('9001');
+    expect(math.compile('replace(xx, "port", "")').evaluate({ xx: 'port9001' })).to.eq('9001');
+    expect(math.compile('replace(xx, "port(\\\\d+)$", "$1")').evaluate({ xx: 'port9001' })).to.eq('9001');
+    expect(math.compile('replace(xx, "\\\\d+$", yy)').evaluate({ xx: 'port9001', yy: 8080 })).to.eq('port8080');
+  });
+
+  it('md5', function () {
+    expect(math.compile('md5("braitsch")').evaluate({})).to.eq('9b74c9897bac770ffc029102a200c5de');
+    expect(math.compile('md5(xx)').evaluate({ xx: 'braitsch' })).to.eq('9b74c9897bac770ffc029102a200c5de');
+  });
+
+  it('lpad', function () {
+    expect(math.compile('lpad("test", 8, "x")').evaluate({})).to.eq('xxxxtest');
+    expect(math.compile('lpad(xx, 8, "x")').evaluate({ xx: 'test' })).to.eq('xxxxtest');
+  });
+
+  it('rpad', function () {
+    expect(math.compile('rpad("test", 8, "x")').evaluate({})).to.eq('testxxxx');
+    expect(math.compile('rpad(xx, 8, "x")').evaluate({ xx: 'test' })).to.eq('testxxxx');
+  });
+
+  it('asc', function () {
+    expect(math.compile('asc(82)').evaluate({})).to.eq('R');
+    expect(math.compile('asc(xx)').evaluate({ xx: 82 })).to.eq('R');
+    expect(math.compile('asc(xx)').evaluate({ xx: '82' })).to.eq('R');
+    expect(math.compile('asc([82])').evaluate({})).to.eq('R');
+    expect(math.compile('asc([82, 83, 84, 85])').evaluate({})).to.eq('RSTU');
+    expect(math.compile('asc([82, 83, 84, 0])').evaluate({})).to.eq('RST');
+    expect(math.compile('asc([xx, yy, zz])').evaluate({ xx: 82, yy: 83, zz: 84 })).to.eq('RST');
+  });
+
+  it('ord', function () {
+    expect(math.compile('ord("R")').evaluate({})).to.eq(82);
+    expect(math.compile('ord("R", 0)').evaluate({})).to.eq(82);
+    expect(math.compile('ord("RSTU", 2)').evaluate({})).to.eq(84);
+    expect(math.compile('ord(xx, yy)').evaluate({ xx: 'RSTU', yy: 2 })).to.eq(84);
+    // eslint-disable-next-line no-unused-expressions
+    expect(math.compile('ord("RSTU", 4)').evaluate({})).to.be.NaN;
+    // eslint-disable-next-line no-unused-expressions
+    expect(math.compile('ord(82)').evaluate({})).to.be.NaN;
+  });
+});

package/test/expressionService.test.js

@@ -0,0 +1,154 @@
+'use strict';
+
+const expect = require('chai').expect;
+const ExpressionService = require('../lib/expressionService');
+
+describe('ExpressionService tests', function () {
+  it('has config available', function () {
+    const exprsvc = new ExpressionService({ device: 1 });
+    expect(exprsvc.config).to.deep.eq({ device: 1 });
+  });
+
+  it('checks name legality', function () {
+    const exprsvc = new ExpressionService();
+    expect(exprsvc.isNameValid('simple')).to.eq(true);
+    expect(exprsvc.isNameValid('com-pound')).to.eq(true);
+    expect(exprsvc.isNameValid('double-com-pound')).to.eq(true);
+    expect(exprsvc.isNameValid('All91_legal-chars')).to.eq(true);
+    expect(exprsvc.isNameValid('-no-prefix')).to.eq(false);
+    expect(exprsvc.isNameValid('no-suffix-')).to.eq(false);
+    expect(exprsvc.isNameValid('no spaces')).to.eq(false);
+    expect(exprsvc.isNameValid('no!')).to.eq(false);
+  });
+
+  it('handles identifier management', function () {
+    const exprsvc = new ExpressionService();
+    exprsvc.addName({ name: 'pin-0', defaultValue: 0, channel: 'primary' });
+    exprsvc.addName({ name: 'pin-1', defaultValue: 0, channel: 'device' });
+    exprsvc.addName({ name: 'pin-2', defaultValue: 2, channel: 'device' });
+    exprsvc.addName({ name: 'exec-1', defaultValue: 0, channel: 'engine' });
+
+    expect(exprsvc.definedNames()).to.deep.eq(['pin-0', 'pin-1', 'pin-2', 'exec-1']);
+    expect(exprsvc.definedNames('device')).to.deep.eq(['pin-1', 'pin-2']);
+    expect(exprsvc.definedNames('engine')).to.deep.eq(['exec-1']);
+    expect(exprsvc.definedNames('other')).to.deep.eq([]);
+
+    expect(exprsvc.referencedNames()).to.deep.eq([]);
+  });
+
+  it('handles expression management', function () {
+    const exprsvc = new ExpressionService();
+    exprsvc.addName({ name: 'pin-0', defaultValue: 0, channel: 'primary' });
+    exprsvc.addName({ name: 'pin-1', defaultValue: 0, channel: 'device' });
+    exprsvc.addName({ name: 'pin-2', defaultValue: 2, channel: 'device' });
+    exprsvc.addName({ name: 'exec-1', defaultValue: 0, channel: 'engine' });
+
+    exprsvc.addExpression({ expression: 'pin-0', path: 'test1' });
+    exprsvc.addExpression({ expression: 'pin-1 + 3', path: 'test2' });
+    exprsvc.addExpression({ expression: 'pin-0 + pin-2', path: 'test3' });
+    exprsvc.addExpression({ expression: 'max(pin-0, pin-2)', path: 'test4' });
+    exprsvc.addExpression({ expression: 'max(pin-0,pin-2)', path: 'test5' });
+
+    expect(exprsvc.referencedNames()).to.deep.eq(['pin-0', 'pin-1', 'pin-2']);
+    expect(exprsvc.referencedNames('device')).to.deep.eq(['pin-1', 'pin-2']);
+    expect(exprsvc.referencedNames('engine')).to.deep.eq([]);
+
+    expect(exprsvc.expressionTriggers('test1')).to.deep.eq(['pin-0']);
+    expect(exprsvc.expressionTriggers('test2')).to.deep.eq(['pin-1']);
+    expect(exprsvc.expressionTriggers('test3')).to.deep.eq(['pin-0', 'pin-2']);
+    expect(exprsvc.expressionTriggers('test4')).to.deep.eq(['pin-0', 'pin-2']);
+    expect(exprsvc.expressionTriggers('test5')).to.deep.eq(['pin-0', 'pin-2']);
+  });
+
+  it('compiles and tests expressions', function () {
+    const exprsvc = new ExpressionService();
+    exprsvc.addName({ name: 'pin-0', defaultValue: 0, channel: 'primary' });
+    exprsvc.addName({ name: 'pin-1', defaultValue: 0, channel: 'device' });
+    exprsvc.addName({ name: 'pin-2', defaultValue: 2, channel: 'device' });
+    exprsvc.addName({ name: 'exec-1', defaultValue: 0, channel: 'engine' });
+
+    const math1 = exprsvc.compileExpression('pin-0');
+    expect(math1.evaluate({ 'pin-0': 5 })).to.eq(5);
+    const math2 = exprsvc.compileExpression('pin-1 + pin-2 + 5');
+    expect(math2.evaluate({ 'pin-1': 3, 'pin-2': 14 })).to.eq(22);
+
+    expect(() => exprsvc.compileExpression('pin-4')).to.throw('Undefined symbol pin-4');
+
+    const math3 = exprsvc.compileExpression('this + 1', { this: 0 });
+    expect(math3.evaluate({ this: 6 })).to.eq(7);
+
+    expect(() => exprsvc.compileExpression('this + 1')).to.throw('Undefined symbol this');
+  });
+
+  /* eslint-disable no-template-curly-in-string */
+
+  it('parses string expressions', function () {
+    const exprsvc = new ExpressionService();
+
+    const parts1 = exprsvc.parseStringExpr('');
+    expect(parts1.length).to.eq(1);
+    expect(parts1[0]).to.deep.eq({ text: '' });
+
+    const parts2 = exprsvc.parseStringExpr('test');
+    expect(parts2.length).to.eq(1);
+    expect(parts2[0]).to.deep.eq({ text: 'test' });
+
+    const parts3 = exprsvc.parseStringExpr('test ${var1}');
+    expect(parts3.length).to.eq(2);
+    expect(parts3[0]).to.deep.eq({ text: 'test ' });
+    expect(parts3[1]).to.deep.eq({ text: '${var1}', expression: 'var1' });
+
+    const parts4 = exprsvc.parseStringExpr('${var1} test');
+    expect(parts4.length).to.eq(2);
+    expect(parts4[0]).to.deep.eq({ text: '${var1}', expression: 'var1' });
+    expect(parts4[1]).to.deep.eq({ text: ' test' });
+
+    const parts5 = exprsvc.parseStringExpr('${var1}');
+    expect(parts5.length).to.eq(1);
+    expect(parts5[0]).to.deep.eq({ text: '${var1}', expression: 'var1' });
+
+    const parts6 = exprsvc.parseStringExpr('test ${var1}${var2} and ${x + y}');
+    expect(parts6.length).to.eq(5);
+    expect(parts6[0]).to.deep.eq({ text: 'test ' });
+    expect(parts6[1]).to.deep.eq({ text: '${var1}', expression: 'var1' });
+    expect(parts6[2]).to.deep.eq({ text: '${var2}', expression: 'var2' });
+    expect(parts6[3]).to.deep.eq({ text: ' and ' });
+    expect(parts6[4]).to.deep.eq({ text: '${x + y}', expression: 'x + y' });
+
+    const parts7 = exprsvc.parseStringExpr('test ${var1{\\}}');
+    expect(parts7.length).to.eq(2);
+    expect(parts7[0]).to.deep.eq({ text: 'test ' });
+    expect(parts7[1]).to.deep.eq({ text: '${var1{\\}}', expression: 'var1{}' });
+
+    const parts8 = exprsvc.parseStringExpr('test \\${var1} ${var1}');
+    expect(parts8.length).to.eq(2);
+    expect(parts8[0]).to.deep.eq({ text: 'test ${var1} ' });
+    expect(parts8[1]).to.deep.eq({ text: '${var1}', expression: 'var1' });
+  });
+
+  it('handles string expression management', function () {
+    const exprsvc = new ExpressionService();
+    exprsvc.addName({ name: 'pin-0', defaultValue: 0, channel: 'primary' });
+    exprsvc.addName({ name: 'pin-1', defaultValue: 0, channel: 'device' });
+    exprsvc.addName({ name: 'pin-2', defaultValue: 2, channel: 'device' });
+    exprsvc.addName({ name: 'exec-1', defaultValue: 0, channel: 'engine' });
+
+    exprsvc.addStringExpression({ string: 'code x', path: 'test1' });
+    expect(exprsvc.referencedNames()).to.deep.eq([]);
+    expect(exprsvc.expressionTriggers('test1')).to.deep.eq([]);
+    expect(exprsvc.hasStringExpression('test1')).to.eq(true);
+    expect(exprsvc.computeStringExpression('test1', {})).to.eq('code x');
+
+    exprsvc.addStringExpression({ string: 'code ${pin-0}', path: 'test2' });
+    expect(exprsvc.referencedNames()).to.deep.eq(['pin-0']);
+    expect(exprsvc.expressionTriggers('test2')).to.deep.eq(['pin-0']);
+    expect(exprsvc.hasStringExpression('test2')).to.eq(true);
+    expect(exprsvc.computeStringExpression('test2', { 'pin-0': 5 })).to.eq('code 5');
+
+    exprsvc.addStringExpression({ string: 'code ${pin-0} and ${pin-1 + pin-2}', path: 'test3' });
+    expect(exprsvc.referencedNames()).to.deep.eq(['pin-0', 'pin-1', 'pin-2']);
+    expect(exprsvc.expressionTriggers('test3')).to.deep.eq(['pin-0', 'pin-1', 'pin-2']);
+    expect(exprsvc.hasStringExpression('test3')).to.eq(true);
+    expect(exprsvc.computeStringExpression('test3', { 'pin-0': 5, 'pin-1': 10, 'pin-2': 20 })).to.eq('code 5 and 30');
+  });
+});