@divmain/jdm-asm 0.2.0 → 0.2.3

package/tests/unit/compiler/input-validation.test.ts

@@ -1,447 +0,0 @@
-/**
- * Tests for input validation functionality.
- *
- * This file tests both compile-time and runtime validation:
- * - compile-time-validation.ts: collectIdentifiers, validateInputReferences
- * - runtime-validation-codegen.ts: validateRuntimeInputs, validateRuntimeInputsDetailed
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  collectIdentifiers,
-  validateInputReferences,
-} from '../../../src/compiler/compile-time-validation';
-import {
-  validateRuntimeInputs,
-  validateRuntimeInputsDetailed,
-  validateRuntimeOutputsDetailed,
-} from '../../../src/compiler/runtime-validation-codegen';
-import type { CompilationContext } from '../../../src/compiler/types';
-import type { ExpressionAST } from '../../../src/compiler/ast-types';
-import { CompilationError } from '../../../src/compiler/errors';
-import { createMockContext as createBaseMockContext } from '../../helpers';
-
-describe('validateRuntimeInputs', () => {
-  it('should return empty array when all required inputs are present', () => {
-    const inputLayout = {
-      fields: [
-        { path: 'age', flatName: 'age', type: 'f64' as any, offset: 0, size: 8 },
-        { path: 'name', flatName: 'name', type: 'string' as any, offset: 8, size: -1 },
-      ],
-    };
-
-    const inputData = { age: 25, name: 'John' };
-    const missing = validateRuntimeInputs(inputData, inputLayout);
-
-    expect(missing).toEqual([]);
-  });
-
-  it('should detect missing top-level fields', () => {
-    const inputLayout = {
-      fields: [
-        { path: 'age', flatName: 'age', type: 'f64' as any, offset: 0, size: 8 },
-        { path: 'name', flatName: 'name', type: 'string' as any, offset: 8, size: -1 },
-      ],
-    };
-
-    const inputData = { age: 25 };
-    const missing = validateRuntimeInputs(inputData, inputLayout);
-
-    expect(missing).toEqual(['name']);
-  });
-
-  it('should detect missing nested fields', () => {
-    const inputLayout = {
-      fields: [
-        { path: 'customer.age', flatName: 'customer_age', type: 'f64' as any, offset: 0, size: 8 },
-        {
-          path: 'customer.name',
-          flatName: 'customer_name',
-          type: 'string' as any,
-          offset: 8,
-          size: -1,
-        },
-      ],
-    };
-
-    const inputData = { customer: { age: 25 } };
-    const missing = validateRuntimeInputs(inputData, inputLayout);
-
-    expect(missing).toEqual(['customer.name']);
-  });
-
-  it('should detect all missing fields', () => {
-    const inputLayout = {
-      fields: [
-        { path: 'age', flatName: 'age', type: 'f64' as any, offset: 0, size: 8 },
-        { path: 'name', flatName: 'name', type: 'string' as any, offset: 8, size: -1 },
-        { path: 'email', flatName: 'email', type: 'string' as any, offset: 8, size: -1 },
-      ],
-    };
-
-    const inputData = {};
-    const missing = validateRuntimeInputs(inputData, inputLayout);
-
-    expect(missing.sort()).toEqual(['age', 'email', 'name']);
-  });
-
-  it('should detect type mismatch - string instead of number', () => {
-    const inputLayout = {
-      fields: [{ path: 'age', flatName: 'age', type: 'f64' as any, offset: 0, size: 8 }],
-    };
-
-    const inputData = { age: '25' }; // String instead of number
-    const errors = validateRuntimeInputs(inputData, inputLayout);
-
-    expect(errors).toEqual(['age']);
-  });
-
-  it('should detect type mismatch - number instead of string', () => {
-    const inputLayout = {
-      fields: [{ path: 'name', flatName: 'name', type: 'string' as any, offset: 0, size: -1 }],
-    };
-
-    const inputData = { name: 123 }; // Number instead of string
-    const errors = validateRuntimeInputs(inputData, inputLayout);
-
-    expect(errors).toEqual(['name']);
-  });
-
-  it('should detect type mismatch - object instead of array', () => {
-    const inputLayout = {
-      fields: [{ path: 'items', flatName: 'items', type: 'array' as any, offset: 0, size: -1 }],
-    };
-
-    const inputData = { items: { a: 1 } }; // Object instead of array
-    const errors = validateRuntimeInputs(inputData, inputLayout);
-
-    expect(errors).toEqual(['items']);
-  });
-});
-
-describe('validateRuntimeInputsDetailed', () => {
-  it('should return valid result for correct input types', () => {
-    const inputLayout = {
-      fields: [
-        { path: 'age', flatName: 'age', type: 'f64' as any, offset: 0, size: 8 },
-        { path: 'name', flatName: 'name', type: 'string' as any, offset: 8, size: -1 },
-        { path: 'active', flatName: 'active', type: 'bool' as any, offset: 16, size: 4 },
-        { path: 'items', flatName: 'items', type: 'array' as any, offset: 20, size: -1 },
-      ],
-    };
-
-    const inputData = { age: 25, name: 'John', active: true, items: [1, 2, 3] };
-    const result = validateRuntimeInputsDetailed(inputData, inputLayout);
-
-    expect(result.valid).toBe(true);
-    expect(result.errors).toEqual([]);
-  });
-
-  it('should detect string instead of number with detailed error', () => {
-    const inputLayout = {
-      fields: [{ path: 'age', flatName: 'age', type: 'f64' as any, offset: 0, size: 8 }],
-    };
-
-    const inputData = { age: 'not a number' };
-    const result = validateRuntimeInputsDetailed(inputData, inputLayout);
-
-    expect(result.valid).toBe(false);
-    expect(result.errors).toHaveLength(1);
-    expect(result.errors[0].path).toBe('age');
-    expect(result.errors[0].message).toContain('Expected f64');
-    expect(result.errors[0].expected).toBe('f64');
-    expect(result.errors[0].actual).toBe('not a number');
-  });
-
-  it('should detect NaN as invalid number', () => {
-    const inputLayout = {
-      fields: [{ path: 'value', flatName: 'value', type: 'f64' as any, offset: 0, size: 8 }],
-    };
-
-    const inputData = { value: NaN };
-    const result = validateRuntimeInputsDetailed(inputData, inputLayout);
-
-    expect(result.valid).toBe(false);
-    expect(result.errors).toHaveLength(1);
-    expect(result.errors[0].path).toBe('value');
-    expect(result.errors[0].message).toContain('NaN');
-  });
-
-  it('should detect float instead of integer for i32', () => {
-    const inputLayout = {
-      fields: [{ path: 'count', flatName: 'count', type: 'i32' as any, offset: 0, size: 4 }],
-    };
-
-    const inputData = { count: 3.14 }; // Float instead of integer
-    const result = validateRuntimeInputsDetailed(inputData, inputLayout);
-
-    expect(result.valid).toBe(false);
-    expect(result.errors).toHaveLength(1);
-    expect(result.errors[0].path).toBe('count');
-    expect(result.errors[0].message).toContain('integer');
-    expect(result.errors[0].message).toContain('floating-point');
-  });
-
-  it('should accept integer for i64', () => {
-    const inputLayout = {
-      fields: [
-        { path: 'bigNumber', flatName: 'bigNumber', type: 'i64' as any, offset: 0, size: 8 },
-      ],
-    };
-
-    const inputData = { bigNumber: 42 };
-    const result = validateRuntimeInputsDetailed(inputData, inputLayout);
-
-    expect(result.valid).toBe(true);
-    expect(result.errors).toEqual([]);
-  });
-
-  it('should accept bigint for i64', () => {
-    const inputLayout = {
-      fields: [
-        { path: 'bigNumber', flatName: 'bigNumber', type: 'i64' as any, offset: 0, size: 8 },
-      ],
-    };
-
-    const inputData = { bigNumber: 9007199254740993n };
-    const result = validateRuntimeInputsDetailed(inputData, inputLayout);
-
-    expect(result.valid).toBe(true);
-    expect(result.errors).toEqual([]);
-  });
-
-  it('should detect string instead of boolean', () => {
-    const inputLayout = {
-      fields: [{ path: 'active', flatName: 'active', type: 'bool' as any, offset: 0, size: 4 }],
-    };
-
-    const inputData = { active: 'true' }; // String instead of boolean
-    const result = validateRuntimeInputsDetailed(inputData, inputLayout);
-
-    expect(result.valid).toBe(false);
-    expect(result.errors).toHaveLength(1);
-    expect(result.errors[0].path).toBe('active');
-    expect(result.errors[0].message).toContain('Expected boolean');
-    expect(result.errors[0].expected).toBe('boolean');
-  });
-
-  it('should detect number instead of string', () => {
-    const inputLayout = {
-      fields: [{ path: 'name', flatName: 'name', type: 'string' as any, offset: 0, size: -1 }],
-    };
-
-    const inputData = { name: 123 };
-    const result = validateRuntimeInputsDetailed(inputData, inputLayout);
-
-    expect(result.valid).toBe(false);
-    expect(result.errors).toHaveLength(1);
-    expect(result.errors[0].path).toBe('name');
-    expect(result.errors[0].message).toContain('Expected string');
-    expect(result.errors[0].expected).toBe('string');
-  });
-
-  it('should detect object instead of array', () => {
-    const inputLayout = {
-      fields: [{ path: 'items', flatName: 'items', type: 'array' as any, offset: 0, size: -1 }],
-    };
-
-    const inputData = { items: { length: 3 } }; // Object instead of array
-    const result = validateRuntimeInputsDetailed(inputData, inputLayout);
-
-    expect(result.valid).toBe(false);
-    expect(result.errors).toHaveLength(1);
-    expect(result.errors[0].path).toBe('items');
-    expect(result.errors[0].message).toContain('Expected array');
-  });
-
-  it('should detect nested field type mismatches', () => {
-    const inputLayout = {
-      fields: [
-        { path: 'customer.age', flatName: 'customer_age', type: 'f64' as any, offset: 0, size: 8 },
-        {
-          path: 'customer.name',
-          flatName: 'customer_name',
-          type: 'string' as any,
-          offset: 8,
-          size: -1,
-        },
-      ],
-    };
-
-    const inputData = { customer: { age: 'thirty', name: 456 } };
-    const result = validateRuntimeInputsDetailed(inputData, inputLayout);
-
-    expect(result.valid).toBe(false);
-    expect(result.errors).toHaveLength(2);
-
-    const paths = result.errors.map((e) => e.path).sort();
-    expect(paths).toEqual(['customer.age', 'customer.name']);
-  });
-
-  it('should report both missing and type errors', () => {
-    const inputLayout = {
-      fields: [
-        { path: 'age', flatName: 'age', type: 'f64' as any, offset: 0, size: 8 },
-        { path: 'name', flatName: 'name', type: 'string' as any, offset: 8, size: -1 },
-        { path: 'email', flatName: 'email', type: 'string' as any, offset: 16, size: -1 },
-      ],
-    };
-
-    const inputData = { age: 'not a number' }; // Wrong type for age, missing name and email
-    const result = validateRuntimeInputsDetailed(inputData, inputLayout);
-
-    expect(result.valid).toBe(false);
-    expect(result.errors).toHaveLength(3);
-
-    // Find each error by path
-    const ageError = result.errors.find((e) => e.path === 'age');
-    const nameError = result.errors.find((e) => e.path === 'name');
-    const emailError = result.errors.find((e) => e.path === 'email');
-
-    expect(ageError?.message).toContain('Expected f64');
-    expect(nameError?.message).toContain('missing');
-    expect(emailError?.message).toContain('missing');
-  });
-});
-
-describe('validateRuntimeOutputsDetailed', () => {
-  it('should validate output types correctly', () => {
-    const outputLayout = {
-      fields: [
-        { path: 'result', flatName: 'result', type: 'f64' as any, offset: 0, size: 8 },
-        { path: 'message', flatName: 'message', type: 'string' as any, offset: 8, size: -1 },
-      ],
-    };
-
-    const outputData = { result: 42, message: 'Success' };
-    const result = validateRuntimeOutputsDetailed(outputData, outputLayout);
-
-    expect(result.valid).toBe(true);
-    expect(result.errors).toEqual([]);
-  });
-
-  it('should detect type mismatches in output', () => {
-    const outputLayout = {
-      fields: [{ path: 'result', flatName: 'result', type: 'f64' as any, offset: 0, size: 8 }],
-    };
-
-    const outputData = { result: 'not a number' };
-    const result = validateRuntimeOutputsDetailed(outputData, outputLayout);
-
-    expect(result.valid).toBe(false);
-    expect(result.errors).toHaveLength(1);
-    expect(result.errors[0].path).toBe('result');
-  });
-});
-
-function createMockContext(fields: string[]): CompilationContext {
-  return createBaseMockContext({
-    inputFields: fields,
-    parseExpression: (expr: string) => {
-      // Mock parser - just return a simple identifier
-      return { type: 'Identifier', name: expr };
-    },
-    parseUnaryExpression: (expr: string) => {
-      return { type: 'Identifier', name: expr };
-    },
-    getUniqueId: (prefix: string) => prefix,
-    loadDecision: () => {
-      throw new Error('Not implemented');
-    },
-  });
-}
-
-function createIdentifier(name: string): ExpressionAST {
-  return { type: 'Identifier', name };
-}
-
-function createBinaryOp(left: ExpressionAST, op: string, right: ExpressionAST): ExpressionAST {
-  return { type: 'BinaryOp', op: op as any, left, right };
-}
-
-function createMemberAccess(object: ExpressionAST, property: string): ExpressionAST {
-  return { type: 'MemberAccess', object, property };
-}
-
-describe('collectIdentifiers', () => {
-  it('should collect simple identifier', () => {
-    const ast = createIdentifier('age');
-    const identifiers = collectIdentifiers(ast);
-    expect(identifiers).toEqual(new Set(['age']));
-  });
-
-  it('should collect identifiers from binary expression', () => {
-    const ast = createBinaryOp(createIdentifier('age'), '+', createIdentifier('years'));
-    const identifiers = collectIdentifiers(ast);
-    expect(identifiers).toEqual(new Set(['age', 'years']));
-  });
-
-  it('should collect identifier from member access base', () => {
-    const ast = createMemberAccess(createIdentifier('customer'), 'age');
-    const identifiers = collectIdentifiers(ast);
-    expect(identifiers).toEqual(new Set(['customer']));
-  });
-
-  it('should collect all identifiers from nested expression', () => {
-    const ast = createBinaryOp(
-      createMemberAccess(createIdentifier('customer'), 'age'),
-      '>',
-      createBinaryOp(createIdentifier('minAge'), '+', createIdentifier('offset')),
-    );
-    const identifiers = collectIdentifiers(ast);
-    expect(identifiers).toEqual(new Set(['customer', 'minAge', 'offset']));
-  });
-});
-
-describe('validateInputReferences', () => {
-  it('should pass when all identifiers are declared', () => {
-    const context = createMockContext(['age', 'name', 'customer.age']);
-    const identifiers = new Set(['age', 'name']);
-    expect(() => validateInputReferences(identifiers, context)).not.toThrow();
-  });
-
-  it('should pass when identifier references object with nested fields', () => {
-    const context = createMockContext(['customer', 'customer.age', 'customer.name']);
-    const identifiers = new Set(['customer']);
-    expect(() => validateInputReferences(identifiers, context)).not.toThrow();
-  });
-
-  it('should pass when identifier references specific nested field', () => {
-    const context = createMockContext(['customer', 'customer.age', 'customer.name']);
-    const identifiers = new Set(['customer.age']);
-    expect(() => validateInputReferences(identifiers, context)).not.toThrow();
-  });
-
-  it('should throw error for single missing identifier', () => {
-    const context = createMockContext(['age', 'name']);
-    const identifiers = new Set(['age', 'undeclared']);
-    expect(() => validateInputReferences(identifiers, context)).toThrow(CompilationError);
-    try {
-      validateInputReferences(identifiers, context);
-      expect.fail('Should have thrown an error');
-    } catch (error) {
-      expect((error as CompilationError).message).toContain('undeclared');
-      expect((error as CompilationError).code).toBe('UNKNOWN_FIELD');
-    }
-  });
-
-  it('should throw error listing all missing identifiers', () => {
-    const context = createMockContext(['age', 'name']);
-    const identifiers = new Set(['undeclared1', 'age', 'undeclared2', 'name']);
-    expect(() => validateInputReferences(identifiers, context)).toThrow(CompilationError);
-    try {
-      validateInputReferences(identifiers, context);
-      expect.fail('Should have thrown an error');
-    } catch (error) {
-      const message = (error as CompilationError).message;
-      expect(message).toContain('undeclared1');
-      expect(message).toContain('undeclared2');
-    }
-  });
-
-  it('should skip special identifiers $ and #', () => {
-    const context = createMockContext(['age', 'name']);
-    const identifiers = new Set(['$', '#', 'age', 'name']);
-    expect(() => validateInputReferences(identifiers, context)).not.toThrow();
-  });
-});

package/tests/unit/compiler/logical-and-parser.test.ts

@@ -1,143 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { parser, lexer } from '../../../src/compiler/expression-parser';
-import { cstToAst } from '../../../src/compiler/cst-visitor';
-
-describe('Expression Parser - Logical AND Operator', () => {
-  beforeEach(() => {
-    // Reset parser state before each test
-    parser.reset();
-  });
-
-  it('should parse "true" as just a boolean literal', () => {
-    const lexingResult = lexer.tokenize('true');
-
-    if (lexingResult.errors.length > 0) {
-      throw new Error(`Lexer error: ${lexingResult.errors.map((e: any) => e.message).join(', ')}`);
-    }
-
-    parser.input = lexingResult.tokens;
-    const cst = parser.expression();
-
-    if (parser.errors.length > 0) {
-      throw new Error(`Parse error: ${parser.errors.map((e: any) => e.message).join(', ')}`);
-    }
-
-    const ast = cstToAst(cst);
-    expect(ast).toEqual({
-      type: 'BooleanLiteral',
-      value: true,
-    });
-  });
-
-  it('should parse "true and true"', () => {
-    const lexingResult = lexer.tokenize('true and true');
-
-    if (lexingResult.errors.length > 0) {
-      throw new Error(`Lexer error: ${lexingResult.errors.map((e: any) => e.message).join(', ')}`);
-    }
-
-    parser.input = lexingResult.tokens;
-    const cst = parser.expression();
-
-    if (parser.errors.length > 0) {
-      throw new Error(`Parse error: ${parser.errors.map((e: any) => e.message).join(', ')}`);
-    }
-
-    const ast = cstToAst(cst);
-    expect(ast).toEqual({
-      type: 'BinaryOp',
-      op: 'and',
-      left: { type: 'BooleanLiteral', value: true },
-      right: { type: 'BooleanLiteral', value: true },
-    });
-  });
-
-  it('should parse "true && true"', () => {
-    const lexingResult = lexer.tokenize('true && true');
-
-    if (lexingResult.errors.length > 0) {
-      throw new Error(`Lexer error: ${lexingResult.errors.map((e: any) => e.message).join(', ')}`);
-    }
-
-    parser.input = lexingResult.tokens;
-    const cst = parser.expression();
-
-    if (parser.errors.length > 0) {
-      throw new Error(`Parse error: ${parser.errors.map((e: any) => e.message).join(', ')}`);
-    }
-
-    const ast = cstToAst(cst);
-    expect(ast).toEqual({
-      type: 'BinaryOp',
-      op: 'and',
-      left: { type: 'BooleanLiteral', value: true },
-      right: { type: 'BooleanLiteral', value: true },
-    });
-  });
-
-  it('should parse "x > 5 and x < 10"', () => {
-    const lexingResult = lexer.tokenize('x > 5 and x < 10');
-
-    if (lexingResult.errors.length > 0) {
-      throw new Error(`Lexer error: ${lexingResult.errors.map((e: any) => e.message).join(', ')}`);
-    }
-
-    parser.input = lexingResult.tokens;
-    const cst = parser.expression();
-
-    if (parser.errors.length > 0) {
-      throw new Error(`Parse error: ${parser.errors.map((e: any) => e.message).join(', ')}`);
-    }
-
-    const ast = cstToAst(cst);
-    expect(ast).toEqual({
-      type: 'BinaryOp',
-      op: 'and',
-      left: {
-        type: 'BinaryOp',
-        op: '>',
-        left: { type: 'Identifier', name: 'x' },
-        right: { type: 'NumberLiteral', value: 5 },
-      },
-      right: {
-        type: 'BinaryOp',
-        op: '<',
-        left: { type: 'Identifier', name: 'x' },
-        right: { type: 'NumberLiteral', value: 10 },
-      },
-    });
-  });
-
-  it('should parse "x > 5 && x < 10"', () => {
-    const lexingResult = lexer.tokenize('x > 5 && x < 10');
-
-    if (lexingResult.errors.length > 0) {
-      throw new Error(`Lexer error: ${lexingResult.errors.map((e: any) => e.message).join(', ')}`);
-    }
-
-    parser.input = lexingResult.tokens;
-    const cst = parser.expression();
-
-    if (parser.errors.length > 0) {
-      throw new Error(`Parse error: ${parser.errors.map((e: any) => e.message).join(', ')}`);
-    }
-
-    const ast = cstToAst(cst);
-    expect(ast).toEqual({
-      type: 'BinaryOp',
-      op: 'and',
-      left: {
-        type: 'BinaryOp',
-        op: '>',
-        left: { type: 'Identifier', name: 'x' },
-        right: { type: 'NumberLiteral', value: 5 },
-      },
-      right: {
-        type: 'BinaryOp',
-        op: '<',
-        left: { type: 'Identifier', name: 'x' },
-        right: { type: 'NumberLiteral', value: 10 },
-      },
-    });
-  });
-});

package/tests/unit/compiler/logical-not-parser.test.ts

@@ -1,107 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseStandardExpression } from '../../../src/compiler/unary-parser';
-
-describe('Logical NOT Expression Parser', () => {
-  describe('parseStandardExpression', () => {
-    it('should parse "not true" expression', () => {
-      const ast = parseStandardExpression('not true');
-      expect(ast.type).toBe('UnaryOp');
-      if (ast.type === 'UnaryOp') {
-        expect(ast.op).toBe('not');
-        expect(ast.operand).toEqual({ type: 'BooleanLiteral', value: true });
-      }
-    });
-
-    it('should parse "not false" expression', () => {
-      const ast = parseStandardExpression('not false');
-      expect(ast.type).toBe('UnaryOp');
-      if (ast.type === 'UnaryOp') {
-        expect(ast.op).toBe('not');
-        expect(ast.operand).toEqual({ type: 'BooleanLiteral', value: false });
-      }
-    });
-
-    it('should parse "!true" expression', () => {
-      const ast = parseStandardExpression('!true');
-      expect(ast.type).toBe('UnaryOp');
-      if (ast.type === 'UnaryOp') {
-        expect(ast.op).toBe('not');
-        expect(ast.operand).toEqual({ type: 'BooleanLiteral', value: true });
-      }
-    });
-
-    it('should parse "!false" expression', () => {
-      const ast = parseStandardExpression('!false');
-      expect(ast.type).toBe('UnaryOp');
-      if (ast.type === 'UnaryOp') {
-        expect(ast.op).toBe('not');
-        expect(ast.operand).toEqual({ type: 'BooleanLiteral', value: false });
-      }
-    });
-
-    it('should parse "not (x > 5)" expression with comparison', () => {
-      const ast = parseStandardExpression('not (x > 5)');
-      expect(ast.type).toBe('UnaryOp');
-      if (ast.type === 'UnaryOp') {
-        expect(ast.op).toBe('not');
-        expect(ast.operand.type).toBe('BinaryOp');
-      }
-    });
-
-    it('should parse "!(x > 5)" expression with comparison', () => {
-      const ast = parseStandardExpression('!(x > 5)');
-      expect(ast.type).toBe('UnaryOp');
-      if (ast.type === 'UnaryOp') {
-        expect(ast.op).toBe('not');
-        expect(ast.operand.type).toBe('BinaryOp');
-      }
-    });
-
-    it('should parse double NOT "not not true"', () => {
-      const ast = parseStandardExpression('not not true');
-      expect(ast.type).toBe('UnaryOp');
-      if (ast.type === 'UnaryOp') {
-        expect(ast.op).toBe('not');
-        expect(ast.operand.type).toBe('UnaryOp');
-        if (ast.operand.type === 'UnaryOp') {
-          expect(ast.operand.op).toBe('not');
-        }
-      }
-    });
-
-    it('should parse NOT with AND "not a and b"', () => {
-      const ast = parseStandardExpression('not a and b');
-      // NOT should bind tighter than AND, so this should be (not a) and b
-      expect(ast.type).toBe('BinaryOp');
-      if (ast.type === 'BinaryOp') {
-        expect(ast.op).toBe('and');
-        expect(ast.left.type).toBe('UnaryOp');
-        if (ast.left.type === 'UnaryOp') {
-          expect(ast.left.op).toBe('not');
-        }
-      }
-    });
-
-    it('should parse NOT with parentheses "not (a or b)"', () => {
-      const ast = parseStandardExpression('not (a or b)');
-      expect(ast.type).toBe('UnaryOp');
-      if (ast.type === 'UnaryOp') {
-        expect(ast.op).toBe('not');
-        expect(ast.operand.type).toBe('BinaryOp');
-        if (ast.operand.type === 'BinaryOp') {
-          expect(ast.operand.op).toBe('or');
-        }
-      }
-    });
-
-    it('should handle type coercion with non-boolean operands', () => {
-      // In standard parsing mode, NOT should accept any expression
-      // and coerce to boolean
-      const ast = parseStandardExpression('not 0');
-      expect(ast.type).toBe('UnaryOp');
-      if (ast.type === 'UnaryOp') {
-        expect(ast.op).toBe('not');
-      }
-    });
-  });
-});