@divmain/jdm-asm 0.2.0

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

@@ -0,0 +1,447 @@
+/**
+ * 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

@@ -0,0 +1,143 @@
+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

@@ -0,0 +1,107 @@
+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');
+      }
+    });
+  });
+});