diff --git a/include/tmatrix.h b/include/tmatrix.h
index 6c11b2feb..04ffad145 100644
--- a/include/tmatrix.h
+++ b/include/tmatrix.h
@@ -8,6 +8,7 @@
 #define __TDynamicMatrix_H__
 
 #include <iostream>
+#include <stdexcept>
 
 using namespace std;
 
@@ -20,35 +21,59 @@ template<typename T>
 class TDynamicVector
 {
 protected:
-  size_t sz;
-  T* pMem;
+  size_t sz = 0;
+  T* pMem = nullptr;
 public:
   TDynamicVector(size_t size = 1) : sz(size)
   {
     if (sz == 0)
       throw out_of_range("Vector size should be greater than zero");
+    if(sz > MAX_VECTOR_SIZE) throw out_of_range("Error");
+
     pMem = new T[sz]();// {}; // У типа T д.б. констуктор по умолчанию
   }
   TDynamicVector(T* arr, size_t s) : sz(s)
   {
     assert(arr != nullptr && "TDynamicVector ctor requires non-nullptr arg");
+    if(sz > MAX_VECTOR_SIZE) throw out_of_range("Error");
     pMem = new T[sz];
     std::copy(arr, arr + sz, pMem);
   }
-  TDynamicVector(const TDynamicVector& v)
+  TDynamicVector(const TDynamicVector& v) : sz(v.sz)
   {
+    pMem = new T[sz];
+    std::copy(v.pMem,v.pMem + sz, pMem);
   }
-  TDynamicVector(TDynamicVector&& v) noexcept
+  TDynamicVector(TDynamicVector&& v) noexcept : sz(v.sz), pMem(v.pMem)
   {
+    v.sz = 0;
+    v.pMem = nullptr;
   }
   ~TDynamicVector()
   {
+    delete[] pMem;
   }
   TDynamicVector& operator=(const TDynamicVector& v)
   {
+    if (this != &v) {
+      if (sz != v.sz) {
+        delete[] pMem;
+        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) {
+      delete[] pMem;
+      sz = v.sz;
+      pMem = v.pMem;
+      v.sz = 0;
+      v.pMem = nullptr;
+    }
       return *this;
   }
 
@@ -57,46 +82,87 @@ class TDynamicVector
   // индексация
   T& operator[](size_t ind)
   {
+    return pMem[ind];
   }
   const T& operator[](size_t ind) const
   {
+    return pMem[ind];
   }
   // индексация с контролем
   T& at(size_t ind)
   {
+    if(ind >= 0 && ind < sz) return pMem[ind];
+    else throw out_of_range("Error");
   }
   const T& at(size_t ind) const
   {
+    if(ind >= 0 && ind < sz) return pMem[ind];
+    else throw out_of_range("Error");
   }
 
   // сравнение
   bool operator==(const TDynamicVector& v) const noexcept
   {
+    return sz == v.sz && std::equal(pMem, pMem + sz, v.pMem);
   }
   bool operator!=(const TDynamicVector& v) const noexcept
   {
+    return !(*this == v);
   }
 
   // скалярные операции
   TDynamicVector operator+(T val)
   {
+    TDynamicVector res(sz);
+    for (size_t i = 0; i < sz; i++)
+      res[i] = pMem[i] + val;
+    return res;
   }
-  TDynamicVector operator-(double val)
+  TDynamicVector operator-(T val)//?
   {
+    TDynamicVector res(sz);
+    for (size_t i = 0; i < sz; i++)
+      res[i] = pMem[i] - val;
+    return res;
   }
-  TDynamicVector operator*(double val)
+  TDynamicVector operator*(T val)//?
   {
+    TDynamicVector res(sz);
+    for (size_t i = 0; i < sz; i++)
+      res[i] = pMem[i] * val;
+    return res;
   }
 
   // векторные операции
   TDynamicVector operator+(const TDynamicVector& v)
   {
+    if(sz != v.sz) throw invalid_argument("Error");
+
+    TDynamicVector res(sz);
+    for(size_t i = 0; i < sz; i++)
+      res[i] = pMem[i] + v.pMem[i];
+    
+      return res;
   }
   TDynamicVector operator-(const TDynamicVector& v)
   {
+    if(sz != v.sz) throw invalid_argument("Error");
+
+     TDynamicVector res(sz);
+    for (size_t i = 0; i < sz; i++)
+      res[i] = pMem[i] - v.pMem[i];
+
+    return res;
   }
-  T operator*(const TDynamicVector& v) noexcept(noexcept(T()))
+  T operator*(const TDynamicVector& v) //noexcept(noexcept(T()))
   {
+    if(sz != v.sz) throw invalid_argument("Error");
+
+    T res = T();
+    for (size_t i = 0; i < sz; i++)
+      res += pMem[i] * v.pMem[i];
+    return res;
+
   }
 
   friend void swap(TDynamicVector& lhs, TDynamicVector& rhs) noexcept
@@ -109,13 +175,13 @@ class TDynamicVector
   friend istream& operator>>(istream& istr, TDynamicVector& v)
   {
     for (size_t i = 0; i < v.sz; i++)
-      istr >> v.pMem[i]; // требуется оператор>> для типа T
+      istr >> v.pMem[i];
     return istr;
   }
   friend ostream& operator<<(ostream& ostr, const TDynamicVector& v)
   {
     for (size_t i = 0; i < v.sz; i++)
-      ostr << v.pMem[i] << ' '; // требуется оператор<< для типа T
+      ostr << v.pMem[i] << ' '; 
     return ostr;
   }
 };
@@ -124,52 +190,133 @@ class TDynamicVector
 // Динамическая матрица - 
 // шаблонная матрица на динамической памяти
 template<typename T>
-class TDynamicMatrix : private TDynamicVector<TDynamicVector<T>>
+class TDynamicMatrix : public TDynamicVector<TDynamicVector<T>>
 {
   using TDynamicVector<TDynamicVector<T>>::pMem;
   using TDynamicVector<TDynamicVector<T>>::sz;
 public:
   TDynamicMatrix(size_t s = 1) : TDynamicVector<TDynamicVector<T>>(s)
   {
+    if(s > MAX_MATRIX_SIZE) throw out_of_range("Error");
+
     for (size_t i = 0; i < sz; i++)
       pMem[i] = TDynamicVector<T>(sz);
   }
 
   using TDynamicVector<TDynamicVector<T>>::operator[];
 
+  TDynamicVector<T>& at(size_t ind)
+{
+    if (ind < sz) 
+        return pMem[ind];
+    else 
+        throw out_of_range("Error");
+}
+
+const TDynamicVector<T>& at(size_t ind) const
+{
+    if (ind < sz) 
+        return pMem[ind];
+    else 
+        throw out_of_range("error");
+}
+
+  size_t size() const noexcept { return sz; } //?
+
   // сравнение
   bool operator==(const TDynamicMatrix& m) const noexcept
   {
+     if (sz != m.sz) return false;
+    for (size_t i = 0; i < sz; i++) {
+      if (pMem[i] != m.pMem[i]) return false;
+    }
+    return true;
   }
 
-  // матрично-скалярные операции
-  TDynamicVector<T> operator*(const T& val)
+   bool operator!=(const TDynamicMatrix& m) const noexcept
   {
+    return !(*this == m);
   }
 
+  // матрично-скалярные операции
+  TDynamicMatrix operator*(const T& val) 
+    {
+        TDynamicMatrix res(sz);
+        for (size_t i = 0; i < sz; i++)
+            res[i] = pMem[i] * val;
+        return res;
+    }
+
+  //operator+ and operator- not needed?
+
   // матрично-векторные операции
   TDynamicVector<T> operator*(const TDynamicVector<T>& v)
   {
+    if(sz != v.size()) throw invalid_argument("Error");
+
+    TDynamicVector<T> res(sz);
+    for (size_t i = 0; i < sz; i++)
+      res[i] = pMem[i] * v;
+    return res;
   }
 
   // матрично-матричные операции
   TDynamicMatrix operator+(const TDynamicMatrix& m)
   {
+    if (sz != m.sz) throw invalid_argument("Error");
+    
+    TDynamicMatrix res(sz);
+    for (size_t i = 0; i < sz; i++)
+      res[i] = pMem[i] + m[i];
+    return res;
   }
   TDynamicMatrix operator-(const TDynamicMatrix& m)
   {
+    if (sz != m.sz) throw invalid_argument("Error");
+    
+    TDynamicMatrix res(sz);
+    for (size_t i = 0; i < sz; i++)
+      res[i] = pMem[i] - m[i];
+    return res;
   }
   TDynamicMatrix operator*(const TDynamicMatrix& m)
   {
+     if (sz != m.size()) throw invalid_argument("Error");
+    
+    TDynamicMatrix res(sz);
+    
+    for (size_t row = 0; row < sz; row++) {          
+        for (size_t col = 0; col < sz; col++) {      
+            T skal = T();                       
+            
+            for (size_t k = 0; k < sz; k++) { 
+                skal += (*this)[row][k] * m[k][col];
+            }
+            
+            res[row][col] = skal;
+        }
+    }
+    
+    return res;
   }
 
   // ввод/вывод
   friend istream& operator>>(istream& istr, TDynamicMatrix& v)
   {
+    for (size_t i = 0; i < v.sz; i++)
+      istr >> v.pMem[i];
+    return istr;
   }
   friend ostream& operator<<(ostream& ostr, const TDynamicMatrix& v)
   {
+    for (size_t i = 0; i < v.sz; i++) {
+      for (size_t j = 0; j < v.sz; j++)
+        ostr << v.pMem[i][j] << ' ';
+      ostr << '\n';
+    }
+    return ostr;
   }
+  
 };
 
 #endif
diff --git a/test/test_tmatrix.cpp b/test/test_tmatrix.cpp
index edaf75ef6..04005ad11 100644
--- a/test/test_tmatrix.cpp
+++ b/test/test_tmatrix.cpp
@@ -1,111 +1,281 @@
 #include "tmatrix.h"
-
 #include <gtest.h>
 
-TEST(TDynamicMatrix, can_create_matrix_with_positive_length)
-{
-  ASSERT_NO_THROW(TDynamicMatrix<int> m(5));
+// Базовые тесты создания матрицы
+TEST(TDynamicMatrix, can_create_matrix_with_positive_length) {
+    ASSERT_NO_THROW(TDynamicMatrix<int> m(3));
 }
 
-TEST(TDynamicMatrix, cant_create_too_large_matrix)
-{
-  ASSERT_ANY_THROW(TDynamicMatrix<int> m(MAX_MATRIX_SIZE + 1));
+TEST(TDynamicMatrix, cant_create_too_large_matrix) {
+    ASSERT_ANY_THROW(TDynamicMatrix<int> m(MAX_MATRIX_SIZE + 1));
 }
 
-TEST(TDynamicMatrix, throws_when_create_matrix_with_negative_length)
-{
-  ASSERT_ANY_THROW(TDynamicMatrix<int> m(-5));
+TEST(TDynamicMatrix, throws_when_create_matrix_with_negative_length) {
+    ASSERT_ANY_THROW(TDynamicMatrix<int> m(-3));
 }
 
-TEST(TDynamicMatrix, can_create_copied_matrix)
-{
-  TDynamicMatrix<int> m(5);
+// Тесты копирования
+TEST(TDynamicMatrix, can_create_copied_matrix) {
+    TDynamicMatrix<int> m(3);
+    ASSERT_NO_THROW(TDynamicMatrix<int> m1(m));
+}
 
-  ASSERT_NO_THROW(TDynamicMatrix<int> m1(m));
+TEST(TDynamicMatrix, copied_matrix_is_equal_to_source_one) {
+    TDynamicMatrix<int> m(2);
+    m[0][0] = 1;
+    m[0][1] = 2;
+    m[1][0] = 3;
+    m[1][1] = 4;
+    
+    TDynamicMatrix<int> m1(m);
+    
+    EXPECT_EQ(m.size(), m1.size());
+    EXPECT_EQ(m[0][0], m1[0][0]);
+    EXPECT_EQ(m[0][1], m1[0][1]);
+    EXPECT_EQ(m[1][0], m1[1][0]);
+    EXPECT_EQ(m[1][1], m1[1][1]);
 }
 
-TEST(TDynamicMatrix, copied_matrix_is_equal_to_source_one)
-{
-  ADD_FAILURE();
+TEST(TDynamicMatrix, copied_matrix_has_its_own_memory) {
+    TDynamicMatrix<int> m(2);
+    m[0][0] = 1;
+    
+    TDynamicMatrix<int> m1(m);
+    m[0][0] = 999;
+    
+    EXPECT_EQ(1, m1[0][0]);
 }
 
-TEST(TDynamicMatrix, copied_matrix_has_its_own_memory)
-{
-  ADD_FAILURE();
+// Тесты доступа к элементам
+TEST(TDynamicMatrix, can_get_size) {
+    TDynamicMatrix<int> m(4);
+    EXPECT_EQ(4, m.size());
 }
 
-TEST(TDynamicMatrix, can_get_size)
-{
-  ADD_FAILURE();
+TEST(TDynamicMatrix, can_set_and_get_element) {
+    TDynamicMatrix<int> m(2);
+    m[1][1] = 42;
+    EXPECT_EQ(42, m[1][1]);
 }
 
-TEST(TDynamicMatrix, can_set_and_get_element)
-{
-  ADD_FAILURE();
+TEST(TDynamicMatrix, throws_when_set_element_with_out_of_range_index) {
+    TDynamicMatrix<int> m(3);
+    EXPECT_ANY_THROW(m.at(5));  
+    EXPECT_ANY_THROW(m.at(10)); 
+}
+// Тесты оператора присваивания
+TEST(TDynamicMatrix, can_assign_matrix_to_itself) {
+    TDynamicMatrix<int> m(2);
+    m[0][0] = 1;
+    
+    m = m;
+    
+    EXPECT_EQ(1, m[0][0]);
 }
 
-TEST(TDynamicMatrix, throws_when_set_element_with_negative_index)
-{
-  ADD_FAILURE();
+TEST(TDynamicMatrix, can_assign_matrices_of_equal_size) {
+    TDynamicMatrix<int> m(2), m1(2);
+    m1[0][0] = 10;
+    
+    m = m1;
+    
+    EXPECT_EQ(10, m[0][0]);
 }
 
-TEST(TDynamicMatrix, throws_when_set_element_with_too_large_index)
-{
-  ADD_FAILURE();
+TEST(TDynamicMatrix, assign_operator_change_matrix_size) {
+    TDynamicMatrix<int> m(2), m1(3);
+    
+    m = m1;
+    
+    EXPECT_EQ(3, m.size());
 }
 
-TEST(TDynamicMatrix, can_assign_matrix_to_itself)
+TEST(TDynamicMatrix, compare_equal_matrices_return_true)
 {
-  ADD_FAILURE();
+    TDynamicMatrix<int> m1(2);
+    m1[0][0] = 2; m1[0][1] = 3;
+    m1[1][0] = 4; m1[1][1] = 5;
+
+    TDynamicMatrix<int> m2(2);
+    m2[0][0] = 2; m2[0][1] = 3;
+    m2[1][0] = 4; m2[1][1] = 5;
+
+    EXPECT_TRUE(m1 == m2);
 }
 
-TEST(TDynamicMatrix, can_assign_matrices_of_equal_size)
+TEST(TDynamicMatrix, compare_matrix_with_itself_return_true)
 {
-  ADD_FAILURE();
+    TDynamicMatrix<int> m(2);
+    m[0][0] = 3; m[0][1] = 4;
+    m[1][0] = 5; m[1][1] = 6;
+
+    EXPECT_TRUE(m == m);
 }
 
-TEST(TDynamicMatrix, assign_operator_change_matrix_size)
+TEST(TDynamicMatrix, matrices_with_different_size_are_not_equal)
 {
-  ADD_FAILURE();
+    TDynamicMatrix<int> m1(2);
+    TDynamicMatrix<int> m2(4);
+
+    EXPECT_TRUE(m1 != m2);
 }
 
-TEST(TDynamicMatrix, can_assign_matrices_of_different_size)
-{
-  ADD_FAILURE();
+// Тесты арифметических операций
+TEST(TDynamicMatrix, can_add_matrices_with_equal_size) {
+    TDynamicMatrix<int> m(2), m1(2);
+    m[0][0] = 1;
+    m1[0][0] = 5;
+    
+    TDynamicMatrix<int> res = m + m1;
+    
+    EXPECT_EQ(6, res[0][0]);
 }
 
-TEST(TDynamicMatrix, compare_equal_matrices_return_true)
-{
-  ADD_FAILURE();
+TEST(TDynamicMatrix, cant_add_matrices_with_not_equal_size) {
+    TDynamicMatrix<int> m(2);
+    TDynamicMatrix<int> m1(4);
+
+    EXPECT_ANY_THROW(m + m1);
 }
 
-TEST(TDynamicMatrix, compare_matrix_with_itself_return_true)
-{
-  ADD_FAILURE();
+TEST(TDynamicMatrix, can_subtract_matrices_with_equal_size) {
+    TDynamicMatrix<int> m(2), m1(2);
+    m[0][0] = 10;
+    m1[0][0] = 3;
+    
+    TDynamicMatrix<int> res = m - m1;
+    
+    EXPECT_EQ(7, res[0][0]);
 }
 
-TEST(TDynamicMatrix, matrices_with_different_size_are_not_equal)
-{
-  ADD_FAILURE();
+TEST(TDynamicMatrix, cant_subtract_matrices_with_not_equal_size) {
+    TDynamicMatrix<int> m(2);
+    TDynamicMatrix<int> m1(4);
+
+    EXPECT_ANY_THROW(m - m1);
 }
 
-TEST(TDynamicMatrix, can_add_matrices_with_equal_size)
-{
-  ADD_FAILURE();
+TEST(TDynamicMatrix, can_multiply_matrix_by_matrix) {
+    TDynamicMatrix<int> m1(2);
+    m1[0][0] = 1; m1[0][1] = 2;
+    m1[1][0] = 3; m1[1][1] = 4;
+
+    TDynamicMatrix<int> m2(2);
+    m2[0][0] = 5; m2[0][1] = 6; /* 1*5+2*7 = 19 1*6+2*8 = 22 3*5+4*7 = 43 3*6+4*8 = 50 вроде бы?*/
+    m2[1][0] = 7; m2[1][1] = 8;
+
+    TDynamicMatrix<int> res = m1 * m2;
+
+    EXPECT_EQ(19, res[0][0]);
+    EXPECT_EQ(22, res[0][1]);
+    EXPECT_EQ(43, res[1][0]);
+    EXPECT_EQ(50, res[1][1]);
 }
 
-TEST(TDynamicMatrix, cant_add_matrices_with_not_equal_size)
-{
-  ADD_FAILURE();
+TEST(TDynamicMatrix, can_multiply_matrix_by_scalar) {
+    TDynamicMatrix<int> m(2);
+    m[0][0] = 1; m[0][1] = 2;
+    m[1][0] = 3; m[1][1] = 4;
+
+    TDynamicMatrix<int> res = m * 5;
+
+    EXPECT_EQ(5, res[0][0]);
+    EXPECT_EQ(10, res[0][1]);
+    EXPECT_EQ(15, res[1][0]);
+    EXPECT_EQ(20, res[1][1]);
 }
 
-TEST(TDynamicMatrix, can_subtract_matrices_with_equal_size)
-{
-  ADD_FAILURE();
+TEST(TDynamicMatrix, can_multiply_by_zero_scalar) {
+    TDynamicMatrix<int> m(2);
+    m[0][0] = 5; m[0][1] = 6;
+    m[1][0] = 7; m[1][1] = 8;
+    
+    TDynamicMatrix<int> res = m * 0;
+    
+    EXPECT_EQ(0, res[0][0]);
+    EXPECT_EQ(0, res[0][1]);
+    EXPECT_EQ(0, res[1][0]);
+    EXPECT_EQ(0, res[1][1]);
 }
 
-TEST(TDynamicMatrix, cant_subtract_matrixes_with_not_equal_size)
-{
-  ADD_FAILURE();
+TEST(TDynamicMatrix, can_multiply_matrix_by_vector) {
+    TDynamicMatrix<int> m(2);
+    m[0][0] = 1; m[0][1] = 2;
+    m[1][0] = 3; m[1][1] = 4;
+
+    TDynamicVector<int> v(2);
+    v[0] = 5; v[1] = 6;
+
+    TDynamicVector<int> res = m * v;
+
+    EXPECT_EQ(17, res[0]);   /*1*5 + 2*6 = 5 + 12 = 17 3*5 + 4*6 = 15 + 24 = 39 вроде в это хочется поверить*/
+    EXPECT_EQ(39, res[1]);   
+}
+
+TEST(TDynamicMatrix, cant_multiply_matrix_by_vector_with_different_size) {
+    TDynamicMatrix<int> m(2);
+    TDynamicVector<int> v(3);
+
+    EXPECT_ANY_THROW(m * v);
+}
+
+TEST(TDynamicMatrix, multiply_by_edinich_matrix_gives_same_matrix) {
+    TDynamicMatrix<int> m(2);
+    m[0][0] = 1; m[0][1] = 2;
+    m[1][0] = 3; m[1][1] = 4;
+    
+    TDynamicMatrix<int> edinich(2);
+    edinich[0][0] = 1; edinich[0][1] = 0;
+    edinich[1][0] = 0; edinich[1][1] = 1;
+    
+    TDynamicMatrix<int> res = m * edinich;
+    
+    EXPECT_EQ(m, res);
 }
 
+// Тесты move-семантики
+TEST(TDynamicMatrix, can_create_matrix_with_move_semantics) {
+    TDynamicMatrix<int> m1(2);
+    m1[0][0] = 1;
+    
+    TDynamicMatrix<int> m2(std::move(m1));
+    
+    EXPECT_EQ(1, m2[0][0]);
+}
+
+TEST(TDynamicMatrix, move_assignment_operator_works_correctly) {
+    TDynamicMatrix<int> m1(2), m2(1);
+    m1[0][0] = 1;
+    
+    m2 = std::move(m1);
+    
+    EXPECT_EQ(1, m2[0][0]);
+}
+//тест на ввод и вывод вроде
+TEST(TDynamicMatrix, can_read_and_write_matrix_from_stream) {
+    std::stringstream input;
+    input << "1 2 3\n";
+    input << "4 5 6\n";
+    input << "7 8 9\n";
+    
+    TDynamicMatrix<int> m(3);
+    input >> m;
+    
+    EXPECT_EQ(1, m[0][0]);
+    EXPECT_EQ(2, m[0][1]);
+    EXPECT_EQ(3, m[0][2]);
+    EXPECT_EQ(4, m[1][0]);
+    EXPECT_EQ(5, m[1][1]);
+    EXPECT_EQ(6, m[1][2]);
+    EXPECT_EQ(7, m[2][0]);
+    EXPECT_EQ(8, m[2][1]);
+    EXPECT_EQ(9, m[2][2]);
+    
+    std::stringstream output;
+    output << m;
+    
+    TDynamicMatrix<int> m2(3);
+    output >> m2;
+    
+    EXPECT_EQ(m, m2);
+}
\ No newline at end of file
diff --git a/test/test_tvector.cpp b/test/test_tvector.cpp
index 1f7737755..798424682 100644
--- a/test/test_tvector.cpp
+++ b/test/test_tvector.cpp
@@ -1,141 +1,233 @@
 #include "tmatrix.h"
-
 #include <gtest.h>
 
-TEST(TDynamicVector, can_create_vector_with_positive_length)
-{
-  ASSERT_NO_THROW(TDynamicVector<int> v(5));
-}
-
-TEST(TDynamicVector, cant_create_too_large_vector)
-{
-  ASSERT_ANY_THROW(TDynamicVector<int> v(MAX_VECTOR_SIZE + 1));
-}
-
-TEST(TDynamicVector, throws_when_create_vector_with_negative_length)
-{
-  ASSERT_ANY_THROW(TDynamicVector<int> v(-5));
-}
-
-TEST(TDynamicVector, can_create_copied_vector)
-{
-  TDynamicVector<int> v(10);
-
-  ASSERT_NO_THROW(TDynamicVector<int> v1(v));
-}
-
-TEST(TDynamicVector, copied_vector_is_equal_to_source_one)
-{
-  ADD_FAILURE();
-}
-
-TEST(TDynamicVector, copied_vector_has_its_own_memory)
-{
-  ADD_FAILURE();
-}
-
-TEST(TDynamicVector, can_get_size)
-{
-  TDynamicVector<int> v(4);
-
-  EXPECT_EQ(4, v.size());
-}
-
-//TEST(TDynamicVector, can_set_and_get_element)
-//{
-//  TDynamicVector<int> v(4);
-//  v[0] = 4;
-//
-//  EXPECT_EQ(4, v[0]);
-//}
-
-TEST(TDynamicVector, throws_when_set_element_with_negative_index)
-{
-  ADD_FAILURE();
-}
-
-TEST(TDynamicVector, throws_when_set_element_with_too_large_index)
-{
-  ADD_FAILURE();
-}
-
-TEST(TDynamicVector, can_assign_vector_to_itself)
-{
-  ADD_FAILURE();
-}
-
-TEST(TDynamicVector, can_assign_vectors_of_equal_size)
-{
-  ADD_FAILURE();
-}
-
-TEST(TDynamicVector, assign_operator_change_vector_size)
-{
-  ADD_FAILURE();
+// Базовые тесты создания вектора
+TEST(TDynamicVector, can_create_vector_with_positive_length) {
+    ASSERT_NO_THROW(TDynamicVector<int> v(5));
 }
 
-TEST(TDynamicVector, can_assign_vectors_of_different_size)
-{
-  ADD_FAILURE();
+TEST(TDynamicVector, cant_create_too_large_vector) {
+    ASSERT_ANY_THROW(TDynamicVector<int> v(MAX_VECTOR_SIZE + 1));
 }
 
-TEST(TDynamicVector, compare_equal_vectors_return_true)
-{
-  ADD_FAILURE();
+TEST(TDynamicVector, throws_when_create_vector_with_negative_length) {
+    ASSERT_ANY_THROW(TDynamicVector<int> v(-5));
 }
 
-TEST(TDynamicVector, compare_vector_with_itself_return_true)
-{
-  ADD_FAILURE();
+// Тесты копирования
+TEST(TDynamicVector, can_create_copied_vector) {
+    TDynamicVector<int> v(5);
+    ASSERT_NO_THROW(TDynamicVector<int> v1(v));
 }
 
-TEST(TDynamicVector, vectors_with_different_size_are_not_equal)
-{
-  ADD_FAILURE();
+TEST(TDynamicVector, copied_vector_is_equal_to_source_one) {
+    TDynamicVector<int> v(3);
+    v[0] = 1; v[1] = 2; v[2] = 3;
+    
+    TDynamicVector<int> v1(v);
+    
+    EXPECT_EQ(v, v1);
 }
 
-TEST(TDynamicVector, can_add_scalar_to_vector)
-{
-  ADD_FAILURE();
+TEST(TDynamicVector, copied_vector_has_its_own_memory) {
+    TDynamicVector<int> v(3);
+    v[0] = 1; v[1] = 2; v[2] = 3;
+    
+    TDynamicVector<int> v1(v);
+    v[0] = 999; 
+    
+    EXPECT_EQ(1, v1[0]); 
 }
 
-TEST(TDynamicVector, can_subtract_scalar_from_vector)
-{
-  ADD_FAILURE();
+// Тесты доступа к элементам
+TEST(TDynamicVector, can_get_size) {
+    TDynamicVector<int> v(4);
+    EXPECT_EQ(4, v.size());
 }
 
-TEST(TDynamicVector, can_multiply_scalar_by_vector)
-{
-  ADD_FAILURE();
+TEST(TDynamicVector, can_set_and_get_element) {
+    TDynamicVector<int> v(3);
+    v[1] = 42;
+    EXPECT_EQ(42, v[1]);
 }
 
-TEST(TDynamicVector, can_add_vectors_with_equal_size)
-{
-  ADD_FAILURE();
+TEST(TDynamicVector, throws_when_set_element_with_negative_index) {
+    TDynamicVector<int> v(3);
+    ASSERT_ANY_THROW(v.at(-1) = 5);
 }
 
-TEST(TDynamicVector, cant_add_vectors_with_not_equal_size)
-{
-  ADD_FAILURE();
+TEST(TDynamicVector, throws_when_set_element_with_too_large_index) {
+    TDynamicVector<int> v(3);
+    ASSERT_ANY_THROW(v.at(3) = 5);
 }
 
-TEST(TDynamicVector, can_subtract_vectors_with_equal_size)
-{
-  ADD_FAILURE();
+// Тесты оператора присваивания
+TEST(TDynamicVector, can_assign_vector_to_itself) {
+    TDynamicVector<int> v(3);
+    v[0] = 1; v[1] = 2; v[2] = 3;
+    
+    v = v;
+    
+    EXPECT_EQ(3, v.size());
+    EXPECT_EQ(1, v[0]);
+    EXPECT_EQ(2, v[1]);
+    EXPECT_EQ(3, v[2]);
 }
 
-TEST(TDynamicVector, cant_subtract_vectors_with_not_equal_size)
-{
-  ADD_FAILURE();
+TEST(TDynamicVector, can_assign_vectors_of_equal_size) {
+    TDynamicVector<int> v(2), v1(2);
+    v1[0] = 10; v1[1] = 20;
+    
+    v = v1;
+    
+    EXPECT_EQ(10, v[0]);
+    EXPECT_EQ(20, v[1]);
 }
 
-TEST(TDynamicVector, can_multiply_vectors_with_equal_size)
-{
-  ADD_FAILURE();
+TEST(TDynamicVector, assign_operator_change_vector_size) {
+    TDynamicVector<int> v(2), v1(4);
+    
+    v = v1;
+    
+    EXPECT_EQ(4, v.size());
 }
 
-TEST(TDynamicVector, cant_multiply_vectors_with_not_equal_size)
-{
-  ADD_FAILURE();
+TEST(TDynamicVector, can_assign_vectors_of_different_size) {
+    TDynamicVector<int> v(2), v1(3);
+    v1[0] = 1; v1[1] = 2; v1[2] = 3;
+    
+    v = v1;
+    
+    EXPECT_EQ(3, v.size());
+    EXPECT_EQ(1, v[0]);
+    EXPECT_EQ(2, v[1]);
+    EXPECT_EQ(3, v[2]);
 }
 
+// Тесты сравнения
+TEST(TDynamicVector, compare_equal_vectors_return_true) {
+    TDynamicVector<int> v(2), v1(2);
+    v[0] = 1; v[1] = 2;
+    v1[0] = 1; v1[1] = 2;
+    
+    EXPECT_TRUE(v == v1);
+}
+
+TEST(TDynamicVector, compare_vector_with_itself_return_true) {
+    TDynamicVector<int> v(2);
+    v[0] = 1; v[1] = 2;
+    
+    EXPECT_TRUE(v == v);
+}
+
+TEST(TDynamicVector, vectors_with_different_size_are_not_equal) {
+    TDynamicVector<int> v(3), v1(2);
+    
+    EXPECT_TRUE(v != v1);
+}
+
+// Тесты арифметических операций с числами
+TEST(TDynamicVector, can_add_scalar_to_vector) {
+    TDynamicVector<int> v(2);
+    v[0] = 1; v[1] = 2;
+    
+    TDynamicVector<int> res = v + 5;
+    
+    EXPECT_EQ(6, res[0]);
+    EXPECT_EQ(7, res[1]);
+}
+
+TEST(TDynamicVector, can_subtract_scalar_from_vector) {
+    TDynamicVector<int> v(2);
+    v[0] = 10; v[1] = 20;
+    
+    TDynamicVector<int> res = v - 3;
+    
+    EXPECT_EQ(7, res[0]);
+    EXPECT_EQ(17, res[1]);
+}
+
+TEST(TDynamicVector, can_multiply_scalar_by_vector) {
+    TDynamicVector<int> v(2);
+    v[0] = 2; v[1] = 3;
+    
+    TDynamicVector<int> res = v * 4;
+    
+    EXPECT_EQ(8, res[0]);
+    EXPECT_EQ(12, res[1]);
+}
+
+// Тесты арифметических операций с векторами
+TEST(TDynamicVector, can_add_vectors_with_equal_size) {
+    TDynamicVector<int> v(2), v1(2);
+    v[0] = 1; v[1] = 2;
+    v1[0] = 3; v1[1] = 4;
+    
+    TDynamicVector<int> res = v + v1;
+    
+    EXPECT_EQ(4, res[0]);
+    EXPECT_EQ(6, res[1]);
+}
+
+TEST(TDynamicVector, cant_add_vectors_with_not_equal_size) {
+    TDynamicVector<int> v(3), v1(2);
+    ASSERT_ANY_THROW(v + v1);
+}
+
+TEST(TDynamicVector, can_subtract_vectors_with_equal_size) {
+    TDynamicVector<int> v(2), v1(2);
+    v[0] = 5; v[1] = 6;
+    v1[0] = 2; v1[1] = 3;
+    
+    TDynamicVector<int> res = v - v1;
+    
+    EXPECT_EQ(3, res[0]);
+    EXPECT_EQ(3, res[1]);
+}
+
+TEST(TDynamicVector, cant_subtract_vectors_with_not_equal_size) {
+    TDynamicVector<int> v(3), v1(2);
+    ASSERT_ANY_THROW(v - v1);
+}
+
+TEST(TDynamicVector, can_multiply_vectors_with_equal_size) {
+    TDynamicVector<int> v(3), v1(3);
+    v[0] = 1; v[1] = 2; v[2] = 3;
+    v1[0] = 4; v1[1] = 5; v1[2] = 6;
+    
+    int res = v * v1;
+    
+    EXPECT_EQ(32, res); // 1*4 + 2*5 + 3*6 = 4 + 10 + 18 = 32 вроде как будто
+}
+
+TEST(TDynamicVector, cant_multiply_vectors_with_not_equal_size) {
+    TDynamicVector<int> v(3), v1(2);
+    ASSERT_ANY_THROW(v * v1);
+}
+
+// Тесты move-семантики
+TEST(TDynamicVector, can_create_vector_with_move_semantics) {
+    TDynamicVector<int> v1(3);
+    v1[0] = 1; v1[1] = 2; v1[2] = 3;
+    
+    TDynamicVector<int> v2(std::move(v1));
+    
+    EXPECT_EQ(0, v1.size());
+    EXPECT_EQ(3, v2.size());
+    EXPECT_EQ(1, v2[0]);
+    EXPECT_EQ(2, v2[1]);
+    EXPECT_EQ(3, v2[2]);
+}
+
+TEST(TDynamicVector, move_assignment_operator_works_correctly) {
+    TDynamicVector<int> v1(3), v2(2);
+    v1[0] = 1; v1[1] = 2; v1[2] = 3;
+    
+    v2 = std::move(v1);
+    
+    EXPECT_EQ(0, v1.size());
+    EXPECT_EQ(3, v2.size());
+    EXPECT_EQ(1, v2[0]);
+    EXPECT_EQ(2, v2[1]);
+    EXPECT_EQ(3, v2[2]);
+}
\ No newline at end of file