fortrangoingonforty/fortbite / bb1c5f4

+nodejs 24.9.0

+$(BUILDDIR)/fortbite_evaluator_m.o: $(BUILDDIR)/fortbite_types_m.o $(BUILDDIR)/fortbite_ast_m.o $(BUILDDIR)/fortbite_arithmetic_m.o $(BUILDDIR)/fortbite_functions_m.o $(BUILDDIR)/fortbite_matrix_m.o

+$(BUILDDIR)/fortbite_io_m.o: $(BUILDDIR)/fortbite_precision_m.o $(BUILDDIR)/fortbite_types_m.o $(BUILDDIR)/fortbite_lexer_m.o $(BUILDDIR)/fortbite_parser_m.o $(BUILDDIR)/fortbite_evaluator_m.o $(BUILDDIR)/fortbite_ast_m.o

+# Test compilation

+TEST_FRAMEWORK = tests/test_framework.f90

+TEST_SOURCES = tests/unit/test_arithmetic.f90 \

+               tests/unit/test_functions.f90 \

+               tests/integration/test_expressions.f90

+

+TEST_OBJECTS = $(TEST_SOURCES:tests/%.f90=$(BUILDDIR)/tests/%.o) \

+               $(BUILDDIR)/tests/test_framework.o

+

+TEST_EXECUTABLES = $(TEST_SOURCES:tests/%.f90=$(BUILDDIR)/tests/%)

+

+# Build test framework

+$(BUILDDIR)/tests/test_framework.o: $(TEST_FRAMEWORK) directories

+	@mkdir -p $(BUILDDIR)/tests/unit $(BUILDDIR)/tests/integration

+	$(FC) $(FFLAGS) -J$(MODDIR) -c $< -o $@

+

+# Library objects (all except main program)

+LIB_OBJECTS = $(filter-out $(BUILDDIR)/fortbite.o, $(OBJECTS))

+

+# Build test executables

+$(BUILDDIR)/tests/unit/%.o: tests/unit/%.f90 $(BUILDDIR)/tests/test_framework.o $(LIB_OBJECTS)

+	$(FC) $(FFLAGS) -J$(MODDIR) -I$(MODDIR) -c $< -o $@

+

+$(BUILDDIR)/tests/integration/%.o: tests/integration/%.f90 $(BUILDDIR)/tests/test_framework.o $(LIB_OBJECTS)

+	$(FC) $(FFLAGS) -J$(MODDIR) -I$(MODDIR) -c $< -o $@

+

+$(BUILDDIR)/tests/unit/%: $(BUILDDIR)/tests/unit/%.o $(BUILDDIR)/tests/test_framework.o $(LIB_OBJECTS)

+	$(FC) $(LDFLAGS) -J$(MODDIR) -o $@ $^

+

+$(BUILDDIR)/tests/integration/%: $(BUILDDIR)/tests/integration/%.o $(BUILDDIR)/tests/test_framework.o $(LIB_OBJECTS)

+	$(FC) $(LDFLAGS) -J$(MODDIR) -o $@ $^

+

+# Test targets

+test-build: directories $(TARGET) $(TEST_EXECUTABLES)

+	@echo "Test build complete!"

+

+test: test-build

+	@./tests/run_tests.sh --no-build

+

+test-unit: test-build

+	@echo "Running unit tests..."

+	@$(BUILDDIR)/tests/unit/test_arithmetic || true

+	@$(BUILDDIR)/tests/unit/test_functions || true

+

+test-integration: test-build

+	@echo "Running integration tests..."

+	@$(BUILDDIR)/tests/integration/test_expressions || true

+

+test-verbose: test-build

+	@for test in $(TEST_EXECUTABLES); do \

+		echo "=== Running $$test ==="; \

+		$$test || true; \

+		echo; \

+	done

+

+# Clean including tests

+clean-all: clean

+	rm -rf test_results

+

+	@echo "  all           - Build the executable (default)"

+	@echo "  clean         - Remove build files"

+	@echo "  clean-all     - Remove build files and test results"

+	@echo "  run           - Build and run FORTBITE"

+	@echo "  install       - Install to /usr/local/bin"

+	@echo "  test          - Run all tests"

+	@echo "  test-unit     - Run unit tests only"

+	@echo "  test-integration - Run integration tests only"

+	@echo "  test-verbose  - Run all tests with full output"

+	@echo "  test-build    - Build test executables only"

+	@echo "  help          - Show this help message"

+.PHONY: all clean clean-all run install help directories test test-unit test-integration test-verbose test-build

+

+

+

+        ! Evaluate the expression

+

+        ! Store the requested precision in the value

+        ! We'll use the precision_kind field to store the number of digits

+        value%precision_kind = node%precision_digits

+    recursive function parse_logical_or(parser) result(node)

+

+

+    recursive function parse_logical_and(parser) result(node)

+

+

+    recursive function parse_equality(parser) result(node)

+

+

+    recursive function parse_relational(parser) result(node)

+

+

+    recursive function parse_additive(parser) result(node)

+    recursive function parse_multiplicative(parser) result(node)

+    recursive function parse_postfix(parser) result(node)

+    recursive function parse_primary(parser) result(node)

+        character(len=100) :: fmt_str

+        integer :: precision_digits

+

+            ! Use precision_kind to determine output format

+            ! If precision_kind < 100, it's the requested precision digits

+            ! Otherwise it's a kind parameter (like real64 = 8)

+            if (value%precision_kind > 0 .and. value%precision_kind < 100) then

+                precision_digits = value%precision_kind

+                write(fmt_str, '(A,I0,A,I0,A)') '(F0.', precision_digits, ')'

+                write(*, fmt_str) value%scalar_val

+            else

+                write(*, '(G0)') value%scalar_val

+            end if

+============================================================

+Running Test Suite: Arithmetic Operations

+============================================================

+✓ Addition: 2 + 3 = 5 ... PASSED

+✓ Addition: -5 + 3 = -2 ... PASSED

+✓ Addition: 0.1 + 0.2 ... PASSED

+✓ Subtraction: 10 - 3 = 7 ... PASSED

+✓ Subtraction: -5 - 3 = -8 ... PASSED

+✓ Multiplication: 4 * 5 = 20 ... PASSED

+✓ Multiplication: -3 * 7 = -21 ... PASSED

+✓ Multiplication: -2 * -3 = 6 ... PASSED

+✓ Division: 15 / 3 = 5 ... PASSED

+✓ Division: 7 / 2 = 3.5 ... PASSED

+✓ Division: -12 / 4 = -3 ... PASSED

+✓ Power: 2^3 = 8 ... PASSED

+✓ Power: 5^2 = 25 ... PASSED

+✓ Power: 4^0.5 = 2 ... PASSED

+✓ Power: 10^-1 = 0.1 ... PASSED

+✓ Negation: -(5) = -5 ... PASSED

+✓ Negation: -(-3) = 3 ... PASSED

+✓ Addition with zero: 5 + 0 = 5 ... PASSED

+✓ Multiplication by zero: 5 * 0 = 0 ... PASSED

+✓ Multiplication by one: 7 * 1 = 7 ... PASSED

+------------------------------------------------------------

+Results: 20 passed, 0 failed, 20 total

+============================================================

+5.0000000000000000

+6.0000000000000000

+30.000000000000000

+5.0000000000000000

+8.0000000000000000

+2 + 3

+10 - 4

+5 * 6

+20 / 4

+2 ^ 3

+exit

+!> Integration tests for complete expression evaluation

+program test_expressions

+    use test_framework

+    use fortbite_types_m, only: value_t, token_t, print_value

+    use fortbite_lexer_m, only: tokenize, free_tokens

+    use fortbite_parser_m, only: parse_expression, parse_error_t

+    use fortbite_evaluator_m, only: evaluate_expression, evaluation_context_t, &

+                                   evaluation_error_t, create_context

+    use fortbite_ast_m, only: ast_node_t, free_ast

+    use iso_fortran_env, only: real64

+    implicit none

+

+    type(test_suite) :: suite

+    type(evaluation_context_t) :: context

+    type(value_t) :: result

+    real(real64) :: expected

+

+    ! Initialize test suite

+    suite = init_test_suite('Expression Evaluation')

+    context = create_context()

+

+    ! Test simple arithmetic expressions

+    call test_expression(suite, context, '2 + 3', 5.0_real64, 'Simple addition')

+    call test_expression(suite, context, '10 - 4', 6.0_real64, 'Simple subtraction')

+    call test_expression(suite, context, '3 * 7', 21.0_real64, 'Simple multiplication')

+    call test_expression(suite, context, '15 / 3', 5.0_real64, 'Simple division')

+    call test_expression(suite, context, '2 ^ 3', 8.0_real64, 'Power operation')

+    call test_expression(suite, context, '2 ** 3', 8.0_real64, 'Power with ** operator')

+

+    ! Test operator precedence

+    call test_expression(suite, context, '2 + 3 * 4', 14.0_real64, 'Precedence: multiplication before addition')

+    call test_expression(suite, context, '(2 + 3) * 4', 20.0_real64, 'Parentheses override precedence')

+    call test_expression(suite, context, '10 - 2 * 3', 4.0_real64, 'Precedence: multiplication before subtraction')

+    call test_expression(suite, context, '2 * 3 + 4 * 5', 26.0_real64, 'Multiple multiplications and addition')

+    call test_expression(suite, context, '2 ^ 3 * 4', 32.0_real64, 'Power before multiplication')

+    call test_expression(suite, context, '2 * 3 ^ 2', 18.0_real64, 'Power before multiplication (2)')

+

+    ! Test nested expressions

+    call test_expression(suite, context, '((2 + 3) * 4) / 2', 10.0_real64, 'Nested parentheses')

+    call test_expression(suite, context, '2 * (3 + (4 * 5))', 46.0_real64, 'Multiple nesting levels')

+

+    ! Test unary operators

+    call test_expression(suite, context, '-5', -5.0_real64, 'Unary minus')

+    call test_expression(suite, context, '+5', 5.0_real64, 'Unary plus')

+    call test_expression(suite, context, '-(2 + 3)', -5.0_real64, 'Unary minus with expression')

+    call test_expression(suite, context, '-2 * 3', -6.0_real64, 'Unary minus with multiplication')

+    call test_expression(suite, context, '2 * -3', -6.0_real64, 'Multiplication with unary minus')

+

+    ! Test floating point expressions

+    call test_expression_near(suite, context, '0.1 + 0.2', 0.3_real64, 1.0e-10_real64, 'Floating point addition')

+    call test_expression(suite, context, '3.5 * 2', 7.0_real64, 'Floating point multiplication')

+    call test_expression(suite, context, '7.5 / 2.5', 3.0_real64, 'Floating point division')

+

+    ! Test mathematical constants

+    call test_expression_near(suite, context, 'pi', 3.141592653589793_real64, 1.0e-10_real64, 'Pi constant')

+    call test_expression_near(suite, context, 'e', 2.718281828459045_real64, 1.0e-10_real64, 'E constant')

+    call test_expression_near(suite, context, '2 * pi', 6.283185307179586_real64, 1.0e-10_real64, 'Expression with pi')

+

+    ! Test precision specification (our recently fixed feature!)

+    call test_precision(suite, context, 'pi::10', 10, 'Pi with 10 digit precision')

+    call test_precision(suite, context, 'e::5', 5, 'E with 5 digit precision')

+

+    ! Run the test suite

+    call run_test_suite(suite)

+

+contains

+

+    !> Test an expression evaluation

+    subroutine test_expression(suite, context, expr_str, expected, test_name)

+        type(test_suite), intent(inout) :: suite

+        type(evaluation_context_t), intent(inout) :: context

+        character(len=*), intent(in) :: expr_str

+        real(real64), intent(in) :: expected

+        character(len=*), intent(in) :: test_name

+

+        type(token_t), allocatable :: tokens(:)

+        type(ast_node_t), pointer :: ast

+        type(parse_error_t) :: parse_err

+        type(evaluation_error_t) :: eval_err

+        type(value_t) :: result

+

+        call add_test_case(suite, test_name)

+

+        ! Tokenize

+        tokens = tokenize(expr_str)

+

+        ! Parse

+        ast => parse_expression(tokens, parse_err)

+        if (parse_err%has_error) then

+            call assert_true(suite, .false., 'Parse error: ' // trim(parse_err%message))

+            call free_tokens(tokens)

+            return

+        end if

+

+        ! Evaluate

+        result = evaluate_expression(ast, context, eval_err)

+        if (eval_err%has_error) then

+            call assert_true(suite, .false., 'Evaluation error: ' // trim(eval_err%message))

+        else

+            call assert_equals(suite, result%scalar_val, expected)

+        end if

+

+        ! Clean up

+        call free_ast(ast)

+        call free_tokens(tokens)

+    end subroutine test_expression

+

+    !> Test an expression evaluation with tolerance

+    subroutine test_expression_near(suite, context, expr_str, expected, tolerance, test_name)

+        type(test_suite), intent(inout) :: suite

+        type(evaluation_context_t), intent(inout) :: context

+        character(len=*), intent(in) :: expr_str

+        real(real64), intent(in) :: expected, tolerance

+        character(len=*), intent(in) :: test_name

+

+        type(token_t), allocatable :: tokens(:)

+        type(ast_node_t), pointer :: ast

+        type(parse_error_t) :: parse_err

+        type(evaluation_error_t) :: eval_err

+        type(value_t) :: result

+

+        call add_test_case(suite, test_name)

+

+        ! Tokenize

+        tokens = tokenize(expr_str)

+

+        ! Parse

+        ast => parse_expression(tokens, parse_err)

+        if (parse_err%has_error) then

+            call assert_true(suite, .false., 'Parse error: ' // trim(parse_err%message))

+            call free_tokens(tokens)

+            return

+        end if

+

+        ! Evaluate

+        result = evaluate_expression(ast, context, eval_err)

+        if (eval_err%has_error) then

+            call assert_true(suite, .false., 'Evaluation error: ' // trim(eval_err%message))

+        else

+            call assert_near(suite, result%scalar_val, expected, tolerance)

+        end if

+

+        ! Clean up

+        call free_ast(ast)

+        call free_tokens(tokens)

+    end subroutine test_expression_near

+

+    !> Test precision specification

+    subroutine test_precision(suite, context, expr_str, expected_precision, test_name)

+        type(test_suite), intent(inout) :: suite

+        type(evaluation_context_t), intent(inout) :: context

+        character(len=*), intent(in) :: expr_str

+        integer, intent(in) :: expected_precision

+        character(len=*), intent(in) :: test_name

+

+        type(token_t), allocatable :: tokens(:)

+        type(ast_node_t), pointer :: ast

+        type(parse_error_t) :: parse_err

+        type(evaluation_error_t) :: eval_err

+        type(value_t) :: result

+

+        call add_test_case(suite, test_name)

+

+        ! Tokenize

+        tokens = tokenize(expr_str)

+

+        ! Parse

+        ast => parse_expression(tokens, parse_err)

+        if (parse_err%has_error) then

+            call assert_true(suite, .false., 'Parse error: ' // trim(parse_err%message))

+            call free_tokens(tokens)

+            return

+        end if

+

+        ! Evaluate

+        result = evaluate_expression(ast, context, eval_err)

+        if (eval_err%has_error) then

+            call assert_true(suite, .false., 'Evaluation error: ' // trim(eval_err%message))

+        else

+            ! Check that precision_kind was set correctly

+            call assert_true(suite, result%precision_kind == expected_precision, &

+                'Precision specification stored correctly')

+        end if

+

+        ! Clean up

+        call free_ast(ast)

+        call free_tokens(tokens)

+    end subroutine test_precision

+

+end program test_expressions

+#!/bin/bash

+

+# FORTBITE Test Runner Script

+# Runs all unit and integration tests

+

+set -e  # Exit on error

+

+# Colors for output

+RED='\033[0;31m'

+GREEN='\033[0;32m'

+YELLOW='\033[1;33m'

+NC='\033[0m' # No Color

+

+echo "================================"

+echo "    FORTBITE Test Suite"

+echo "================================"

+echo

+

+# Create test results directory

+mkdir -p test_results

+

+# Track overall results

+TOTAL_TESTS=0

+PASSED_TESTS=0

+FAILED_TESTS=0

+FAILED_LIST=""

+

+# Function to run a test

+run_test() {

+    local test_name=$1

+    local test_exec=$2

+    local test_type=$3

+

+    echo -n "Running $test_type test: $test_name ... "

+

+    if [ -f "$test_exec" ]; then

+        if $test_exec > "test_results/${test_name}.log" 2>&1; then

+            echo -e "${GREEN}PASSED${NC}"

+            ((PASSED_TESTS++))

+        else

+            echo -e "${RED}FAILED${NC}"

+            ((FAILED_TESTS++))

+            FAILED_LIST="$FAILED_LIST\n  - $test_name"

+            echo "  Error output:"

+            tail -n 5 "test_results/${test_name}.log" | sed 's/^/    /'

+        fi

+    else

+        echo -e "${YELLOW}NOT FOUND${NC} (skipping)"

+    fi

+    ((TOTAL_TESTS++))

+}

+

+# Build tests if needed

+if [ "$1" != "--no-build" ]; then

+    echo "Building tests..."

+    make test-build || exit 1

+    echo

+fi

+

+# Run unit tests

+echo "=== Unit Tests ==="

+run_test "arithmetic" "build/tests/unit/test_arithmetic" "unit"

+run_test "functions" "build/tests/unit/test_functions" "unit"

+run_test "complex" "build/tests/unit/test_complex" "unit"

+run_test "matrix" "build/tests/unit/test_matrix" "unit"

+echo

+

+# Run integration tests

+echo "=== Integration Tests ==="

+run_test "expressions" "build/tests/integration/test_expressions" "integration"

+run_test "variables" "build/tests/integration/test_variables" "integration"

+echo

+

+# Run end-to-end tests using test scripts

+echo "=== End-to-End Tests ==="

+if [ -d "tests/fixtures" ]; then

+    for fixture in tests/fixtures/*.fb; do

+        if [ -f "$fixture" ]; then

+            test_name=$(basename "$fixture" .fb)

+            echo -n "Running E2E test: $test_name ... "

+

+            expected_output="${fixture%.fb}.expected"

+            if [ -f "$expected_output" ]; then

+                if ./build/bin/fortbite < "$fixture" > "test_results/${test_name}.out" 2>&1; then

+                    # Strip prompts and compare output

+                    grep -v "fortbite>" "test_results/${test_name}.out" | \

+                    grep -v "======" | \

+                    grep -v "Type" | \

+                    grep -v "Use" | \

+                    grep -v "Goodbye" > "test_results/${test_name}.clean"

+

+                    if diff -q "$expected_output" "test_results/${test_name}.clean" > /dev/null; then

+                        echo -e "${GREEN}PASSED${NC}"

+                        ((PASSED_TESTS++))

+                    else

+                        echo -e "${RED}FAILED${NC} (output mismatch)"

+                        ((FAILED_TESTS++))

+                        FAILED_LIST="$FAILED_LIST\n  - E2E: $test_name"

+                    fi

+                else

+                    echo -e "${RED}FAILED${NC} (execution error)"

+                    ((FAILED_TESTS++))

+                    FAILED_LIST="$FAILED_LIST\n  - E2E: $test_name"

+                fi

+            else

+                echo -e "${YELLOW}NO EXPECTED OUTPUT${NC} (skipping)"

+            fi

+            ((TOTAL_TESTS++))

+        fi

+    done

+fi

+echo

+

+# Summary

+echo "================================"

+echo "         Test Summary"

+echo "================================"

+echo -e "Total:  $TOTAL_TESTS tests"

+echo -e "Passed: ${GREEN}$PASSED_TESTS${NC} tests"

+echo -e "Failed: ${RED}$FAILED_TESTS${NC} tests"

+

+if [ $FAILED_TESTS -gt 0 ]; then

+    echo

+    echo -e "${RED}Failed tests:${NC}"

+    echo -e "$FAILED_LIST"

+    exit 1

+else

+    echo

+    echo -e "${GREEN}All tests passed!${NC}"

+    exit 0

+fi

+!> Test framework module for FORTBITE

+!> Provides utilities for unit testing

+module test_framework

+    use iso_fortran_env, only: real64, output_unit, error_unit

+    implicit none

+    private

+

+    public :: test_suite, test_case, assert_equals, assert_true, assert_false

+    public :: assert_near, run_test_suite, init_test_suite, add_test_case

+

+    !> Test case type

+    type :: test_case

+        character(len=100) :: name = ''

+        logical :: passed = .true.

+        character(len=200) :: failure_message = ''

+    end type test_case

+

+    !> Test suite type

+    type :: test_suite

+        character(len=100) :: name = ''

+        type(test_case) :: tests(100)

+        integer :: test_count = 0

+        integer :: passed_count = 0

+        integer :: failed_count = 0

+        integer :: current_test_index = 0

+    end type test_suite

+

+contains

+

+    !> Initialize a test suite

+    function init_test_suite(name) result(suite)

+        character(len=*), intent(in) :: name

+        type(test_suite) :: suite

+

+        suite%name = trim(name)

+        suite%test_count = 0

+        suite%passed_count = 0

+        suite%failed_count = 0

+        suite%current_test_index = 0

+    end function init_test_suite

+

+    !> Add a test case to the suite

+    subroutine add_test_case(suite, name)

+        type(test_suite), intent(inout) :: suite

+        character(len=*), intent(in) :: name

+

+        suite%test_count = suite%test_count + 1

+        if (suite%test_count > size(suite%tests)) then

+            write(error_unit, *) 'ERROR: Too many test cases!'

+            return

+        end if

+

+        suite%current_test_index = suite%test_count

+        suite%tests(suite%test_count)%name = trim(name)

+        suite%tests(suite%test_count)%passed = .true.

+        suite%tests(suite%test_count)%failure_message = ''

+    end subroutine add_test_case

+

+    !> Run all tests in a suite

+    subroutine run_test_suite(suite)

+        type(test_suite), intent(inout) :: suite

+        integer :: i

+

+        write(output_unit, '(A)') repeat('=', 60)

+        write(output_unit, '(A,A)') 'Running Test Suite: ', trim(suite%name)

+        write(output_unit, '(A)') repeat('=', 60)

+

+        suite%passed_count = 0

+        suite%failed_count = 0

+

+        do i = 1, suite%test_count

+            if (suite%tests(i)%passed) then

+                suite%passed_count = suite%passed_count + 1

+                write(output_unit, '(A,A,A)') '✓ ', trim(suite%tests(i)%name), ' ... PASSED'

+            else

+                suite%failed_count = suite%failed_count + 1

+                write(output_unit, '(A,A,A)') '✗ ', trim(suite%tests(i)%name), ' ... FAILED'

+                if (len_trim(suite%tests(i)%failure_message) > 0) then

+                    write(output_unit, '(A,A)') '  ', trim(suite%tests(i)%failure_message)

+                end if

+            end if

+        end do

+

+        write(output_unit, '(A)') repeat('-', 60)

+        write(output_unit, '(A,I0,A,I0,A,I0,A)') 'Results: ', &

+            suite%passed_count, ' passed, ', &

+            suite%failed_count, ' failed, ', &

+            suite%test_count, ' total'

+        write(output_unit, '(A)') repeat('=', 60)

+    end subroutine run_test_suite

+

+    !> Assert that two real values are equal

+    subroutine assert_equals(suite, actual, expected, message)

+        type(test_suite), intent(inout) :: suite

+        real(real64), intent(in) :: actual, expected

+        character(len=*), intent(in), optional :: message

+

+        character(len=200) :: fail_msg

+        integer :: idx

+

+        idx = suite%current_test_index

+        if (idx < 1 .or. idx > suite%test_count) return

+

+        if (abs(actual - expected) > epsilon(1.0_real64)) then

+            write(fail_msg, '(A,G0,A,G0)') 'Expected: ', expected, ', Got: ', actual

+            if (present(message)) then

+                fail_msg = trim(message) // ' - ' // trim(fail_msg)

+            end if

+            suite%tests(idx)%passed = .false.

+            suite%tests(idx)%failure_message = trim(fail_msg)

+        end if

+    end subroutine assert_equals

+

+    !> Assert that two real values are approximately equal

+    subroutine assert_near(suite, actual, expected, tolerance, message)

+        type(test_suite), intent(inout) :: suite

+        real(real64), intent(in) :: actual, expected, tolerance

+        character(len=*), intent(in), optional :: message

+

+        character(len=200) :: fail_msg

+        integer :: idx

+

+        idx = suite%current_test_index

+        if (idx < 1 .or. idx > suite%test_count) return

+

+        if (abs(actual - expected) > tolerance) then

+            write(fail_msg, '(A,G0,A,G0,A,G0)') 'Expected: ', expected, &

+                ' (±', tolerance, '), Got: ', actual

+            if (present(message)) then

+                fail_msg = trim(message) // ' - ' // trim(fail_msg)

+            end if

+            suite%tests(idx)%passed = .false.

+            suite%tests(idx)%failure_message = trim(fail_msg)

+        end if

+    end subroutine assert_near

+

+    !> Assert that a condition is true

+    subroutine assert_true(suite, condition, message)

+        type(test_suite), intent(inout) :: suite

+        logical, intent(in) :: condition

+        character(len=*), intent(in), optional :: message

+

+        integer :: idx

+

+        idx = suite%current_test_index

+        if (idx < 1 .or. idx > suite%test_count) return

+

+        if (.not. condition) then

+            suite%tests(idx)%passed = .false.

+            if (present(message)) then

+                suite%tests(idx)%failure_message = trim(message)

+            else

+                suite%tests(idx)%failure_message = 'Assertion failed: Expected true, got false'

+            end if

+        end if

+    end subroutine assert_true

+

+    !> Assert that a condition is false

+    subroutine assert_false(suite, condition, message)

+        type(test_suite), intent(inout) :: suite

+        logical, intent(in) :: condition

+        character(len=*), intent(in), optional :: message

+

+        integer :: idx

+

+        idx = suite%current_test_index

+        if (idx < 1 .or. idx > suite%test_count) return

+

+        if (condition) then

+            suite%tests(idx)%passed = .false.

+            if (present(message)) then

+                suite%tests(idx)%failure_message = trim(message)

+            else

+                suite%tests(idx)%failure_message = 'Assertion failed: Expected false, got true'

+            end if

+        end if

+    end subroutine assert_false

+

+end module test_framework

+!> Unit tests for arithmetic operations

+program test_arithmetic

+    use test_framework

+    use fortbite_types_m, only: value_t, create_scalar, VALUE_SCALAR

+    use fortbite_arithmetic_m, only: add_values, subtract_values, multiply_values, &

+                                    divide_values, power_values, negate_value

+    use iso_fortran_env, only: real64

+    implicit none

+

+    type(test_suite) :: suite

+    type(value_t) :: a, b, result

+    real(real64) :: expected

+

+    ! Initialize test suite

+    suite = init_test_suite('Arithmetic Operations')

+

+    ! Test addition

+    call add_test_case(suite, 'Addition: 2 + 3 = 5')

+    a = create_scalar(2.0_real64)

+    b = create_scalar(3.0_real64)

+    result = add_values(a, b)

+    call assert_equals(suite, result%scalar_val, 5.0_real64)

+

+    call add_test_case(suite, 'Addition: -5 + 3 = -2')

+    a = create_scalar(-5.0_real64)

+    b = create_scalar(3.0_real64)

+    result = add_values(a, b)

+    call assert_equals(suite, result%scalar_val, -2.0_real64)

+

+    call add_test_case(suite, 'Addition: 0.1 + 0.2')

+    a = create_scalar(0.1_real64)

+    b = create_scalar(0.2_real64)

+    result = add_values(a, b)

+    call assert_near(suite, result%scalar_val, 0.3_real64, 1.0e-10_real64)

+

+    ! Test subtraction

+    call add_test_case(suite, 'Subtraction: 10 - 3 = 7')

+    a = create_scalar(10.0_real64)

+    b = create_scalar(3.0_real64)

+    result = subtract_values(a, b)

+    call assert_equals(suite, result%scalar_val, 7.0_real64)

+

+    call add_test_case(suite, 'Subtraction: -5 - 3 = -8')

+    a = create_scalar(-5.0_real64)

+    b = create_scalar(3.0_real64)

+    result = subtract_values(a, b)

+    call assert_equals(suite, result%scalar_val, -8.0_real64)

+

+    ! Test multiplication

+    call add_test_case(suite, 'Multiplication: 4 * 5 = 20')

+    a = create_scalar(4.0_real64)

+    b = create_scalar(5.0_real64)

+    result = multiply_values(a, b)

+    call assert_equals(suite, result%scalar_val, 20.0_real64)

+

+    call add_test_case(suite, 'Multiplication: -3 * 7 = -21')

+    a = create_scalar(-3.0_real64)

+    b = create_scalar(7.0_real64)

+    result = multiply_values(a, b)

+    call assert_equals(suite, result%scalar_val, -21.0_real64)

+

+    call add_test_case(suite, 'Multiplication: -2 * -3 = 6')

+    a = create_scalar(-2.0_real64)

+    b = create_scalar(-3.0_real64)

+    result = multiply_values(a, b)

+    call assert_equals(suite, result%scalar_val, 6.0_real64)

+

+    ! Test division

+    call add_test_case(suite, 'Division: 15 / 3 = 5')

+    a = create_scalar(15.0_real64)

+    b = create_scalar(3.0_real64)

+    result = divide_values(a, b)

+    call assert_equals(suite, result%scalar_val, 5.0_real64)

+

+    call add_test_case(suite, 'Division: 7 / 2 = 3.5')

+    a = create_scalar(7.0_real64)

+    b = create_scalar(2.0_real64)

+    result = divide_values(a, b)

+    call assert_equals(suite, result%scalar_val, 3.5_real64)

+

+    call add_test_case(suite, 'Division: -12 / 4 = -3')

+    a = create_scalar(-12.0_real64)

+    b = create_scalar(4.0_real64)

+    result = divide_values(a, b)

+    call assert_equals(suite, result%scalar_val, -3.0_real64)

+

+    ! Test power operations

+    call add_test_case(suite, 'Power: 2^3 = 8')

+    a = create_scalar(2.0_real64)

+    b = create_scalar(3.0_real64)

+    result = power_values(a, b)

+    call assert_equals(suite, result%scalar_val, 8.0_real64)

+

+    call add_test_case(suite, 'Power: 5^2 = 25')

+    a = create_scalar(5.0_real64)

+    b = create_scalar(2.0_real64)

+    result = power_values(a, b)

+    call assert_equals(suite, result%scalar_val, 25.0_real64)

+

+    call add_test_case(suite, 'Power: 4^0.5 = 2')

+    a = create_scalar(4.0_real64)

+    b = create_scalar(0.5_real64)

+    result = power_values(a, b)

+    call assert_equals(suite, result%scalar_val, 2.0_real64)

+

+    call add_test_case(suite, 'Power: 10^-1 = 0.1')

+    a = create_scalar(10.0_real64)

+    b = create_scalar(-1.0_real64)

+    result = power_values(a, b)

+    call assert_near(suite, result%scalar_val, 0.1_real64, 1.0e-10_real64)

+

+    ! Test negation

+    call add_test_case(suite, 'Negation: -(5) = -5')

+    a = create_scalar(5.0_real64)

+    result = negate_value(a)

+    call assert_equals(suite, result%scalar_val, -5.0_real64)

+

+    call add_test_case(suite, 'Negation: -(-3) = 3')

+    a = create_scalar(-3.0_real64)

+    result = negate_value(a)

+    call assert_equals(suite, result%scalar_val, 3.0_real64)

+

+    ! Test special cases

+    call add_test_case(suite, 'Addition with zero: 5 + 0 = 5')

+    a = create_scalar(5.0_real64)

+    b = create_scalar(0.0_real64)

+    result = add_values(a, b)

+    call assert_equals(suite, result%scalar_val, 5.0_real64)

+

+    call add_test_case(suite, 'Multiplication by zero: 5 * 0 = 0')

+    a = create_scalar(5.0_real64)

+    b = create_scalar(0.0_real64)

+    result = multiply_values(a, b)

+    call assert_equals(suite, result%scalar_val, 0.0_real64)

+

+    call add_test_case(suite, 'Multiplication by one: 7 * 1 = 7')

+    a = create_scalar(7.0_real64)

+    b = create_scalar(1.0_real64)

+    result = multiply_values(a, b)

+    call assert_equals(suite, result%scalar_val, 7.0_real64)

+

+    ! Run the test suite

+    call run_test_suite(suite)

+

+end program test_arithmetic

+!> Unit tests for mathematical functions

+program test_functions

+    use test_framework

+    use fortbite_types_m, only: value_t, create_scalar, create_complex, VALUE_SCALAR, VALUE_COMPLEX

+    use fortbite_functions_m, only: eval_trigonometric, eval_hyperbolic, eval_logarithmic, &

+                                   eval_exponential, eval_statistical, eval_special, &

+                                   eval_complex_functions

+    use iso_fortran_env, only: real64

+    implicit none

+

+    type(test_suite) :: suite

+    type(value_t) :: arg, result

+    real(real64) :: pi

+

+    ! Initialize test suite

+    suite = init_test_suite('Mathematical Functions')

+    pi = 4.0_real64 * atan(1.0_real64)

+

+    ! Test trigonometric functions

+    call add_test_case(suite, 'sin(0) = 0')

+    arg = create_scalar(0.0_real64)

+    result = eval_trigonometric('sin', arg)

+    call assert_near(suite, result%scalar_val, 0.0_real64, 1.0e-10_real64)

+

+    call add_test_case(suite, 'sin(pi/2) = 1')

+    arg = create_scalar(pi/2.0_real64)

+    result = eval_trigonometric('sin', arg)

+    call assert_near(suite, result%scalar_val, 1.0_real64, 1.0e-10_real64)

+

+    call add_test_case(suite, 'cos(0) = 1')

+    arg = create_scalar(0.0_real64)

+    result = eval_trigonometric('cos', arg)

+    call assert_near(suite, result%scalar_val, 1.0_real64, 1.0e-10_real64)

+

+    call add_test_case(suite, 'cos(pi) = -1')

+    arg = create_scalar(pi)

+    result = eval_trigonometric('cos', arg)

+    call assert_near(suite, result%scalar_val, -1.0_real64, 1.0e-10_real64)

+

+    call add_test_case(suite, 'tan(0) = 0')

+    arg = create_scalar(0.0_real64)

+    result = eval_trigonometric('tan', arg)

+    call assert_near(suite, result%scalar_val, 0.0_real64, 1.0e-10_real64)

+

+    call add_test_case(suite, 'tan(pi/4) = 1')

+    arg = create_scalar(pi/4.0_real64)

+    result = eval_trigonometric('tan', arg)

+    call assert_near(suite, result%scalar_val, 1.0_real64, 1.0e-10_real64)

+

+    ! Test inverse trigonometric functions

+    call add_test_case(suite, 'asin(0) = 0')

+    arg = create_scalar(0.0_real64)

+    result = eval_trigonometric('asin', arg)

+    call assert_near(suite, result%scalar_val, 0.0_real64, 1.0e-10_real64)

+

+    call add_test_case(suite, 'asin(1) = pi/2')

+    arg = create_scalar(1.0_real64)

+    result = eval_trigonometric('asin', arg)

+    call assert_near(suite, result%scalar_val, pi/2.0_real64, 1.0e-10_real64)

+

+    call add_test_case(suite, 'acos(1) = 0')

+    arg = create_scalar(1.0_real64)

+    result = eval_trigonometric('acos', arg)

+    call assert_near(suite, result%scalar_val, 0.0_real64, 1.0e-10_real64)

+

+    call add_test_case(suite, 'atan(1) = pi/4')

+    arg = create_scalar(1.0_real64)

+    result = eval_trigonometric('atan', arg)

+    call assert_near(suite, result%scalar_val, pi/4.0_real64, 1.0e-10_real64)

+

+    ! Test hyperbolic functions

+    call add_test_case(suite, 'sinh(0) = 0')

+    arg = create_scalar(0.0_real64)

+    result = eval_hyperbolic('sinh', arg)

+    call assert_near(suite, result%scalar_val, 0.0_real64, 1.0e-10_real64)

+

+    call add_test_case(suite, 'cosh(0) = 1')

+    arg = create_scalar(0.0_real64)

+    result = eval_hyperbolic('cosh', arg)

+    call assert_near(suite, result%scalar_val, 1.0_real64, 1.0e-10_real64)

+

+    call add_test_case(suite, 'tanh(0) = 0')

+    arg = create_scalar(0.0_real64)

+    result = eval_hyperbolic('tanh', arg)

+    call assert_near(suite, result%scalar_val, 0.0_real64, 1.0e-10_real64)

+

+    ! Test logarithmic functions

+    call add_test_case(suite, 'log(e) = 1')

+    arg = create_scalar(exp(1.0_real64))

+    result = eval_logarithmic('log', arg)

+    call assert_near(suite, result%scalar_val, 1.0_real64, 1.0e-10_real64)

+

+    call add_test_case(suite, 'ln(e) = 1')

+    arg = create_scalar(exp(1.0_real64))

+    result = eval_logarithmic('ln', arg)

+    call assert_near(suite, result%scalar_val, 1.0_real64, 1.0e-10_real64)

+

+    call add_test_case(suite, 'log10(10) = 1')

+    arg = create_scalar(10.0_real64)

+    result = eval_logarithmic('log10', arg)

+    call assert_near(suite, result%scalar_val, 1.0_real64, 1.0e-10_real64)

+

+    call add_test_case(suite, 'log10(100) = 2')

+    arg = create_scalar(100.0_real64)

+    result = eval_logarithmic('log10', arg)

+    call assert_near(suite, result%scalar_val, 2.0_real64, 1.0e-10_real64)

+

+    call add_test_case(suite, 'log2(8) = 3')

+    arg = create_scalar(8.0_real64)

+    result = eval_logarithmic('log2', arg)

+    call assert_near(suite, result%scalar_val, 3.0_real64, 1.0e-10_real64)

+

+    ! Test exponential functions

+    call add_test_case(suite, 'exp(0) = 1')

+    arg = create_scalar(0.0_real64)

+    result = eval_exponential('exp', arg)

+    call assert_near(suite, result%scalar_val, 1.0_real64, 1.0e-10_real64)

+

+    call add_test_case(suite, 'exp(1) = e')

+    arg = create_scalar(1.0_real64)

+    result = eval_exponential('exp', arg)

+    call assert_near(suite, result%scalar_val, exp(1.0_real64), 1.0e-10_real64)

+

+    call add_test_case(suite, 'exp2(3) = 8')

+    arg = create_scalar(3.0_real64)

+    result = eval_exponential('exp2', arg)

+    call assert_near(suite, result%scalar_val, 8.0_real64, 1.0e-10_real64)

+

+    call add_test_case(suite, 'exp10(2) = 100')

+    arg = create_scalar(2.0_real64)

+    result = eval_exponential('exp10', arg)

+    call assert_near(suite, result%scalar_val, 100.0_real64, 1.0e-10_real64)

+

+    ! Test special functions

+    call add_test_case(suite, 'floor(3.7) = 3')

+    arg = create_scalar(3.7_real64)

+    result = eval_special('floor', arg)

+    call assert_equals(suite, result%scalar_val, 3.0_real64)

+

+    call add_test_case(suite, 'floor(-2.3) = -3')

+    arg = create_scalar(-2.3_real64)

+    result = eval_special('floor', arg)

+    call assert_equals(suite, result%scalar_val, -3.0_real64)

+

+    call add_test_case(suite, 'ceil(3.2) = 4')

+    arg = create_scalar(3.2_real64)

+    result = eval_special('ceil', arg)

+    call assert_equals(suite, result%scalar_val, 4.0_real64)

+

+    call add_test_case(suite, 'ceil(-2.7) = -2')

+    arg = create_scalar(-2.7_real64)

+    result = eval_special('ceil', arg)

+    call assert_equals(suite, result%scalar_val, -2.0_real64)

+

+    call add_test_case(suite, 'round(3.5) = 4')

+    arg = create_scalar(3.5_real64)

+    result = eval_special('round', arg)

+    call assert_equals(suite, result%scalar_val, 4.0_real64)

+

+    call add_test_case(suite, 'round(3.4) = 3')

+    arg = create_scalar(3.4_real64)

+    result = eval_special('round', arg)

+    call assert_equals(suite, result%scalar_val, 3.0_real64)

+

+    call add_test_case(suite, 'factorial(5) = 120')

+    arg = create_scalar(5.0_real64)

+    result = eval_special('factorial', arg)

+    call assert_equals(suite, result%scalar_val, 120.0_real64)

+

+    call add_test_case(suite, 'factorial(0) = 1')

+    arg = create_scalar(0.0_real64)

+    result = eval_special('factorial', arg)

+    call assert_equals(suite, result%scalar_val, 1.0_real64)

+

+    ! Test complex functions

+    call add_test_case(suite, 'real(3+4i) = 3')

+    arg = create_complex(3.0_real64, 4.0_real64)

+    result = eval_complex_functions('real', arg)

+    call assert_equals(suite, result%scalar_val, 3.0_real64)

+

+    call add_test_case(suite, 'imag(3+4i) = 4')

+    arg = create_complex(3.0_real64, 4.0_real64)

+    result = eval_complex_functions('imag', arg)

+    call assert_equals(suite, result%scalar_val, 4.0_real64)

+

+    call add_test_case(suite, 'abs(3+4i) = 5')

+    arg = create_complex(3.0_real64, 4.0_real64)

+    result = eval_complex_functions('cabs', arg)

+    call assert_equals(suite, result%scalar_val, 5.0_real64)

+

+    call add_test_case(suite, 'arg(1+i) = pi/4')

+    arg = create_complex(1.0_real64, 1.0_real64)

+    result = eval_complex_functions('arg', arg)

+    call assert_near(suite, result%scalar_val, pi/4.0_real64, 1.0e-10_real64)

+

+    ! Run the test suite

+    call run_test_suite(suite)

+

+end program test_functions