THE EIGHT BASIC PRINCIPLES OF TESTING

Following are eight basic principles of testing:

Define the expected output or result.
1. Do not test your own programs.
2. Inspect the results of each test completely.
3. Include test cases for invalid or unexpected conditions.
4. Test the program to see if it does what it is not supposed to do as well as what it is supposed
to do.
5. Avoid disposable test cases unless the program itself is disposable.
6. Do not plan tests assuming that no errors will be found.
7. The probability of locating more errors in any one module is directly proportional to the
number of errors already found in that module.

Let us look at each of these points.

1) DEFINE THE EXPECTED OUTPUT OR RESULT
More often that not, the tester approaches a test case without a set of predefined and
expected results. The danger in this lies in the tendency of the eye to see what it wants to see.
Without knowing the expected result, erroneous output can easily be overlooked. This problem
can be avoided by carefully pre-defining all expected results for each of the test cases. Sounds
obvious? You would be surprised how many people miss this pint while doing the self-
assessment test.
2) DO NOT TEST YOUR OWN PROGRAMS
Programming is a constructive activity. To suddenly reverse constructive thinking and begin the
destructive process of testing is a difficult task. The publishing business has been applying this
idea for years. Writers do not edit their own material for the simple reason that the work is
their baby and editing out pieces of their work can be a very depressing job. The attitudinal l
problem is not the only consideration for this principle. System errors can be caused by an
incomplete or faulty understanding of the original design specifications; it is likely that the
programmer would carry these misunderstandings into the test phase.
3) INSPECT THE RESULTS OF EACH TEST COMPLETELY
As obvious as it sounds, this simple principle is often overlooked. In many test cases, an after-
the-fact review of earlier test results shows that errors were present but overlooked because
no one took the time to study the results.
4) INCLUDE TEST CASES FOR INVALID OR UNEXPECTED CONDITIONS
Programs already in production often cause errors when used in some new or novel fashion.
This stems from the natural tendency to concentrate on valid and expected input conditions
during a testing cycle. When we use invalid or unexpected input conditions, the likelihood of
boosting the error detection rate is significantly increased.
5) TEST THE PROGRAM TO SEE IF IT DOES WHAT IT IS NOT SUPPOSED TO DO AS WELL AS
WHAT IT IS SUPPOSED TO DO
It is not enough to check if the test produced the expected output. New systems, and especially
new modifications, often produce unintended side effects such as unwanted disk files or
destroyed records. A thorough examination of data structures, reports, and other output can
often show that a program is doing what is not supposed to do and therefore still contains
errors.
6) AVOID DISPOSABLE TEST CASES UNLESS THE PROGRAM ITSELF IS DISPOSABLE
Test cases should be documented so they can be reproduced. With a non-structured approach
to testing, test cases are often created on-the-fly. The tester sits at a terminal, generates test
input, and submits them to the program. The test data simply disappears when the test is
complete. Reproducible test cases become important later when a program is revised, due to
the discovery of bugs or because the user requests new options. In such cases, the revised
program can be put through the same extensive tests that were used for the original version.
Without saved test cases, the temptation is strong to test only the logic handled by the
modifications. This is unsatisfactory because changes which fix one problem often create a host
of other apparently unrelated problems elsewhere in the system. As considerable time and
effort are spent in creating meaningful tests, tests which are not documented or cannot be
duplicated should be avoided.
7) DO NOT PLAN TESTS ASSUMING THAT NO ERRORS WILL BE FOUND
Testing should be viewed as a process that locates errors and not one that proves the program
works correctly. The reasons for this were discussed earlier.
8) THE PROBABILITY OF LOCATING MORE ERRORS IN ANY ONE MODULE IS DIRECTLY
PROPORTIONAL TO THE NUMBER OF ERRORS ALREADY FOUND IN THAT MODULE
At first glance, this may seem surprising. However, it has been shown that if certain modules or
sections of code contain a high number of errors, subsequent testing will discover more errors
in that particular section that in other sections. Consider a program that consists of two
modules, A and B. If testing reveals five errors in module A and only one error in module B,
module A will likely display more errors that module B in any subsequent tests. Why is this so?
There is no definitive explanation, but it is probably due to the fact that the error-prone module
is inherently complex or was badly programmed. By identifying the most bug-prone modules,
the tester can concentrate efforts there and achieve a higher rate of error detection that if all
portions of the system were given equal attention. Extensive testing of the system after
modifications have been made is referred to as regression testing.

OUTSOURCED SOFTWARE testing process, if not subject to the basic principles, can land the
tester into trouble. Haphazard testing results in chaos and incorrect judgement. Here are some
of the software testing rules which when abided, can result in overall success:
1) Definition of expected results
Mostly, the testers do not have their results defined and do not chalk out the most
expected outcome. Without knowing this, errors in the output might miss the testers eye.
Pre-defining the expected results can solve this problem for each of the test cases. Though
this might sound ridiculous, many of the testers are known to skip this step and land
eventually in no-mans land.
2) Dont test your own programmes
Software programming is actually a creative process while testing is a negative and destructive
process. To ward off creativity and then focus on the negative process of testing, is a difficult
switch. This writers analogy is similar too, as writers do not edit their own written material but
get it edited through an editor.
Additionally, it might happen that the programmer has had a faulty understanding of the
software design. In this case, it is most likely that the programmer would initiate the same
application with a faulty outlook leading to incorrect results.
3) Check each and every test thoroughly
In many test cases, a hindsight review of earlier test results in software testing service shows
that errors which were present were often overlooked because the results were not thoroughly
studied.
4) Test cases should be used for unexpected conditions
Programmes which are already under production when used in an innovative fashion cause a
great deal of errors and bugs because most testers test the applications using valid and
expected input conditions only. Using invalid or unexpected input conditions, the chances of
detecting errors increase manifold.
5) Test the programme for what it is expected to do and what it is not
Along with the test of whether the programme is giving the desired results, software testing
services should also include testing of unintended side-effects. These include unwanted disk
files or tarnished records. Examination of data structures and reports will reveal that the output
can show what it is not supposed to do though it does what it is expected to do.
6) Software testing should be done with the intent of finding errors
Software testing services include testing processes that locate errors and not with the intent of
rendering the program as perfect. The probability of locating more errors is directly
proportional to the number of errors already found.