@divmain/jdm-asm 0.2.0 → 0.2.3

package/tests/unit/compiler/optimizer-cache.test.ts

@@ -1,327 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import {
-  runOptimizations,
-  getExpressionCache,
-  clearExpressionCache,
-  constantFolding,
-  deadCodeElimination,
-} from '../../../src/compiler/optimizer';
-import { type JDMDecision, type JDMNode, NodeType } from '../../../src/compiler/parser';
-import * as unaryParser from '../../../src/compiler/unary-parser';
-
-describe('Optimizer Expression Caching', () => {
-  describe('Cache Initialization', () => {
-    it('should create cache on first access', () => {
-      const node: JDMNode = {
-        id: 'test-1',
-        type: NodeType.DECISION_TABLE,
-        name: 'Test',
-        position: { x: 0, y: 0 },
-      };
-
-      const cache = getExpressionCache(node);
-
-      expect(cache).toBeDefined();
-      expect(cache.size).toBe(0);
-      expect(node.parsedContent).toBeDefined();
-      expect(node.parsedContent._cachedExprs).toBe(cache);
-    });
-
-    it('should return existing cache on subsequent access', () => {
-      const node: JDMNode = {
-        id: 'test-2',
-        type: NodeType.DECISION_TABLE,
-        name: 'Test',
-        position: { x: 0, y: 0 },
-      };
-
-      const cache1 = getExpressionCache(node);
-      const cache2 = getExpressionCache(node);
-
-      expect(cache1).toBe(cache2);
-    });
-  });
-
-  describe('Cache Usage During Optimization', () => {
-    it('should cache parsed expressions in constant folding', () => {
-      const ast: JDMDecision = {
-        nodes: [
-          {
-            id: 'dt-1',
-            type: NodeType.DECISION_TABLE,
-            name: 'Test Table',
-            position: { x: 0, y: 0 },
-            content: {
-              inputs: [{ id: 'input1', field: 'x' }],
-              outputs: [{ id: 'output1', field: 'result' }],
-              rules: [
-                { input1: '> 5', output1: '10' },
-                { input1: '> 3', output1: '5' },
-              ],
-            },
-          },
-        ],
-        edges: [],
-      };
-
-      const optimized = constantFolding(ast);
-      const node = optimized.nodes[0];
-      const cache = getExpressionCache(node);
-
-      // The expressions should be cached
-      expect(cache.size).toBeGreaterThan(0);
-    });
-
-    it('should reuse cached expressions across multiple passes', () => {
-      const parseUnaryMock = vi.spyOn(unaryParser, 'parseUnaryExpression');
-      const parseStandardMock = vi.spyOn(unaryParser, 'parseStandardExpression');
-
-      const ast: JDMDecision = {
-        nodes: [
-          {
-            id: 'dt-1',
-            type: NodeType.DECISION_TABLE,
-            name: 'Test Table',
-            position: { x: 0, y: 0 },
-            content: {
-              inputs: [{ id: 'input1', field: 'x' }],
-              outputs: [{ id: 'output1', field: 'result' }],
-              rules: [
-                { input1: '> 5', output1: '10' },
-                { input1: '> 5', output1: '20' }, // Same expression as first rule
-              ],
-            },
-          },
-        ],
-        edges: [],
-      };
-
-      // Run constant folding first
-      const afterFolding = constantFolding(ast);
-      const foldingCalls = parseUnaryMock.mock.calls.length;
-
-      // Clear mock counts
-      parseUnaryMock.mockClear();
-
-      // Run dead code elimination on the already-cached node
-      deadCodeElimination(afterFolding);
-      const dceCalls = parseUnaryMock.mock.calls.length;
-
-      // DCE should use cached expressions, so should parse fewer (or zero) new expressions
-      expect(dceCalls).toBeLessThanOrEqual(foldingCalls);
-
-      parseUnaryMock.mockRestore();
-      parseStandardMock.mockRestore();
-    });
-
-    it('should cache expressions in switch nodes', () => {
-      const ast: JDMDecision = {
-        nodes: [
-          {
-            id: 'switch-1',
-            type: NodeType.SWITCH,
-            name: 'Test Switch',
-            position: { x: 0, y: 0 },
-            content: {
-              conditions: [
-                { id: '1', expression: 'x > 5' },
-                { id: '2', expression: 'x > 3' },
-              ],
-            },
-          },
-        ],
-        edges: [],
-      };
-
-      const optimized = constantFolding(ast);
-      const node = optimized.nodes[0];
-      const cache = getExpressionCache(node);
-
-      expect(cache.size).toBeGreaterThan(0);
-    });
-
-    it('should cache expressions in expression nodes', () => {
-      const ast: JDMDecision = {
-        nodes: [
-          {
-            id: 'expr-1',
-            type: NodeType.EXPRESSION,
-            name: 'Test Expression',
-            position: { x: 0, y: 0 },
-            content: {
-              expression: 'x + y', // Non-foldable expression to preserve cache
-            },
-          },
-        ],
-        edges: [],
-      };
-
-      const optimized = constantFolding(ast);
-      const node = optimized.nodes[0];
-      const cache = getExpressionCache(node);
-
-      // Expression can't be folded, so cache is preserved
-      expect(cache.size).toBeGreaterThan(0);
-    });
-  });
-
-  describe('Cache Invalidation', () => {
-    it('should clear cache when expressions are modified', () => {
-      const ast: JDMDecision = {
-        nodes: [
-          {
-            id: 'expr-1',
-            type: NodeType.EXPRESSION,
-            name: 'Test Expression',
-            position: { x: 0, y: 0 },
-            content: {
-              expression: '2 + 3', // This will be folded to "5"
-            },
-          },
-        ],
-        edges: [],
-      };
-
-      const optimized = constantFolding(ast);
-      const node = optimized.nodes[0];
-      const cache = getExpressionCache(node);
-
-      // After constant folding, the expression changed, so cache should be cleared
-      // The folded expression should be "5", which is different from original
-      expect(node.content.expression).toBe('5');
-
-      // Cache should be empty after modification
-      expect(cache.size).toBe(0);
-    });
-
-    it('should clear cache manually', () => {
-      const node: JDMNode = {
-        id: 'test-1',
-        type: NodeType.DECISION_TABLE,
-        name: 'Test',
-        position: { x: 0, y: 0 },
-      };
-
-      const cache = getExpressionCache(node);
-      cache.set('test', { type: 'NumberLiteral', value: 42 });
-
-      expect(cache.size).toBe(1);
-
-      clearExpressionCache(node);
-
-      expect(cache.size).toBe(0);
-    });
-  });
-
-  describe('Cache Correctness', () => {
-    it('should produce same results with and without cache', () => {
-      const ast: JDMDecision = {
-        nodes: [
-          {
-            id: 'dt-1',
-            type: NodeType.DECISION_TABLE,
-            name: 'Test Table',
-            position: { x: 0, y: 0 },
-            content: {
-              inputs: [{ id: 'input1', field: 'x' }],
-              outputs: [{ id: 'output1', field: 'result' }],
-              rules: [
-                { input1: '> 5', output1: '10' },
-                { input1: '> 3', output1: '5' },
-              ],
-            },
-          },
-        ],
-        edges: [],
-      };
-
-      // Deep clone to avoid sharing state
-      const ast1 = JSON.parse(JSON.stringify(ast));
-      const ast2 = JSON.parse(JSON.stringify(ast));
-
-      // Run optimizations on both
-      const optimized1 = runOptimizations(ast1);
-      const optimized2 = runOptimizations(ast2);
-
-      // Clear cache from both to compare only the content
-      if (optimized1.nodes[0].parsedContent) {
-        delete optimized1.nodes[0].parsedContent._cachedExprs;
-      }
-      if (optimized2.nodes[0].parsedContent) {
-        delete optimized2.nodes[0].parsedContent._cachedExprs;
-      }
-
-      // Results should be identical
-      expect(optimized1).toEqual(optimized2);
-    });
-  });
-
-  describe('Cache with Deep Copy', () => {
-    it('should preserve cache across JSON deep copy in optimization passes', () => {
-      const ast: JDMDecision = {
-        nodes: [
-          {
-            id: 'dt-1',
-            type: NodeType.DECISION_TABLE,
-            name: 'Test Table',
-            position: { x: 0, y: 0 },
-            content: {
-              inputs: [{ id: 'input1', field: 'x' }],
-              outputs: [{ id: 'output1', field: 'result' }],
-              rules: [{ input1: '> 5', output1: '10' }],
-            },
-          },
-        ],
-        edges: [],
-      };
-
-      // First pass builds cache
-      const afterFirstPass = constantFolding(ast);
-      const node1 = afterFirstPass.nodes[0];
-
-      // Note: JSON.parse(JSON.stringify()) will lose the Map cache
-      // This is expected behavior - each optimization pass starts fresh
-      // The cache is useful WITHIN a pass when the same expression appears multiple times
-      expect(getExpressionCache(node1)).toBeDefined();
-    });
-  });
-
-  describe('Cache Performance', () => {
-    it('should reduce parsing calls for duplicate expressions', () => {
-      const parseUnaryMock = vi.spyOn(unaryParser, 'parseUnaryExpression');
-
-      const ast: JDMDecision = {
-        nodes: [
-          {
-            id: 'dt-1',
-            type: NodeType.DECISION_TABLE,
-            name: 'Test Table',
-            position: { x: 0, y: 0 },
-            content: {
-              inputs: [{ id: 'input1', field: 'x' }],
-              outputs: [{ id: 'output1', field: 'result' }],
-              rules: [
-                { input1: '> 5', output1: '10' },
-                { input1: '> 5', output1: '20' }, // Duplicate
-                { input1: '> 5', output1: '30' }, // Duplicate
-                { input1: '> 5', output1: '40' }, // Duplicate
-                { input1: '> 3', output1: '5' },
-                { input1: '> 3', output1: '6' }, // Duplicate
-              ],
-            },
-          },
-        ],
-        edges: [],
-      };
-
-      constantFolding(ast);
-
-      const callCount = parseUnaryMock.mock.calls.length;
-
-      // Should only parse "> 5" once and "> 3" once, total 2 parses (not 6)
-      expect(callCount).toBe(2);
-
-      parseUnaryMock.mockRestore();
-    });
-  });
-});