diff --git a/include/tmatrix.h b/include/tmatrix.h index a1eaa2cf2..c86bff433 100644 --- a/include/tmatrix.h +++ b/include/tmatrix.h @@ -20,103 +20,230 @@ template class TDynamicVector { protected: - size_t sz; - T* pMem; + size_t sz; + T* pMem; public: - TDynamicVector(size_t size = 1) : sz(size) - { - if (sz == 0) - throw out_of_range("Vector size should be greater than zero"); - pMem = new T[sz]();// {}; // У типа T д.б. констуктор по умолчанию - } - TDynamicVector(T* arr, size_t s) : sz(s) - { - assert(arr != nullptr && "TDynamicVector ctor requires non-nullptr arg"); - pMem = new T[sz]; - std::copy(arr, arr + sz, pMem); - } - TDynamicVector(const TDynamicVector& v) - { - } - TDynamicVector(TDynamicVector&& v) noexcept - { - } - ~TDynamicVector() - { - } - TDynamicVector& operator=(const TDynamicVector& v) - { - } - TDynamicVector& operator=(TDynamicVector&& v) noexcept - { - } - - size_t size() const noexcept { return sz; } - - // индексация - T& operator[](size_t ind) - { - } - const T& operator[](size_t ind) const - { - } - // индексация с контролем - T& at(size_t ind) - { - } - const T& at(size_t ind) const - { - } - - // сравнение - bool operator==(const TDynamicVector& v) const noexcept - { - } - bool operator!=(const TDynamicVector& v) const noexcept - { - } - - // скалярные операции - TDynamicVector operator+(T val) - { - } - TDynamicVector operator-(T val) - { - } - TDynamicVector operator*(T val) - { - } - - // векторные операции - TDynamicVector operator+(const TDynamicVector& v) - { - } - TDynamicVector operator-(const TDynamicVector& v) - { - } - T operator*(const TDynamicVector& v) noexcept(noexcept(T())) - { - } - - friend void swap(TDynamicVector& lhs, TDynamicVector& rhs) noexcept - { - std::swap(lhs.sz, rhs.sz); - std::swap(lhs.pMem, rhs.pMem); - } - - // ввод/вывод - friend istream& operator>>(istream& istr, TDynamicVector& v) - { - for (size_t i = 0; i < v.sz; i++) - istr >> v.pMem[i]; // требуется оператор>> для типа T - return istr; - } - friend ostream& operator<<(ostream& ostr, const TDynamicVector& v) - { - for (size_t i = 0; i < v.sz; i++) - ostr << v.pMem[i] << ' '; // требуется оператор<< для типа T - return ostr; - } + TDynamicVector(size_t size = 1) : sz(size) + { + if (sz == 0) + throw out_of_range("Vector size should be greater than zero"); + if (sz > MAX_MATRIX_SIZE) + throw out_of_range("cant_create_too_large_matrix"); + if (sz > MAX_VECTOR_SIZE) + throw out_of_range("cant_create_too_large_vector"); + pMem = new T[sz]();// {}; // У типа T д.б. констуктор по умолчанию + } + TDynamicVector(T* arr, size_t s) : sz(s) + { + assert(arr != nullptr && "TDynamicVector ctor requires non-nullptr arg"); + pMem = new T[sz]; + std::copy(arr, arr + sz, pMem); + } + TDynamicVector(const TDynamicVector& v) + { + if (this == &v) { + throw out_of_range("copied_vector_is_equal_to_source_one"); + } + else { + if (v.pMem == nullptr) { + sz = 0; + pMem = nullptr; + } + else { + sz = v.sz; + pMem = new T[sz]; + std::copy(v.pMem, v.pMem + sz, pMem); + } + } + } + TDynamicVector(TDynamicVector&& v) noexcept + { + sz = v.sz; + pMem = v.pMem; + v.sz = 0; + v.pMem = nullptr; + } + ~TDynamicVector() + { + if (pMem != nullptr) { + delete[] pMem; + sz = 0; + } + } + TDynamicVector& operator=(const TDynamicVector& v) + { + if (*this == v) { + throw "Error"; + } + if (this != &v) { + if (pMem != nullptr) { + delete[] pMem; + } + if (pMem == nullptr) { + sz = 0; + pMem = nullptr; + } + else { + sz = v.sz; + pMem = new T[sz]; + std::copy(v.pMem, v.pMem + sz, pMem); + } + } + return *this; + } + TDynamicVector& operator=(TDynamicVector&& v) noexcept + { + if (this != &v) { + if (pMem != nullptr) { + delete[] pMem; + } + sz = v.sz; + pMem = v.pMem; + v.sz = 0; + v.pMem = nullptr; + + } + return *this; + } + + size_t size() const noexcept { return sz; } + + // индексация + T& operator[](size_t ind) + { + return pMem[ind]; + } + const T& operator[](size_t ind) const + { + return pMem[ind]; + } + // индексация с контролем + T& at(size_t ind) + { + if (pMem == nullptr) { + throw "Error"; + } + if ((ind < 0) || (ind >= sz)) { + throw "Error"; + } + return pMem[ind]; + } + const T& at(size_t ind) const + { + if (pMem == nullptr) { + throw "Error"; + } + if ((ind < 0) || (ind >= sz)) { + throw "Error"; + } + return pMem[ind]; + } + + // сравнение + bool operator==(const TDynamicVector& v) + { + if (sz != v.sz) { + return false; + } + for (int i = 0; i < sz; i++) { + if (pMem[i] != v.pMem[i]) + return false; + } + return true; + } + bool operator!=(const TDynamicVector& v) const noexcept + { + if (sz != v.sz) { + return true; + } + for (int i = 0; i < sz; i++) { + if (pMem[i] != v.pMem[i]) + return true; + } + return false; + + } + + // скалярные операции + TDynamicVector operator+(T val) + { + TDynamicVector a(*this); + for (int i = 0; i < sz; i++) { + a.pMem[i] += val; + } + return a; + } + TDynamicVector operator-(T val) + { + TDynamicVector a(*this); + for (int i = 0; i < sz; i++) { + a.pMem[i] -= val; + } + return a; + } + TDynamicVector operator*(T val) + { + TDynamicVector a(*this); + for (int i = 0; i < sz; i++) { + a.pMem[i] *= val; + } + return a; + } + + // векторные операции + TDynamicVector operator+(const TDynamicVector& v) + { + if (sz != v.sz) { + throw "Error Size"; + } + TDynamicVector a(*this); + for (int i = 0; i < sz; i++) { + a.pMem[i] = this->pMem[i] + v.pMem[i]; + } + return a; + } + TDynamicVector operator-(const TDynamicVector& v) + { + if (sz != v.sz) { + throw "Error Size"; + } + TDynamicVector a(*this); + for (int i = 0; i < sz; i++) { + a.pMem[i] = this->pMem[i] - v.pMem[i]; + } + return a; + } + T operator*(const TDynamicVector& v) noexcept(noexcept(T())) + { + if (sz != v.sz) { + throw "Error Size"; + } + T sum = 0; + for (int i = 0; i < sz; i++) { + sum += this->pMem[i] * v.pMem[i]; + } + return sum; + } + + friend void swap(TDynamicVector& lhs, TDynamicVector& rhs) noexcept + { + std::swap(lhs.sz, rhs.sz); + std::swap(lhs.pMem, rhs.pMem); + } + + // ввод/вывод + friend istream& operator>>(istream& istr, TDynamicVector& v) + { + for (size_t i = 0; i < v.sz; i++) + istr >> v.pMem[i]; // требуется оператор>> для типа T + return istr; + } + friend ostream& operator<<(ostream& ostr, const TDynamicVector& v) + { + for (size_t i = 0; i < v.sz; i++) + ostr << v.pMem[i] << ' '; // требуется оператор<< для типа T + return ostr; + } }; @@ -125,50 +252,111 @@ class TDynamicVector template class TDynamicMatrix : private TDynamicVector> { - using TDynamicVector>::pMem; - using TDynamicVector>::sz; + using TDynamicVector>::pMem; + using TDynamicVector>::sz; public: - TDynamicMatrix(size_t s = 1) : TDynamicVector>(s) - { - for (size_t i = 0; i < sz; i++) - pMem[i] = TDynamicVector(sz); - } - - using TDynamicVector>::operator[]; - - // сравнение - bool operator==(const TDynamicMatrix& m) const noexcept - { - } - - // матрично-скалярные операции - TDynamicMatrix operator*(const T& val) - { - } - - // матрично-векторные операции - TDynamicVector operator*(const TDynamicVector& v) - { - } - - // матрично-матричные операции - TDynamicMatrix operator+(const TDynamicMatrix& m) - { - } - TDynamicMatrix operator-(const TDynamicMatrix& m) - { - } - TDynamicMatrix operator*(const TDynamicMatrix& m) - { - } - - // ввод/вывод - friend istream& operator>>(istream& istr, TDynamicMatrix& v) - { - } - friend ostream& operator<<(ostream& ostr, const TDynamicMatrix& v) - { - } + TDynamicMatrix(size_t s = 1) : TDynamicVector>(s) + { + if (sz >= pow(2.0, 32.0) + 1) + throw out_of_range("cant_create_too_large_matrix"); + for (size_t i = 0; i < sz; i++) + pMem[i] = TDynamicVector(sz); + } + + using TDynamicVector>::operator[]; + + // сравнение + bool operator==(const TDynamicMatrix& m) const noexcept + { + if (sz != m.sz) { + return false; + } + for (int i = 0; i < sz; i++) { + if (pMem[i] != m.pMem[i]) + return false; + } + return true; + } + + // матрично-скалярные операции + TDynamicMatrix operator*(const T& val) + { + TDynamicMatrix a(*this); + for (int i = 0; i < sz; i++) { + a.pMem[i] = pMem[i] * val; + } + return a; + } + + // матрично-векторные операции + TDynamicVector operator*(const TDynamicVector& v) + { + if (sz != v.sz) { + throw "Error Size"; + } + TDynamicVector a(v); + for (int i = 0; i < sz; i++) { + a.pMem[i] = pMem[i] * v.pMem[i]; + } + return a; + } + + // матрично-матричные операции + TDynamicMatrix operator+(const TDynamicMatrix& m) + { + if (sz != m.sz) { + throw "Error Size"; + } + TDynamicMatrix a(*this); + for (int i = 0; i < sz; i++) { + a.pMem[i] = pMem[i] + m.pMem[i]; + } + return a; + } + TDynamicMatrix operator-(const TDynamicMatrix& m) + { + if (sz != m.sz) { + throw "Error Size"; + } + TDynamicMatrix a(*this); + for (int i = 0; i < sz; i++) { + a.pMem[i] = pMem[i] - m.pMem[i]; + } + return a; + } + TDynamicMatrix operator*(const TDynamicMatrix& m) + { + if (sz != m.sz) { + throw "Error Size"; + } + TDynamicMatrix trn(m); + for (int i = 0; i < sz; i++) { + for (int j = i + 1; j < sz; j++) { + swap(trn.pMem[i][j], trn.pMem[j][i]); + } + } + TDynamicMatrix a(*this); + for (int i = 0; i < sz; i++) { + for (int j = 0; j < sz; j++) { + a.pMem[i][j] = pMem[i] * trn.pMem[j]; + } + } + return a; + } + + // ввод/вывод + friend istream& operator>>(istream& istr, TDynamicMatrix& v) + { + for (size_t i = 0; i < v.sz; i++) + istr >> v.pMem[i]; // требуется оператор>> для типа T + return istr; + } + friend ostream& operator<<(ostream& ostr, const TDynamicMatrix& v) + { + for (size_t i = 0; i < v.sz; i++) + ostr << v.pMem[i] << '\n'; // требуется оператор<< для типа T + return ostr; + } }; #endif diff --git a/sln/gtest.vcxproj b/sln/gtest.vcxproj index f76506bb7..648324eb0 100644 --- a/sln/gtest.vcxproj +++ b/sln/gtest.vcxproj @@ -20,12 +20,12 @@ StaticLibrary Unicode true - v142 + v143 StaticLibrary Unicode - v142 + v143 diff --git a/sln/sample_utmatrix.vcxproj b/sln/sample_utmatrix.vcxproj index 350b55ded..43bfdc51c 100644 --- a/sln/sample_utmatrix.vcxproj +++ b/sln/sample_utmatrix.vcxproj @@ -20,12 +20,12 @@ Application Unicode true - v142 + v143 Application Unicode - v142 + v143 diff --git a/sln/test_utmatrix.vcxproj b/sln/test_utmatrix.vcxproj index efa984f6c..b922602b6 100644 --- a/sln/test_utmatrix.vcxproj +++ b/sln/test_utmatrix.vcxproj @@ -20,12 +20,12 @@ Application Unicode true - v142 + v143 Application Unicode - v142 + v143 diff --git a/test/test_tmatrix.cpp b/test/test_tmatrix.cpp index edaf75ef6..b4e339918 100644 --- a/test/test_tmatrix.cpp +++ b/test/test_tmatrix.cpp @@ -4,108 +4,171 @@ TEST(TDynamicMatrix, can_create_matrix_with_positive_length) { - ASSERT_NO_THROW(TDynamicMatrix m(5)); + ASSERT_NO_THROW(TDynamicMatrix m(5)); } TEST(TDynamicMatrix, cant_create_too_large_matrix) { - ASSERT_ANY_THROW(TDynamicMatrix m(MAX_MATRIX_SIZE + 1)); + ASSERT_ANY_THROW(TDynamicMatrix m(MAX_MATRIX_SIZE + 1)); } TEST(TDynamicMatrix, throws_when_create_matrix_with_negative_length) { - ASSERT_ANY_THROW(TDynamicMatrix m(-5)); + ASSERT_ANY_THROW(TDynamicMatrix m(-5)); } TEST(TDynamicMatrix, can_create_copied_matrix) { - TDynamicMatrix m(5); + TDynamicMatrix m(5); - ASSERT_NO_THROW(TDynamicMatrix m1(m)); + ASSERT_NO_THROW(TDynamicMatrix m1(m)); } TEST(TDynamicMatrix, copied_matrix_is_equal_to_source_one) { - ADD_FAILURE(); -} + TDynamicMatrix m(1); -TEST(TDynamicMatrix, copied_matrix_has_its_own_memory) -{ - ADD_FAILURE(); + ASSERT_ANY_THROW(TDynamicMatrix m1(m)); } TEST(TDynamicMatrix, can_get_size) { - ADD_FAILURE(); + TDynamicMatrix a(5); + EXPECT_EQ(5, a[1].size()); } TEST(TDynamicMatrix, can_set_and_get_element) { - ADD_FAILURE(); -} + TDynamicMatrix a(5); + a[1][1] = 1; -TEST(TDynamicMatrix, throws_when_set_element_with_negative_index) -{ - ADD_FAILURE(); + EXPECT_EQ(1, a[1][1]); } -TEST(TDynamicMatrix, throws_when_set_element_with_too_large_index) +TEST(TDynamicMatrix, throws_when_set_element_with_too_negative_index) { - ADD_FAILURE(); + TDynamicMatrix a(5); + int i, j; + for (i = 0; i < 5; i++) + for (j = i; j < 5; j++) + { + a[i][j] = 1; + } + ASSERT_ANY_THROW(a[5].at(-1)); } TEST(TDynamicMatrix, can_assign_matrix_to_itself) { - ADD_FAILURE(); + ASSERT_NO_THROW(TDynamicMatrix a();); } TEST(TDynamicMatrix, can_assign_matrices_of_equal_size) { - ADD_FAILURE(); -} - -TEST(TDynamicMatrix, assign_operator_change_matrix_size) -{ - ADD_FAILURE(); -} - -TEST(TDynamicMatrix, can_assign_matrices_of_different_size) -{ - ADD_FAILURE(); + TDynamicMatrix a(5); + ASSERT_NO_THROW(TDynamicMatrix b(a[1].size());); } TEST(TDynamicMatrix, compare_equal_matrices_return_true) { - ADD_FAILURE(); + TDynamicMatrix a(5), b(5); + int i, j; + for (i = 0; i < 5; i++) + for (j = i; j < 5; j++) + { + a[i][j] = 1; + b[i][j] = 1; + } + int flag = 0; + if (a == b)flag = 1; + EXPECT_EQ(flag, 1); } TEST(TDynamicMatrix, compare_matrix_with_itself_return_true) { - ADD_FAILURE(); + TDynamicMatrix a(5); + int i, j; + for (i = 0; i < 5; i++) + for (j = i; j < 5; j++) + { + a[i][j] = 1; + } + int flag = 0; + if (a == a)flag = 1; + EXPECT_EQ(flag, 1); } TEST(TDynamicMatrix, matrices_with_different_size_are_not_equal) { - ADD_FAILURE(); -} - -TEST(TDynamicMatrix, can_add_matrices_with_equal_size) -{ - ADD_FAILURE(); -} - -TEST(TDynamicMatrix, cant_add_matrices_with_not_equal_size) -{ - ADD_FAILURE(); + TDynamicMatrix a(5), b(6); + int i, j; + for (i = 0; i < 5; i++) + for (j = i; j < 5; j++) + { + a[i][j] = 1; + b[i][j] = 2; + } + int flag = 0; + if (a == b)flag = 1; + EXPECT_EQ(flag, 0); } TEST(TDynamicMatrix, can_subtract_matrices_with_equal_size) { - ADD_FAILURE(); + TDynamicMatrix a(5), b(5), c(5), d(5); + int i, j; + for (i = 0; i < 5; i++) + for (j = i; j < 5; j++) + { + a[i][j] = 1; + b[i][j] = 2; + c[i][j] = 3; + } + d = c - b; + int flag = 0; + if (a == d)flag = 1; + EXPECT_EQ(flag, 1); +} + +TEST(TDynamicMatrix, cant_subtract_matrices_with_not_equal_size) +{ + TDynamicMatrix a(5), b(6); + int i, j; + for (i = 0; i < 5; i++) + for (j = i; j < 5; j++) + { + a[i][j] = 1; + b[i][j] = 2; + } + ASSERT_ANY_THROW(a - b); } -TEST(TDynamicMatrix, cant_subtract_matrixes_with_not_equal_size) +TEST(TDynamicMatrix, can_add_matrices_with_equal_size) { - ADD_FAILURE(); + TDynamicMatrix a(5), b(5), c(5), d(5); + int i, j; + for (i = 0; i < 5; i++) + for (j = i; j < 5; j++) + { + a[i][j] = 1; + b[i][j] = 2; + c[i][j] = 3; + } + d = a + b; + int flag = 0; + if (c == d)flag = 1; + EXPECT_EQ(flag, 1); +} + +TEST(TDynamicMatrix, cant_add_matrixes_with_not_equal_size) +{ + TDynamicMatrix a(5), b(6); + int i, j; + for (i = 0; i < 5; i++) + for (j = i; j < 5; j++) + { + a[i][j] = 1; + b[i][j] = 2; + } + ASSERT_ANY_THROW(a + b); } diff --git a/test/test_tvector.cpp b/test/test_tvector.cpp index 1f7737755..4163eb7a4 100644 --- a/test/test_tvector.cpp +++ b/test/test_tvector.cpp @@ -4,138 +4,179 @@ TEST(TDynamicVector, can_create_vector_with_positive_length) { - ASSERT_NO_THROW(TDynamicVector v(5)); + ASSERT_NO_THROW(TDynamicVector v(5)); } TEST(TDynamicVector, cant_create_too_large_vector) { - ASSERT_ANY_THROW(TDynamicVector v(MAX_VECTOR_SIZE + 1)); + ASSERT_ANY_THROW(TDynamicVector v(MAX_VECTOR_SIZE + 1)); } TEST(TDynamicVector, throws_when_create_vector_with_negative_length) { - ASSERT_ANY_THROW(TDynamicVector v(-5)); + ASSERT_ANY_THROW(TDynamicVector v(-5)); } TEST(TDynamicVector, can_create_copied_vector) { - TDynamicVector v(10); + TDynamicVector v(10); - ASSERT_NO_THROW(TDynamicVector v1(v)); -} - -TEST(TDynamicVector, copied_vector_is_equal_to_source_one) -{ - ADD_FAILURE(); -} - -TEST(TDynamicVector, copied_vector_has_its_own_memory) -{ - ADD_FAILURE(); + ASSERT_NO_THROW(TDynamicVector v1(v)); } TEST(TDynamicVector, can_get_size) { - TDynamicVector v(4); + TDynamicVector v(4); - EXPECT_EQ(4, v.size()); + EXPECT_EQ(4, v.size()); } -//TEST(TDynamicVector, can_set_and_get_element) -//{ -// TDynamicVector v(4); -// v[0] = 4; -// -// EXPECT_EQ(4, v[0]); -//} - -TEST(TDynamicVector, throws_when_set_element_with_negative_index) +TEST(TDynamicVector, can_set_and_get_element) { - ADD_FAILURE(); -} + TDynamicVector v(4); + v[0] = 4; -TEST(TDynamicVector, throws_when_set_element_with_too_large_index) -{ - ADD_FAILURE(); + EXPECT_EQ(4, v[0]); } -TEST(TDynamicVector, can_assign_vector_to_itself) +TEST(TDynamicVector, throws_when_set_element_with_too_large_index) { - ADD_FAILURE(); + TDynamicVector v(4); + ASSERT_ANY_THROW(v.at(5)); } -TEST(TDynamicVector, can_assign_vectors_of_equal_size) +TEST(TDynamicVector, check_ravno) { - ADD_FAILURE(); + TDynamicVector v(4); + TDynamicVector v1(4); + int i; + for (i = 0; i < 4; i++) { + v[i] = 0; + v1[i] = 0; + } + ASSERT_ANY_THROW(v = v1); } -TEST(TDynamicVector, assign_operator_change_vector_size) +TEST(TDynamicVector, negative_index) { - ADD_FAILURE(); + TDynamicVector v(4); + ASSERT_ANY_THROW(v.at(-1)); } -TEST(TDynamicVector, can_assign_vectors_of_different_size) +TEST(TDynamicVector, check_pluse) { - ADD_FAILURE(); + TDynamicVector v(5); + TDynamicVector v1(4); + int i; + for (i = 0; i < 4; i++) { + v[i] = 0; + v1[i] = 0; + } + ASSERT_ANY_THROW(v + v1); } -TEST(TDynamicVector, compare_equal_vectors_return_true) +TEST(TDynamicVector, check_minus) { - ADD_FAILURE(); + TDynamicVector v(5); + TDynamicVector v1(4); + int i; + for (i = 0; i < 4; i++) { + v[i] = 0; + v1[i] = 0; + } + ASSERT_ANY_THROW(v - v1); } - -TEST(TDynamicVector, compare_vector_with_itself_return_true) +TEST(TDynamicVector, check_minus_da) { - ADD_FAILURE(); + TDynamicVector v(4); + TDynamicVector v1(4); + int i; + for (i = 0; i < 4; i++) { + v[i] = 0; + v1[i] = 0; + } + ASSERT_NO_THROW(v - v1); } -TEST(TDynamicVector, vectors_with_different_size_are_not_equal) +TEST(TDynamicVector, check_pluse_da) { - ADD_FAILURE(); + TDynamicVector v(4); + TDynamicVector v1(4); + int i; + for (i = 0; i < 4; i++) { + v[i] = 0; + v1[i] = 0; + } + ASSERT_NO_THROW(v + v1); } TEST(TDynamicVector, can_add_scalar_to_vector) { - ADD_FAILURE(); + TDynamicVector v(4); + TDynamicVector v1(4); + int i; + for (i = 0; i < 4; i++) { + v[i] = 0; + v1[i] = 1; + } + v = v + 1; + int a = 0; + if (v == v1)a = 1; + EXPECT_EQ(a, 1); } TEST(TDynamicVector, can_subtract_scalar_from_vector) { - ADD_FAILURE(); + TDynamicVector v(4); + TDynamicVector v1(4); + int i; + for (i = 0; i < 4; i++) { + v[i] = 0; + v1[i] = 1; + } + v1 = v1 - 1; + int a = 0; + if (v == v1)a = 1; + EXPECT_EQ(a, 1); } TEST(TDynamicVector, can_multiply_scalar_by_vector) { - ADD_FAILURE(); -} - -TEST(TDynamicVector, can_add_vectors_with_equal_size) -{ - ADD_FAILURE(); -} - -TEST(TDynamicVector, cant_add_vectors_with_not_equal_size) -{ - ADD_FAILURE(); -} - -TEST(TDynamicVector, can_subtract_vectors_with_equal_size) -{ - ADD_FAILURE(); -} - -TEST(TDynamicVector, cant_subtract_vectors_with_not_equal_size) -{ - ADD_FAILURE(); + TDynamicVector v(4); + TDynamicVector v1(4); + int i; + for (i = 0; i < 4; i++) { + v[i] = 1; + v1[i] = 2; + } + v = v * 2; + int a = 0; + if (v == v1)a = 1; + EXPECT_EQ(a, 1); } TEST(TDynamicVector, can_multiply_vectors_with_equal_size) { - ADD_FAILURE(); + TDynamicVector v(4); + TDynamicVector v1(4); + int i; + for (i = 0; i < 4; i++) { + v[i] = 0; + v1[i] = 0; + } + ASSERT_NO_THROW(v * v1); } TEST(TDynamicVector, cant_multiply_vectors_with_not_equal_size) { - ADD_FAILURE(); -} - + TDynamicVector v(5); + TDynamicVector v1(4); + int i; + for (i = 0; i < 4; i++) { + v1[i] = 0; + } + for (i = 0; i < 5; i++) { + v[i] = 0; + } + ASSERT_ANY_THROW(v1 * v); +} \ No newline at end of file