testing
Post on 17-Feb-2017
131 Views
Preview:
TRANSCRIPT
Testing
Indu SharmaHOD(CSE)
CPTC,Rajsamand
Validation & Verification• Verification• “Are we building the product right?”• Ensure software meet specification (error-free)• Process of determining whether output of one
phase of development conforms to its previous phase.
• Validation• “Are we building the right product?”• Ensure software meets customer’s needs• Process of determining whether a fully developed
system conforms to its SRS document
Verification versus Validation• Verification is concerned with phase containment of errors• Validation is concerned about the final product to be error
free
Validation & Verification• There are two major approaches for verification and
validation:• Software Inspections, and• Software Testing
Inspection Vs. Testing
Production
Requirements Artifacts
Design Artifacts
Code Artifacts
Unit Testing Integration Testing
System Testing
Acceptance Testing
Inspection
Testing
Inspection Vs. Testing
• Testing is an activity that can be generally performed only on code. Inspection is a more general activity that can be applied to any work product, including code.• Testing can evaluate the product working
whereas inspection can only examine the static documents.• Testing is a dynamic technique for V&V whereas
inspection is a static technique.
What is Software Testing• Glen Myers• Testing is the process of executing a program with the intent of
finding errors• Software Testing is the process of evaluating a system by
manual or automated means to verify that it satisfies specified requirements in terms of SRS, functionality, and performance.• The software is tested under normal and abnormal
conditions• Normal conditions->positive testing->normal data• Abnormal conditions->Negative testing->abnormal data
Testing Objectives
1. Testing is a process of executing a program with the intent of finding error.
2. A good test case (a document which defines each test case in detail) is one that has a high probability of finding an as-yet-undiscovered error.
3. A successful test is one that uncovers an as-yet-undiscovered error.
Testing Principles
1. All tests should be traceable to customer requirements.
2. Tests should be planned long before testing begins.
3. The Pareto principle applies to software testing.• Typically, 80% of the errors come from 20% of
the modules. The problem, of course, is to isolate these suspect components and to thoroughly test them.
Testing Principles4. Testing should begin “in the small” and progress toward
testing “in the large.”5. Exhaustive testing is not possible.6. To be most effective, testing should be conducted by an
independent third party.
Testing Process
A Software Testing Strategy or Levels of Testing• Large systems are built of sub-systems which are
built of modules which are composed of procedures and functions. The testing process should therefore proceed in stages where testing is carried out incrementally in conjunction with system implementation.• The sequence of testing activities:• Unit Testing• Integration Testing• System Testing• Acceptance Testing
A Software Testing Strategy or Levels of Testing• The relation of the errors introduced in different phases, and
different levels of testing can be shown as:Client Needs Acceptance TestingRequirements System TestingDesign - Integration TestingCode - Unit Testing
Testing Methodologies• There are two basic methodologies to testing:• Functional Testing Or Black Box Testing Or Behavioral Testing• Structural Testing or White Box Testing Or Glass Box Testing
Black-Box Testing
• In Black-Box testing the structure of the program is not considered. Test cases are decided solely on the basis of the requirements or specifications of the program or module, and the internals of the module or the program are not considered for selection of test cases.• In black-box testing, the tester only knows the
inputs that can be given to the system and what output the system should give.
White-Box Testing• It is concerned with testing the implementation of the
program. • The intent of this testing is not to exercise all the different
input or output conditions but to exercise the different programming structures and data structures used in the program.
Black-Box Testing Techniques
• The most obvious black-box testing is exhaustive testing, which is impractical and infeasible.• The set of test cases includes all the possible inputs
to the program.• Even for small program the no. of elements in the
input domain can be extremely large (i.e. it is not practical due to cost constrains.)• One other criteria for generating test cases is to
generate them randomly. This strategy has little chances of resulting in a set of test cases that is close to optimal (i.e. that detects maximum errors with minimum test cases.)
Black-Box Testing Techniques• There are no formal rules for designing test case
for Black-box testing.• However, there are a number of techniques that
can be used to select test cases that have been found to be very successful in detecting errors. Some of these techniques are:• Equivalence class partitioning• Boundary value analysis• Cause-Effect Graphing
Equivalence Class Partitioning• Input values to a program are partitioned into equivalence
classes. • Partitioning is done such that:
• program behaves in similar ways to every input value belonging to an equivalence class.
Why define equivalence classes?• Test the code with just one representative value from each
equivalence class: • as good as testing using any other values from the equivalence
classes.
Equivalence Class Partitioning• How do you determine the equivalence classes?• examine the input data. • few general guidelines for determining the equivalence classes
can be given
Equivalence Class Partitioning• If the input data to the program is specified by a range of
values:• e.g. numbers between 1 to 5000. • one valid and two invalid equivalence classes are defined.
1 5000
Equivalence Class Partitioning• If input is an enumerated set of values: • e.g. {a,b,c}• one equivalence class for valid input values • another equivalence class for invalid input values should be
defined.
Example• A program reads an input value in the range of 1 and 5000:• computes the square root of the input number
SQRT
Example (cont.)• There are three equivalence classes: • the set of negative integers, • set of integers in the range of 1 and 5000, • integers larger than 5000.
1 5000
Example (cont.)• The test suite must include:• representatives from each of the three equivalence classes:• a possible test suite can be:
{-5,500,6000}.
1 5000
Boundary Value Analysis
• Whereas equivalence class partitioning deals with selecting representative values from within the class, BVA forces on testing of values from the boundary of the class.• Some typical programming errors occur: • at boundaries of equivalence classes • might be purely due to psychological factors.
• Programmers often fail to see:• special processing required at the boundaries of
equivalence classes.
Boundary Value Analysis• Programmers may improperly use < instead of <= • Boundary value analysis:• select test cases at the boundaries of different equivalence
classes.
Example• For a function that computes the square root of an integer in
the range of 1 and 5000:• test cases must include the values: {0,1,5000,5001}.
1 5000
Cause Effect graphing
• Equivalence classes and boundary value analysis consider each input separately.• To handle multiple inputs, different combinations
of equivalent classes of inputs can be tried.• Number of combinations can be large – if n
different input conditions such that each condition is valid/invalid, total: 2n Test Cases.• Cause effect graphing helps in selecting
combinations as input conditions.
CE-graphing
• Identify causes and effects in the system• Cause: distinct input condition which can be true or
false• Effect: distinct output condition (T/F)
• Identify which causes can produce which effects; can combine causes• Causes/effects are nodes in the graph and arcs
are drawn to capture dependency; and/or are allowed
Steps to create cause-effect graph• Draw causes on the LHS• Draw effects on the RHS• Draw logical relationship between causes and effects • as edges in the graph.
• Extra nodes can be added • to simplify the graph
Drawing Cause-Effect Graphs
A BIf A then B
AC
If (A and B)then CB
Drawing Cause-Effect Graphs
AC
If (A or B) then CB
AC
If (not(A and B)) then CB
~
Drawing Cause-Effect Graphs
AC
If (not (A or B))then CB
A BIf (not A) then B
~
~
CE-graphing
• From the CE graph, can make a decision table• Lists combination of conditions that set different
effects• Together they check for various effects
• Decision table can be used for forming the test cases. • Each combinations of conditions in the table for
an effect is a test-case.
CE graphing: Example
• A bank database which allows two commands• Credit acc# amt• Debit acc# amt
• Requirements• If credit and acc# valid, then credit• If debit and acc# valid and amt less than balance, then
debit• Invalid command - message
Example…• Causes• C1: command is credit• C2: command is debit• C3: acc# is valid• C4: amt is valid
• Effects• E1: Print “Invalid command”• E2: Print “Invalid acct#”• E3: Print “Debit amt not valid”• R4: Debit account• E5: Credit account
Example…
Example…
# 1 2 3 4 5C1 0 1 x x 1C2 0 x 1 1 xC3 x 0 1 1 1C4 x x 0 1 1E1 1E2 1E3 1E4 1E5 1
White-Box Testing Techniques• There are different approaches to structural testing. One of
these approaches is the control-flow based testing. It includes:• Statement coverage testing• Branch coverage testing• Path coverage testing
Control Flow Based Technique• In this technique the control flow graph of a program is
considered and coverage of various aspects of the graph are specified as criteria.
• What is Control Flow Graph?
Control Flow Graph (CFG)• A control flow graph (CFG) describes: • the sequence in which different instructions of a program get
executed. • the way control flows through the program.
Control Flow Graph (CFG)
Control Flow Graph (CFG)
Control Flow Graph• Considers the program as control flow graph• Nodes represent code blocks – i.e. set of statements
always executed together• An edge (i,j) represents a possible transfer of control
from i to j • Assume a start node and an end node• A path is a sequence of nodes from start to end• An edge must terminate at a node, even if the
node does not represent any procedural statement.
Control Flow Graph• Predicate Nodes: Each node that contains a condition is called
predicate node.• Regions: Areas bounded by edges and nodes are called
regions. When counting regions, we include the area outside the graph as a region.
Statement Coverage Testing• Statement coverage methodology:• design test cases so that every statement in a program is
executed at least once. • The principal idea: • unless a statement is executed, we have no way of knowing if an
error exists in that statement
Statement Coverage Testing• Observing that a statement behaves properly for one input
value:• no guarantee that it will behave correctly for all input values.
Statement Coverage Testing
• Criterion: Each statement is executed at least once during testing • i.e. set of paths executed during testing should include all
nodes• Limitation: does not require a decision to evaluate to false
if no else clause• E.g. : abs (x) { if ( x>=0) x = -x; return (x); }• This program is clearly wrong.• The set of test cases {x = 0} achieves 100% statement coverage,
but error not detected
Branch Coverage Testing
• Criterion: Each edge should be traversed at least once during testing• i.e. each decision must evaluate to both true and false
during testing• Branch coverage implies statement coverage• The problem with branch coverage comes if a decision
has many conditions in it (i.e. consisting of a Boolean Expression with Boolean operators and/or). In such situations, a decision can evaluate to true and false without actually exercising all the conditions.
Branch Coverage Testing
• For eg., consider the following function that checks the validity of data item. The data item is valid if it lies between 0 and 100.int check(x)int x;{
if((x>=0) && (x<=200))check=true;else check=false;
}• The module is incorrect, as it is checking x<=200 instead of 100
(perhaps a typing mistake made by the programmer). • Suppose the module is tested with the following set of test cases:
{x=5,x=-5}. The branch coverage criteria will be satisfied for this module by this set.
Path Coverage Testing• More general coverage criteria is one that
requires all possible paths in the control flow graph be executed during testing.• Path coverage implies Branch coverage• The problem with this criterion is that programs
that contain loops can have an infinite number of possible paths.• Furthermore, not all paths in a graph may be
“feasible” in the sense that there may not be any inputs for which the path can be executed.
Path Coverage Testing• Now, the question arises:• How do we know how many paths to look for?• The answer is by computing the Cyclomatic Complexity.
Cyclomatic Complexity
• Cyclomatic complexity is a software metric that provides a quantitative measure of the logical complexity of a program. • When used in the context of the path coverage
testing method, the value computed for cyclomatic complexity defines the number of independent paths and provides us with an upper bound for the number of tests that must be conducted to ensure that all statements have been executed at least once.
Cyclomatic Complexity
• Independent Path: An independent path is any path through the program that introduces at least one new set of processing statements or a new condition.• When stated in terms of Flow Graph, and
independent path must move along at least one edge that has not been traversed before the path is defined.
Cyclomatic Complexity• For eg. A set of independent paths for the flow graph is:• Path1: 1-10• Path2: 1-2-3-4-5-9-1-10• Path3: 1-2-3-6-7-9-1-10• Path4: 1-2-3-6-8-9-1-10• Note that each path introduces a new age. The path:
1-2-3-4-5-9-1-2-3-6-8-9-1-10• Is not considered to be an independent path because
it simply a combination of already specified paths and does not traverse any new age.
Cyclomatic Complexity• Note that the path set is not unique. In fact, a no. of different
path sets can be derived for a given procedural design.• How do we know how many paths to look for?• The answer is by computing the Cyclomatic Complexity.
Cyclomatic Complexity• Cyclomatic complexity is compounded in one
of three ways:1. The number of regions of the flow graph
correspond to the Cyclomatic Complexity.2. Cyclomatic Complexity, V(G), for a flow graph, G, is
defined as V(G)=E-N+2Where E is the no. of flow graph edges, N is the no. of flow graph nodes.
3. Cyclomatic Complexity, for a flow graph G is also defined as V(G)=P+1Where P is the number of predicate nodes contained in the flow graph G.
Cyclomatic Complexity• Now refer to Flow Graph:
1. The flow graph has 4 regions.2. V(G)=10 edges – 8 nodes + 2 = 43. V(G)=3 predicate nodes + 1 = 4
top related