unit_base.h

Go to the documentation of this file.

#ifndef UNIT_BASE_GROUP
#define UNIT_BASE_GROUP
 
/*
*  Name   : unit_base tools for unit testing
*  Author : Chris Koeritz
**
* Copyright (c) 2009-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
*/
 
 
#include <basis/astring.h>
#include <basis/contracts.h>
#include <basis/enhance_cpp.h>
#include <basis/mutex.h>
#include <structures/string_table.h>
 
namespace unit_test {
 
// these macros can be used to put more information into the test name.
// using these is preferable to calling the class methods directly, since
// those cannot print out the original version of the formal parameters a
// and b for the test; the macros show the expressions that failed rather
// than just the values.
// note that these require the calling object to be derived from unit_base.
#define UNIT_BASE_THIS_OBJECT (*this)
  // the macro for UNIT_BASE_THIS_OBJECT allows tests to use a single unit_base object by
  // changing the value of UNIT_BASE_THIS_OBJECT to refer to the proper object's name.
#define ASSERT_EQUAL(a, b, test_name) { \
  BASE_FUNCTION(func); \
  UNIT_BASE_THIS_OBJECT.assert_equal(a, b, function_name, test_name, basis::astring(#a) + " must be equal to " + #b); \
}
#define ASSERT_INEQUAL(a, b, test_name) { \
  BASE_FUNCTION(func); \
  UNIT_BASE_THIS_OBJECT.assert_not_equal(a, b, function_name, test_name, basis::astring(#a) + " must be inequal to " + #b); \
}
#define ASSERT_TRUE(a, test_name) { \
  BASE_FUNCTION(func); \
  UNIT_BASE_THIS_OBJECT.assert_true(a, function_name, test_name, basis::astring(#a) + " must be true"); \
}
#define ASSERT_FALSE(a, test_name) { \
  BASE_FUNCTION(func); \
  UNIT_BASE_THIS_OBJECT.assert_false(a, function_name, test_name, basis::astring(#a) + " must be false"); \
}
// pointer versions for nicer syntax.
#define ASSERT_NULL(x, y) ASSERT_FALSE(x, y)
#define ASSERT_NON_NULL(x, y) ASSERT_TRUE(x, y)
 
class unit_base : public virtual basis::nameable
{
public:
  unit_base();
  virtual ~unit_base();
 
  DEFINE_CLASS_NAME("unit_base");
 
  int total_tests() const;  
  int passed_tests() const;  
  int failed_tests() const;  
 
  void assert_equal(const basis::hoople_standard &a, const basis::hoople_standard &b,
      const basis::astring &class_name, const basis::astring &test_name,
      const basis::astring &diagnostic_info);
  void assert_not_equal(const basis::hoople_standard &a, const basis::hoople_standard &b,
      const basis::astring &class_name, const basis::astring &test_name,
      const basis::astring &diagnostic_info);
 
  void assert_equal(const basis::byte_array &a, const basis::byte_array &b,
      const basis::astring &class_name, const basis::astring &test_name,
      const basis::astring &diagnostic_info);
  void assert_not_equal(const basis::byte_array &a, const basis::byte_array &b,
      const basis::astring &class_name, const basis::astring &test_name,
      const basis::astring &diagnostic_info);
 
  void assert_equal(int a, int b,
      const basis::astring &class_name, const basis::astring &test_name,
      const basis::astring &diagnostic_info);
  void assert_not_equal(int a, int b,
      const basis::astring &class_name, const basis::astring &test_name,
      const basis::astring &diagnostic_info);
 
  void assert_equal(double a, double b,
      const basis::astring &class_name, const basis::astring &test_name,
      const basis::astring &diagnostic_info);
  void assert_not_equal(double a, double b,
      const basis::astring &class_name, const basis::astring &test_name,
      const basis::astring &diagnostic_info);
 
  void assert_equal(const void *a, const void *b,
      const basis::astring &class_name, const basis::astring &test_name,
      const basis::astring &diagnostic_info);
 
  void assert_not_equal(const void *a, const void *b,
      const basis::astring &class_name, const basis::astring &test_name,
      const basis::astring &diagnostic_info);
 
  void assert_true(bool result, 
      const basis::astring &class_name, const basis::astring &test_name,
      const basis::astring &diagnostic_info);
  void assert_false(bool result, 
      const basis::astring &class_name, const basis::astring &test_name,
      const basis::astring &diagnostic_info);
  
  // these two methods can be used in an ad hoc manner when using the above
  // assert methods is not helpful.  the "test_name" should be provided
  // like above, but the "diagnostic_info" can be phrased in any way needed
  // to describe the pass or fail event.
  void record_pass(const basis::astring &class_name,
          const basis::astring &test_name,
          const basis::astring &diagnostic_info);
  void record_fail(const basis::astring &class_name,
          const basis::astring &test_name,
          const basis::astring &diagnostic_info);
 
  int final_report();
 
private:
  basis::mutex c_lock;  
  int c_total_tests;  
  int c_passed_tests;  
  structures::string_table c_successful;  
  structures::string_table c_failed;  
 
  void write_cppunit_xml();
 
  void count_successful_test(const basis::astring &class_name, const basis::astring &test_name);
 
  void count_failed_test(const basis::astring &class_name, const basis::astring &test_name, const basis::astring &diag);
 
  void record_successful_assertion(const basis::astring &class_name, const basis::astring &test_name,
      const basis::astring &assertion_name);
 
  void record_failed_object_compare(const basis::hoople_standard &a,
      const basis::hoople_standard &b, const basis::astring &class_name,
      const basis::astring &test_name, const basis::astring &assertion_name);
  void record_failed_int_compare(int a, int b,
      const basis::astring &class_name, const basis::astring &test_name,
      const basis::astring &assertion_name);
  void record_failed_double_compare(double a, double b,
      const basis::astring &class_name, const basis::astring &test_name,
      const basis::astring &assertion_name);
  void record_failed_tf_assertion(bool result, bool expected_result,
      const basis::astring &class_name, const basis::astring &test_name,
      const basis::astring &assertion_name);
  void record_failed_pointer_compare(const void *a, const void *b,
      const basis::astring &class_name, const basis::astring &test_name,
      const basis::astring &assertion_name);
};
 
} //namespace.
 
#endif