54.1 Introduction to Program Testing 54.9 Cyclomatic Complexity - flow graph 54.2 Overview of Program Testing 54.10 Cyclomatic Complexity - Metric and Test Cases 54.3 Testability 54.11 Black box testing 54.4 Test Utopia 54.12 Input to a Black Box Test 54.5 From Program Test to Program Proof 54.13 Example of Equivalence Partitioning (1) 54.6 White box testing 54.14 Example of Equivalence Partitioning (2) 54.7 Basis Path Testing 54.15 Regression testing 54.8 Cyclomatic Complexity - flow chart

 

54.1.  Introduction to Program Testing
Contents   Up Previous Next   Slide Annotated slide Aggregated slides    Subject index Program index Exercise index 

Program testing is the process of executing a program with the intent of finding errors A good test is one that has a high probability of finding an error Program testing cannot show the absence of errors It can only show if errors are present It is possible to write the tests before the program Test driven development

54.2.  Overview of Program Testing
Contents   Up Previous Next   Slide Annotated slide Aggregated slides    Subject index Program index Exercise index 

Types of test White box test Black box test Levels of test Unit test Integration test System test Repetition of test Regression test

54.3.  Testability
Contents   Up Previous Next   Slide Annotated slide Aggregated slides    Subject index Program index Exercise index 

Observability The outcome of a test execution must be approachable and visible Controllability The program input and state must be controllable prior to test execution Decomposability A program must be broken into parts which can be tested individually Understandability The specification of the program - what is the correct program behaviour - must be available

54.4.  Test Utopia
Contents   Up Previous Next   Slide Annotated slide Aggregated slides    Subject index Program index Exercise index 

Total test All possible combinatoric combinations of commands and expressions should be executed relative to the control structures in a program Even in small programs, the number of paths in a total test is very large In many programs, there is no upper limit on the number of paths in a total test

54.5.  From Program Test to Program Proof
Contents   Up Previous Next   Slide Annotated slide Aggregated slides    Subject index Program index Exercise index 

Program proofs Prove that the postcondition of the program is true, given that The precondition of the program is true The program terminates Relies on A decoration of the program with mathematical assertions which reflect the intended result of the program relative to the initial program assumptions Proof rules for all constructs of the program

54.6.  White box testing
Contents   Up Previous Next   Slide Annotated slide Aggregated slides    Subject index Program index Exercise index 

Wish list to white box testing: All independent paths of a program unit has been executed at least once All logical branches have been exercised All loops and datastructures have been exercised at their boundaries

54.7.  Basis Path Testing
Contents   Up Previous Next   Slide Annotated slide Aggregated slides    Subject index Program index Exercise index 

Overall approach Draw a flow chart of the program unit Abstract the flow chart to a flow graph Find the cyclomatic complexity (say n) - a test metric Identify n test cases that follow each of the independent paths

54.8.  Cyclomatic Complexity - flow chart
Contents   Up Previous Next   Slide Annotated slide Aggregated slides    Subject index Program index Exercise index 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

  public static void P(){
    // Entry 
    while(A){
      X;
      if (B){
        if(C)
          Y;
        else 
          Z;
        // p
      } else{
         V; W;
      }
      // q
    }
    // Exit: r
  }

Figure 54.1    The flow chart for the program unit P

54.9.  Cyclomatic Complexity - flow graph
Contents   Up Previous Next   Slide Annotated slide Aggregated slides    Subject index Program index Exercise index 

Figure 54.2    The accompanying flow chart for the program unit P

54.10.  Cyclomatic Complexity - Metric and Test Cases
Contents   Up Previous Next   Slide Annotated slide Aggregated slides    Subject index Program index Exercise index 

The cyclomatic complexity of the program unit P is determined Can be done the flow graph - by use of simple graph theory concepts The number of regions of the flow graph   or The number of predicate notes + 1 Construct a test case for each independent path The test case should follow the control-flow of the path

54.11.  Black box testing
Contents   Up Previous Next   Slide Annotated slide Aggregated slides    Subject index Program index Exercise index 

Wish list of black box testing Locate functional errors Do we get the expected result on given inputs to a method? Locate interface errors Are data passed correctly to and from methods? Locate efficiency errors Is the method fast enough?

54.12.  Input to a Black Box Test
Contents   Up Previous Next   Slide Annotated slide Aggregated slides    Subject index Program index Exercise index 

Include boundary representatives Such as empty collections and full collections Include one or more representative for invalid input Typecheck and use of preconditions may eliminate this need

54.13.  Example of Equivalence Partitioning (1)
Contents   Up Previous Next   Slide Annotated slide Aggregated slides    Subject index Program index Exercise index 

1
2
3
4

  // Exchange element i and j in table
  public void SwapElements<T>(T[] table, int i, int j){
    ...
  }

Equivalence partitions - all combinations of table table is empty, table is singular, table with two or more elements i and j One of i and j are outside the bounds of table i inside and j outside, i outside and j inside, both are outside Both i and j are inside the bounds of table i < j, i > j, i = j

54.14.  Example of Equivalence Partitioning (2)
Contents   Up Previous Next   Slide Annotated slide Aggregated slides    Subject index Program index Exercise index 

1
2
3
4
5
6
7

  // Find the largest element in table in between the indexes from and to.
  // Return the index of this element.
  // Precondition: 0 <= from <= to <= table.Length-1
  public int FindMaxIndex<T>(T[] table, int from, int to)
    where T: IComparable<T> {
       ...
  }

Equivalence partitions - all combinations of table table is empty/singular, largest element is first in table, largest element is last in table, largest element is in mid of table, all elements in table are equal from and to from and to are located at the boundaries of table from = to from = to - 1 from and to are not close to each other

54.15.  Regression testing
Contents   Up Previous Next   Slide Annotated slide Aggregated slides    Subject index Program index Exercise index 

After modification of part P in a program Q Test that the part P works correctly Test that the overall program Q has not been affected by the modification

After modification of part P in a program Q Test that the part P works correctly Test that the overall program Q has not been affected by the modification