ast.test.js

const { parse } = require("../../src/utils/parser.js");
const ast = require('../../src/utils/ast.js');

// Expression without precedence
test('astToString could work correctly for symbol expression', () => {

    inputString = "A"; 

    const input = parse(inputString);

    const output = ast.astToString(input);

    expect(output).toEqual(inputString);
});


test('astToString could work correctly for not expression', () => {

    inputString = "!A"; 

    const input = parse(inputString);

    const output = ast.astToString(input);

    expect(output).toEqual(inputString);
});

test('astToString could work correctly for and expression', () => {
    inputString = "A&B"; 

    const input = parse(inputString);

    const output = ast.astToString(input);

    expect(output).toEqual(inputString);
});

test('astToString could work correctly for or expression', () => {
    inputString = "A||B"; 

    const input = parse(inputString);

    const output = ast.astToString(input);

    expect(output).toEqual(inputString);
});

test('astToString could work correctly for imply expression', () => {
    inputString = "A->B"; 

    const input = parse(inputString);

    const output = ast.astToString(input);

    expect(output).toEqual(inputString);
});

test('astToString could work correctly for complex expression', () => {
    inputString = "!A->B||C&D"; 

    const input = parse(inputString);

    const output = ast.astToString(input);

    expect(output).toEqual(inputString);
});

// precedence tests
test('astToString could work correctly for complex expression', () => {
    inputString = "!A->(B||C)&D"; 

    const input = parse(inputString);

    const output = ast.astToString(input);

    expect(output).toEqual(inputString);
});

test('astToString could work correctly for complex expression', () => {
    inputString = "!(A->B||C)&D"; 

    const input = parse(inputString);

    const output = ast.astToString(input);

    expect(output).toEqual(inputString);
});

test('astToString could work correctly for complex expression', () => {
    inputString = "(!A->B)||C&D"; 

    const input = parse(inputString);

    const output = ast.astToString(input);

    expect(output).toEqual(inputString);
});

test('astToString could work correctly for complex expression', () => {
    inputString = "!(A->B||C&D)"; 

    const input = parse(inputString);

    const output = ast.astToString(input);

    expect(output).toEqual(inputString);
});

// astToLaTeX test for expression
test('astToLaTeX could work correctly for and expression', () => {
    const inputString = "A & B";
    const input = parse(inputString);
    const output = ast.astToLaTeX(input);
    expect(output).toEqual("\\mathit{A} \\land \\mathit{B}");
});

test('astToLaTeX could work correctly for or expression', () => {
    const inputString = "A || B";
    const input = parse(inputString);
    const output = ast.astToLaTeX(input);
    expect(output).toEqual("\\mathit{A} \\lor \\mathit{B}");
});

test('astToLaTeX could work correctly for negation expression', () => {
    const inputString = "!A";
    const input = parse(inputString);
    const output = ast.astToLaTeX(input);
    expect(output).toEqual("\\neg \\mathit{A}");
});

test('astToLaTeX could work correctly for implication expression', () => {
    const inputString = "A -> B";
    const input = parse(inputString);
    const output = ast.astToLaTeX(input);
    expect(output).toEqual("\\mathit{A} \\rightarrow \\mathit{B}");
});

test('astToLaTeX could work correctly for true and false expression', () => {
    const inputString = "true & false";
    const input = parse(inputString);
    const output = ast.astToLaTeX(input);
    expect(output).toEqual("\\top \\land \\bot");
});

test('astToLaTeX could work correctly for mixed logical expression', () => {
    const inputString = "P -> Q || !R";
    const input = parse(inputString);
    const output = ast.astToLaTeX(input);
    expect(output).toEqual("\\mathit{P} \\rightarrow \\mathit{Q} \\lor \\neg \\mathit{R}");
});

test('astToLaTeX could work correctly for complex expression', () => {
    const inputString = "X & (Y -> Z)";
    const input = parse(inputString);
    const output = ast.astToLaTeX(input);
    expect(output).toEqual("\\mathit{X} \\land (\\mathit{Y} \\rightarrow \\mathit{Z})");
});