#include "List.h"
#include "unit_test_framework.h"

using namespace std;

// Add your test cases here

TEST(test_empty1) {
    List<int> list;
    ASSERT_TRUE(list.empty());
}

TEST(test_empty2) {
    List<int> list;
    list.push_back(1);
    ASSERT_TRUE(!list.empty());
}

TEST(test_size1) {
    List<int> list;
    ASSERT_TRUE(list.size() == 0);
}

TEST(test_size2) {
    List<int> list;
    list.push_back(1);
    ASSERT_TRUE(list.size() == 1);
}

TEST(test_front1) {
    List<int> list;
    list.push_back(1);
    ASSERT_TRUE(list.front() == 1);
    ASSERT_TRUE(list.back() == 1);
}

TEST(test_front2) {
    List<int> list;
    list.push_back(3);
    list.push_back(2);
    list.push_back(1);
    ASSERT_TRUE(list.front() == 3);
    ASSERT_TRUE(list.back() == 1);
}

TEST(test_back1) {
    List<int> list;
    list.push_back(1);
    ASSERT_TRUE(list.back() == 1);
    ASSERT_TRUE(list.front() == 1);
}

TEST(test_back2) {
    List<int> list;
    list.push_back(1);
    list.push_back(2);
    list.push_back(3);
    list.push_back(4);
    list.push_back(5);
    ASSERT_TRUE(list.back() == 5);
    ASSERT_TRUE(list.front() == 1);
}

TEST(test_push_front1) {
    List<int> list;
    list.push_front(1);
    ASSERT_TRUE(list.front() == 1);
    ASSERT_TRUE(list.back() == 1);
}

TEST(test_push_front2) {
    List<int> list;
    list.push_front(1);
    list.push_front(2);
    list.push_front(3);
    ASSERT_TRUE(list.front() == 3);
    ASSERT_TRUE(list.back() == 1);
}

TEST(test_push_back1) {
    List<int> list;
    list.push_back(1);
    ASSERT_TRUE(list.front() == 1);
    ASSERT_TRUE(list.back() == 1);
}

TEST(test_push_back2) {
    List<int> list;
    list.push_back(1);
    list.push_back(2);
    list.push_back(3);
    ASSERT_TRUE(list.front() == 1);
    ASSERT_TRUE(list.back() == 3);
}
TEST(test_pop_front1) {
    List<int> list;
    list.push_front(1);
    list.push_front(2);
    list.push_front(3);
    list.pop_front();
    ASSERT_TRUE(list.front() == 2);
    ASSERT_TRUE(list.back() == 1);
}

TEST(test_pop_front2) {
    List<int> list;
    list.push_front(1);
    list.pop_front();
    ASSERT_TRUE(list.empty());
}

TEST(test_pop_front3) {
    List<int> list;
    list.push_front(1);
    list.push_front(2);
    list.push_front(3);
    list.pop_front();
    list.pop_front();
    list.pop_front();
    ASSERT_TRUE(list.empty());
}

TEST(test_pop_back1) {
    List<int> list;
    list.push_back(1);
    list.push_back(2);
    list.push_back(3);
    list.pop_back();
    ASSERT_TRUE(list.front() == 1);
    ASSERT_TRUE(list.back() == 2);
}

TEST(test_pop_back2) {
    List<int> list;
    list.push_back(1);
    list.pop_back();
    ASSERT_TRUE(list.empty());
}

TEST(test_clear1) {
    List<int> list;
    list.push_back(1);
    list.push_back(2);
    list.push_back(3);
    list.clear();
    ASSERT_TRUE(list.empty());
}

TEST(test_clear2) {
    List<int> list;
    list.clear();
    ASSERT_TRUE(list.empty());
}

TEST(test_List_def_ctor) {
    List<int> list;
    ASSERT_TRUE(list.size() == 0);
    ASSERT_TRUE(list.empty());
}

TEST(test_List_copy_ctor1) {
    List<int> list;
    List<int> copy(list);
    ASSERT_TRUE(copy.empty())
}

TEST(test_List_copy_ctor2) {
    List<int> list;
    list.push_back(1);
    list.push_back(2);
    List<int> copy(list);
    ASSERT_TRUE(copy.front() == 1);
    ASSERT_TRUE(copy.back() == 2);
    ASSERT_TRUE(copy.size() == 2);
}

TEST(test_List_operator_assign1) {
    List<int> list;
    list.push_back(1);
    list.push_back(2);

    List<int> copy;
    copy = list;
    ASSERT_TRUE(copy.front() == 1);
    ASSERT_TRUE(copy.back() == 2);
    ASSERT_TRUE(copy.size() == 2);
}

TEST(test_List_operator_assign2) {
    List<int> list;
    list.push_back(1);
    list.push_back(2);
    list = list;
    ASSERT_TRUE(list.front() == 1);
    ASSERT_TRUE(list.back() == 2);
    ASSERT_TRUE(list.size() == 2);
}

TEST(test_List_operator_assign3) {
    List<int> list;
    List<int> copy;
    copy = list;
    ASSERT_TRUE(copy.size() == 0);
    ASSERT_TRUE(copy.empty());
}

TEST(test_List_operator_assign4) {
    List<int> list;
    List<int> copy;
    copy.push_back(1);
    copy.push_back(2);
    copy = list;
    ASSERT_TRUE(copy.size() == 0);
    ASSERT_TRUE(copy.empty());
}

TEST(test_List_operator_assign5) {
    List<int> list;
    list.push_back(1);
    list.push_back(2);
    list.push_back(3);
    list.push_back(4);
    list.push_back(5);
    List<int> copy;
    copy.push_back(1);
    copy.push_back(2);
    copy = list;
    ASSERT_TRUE(copy.size() == 5);
    ASSERT_TRUE(copy.front() == 1);
    ASSERT_TRUE(copy.back() == 5);
}

TEST(test_i_operator_prev) {
    List<int> list;
    list.push_back(1);
    list.push_back(2);
    List<int>::Iterator i = list.begin();
    --(++i);
    ASSERT_TRUE(*i == 1);
}

TEST(test_i_operator_deref) {
    List<int> list;
    list.push_back(1);
    List<int>::Iterator i = list.begin();
    ASSERT_TRUE(*i == 1);
}

TEST(test_i_operator_next1) {
    List<int> list;
    list.push_back(1);
    list.push_back(2);

    List<int>::Iterator i = list.begin();
    ++i;
    ASSERT_TRUE(*i == 2);
}

TEST(test_i_operator_next2) {
    List<int> list;
    list.push_back(1);
    list.push_back(2);

    List<int>::Iterator i = list.begin();
    ++(++i);
    ASSERT_TRUE(i == list.end());
}


TEST(test_i_operator_equals1) {
    List<int> list;
    list.push_back(1);

    List<int>::Iterator i = list.begin();
    ++i;
    ASSERT_TRUE(i == list.end());
}

TEST(test_i_operator_equals2) {
    List<int> list;
    list.push_back(1);
    list.push_back(2);
    List<int>::Iterator i = list.begin();
    ++i;
    ASSERT_TRUE(*i == 2);
}

TEST(test_i_operator_notEquals) {
    List<int> list;
    list.push_back(1);
    list.push_back(2);

    List<int>::Iterator i = list.begin();
    ++i;
    ASSERT_TRUE(i != list.begin());
}

TEST(test_i_begin) {
    List<int> list;
    list.push_back(1);
    list.push_back(2);

    List<int>::Iterator i = list.begin();
    ASSERT_TRUE(*i == 1);
}

TEST(test_Iterator_end) {
    List<int> list;
    list.push_back(1);
    list.push_back(2);

    List<int>::Iterator i = list.begin();
    ++(++i);
    ASSERT_TRUE(i == list.end());
}

TEST(test_i_erase1) {
    List<int> list;
    list.push_back(1);
    list.push_back(2);
    list.push_back(3);
    
    List<int>::Iterator i = list.begin();
    ++i;
    list.erase(i);
    ASSERT_TRUE(list.size() == 2);
    ASSERT_TRUE(list.front() == 1);
    ASSERT_TRUE(list.back() == 3);
}

TEST(test_i_erase2) {
    List<int> list;
    list.push_back(1);
    List<int>::Iterator i = list.begin();
    list.erase(i);
    ASSERT_TRUE(list.empty());
}

TEST(test_i_erase3) {
    List<int> list;
    list.push_back(1);
    list.push_back(2);
    List<int>::Iterator i = list.begin();
    ++i;
    list.erase(i);
    ASSERT_TRUE(list.back() == 1);
}

TEST(test_i_erase4) {
    List<int> list;
    list.push_back(1);
    list.push_back(2);
    List<int>::Iterator i = list.begin();
    list.erase(i);
    ASSERT_TRUE(list.front() == 2);
}

TEST(test_i_insert1) {
    List<int> list;
    list.push_back(2);
    List<int>::Iterator i = list.begin();
    list.insert(i, 1);
    ASSERT_TRUE(list.front() == 1);
    ASSERT_TRUE(list.back() == 2);
    ASSERT_TRUE(list.size() == 2);
}

TEST(test_i_insert2) {
    List<int> list;
    List<int>::Iterator i = list.end();
    list.insert(i, 1);
    ASSERT_TRUE(list.front() == 1);
    ASSERT_TRUE(list.back() == 1);
    ASSERT_TRUE(list.size() == 1);
}

TEST(test_i_insert3) {
    List<int> list;
    list.push_back(1);
    List<int>::Iterator i = list.end();
    list.insert(i, 2);
    ASSERT_TRUE(list.front() == 1);
    ASSERT_TRUE(list.back() == 2);
    ASSERT_TRUE(list.size() == 2);
}

TEST(test_i_insert4) {
    List<int> list;
    list.push_back(1);
    list.push_back(3);
    List<int>::Iterator i = list.begin();
    ++i;
    list.insert(i, 2);
    ASSERT_TRUE(list.front() == 1);
    ASSERT_TRUE(list.back() == 3);
    ASSERT_TRUE(list.size() == 3);
}

TEST(test_i_l_iteration1) {
    int count = 0;
    List<int> list;
    list.push_back(1);
    list.push_back(2);
    list.push_back(3);
    list.push_back(4);
    list.push_back(5);
    List<int>::Iterator i;
    for (i = list.begin(); i != list.end(); ++i) {
        count++;
    }
    ASSERT_TRUE(count == 5);
}

TEST(test_i_l_iteration2) {
    int count = 0;
    List<int> list;
    List<int>::Iterator i;
    for (i = list.begin(); i != list.end(); ++i) {
        count++;
    }
    ASSERT_TRUE(count == 0);
}

TEST_MAIN()