UnitTesting.cpp

/****************************************************************************************************************/
/*                                                                                                              */
/*   Flood: An Open Source Neural Networks C++ Library                                                          */
/*   www.cimne.com/flood                                                                                        */
/*                                                                                                              */
/*   U N I T   T E S T I N G   C L A S S                                                                        */
/*                                                                                                              */
/*   Roberto Lopez                                                                                              */ 
/*   International Center for Numerical Methods in Engineering (CIMNE)                                          */
/*   Technical University of Catalonia (UPC)                                                                    */
/*   Barcelona, Spain                                                                                           */
/*   E-mail: rlopez@cimne.upc.edu                                                                               */ 
/*                                                                                                              */
/****************************************************************************************************************/

#include<iostream>
#include<fstream>
#include<string>
#include<sstream>
#include <time.h>

#include"UnitTesting.h"

namespace Flood
{

// GENERAL CONSTRUCTOR


UnitTesting::UnitTesting(void)
{
   message = "";

   tests_count = 0;
   tests_passed_count = 0;
   tests_failed_count = 0;

   display = true;
}


// DESTRUCTOR
 

UnitTesting::~UnitTesting(void)
{ 
}


// METHODS

// int get_tests_count(void) method


int UnitTesting::get_tests_count(void)
{
   return(tests_count);
}


// int get_tests_passed_count(void) method


int UnitTesting::get_tests_passed_count(void)
{
   return(tests_passed_count);
}


// int get_tests_failed_count(void) method


int UnitTesting::get_tests_failed_count(void)
{
   return(tests_failed_count);
}


// std::string& get_message(void) method


std::string& UnitTesting::get_message(void)
{
   return(message);
}


// bool get_display(void) method


bool UnitTesting::get_display(void)
{
   return(display);
}


// void set_tests_count(int) method


void UnitTesting::set_tests_count(int new_tests_count)
{
   // Control sentence (if debug)      

   #ifdef _DEBUG 

   if(new_tests_count < 0)
   {
      std::cout << "Flood Warning: UnitTesting class." << std::endl 
                << "void set_tests_count(int) method." << std::endl
                << "Test count must be equal or greater than zero." << std::endl;
   }

   #endif

   tests_count = new_tests_count;
}


// void set_tests_passed_count(int) method


void UnitTesting::set_tests_passed_count(int new_tests_passed_count)
{
   // Control sentence (if debug)      

   #ifdef _DEBUG 

   if(new_tests_passed_count < 0)
   {
      std::cout << "Flood Warning: UnitTesting class." << std::endl 
                << "void set_tests_passed_count(int) method." << std::endl
                << "Test pased count must be equal or greater than zero." << std::endl;
   }

   #endif

   tests_passed_count = new_tests_passed_count;
}


// void set_tests_failed_count(int) method


void UnitTesting::set_tests_failed_count(int new_tests_failed_count)
{
   // Control sentence (if debug)      

   #ifdef _DEBUG 

   if(new_tests_failed_count < 0)
   {
      std::cout << "Flood Warning: UnitTesting class." << std::endl 
                << "void set_tests_failed_count(int) method." << std::endl
                << "Test failed count must be equal or greater than zero." << std::endl;
   }
   #endif    
   
   tests_failed_count = new_tests_failed_count;
}


// void set_message(const std::string&) method


void UnitTesting::set_message(const std::string& new_message)
{
   message = new_message;
}


// void set_display(bool) method


void UnitTesting::set_display(bool new_display)
{
   display = new_display;
}


// void assert_true(bool, std::string) method


void UnitTesting::assert_true(bool condition, const std::string& error_message)
{
   tests_count++;

   if(condition)
   {
      tests_passed_count++;
   }
   else
   {
      message += "void assert_true(bool, const std::string&) method failed\n";
      message += error_message;
      tests_failed_count++;
   }
}


// void assert_false(bool) method


void UnitTesting::assert_false(bool condition, const std::string& error_message)
{
   tests_count++;

   if(!condition)
   {
      tests_passed_count++;
   }
   else
   {
      message += "void assert_false(bool, const std::string&) method failed\n";
      message += error_message;
      tests_failed_count++;
   }
}


// void print_results(void) method


void UnitTesting::print_results(void)
{
   run_test_case();

   std::cout << message << std::endl;

   std::cout << "Tests run: " << tests_count << std::endl;
   std::cout << "Tests passed: " << tests_passed_count << std::endl;
   std::cout << "Tests failed: " << tests_failed_count << std::endl;

   if(tests_failed_count == 0)
   {
      std::cout << "Test case OK." << std::endl;
   }
   else
   {
      std::cout << "Test case NOT OK: " << tests_failed_count << " tests failed."  << std::endl;
   } 
}

}

// Flood: An Open Source Neural Networks C++ Library.
// Copyright (C) 2005-2010 Roberto Lopez 
//
// This library is free software; you can redistribute it and/or
// modify it under the s of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

---