Testing Vs. Inspection
Research Paper
Diala T. Gammoh, Ph.D. Student
Dr. Damla Turgut, Ph.D.
University of Central Florida,
Orlando Florida - 2007
Paper Outline – IEEE paper
format using Latex
Abstract
•
Introduction
•
Description
2.1 Testing
2.2 Inspection
•
Testing Vs. Inspection
•
Conclusion
References
Abstract
This research addresses the use of the
inspection and testing tools, their
definitions, importance, and principles.
There are different perspectives among
companies and organization about the
applicability of each. This research will
address these perspectives.
Introduction
Several studies were done to compare
inspection and testing with the result that the
inspection is more favorable than the testing
but it is not as widely used as testing.
Both inspection and testing have the same
objective to raise the quality of the software
product which will save time and money,
developers should be aware of the advantages
and disadvantages of both of them in order to
make their decisions, this research will help
developers to make such a decision.
Software Testing
Software testing is a process, or a series
of processes, designed to make sure
computer code does what it was designed
to do and that it does not do anything
unintended. Software should be
predictable and consistent, offering no
surprises to users
Software Testing
Testing shouldn’t be done to show that
the program works; rather, you should
start with the assumption that the
program contains errors (a valid
assumption for almost any program) and
then test the program to find as many of
the errors as possible.
“Testing is the process of executing a
program with the intent of finding error”.
Software Testing
To combat the challenges associated with
testing economics, some strategies should
be established before beginning. Two of
the most prevalent strategies include:
1. Black-box – input/output driven testing
2. White-box – logic driven testing
Software Testing
A set of vital testing principles or guidelines were
Identified from “The Art of Software Testing” Book
Principle 1: A necessary part of a test case is a
definition of the expected output or result.
Principle 2: A programmer should avoid attempting
to test his or her own program.
Principle 3: A programming organization should not
test its own programs.
Principle 4: Thoroughly inspect the results of each
test.
Principle 5: Test cases must be written for input
conditions that are invalid and unexpected, as well
as for those that are valid and expected.
Software Testing
A set of vital testing principles or guidelines were
Identified:
Principle 6: Examining a program to see if it does
not do what it is supposed to do is only half the
battle, the other half is seeing whether the program
does what it is not supposed to do.
Principle 7: Avoid throwaway test cases unless the
program is truly a throwaway program.
Principle 8: Do not plan a testing effort under the
tacit assumption that no errors will be found.
Principle 9: The probability of the existence of more
errors in a section of a program is proportional to
the number of errors already found in that section.
Principle 10: Testing is an extremely creative and
intellectually challenging task.
Software Testing
Moving beyond the psychological issues
mentioned in the principles above, the
most important consideration in program
testing is the design and creation of
effective test cases.
The recommended procedure is to develop
test cases using the black-box methods
and then develop supplementary test
cases as necessary with white-box
methods.
Software Testing
Software Testing
From the previous figure, we can see that:
-
-
Defects are generated in each life cycle
production activity.
Injected defects are removed in testing
activities after code is completed.
Not all defects are removed at SHIP.
Software Inspection
We need inspections to remove software
defects at early stages and reduced cost.
Inspections enable us to remove defects
early in the software life cycle and it is
always cheaper to remove defects earlier
than later in the software life cycle.
It is important to note that inspections
are a way to remove defects at a lower
cost, not a way to prevent defects from
occurring.
Software Inspection
Software Inspection
After Inspections, residual defects are
removed during testing, but typically not
all injected defects are removed.
There is still a gap of latent defects that
the users could potentially find. In the
scenario, with inspections, the gap is
smaller, due to the defects removed by
inspections.
This reduced gap represents a quality
improvement in the product delivered to
the users.
Testing Vs. Inspection
We can notice that the inspections provide
significant benefit and the publicly
published data clearly demonstrate their
effectiveness:
- Defects are not discovered all at once
during test or by the users
- The increased labor hours required for
fixing defects after the product is
shipped is often due to loss of project
team knowledge.
- When fewer defects enter test, the
productivity of test improves; i.e., the
costs of test are lower and the time to
complete test is reduced.
Testing Vs. Inspection
It is found that testing is more popular
than inspection. This is partially due to:
1- Views that Inspections can only be
done one way
2- Views that they are not easy to do well
3- Management often views Inspections
as an added cost, when in fact and as
mentioned above will reduce costs
during a project
4- With the advent of each new
development tool or language, the
providers and users seem to believe
that Inspections do not add value or
are less necessary
Conclusion
Because of these and other factors,
shortcuts in Inspection process have been
taken without any proof that the change is
an improvement. Some of these
homegrown changes cause the
Inspections process to be less effective. In
turn the value of what was defined as the
Inspection process is diminished.
Conclusion
Inspections may not be the most
enjoyable engineering task compared to
designing and coding.
Also, programmers are very possessive
about artifacts they create. Inspections
are labor intensive and low tech, but they
do work.
Conclusion
Since Inspections do work, they should be
used until the software community has
truly evolved to a position where the
software process and environment permit
fewer defects to be generated when
software products are created.
References
−
−
−
−
−
−
The Art of Software Testing Book, Glenford J.
Myers ,2004
High Quality Low Cost Software Inspections
Book, Ronald A. Radice,2002
Inspection vs. Testing, Gustav Evertsson, 2002
Improvement of design specifications with
inspection and testing, Winkler, D.; Riedl, B.;
Biffl, S.,IEEE 2005
http://www.featuredrivendevelopment.com/nod
e/566
http://en.wikipedia.org/wiki/Main_Page