init commit

backprop/test/CVS/Entries

@@ -0,0 +1,13 @@
+/Makefile/1.7/Wed Apr 13 15:04:03 2005//
+/coucheTest.cpp/1.2/Wed Apr 13 15:04:03 2005//
+/coucheTest.h/1.2/Wed Apr 13 15:04:03 2005//
+/inputCoucheTest.cpp/1.3/Wed Apr 13 15:04:03 2005//
+/inputCoucheTest.h/1.2/Wed Apr 13 15:04:03 2005//
+/neuroneTest.cpp/1.1.1.1/Wed Apr 13 15:04:03 2005//
+/neuroneTest.h/1.1.1.1/Wed Apr 13 15:04:03 2005//
+/synapseMatrixTest.cpp/1.2/Wed Apr 13 15:04:03 2005//
+/synapseMatrixTest.h/1.2/Wed Apr 13 15:04:03 2005//
+/synapseTest.cpp/1.1/Wed Apr 13 15:04:03 2005//
+/synapseTest.h/1.1/Wed Apr 13 15:04:03 2005//
+/test.cpp/1.5/Wed Apr 13 15:04:03 2005//
+D

backprop/test/CVS/Repository

@@ -0,0 +1 @@
+ia2005/backprop/test

backprop/test/CVS/Root

@@ -0,0 +1 @@
+:pserver:feeling@jfroche.be:/opt/cvsroot

backprop/test/Makefile

@@ -0,0 +1,26 @@
+#Id: Makefile,v 1.4 2005/04/04 22:58:08 jfroche Exp $'
+CFLAGS= -Wall -g -ansi
+CPP= g++
+GCC= gcc
+TESTINCLUDES=-lcppunit -ldl
+all : test
+test : test.o neuroneTest.o coucheTest.o synapseTest.o synapseMatrixTest.o inputCoucheTest.o reseauTest.o ../couche.o ../neurone.o ../synapse.o ../synapseMatrix.o ../inputCouche.o ../Utils.o ../reseau.o ../outputCouche.o ../hiddenCouche.o
+	$(CPP) $(CFLAGS) $(TESTINCLUDES) -o test test.o neuroneTest.o coucheTest.o synapseTest.o inputCoucheTest.o  synapseMatrixTest.o reseauTest.o ../synapse.o  ../neurone.o ../couche.o ../synapseMatrix.o ../inputCouche.o ../Utils.o ../reseau.o ../outputCouche.o ../hiddenCouche.o
+neuroneTest.o : neuroneTest.cpp
+	$(CPP) $(CFLAGS) $(INCLUDES) -c neuroneTest.cpp
+coucheTest.o : coucheTest.cpp
+	$(CPP) $(CFLAGS) $(INCLUDES) -c coucheTest.cpp
+inputCoucheTest.o : inputCoucheTest.cpp
+	$(CPP) $(CFLAGS) $(INCLUDES) -c inputCoucheTest.cpp
+synapseTest.o : synapseTest.cpp
+	$(CPP) $(CFLAGS) $(INCLUDES) -c synapseTest.cpp
+synapseMatrixTest.o : synapseMatrixTest.cpp
+	$(CPP) $(CFLAGS) $(INCLUDES) -c synapseMatrixTest.cpp
+reseauTest.o : reseauTest.cpp
+	$(CPP) $(CFLAGS) $(INCLUDES) -c reseauTest.cpp
+test.o : test.cpp
+	$(CPP) $(CFLAGS) $(INCLUDES) -c test.cpp
+clean : 
+	rm -f test test.o neuroneTest.o coucheTest.o synapseTest.o synapseMatrixTest.o
+cleano : 
+	rm -f *.o

backprop/test/coucheTest.cpp

@@ -0,0 +1,52 @@
+#include "coucheTest.h"
+void CoucheTest::setUp(){
+ // construction du test
+    Output = Couche(10);
+    Input = Couche(5,&Output);
+}
+
+void CoucheTest::tearDown(){
+ // destruction du test
+ //   delete Output;
+ //   delete Input;
+}
+
+void CoucheTest::testInit(){
+ // verifie les assignations du constructeur de la classe
+    CPPUNIT_ASSERT( Input.getNumber()==5 );
+    CPPUNIT_ASSERT( Output.getNumber()==10 );
+    CPPUNIT_ASSERT( Input.getNextCouche() == &Output );
+    CPPUNIT_ASSERT( Output.getNextCouche() == NULL );
+}
+
+void CoucheTest::testGetSynapse(){
+    Input.getSynapse(1,1);
+}
+
+void CoucheTest::testGetSynapseOverflow(){
+    Input.getSynapse(5,10);
+}
+
+void CoucheTest::testGetSynapseUninitialized(){
+    Output.getSynapse(1,1);
+}
+
+void CoucheTest::testNextCouche(){
+ // verifie l assignation du pointeur vers le suivant
+    CPPUNIT_ASSERT( Output.getNextCouche()==NULL );
+    Output.setNextCouche(&Input);
+    CPPUNIT_ASSERT( Output.getNextCouche() == &Input );
+}
+
+void CoucheTest::testOperator(){
+ // verifie l'assignation d'un poid à un neurone
+    CPPUNIT_ASSERT( Input[0].getWeight()==0.0 );
+    Input[0] = 3.0;
+    CPPUNIT_ASSERT( Input[0].getWeight()==3.0 );
+    Input[0].setWeight(4.0);
+    CPPUNIT_ASSERT( Input[0].getWeight()==4.0 );
+}
+
+void CoucheTest::testOperatorThrow(){
+    Input[5];
+}

backprop/test/coucheTest.h

@@ -0,0 +1,32 @@
+#include <cppunit/TestFixture.h>
+#include <cppunit/TestCaller.h>
+#include <cppunit/extensions/TestFactoryRegistry.h>
+#include <cppunit/extensions/HelperMacros.h>
+#include "../couche.h"
+#include "../neurone.h"
+
+class CoucheTest : public CppUnit::TestFixture  {
+      CPPUNIT_TEST_SUITE( CoucheTest );
+      CPPUNIT_TEST( testInit );   // on enregistre les tests à faire dans l ordre
+      CPPUNIT_TEST( testNextCouche );
+      CPPUNIT_TEST( testOperator );
+      CPPUNIT_TEST( testGetSynapse );
+      CPPUNIT_TEST_EXCEPTION( testOperatorThrow, const unsigned int );
+      CPPUNIT_TEST_EXCEPTION( testGetSynapseOverflow, const unsigned int);
+      CPPUNIT_TEST_EXCEPTION( testGetSynapseUninitialized, std::string);
+      CPPUNIT_TEST_SUITE_END();
+private:
+    Couche Input;// un evenement a tester
+    Couche Output;// un deuxieme evenement a tester
+public:
+    void setUp();
+    void tearDown();
+    void testInit();
+    void testNextCouche();
+    void testOperator();
+    void testOperatorThrow();
+    void testGetSynapse();
+    void testActive();
+    void testGetSynapseOverflow();
+    void testGetSynapseUninitialized();
+};

backprop/test/inputCoucheTest.cpp

@@ -0,0 +1,38 @@
+#include "inputCoucheTest.h"
+void InputCoucheTest::setUp(){
+ // construction du test
+    Input2 = InputCouche(10);
+    Input1 = InputCouche(5,&Input2);
+}
+
+void InputCoucheTest::tearDown(){
+ // destruction du test
+ //   delete Output;
+ //   delete Input;
+}
+
+void InputCoucheTest::testActivate(){
+    vector<bool> v;
+    v.push_back(1);
+    v.push_back(0);
+    v.push_back(1);
+    v.push_back(1);
+    Input1.activate(v);
+    CPPUNIT_ASSERT( Input1[0].getWeight() == 1.0  );
+    CPPUNIT_ASSERT( Input1[1].getWeight() == 0.0  );
+}
+
+void InputCoucheTest::testGetChange(){
+  CPPUNIT_ASSERT( Input1.getChange(2,2) == 0.0 );
+}
+
+void InputCoucheTest::testActivateWrongSize(){
+    vector<bool> v(6);
+    Input1.activate(v);
+}
+
+void InputCoucheTest::testCopy(){
+    Input2[2] = 3.2;
+    Input1 = Input2;
+    CPPUNIT_ASSERT( Input1[2].getWeight() == 3.2 );
+}

backprop/test/inputCoucheTest.h

@@ -0,0 +1,25 @@
+#include <cppunit/TestFixture.h>
+#include <cppunit/TestCaller.h>
+#include <cppunit/extensions/TestFactoryRegistry.h>
+#include <cppunit/extensions/HelperMacros.h>
+#include "../inputCouche.h"
+#include <vector>
+
+class InputCoucheTest : public CppUnit::TestFixture  {
+      CPPUNIT_TEST_SUITE( InputCoucheTest );
+      CPPUNIT_TEST( testActivate );
+      CPPUNIT_TEST( testGetChange );
+      CPPUNIT_TEST( testCopy );
+      CPPUNIT_TEST_EXCEPTION( testActivateWrongSize, std::string);
+      CPPUNIT_TEST_SUITE_END();
+private:
+    InputCouche Input1;// un evenement a tester
+    InputCouche Input2;// un deuxieme evenement a tester
+public:
+    void setUp();
+    void tearDown();
+    void testActivate();
+    void testActivateWrongSize();
+    void testGetChange();
+    void testCopy();
+};

backprop/test/neuroneTest.cpp

@@ -0,0 +1,46 @@
+#include "neuroneTest.h"
+void NeuroneTest::setUp(){
+ // construction du test
+    Neur1 = new Neurone();
+    Neur2 = new Neurone(100.0,Neur1);
+}
+
+void NeuroneTest::tearDown(){
+ // destruction du test
+    delete Neur1;
+    delete Neur2;
+}
+
+void NeuroneTest::testInit(){
+ // verifie les assignations du constructeur de la classe
+    CPPUNIT_ASSERT( Neur1->getWeight()==0.0 );
+    CPPUNIT_ASSERT( Neur2->getWeight()==100.0 );
+    CPPUNIT_ASSERT( Neur1->getNextNeurone()==NULL );
+    CPPUNIT_ASSERT( Neur2->getNextNeurone()==Neur1 );
+}
+
+void NeuroneTest::testNextNeurone(){
+ // verifie l assignation du pointeur vers le suivant
+    CPPUNIT_ASSERT( Neur1->getNextNeurone()==NULL );
+    Neur1->setNextNeurone(Neur2);
+    CPPUNIT_ASSERT( Neur1->getNextNeurone()==Neur2 );
+}
+
+void NeuroneTest::testSetWeight(){
+ // verifie l'assignation d'un poid à un neurone
+    CPPUNIT_ASSERT( Neur1->getWeight()==0.0 );
+    Neur1->setWeight(1.0);
+    CPPUNIT_ASSERT( Neur1->getWeight()==1.0 );
+}
+
+void NeuroneTest::testActive(){
+ // verifie l'activation d'un neurone
+    CPPUNIT_ASSERT( Neur2->getWeight()==100.0 );
+    CPPUNIT_ASSERT( Neur2->getState()==true );
+}
+
+void NeuroneTest::testOperotorAssign(){
+    Neurone bla(3.0);
+    bla = 3.0;
+    CPPUNIT_ASSERT(bla.getWeight()==3);
+}

backprop/test/neuroneTest.h

@@ -0,0 +1,27 @@
+#include <cppunit/TestFixture.h>
+#include <cppunit/TestCaller.h>
+#include <cppunit/extensions/TestFactoryRegistry.h>
+#include <cppunit/extensions/HelperMacros.h>
+#include "../couche.h"
+
+
+class NeuroneTest : public CppUnit::TestFixture  {
+      CPPUNIT_TEST_SUITE( NeuroneTest );
+      CPPUNIT_TEST( testInit );   // on enregistre les tests à faire dans l ordre
+      CPPUNIT_TEST( testNextNeurone );
+      CPPUNIT_TEST( testSetWeight );
+      CPPUNIT_TEST( testActive );
+      CPPUNIT_TEST( testOperotorAssign );
+      CPPUNIT_TEST_SUITE_END();
+private:
+    Neurone* Neur1;// un evenement a tester
+    Neurone* Neur2;// un deuxieme evenement a tester
+public:
+    void setUp();
+    void tearDown();
+    void testInit();
+    void testNextNeurone();
+    void testSetWeight();
+    void testOperotorAssign();
+    void testActive();
+};

backprop/test/synapseMatrixTest.cpp

@@ -0,0 +1,36 @@
+#include "synapseMatrixTest.h"
+
+void SynapseMatrixTest::setUp(){
+ // construction du test
+    SynM1 = new SynapseMatrix(3,2);
+    SynM2 = new SynapseMatrix(4,4);
+}
+
+void SynapseMatrixTest::tearDown(){
+ // destruction du test
+    delete SynM1;
+    delete SynM2;
+}
+
+void SynapseMatrixTest::testOperatorIndex(){
+    SynapseMatrix SynM3(3,5);
+    SynM3(0,4) = 2.1;
+    CPPUNIT_ASSERT( SynM3(0,4).getWeight()==2.1 );
+}
+
+void SynapseMatrixTest::testOperatorAssign(){
+    SynapseMatrix SynM4(5,4);
+    SynapseMatrix SynM5(2,2);
+    SynM4(3,2) = 3.2;
+    SynM5 = SynM4;
+    CPPUNIT_ASSERT( SynM5(3,2).getWeight()==3.2 );
+}
+
+void SynapseMatrixTest::testInit(){
+ // verifie les assignations du constructeur de la classe
+    CPPUNIT_ASSERT( SynM1->getLineCount()==3 );
+    CPPUNIT_ASSERT( SynM2->getLineCount()==4 );
+    CPPUNIT_ASSERT( SynM1->getColumnCount()==2 );
+    CPPUNIT_ASSERT( SynM2->getColumnCount()==4 );
+}
+

backprop/test/synapseMatrixTest.h

@@ -0,0 +1,23 @@
+#include <cppunit/TestFixture.h>
+#include <cppunit/TestCaller.h>
+#include <cppunit/extensions/TestFactoryRegistry.h>
+#include <cppunit/extensions/HelperMacros.h>
+#include "../synapseMatrix.h"
+
+
+class SynapseMatrixTest : public CppUnit::TestFixture  {
+      CPPUNIT_TEST_SUITE( SynapseMatrixTest );
+      CPPUNIT_TEST( testInit );   // on enregistre les tests à faire dans l ordre
+      CPPUNIT_TEST( testOperatorIndex );
+      CPPUNIT_TEST( testOperatorAssign );
+      CPPUNIT_TEST_SUITE_END();
+private:
+    SynapseMatrix* SynM1;// une matrice de synapse
+    SynapseMatrix* SynM2;
+public:
+    void setUp();
+    void tearDown();
+    void testInit();
+    void testOperatorIndex();
+    void testOperatorAssign();
+};

backprop/test/synapseTest.cpp

@@ -0,0 +1,25 @@
+#include "synapseTest.h"
+
+void SynapseTest::setUp(){
+ // construction du test
+    Syn1 = new Synapse();
+    Syn2 = new Synapse(100.0);
+}
+
+void SynapseTest::tearDown(){
+ // destruction du test
+    delete Syn1;
+    delete Syn2;
+}
+
+void SynapseTest::testInit(){
+ // verifie les assignations du constructeur de la classe
+    CPPUNIT_ASSERT( Syn1->getWeight()==0.0 );
+    CPPUNIT_ASSERT( Syn2->getWeight()==100.0 );
+}
+
+void SynapseTest::testOperotorAssign(){
+    Synapse bla(3.0);
+    bla = 5.0;
+    CPPUNIT_ASSERT(bla.getWeight()==5.0);
+}

backprop/test/synapseTest.h

@@ -0,0 +1,21 @@
+#include <cppunit/TestFixture.h>
+#include <cppunit/TestCaller.h>
+#include <cppunit/extensions/TestFactoryRegistry.h>
+#include <cppunit/extensions/HelperMacros.h>
+#include "../synapse.h"
+
+
+class SynapseTest : public CppUnit::TestFixture  {
+      CPPUNIT_TEST_SUITE( SynapseTest );
+      CPPUNIT_TEST( testInit );   // on enregistre les tests à faire dans l ordre
+      CPPUNIT_TEST( testOperotorAssign );
+      CPPUNIT_TEST_SUITE_END();
+private:
+    Synapse* Syn1;// une synapse
+    Synapse* Syn2;
+public:
+    void setUp();
+    void tearDown();
+    void testInit();
+    void testOperotorAssign();
+};

backprop/test/test.cpp

@@ -0,0 +1,35 @@
+#include <cppunit/ui/text/TestRunner.h>
+#include <cppunit/TestFixture.h>
+#include <cppunit/TestSuite.h>
+#include <cppunit/TestCaller.h>
+#include <cppunit/TestResult.h>
+#include <cppunit/CompilerOutputter.h>
+#include <cppunit/extensions/TestFactoryRegistry.h>
+#include <cppunit/extensions/HelperMacros.h>
+#include <iostream>
+#include <stdexcept>
+#include "neuroneTest.h"
+#include "coucheTest.h"
+#include "synapseTest.h"
+#include "synapseMatrixTest.h"
+#include "inputCoucheTest.h"
+#include "reseauTest.h"
+using namespace std;
+
+CPPUNIT_TEST_SUITE_REGISTRATION( NeuroneTest ); // teste les neurones
+CPPUNIT_TEST_SUITE_REGISTRATION( CoucheTest ); // teste les couches
+CPPUNIT_TEST_SUITE_REGISTRATION( SynapseTest );
+CPPUNIT_TEST_SUITE_REGISTRATION( SynapseMatrixTest );
+CPPUNIT_TEST_SUITE_REGISTRATION( InputCoucheTest );
+CPPUNIT_TEST_SUITE_REGISTRATION( ReseauTest );
+
+int main(void){
+    CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
+    CppUnit::TextUi::TestRunner runner;
+    runner.addTest( suite );
+
+    runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
+                                                       std::cout ) );
+    bool wasSucessful = runner.run(); // lance les testes
+    return wasSucessful;
+}