Added NumericalExpressionDataToNodeConverter tests

test/index.spec.ts

@@ -29,6 +29,7 @@ import './unit-tests/node/node-literal-utils/NodeLiteralUtils.spec';
 import './unit-tests/node/node-metadata/NodeMetadata.spec';
 import './unit-tests/node/node-statement-utils/NodeStatementUtils.spec';
 import './unit-tests/node/node-utils/NodeUtils.spec';
+import './unit-tests/node/numerical-expression-data-to-node-converter/NumericalExpressionDataToNodeConverter.spec';
 import './unit-tests/options/Options.spec';
 import './unit-tests/options/ValidationErrorsFormatter.spec';
 import './unit-tests/source-code/ObfuscatedCode.spec';

test/unit-tests/node/numerical-expression-data-to-node-converter/NumericalExpressionDataToNodeConverter.spec.ts

@@ -0,0 +1,56 @@
+import 'reflect-metadata';
+
+import * as ESTree from 'estree';
+
+import { assert } from 'chai';
+
+import { TNumberNumericalExpressionData } from '../../../../src/types/analyzers/number-numerical-expression-analyzer/TNumberNumericalExpressionData';
+
+import { NodeFactory } from '../../../../src/node/NodeFactory';
+import { NumericalExpressionDataToNodeConverter } from '../../../../src/node/NumericalExpressionDataToNodeConverter';
+
+describe('NumericalExpressionDataToNodeConverter', () => {
+    describe('Variant #1: base', () => {
+        const expectedExpressionNode: ESTree.Expression = NodeFactory.binaryExpressionNode(
+            '+',
+            NodeFactory.binaryExpressionNode(
+                '+',
+                NodeFactory.literalNode(1),
+                NodeFactory.binaryExpressionNode(
+                    '*',
+                    NodeFactory.unaryExpressionNode(
+                        '-',
+                        NodeFactory.literalNode(2),
+                    ),
+                    NodeFactory.literalNode(3)
+                ),
+            ),
+            NodeFactory.literalNode(4)
+        );
+        const numberNumericalExpressionData: TNumberNumericalExpressionData = [
+            1, [-2, 3], 4
+        ];
+
+        let expressionNode: ESTree.Expression;
+
+        before(() => {
+            expressionNode = NumericalExpressionDataToNodeConverter.convert(
+                numberNumericalExpressionData,
+                (number: number, isPositiveNumber: boolean): ESTree.Expression => {
+                    const numberLiteralNode: ESTree.Literal = NodeFactory.literalNode(number);
+
+                    return isPositiveNumber
+                        ? numberLiteralNode
+                        : NodeFactory.unaryExpressionNode(
+                            '-',
+                            numberLiteralNode
+                        );
+                }
+            );
+        });
+
+        it('should convert number numerical expression data to expression node', () => {
+            assert.deepEqual(expressionNode, expectedExpressionNode);
+        });
+    });
+});