@cloudpss/expression 0.6.0-alpha.2 → 0.6.0-alpha.20

package/tests/analyze.ts

@@ -1,15 +1,49 @@
 import { Evaluator, Expression, Scope } from '../dist/index.js';
 
 const e = new Evaluator();
-const s = new Scope({}, false);
+e.import({ w: 123 });
+const s = new Scope({ sin: 12 }, false);
 
-describe.skip('Analyze', () => {
+describe('Analyze', () => {
     it('simple', () => {
-        expect(e.analyze(Expression('a+b'), s)).toEqual([['a'], ['b']]);
+        expect(e.analyze(Expression('  '), s)).toEqual([]);
+        expect(e.analyze(Expression('a + b + @c'), s)).toEqual([['a'], ['b'], ['@c']]);
+    });
+    it('bad', () => {
+        expect(e.analyze(Expression('a + '), s)).toEqual([]);
+        expect(e.analyze(Expression('a.b.'), s)).toEqual([]);
+        expect(() => e.analyze(Expression('a.b.'))).toThrow();
+    });
+    it('local', () => {
+        expect(e.analyze(Expression('let a = 12; a + nil'), s)).toEqual([]);
+        expect(e.analyze(Expression('let a = 12; a + nil'), s)).toEqual([]);
+        expect(e.analyze(Expression('let a = 12; a + b'), s)).toEqual([['b']]);
+    });
+    it('repeat', () => {
+        expect(e.analyze(Expression('a + b + a + a.b + b.c + a * a !. b'), s)).toEqual([
+            ['a'],
+            ['b'],
+            ['a', 'b'],
+            ['b', 'c'],
+        ]);
+    });
+    it('prefixed', () => {
+        expect(e.analyze(Expression('@@a + $b + c. $$ + $'), s)).toEqual([['@@a'], ['$b'], ['c', '$$'], ['$']]);
+    });
+    it('unicode', () => {
+        expect(e.analyze(Expression('变量.属性 + 变量2[索引] + 函数()'), s)).toEqual([]);
     });
     it('access', () => {
-        expect(e.analyze(Expression('a.b[1]+b'), s)).toEqual([['a', 'b'], ['b']]);
-        expect(e.analyze(Expression('a.b["x"]+b'), s)).toEqual([['a', 'b', 'x'], ['b']]);
-        expect(e.analyze(Expression('a.b[x]+b'), s)).toEqual([['a', 'b'], ['x'], ['b']]);
+        expect(e.analyze(Expression('a .b [1]+b'), s)).toEqual([['a', 'b'], ['b']]);
+        expect(e.analyze(Expression('a. b["x"]+b'), s)).toEqual([['a', 'b'], ['b']]);
+        expect(e.analyze(Expression('a.b[x] + b + c.12.3'), s)).toEqual([['a', 'b'], ['x'], ['b'], ['c', 12, 3]]);
+    });
+    it('with lib', () => {
+        const e0 = new Evaluator();
+        const exp = Expression('sin(x) + y::z.t()::cos() + w.123');
+        expect(e.analyze(exp, s)).toEqual([['sin'], ['x'], ['z', 't'], ['y']]);
+        expect(e0.analyze(exp, s)).toEqual([['sin'], ['x'], ['z', 't'], ['y'], ['w', 123]]);
+        expect(e.analyze(exp)).toEqual([['x'], ['z', 't'], ['y']]);
+        expect(e0.analyze(exp)).toEqual([['x'], ['z', 't'], ['y'], ['w', 123]]);
     });
 });

package/tests/compile.ts

@@ -0,0 +1,65 @@
+import { Evaluator, Expression, Scope } from '../dist/index.js';
+
+const e = new Evaluator({
+    logger: {
+        warn: () => void 0,
+        error: () => void 0,
+        info: () => void 0,
+        debug: () => void 0,
+    },
+});
+const s = new Scope({}, false);
+
+describe('Evaluator.compile should work correctly', () => {
+    it('should eval const', () => {
+        const result = e.compile(Expression('12'), false);
+        expect(result(s, e)).toBe(12);
+        expect(e.evaluate(result, s)).toBe(12);
+    });
+
+    it('should eval exp', () => {
+        const result = e.compile(Expression('exp(2)'), false);
+        expect(result(s, e)).toBe(Math.exp(2));
+        expect(e.evaluate(result, s)).toBe(Math.exp(2));
+    });
+
+    it('should eval error', () => {
+        const result = e.compile(Expression('exp+++'), false);
+        expect(result(s, e)).toBe(null);
+        expect(e.evaluate(result, s)).toBe(null);
+    });
+});
+
+describe('Evaluator.compile should convert result', () => {
+    it('should eval const', () => {
+        const result = e.compile(Expression('12', 'string'), false);
+        expect(result(s, e)).toBe('12');
+        expect(e.evaluate(result, s)).toBe('12');
+    });
+
+    it('should eval exp', () => {
+        const result = e.compile(Expression('exp(2)', 's'), false);
+        expect(result(s, e)).toBe(Math.exp(2).toString());
+        expect(e.evaluate(result, s)).toBe(Math.exp(2).toString());
+    });
+
+    it('should not convert defaults', () => {
+        {
+            const result = e.compile(Expression('nil', 's'), false);
+            expect(result(s, e)).toBe(null);
+            expect(e.evaluate(result, s, 1)).toBe(1);
+        }
+        {
+            // syntax error
+            const result = e.compile(Expression('exp+++', 's'), false);
+            expect(result(s, e)).toBe(null);
+            expect(e.evaluate(result, s, 1)).toBe(1);
+        }
+        {
+            // runtime error
+            const result = e.compile(Expression('x() + 1', 's'), false);
+            expect(result(s, e)).toBe(null);
+            expect(e.evaluate(result, s, 1)).toBe(1);
+        }
+    });
+});

package/tests/condition.ts

@@ -1,6 +1,16 @@
 import { Evaluator, type ExpressionSource, Scope } from '../dist/index.js';
 
-const e = new Evaluator();
+const e = new Evaluator({
+    logger: undefined,
+});
+const en = new Evaluator({
+    logger: {
+        warn: () => void 0,
+        error: () => void 0,
+        info: () => void 0,
+        debug: () => void 0,
+    },
+});
 const s = new Scope(undefined, false);
 
 describe('Evaluate conditions', () => {
@@ -9,7 +19,6 @@ describe('Evaluate conditions', () => {
         expect(e.evaluateCondition(false, s)).toBe(false);
     });
     it('can evaluate empty literals', () => {
-        // @ts-expect-error null
         expect(e.evaluateCondition(null, s)).toBe(true);
         expect(e.evaluateCondition(undefined, s)).toBe(true);
     });
@@ -18,20 +27,28 @@ describe('Evaluate conditions', () => {
         expect(e.evaluateCondition('true' as ExpressionSource<boolean>, s)).toBe(true);
         expect(e.evaluateCondition('false' as ExpressionSource<boolean>, s)).toBe(false);
     });
-    it('can convert to boolean', () => {
-        expect(e.evaluateCondition('""' as ExpressionSource<boolean>, s)).toBe(true);
-        expect(e.evaluateCondition('nil' as ExpressionSource<boolean>, s)).toBe(true);
-        expect(e.evaluateCondition('undefined' as ExpressionSource<boolean>, s)).toBe(true);
-        expect(e.evaluateCondition('0' as ExpressionSource<boolean>, s)).toBe(true);
-        expect(e.evaluateCondition('nan' as ExpressionSource<boolean>, s)).toBe(true);
+    it('can evaluate to boolean', () => {
         expect(e.evaluateCondition('(false)' as ExpressionSource<boolean>, s)).toBe(false);
-
-        expect(e.evaluateCondition('""' as ExpressionSource<boolean>, s, false)).toBe(true);
-        expect(e.evaluateCondition('nil' as ExpressionSource<boolean>, s, false)).toBe(false);
-        expect(e.evaluateCondition('undefined' as ExpressionSource<boolean>, s, false)).toBe(false);
-        expect(e.evaluateCondition('0' as ExpressionSource<boolean>, s, false)).toBe(true);
-        expect(e.evaluateCondition('nan' as ExpressionSource<boolean>, s, false)).toBe(true);
+        expect(e.evaluateCondition('(true)' as ExpressionSource<boolean>, s)).toBe(true);
         expect(e.evaluateCondition('(false)' as ExpressionSource<boolean>, s, false)).toBe(false);
+        expect(e.evaluateCondition('(true)' as ExpressionSource<boolean>, s, false)).toBe(true);
+    });
+    it('can evaluate to nil', () => {
+        expect(e.evaluateCondition('{}' as ExpressionSource<boolean>, s)).toBe(true);
+        expect(e.evaluateCondition('{}' as ExpressionSource<boolean>, s, false)).toBe(false);
+    });
+    it('do not convert to boolean', () => {
+        expect(en.evaluateCondition('""' as ExpressionSource<boolean>, s)).toBe(true);
+        expect(en.evaluateCondition('nil' as ExpressionSource<boolean>, s)).toBe(true);
+        expect(en.evaluateCondition('undefined' as ExpressionSource<boolean>, s)).toBe(true);
+        expect(en.evaluateCondition('0' as ExpressionSource<boolean>, s)).toBe(true);
+        expect(en.evaluateCondition('nan' as ExpressionSource<boolean>, s)).toBe(true);
+
+        expect(en.evaluateCondition('""' as ExpressionSource<boolean>, s, false)).toBe(false);
+        expect(en.evaluateCondition('nil' as ExpressionSource<boolean>, s, false)).toBe(false);
+        expect(en.evaluateCondition('undefined' as ExpressionSource<boolean>, s, false)).toBe(false);
+        expect(en.evaluateCondition('0' as ExpressionSource<boolean>, s, false)).toBe(false);
+        expect(en.evaluateCondition('nan' as ExpressionSource<boolean>, s, false)).toBe(false);
     });
     it('can evaluate complex', () => {
         expect(e.evaluateCondition('12>3' as ExpressionSource<boolean>, s)).toBe(true);
@@ -42,8 +59,7 @@ describe('Evaluate conditions', () => {
         expect(e.evaluateCondition('12<=3' as ExpressionSource<boolean>, s)).toBe(false);
     });
     it('can return default on error', () => {
-        expect(e.evaluateCondition('12>>3' as ExpressionSource<boolean>, undefined, true)).toBe(true);
-        // @ts-expect-error null
-        expect(e.evaluateCondition('12>>3' as ExpressionSource<boolean>, null, false)).toBe(false);
+        expect(en.evaluateCondition('12>>3' as ExpressionSource<boolean>, undefined, true)).toBe(true);
+        expect(en.evaluateCondition('12>>3' as ExpressionSource<boolean>, null, false)).toBe(false);
     });
 });

package/tests/definition.ts

@@ -1,42 +1,261 @@
+import { jest } from '@jest/globals';
 import * as def from '../dist/definitions.js';
+import { Expression } from '../dist/expression.js';
 
 describe('definitions', () => {
     it('should handle parameter', () => {
-        expect(def.Parameter()).toBeDefined();
-        expect(def.isParameter(def.Parameter())).toBe(true);
+        expect(def.isParameter(null)).toBe(false);
+        expect(def.isParameter(() => void 0)).toBe(false);
+        expect(def.isParameter({ key: '', name: '', description: '', type: 'real', value: 0 })).toBe(true);
+        expect(def.isParameter({ type: 'label' })).toBe(false);
+        expect(def.isParameter({ name: '', description: '', items: [] })).toBe(false);
     });
 
     it('should handle parameter group', () => {
-        expect(def.ParameterGroup()).toBeDefined();
-        expect(def.isParameterGroup(def.ParameterGroup())).toBe(true);
+        expect(def.isParameterGroup(null)).toBe(false);
+        expect(def.isParameterGroup(() => void 0)).toBe(false);
+        expect(def.isParameterGroup({ name: '', description: '', items: [] })).toBe(true);
+        expect(def.isParameterGroup({ items: [] })).toBe(false);
+        expect(def.isParameterGroup({ key: '', name: '', description: '', items: [] })).toBe(false);
     });
 
     it('should handle parameter decoration', () => {
-        expect(def.ParameterDecoration()).toBeDefined();
-        expect(def.isParameterDecoration(def.ParameterDecoration())).toBe(true);
+        expect(def.isParameterDecoration(null)).toBe(false);
+        expect(def.isParameterDecoration(() => void 0)).toBe(false);
+        expect(def.isParameterDecoration({ type: 'label' })).toBe(true);
+        expect(def.isParameterDecoration({ name: '', description: '', items: [] })).toBe(false);
+        expect(def.isParameterDecoration({ key: '', name: '', description: '', type: 'real', value: 0 })).toBe(false);
     });
 
     it('should handle parameter decoration group', () => {
-        expect(def.ParameterDecorationGroup()).toBeDefined();
-        expect(def.isParameterDecorationGroup(def.ParameterDecorationGroup())).toBe(true);
+        expect(def.isParameterDecorationGroup(null)).toBe(false);
+        expect(def.isParameterDecorationGroup(() => void 0)).toBe(false);
+        expect(def.isParameterDecorationGroup({ items: [] })).toBe(true);
+        expect(def.isParameterDecorationGroup({ name: '', description: '', items: [] })).toBe(false);
     });
 
     it('should handle variable', () => {
-        expect(def.Variable()).toBeDefined();
-        expect(def.isVariable(def.Variable())).toBe(true);
+        expect(def.isVariable(null)).toBe(false);
+        expect(def.isVariable(() => void 0)).toBe(false);
+        expect(def.isVariable({ key: '', value: 0 })).toBe(true);
+        expect(def.isVariable({ key: '', name: '', description: '', type: 'real', value: 0 })).toBe(false);
     });
 
     it('should handle choice', () => {
-        expect(def.Choice()).toBeDefined();
-        expect(def.isChoice(def.Choice())).toBe(true);
+        expect(def.isChoice(null)).toBe(false);
+        expect(def.isChoice(() => void 0)).toBe(false);
+        expect(def.isChoice({ name: '', description: '' })).toBe(true);
+        expect(def.isChoice({ key: null, name: '', description: '' })).toBe(true);
+        expect(def.isChoice({ key: '', name: '', description: '' })).toBe(true);
+    });
+
+    it('should handle constraint', () => {
+        expect(def.isConstraint(null)).toBe(false);
+        expect(def.isConstraint(() => void 0)).toBe(false);
+        expect(def.isConstraint({ name: '', description: '' })).toBe(false);
+        expect(def.isConstraint({ key: null, name: '', description: '' })).toBe(false);
+        expect(def.isConstraint({ key: '', name: '', description: '' })).toBe(false);
+        expect(def.isConstraint({ message: '' })).toBe(false);
+        expect(def.isConstraint({ condition: '' })).toBe(false);
+        expect(def.isConstraint({ message: '', condition: '' })).toBe(true);
+        expect(def.isConstraint({ message: '', condition: '', level: 'error' })).toBe(true);
+        expect(def.isConstraint({ message: '', condition: '', level: 'error', messageData: '' })).toBe(true);
+        expect(def.isConstraint({ message: '', condition: '', messageData: {} })).toBe(true);
+        expect(def.isConstraint({ message: '', condition: '', messageData: null })).toBe(true);
+        expect(def.isConstraint({ message: '', condition: '', messageData: undefined })).toBe(true);
+        expect(def.isConstraint({ message: '', condition: '', messageData: () => void 0 })).toBe(true);
+        expect(def.isConstraint({ message: '', condition: '', messageData: 1 })).toBe(false);
+    });
 
-        expect(def.Choice('x').key).toBe('x');
-        expect(def.isChoice(def.Choice('x'))).toBe(true);
+    it('should generate track id', () => {
+        const mockRandom = jest
+            .spyOn(Math, 'random')
+            .mockReturnValueOnce(0)
+            .mockReturnValueOnce(1 - 2 ** -53);
+        const id1 = def.generateTrackId();
+        const id2 = def.generateTrackId();
+        mockRandom.mockRestore();
+        expect(id1).toBe(1);
+        expect(id2).toBe(0x7fff_ffff);
+    });
 
-        expect(def.Choice(0).key).toBe(0);
-        expect(def.isChoice(def.Choice(0))).toBe(true);
+    it('should convert argument value', () => {
+        // @ts-expect-error 未知类型
+        expect(def.toArgumentValue(undefined, { type: 'xxx', key: '', name: '', description: '', value: 1 })).toBe(
+            null,
+        );
+        expect(def.toArgumentValue(undefined, { type: 'real', key: '', name: '', description: '', value: 1 })).toBe(
+            null,
+        );
+        expect(def.toArgumentValue(null, { type: 'real', key: '', name: '', description: '', value: 1 })).toBe(null);
+        expect(def.toArgumentValue('12', { type: 'real', key: '', name: '', description: '', value: 1 })).toBe(12);
+        expect(def.toArgumentValue(null, { type: 'text', key: '', name: '', description: '', value: '1' })).toBe('');
+        expect(def.toArgumentValue(12, { type: 'text', key: '', name: '', description: '', value: '1' })).toBe('12');
+        expect(
+            def.toArgumentValue(null, { type: 'grouped', key: '', name: '', description: '', value: {}, items: [] }),
+        ).toBe(null);
 
-        expect(def.Choice(false).key).toBe(false);
-        expect(def.isChoice(def.Choice(false))).toBe(true);
+        expect(
+            def.toArgumentValue(null, { type: 'choice', key: '', name: '', description: '', value: 1, choices: [] }),
+        ).toBe(null);
+        expect(
+            def.toArgumentValue(null, {
+                type: 'choice',
+                key: '',
+                name: '',
+                description: '',
+                value: 1,
+                choices: [{ key: '0', name: '', description: '' }],
+            }),
+        ).toBe('');
+        expect(
+            def.toArgumentValue(null, {
+                type: 'choice',
+                key: '',
+                name: '',
+                description: '',
+                value: 1,
+                choices: [
+                    { key: '0', name: '', description: '' },
+                    { key: 1, name: '', description: '' },
+                ],
+            }),
+        ).toBe('');
+        expect(def.toArgumentValue(null, { type: 'logical', key: '', name: '', description: '', value: 1 })).toBe(null);
+        expect(def.toArgumentValue('0', { type: 'logical', key: '', name: '', description: '', value: 1 })).toBe(0);
+        expect(
+            def.toArgumentValue(null, {
+                type: 'logical',
+                key: '',
+                name: '',
+                description: '',
+                value: false,
+                choices: [
+                    { key: 0, name: '', description: '' },
+                    { key: 1, name: '', description: '' },
+                ],
+            }),
+        ).toBe(null);
+        expect(
+            def.toArgumentValue(null, {
+                type: 'logical',
+                key: '',
+                name: '',
+                description: '',
+                value: true,
+            }),
+        ).toBe(null);
+        expect(
+            def.toArgumentValue(null, {
+                type: 'logical',
+                key: '',
+                name: '',
+                description: '',
+                value: 'true',
+            }),
+        ).toBe('');
+        expect(
+            def.toArgumentValue(null, {
+                type: 'logical',
+                key: '',
+                name: '',
+                description: '',
+                value: 'true',
+                choices: [
+                    { key: '0', name: '', description: '' },
+                    { key: '1', name: '', description: '' },
+                ],
+            }),
+        ).toBe('');
+        expect(
+            def.toArgumentValue(null, {
+                type: 'multiSelect',
+                key: '',
+                name: '',
+                description: '',
+                value: [1],
+                choices: [],
+            }),
+        ).toStrictEqual([]);
+        expect(
+            def.toArgumentValue(1, {
+                type: 'multiSelect',
+                key: '',
+                name: '',
+                description: '',
+                value: [1],
+                choices: [],
+            }),
+        ).toStrictEqual([1]);
+        expect(
+            def.toArgumentValue('', {
+                type: 'multiSelect',
+                key: '',
+                name: '',
+                description: '',
+                value: [1],
+                choices: [],
+            }),
+        ).toStrictEqual(null);
+        expect(
+            def.toArgumentValue('', {
+                type: 'multiSelect',
+                key: '',
+                name: '',
+                description: '',
+                value: [1],
+                choices: Expression(''),
+            }),
+        ).toStrictEqual(null);
+        expect(
+            def.toArgumentValue(['', '1', '  2 '], {
+                type: 'multiSelect',
+                key: '',
+                name: '',
+                description: '',
+                value: [1],
+                choices: [],
+            }),
+        ).toStrictEqual(null);
+        expect(
+            def.toArgumentValue(['0', '1', '  2 '], {
+                type: 'multiSelect',
+                key: '',
+                name: '',
+                description: '',
+                value: [1],
+                choices: [],
+            }),
+        ).toStrictEqual([0, 1, 2]);
+        expect(
+            def.toArgumentValue(['0', '1', '  2 '], {
+                type: 'multiSelect',
+                key: '',
+                name: '',
+                description: '',
+                value: [],
+                choices: [],
+            }),
+        ).toStrictEqual([0, 1, 2]);
+        expect(
+            def.toArgumentValue([1, 2], {
+                type: 'multiSelect',
+                key: '',
+                name: '',
+                description: '',
+                value: ['1'],
+                choices: [],
+            }),
+        ).toStrictEqual(['1', '2']);
+        expect(
+            def.toArgumentValue(['', '1', '  2 '], {
+                type: 'multiSelect',
+                key: '',
+                name: '',
+                description: '',
+                value: [1],
+                choices: Expression(''),
+            }),
+        ).toStrictEqual(null);
     });
 });

package/tests/eval-complex.ts

@@ -44,18 +44,15 @@ describe('Evaluator should work correctly', () => {
         const result = e.evaluate(Expression('a.0'), s);
         expect(result).toBe(36);
     });
-    it('should eval deep with extern', () => {
+    it('should not eval deep with extern', () => {
         const s = new Scope(
             {
-                a: new VmExtern([Expression('b.0 + d.0')]),
-                b: new VmExtern([Expression('c.0 + d.0')]),
-                c: new VmExtern([12]),
-                d: new VmExtern([Expression('c.0')]),
+                a: new VmExtern([Expression('1')]),
             },
             false,
         );
-        const result = e.evaluate(Expression('a.0'), s);
-        expect(result).toBe(36);
+        const result = e.evaluate<VmExtern>(Expression('a.0'), s);
+        expect(result?.value).toStrictEqual(Expression('1'));
     });
     it('should eval deep with compiled expression', () => {
         const s = new Scope(
@@ -105,7 +102,7 @@ describe('Evaluator should work correctly', () => {
         const result = e.evaluate(Expression('a + a + a + a + a + a + a + a + a + a'), s);
         expect(result).toBe(10);
     });
-    it('should report loop', () => {
+    it('should report loop by scope', () => {
         const s = new Scope(
             {
                 a: Expression('b'),
@@ -114,6 +111,17 @@ describe('Evaluator should work correctly', () => {
             },
             true,
         );
+        expect(() => e.evaluate(Expression('a'), s)).toThrow(/Execution recursion exceeds limit/);
+    });
+    it('should report loop by mirascript', () => {
+        const s = new Scope(
+            {
+                a: Expression('fn x{b}x()'),
+                b: Expression('fn x{c}x()'),
+                c: Expression('fn x{a}x()'),
+            },
+            true,
+        );
         expect(() => e.evaluate(Expression('a'), s)).toThrow(/Maximum call depth exceeded/);
     });
 
@@ -132,7 +140,7 @@ describe('Evaluator should work correctly', () => {
             a: new ArrayBuffer(0),
             v: new DataView(new ArrayBuffer(0)),
             test() {
-                expect(this).toBeProxy();
+                expect(this).not.toBeProxy();
                 expect(this.d).not.toBeProxy();
                 expect(this.r).not.toBeProxy();
                 // eslint-disable-next-line @typescript-eslint/unbound-method
@@ -144,7 +152,7 @@ describe('Evaluator should work correctly', () => {
             },
         });
         const s = new Scope({ o }, true);
-        expect(e.evaluate(Expression('o.test()'), s)).toBe(3);
-        expect(e.evaluate(Expression('o.z'), s)).toBe(3);
+        expect(e.evaluate<VmExtern>(Expression('o.test()'), s)?.value).toStrictEqual(Expression('o.y+o.x.p'));
+        expect(e.evaluate<VmExtern>(Expression('o.z'), s)?.value).toStrictEqual(Expression('o.y+o.x.p'));
     });
 });

package/tests/eval.ts

@@ -1,9 +1,17 @@
-import { Evaluator, Expression, Scope } from '../dist/index.js';
+import { Evaluator, Expression, Scope, VmFunction } from '../dist/index.js';
 
-const e = new Evaluator();
+const e = new Evaluator({
+    logger: {
+        warn: () => void 0,
+        error: () => void 0,
+        info: () => void 0,
+        debug: () => void 0,
+    },
+});
 const s = new Scope({}, false);
+const st = new Scope(null, true);
 
-describe('Evaluator should work correctly', () => {
+describe('Evaluator.evaluate should work correctly', () => {
     it('should eval const', () => {
         const result = e.evaluate(Expression('12'), s);
         expect(result).toBe(12);
@@ -16,11 +24,39 @@ describe('Evaluator should work correctly', () => {
 
     it('should eval error', () => {
         const result = e.evaluate(Expression('exp+++'), s);
-        expect(result).toBe(undefined);
+        expect(result).toBe(null);
+    });
+
+    it('should eval null', () => {
+        const result = e.evaluate(null, s);
+        expect(result).toBe(null);
+    });
+    it('should eval undefined', () => {
+        const result = e.evaluate(undefined, s);
+        expect(result).toBe(null);
+    });
+    it('should eval value', () => {
+        {
+            const result = e.evaluate(1, s);
+            expect(result).toBe(1);
+        }
+        {
+            const result = e.evaluate('', s);
+            expect(result).toBe('');
+        }
+        {
+            const result = e.evaluate(false, s);
+            expect(result).toBe(false);
+        }
+    });
+    it('should eval vm function', () => {
+        const f = VmFunction(() => 1);
+        const result = e.evaluate(f, s);
+        expect(result).toBe(f);
     });
 });
 
-describe('Evaluator should convert result', () => {
+describe('Evaluator.evaluate should convert result', () => {
     it('should eval const', () => {
         const result = e.evaluate(Expression('12', 'string'), s);
         expect(result).toBe('12');
@@ -31,12 +67,23 @@ describe('Evaluator should convert result', () => {
         expect(result).toBe(Math.exp(2).toString());
     });
 
-    it('should not convert when error', () => {
-        // syntax error
-        const result = e.evaluate(Expression('exp+++', 's'), s, 1);
-        expect(result).toBe(1);
-        // runtime error
-        const result2 = e.evaluate(Expression('x() + 1', 's'), s, 1);
-        expect(result2).toBe(1);
+    it('should not convert defaults', () => {
+        {
+            const result = e.evaluate(Expression('nil', 's'), s, 1);
+            expect(result).toBe(1);
+        }
+        {
+            // syntax error
+            expect(() => e.evaluate(Expression('exp+++', 's'), undefined, 1)).toThrow();
+        }
+        {
+            // syntax error cached
+            expect(() => e.evaluate(Expression('exp+++', 's'), st)).toThrow();
+        }
+        {
+            // runtime error
+            const result = e.evaluate(Expression('x() + 1', 's'), s, 1);
+            expect(result).toBe(1);
+        }
     });
 });