Assertions, verification, validation

In this section we will consider how to formalize theories on the correct "state" of a program, and use that information for active testing within the code.

Later we will also consider the exception-handling aspect of program reliability.

Program reliability

• Obviously the goal is to develop fault-free programs, but we must acknowledge and plan for the possibility of errors

• To provide reliability, we should include thorough run-time error checking within the program

• One part of checking is the verification of all input data (e.g. taking all input as strings and converting it to appropriate data types, and testing ranges)

• Another common part is testing the values used for loop counters and exit conditions - to prevent infinite loops

• Yet another part is testing that all array accesses are made within valid bounds for the array

Assertions in C++

• The cassert library provides a special testing feature, called the assert function

• assert is used to double-check conditions you're certain must be true

  Example: a square root routine might assume it is never called with a negative value:

  double squareroot(double x)
  {
     // test for negative values of x
     assert(x >= 0.0);
     // now continue with regular code
     ...
  }
  

  Assert tests the listed condition, and if it evaluates to false assert terminates the program with an error message (the message usually indicates which assert statement caused termination)

• The reasoning behind the assert function is that, in many cases, it is preferable to abort the program rather than continue with clearly erroneous data.

  The drawback is that the use of assertions does slow down the execution speed of the program. In practice, assertions are usually used during until program testing and debugging is complete. Appropriate corrections and error handling are added to the software to ensure correct behaviour, and after testing is completed the assertions are turned off.

Example assertions

Some examples might include:

• Testing for divide-by-zero

  assert(den != 0);
  x = num / den;
  

• Testing for impossible data values

  assert(age >= 0);
  cout << "The age of the car is " << age << " years";
  

• Testing array bounds

  assert((index >= 0) && (index < ARRSIZE));
  cout << myarray[index] << endl;
  

Loop verification

• A common use for assertions is to test conditions you're sure must be true before entering a loop and after leaving a loop

• These are often used to test the values for loop counters before a loop starts (i.e. to avoid infinite loops)

  assert(y != 0);
  for (x = 0; x < M; x = x + y) {
     // body of loop
  }
  

• The assertions are also often used as a safeguard against seemingly impossible values once the loop finishes

  for (...) {
     sum = ...
  }
  assert(sum >= 0);
  

• Very similar practices can be used for function calls - i.e. assertions about what must be true before and after the call

Pre- and post-conditions

• Pre-conditions are assertions about the current state of the program immediately before entering a loop or a function

  assert(x >= 0);
  y = sqrt(x);
  

• Post-conditions are assertions about the state of the program immediately after a loop or function completes

  // create a backup copy of a string
  strcpy(backup, mystring);
  
  // call foo to do something based on mystring
  foo(mystring);
  
  // check that foo didn't change string
  assert(strcmp(backup, mystring) == 0);
  

Turning off the assert statements

To turn off assertions, the easiest approach is to add the following line of code above the #include <assert> statement:

// automatically disable assertion checking
#define NDEBUG

#include <cassert>