Adding tests for exceptions.

Removing include of matrix_helpers.hpp for matrix.hpp testing purposes.

matrix_dummy.cpp

@@ -9,4 +9,5 @@
 
 namespace math { namespace matrix {
   template class matrix<int, 2, 2>;
+  template class row_reference<int, 2>;
 } }

matrix_test.cpp

@@ -8,18 +8,68 @@
 #include <gmock/gmock.h>
 
 #include "matrix.hpp"
-#include "matrix_helpers.hpp"
 
 using matr2i = math::matrix::matrix<int, 2, 2>;
 using matr2 = math::matrix::matrix<double, 2, 2>;
 
+matr2i identity2i() { return matr2i({{{1,0},{0,1}}}); }
+matr2 identity2() { return matr2({{{1,0},{0,1}}}); }
+
 TEST(Matrix, Equality) {
-  using math::matrix::identity;
-  EXPECT_THAT((identity<int, 2>()), matr2i({{{1,0},{0,1}}}));
+  EXPECT_THAT(identity2i(),
+              matr2i({{{1,0},{0,1}}}));
+  EXPECT_THAT(identity2i(),
+              ::testing::Not(matr2i({{{0,1},{0,1}}})));
+}
+
+TEST(Matrix, AtRowBeyondBoundaryThrowsException) {
+  EXPECT_THROW(identity2i().at(2), std::out_of_range);
+}
+
+TEST(Matrix, ConstAtRowBeyondBoundaryThrowsException) {
+  auto const iden = identity2i();
+  EXPECT_THROW(iden.at(2), std::out_of_range);
+}
+
+TEST(Matrix, AtCoordBeyondBoundaryThrowsException) {
+  EXPECT_THROW(identity2i().at(2, 1), std::out_of_range);
+  EXPECT_THROW(identity2i().at(1, 2), std::out_of_range);
+}
+
+TEST(Matrix, ConstAtCoordBeyondBoundaryThrowsException) {
+  auto const iden = identity2i();
+  EXPECT_THROW(iden.at(2, 1), std::out_of_range);
+  EXPECT_THROW(iden.at(1, 2), std::out_of_range);
+}
+
+TEST(Matrix, AtColumnBeyondBoundaryThrowsException) {
+  auto iden = identity2i();
+  auto row = iden[1];
+  EXPECT_THROW(row.at(2), std::out_of_range);
+}
+
+TEST(Matrix, ConstAtColumnBeyondBoundaryThrowsException) {
+  auto const iden = identity2i();
+  auto const row = iden[1];
+  EXPECT_THROW(row.at(2), std::out_of_range);
+}
+
+TEST(Matrix, TransposeOfSquareMatrixRotatesAroundDiagonal) {
+  matr2i mat({{{1, 1}, {2, 2}}});
+  EXPECT_THAT(mat.transpose(),
+              matr2i({{{1, 2}, {1, 2}}}));
+}
+
+TEST(Matrix, TransposeOfMatrixFlipsDimension) {
+  using matr3x2i = math::matrix::matrix<int, 3, 2>;
+  using matr2x3i = math::matrix::matrix<int, 2, 3>;
+  matr3x2i mat({{{1, 1}, {2, 2}, {3, 3}}});
+  EXPECT_THAT(mat.transpose(),
+              matr2x3i({{{1, 2, 3}, {1, 2, 3}}}));
 }
 
 TEST(Matrix, AdditionSumsAllElements) {
-  auto iden = math::matrix::identity<int, 2>();
+  auto iden = identity2i();
   auto result = matr2i({{{2,0},{0,2}}});
   EXPECT_THAT(iden + iden, result);
 }
@@ -30,21 +80,21 @@ TEST(Matrix, DefaultConstructorIsZeros) {
 }
 
 TEST(Matrix, SubtractionDiffsAllElements) {
-  auto zero = matr2i({{{0,0},{0,0}}});
-  auto iden = math::matrix::identity<int, 2>();
-  EXPECT_THAT(iden-iden, zero);
+  auto iden = identity2i();
+  EXPECT_THAT(iden-iden, matr2i());
 }
 
 TEST(Matrix, NegationAltersAllElements) {
-  auto iden = math::matrix::identity<int, 2>();
-  EXPECT_THAT(-iden, matr2i({{{-1,0},{0,-1}}}));
+  EXPECT_THAT(-identity2i(), matr2i({{{-1,0},{0,-1}}}));
+}
+
+TEST(Matrix, MultiplicationAltersAllElements) {
+  EXPECT_THAT(2*identity2(), matr2({{{2.0,0.0},{0.0,2.0}}}));
+  EXPECT_THAT(identity2()*2, matr2({{{2.0,0.0},{0.0,2.0}}}));
 }
 
-TEST(Matrix, _matrix_scaling) {
-  auto iden = math::matrix::identity<double, 2>();
-  EXPECT_THAT(2*iden, matr2({{{2.0,0.0},{0.0,2.0}}}));
-  EXPECT_THAT(iden*2, matr2({{{2.0,0.0},{0.0,2.0}}}));
-  EXPECT_THAT(iden/2.0, matr2({{{0.5,0.0},{0.0,0.5}}}));
+TEST(Matrix, DivisionAltersAllElements) {
+  EXPECT_THAT(identity2()/2.0, matr2({{{0.5,0.0},{0.0,0.5}}}));
 }
 
 TEST(Matrix, MultiplyingSameSizeMatricesProducesSameSize) {
@@ -95,7 +145,7 @@ TEST(Matrix, MatrixConstructableFromVector) {
 }
 
 TEST(Matrix, CanAlterEntireRowInOneExpression) {
-  matr2i A = math::matrix::identity<int, 2>();
+  matr2i A = identity2i();
   matr2i const B = 2 * A;
   A[0] = B[0];
   EXPECT_THAT(A, matr2i({{{2,0},{0,1}}}));