src/tests/test_s21_vector.cpp - master - Xakka/CPP2

src/tests/test_s21_vector.cpp
257 строк6 KB
moshedur
master: release 1.0
04 янв 2025, 23:35
04 янв 2025, 23:351c45f0a
#include "test_s21.h"

class test_vector : public testing::Test {
 public:
};

TEST(test_vector, test_vector_1) {
  s21::s21_vector<int> vec;
  vec[1] = 11;
  ASSERT_EQ(vec[1], 11);
}

TEST(test_vector, test_vector_2) {
  s21::s21_vector<int> vec{1, 2, 3, 4, 5};
  ASSERT_EQ(vec.at(3), 4);
}

TEST(test_vector, test_vector_3) {
  s21::s21_vector<int> vec{1, 2, 3, 4, 5};
  ASSERT_EQ(vec.at(3) = 12, 12);
}

TEST(test_vector, test_const_at) {
  const s21::s21_vector<int> vec{1, 2, 3, 4, 5};
  ASSERT_EQ(vec.at(3), 4);
}

TEST(test_vector, test_vector_5) {
  s21::s21_vector<int> vec{1, 2, 3, 4, 5};
  ASSERT_EQ(*vec.data(), 1);
}

TEST(test_vector, test_vector_6) {
  s21::s21_vector<int> vec{1, 2, 3, 4, 5};
  ASSERT_EQ(vec.front(), 1);
}

TEST(test_vector, test_vector_7) {
  s21::s21_vector<int> vec{1, 2, 3, 4, 5};
  ASSERT_EQ(vec.back(), 5);
}

TEST(test_vector, test_vector_8) {
  s21::s21_vector<int> vec{1, 2, 3, 4, 5};
  ASSERT_EQ(vec.empty(), 0);
}

TEST(test_vector, test_vector_9) {
  s21::s21_vector<int> vec{1, 2, 3, 4, 5};
  ASSERT_EQ(vec.size(), 5);
}

TEST(test_vector, test_vector_10) {
  s21::s21_vector<int> vec{1, 2, 3, 4, 5};
  ASSERT_EQ((vec.max_size() > 0), 1);
}

TEST(test_vector, test_reserve) {
  s21::s21_vector<int> vec{1, 2, 3, 4, 5};
  s21::s21_vector<int> vec2{1, 2, 3, 4, 5};
  vec2.reserve(55);
  for (size_t x = 0; x < vec2.size(); x++) {
    ASSERT_EQ(vec2[x], vec[x]);
  }
  ASSERT_EQ(vec2.capacity(), 55);
  ASSERT_EQ(vec2.size(), 5);
}

TEST(test_vector, test_reserve2) {
  s21::s21_vector<int> vec{1, 2, 3, 4, 5};
  EXPECT_THROW(vec.reserve(4), std::invalid_argument);
}

TEST(test_vector, test_vector_12) {
  s21::s21_vector<int> vec{1, 2, 3, 4, 5};
  ASSERT_EQ(vec.capacity(), 5);
}

TEST(test_vector, test_vector_13) {
  s21::s21_vector<int> reference(5);
  reference[0] = 11;
  reference.reserve(14);
  reference.shrink_to_fit();
  ASSERT_EQ(reference.capacity(), 5);
  ASSERT_EQ(reference[0], 11);
}

TEST(test_vector, test_vector_14) {
  s21::s21_vector<int> reference(5);
  s21::s21_vector<int> vec = reference;
  ASSERT_EQ(reference.capacity(), vec.capacity());
  ASSERT_EQ(reference.size(), vec.size());
}

TEST(test_vector, test_vector_15) {
  s21::s21_vector<int> reference(5);
  s21::s21_vector<int> reference2(5);
  s21::s21_vector<int> vec = std::move(reference);
  ASSERT_EQ(reference2.capacity(), vec.capacity());
  ASSERT_EQ(reference2.size(), vec.size());
}

TEST(test_vector, test_vector_16) {
  s21::s21_vector<int> reference{1, 2, 3};
  s21::s21_vector<int> result{2, 3, 4};
  s21::s21_vector<int> vec{2, 3, 4};
  reference = std::move(vec);
  for (size_t x = 0; x < reference.size(); x++) {
    ASSERT_EQ(reference[x], result[x]);
  }
}

TEST(test_vector, test_clear) {
  s21::s21_vector<int> vec{1, 2, 3};
  vec.clear();
  ASSERT_EQ(vec.size(), 0);
}

TEST(test_vector, test_pop_back) {
  s21::s21_vector<int> vec{1, 2, 3};
  vec.pop_back();
  ASSERT_EQ(vec.size(), 2);
}

TEST(test_vector, test_push_back) {
  s21::s21_vector<int> vec{1, 2, 3};
  vec.reserve(10);
  vec.push_back(11);
  ASSERT_EQ(vec[3], 11);
}

TEST(test_vector, test_push_back2) {
  s21::s21_vector<int> vec{1, 2, 3};
  vec.push_back(11);
  ASSERT_EQ(vec[3], 11);
}

TEST(test_vector, test_swap) {
  s21::s21_vector<int> vec{1, 2, 3};
  s21::s21_vector<int> vec2{4, 5, 6, 7};
  s21::s21_vector<int> ref{1, 2, 3};
  s21::s21_vector<int> ref2{4, 5, 6, 7};
  vec.swap(vec2);
  for (size_t x = 0; x < vec.size(); x++) {
    ASSERT_EQ(vec[x], ref2[x]);
  }
  for (size_t x = 0; x < vec2.size(); x++) {
    ASSERT_EQ(vec2[x], ref[x]);
  }
}

TEST(test_vector, test_insert) {
  s21::s21_vector<int> vec{1, 2, 3};
  s21::s21_vector<int> vec2{13, 1, 2, 3};
  s21::s21_vector<int>::iterator it = vec.begin();
  vec.insert(it, 13);
  for (size_t x = 0; x < vec.size(); x++) {
    ASSERT_EQ(vec[x], vec2[x]);
  }
}

TEST(test_vector, test_insert2) {
  s21::s21_vector<int> vec{1, 2, 3};
  s21::s21_vector<int>::iterator it = vec.begin() + 3;
  vec.insert(it, 13);
  ASSERT_EQ(vec[3], 13);
}

TEST(test_vector, test_insert3) {
  s21::s21_vector<int> vec{1, 2, 3};
  s21::s21_vector<int>::iterator it = vec.end() - 1;
  vec.insert(it, 13);
  ASSERT_EQ(vec[2], 13);
}

TEST(test_vector, test_insert4) {
  s21::s21_vector<int> vec{1, 2, 3};
  s21::s21_vector<int>::iterator it = vec.begin() + 5;
  vec.insert(it, 13);
  ASSERT_EQ(vec[5], 13);
}

TEST(test_vector, test_erase) {
  s21::s21_vector<int> vec{1, 2, 3, 4, 5};
  s21::s21_vector<int> vec2{2, 3, 4, 5};
  s21::s21_vector<int>::iterator it = vec.begin();
  vec.erase(it);
  for (size_t x = 0; x < vec.size(); x++) ASSERT_EQ(vec[x], vec2[x]);
}

TEST(test_vector, test_erase2) {
  s21::s21_vector<int> vec{1, 2, 3, 4, 5};
  s21::s21_vector<int> vec2{1, 2, 3, 4};
  s21::s21_vector<int>::iterator it = vec.end() - 1;
  vec.erase(it);
  for (size_t x = 0; x < vec.size(); x++) ASSERT_EQ(vec[x], vec2[x]);
}

TEST(test_vector, test_erase3) {
  s21::s21_vector<int> vec{1, 2, 3, 4, 5};
  s21::s21_vector<int> vec2{1, 2, 3, 4, 5};
  s21::s21_vector<int>::iterator it = vec.end() + 2;
  EXPECT_THROW(vec.erase(it), std::out_of_range);
}

TEST(test_vector, test_begin) {
  s21::s21_vector<int> vec{1, 2, 3};
  s21::s21_vector<int>::iterator it;
  it = vec.begin();
  ASSERT_EQ(*it, 1);
}

TEST(test_vector, test_increment) {
  s21::s21_vector<int> vec{1, 2, 3};
  s21::s21_vector<int>::iterator it;
  it = vec.begin();
  ASSERT_EQ(*(++it), 2);
}

TEST(test_vector, test_decrement) {
  s21::s21_vector<int> vec{1, 2, 3};
  s21::s21_vector<int>::iterator it;
  it = vec.end();
  ASSERT_EQ(*(--it), 3);
}

TEST(test_vector, test_const_increment) {
  const s21::s21_vector<int> vec{1, 2, 3};
  s21::s21_vector<int>::const_iterator it = vec.cbegin() + 1;
  ASSERT_EQ(*(++it), 3);
}

TEST(test_vector, test_const_decrement) {
  const s21::s21_vector<int> vec{1, 2, 3};
  s21::s21_vector<int>::const_iterator it;
  it = vec.cend() - 1;
  ASSERT_EQ(*(--it), 2);
}

TEST(test_vector, test_const_bool) {
  const s21::s21_vector<int> vec{1, 2, 3};
  s21::s21_vector<int>::const_iterator it = vec.cend();
  s21::s21_vector<int>::const_iterator it2 = vec.cbegin();
  ASSERT_EQ(it != it2, 1);
}

TEST(test_vector, insert_many_back) {
  s21::s21_vector<int> vec{1};
  s21::s21_vector<int> result{1, 1, 2, 3, 4, 5, 6, 7, 8};
  vec.insert_many_back(1, 2, 3, 4, 5, 6, 7, 8);
  ASSERT_EQ(vec.size(), result.size());
  while (!vec.empty() && !result.empty()) {
    ASSERT_EQ(vec.back(), result.back());
    vec.pop_back();
    result.pop_back();
  }
}