Testing with Boost Test Framework

• A little about boost
  • Boost is
    • A library of advanced tools for C++
    • The organization that supports the development of the library.
  • This serves as a developing grounds for new additions to C++
  • In "Effective C++", Scott Meyers dedicates an entire chapter to why boost is so good.
  • There are several places that claim this works "everywhere", but Windows and Linux are specifically mentioned.
• The Boost Test Framework
  • A useful tutorial is here.
• We are focusing on unit tests
  • I assume that you have a basic "unit" you want to tests.
  • This is a class or an algorithm implementation.
  • It is contained in a separate file, with no main.
• We will be learning the basics of this library.
• A starting example
  • A program that converts temperatures, FtoC and CtoF
  • I have these in this directory
  • What would I want to test?
    • Probably 0 and 100 in each to the other.
    • Some negative values.
  • I could build a vector of input and output values.
    • And just loop through testing each.
  • But let's build a test routine using the boost library.
  • Start with a new file. (FtoCTest1.cpp)
    • Basis Start
      • I need to define the test module
      • I need a couple of header files for the boost library
      • I also need to include my header file.

      • #define BOOST_TEST_MODULE "main"
        #include <boost/test/unit_test.hpp> 
        #include <boost/test/included/unit_test.hpp>
        
        #incldue "FtoC.h" 
        

      • Next declare the start of a test case
        • This is a macro, but you can ignore that.
        • It takes a name, should be identifier like.
        • The test case ends with a second macro.

        • BOOST_AUTO_TEST_SUITE(f_to_c)
          // code goes here
          BOOST_AUTO_TEST_SUITE_END() 

      • Finally let's declare a test case

        • BOOST_AUTO_TEST_CASE(basic_tests) {
              BOOST_TEST(0 == FtoC(32));
              BOOST_TEST(100 == FtoC(212));
              BOOST_TEST(32 == CtoF(0));
              BOOST_TEST(212 == CtoF(100));
          } 

        • A test case is a single set of tests.
        • BOOST_TEST comes several flavors,
          • BOOST_TEST(statement)
          • BOOST_TEST(statement, "failure Message");
          • Plus several others.
      • Note, we do not produce a main, The library will do this for us.
      • To the Makefile I have added

        • FtoCTest1: FtoC.o 

      • Using the included makefile, you should be able make test
        • This will compile a test driver for you.
        • This takes longer than a typical build but don't panic.
      • You can now run your test
        • FtoCTest1 tells us that all tests passed.
        • FtoCTest1 --log_level=all gives us a detailed report of what happened.
          • log_level reference
          • all, error, ...
        • FtoCTest1 --report_level=detailed gives a report on what tests passed.
          • detailed, short, no , confirm ( the default)
      • This is nice, but let's generate some errors
        • Add the following code

        • BOOST_AUTO_TEST_CASE(errors) {
              BOOST_TEST(2 == FtoC(32));
              BOOST_TEST(100 > FtoC(212));
              BOOST_TEST(32 < CtoF(0), "0c is not less than 32f");
              BOOST_TEST(false, " Boolean test failed");
          }
          

        • I called this FtoCTest2.cpp
      • An extension
        • I know that $ \frac{9}{5}c+32 = f $,
          • So if I change c by $\frac{5}{9} $ each time
            • $ \frac{9}{5}(c+n*\frac{5}{9}) + 32 = f_{old} $
            • $ \frac{9}{5}c+n*\frac{5}{9}\frac{9}{5} + 32 = f_{new} $
            • $ \frac{9}{5}c+32 + n = f_{new} $
            • $ f_{old} + n = f_{new} $
            • Or f will change by 1 each time I change c by $\frac{5}{9} $.
        • That inspired this test

          • void DoALoopTest() {
                double dc = 5.0/9.0;
                double df = 1.0;
                double cent;
                double f = 32.0;
                double tmp;
            
                for(cent = 0; cent <= 100; cent += dc) {
                   tmp = CtoF(static_cast<float>(cent));
            
                   BOOST_TEST(f == tmp);
                   f += df;
                }
                return;
            }
            
            BOOST_AUTO_TEST_CASE(Loop_Through_C_test) {
                 DoALoopTest();
            } 

      • I wanted to go the other direction as well (0 to -100)

        • f = 32.0;
          
          for(cent = 0; cent > -100; cent -=dc) {
             tmp = CtoF(static_cast<float>(cent));
             BOOST_TEST(f == tmp, tolerance(0.001) );
             f -= df;
          } 

        • But roundoff errors got me.

          • FtoCTest2.cpp(30): error: in "f_to_c/Loop_Through_C_test":
                    check f == tmp has failed [16 != 15.999999046325684]
            FtoCTest2.cpp(30): error: in "f_to_c/Loop_Through_C_test":
                    check f == tmp has failed [12 != 12.000000953674316]

        • Fortunately the unit test library has a fix.

          • using namespace boost::test_tools;
            ...
            BOOST_TEST(f == tmp, tolerance(0.001) );

      • I called this FtoCTest3.cpp
  • Some additional macros
    • BOOST_TEST_MESSAGE(string) prints a message to the log
    • BOOST_ERROR(string) log a failure, but continue.
    • BOOST_FAIL(string) log a failure and abort the current test.
    • See other.cpp