tests.cpp

// ronavraham1999@gmail.com

#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "doctest.h"
#include "SquareMat.hpp"

using namespace mat;

TEST_CASE("Constructor and basic properties") {
    SUBCASE("Valid size") {
        SquareMat m(3);
        CHECK(m[0][0] == 0.0);
        CHECK(m[2][2] == 0.0);
    }
    SUBCASE("Invalid size throws") {
        CHECK_THROWS_AS(SquareMat(-1), std::invalid_argument);
        CHECK_THROWS_AS(SquareMat(0), std::invalid_argument);
    }
}

TEST_CASE("Copy constructor and assignment") {
    SquareMat A(2);
    A[0][0] = 1; A[0][1] = 2;
    A[1][0] = 3; A[1][1] = 4;

    SUBCASE("Copy constructor creates deep copy") {
        SquareMat B(A);
        CHECK(B[0][0] == 1);
        B[0][0] = 99;
        CHECK(A[0][0] == 1); // A should remain unchanged
    }

    SUBCASE("Assignment operator creates deep copy") {
        SquareMat C(2);
        C = A;
        CHECK(C[1][1] == 4);
        C[1][1] = 77;
        CHECK(A[1][1] == 4); // A should remain unchanged
    }
}

TEST_CASE("Matrix arithmetic") {
    SquareMat A(2), B(2);
    A[0][0] = 1; A[0][1] = 2;
    A[1][0] = 3; A[1][1] = 4;

    B[0][0] = 5; B[0][1] = 6;
    B[1][0] = 7; B[1][1] = 8;

    SUBCASE("Addition and subtraction") {
        auto C = A + B;
        CHECK(C[0][0] == 6);
        auto D = B - A;
        CHECK(D[1][1] == 4);
    }

    SUBCASE("Unary minus") {
        auto C = -A;
        CHECK(C[0][0] == -1);
        CHECK(C[1][1] == -4);
    }

    SUBCASE("Matrix multiplication") {
        auto C = A * B;
        CHECK(C[0][0] == 19);
        CHECK(C[1][1] == 50);
    }

    SUBCASE("Scalar multiplication") {
        auto C = A * 2;
        CHECK(C[0][1] == 4);
        auto D = 2 * A;
        CHECK(D[1][0] == 6);
    }

    SUBCASE("Element-wise multiplication") {
        auto C = A % B;
        CHECK(C[0][0] == 5);
        CHECK(C[1][1] == 32);
    }

    SUBCASE("Modulo with scalar") {
        SquareMat C = B % 3;
        CHECK(C[0][0] == doctest::Approx(2.0));
    }

    SUBCASE("Division by scalar") {
        SquareMat C = A / 2;
        CHECK(C[1][1] == 2.0);
        CHECK_THROWS_AS(A / 0, std::invalid_argument);
    }

    SUBCASE("Power operator") {
        SquareMat I = A ^ 0;
        CHECK(I[0][0] == 1);
        CHECK(I[0][1] == 0);
        auto P = A ^ 2;
        CHECK(P[0][0] == 7);
        CHECK(P[1][1] == 22);
    }
}

TEST_CASE("Increment and Decrement") {
    SquareMat A(2);
    A[0][0] = 1; A[1][1] = 2;

    SUBCASE("Pre-increment") {
        ++A;
        CHECK(A[0][0] == 2);
    }

    SUBCASE("Post-increment") {
        SquareMat B = A++;
        CHECK(B[0][0] == 1);
        CHECK(A[0][0] == 2);
    }

    SUBCASE("Pre-decrement") {
        --A;
        CHECK(A[1][1] == 1);
    }

    SUBCASE("Post-decrement") {
        SquareMat B = A--;
        CHECK(B[1][1] == 2);
        CHECK(A[1][1] == 1);
    }
}

TEST_CASE("Transpose operator") {
    SquareMat A(2);
    A[0][1] = 5;
    auto T = ~A;
    CHECK(T[1][0] == 5);
}

TEST_CASE("Comparison operators") {
    SquareMat A(2), B(2);
    A[0][0] = 1; B[0][0] = 2;

    SUBCASE("Equality and inequality") {
        CHECK(A != B);
    }

    SUBCASE("Greater and less") {
        CHECK(B > A);
        CHECK(A < B);
        CHECK(A <= B);
        CHECK(B >= A);
    }
}

TEST_CASE("Determinant operator") {
    SquareMat A(2);
    A[0][0] = 1; A[0][1] = 2;
    A[1][0] = 3; A[1][1] = 4;
    CHECK(!A == -2);
}

TEST_CASE("Compound assignment operators") {
    SquareMat A(2), B(2);
    A[0][0] = 1; A[1][1] = 2;
    B[0][0] = 3; B[1][1] = 4;

    SUBCASE("Add and subtract assignment") {
        A += B;
        CHECK(A[0][0] == 4);
        A -= B;
        CHECK(A[0][0] == 1);
    }

    SUBCASE("Multiply and divide assignment with scalar") {
        A *= 2;
        CHECK(A[1][1] == 4);
        A /= 2;
        CHECK(A[1][1] == 2);
    }

    SUBCASE("Multiply assignment with matrix") {
        SquareMat C(2);
        C[0][0] = 1; C[1][1] = 1;
        A *= C;
        CHECK(A[0][0] == 1);
    }

    SUBCASE("Modulo assignment with scalar") {
        B %= 2;
        CHECK(B[0][0] == 1);
    }

    SUBCASE("Modulo assignment with matrix") {
        SquareMat C(2);
    C[0][0] = 2; C[0][1] = 2;
    C[1][0] = 2; C[1][1] = 2;        
    B %= C;
        CHECK(B[0][0] == 1);
    }
}