added layer tests and updated tests configs

CMakeLists.txt

@@ -48,19 +48,9 @@ target_link_libraries(ga.out PRIVATE helpers game genetic matrix machine ${SDL2_
 
 enable_testing()
 
-file(GLOB MATRIX_TEST "./tests/matrix_test.cc")
-add_executable(matrix_test ${MATRIX_TEST})
-target_link_libraries(matrix_test matrix GTest::gtest_main)
-
-file(GLOB CHROMOSOME_TEST "./tests/chromosome_test.cc")
-add_executable(chromosome_test ${CHROMOSOME_TEST})
-target_link_libraries(chromosome_test helpers genetic ${SDL2_LIBRARIES} GTest::gtest_main)
-
-file(GLOB POPUALTION_TEST "./tests/population_test.cc")
-add_executable(population_test ${POPUALTION_TEST})
-target_link_libraries(population_test genetic helpers ${SDL2_LIBRARIES} GTest::gtest_main)
+file(GLOB TESTS "tests/*_test.cc")
+add_executable(tests ${TESTS})
+target_link_libraries(tests matrix helpers genetic machine ${SDL2_LIBRARIES} GTest::gtest_main GTest::gmock)
 
 include(GoogleTest)
-gtest_discover_tests(matrix_test)
-gtest_discover_tests(chromosome_test)
-gtest_discover_tests(population_test)
+gtest_discover_tests(tests)

clean.sh

@@ -1,3 +1,3 @@
 #!/usr/bin/sh
 
-rm -rf *.a *.o *.out
+rm -rf *.a *.o *.out ./build/

machine/layer.cpp

@@ -1,24 +1,39 @@
 #include "layer.h"
+#include "../helpers/utils.h"
 #include <stdexcept>
 
 using Matrices::Matrix;
+using std::invalid_argument;
+using Utils::random;
 
 namespace Layers {
   unsigned int size;
   Matrix *values;
 
-  InputLayer::InputLayer(unsigned int size){
+  Layer::Layer(unsigned int size){
     this->size = size;
+    this->values = new Matrix(1, size);
+    for(unsigned int i = 0; i < size; i++)
+      this->values->update_value(i, 0, random(-1, 1));
   }
 
-  void InputLayer::set_node_values(Matrix *values){
-    if(values->get_width() != 1 || values->get_height() != this->size)
-      throw std::invalid_argument("Invalid values dimensions!");
+  Layer::Layer(Matrix *values){
+    if(values->get_width() != 1)
+      throw invalid_argument("Invalid values dimensions!");
 
+    this->size = values->get_height();
     this->values = values;
   }
 
-  InputLayer::~InputLayer(){
+  Matrix* Layer::get_values(){
+    return this->values;
+  }
+
+  Layer::~Layer(){
     delete this->values;
   }
+
+  unsigned int Layer::get_size() const {
+    return this->size;
+  }
 }

machine/layer.h

@@ -5,16 +5,13 @@
 using Matrices::Matrix;
 
 namespace Layers{
-
-  struct Layer{
-    virtual void set_node_values(Matrix *values);
-  };
-
-  class InputLayer: Layer{
+  class Layer{
     public:
-      InputLayer(unsigned int size);
-      void set_node_values(Matrix *values);
-      ~InputLayer();
+      Layer(unsigned int size);
+      Layer(Matrix *values);
+      Matrix* get_values();
+      unsigned int get_size() const;
+      ~Layer();
     private:
       unsigned int size;
       Matrix *values;

machine/machine.cpp

@@ -1,5 +1,18 @@
 #include "machine.h"
+#include "layer.h"
+#include <vector>
 
-using Machine::NN;
+using Layers::Layer;
+using std::vector;
 
-NN::NN(){}
+namespace Machine {
+  vector<Layer*>* layers;
+
+  void NN::add_layer(unsigned int size){
+    layers->push_back(new Layer(size));
+  }
+
+  void NN::add_layer(Layer* layer){
+    layers->push_back(layer);
+  }  
+}

machine/machine.h

@@ -1,13 +1,21 @@
 #pragma once
 
+#include <iostream>
+#include <vector>
+#include "layer.h"
+
+using Layers::Layer;
+using std::vector;
+
 namespace Machine {
 
   class NN{
 
     public:
-      NN();
+      void add_layer(unsigned int size);
+      void add_layer(Layer* layer);
 
     private:
-
+      vector<Layer*>* layers = new vector<Layer*>;
   };
 };

tests/gene_test.cc

@@ -1,16 +1,18 @@
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 #include <stdexcept>
+#include "../genetic/gene.h"
 
 using ::testing::AllOf;
 using ::testing::Ge;
 using ::testing::Le;
 using Genes::Gene;
+using std::invalid_argument;
 
 namespace {
   TEST(CreationTest, CreateGeneTest){
     Gene *gene = new Gene();
-    ASSERT_THAT(gene->get_gene_value(), AllOf(Ge(-1), Le(1));
+    ASSERT_THAT(gene->get_gene_value(), AllOf(Ge(-1), Le(1)));
     delete gene;
   }
 
@@ -23,13 +25,13 @@ namespace {
 
   TEST(UpdateTest, MutationLesserThanZeroRateTest){
     Gene *gene = new Gene();
-    EXPECT_THROW({ gene->mutate(-1); }, std::invalid_argument);
+    EXPECT_THROW({ gene->mutate(-1); }, invalid_argument);
     delete gene;
   } 
 
   TEST(UpdateTest, MutationGreaterThanOneRateTest){
     Gene *gene = new Gene();
-    EXPECT_THROW({ gene->mutate(2); }, std::invalid_argument);
+    EXPECT_THROW({ gene->mutate(2); }, invalid_argument);
     delete gene;
   }
 
@@ -61,7 +63,6 @@ namespace {
 
     delete gene;
     delete copy_gene;
-
   }
 }
 

tests/layer_test.cc

@@ -0,0 +1,48 @@
+#include "../machine/layer.h"
+#include <stdexcept>
+#include "../matrix/matrix.h"
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+using Matrices::Matrix;
+using Layers::Layer;
+using std::invalid_argument;
+using ::testing::AllOf;
+using ::testing::Ge;
+using ::testing::Le;
+
+namespace {
+
+  TEST(CreationTest, CreateLayerBySizeTest){
+    Layer* layer = new Layer(3);
+    ASSERT_EQ(layer->get_size(), 3);
+    ASSERT_EQ(layer->get_values()->get_width(), 1);
+    ASSERT_EQ(layer->get_values()->get_height(), 3);
+    delete layer;
+  }
+
+  TEST(CreationTest, CreateLayerByMatrixTest){
+    Matrix* values = new Matrix(1, 3);
+    Layer* layer = new Layer(values);
+
+    ASSERT_EQ(layer->get_size(), 3);
+    ASSERT_EQ(layer->get_values(), values);
+    ASSERT_EQ(layer->get_values()->get_width(), 1);
+    ASSERT_EQ(layer->get_values()->get_height(), 3);
+
+    delete layer;
+  }
+
+  TEST(CreationTest, CreateLayerWithInvalidWidhtTest){
+    Matrix* values = new Matrix(3, 3);
+    EXPECT_THROW({ new Layer(values); }, invalid_argument);
+    delete values;
+  }
+
+  TEST(ValuesTest, GetValuesTest){
+    Layer *layer = new Layer(1);
+    ASSERT_THAT(layer->get_values()->get_position_value(0, 0), AllOf(Ge(-1), Le(1)));
+    delete layer;
+  }
+
+}