Goals of Testing

Immediate goals
Bug Discovery
Bug prevention

Long term goals

Reliability
Software Testing Quality

Customer Satisfaction
Risk management
Post Implementation goals

Reduced maintenance cost

Improved testing process

IMPORTANT GOALS OF SOFTWARE TESTING

1. Always Identifying the bugs as early as possible.
2. Preventing the bugs in a project and product.
3. Check whether the customer requirements criterion is met or not.
4. And finally main goal of testing to measure the quality of the product and project.

1. Short-term or immediate goals of software testing: -

These goals are the immediate results after performing testing. These
goals even may be set in the individual phases of SDLC. Some of them
are :

a) Bug discovery: The immediate goal about software testing is to

find errors at any stage of software development. More the bugs
discovered at early stage, better will be the success rate about software
testing.

b) Bug prevention: It is the consequent action of bug discovery.

From the behavior and analysis of bugs discovered, everyone in the
software development team gets to learn how to code so that bugs
discovered should not be repeated in later stages or future projects.

Though errors always cannot be prevented to zero, they can be minimized.

In this sense prevention of a bug is a superior goal of testing.

2. Long-term goals of software testing: -

These goals affect the product quality in the deep run, when one cycle of

Software Testing chapter 1 Vaishali Rane Page 1

 the SDLC is over. Some of them are :

a) Quality: Since software is also a product, so its quality is primary

from the user‟s point of view. Thorough testing ensures superior quality.
Quality depends on various factors, such as correctness, integrity,
efficiency, and reliability. So to achieve quality you have to achieve all
the above mentioned factors of Quality.
b) Customer satisfaction: From the user‟s perspective, the prime
goal of software testing is customer satisfaction only. If we want the
client and customer to be satisfied with the software product, then
testing should be complete and thorough.
c) Reliability : is the confidence on software that it will never fail
while working. This also means to gain the confidence of the
customers by providing them, a good quality product.
A complete testing process achieves reliability, reliability enhances the
quality, and quality in turn, increases the customer satisfaction.
4. Risk management : it is done to reduce the failure rate of the product
and manage risk in different situations.

3. Post-implementation goals of software testing: - These goals are

become essential after the product is released. Some of them are
completely discussed below:

a) Reduced maintenance cost: The maintenance cost about any

software product is not its physical cost, as effective software does not
wear out. The only maintenance cost in a software product is its failure
due to errors.
Post- release errors are always costlier to fix, as they are difficult to
detect. Thus, if testing has been done rigorously and effectively, then
the chances about failure are minimized and as a result of this
maintenance cost is reduced.
b) Improved software testing process: A testing process for one
project may not be blooming successful and there may be area for
improvement. Therefore, the bug history and post-implementation
results can be analyzed to find out snags in the present testing
process, which can be determine in future projects.
Thus, the long-term post-implementation goal is to improve the testing
process for future projects.

Software testing is done for many reasons

 Check reliability of the software
 Ensure software does not contain bug which becomes a reason for failure
 Software is in accordance to its specification and meets its requirements.
 User is capable of using the software
 Check software works with other software and hardware it needs to work
with
 Improve quality of software by removing maximum
possible errors or defects from it.

Software Testing chapter 1 Vaishali Rane Page 2

 Objectives of software testing
1. Finding error: Finding defects which may get created by the
programmer while developing the software.
2. Quality improvement: Gaining confidence in and providing
information about the level of quality.
3. Creating good test cases: Good test case is one that has a high
probability of finding undiscovered error.
4. Meets users requirements : To make sure that the end result meets the
business and user requirements.
5. Satisfying Requirements: To ensure that it satisfies the BRS that is
Business Requirement Specification and SRS that is System Requirement
Specifications.
6. To gain the confidence of the customers by providing them a quality product

1.2 Failure, Error, Fault, Defect, Bug Terminology

Fault: It is a condition that causes the software to fail to perform its required function.
Error: Refers to difference between Actual Output and Expected output.
Failure: It is the inability of a system or component to perform required
function according to its specification.
IEEE Definitions
Failure: External behavior is incorrect

Fault: Discrepancy in code that causes a failure.

Error: Human mistake that caused fault
Note: Error is terminology of Developer. Bug is terminology of Tester
The various terms related to software failure with respect to the area of
application are listed as Defect, Variance, Fault, Failure, Problem,
Inconsistency, Error, Feature, Incident, Bug, and Anomaly. Failure: the
inability of a system or component to perform its required functions
within specified performance requirements.
Fault: An incorrect step, process, or data definition in a computer program.
Error: A human action that produces an incorrect result.
An error can be a grammatical error in one or more of the code lines,
or a logical error in carrying out one or more of the client„s requirements.
Not all software errors become software faults. in some cases, the
software error can cause improper functioning of the software. In many
other cases, erroneous code lines will not affect the functionality of the
software as a whole.
A failure is said to occur whenever the external behavior of a system
does not conform to that prescribed in the system specification. A
software fault becomes a software failure only when it is ―activated.
The various terms related to software failure with respect to the area of
application are listed as Defect, Variance, Fault, Failure, Problem,
Inconsistency, Error, Feature, Incident, Bug, and Anomaly.
Problem, error, and bug are probably the most generic terms used.

Software Testing chapter 1 Vaishali Rane Page 3

 Anomaly, incident, and variance don„t sound quite so negative and infer
more unintended operation than an all-out failure.
Fault, failure, and defect tend to imply a condition that„s really severe,
maybe even dangerous. It doesn„t sound right to call an incorrectly
coloured icon a fault. These words also tend to imply blame: ―It„s his
fault that the software failed.
As all the words sound the same they are distinguished based on the
severity and the area in which the software failure has occurred.
When we run a program the error that we get during execution is termed
on the basis of runtime error, compile time error, computational error, and
assignment error.
The error can be removed by debugging, if not resolved leads to a problem
and if the problem becomes large leads to software failure.
A bug can be defined as the initiation of error or a problem due to
which fault, failure, incident or an anomaly occurs.
The program to find the factorial of a number given below lists few errors
problem and failure in a program.

For example
#include<stdio.h>
void main()
{
int i , fact, n;
printf(“enter the number “);
scanf(“%d”,&n);
for(i =1 ;i <=n;i++)
fact = fact * i;
printf (“the factorial of a number is %d”, fact);
}

As in line number 4 the fact is not initialized to 1, so it takes garbage value

and gives a wrong output, this is an example of a bug. If fact is initialized
to zero (fact = 0) than the output will be zero as anything multiplied by
zero will give the output as zero. This is a bug which can be removed by
initializing fact = 1 during initializing. As the fact is declared as integer,
for the
number till 7! will work perfectly. When the number entered is 8, the
output is garbage value as the integer limit is from – 32767 to +32768, so
in declaration change the initialization to long int fact.
1.3 Test Case

IEEE defines test case as “a set of inputs values, execution

preconditions and expected outcomes developed for a particular
objects”
Test case is a well-documented procedure designed to test the functionality of the
feature in the

Software Testing chapter 1 Vaishali Rane Page 4

 system.
A test case is a set of conditions or variables under which a tester will
determine whether a system under test satisfies requirements or works
correctly. For designing the test case, it needs to provide set of inputs and
its corresponding expected outputs.
Parameters:
1. Test case ID: is the identification number given to each test case.
2. Purpose: defines why the case is being designed.
3. Precondition: The prerequisite for running in the system.
4. Input: Actual inputs must be provided, instead of general inputs.
5. Expected outputs: which should be produced when there is no failure?
6. Actual outputs: What is the actual output when the code is executed.
7. Status: If Expected and actual result is same status is
Pass otherwise it is Fail. Two approaches to testing
Software -
Test to pass: A test case producing expected result is called test to pass,
its capabilities are not pushed.
Test to fail/ error forcing: A test case that doesn‟t produce expected
result is called test to fail. Sole purpose is to break the software.

Software Testing chapter 1 Vaishali Rane Page 5