Software testing and its 7 Principles
Software testing is the process of executing a program with the aim of
finding the error. To make our software perform well it should be error-
free. If testing is done successfully it will remove all the errors from the
software. Software Testing is a process of evaluation of the software on
the requirements gathered from system specifications and users.
Software Testing is done at the every phase level in software development
life cycle (SDLC). Can also be done at module level in the program code.
Validation and Verification are two main things that are included in Software
testing. Also, Software Testing is very important else the software bugs can
be dangerous.
Types of Software Testing:-
1. Unit Testing
2. Integration Testing
3. Regression Testing
4. Smoke Testing
5. System Testing
6. Alpha Testing
7. Beta Testing
8. Performance Testing
1. Unit Testing
Unit tests are typically written by developers as they write the code for a
given unit. They are usually written in the same programming language as
the software and use a testing framework or library that provides the
necessary tools for creating and running the tests. These frameworks often
include assertion libraries, which allow developers to write test cases that
check the output of a given unit against expected results. The tests are
usually run automatically and continuously as part of the software build
process, and the results are typically displayed in a test runner or a
continuous integration tool.
Unit testing has several benefits, including:
Early detection and isolation of defects, which can save time and money by
allowing developers to fix errors before they become more costly to fix.
Improved software quality and maintainability, as unit tests help to ensure
that code changes do not break existing functionality.
Increased developer confidence, as developers can make changes to the
code with the knowledge that any errors will be caught by the unit tests.
Facilitation of test-driven development, a software development methodology
in which tests are written before code is written, ensuring that code is written
to meet the requirements.
Overall, Unit testing is an essential part of software development that helps
to ensure the quality and reliability of the software, by identifying errors early
on in the development process.
2. Integration Testing
Integration testing is a software testing method in which individual units or
components of a software application are combined and tested as a group.
The goal of integration testing is to validate that the interactions between
the units or components of the software work as expected and that the
software as a whole functions correctly.
Integration testing is typically performed after unit testing and before
system testing. It is usually done by developers and test engineers, and
it is usually carried out at the module level. Integration tests are typically
automated and run frequently, as part of the software build process, to
ensure that the software remains stable and free of defects over time.
Integration testing is done to verify that different components or modules of
the software work together as expected, and to identify and fix any issues
that might arise due to interactions between the modules. These tests can
include testing different combinations of inputs, testing how the software
handles different types of data, and testing how the software handles
different error conditions.
Integration testing has several benefits, including:
Detection of defects that may not be discovered during unit testing, as it
examines the interactions between components
Improved system design, as integration testing can help identify design
weaknesses
Improved software quality and reliability, as integration testing helps to
ensure that the software as a whole functions correctly.
Facilitation of continuous integration and delivery, as integration testing helps
to ensure that changes to the software do not break existing functionality
Overall, integration testing is an essential part of software development that
helps to ensure the quality and reliability of the software by identifying
defects in the interactions between the units and components of the software
early on in the development process.
3. Regression Testing
Regression testing is software testing method in which previously
developed and tested software is retested after it has been modified or
changed. The goal of regression testing is to ensure that any changes
to the software have not introduced new bugs or broken existing
functionality. It is typically done to verify that changes such as bug fixes,
new features, or updates to existing features have not affected the overall
functionality of the software.
Regression testing is typically performed after unit testing and integration
testing. It is usually done by developers and test engineers and it is usually
carried out by re-running a suite of previously passed test cases. The test
cases are chosen to cover the areas of the software that were affected by
the changes, and to ensure that the most critical functionality of the software
is still working correctly. Regression testing is typically automated and run
frequently, as part of the software build process, to ensure that the software
remains stable and free of defects over time.
Regression testing has several benefits, including:
Early detection and isolation of defects, which can save time and money by
allowing developers to fix errors before they become more costly to fix.
Improved software quality and maintainability, as regression testing helps to
ensure that code changes do not break existing functionality
Increased developer and user confidence, as regression testing helps to
ensure that the software is still working correctly after changes have been
made
Facilitation of continuous integration and delivery, as regression testing helps
to ensure that changes to the software can be safely released.
Overall, regression testing is an essential part of software development that
helps to ensure
4. Smoke Testing
Smoke testing, also known as “Build Verification Testing” or “Build
Acceptance Testing”, is a software testing method in which a minimal set of
tests are run on a new build of a software application to determine if it is
stable enough to proceed with further testing. The goal of smoke testing is to
quickly identify and isolate major issues with the software build, so that
development can be halted if the build is found to be too unstable or
unreliable.
Smoke testing is typically performed early in the software testing process,
after the software has been built and before more extensive testing is done.
It is usually done by developers and test engineers and it is usually carried
out by running a small set of critical test cases that exercise the most
important functionality of the software. Smoke tests are usually automated
and can be run as part of the software build process.
Smoke testing has several benefits, including:
Early identification of major issues, which can save time and money by
allowing developers to fix errors before they become more costly to fix.
Improved software quality and reliability, as smoke testing helps to ensure
that the software is stable enough to proceed with further testing
Facilitation of continuous integration and delivery, as smoke testing helps to
ensure that new builds of the software are stable and reliable before they are
released.
Overall, smoke testing is an important part of software development that
helps to ensure the quality and reliability of the software by identifying major
issues early on in the development process. It helps to quickly determine if a
new build of the software is stable enough to proceed with further testing,
providing increased confidence in the software to the development team and
end-users.
5. System Testing
System testing is a software testing method in which an entire software
system is tested as a whole, in order to ensure that it meets the
requirements and specifications that it was designed for. The goal of system
testing is to validate that the software system behaves as expected when it is
used in its intended environment, and that it meets all the requirements for
functionality, performance, security, and usability.
System testing is typically performed after unit testing, integration testing,
and regression testing. It is usually done by test engineers and it is usually
carried out by running a set of test cases that cover all the functionality of the
software. The test cases are chosen to cover the requirements and
specifications of the software, and to ensure that the software behaves
correctly under different conditions and scenarios. System testing is typically
automated and run frequently, as part of the software build process, to
ensure that the software remains stable and free of defects over time.
System testing has several benefits, including:
Early detection and isolation of defects, which can save time and money by
allowing developers to fix errors before they become more costly to fix.
Improved software quality and reliability, as system testing helps to ensure
that the software meets all the requirements and specifications that it was
designed for.
Increased user confidence, as system testing helps to ensure that the
software behaves correctly when it is used in its intended environment.
Facilitation of acceptance testing, as system testing helps to ensure that the
software is ready for release.
Overall, system testing is an essential part of software development that
helps to ensure the quality and reliability of the software by identifying
defects early on in the development process. It helps to ensure that the
software meets all the requirements and specifications that it was designed
for, providing increased confidence in the software to the development team
and end-users.
There are seven principles in software testing:
1. Testing shows the presence of defects
2. Exhaustive testing is not possible
3. Early testing
4. Defect clustering
5. Pesticide paradox
6. Testing is context-dependent
7. Absence of errors fallacy
• Testing shows the presence of defects: The goal of software testing is
to make the software fail. Software testing reduces the presence of
defects. Software testing talks about the presence of defects and doesn’t
talk about the absence of defects. Software testing can ensure that
defects are present but it cannot prove that software is defect-free. Even
multiple testing can never ensure that software is 100% bug-free. Testing
can reduce the number of defects but not remove all defects.
• Exhaustive testing is not possible: It is the process of testing the
functionality of the software in all possible inputs (valid or invalid)
and pre-conditions is known as exhaustive testing. Exhaustive
testing is impossible means the software can never test at every test
case. It can test only some test cases and assume that the software
is correct and it will produce the correct output in every test case. If
the software will test every test case then it will take more cost,
effort, etc., which is impractical.
• Early Testing: To find the defect in the software, early test activity shall
be started. The defect detected in the early phases of SDLC will be very
less expensive. For better performance of software, software testing will
start at the initial phase i.e. testing will perform at the requirement
analysis phase.
• Defect clustering: In a project, a small number of modules can contain
most of the defects. Pareto Principle to software testing state that 80% of
software defects come from 20% of modules.
• Pesticide paradox: Repeating the same test cases, again and again, will
not find new bugs. So it is necessary to review the test cases and add or
update test cases to find new bugs.
• Testing is context-dependent: The testing approach depends on the
context of the software developed. Different types of software need to
perform different types of testing. For example, the testing of the e-
commerce site is different from the testing of the Android application.
• Absence of errors fallacy: If built software is 99% bug-free but it does
not follow the user requirement then it is unusable. It is not only
necessary that software is 99% bug-free but it is also mandatory to fulfil
all the customer requirements.
Levels of Software Testing
Software Testing is an activity performed to identify errors so that
errors can be removed to obtain a product with greater quality. To
assure and maintain the quality of software and to represents the ultimate
review of specification, design, and coding, Software testing is required.
There are different levels of testing :
1. Unit Testing :
In this type of testing, errors are detected individually from every
component or unit by individually testing the components or units of
software to ensure that if they are fit for use by the developers. It is the
smallest testable part of the software.
2. Integration Testing :
In this testing, two or more modules which are unit tested are integrated
to test i.e. technique interacting components and are then verified if these
integrated modules work as per the expectation or not and interface
errors are also detected.
3. System Testing :
In system testing, complete and integrated Softwares are tested i.e. all
the system elements forming the system is tested as a whole to meet the
requirements of the system.
4. Acceptance Testing :
It is a kind of testing conducted to ensure whether the requirement of
the users are fulfilled prior to its delivery and the software works
correctly in the user’s working environment.
These testing can be conducted at various stages of software development.
The levels of testing along with the corresponding software development
phase is shown by the following diagram –
While performing the software testing, following Testing principles must be
applied by every software engineer:
• The requirements of customers should be traceable and identified by all
different tests.
• Planning of tests that how tests will be conducted should be done long
before the beginning of the test.
• The Pareto principle can be applied to software testing- 80% of all errors
identified during testing will likely be traceable to 20% of all program
modules.
• Testing should begin “in the small” and progress toward testing “in the
large”.
• Exhaustive testing which simply means to test all the possible
combinations of data is not possible.
• Testing conducted should be most effective and for this purpose, an
independent third party is required.