Ø Strategic approach to Software Testing
Software
testing should be done systematically. It
should be not like that every developer can test the software. Earlier thinking about software testing was
that any of the persons especially code builders can perform the software
testing best. Well, this may not be
correct option. Software is present
everywhere. Since humans are imperfect,
so does software. Some of major failures
of software are Intel Pentium Floating Point Division bug of 1994, NASA Mass
Polar Lander of 1999, Patriot Missile Defence System of 1991 and Y2K Problem
etc. So, there must be separate group of
people apart from coders that can test the software for flaws/errors.
Ø What is Software Testing?
Software Testing may be regarded as:-
1.
It is the process of demonstrating that
errors are absent.
2.
It is the process of establishing
confidence that a program does what it is supposed to do.
3.
The purpose of testing is to show that a
program performs its main functions correctly.
However,
testing is finding and removing errors. We
should start with the assumption that the program contains errors and then test
the program to find as many of the errors as possible.
Therefore,
“Testing is the process of executing a
program with the intent of finding errors”.
Ø Why should Software be tested?
Launching
of software without testing may lead to cost higher than that of testing it
first, especially into service where human safety is involved. Therefore in life critical systems, economics
must not be the prime consideration while deciding whether a product should be
released to a customer. The date of
releasing the software in the market is very important decision.
Ø Who should do the Software Testing?
Many organizations
have made a distinction between development and testing phase by making different
people responsible for each phase. Success
in testing is finding errors. Therefore,
most of the times, testing persons are different from development persons for
the overall benefit of the system. Developers
provide guide lines during testing, however, while responsibility is owned by
testing persons.
Ø What should we test in Software?
We should
test programs responses to every possible input. It means, we should test all valid and
invalid inputs. For an instance a
program needs 8 bit integers as input. Total
possible combinations are many. If only
one second is required to execute one set of inputs, it may take 18 hours to
test all combinations. Practically,
inputs are more than two and size is also more than 8 bits.
If the
path of a program can be traced this problem of testing software becomes quite
easy it is the root of coding. A program
may have many paths. The important point
to be considered here is that we just cannot complete whole possible tests
(i.e.) exhaustive testing is not feasible.
Ø Some terminologies related to Software
Testing
Institute
of Electronics and Electrical Engineers (IEEE) has developed some of the
standard terminologies which are stated as:
Error/Mistake: An error is simply a
mistake. This can be anything like
syntax error or misunderstanding of specifications. Sometimes there are logical errors.
Bug:
The mistake in the coding section done by the developers is
termed as a bug. The fault in the source
code is termed as a bug.
Fault:
A fault is the representation of an error; here representation
is the mode of expression, such as narrative test, data flow diagrams, ER
Diagrams, source code etc., fault is same as defect.
Failure:
A failure occurs when a fault executes. Failure is dynamic. Program needs to be executed for a failure to
occur.
Test, Test Case and Test Suite: Test case describes an input
description and an expected output description.
Test Case:
Test case is single test done & it is the basic part of
whole testing.
Test Suite:
The set of test cases is called a test suite. We may have test suite of all possible test
case. Any combination of test cases may generate
a test suite.
Alpha Testing: The alpha testing is conducted
at the developers’ site by a customer. It
may be started when formal testing process is near completion.
Beta Testing: These tests are conducted by
the customers/end users at their sites. It
is conducted in a real environment that cannot be controlled by the developer.
Unit Testing: In simple words, unit testing
is testing of individual modules/units of the whole software according to the
prepared test cases separately. The various reasons could be.
1.
The size
of single module is small enough that we can locate an error fairly easily.
2.
The module
is small enough that one can attempt to test it in some demonstrably exhaustive
fashion.
3.
Configuring
interactions of multiple errors in widely different parts of the software are
eliminated.
Integration Testing: After performing the unit
testing, it is much required that the software must be checked as integrated
software. Here tree different
integration approaches are performed.
1.
Top-Down Integration: It is integration from the top position to
the bottom.
2.
Bottom-Up Integration: This integration goes from bottom to the top
level.
3.
Sandwich Integration: This goes from both top and bottom and ends
at center.
System Testing: The combination of all the
testing namely alpha, beta and unit testing makes system testing; hence whole
of the software is being tested at different environments. The major things checked here are usability;
security, compatibility, dependability and the proper documentation are checked
in system testing. No part of testing is
left here.
2 comments:
The overall outlook for engineers of any specialty is good with an expected growth of 11%. Currently there are 1.5 million engineers working in a wide variety of specialties. Civil, mechanical, industrial, and civil engineering degrees hold the four top positions number of engineers employed.
Post a Comment