Testing the Queue Class

• I want to build a test suite for the queue class.
• Start with the basic outline from before

  • #define BOOST_TEST_MODULE  DLCL_Tests
    #include <boost/test/unit_test.hpp>
    #include <boost/test/included/unit_test.hpp>
    
    // new to catch output
    #include <boost/test/tools/output_test_stream.hpp>
    
    #include "QueueT.h"
    
    #include <vector>
    
    // so we can use the elements of the output_test_stream without
    // a horrid list of namespaces
    using boost::test_tools::output_test_stream;
    using namespace std; 

  • There are some pieces added.
• I added a bit the queue as well
  • An attempt to run Front on an empty queue will produce an error message.
  • "Invalid Front on Empty Queue"
  • An attempt run Dequeue on an empty queue will throw an out_of_range exception.
• Let's start with a basic constructor test.
  • What conditions should be true in a new queue?
    • Size, IsEmpty, IsFull

  • BOOST_AUTO_TEST_CASE (Queue_Constructor) {
        QueueT q;
    
        BOOST_TEST(q.IsEmpty());
        BOOST_TEST(not q.IsFull());
        BOOST_TEST(q.Size() == 0);
    
        return;
    } 

• How about a simple enqueue/dequeue a single element.
  • This was one of our base cases, enqueue/dequeue on an empty queue.
  • Look at Simple_ENQUEUE_DEQUEUE
• Testing output
  • reference
  • You can capture output intended for the standard output.
  • This is some c++ stream magic

  • output_test_stream output;
    streambuf * old = cout.rdbuf(output.rdbuf());
    
    // force the error
    Queue q;
    q.Front();
    
    // restore cout.
    cout.rdbuf(old);
              

  • After this runs, output contains the value of anything written to cout.
  • There five member functions to an output_test_stream
    • is_empty(bool flush)
    • check_length(size_t len, bool flush)
    • is_equal(string s, bool flush)
    • match_pattern(bool flush)
    • flush()
  • In each case, the flush flag indicates to clear the stream.
  • We will not discuss match_pattern

  • BOOST_AUTO_TEST_CASE(Front_Error_Test) {
        output_test_stream output;
        streambuf * old = cout.rdbuf(output.rdbuf());
    
        string goodMessage = "Invalid Front on Empty Queue\n";
        tring badMessage = "invalid front on empty q\n";
        QueueT q;
        q.Front();
    
        cout.rdbuf(old);
    
        BOOST_TEST(not output.is_empty(false));
    
        BOOST_TEST(output.check_length(goodMessage.size(),false));
        BOOST_TEST(output.check_length(badMessage.size(),false), "This should fail");
        BOOST_TEST(output.is_equal(goodMessage,false));
        BOOST_TEST(output.is_equal(badMessage,false));
    
        output.flush();
    
        return;
    } 

• Exceptions
  • reference
  • BOOST_REQUIRE_TROW(call, exception_type)
  • BOOST_CHECK_TROW(call, exception_type)
  • BOOST_WARN_TROW(call, exception_type)
    • See this reference for warning levels.
  • These check for exceptions
    • You expect call to throw an exception of exception_type
    • Reports error if not exception is thrown
    • Aborts the test routine if the wrong exception is thrown.
      • It does this via an exception so it can be caught.
  • BOOST_*_NO_THROW(call)
    • Opposite of above.
  • BOOST_*_EXCEPTION (call, exception, routine to test exception)