| The first example creates the class Book . En route, the unit test framework is built and the first unit test written. A.1.1 Step 0: Set Up the Unit Test Framework The framework initially is built on a single class, UnitTest , shown in Figure A-1. The source code for UnitTest includes a header file, UnitTest.h , and an implementation file, UnitTest.cpp , as shown in Example A-1. Figure A-1. The class UnitTest 
Example A-1. The class UnitTest UnitTest.h #define UT_ASSERT( condition ) \ assertTrue(condition,__FILE__,__LINE_ _,#condition) class UnitTest { public: virtual ~UnitTest( ) {} virtual void runTest ( ) = 0; protected: void assertTrue (bool condition, const char *file, int line, const char *msg); static int num_test_success ; }; UnitTest.cpp #include <stdio.h> #include <stdlib.h> #include "UnitTest.h" int UnitTest:: num_test_success = 0; void UnitTest:: assertTrue (bool condition, const char *file, int line, const char *msg) { if (!(condition)) { printf("FAILURE!\n"); printf("%s:%d:%s\n", file, line, msg); exit(1); } ++num_test_success; }
UnitTest is an abstract class because it contains the pure virtual function runTest( ) . Actual unit tests will be inherited from UnitTest and must override the runTest( ) method. The function assertTrue( ) should be used to test Boolean conditions in runTest( ) . If the condition is TRUE , the counter num_test_success is incremented. If it is FALSE , the function test_failure() is called. This function reports the file location of the failure and exits. The macro UT_ASSERT() is used in place of direct calls to assertTrue( ) . It uses the preprocessor directives __FILE_ _ and __LINE_ _ to fill in the location of the call at compilation, and the #condition argument allows the conditional expression to be printed in the failure report. Compile UnitTest with the command g++ -c UnitTest.cpp (or your compiler's equivalent command). A.1.2 Step 1: Create a Unit Test Start by creating the unit test class BookTest , as shown in Example A-2. Example A-2. The definition of the class BookTest BookTest.h #include "UnitTest.h" #include "Book.h" class BookTest : public UnitTest { public: void runTest ( ) { Book book("Cosmos"); UT_ASSERT(!strcmp(book.title, "Cosmos")); } };
The unit test BookTest constructs an instance of the class Book , passing the title as an argument, and then tests the value of the book's title attribute. Since the entire implementation of BookTest is present in BookTest.h , no .cpp file is necessary. BookTest is instantiated and run by a class called TestRunner , which also contains the main( ) method for the test framework. Example A-3 shows the implementation of TestRunner . Example A-3. The class TestRunner TestRunner.cpp #include "stdio.h" #include "BookTest.h" int main ( ) { BookTest test; test.runTest( ); printf("SUCCESS!\n"); return 0; }
Compile TestRunner . The compiler will report that it cannot find the file Book.h , and that the class Book is undeclared. No surprise there! So, the next step is to create the most basic implementation of the class Book that will allow the code to compile, as shown in Example A-4. Example A-4. Initial version of the class Book Book.h #include "string.h" class Book { public: Book(const char* title) {} char title[255]; };
The class TestRunner should compile now. The test framework and the unit test are in place. To run the test, link the objects together into an executable: g++ -o TestRunner TestRunner.o UnitTest.o
Execute TestRunner . The following result is reported : FAILURE! BookTest.h:9:!strcmp(book.title, "Cosmos")
This failure demonstrates that the unit test framework is working. Note how the UT_ASSERT() macro captures the file's name and location, as well as the code contents of the test assertion. A.1.3 Step 2: Create a Book BookTest fails because Book does not yet contain the functionality being tested . In this step, the minimum necessary code to achieve unit test success is added. The constructor for Book is changed to set the title attribute, as shown in Example A-5. Example A-5. The class Book with title attribute set by the constructor Book.h #include "string.h" class Book { public: Book(const char* title) { strcpy(this->title, title); } char title[255]; };
A.1.4 Step 3: Test Again The final step is to rebuild the code, re-run the unit test, and see whether the changes produce the desired results. Rebuild and execute TestRunner . The results of BookTest are reported: SUCCESS!
An instance of Book can now be created and given a title. | 