#include <cassert>
#include <iostream>

// Include or place the SMatrix class definition here

int main()
{
    // --------------------------------------------------
    // 1. Default constructor
    // --------------------------------------------------
    SMatrix<int, 3> m1;

    assert(m1.size() == 3);

 

    // --------------------------------------------------
    // 2. Constructor with a value
    // --------------------------------------------------
    SMatrix<int, 2> m2(5);

    assert(m2.get(0, 0) == 5);
    assert(m2.get(0, 1) == 5);
    assert(m2.get(1, 0) == 5);
    assert(m2.get(1, 1) == 5);


    // --------------------------------------------------
    // 3. Constructor with initializer_list
    // --------------------------------------------------
    SMatrix<int, 2> m3({1, 2, 3, 4});

    assert(m3.get(0, 0) == 1);
    assert(m3.get(0, 1) == 2);
    assert(m3.get(1, 0) == 3);
    assert(m3.get(1, 1) == 4);


    // --------------------------------------------------
    // 4. set()
    // --------------------------------------------------
    m3.set(0, 1, 42);

    assert(m3.get(0, 1) == 42);


    // --------------------------------------------------
    // 5. operator[][] for reading
    // --------------------------------------------------
    assert(m3[0][0] == 1);
    assert(m3[0][1] == 42);
    assert(m3[1][0] == 3);
    assert(m3[1][1] == 4);


    // --------------------------------------------------
    // 6. operator[][] for writing
    // --------------------------------------------------
    m3[1][0] = 99;

    assert(m3.get(1, 0) == 99);


    // --------------------------------------------------
    // 7. Copy constructor
    // --------------------------------------------------
    SMatrix<int, 2> m4(m3);

    assert(m4.equals(m3));


    // --------------------------------------------------
    // 8. Check that the copy is independent
    // --------------------------------------------------
    m4[0][0] = 1000;

    assert(m4[0][0] == 1000);
    assert(m3[0][0] == 1);

    assert(!m4.equals(m3));


    // --------------------------------------------------
    // 9. Assignment operator
    // --------------------------------------------------
    m4 = m3;

    assert(m4.equals(m3));


    // --------------------------------------------------
    // 10. Self-assignment
    // --------------------------------------------------
    m3 = m3;

    assert(m3[0][0] == 1);
    assert(m3[0][1] == 42);
    assert(m3[1][0] == 99);
    assert(m3[1][1] == 4);


    // --------------------------------------------------
    // 11. Tests with a const object
    // --------------------------------------------------
    const SMatrix<int, 2> cm({10, 20, 30, 40});

    assert(cm.size() == 2);

    assert(cm.get(0, 0) == 10);
    assert(cm.get(0, 1) == 20);
    assert(cm.get(1, 0) == 30);
    assert(cm.get(1, 1) == 40);


    // --------------------------------------------------
    // 12. operator[][] on a const object
    // --------------------------------------------------
    assert(cm[0][0] == 10);
    assert(cm[1][1] == 40);


    // --------------------------------------------------
    // 13. equals() with a const argument
    // --------------------------------------------------
    const SMatrix<int, 2> ca({1, 2, 3, 4});

    SMatrix<int, 2> cb({1, 2, 3, 4});

    assert(cb.equals(ca));


    // --------------------------------------------------
    // 14. equals() with different matrices
    // --------------------------------------------------
    const SMatrix<int, 2> cc({1, 2, 3, 5});

    assert(!cb.equals(cc));


    // --------------------------------------------------
    // 15. Test with double
    // --------------------------------------------------
    SMatrix<double, 2> md(3.5);

    assert(md.get(0, 0) == 3.5);
    assert(md[1][1] == 3.5);


    // --------------------------------------------------
    // 16. 1x1 matrix
    // --------------------------------------------------
    SMatrix<int, 1> one({42});

    assert(one.size() == 1);
    assert(one.get(0, 0) == 42);
    assert(one[0][0] == 42);


    // --------------------------------------------------
    // 17. print()
    // --------------------------------------------------
    std::cout << "Displaying m3:" << std::endl;
    m3.print();

    std::cout << std::endl;
    std::cout << "All tests passed." << std::endl;

    return 0;
}