diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 000000000..da77fa045
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,41 @@
+cmake_minimum_required(VERSION 2.8)
+
+set(PROJECT_NAME my_matrix)
+project(${PROJECT_NAME})
+
+# TODO(Kornyakov): not sure if these lines are needed
+set(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "Configs" FORCE)
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Debug)
+endif()
+
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/bin)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE})
+
+set(MP2_LIBRARY "${PROJECT_NAME}")
+set(MP2_TESTS   "test_${PROJECT_NAME}")
+set(MP2_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/include") # Path to your header files
+
+include_directories("${MP2_INCLUDE}" gtest)
+
+add_library(${MP2_LIBRARY} INTERFACE)
+
+target_include_directories(${MP2_LIBRARY} INTERFACE
+    "${MP2_INCLUDE}"
+)
+
+
+# BUILD
+add_subdirectory(samples)
+add_subdirectory(gtest)
+add_subdirectory(test)
+
+# REPORT
+message( STATUS "")
+message( STATUS "General configuration for ${PROJECT_NAME}")
+message( STATUS "======================================")
+message( STATUS "")
+message( STATUS "   Configuration: ${CMAKE_BUILD_TYPE}")
+message( STATUS "")
\ No newline at end of file
diff --git a/gtest/CMakeLists.txt b/gtest/CMakeLists.txt
new file mode 100644
index 000000000..347e4d5c6
--- /dev/null
+++ b/gtest/CMakeLists.txt
@@ -0,0 +1,11 @@
+set(target "gtest")
+
+add_library(${target} STATIC gtest-all.cc)
+
+if((${CMAKE_CXX_COMPILER_ID} MATCHES "GNU" OR
+    ${CMAKE_CXX_COMPILER_ID} MATCHES "Clang") AND
+    (${CMAKE_SYSTEM_NAME} MATCHES "Linux"))
+    set(pthread "-pthread")
+endif()
+
+target_link_libraries(${target} ${pthread})
diff --git a/include/tmatrix.h b/include/tmatrix.h
index a1eaa2cf2..7fa9ca7ca 100644
--- a/include/tmatrix.h
+++ b/include/tmatrix.h
@@ -17,158 +17,444 @@ const int MAX_MATRIX_SIZE = 10000;
 // Динамический вектор - 
 // шаблонный вектор на динамической памяти
 template<typename T>
-class TDynamicVector
-{
+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) || (sz > MAX_VECTOR_SIZE))
+            throw out_of_range("Vector size is invalid");
+        
+        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) {
+        sz = v.sz;
+
+        pMem = new T[sz];
+
+        for (size_t i = 0; i < sz; i++) {
+            pMem[i] = v.pMem[i];
+        }
+    };
+
+
+    TDynamicVector(TDynamicVector&& v) noexcept {
+        sz = v.sz;
+        pMem = v.pMem;
+        v.sz = 0;
+        v.pMem = nullptr;
+    };
+    
+
+    ~TDynamicVector() {
+        delete[] pMem;
+        pMem = nullptr;
+    };
+  
+
+    TDynamicVector& operator=(const TDynamicVector& v) {
+        if (this != &v) {
+            sz = v.sz;
+
+            delete[] pMem;
+
+            pMem = new T[sz];
+
+            for (size_t i = 0; i < sz; i++) {
+                pMem[i] = v.pMem[i];
+            }
+        }
+
+        return *this;
+    };
+  
+
+    TDynamicVector& operator=(TDynamicVector&& v) noexcept {
+        if (this == &v)
+            return *this;
+             
+        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 ((ind < 0) || (ind >= sz))
+            throw out_of_range("Index error");
+
+        return pMem[ind];
+    }
+
+
+    const T& at(size_t ind) const {
+        if ((ind < 0) || (ind >= sz))
+            throw out_of_range("Index error");
+
+        return pMem[ind];
+    };
+
+
+    // сравнение
+    bool operator==(const TDynamicVector& v) const noexcept {
+        if (sz != v.sz)
+            return false;
+
+        if (this == &v)
+            return true;
+
+        for (size_t 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 (size_t i = 0; i < sz; i++)
+            if (pMem[i] != v.pMem[i])
+                return true;
+
+        return false;
+    }
+
+
+      // скалярные операции
+    TDynamicVector operator+(T val) {
+        TDynamicVector<T> result(sz);
+
+        for(size_t i = 0; i < sz; i++) {
+            result.pMem[i] = pMem[i] + val;
+        }
+        
+        return result;
+    }
+
+
+    TDynamicVector operator-(T val) {
+        TDynamicVector<T> result(sz);
+
+        for(size_t i = 0; i < sz; i++) {
+            result.pMem[i] = pMem[i] - val;
+        }
+        
+        return result;
+    }
+
+
+    TDynamicVector operator*(T val) {
+        TDynamicVector<T> result(sz);
+
+        for(size_t i = 0; i < sz; i++) {
+            result.pMem[i] = pMem[i] * val;
+        }
+        
+        return result;
+    }
+
+    
+    // векторные операции
+    TDynamicVector operator+(const TDynamicVector& v) {
+        if (sz != v.sz)
+            throw length_error("Sizes of vectors must be equals");
+
+        TDynamicVector<T> result(sz);
+
+        for (size_t i = 0; i < sz; i++) {
+            result.pMem[i] = pMem[i] + v.pMem[i];
+        }
+
+        return result;
+    }
+    
+
+    TDynamicVector operator-(const TDynamicVector& v) {
+        if (sz != v.sz)
+            throw length_error("Sizes of vectors must be equals");
+
+        TDynamicVector<T> result(sz);
+
+        for (size_t i = 0; i < sz; i++) {
+            result.pMem[i] = pMem[i] - v.pMem[i];
+        }
+
+        return result;
+    }
+
+
+    T operator*(const TDynamicVector& v) {
+        if (sz != v.sz)
+            throw length_error("Sizes of vectors must be equals");
+
+        T result = 0;
+
+        for (size_t i = 0; i < sz; i++) {
+            result += pMem[i] * v.pMem[i];
+        }
+
+        return result;
+    }
+
+
+    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) {
+        ostr << "||" << '\t';
+        for (size_t i = 0; i < v.sz; i++)
+            ostr << v.pMem[i] << '\t'; // требуется оператор<< для типа T
+        ostr << "||";
+
+        return ostr;
+    }
 };
 
 
+
 // Динамическая матрица - 
 // шаблонная матрица на динамической памяти
 template<typename T>
-class TDynamicMatrix : private TDynamicVector<TDynamicVector<T>>
-{
-  using TDynamicVector<TDynamicVector<T>>::pMem;
-  using TDynamicVector<TDynamicVector<T>>::sz;
+class TDynamicMatrix : private TDynamicVector<TDynamicVector<T>> {
+    using TDynamicVector<TDynamicVector<T>>::pMem;
+    using TDynamicVector<TDynamicVector<T>>::sz;
+
 public:
-  TDynamicMatrix(size_t s = 1) : TDynamicVector<TDynamicVector<T>>(s)
-  {
-    for (size_t i = 0; i < sz; i++)
-      pMem[i] = TDynamicVector<T>(sz);
-  }
-
-  using TDynamicVector<TDynamicVector<T>>::operator[];
-
-  // сравнение
-  bool operator==(const TDynamicMatrix& m) const noexcept
-  {
-  }
-
-  // матрично-скалярные операции
-  TDynamicMatrix operator*(const T& val)
-  {
-  }
-
-  // матрично-векторные операции
-  TDynamicVector<T> operator*(const TDynamicVector<T>& 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<TDynamicVector<T>>(s) {
+        if ((this->sz <= 0) || (this->sz > MAX_MATRIX_SIZE))
+            throw out_of_range("Matrix size is invalid");
+
+        for (size_t i = 0; i < this->sz; i++)
+            this->pMem[i] = TDynamicVector<T>(this->sz);
+    }
+
+
+    TDynamicMatrix(const TDynamicMatrix& m) : TDynamicVector<TDynamicVector<T>>(m) {
+        for (size_t i = 0; i < this->sz; i++)
+            this->pMem[i] = m[i]; 
+    }
+
+    
+    TDynamicMatrix& operator=(const TDynamicMatrix& m) {
+        if (this != &m) {
+            size_t new_sz = m.size();
+            TDynamicVector<T>* new_pMem = new TDynamicVector<T>[new_sz];
+
+            for (size_t i = 0; i < new_sz; i++)
+                new_pMem[i] = m[i];
+
+            delete[] this->pMem;
+
+            this->sz = new_sz;
+            this->pMem = new_pMem;
+        }
+
+        return *this;
+    }
+
+
+    TDynamicMatrix& operator=(TDynamicMatrix&& v) noexcept {
+        if (this != &v) {
+            TDynamicVector<TDynamicVector<T>>::operator=(std::move(v));
+        }
+
+        return *this;
+    }
+
+
+    ~TDynamicMatrix() = default;
+
+
+    using TDynamicVector<TDynamicVector<T>>::operator[];
+
+
+    T& at(size_t row, size_t col) {
+        if ((row < 0) || (row >= this->sz) || (col < 0) || (col >= this->sz))
+            throw out_of_range("Index error");
+
+        return this->pMem[row][col];
+    }
+
+
+    const T& at(size_t row, size_t col) const {
+        if ((row < 0) || (row >= this->sz) || (col < 0) || (col >= this->sz))
+            throw out_of_range("Index error");
+
+        return this->pMem[row][col];
+    };
+
+
+    using TDynamicVector<TDynamicVector<T>>::size;
+
+
+    // сравнение
+    bool operator==(const TDynamicMatrix& m) const noexcept {
+        if (m.sz != this->sz) {
+            return false;
+        }
+
+        for (size_t i = 0; i < this->sz; i++) {
+            if (this->pMem[i] != m.pMem[i]) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+
+    bool operator!=(const TDynamicMatrix& m) const noexcept {
+        if (m.sz != this->sz) {
+            return true;
+        }
+
+        for (size_t i = 0; i < this->sz; i++) {
+            if (this->pMem[i] != m.pMem[i]) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+
+    // матрично-скалярные операции
+    TDynamicMatrix operator*(const T& val) {
+        TDynamicMatrix<T> result(*this);
+
+        for (size_t i = 0; i < this->sz; i++) {
+            result.pMem[i] = this->pMem[i] * val;
+        }
+
+        return result;
+    }
+
+
+    // матрично-векторные операции
+    TDynamicVector<T> operator*(const TDynamicVector<T>& v) {
+        if (this->sz != v.size())
+            throw length_error("Invalid size");
+
+        TDynamicVector<T> result(this->sz);
+
+        for (size_t i = 0; i < this->sz; i++) {
+            result[i] = 0;
+            for (size_t j = 0; j < this->sz; j++) {
+                result[i] += this->pMem[i][j] * v[j];
+            }
+        }
+
+        return result;
+    }
+
+
+    // матрично-матричные операции
+    TDynamicMatrix operator+(const TDynamicMatrix& m) {
+        if (this->sz != m.sz)
+            throw length_error("Sizes of matrices must be equals");
+
+        TDynamicMatrix<T> result(this->sz);
+
+        for (size_t i = 0; i < this->sz; i++)
+            result.pMem[i] = this->pMem[i] + m.pMem[i]; 
+
+        return result;
+    }
+
+
+    TDynamicMatrix operator-(const TDynamicMatrix& m) {
+        if (this->sz != m.sz)
+            throw length_error("Sizes of matrices must be equals");
+
+        TDynamicMatrix<T> result(this->sz);
+
+        for (size_t i = 0; i < this->sz; i++)
+            result.pMem[i] = this->pMem[i] - m.pMem[i]; 
+
+        return result;
+    }
+
+
+    TDynamicMatrix operator*(const TDynamicMatrix& m) {
+        if (this->sz != m.sz)
+            throw length_error("Sizes of matrices must be equals");
+
+        TDynamicMatrix<T> result(this->sz);
+
+        for (size_t i = 0; i < this->sz; i++)
+            for (size_t j = 0; j < this->sz; j++) {
+                result.pMem[i][j] = 0;
+                for (size_t k = 0; k < this->sz; k++)
+                    result.pMem[i][j] += this->pMem[i][k] * m.pMem[k][j];
+            }
+
+        return result;
+    }
+
+
+    // ввод/вывод
+    friend istream& operator>>(istream& istr, TDynamicMatrix& m) {
+        for (size_t i = 0; i < m.sz; i++)
+            istr >> m.pMem[i];
+        
+        return istr;
+    }
+
+
+    friend ostream& operator<<(ostream& ostr, const TDynamicMatrix& m) {
+        for (size_t i = 0; i < m.sz; i++)
+            ostr << m.pMem[i] << '\n';
+        
+        return ostr;
+    }
 };
 
 #endif
diff --git a/samples/CMakeLists.txt b/samples/CMakeLists.txt
new file mode 100644
index 000000000..2b2c64765
--- /dev/null
+++ b/samples/CMakeLists.txt
@@ -0,0 +1,16 @@
+# Get all cpp-files in the current directory
+file(GLOB samples_list RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
+
+
+foreach(sample_filename ${samples_list})
+  # Get file name without extension
+  get_filename_component(sample ${sample_filename} NAME_WE)
+
+  # Add and configure executable file to be produced
+  add_executable(${sample} ${sample_filename})
+  target_link_libraries(${sample} ${MP2_LIBRARY})
+  set_target_properties(${sample} PROPERTIES
+    OUTPUT_NAME "${sample}"
+    PROJECT_LABEL "${sample}"
+    RUNTIME_OUTPUT_DIRECTORY "../")
+endforeach()
\ No newline at end of file
diff --git a/samples/sample_matrix.cpp b/samples/sample_matrix.cpp
index d6bc73330..6a3a09e86 100644
--- a/samples/sample_matrix.cpp
+++ b/samples/sample_matrix.cpp
@@ -6,25 +6,41 @@
 
 #include <iostream>
 #include "tmatrix.h"
-//---------------------------------------------------------------------------
-
-void main()
-{
-  TDynamicMatrix<int> a(5), b(5), c(5);
-  int i, j;
-
-  setlocale(LC_ALL, "Russian");
-  cout << "Тестирование класс работы с матрицами"
-    << endl;
-  for (i = 0; i < 5; i++)
-    for (j = i; j < 5; j++ )
-    {
-      a[i][j] =  i * 10 + j;
-      b[i][j] = (i * 10 + j) * 100;
-    }
-  c = a + b;
-  cout << "Matrix a = " << endl << a << endl;
-  cout << "Matrix b = " << endl << b << endl;
-  cout << "Matrix c = a + b" << endl << c << endl;
+
+
+int main() {
+    setlocale(LC_ALL, "Russian");
+
+    TDynamicMatrix<int> m1(3), m2(3), _m(3);
+    TDynamicVector<int> v(3), _v(3);
+
+    int i, j;
+
+    for (i = 0; i < 3; i++)
+        for (j = 0; j < 3; j++) {
+              m1[i][j] = 1;
+              m2[i][j] = 2;
+              v[i] = 1;
+        }
+  
+    cout << "Тестирование класс работы с матрицами" << endl << endl;
+    cout << "Матрица A:" << endl << m1 << endl;
+    cout << "Матрица B:" << endl << m2 << endl;
+    cout << "Вектор x:" << endl << v << endl << endl;
+    cout << "--------------------" << endl << endl;
+
+    _m = m1 * 5;
+    cout << "Матрица A * 5:" << endl << _m << endl;
+
+    _v = m2 * v;
+    cout << "Вектор B * x:" << endl << _v << endl << endl;
+
+    _m = m1 + m2;
+    cout << "Матрица A + B:" << endl << _m << endl;
+
+    _m = m1 - m2;
+    cout << "Матрица A - B:" << endl << _m << endl;
+
+    _m = m1 * m2;
+    cout << "Матрица A * B:" << endl << _m << endl; 
 }
-//---------------------------------------------------------------------------
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
new file mode 100644
index 000000000..02b6b07e6
--- /dev/null
+++ b/test/CMakeLists.txt
@@ -0,0 +1,9 @@
+set(target ${MP2_TESTS})
+
+file(GLOB hdrs "*.h*")
+file(GLOB srcs "*.cpp")
+
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../3rdparty")
+
+add_executable(${target} ${srcs} ${hdrs})
+target_link_libraries(${target} gtest ${MP2_LIBRARY})
diff --git a/test/test_tmatrix.cpp b/test/test_tmatrix.cpp
index edaf75ef6..94fbefc38 100644
--- a/test/test_tmatrix.cpp
+++ b/test/test_tmatrix.cpp
@@ -1,111 +1,199 @@
 #include "tmatrix.h"
-
 #include <gtest.h>
 
-TEST(TDynamicMatrix, can_create_matrix_with_positive_length)
-{
-  ASSERT_NO_THROW(TDynamicMatrix<int> m(5));
-}
 
-TEST(TDynamicMatrix, cant_create_too_large_matrix)
-{
-  ASSERT_ANY_THROW(TDynamicMatrix<int> m(MAX_MATRIX_SIZE + 1));
+TEST(TDynamicMatrix, can_create_matrix_with_positive_length) {
+    ASSERT_NO_THROW(TDynamicMatrix<int> m(5));
 }
 
-TEST(TDynamicMatrix, throws_when_create_matrix_with_negative_length)
-{
-  ASSERT_ANY_THROW(TDynamicMatrix<int> m(-5));
+
+TEST(TDynamicMatrix, cant_create_too_large_matrix) {
+    ASSERT_ANY_THROW(TDynamicMatrix<int> m(MAX_MATRIX_SIZE + 1));
 }
 
-TEST(TDynamicMatrix, can_create_copied_matrix)
-{
-  TDynamicMatrix<int> m(5);
 
-  ASSERT_NO_THROW(TDynamicMatrix<int> m1(m));
+TEST(TDynamicMatrix, throws_when_create_matrix_with_negative_length) {
+    ASSERT_ANY_THROW(TDynamicMatrix<int> m(-5));
 }
 
-TEST(TDynamicMatrix, copied_matrix_is_equal_to_source_one)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicMatrix, can_create_copied_matrix) {
+    TDynamicMatrix<int> m(5);
+
+    ASSERT_NO_THROW(TDynamicMatrix<int> m1(m));
 }
 
-TEST(TDynamicMatrix, copied_matrix_has_its_own_memory)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicMatrix, copied_matrix_is_equal_to_source_one) {
+    TDynamicMatrix<int> source(4);
+    source[3][1] = 2;
+    source[1][2] = 9;
+    TDynamicMatrix<int> copied(source);
+
+    EXPECT_EQ(source, copied);
 }
 
-TEST(TDynamicMatrix, can_get_size)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicMatrix, copied_matrix_has_its_own_memory) {
+    TDynamicMatrix<double> source(5);
+    source[3][4] = 2.4;
+    TDynamicMatrix<double> copied(source);
+    copied[3][4] = 2.5;
+
+    EXPECT_NE(source[3][4], copied[3][4]);
 }
 
-TEST(TDynamicMatrix, can_set_and_get_element)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicMatrix, can_get_size) {
+    TDynamicMatrix<int> m(4);
+
+    EXPECT_EQ(4, m.size());
 }
 
-TEST(TDynamicMatrix, throws_when_set_element_with_negative_index)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicMatrix, can_set_and_get_element) {
+    TDynamicMatrix<int> m(4);
+    m[2][1] = 4;
+
+    EXPECT_EQ(4, m[2][1]);
 }
 
-TEST(TDynamicMatrix, throws_when_set_element_with_too_large_index)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicMatrix, throws_when_set_element_with_negative_index) {
+    TDynamicMatrix<double> m(3);
+
+    EXPECT_ANY_THROW(m.at(-1, 2) = 3.4);
+    EXPECT_ANY_THROW(m.at(2, -1) = -32.1);
 }
 
-TEST(TDynamicMatrix, can_assign_matrix_to_itself)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicMatrix, throws_when_set_element_with_too_large_index) {
+    TDynamicMatrix<double> m(3);
+
+    EXPECT_ANY_THROW(m.at(1, 4) = 3.4);
+    EXPECT_ANY_THROW(m.at(3, 2) = -32.1);
 }
 
-TEST(TDynamicMatrix, can_assign_matrices_of_equal_size)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicMatrix, can_assign_matrix_to_itself) {
+    TDynamicMatrix<int> m(10);
+    m[3][0] = 2;
+    m[9][4] = 1;
+
+    TDynamicMatrix<int> _m(m);
+
+    _m = _m;
+
+    EXPECT_EQ(_m, _m);
 }
 
-TEST(TDynamicMatrix, assign_operator_change_matrix_size)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicMatrix, can_assign_matrices_of_equal_size) {
+    TDynamicMatrix<double> m(10);
+    m[2][4] = 2;
+    m[9][0] = 1.2;
+
+    TDynamicMatrix<double> _m(10);
+    _m[2][4] = 1.8;
+    _m[3][8] = 5.2;
+
+    _m = m;
+
+    EXPECT_EQ(m, _m);
 }
 
-TEST(TDynamicMatrix, can_assign_matrices_of_different_size)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicMatrix, assign_operator_change_matrix_size) {
+    TDynamicMatrix<double> m1(7);
+    TDynamicMatrix<double> m2(10);
+
+    m2 = m1;
+
+    EXPECT_EQ(7, m2.size());
 }
 
-TEST(TDynamicMatrix, compare_equal_matrices_return_true)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicMatrix, can_assign_matrices_of_different_size) {
+    TDynamicMatrix<double> m1(7);
+    TDynamicMatrix<double> m2(10);
+
+    m1[0][4] = 3;
+    m2[0][4] = 1.3;
+    m2[9][3] = 4.1;
+
+    m2 = m1;
+
+    EXPECT_EQ(m1, m2);
 }
 
-TEST(TDynamicMatrix, compare_matrix_with_itself_return_true)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicMatrix, compare_equal_matrices_return_true) {
+    TDynamicMatrix<int> m1(10), m2(10);
+
+    m1[0][4] = -1;
+    m2[0][4] = -1;
+    m1[3][7] = 43;
+    m2[3][7] = 43;
+
+    EXPECT_TRUE(m1 == m2);
 }
 
-TEST(TDynamicMatrix, matrices_with_different_size_are_not_equal)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicMatrix, compare_matrix_with_itself_return_true) {
+    TDynamicMatrix<double> m(5);
+
+    m[1][0] = -3.14;
+    m[3][4] = 888.3;
+
+    EXPECT_TRUE(m == m);
 }
 
-TEST(TDynamicMatrix, can_add_matrices_with_equal_size)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicMatrix, matrices_with_different_size_are_not_equal) {
+    TDynamicMatrix<int> m1(9), m2(10);
+
+    EXPECT_FALSE(m1 == m2);
+
 }
 
-TEST(TDynamicMatrix, cant_add_matrices_with_not_equal_size)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicMatrix, can_add_matrices_with_equal_size) {
+    TDynamicMatrix<int> m1(4), m2(4), _m(4);
+
+    m1[0][2] = m1[1][3] = m1[2][0] = m1[3][1] = 2;
+    m2[0][2] = m2[1][3] = m2[2][0] = m2[3][1] = 6;
+    _m[0][2] = _m[1][3] = _m[2][0] = _m[3][1] = 8;
+
+    EXPECT_EQ(m1 + m2, _m);
 }
 
-TEST(TDynamicMatrix, can_subtract_matrices_with_equal_size)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicMatrix, cant_add_matrices_with_not_equal_size) {
+    TDynamicMatrix<int> m1(3), m2(4);
+
+    m1[0][1] = m1[1][2] = m1[2][0] = 2;
+    m2[0][2] = m2[1][3] = m2[2][0] = m2[3][1] = 3;
+
+    ASSERT_ANY_THROW(m1 + m2);
 }
 
-TEST(TDynamicMatrix, cant_subtract_matrixes_with_not_equal_size)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicMatrix, can_subtract_matrices_with_equal_size) {
+    TDynamicMatrix<int> m1(4), m2(4), _m(4);
+
+    m1[0][2] = m1[1][3] = m1[2][0] = m1[3][1] = 4;
+    m2[0][2] = m2[1][3] = m2[2][0] = m2[3][1] = 1;
+    _m[0][2] = _m[1][3] = _m[2][0] = _m[3][1] = 3;
+
+    EXPECT_EQ(m1 - m2, _m);
 }
 
+
+TEST(TDynamicMatrix, cant_subtract_matrixes_with_not_equal_size) {
+    TDynamicMatrix<int> m1(3), m2(4);
+
+    m1[0][1] = m1[1][2] = m1[2][0] = 2;
+    m2[0][2] = m2[1][3] = m2[2][0] = m2[3][1] = 3;
+
+    ASSERT_ANY_THROW(m1 - m2);
+}
diff --git a/test/test_tvector.cpp b/test/test_tvector.cpp
index 1f7737755..cc0c072d3 100644
--- a/test/test_tvector.cpp
+++ b/test/test_tvector.cpp
@@ -1,141 +1,252 @@
 #include "tmatrix.h"
-
 #include <gtest.h>
 
-TEST(TDynamicVector, can_create_vector_with_positive_length)
-{
-  ASSERT_NO_THROW(TDynamicVector<int> v(5));
+
+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, 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, 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, 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_is_equal_to_source_one) {
+    TDynamicVector<double> source(5);
+    source[3] = 2.4;
+    source[1] = 9.12;
+    TDynamicVector<double> copied(source);
+
+    EXPECT_EQ(source, copied);
 }
 
-TEST(TDynamicVector, copied_vector_has_its_own_memory)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicVector, copied_vector_has_its_own_memory) {
+    TDynamicVector<double> source(5);
+    source[3] = 2.4;
+    TDynamicVector<double> copied(source);
+    copied[3] = 2.5;
+
+    EXPECT_NE(source[3], copied[3]);
 }
 
-TEST(TDynamicVector, can_get_size)
-{
-  TDynamicVector<int> v(4);
 
-  EXPECT_EQ(4, v.size());
+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, can_set_and_get_element) {
+    TDynamicVector<int> v(4);
+    v[0] = 4;
+
+    EXPECT_EQ(4, v[0]);
 }
 
-TEST(TDynamicVector, throws_when_set_element_with_too_large_index)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicVector, throws_when_set_element_with_negative_index) {
+    TDynamicVector<char> v(5);
+
+    ASSERT_ANY_THROW(v.at(-2) = 3);
 }
 
-TEST(TDynamicVector, can_assign_vector_to_itself)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicVector, throws_when_set_element_with_too_large_index) {
+    TDynamicVector<char> v(15);
+
+    ASSERT_ANY_THROW(v.at(15) = 3);
+    ASSERT_ANY_THROW(v.at(MAX_VECTOR_SIZE) = 3);
 }
 
-TEST(TDynamicVector, can_assign_vectors_of_equal_size)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicVector, can_assign_vector_to_itself) {
+    TDynamicVector<double> v(10);
+    v[3] = 2;
+    v[9] = 1.2;
+
+    TDynamicVector<double> _v(v);
+
+    _v = _v;
+
+    EXPECT_EQ(_v, _v);
 }
 
-TEST(TDynamicVector, assign_operator_change_vector_size)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicVector, can_assign_vectors_of_equal_size) {
+    TDynamicVector<double> v(10);
+    v[3] = 2;
+    v[9] = 1.2;
+
+    TDynamicVector<double> _v(10);
+    v[3] = 1;
+    v[4] = 5.2;
+
+    _v = v;
+
+    EXPECT_EQ(v, _v);
 }
 
-TEST(TDynamicVector, can_assign_vectors_of_different_size)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicVector, assign_operator_change_vector_size) {
+    TDynamicVector<double> v1(7);
+    TDynamicVector<double> v2(10);
+
+    v2 = v1;
+
+    EXPECT_EQ(7, v2.size());
 }
 
-TEST(TDynamicVector, compare_equal_vectors_return_true)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicVector, can_assign_vectors_of_different_size) {
+    TDynamicVector<double> v1(7);
+    TDynamicVector<double> v2(10);
+
+    v1[0] = 3;
+    v2[0] = 1.3;
+    v2[9] = 4.1;
+
+    v2 = v1;
+
+    EXPECT_EQ(v1, v2);
 }
 
-TEST(TDynamicVector, compare_vector_with_itself_return_true)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicVector, compare_equal_vectors_return_true) {
+    TDynamicVector<int> v1(10), v2(10);
+
+    v1[0] = -1;
+    v2[0] = -1;
+    v1[3] = 43;
+    v2[3] = 43;
+
+    EXPECT_TRUE(v1 == v2);
 }
 
-TEST(TDynamicVector, vectors_with_different_size_are_not_equal)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicVector, compare_vector_with_itself_return_true) {
+    TDynamicVector<double> v(5);
+
+    v[1] = -3.14;
+    v[3] = 888.3;
+
+    EXPECT_TRUE(v == v);
 }
 
-TEST(TDynamicVector, can_add_scalar_to_vector)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicVector, vectors_with_different_size_are_not_equal) {
+    TDynamicVector<int> v1(9), v2(10);
+
+    EXPECT_FALSE(v1 == v2);
 }
 
-TEST(TDynamicVector, can_subtract_scalar_from_vector)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicVector, can_add_scalar_to_vector) {
+    TDynamicVector<int> v(4), _v(4);
+
+    v[0] = v[1] = v[2] = v[3] = 1;
+    _v[0] = _v[1] = _v[2] = _v[3] = 2;
+
+    EXPECT_EQ(v + 1, _v);
 }
 
-TEST(TDynamicVector, can_multiply_scalar_by_vector)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicVector, can_subtract_scalar_from_vector) {
+    TDynamicVector<int> v(4), _v(4);
+
+    v[0] = v[1] = v[2] = v[3] = 2;
+    _v[0] = _v[1] = _v[2] = _v[3] = 1;
+
+    EXPECT_EQ(v - 1, _v);
 }
 
-TEST(TDynamicVector, can_add_vectors_with_equal_size)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicVector, can_multiply_scalar_by_vector) {
+    TDynamicVector<int> v(4), _v(4);
+
+    v[0] = v[1] = v[2] = v[3] = 2;
+    _v[0] = _v[1] = _v[2] = _v[3] = 8;
+
+    EXPECT_EQ(v * 4, _v);
 }
 
-TEST(TDynamicVector, cant_add_vectors_with_not_equal_size)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicVector, can_add_vectors_with_equal_size) {
+    TDynamicVector<int> v1(4), v2(4), _v(4);
+
+    v1[0] = v1[1] = v1[2] = v1[3] = 2;
+    v2[0] = v2[1] = v2[2] = v2[3] = 6;
+    _v[0] = _v[1] = _v[2] = _v[3] = 8;
+
+    EXPECT_EQ(v1 + v2, _v);
 }
 
-TEST(TDynamicVector, can_subtract_vectors_with_equal_size)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicVector, cant_add_vectors_with_not_equal_size) {
+    TDynamicVector<int> v1(3), v2(4);
+
+    v1[0] = v1[1] = v1[2] = 2;
+    v2[0] = v2[1] = v2[2] = v2[3] = 3;
+
+    ASSERT_ANY_THROW(v1 + v2);
 }
 
-TEST(TDynamicVector, cant_subtract_vectors_with_not_equal_size)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicVector, can_subtract_vectors_with_equal_size) {
+    TDynamicVector<int> v1(4), v2(4), _v(4);
+
+    v1[0] = v1[1] = v1[2] = v1[3] = 9;
+    v2[0] = v2[1] = v2[2] = v2[3] = 2;
+    _v[0] = _v[1] = _v[2] = _v[3] = 7;
+
+    EXPECT_EQ(v1 - v2, _v);
 }
 
-TEST(TDynamicVector, can_multiply_vectors_with_equal_size)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicVector, cant_subtract_vectors_with_not_equal_size) {
+    TDynamicVector<int> v1(3), v2(4);
+
+    v1[0] = v1[1] = v1[2] = 2;
+    v2[0] = v2[1] = v2[2] = v2[3] = 3;
+
+    ASSERT_ANY_THROW(v1 - v2);
 }
 
-TEST(TDynamicVector, cant_multiply_vectors_with_not_equal_size)
-{
-  ADD_FAILURE();
+
+TEST(TDynamicVector, can_multiply_vectors_with_equal_size) {
+    TDynamicVector<int> v1(3), v2(3);
+
+    v1[0] = 1;
+    v1[1] = 4;
+    v1[2] = 2;
+
+    v2[0] = 2;
+    v2[1] = -1;
+    v2[2] = 3;
+
+    EXPECT_EQ(v1 * v2, 4);
 }
 
+
+TEST(TDynamicVector, cant_multiply_vectors_with_not_equal_size) {
+    TDynamicVector<int> v1(3), v2(4);
+
+    v1[0] = v1[1] = v1[2] = 2;
+    v2[0] = v2[1] = v2[2] = v2[3] = 3;
+
+    ASSERT_ANY_THROW(v1 * v2);
+}