Testing the DLCL Class

• I have implemented a DLCL class sort of.
  • This is a mock up for testing purposes.
  • It is based on a vector.
  • It will probably have very little aid for implementing your program.
  • But I believe that it will be very useful for testing your program.
  • The code is here
  • For the most part, this code is untested.
• So how would we go about testing the code?
  • main.cpp has a minimal set of tests.
    • Construction
    • Copy by value
    • Insert
    • Size
    • Home
    • Right
    • Data
  • Are these thoroughly tested?
    • I would describe most of them as a test by trial and error.
    • Not systematic.
  • For the most part, they test things because they are needed to test other things.
    • We don't really know that the constructor works, other than it does not fail when we use it.
    • The same is true of the copy constructor.
    • The movement functions are just used.
      • There could be a bug in both move and insert and the test wold be ok.
      • We may always have this problem, but we really should test more thoroughly.
• Where to start?
  • Build the test framework.
  • Copy this from the previous set of notes.
    • DLTest0.cpp
      • Note, I will use a digit at the end as we progress through the tests.
      • Also note, there is no main, the unit test framework generates this for you.
    • I also modified the given Makefile
      • I added DLTest to the OBJS definition
      • A added a dependency for DLTest

      • OBJS =  main DLTest
        ...
        DLTest: DListT.o 

• So what can we test about the constructor?
  • Is the size 0?
  • Do we get the correct error data when we attempt to access the current.
  • Do we get a data error when we attempt to access the current?
    • The last two are probably testing the data access as well.
    • But I don't see a way around it.
  • How do I test for output however?
    • It turns out the library has a very nice tool for this.
    • reference
    • You need to include

    • #include <boost/test/tools/output_test_stream.hpp> 

    • The namespace is rather complex, so this will help too

    • using boost::test_tools::output_test_stream; 

    • Declare a test stream, and use some tests.

    • output_test_stream output;
      string errorMessage = "Error: Attempt to access Empty List.\n";
      

    • Note the \n added to the string, this represents the endl that was printed with the message.
    • Some C++ magic, replace the output stream with the new stream.

    • // change stdout to be the new output buffer
      streambuf * old = cout.rdbuf(output.rdbuf());
      
      // force the error
      string x = aList.Data();
      
      // restore cout.
      cout.rdbuf(old); 

    • Finally, run the output tests

    • BOOST_TEST(output.is_equal(errorMessage,false));
      BOOST_TEST(output.check_length(errorMessage.size(), false));
      BOOST_TEST(!output.is_empty(false)); 

    • Note the parameter bool to all commands,
      • This tells boost not to clear the buffer.
    • The framework uses cout, so make sure you don't have the framework output anything while capturing I/O.
    • Please, not, this is hard to recreate, you probably want to save this somewhere.
  • I can't remember the flag to the get the full report, so I added a case to the Makefile
    • A rule to make test

    • test: DLTest
              DLTest --log_level= all
      # the above line needs a tab a the beginning 

    • And since test is a phony target, I added that to .PHONY
  • While we are here, we should probably test the Left,Right and Home just to make sure that they don't crash.
    • Just to cause a problem I added an abort call to Left.
      • This will cause the program to crash.
      • Unfortunately it is a SIGABRT, not a SIGSEGV
  • Since I wanted to test access I built a BadDataTest function
    • Who knows, I might get a pointer thrown the wrong direction and get some output.
  • DLTest1.cpp
• What can I test for a single insert?
  • That the size and contents are correct.
  • I can also test Left, Right and Home still work.
  • Doing this I decided to abstract BadDataTest to be just DataTest.
    • It will take a the data value and a parameter
  • I think it will be useful to build a list compare
    • I will maintain a vector with the proper values.
    • I will pass that, along with a list in.
    • Compare the sizes.
      • Note the fatal error if they are not the same size.
    • Then compare element wise, using the test routine from above.
  • The development of the CompareLists function leads to some easy other tests.
  • Look at the DLCL_Multiple_InsertTest
  • Look at the DLCL_Random_Insert_Test
  • DLTest2.cpp