Unit 1.pptx

1. INTRODUCTION TO TESTING – WHY AND WHAT:
1.1 Why is testing necessary?
1.2 What is testing?
1.3 Role of Tester
1.4 Overview of STLC

2. SOFTWARE TESTING LIFE CYCLE - V MODEL:
• 2.1 V-Model
• 2.2 SDLC vs STLC
• 2.3 Different stages in STLC
• 2.4 Document templates generated in different phases of STLC
• 2.5 Different levels of testing
• 2.6 Different types of testing: Functional Testing
• 2.7 API Testing
• 2.8 Usability Testing
• 2.9 Exploratory Testing
• 2.10 Ad-hoc Testing
• 2.11 Static Testing:
• Static techniques,
• Reviews,

• 3. BASICS OF TEST DESIGN TECHNIQUES:
• 3.1 Various test categories
• 3.2 Test design techniques for different categories of tests
• 3.3 Designing test cases using MS-Excel.

WHY IS TESTING NECESSARY?
• Testing is necessary because we all make mistakes.
• Some of those mistakes are unimportant, but some of them are expensive or dangerous
• We need to check everything and anything we produce because things can always go wrong - humans make
mistakes all the time - it is what we do best!
• Because we should assume our work contains mistakes, we all need to check our own work.
• However, some mistakes come from bad assumptions and blind spots
• So we may not notice the flaws in what we have done.
• Ideally, we should get someone else to check our work - another person is more likely to spot the flaws.

Software systems context
• Testing Principle (1) - Testing is context dependent Testing is done differently in different contexts.
For example, safety-critical software is tested differently from an e-commerce site.
• An error on a bill, a delay when waiting for a credit card to process and a website that did not load correctly
are common examples of problems that may happen because of software problems.
• Not all software systems carry the same level of risk and not all problems have the same impact when they
occur.
• A risk is something that has not happened yet and it may never happen;

• Some of the problems can be costly and damaging - with loss of money, time or business reputation and
even may result in injury or death.
• For example, suppose a user interface has typographical defects. Does this matter
• If my personal family-tree website has my maternal grandmother's maiden name spelt wrong?
• If the company website has some spelling mistakes in the text
• If a software program miscalculates pesticide application quantities

Causes of software defects
• If someone makes an error or mistake in using the software, this may lead directly to a problem - the
software is used incorrectly and so does not behave as we expected.
• However, people also design and build the software and they can make mistakes during the design and build.
• These mistakes mean that there are flaws in the software itself. These are called defects or sometimes bugs
or faults.
• When the software code has been built, it is executed and then any defects may cause the system to fail to
do what it should do (or do something it shouldn't), causing a failure.
• Not all defects result in failures; some stay dormant in the code and we may never notice them.

• Our mistakes are also important because software systems and projects are complicated.
• Many interim and final products are built during a project, and people will almost certainly make mistakes
and errors in all the activities of the build.
• Some of these are found and removed by the authors of the work, but it is difficult for people to find their
own mistakes while building a product.
• Defects in software, systems or documents may result in failures, but not all defects do cause failures.
• We could argue that if a mistake does not lead to a defect or a defect does not lead to a failure

• Additionally, we are more likely to make errors when dealing with perplexing technical or business problems,
complex business processes, code or infra-structure, changing technologies, or many system interactions.
• our brains can only deal with a reasonable amount of complexity or change when asked to deal with more
our brains may not process the information we have correctly.
• Failures can also be caused by environmental conditions as well
for example, a radiation burst, a strong magnetic field, electronic fields, or pollution could cause faults in
hardware or firmware.
• Those faults might prevent or change the execution of software.
• Failures may also arise because of human error in interacting with the software, perhaps a wrong input value
being entered or an output being misinterpreted.
• Finally, failures may also be caused by someone deliberately trying to cause a failure in a system malicious
damage.

we have to consider defects and failures arising from:
• errors in the specification, design and implementation of the software and system;
• errors in use of the system;
• environmental conditions;
• intentional damage;
• potential consequences of earlier errors, intentional damage, defects and failures.

• We can see that requirement 1 is implemented correctly –
we understood the customer's requirement, designed correctly to meet that requirement, built correctly to
meet the design, and so deliver that requirement with the right attributes
• Requirement 2 is fine until the software is coded, when we make some mistakes and introduce defects.
• The defects introduced in requirement 3 are harder to deal with;
• we built exactly what we were told to but unfortunately the designer made some mistakes
• Unless we check against the requirements definition, we will not spot those defects during testing.
• When we do notice them they will be hard to fix because design changes will be required.

• The defects in requirement 4 were introduced during the definition of the requirements;
• The product has been designed and built to meet that flawed requirements definition.
• If we test the product meets its requirements and design, it will pass its tests but may be rejected by the
user or customer.
• Defects reported by the customer in acceptance test or live use can be very costly.
• Unfortunately, requirements and design defects are not rare;
• assessments of thousands of projects have shown that defects introduced during requirements and design
make up close to half of the total number of defects.

What is the cost of defects?
• considering the impact of failures arising from defects we have not found, we need to consider the impact of
when we find those defects.
• The cost of finding and fixing defects rises considerably across the life cycle;
• if an error is made and the consequent defect is detected in the requirements at the specification stage,
then it is relatively cheap to find and fix.
• The specification can be corrected and reissued.
• Similarly if an error is made and the consequent defect detected in the design at the design stage then the
design can be corrected and reissued with relatively little expense.
• If however a defect is introduced in the requirement specification and it is not detected until acceptance
testing or even once the system has been implemented then it will be much more expensive to fix.
• defect in the requirements may well propagate into several places in the design and code;
• all the testing work done-to that point will need to be repeated in order to reach the confidence level in the
software that we require.

• It is quite often the case that defects detected at a very late stage, depending on how serious they are, are
not corrected because the cost of doing so is too expensive.
• Also, if the software is delivered and meets an agreed specification, it sometimes still won't be accepted if
the specification was wrong.
• The project team may have delivered exactly what they were asked to deliver, but it is not what the users
wanted.
• This can lead to users being unhappy with the system that is finally delivered.
• In some cases, where the defect is too serious, the system may have to be de-installed completely.

Role of testing in software development, maintenance and operations
• human errors can cause a defect or fault to be introduced at any stage within the software development life
cycle
• depending upon the consequences of the mistake, the results can be trivial or catastrophic.
• Rigorous testing is necessary during development and maintenance to identify defects, in order to reduce
failures
• Executing tests helps us move towards improved quality of product and service
• It is also be required to carry out software testing to meet contractual or legal requirements, or
industry-specific standards.
• The avionics, motor, medical and pharmaceutical industries all have standards covering the testing of software
For example, the US Federal Aviation Administration's DO-178B standard [RTCA/DO-178B]

Testing and quality
• Testing helps us to measure the quality of software in terms of the number of defects found
• We can do this for both the functional attributes of the software and for the non-functional software
requirements and characteristics
• Testing can give confidence in the quality of the soft-ware if it finds few or no defects
• poor test may uncover few defects and leave us with a false sense of security
• A well-designed test will uncover defects if they are present and so, if such a test passes
• When testing does find defects, the quality of the software system increases when those defects are fixed

What is quality?
• Projects aim to deliver software to specification
• Additionally, the delivered system must meet the specification. This is known as validation
• customer wants the project to be within budget and timescale
• It should arrive when they need it and not cost too much.
• We need to understand what the customers understand by quality and what their expectations are
• if our customers find they have spent more money than they wanted they won't be impressed by the technical
excellence of the solution.

What is root cause analysis?
• When we detect failures, we might try to track them back to their root cause, the real reason that they
happened.
• For example, suppose an organization has a problem with printing repeatedly
• Some of the obvious causes they discover might be:
 Printer runs out of supplies (ink or paper).
 Printer driver software fails.
 Printer room is too hot for the printer and it seizes up
• We use testing to help us find faults and (potential) failures during software development, maintenance and
operations.
• Fixing a defect has some chance of introducing another defect or of being done incorrectly or incompletely
• The more rigorous our testing, the more defects we'll find.

• Strategy for dealing with errors, faults and failures is to try to prevent them
• Understanding the root causes of defect is an important aspect of quality assurance activities
• Testing contributes by helping us to identify defects as early as possible before the software is in use.
• Process improvements should prevent those defects recurring
• Organizations should consider testing as part of a larger quality assurance strategy
e.g., development standards, training and root cause analysis

How much testing is enough?
• Testing Principle(2) - Exhaustive testing is impossible
• Testing everything (all combinations of inputs and preconditions) is not feasible except for trivial cases.
Instead of exhaustive testing, we use risks and priorities to focus testing efforts.
 How much testing should we do?
• We have a choice: test everything, test nothing or test some of the software.
• We don't want to use software that has not been completely tested
• we must exercise every aspect of a software system during testing
• Pressures on a project include time and budget as well as pressure to deliver a technical solution
• we need a test approach which provides the right amount of testing for this project
• Assessing and managing risk is one of the most important activities in any project
• Deciding how much testing is enough should take account of the level of risk

• We carry out a risk assessment to decide how much testing to do
• We can then vary the testing effort based on the level of risk in different areas
• Additionally, testing should provide sufficient information to stakeholders to make informed decisions
• The effort put into the quality assurance and testing activities needs to be tailored to the risks and costs
associated with the project

WHAT IS TESTING?
The driving test - an analogy for software testing
• In a driving test, the examiner critically assesses the candidate's driving, noting every mistake, large or small
• The examiner takes the driver through a route which tests many possible
• At the end of the test, the examiner makes a judgment about the driver's performance.
• The examiner bases the judgment on the number and severity of the failures identified
• A single severe fault is enough to fail the whole test
• Many minor faults would reduce the confidence of the examiner in the quality

• The test is planned and prepared for.
• In advance of the test, the examiner has planned a series of routes which cover the key driving activities
• The test has known goals - assessing whether the driver is sufficiently safe to be allowed to drive by
themselves
• There are clear pass/fail criteria, based on the number and severity of faults
• The test is therefore carried out to show that the driver satisfies the requirements for driving and to
demonstrate that they are fit to drive
• The examiner looks for faults in the driving
• The time for the test is limited, so it is not a complete test of the driver's abilities .
• All the drivers are tested in an equivalent way and the examiner is neutral and objective.
• A driver who fails will get a report with a list of faults and areas to improve before retaking the test.

Defining software testing
The definition starts with a description of testing as a process and then lists some objectives of the test process
• Process - Testing is a process rather than a single activity - there are a series of activities involved.
• All life cycle activities :
Designing tests early in the life cycle can help to prevent defects from being introduced into code
The test basis includes documents such as the requirements and design specifications.
• Both static and dynamic
tests where the software code is executed to demonstrate the results of running tests :dynamic
testing
Testing and finding defects without executing code: static testing.
This testing includes reviewing of documents including source code

• Planning - Activities take place before and after test execution
• Preparation - We need to choose what testing we'll do, by selecting test conditions
and designing test cases.
• Evaluation - we must check the results and evaluate the software under test and
the completion criteria
• Software products and related work products - We don't just test code. We test the
requirements and design specifications, and we test related documents

• The second part of the definition covers the some of the objectives for testing the reasons
• Determine that (software products) satisfy specified requirements - Some of the testing we do is focused
on checking products against the specification for the product
• Demonstrate that (software products) are fit for purpose -'Fit for purpose' looks at whether the software
does enough to help the users to carry out their tasks
• Detect defects - Finding the defects helps us understand the risks associated with putting the software into
operational use

Software test and driving test compared
software test is very like a driving test in many ways, although of course it is not a perfect analogy!
The driving examiner becomes the software tester
The driver being examined becomes the system or software under test
 Planning and preparation - Both the examiner and the tester need a plan of action and need to prepare for the
test
 Static and dynamic - Both dynamic (driving the car or executing the soft ware) and static (questions to the
driver or a review of the software) tests are useful.
 Evaluation - The examiner and the tester must make an objective evaluation, log the test outcome and report
factual observations about the test.
 Determine that they satisfy specified requirements - The examiner and tester both check against requirements
to carry out particular tasks successfully.
 Demonstrate that they are fit for purpose - The examiner and the tester are not evaluating for perfection but
for meeting sufficient of the attributes required to pass the test.
 Detect defects - The examiner and tester both look for and log faults

When can we meet our test objectives?
• Testing Principle (3)- Early testing
• Testing activities should start as early as possible in the software or system development life cycle and should
be focused on defined objectives
• both dynamic testing and static testing as a means for achieving similar test objectives
• testing can have different goals and objectives, which often include:
 finding defects;
 gaining confidence in and providing information about the level of quality;
 preventing defects.
• Early testing - such as early test design and review activities - finds defects early on when they are cheap to
find and fix.
• The main objective may be to cause as many failures as possible so that defects in the software are identified

• Fixing the defects may not always be the test objective or the desired outcome.
• Sometimes we simply want to gather information and measure the software.
 mean time between failures to assess reliability
 an assessment of the defect density in the software to assess
 understand the risk of releasing it.
regression testing :
 testing to ensure nothing has changed that should not have changed.
 When maintaining software by enhancing it or fixing bugs, we are changing software that is already being
used.
 objective of testing may be to ensure that we have not made errors and introduced defects

• Testing Principle(4) - Defect clustering
• A small number of modules contain most of the defects discovered during pre-release testing or show the most
operational failures.
• Focusing on defects can help us plan our tests
 Reviewing defects and failures in order to improve processes allows us to improve our testing and our
requirements, design and development processes
 defects tend to cluster.
 This can happen because an area of the code is particularly complex and tricky
 changing software and other products tends to cause knock-on defects
 Testers will often use this information when making their risk assessment and focus on known 'hot spots’.
 reviews and other static tests is to carry out testing as early as possible, finding and fixing defects

The defect clusters change over time
• Testing Principle(5) - Pesticide paradox
• If the same tests are repeated over and over again, eventually the same set of test cases will no longer find any
new bugs. To overcome this 'pesticide paradox', the test cases need to be regularly reviewed and revised, and
new and different tests need to be written to exercise different parts of the software or system to potentially
find more defects.
• Over time, as we improve our whole software development life cycle and the early static testing, we may well
find that dynamic test levels find fewer defects.
• A typical test improvement initiative will initially find more defects as the testing improves
• as the defect prevention kicks in, we see the defect numbers dropping
• As the 'hot spots' for bugs get cleaned up we need to move our focus else-where

Debugging removes defects
• When a test finds a defect that must be fixed, a programmer must do some work to locate the defect in the
code and make the fix.
• In this process, called debugging, a programmer will examine the code for the immediate cause of the
problem
• The fix is often then tested separately (e.g. by an independent tester) to confirm the fix
• Notice that testing and debugging are different activities.
• Developers may test their own fixes, in which case the very tight cycle of identifying faults
• However, often following the debugging cycle the fixed code is tested independently

Is the software defect free?
• Testing Principle(6) - Testing shows presence of defects
• Testing can show that defects are present, but cannot prove that there are no defects. Testing reduces the
probability of undiscovered defects remaining in the software but, even if no defects are found, it is not a proof
of correctness.
• This principle arises from the theory of the process of scientific experimentation and has been adopted by
testers
• Assume many tests we executed without finding a bug, we have not shown 'There are no bugs’
• As soon as we find a bug, we have shown 'This code is not bug-free'.

If we don't find defects does that mean the users will accept the
software?
• Testing Principle (7)- Absence of errors fallacy
• Finding and fixing defects does not help if the system built is unusable and does not fulfill the users' needs and
expectations.
• The customers for software the people and are not interested in defects or numbers of defects, except when
they are directly affected by the instability of the software.
• The people using soft-ware are more interested in the software
• supporting them in completing tasks efficiently and effectively.
• The software must meet their needs.

Role of Tester:
• A Software Tester is required from early stages of SDLC:
• In requirements phase – tester does requirement analysis.
• In design phase – tester does use-case analysis and starts drafting a Test Plan.
• In development phase – tester start developing test cases and test scripts and finalize the
• test plan.
• In testing phase – conduct various types of tests, maintain logs and test summary reports.
• In deployment phase – prepare training documentation, lessons learned etc.
• In support phase – test the production issues.

Overview of STLC:
• Software Testing Lifecycle is a standard procedure divided into different phases,
• STLC stands for Software Testing Life Cycle. STLC is a sequence of different activities performed by the
testing team to ensure the quality of the software or the product.
• STLC is an integral part of Software Development Life Cycle (SDLC). But, STLC deals only with the testing
phases.
• STLC starts as soon as requirements are defined or SRD (Software Requirement Document) is shared by
stakeholders.
• STLC provides a step-by-step process to ensure quality software.
• In the early stage of STLC, while the software or the product is developing, the tester can analyze and define
the scope of testing, entry and exit criteria and also the Test Cases.
• It helps to reduce the test cycle time along with better quality.
• As soon as the development phase is over, the testers are ready with test cases and start with execution. This
helps to find bugs in the initial phase.

SOFTWARE TESTING LIFE CYCLE
• STLC V-Model
• What is STLC V-Model?
• One of the major handicaps of waterfall STLC model was that, defects were found at a very later state of the
development process, since testing was done at the end of the development cycle.
• It became very challenging and costly to fix the defects since it were found at a very later stage.
• To overcome this problem, a new development model was introduced called the “V Model”
• V model is now one of the most widely used software development process.
• Introduction of V model has actually proved the implementation of testing right from the requirement phase.
V model is also called as verification and validation model.

• To understand the V model, let’s first understand what is verification and validation in software.
• Verification: Verification is a static analysis technique. In this technique testing is done without executing the
code.
• Examples include – Reviews, Inspection and walkthrough.
• Validation: Validation is a dynamic analysis technique where testing is done by executing the code. Examples
include functional and non-functional testing techniques.
• In V model, the development and QA activities are done simultaneously.
• There is no discrete phase called Testing, rather testing starts right from the requirement phase.
• The verification and validation activities go hand in hand.
• To understand the V model, let’s look at the figure below:

• In a typical development process, the left hand side shows the development activities and right hand side
shows the testing activities.
 Left Hand side:
• As said earlier, left hand side activities are the development activities.
• Normally we feel, what testing can we do in development phase, but this is the beauty of this model which
demonstrates that testing can be done in all phase of development activities as well.
• Requirement analysis: In this phase the requirements are collected, analyzed and studied.
• Here how the system is implemented, is not important but, what the system is supposed to do, is important.
Brain storming sessions/walkthrough, interviews are done to have the objectives clear.
• Verification activities: Requirements reviews.
• Validation activities: Creation of UAT (User acceptance test) test cases
• Artifacts produced: Requirements understanding document, UAT test cases.

• System requirements / High level design: In this phase a high level design of the software is build. The team
studies and investigates on how the requirements could be implemented.
• The technical feasibility of the requirements is also studied.
• The team also comes up with the modules that would be created/ dependencies, Hardware / software needs
• Verification activities: Design reviews
• Validation activities: Creation of System test plan and cases, Creation of traceability metrics
• Artifacts produced: System test cases, Feasibility reports, System test plan, Hardware software requirements,
and modules to be created etc.

• Architectural design: In this phase, based on the high level design, software architecture is created.
• The modules, their relationships and dependencies, architectural diagrams, database tables, technology details
are all finalized in this phase.
• Validation activities: Integration test plan and test cases.
• Artifacts produced: Design documents, Integration test plan and test cases, Database table designs etc.
• Module design/ Low level Design: In this phase each and every module or the software components are
designed individually. Methods, classes, interfaces, data types etc are all finalized in this phase.
• Validation activities: Creation and review of unit test cases.
• Artifacts produced: Unit test cases

Implementation / Code: In this phase, actual coding is done.
• Verification activities: Code review, test cases review
• Validation activities: Creation of functional test cases.
• Artifacts produced: test cases, review checklist.

Right Hand Side:
• Right hand side demonstrates the testing activities or the Validation Phase. We will start from bottom.
• Unit Testing: In this phase all the unit test case, created in the Low level design phase are executed.
• Unit testing is a white box testing technique, where a piece of code is written which invokes a method (or any
other piece of code) to test whether the code snippet is giving the expected output or not.
• This testing is basically performed by the development team.
• In case of any anomaly, defects are logged and tracked.
• Artifacts produced: Unit test execution results

• Integration Testing: In this phase the integration test cases are executed which were created in the
Architectural design phase. In case of any anomalies, defects are logged and tracked.
• *Integration Testing: Integration testing is a technique where the unit tested modules are integrated and tested
whether the integrated modules are rendering the expected results.
• In simpler words, It validates whether the components of the application work together as expected.
• Artifacts produced: Integration test results.
• Systems testing: In this phase all the system test cases, functional test cases and nonfunctional test cases are
executed.
• In other words, the actual and full fledge testing of the application takes place here.
• Defects are logged and tracked for its closure. Progress reporting is also a major part in this phase.
• The traceability metrics are updated to check the coverage and risk mitigated.
• Artifacts produced: Test results, Test logs, defect report, test summary report and updated traceability
matrices.

• User acceptance Testing: Acceptance testing is basically related to the business requirements testing.
• Here testing is done to validate that the business requirements are met in the user environment.
• Compatibility testing and sometimes nonfunctional testing (Load, stress and volume) testing are also done in
this phase.
• Artifacts produced: UAT results, Updated Business coverage matrices.

When to use V Model?
V model is applicable when:
• Requirement is well defined and not ambiguous
• Acceptance criteria are well defined.
• Project is short to medium in size.
• Technology and tools used are not dynamic

SDLC vs STLC
• STLC is part of SDLC. It can be said that STLC is a subset of the SDLC set
• STLC is limited to the testing phase where quality of software or product ensures.
• SDLC has vast and vital role in complete development of a software or product.
• However, STLC is a very important phase of SDLC and the final product or the software cannot be released
without passing through the STLC process.
• STLC is also a part of the post-release/ update cycle, the maintenance phase of SDLC where known defects
get fixed or a new functionality is added to the software.

• STLC has the following different phases but it is not mandatory to follow all phases.
• Phases are dependent on the nature of the software or the product, time and resources allocated for the testing
and the model of SDLC that is to be followed.

• There are 6 major phases of STLC −
• Requirement Analysis − When the SRD is ready and shared with the stakeholders, the testing team starts high
level analysis concerning the AUT (Application under Test).
• Test Planning − Test Team plans the strategy and approach.
• Test Case Designing − Develop the test cases based on scope and criteria’s.
• Test Environment Setup − When integrated environment is ready to validate the product.
• Test Execution − Real-time validation of product and finding bugs.
• Test Closure − Once testing is completed, matrix, reports, results are documented.

Document templates generated in different phases of STLC
Requirement Analysis − The Matrix is created at the very beginning of a project as it forms the basis of the
project's scope and deliverables that will be produced.
• Test Planning − The basic entry criteria of this phase is provision of Test plan/strategy document .
• Test Case Designing – Test cases/scripts
• Test Environment Setup –
• Test Execution –
• Test Closure –

TEST LEVELS
• The key characteristics for each test level are discussed and defined to be able to more clearly separate the
various test levels.
Component testing :
• Component testing, also known as unit, module and program testing, searches for defects in, and verifies the
functioning of software (e.g. modules, programs, objects, classes, etc.) that are separately testable.
• Component testing may be done in isolation from the rest of the system depending on the context of the
development life cycle and the system.
Most often stubs and drivers are used to replace the missing software and simulate the interface between the
software components in a simple manner.Stubs are basically known as a “called programs” and are used in the
Top-down integration testing. While, drivers are the “calling program” and are used in bottom-up integration
testing
• A stub is called from the software component to be tested; a driver calls a component to be tested (see Figure
2.5).
• Component testing may include testing of functionality and specific non-functional characteristics such as
resource-behavior (e.g. memory leaks), performance or robustness testing, as well as structural testing (e.g.
decision coverage). Test cases are derived from work products such as the software design or the data model.

• Sometimes, depending on the applicable level of risk, component testing is carried out by a different
programmer thereby introducing independence.
• Defects are typically fixed as soon as they are found, without formally recording the incidents found.
• One approach in component testing, used in Extreme Programming (XP), is to prepare and automate test cases
before coding.
• This is called a test-first approach or test-driven development.
• This approach is highly iterative and is based on cycles of developing test cases, then building and integrating
small pieces of code, and executing the component tests until they pass.
•

Integration testing
• Integration testing tests interfaces between components, interactions to different parts of a system such as an
operating system, file system and hard-ware or interfaces between systems.
• Note that integration testing should be differentiated from other integration activities. Integration testing is
often carried out by the integrator, but preferably by a specific integration tester or test team.
• There may be more than one level of integration testing and it may be carried out on test objects of varying
size. For example:
• Component integration testing tests the interactions between software components and is done after component
testing;
• System integration testing tests the interactions between different systems and may be done after system
testing.
• In this case, the developing organization may control only one side of the interface, so changes may be
destabilizing.
• Business processes implemented as workflows may involve a series of systems that can even run on different
platforms.

• The greater the scope of integration, the more difficult it becomes to isolate failures to a specific interface,
which may lead to an increased risk.
• This leads to varying approaches to integration testing.
• One extreme is that all components or systems are integrated simultaneously, after which everything is tested
as a whole. This is called 'big-bang' integration testing.
• Big-bang testing has the advantage that everything is finished before integration testing starts
• The major disadvantage is that in general it is time-consuming and difficult to trace the cause of failures with
this late integration
• So big-bang integration may seem like a good idea when planning the project, being optimistic and expecting
to find no problems.
• Another extreme is that all programs are integrated one by one, and a test is carried out after each step
(incremental testing).
• The incremental approach has the advantage that the defects are found early in a smaller assembly when it is
relatively easy to detect the cause
• A disadvantage is that it can be time-consuming since stubs and drivers have to be developed and used in the
test.

• Within incremental integration testing a range of possibilities exist, partly depending on the system
architecture:
• Top-down: testing takes place from top to bottom, following the control flow or architectural structure (e.g.
starting from the GUI or main menu). Components or systems are substituted by stubs.
• Bottom-up: testing takes place from the bottom of the control flow upwards. Components or systems are
substituted by drivers.
• Functional incremental: integration and testing takes place on the basis of the functions or functionality, as
documented in the functional specification.
 The best choice is to start integration with those interfaces that are expected to cause most problems.
 Doing so prevents major defects at the end of the integration test stage.
 In order to reduce the risk of late defect discovery, integration should normally be incremental rather than
'big-bang’.
 If integration tests are planned before components or systems are built, they can be developed in the order
required for most efficient testing.

• At each stage of integration, testers concentrate solely on the integration itself.
• For example, if they are integrating component A with component B they are interested in testing the
communication between the components, not the functionality of either one.
• Both functional and structural approaches may be used. Testing of specific non-functional characteristics (e.g.
performance) may also be included in integration testing.
• Integration testing may be carried out by the developers, but can be done by a separate team of specialist
integration testers, or by a specialist group of developers/integrators including non-functional specialists.

System testing
• System testing is concerned with the behavior of the whole system/product as defined by the scope of a
development project or product.
• It may include tests based on risks and/or requirements specification, business processes, use cases, or other
high level descriptions of system behavior, interactions with the operating system, and system resources.
• System testing is most often the final test on behalf of development to verify that the system to be delivered
meets the specification and its purpose may be to find as many defects as possible.
• Most often it is carried out by specialist testers that form a dedicated, and sometimes independent, test team
within development, reporting to the development manager or project manager.
• In some organizations system testing is carried out by a third party team or by business analysts. Again the
required level of independence is based on the applicable risk level .
• System testing should investigate both functional and non-functional requirements of the system.

• System testing of functional requirements starts by using the most appropriate specification-based (black-box)
techniques for the aspect of the system to be tested .
• System testing requires a controlled test environment with regard to, amongst other things, control of the
software versions, testware and the test data
• A system test is executed by the development organization in a (properly controlled) environment
• The test environment should correspond to the final target or production environment as much as possible in
order to minimize the risk of environment-specific failures not being found by testing

Acceptance testing
• When the development organization has performed its system test and has corrected all or most defects, the
system will be delivered to the user or customer for acceptance testing.
• The acceptance test should answer questions such as: 'Can the system be released?', 'What, if any, are the
outstanding (business) risks?' and 'Has development met their obligations?’.
• Acceptance testing is most often the responsibility of the user or customer, although other stakeholders may
be involved as well.
• The execution of the acceptance test requires a test environment that is for most aspects, representative of the
production environment .
• The goal of acceptance testing is to establish confidence in the system, part of the system or specific non-
functional characteristics, e.g. usability, of the system
• Acceptance testing is most often focused on a validation type of testing, whereby we are trying to determine
whether the system is fit for purpose.

• Finding defects should not be the main focus in acceptance testing.
• Although it assesses the system's readiness for deployment and use, it is not necessarily the final level of
testing.
For example, a large-scale system integration test may come after the acceptance of a system.
Acceptance testing may occur at more than just a single level, for example:
• A Commercial Off The Shelf (COTS) software product may be acceptance tested when it is installed or
integrated.
• Acceptance testing of the usability of a component may be done during component testing.
• Acceptance testing of a new functional enhancement may come before system testing.

• Within the acceptance test for a business-supporting system, two main test types can be distinguished;
• The user acceptance test focuses mainly on the functionality thereby validating the fitness-for-use of the
system by the business user.
• The operational acceptance test (also called production acceptance test) validates whether the system meets
the requirements for operation.
• The user acceptance test is performed by the users and application managers.
• In terms of planning, the user acceptance test usually links tightly to the system test and will, in many cases,
be organized partly overlapping in time.
• If the system to be tested consists of a number of more or less independent subsystems, the acceptance test for
a subsystem that complies with the exit criteria of the system test can start while another subsystem may still
be in the system test phase.
• In most organizations, system administration will perform the operational acceptance test shortly before the
system is released.
• The operational acceptance test may include testing of backup/restore, disaster recovery, maintenance tasks
and periodic check of security vulnerabilities

• Other types of acceptance testing that exist are contract acceptance testing and compliance acceptance
testing.
• Contract acceptance testing is performed against a contract's acceptance criteria for producing custom-
developed software.
• Acceptance should be formally defined when the contract is agreed.
• Compliance acceptance testing or regulation acceptance testing is performed against the regulations which
must be adhered to, such as governmental, legal or safety regulations.
• Very often this type of system undergoes two stages of acceptance test.
• The first is called alpha testing.
• This test takes place at the developer's site.
• A cross-section of potential users and members of the developer's organization are invited to use the system.
Developers observe the users

• Alpha testing may also be carried out by an independent test team.
• Beta testing, or field testing, sends the system to a cross-section of users who install it and use it under real-
world working conditions.
• The users send records of incidents with the system to the development organization where the defects are
repaired.

TEST TYPES: Functional testing
• Test types are introduced as a means of clearly defining the objective of a certain test level for a programme
or project.
• Focusing the testing on a specific test objective and, therefore, selecting the appropriate type of test helps
making and communicating decisions against test objectives easier.
Testing of function (functional testing)
• The function of a system (or component) is 'what it does’.
• This is typically described in a requirements specification, a functional specification, or in use cases.
• There may be some functions that are 'assumed' to be provided that are not documented that are also part of
the requirement for a system, though it is difficult to test against undocumented and implicit requirements.
• Functional tests are based on these functions, described in documents or understood by the testers and may be
performed at all test levels (e.g. test for components may be based on a component specification).

• Functional testing considers the specified behavior and is often also referred to as black-box testing.
• Function (or functionality) testing can, based upon ISO 9126, be done focusing on suitability,
interoperability, security, accuracy and compliance.
• Security testing, for example, investigates the functions (e.g. a firewall) relating to detection of threats, such
as viruses, from malicious outsiders.
• Testing functionality can be done from two perspectives: requirements-based or business-process-based.
• Requirements-based testing uses a specification of the functional requirements for the system as the basis for
designing tests.
• We should also prioritize the requirements based on risk criteria (if this is not already done in the
specification) and use this to prioritize the tests .
• This will ensure that the most important and most critical tests are included in the testing effort

• Business-process-based testing uses knowledge of the business processes.
• Business processes describe the scenarios involved in the day-to-day business use of the system.
• For example, a personnel and payroll system may have a business process along the lines of: someone joins
the company, he or she is paid on a regular basis, and he or she finally leaves the company.
• Use cases originate from object-oriented development
• They also take the business processes as a starting point, although they start from tasks to be performed by
users
• The techniques used for functional testing are often specification-based, but experienced-based techniques
can also be used

API Testing
• What is an API?
• API stands for Application Programming Interface, which specifies how one component should interact with
the other.
• It consists of a set of routines, protocols and tools for building the software applications.
What is an API Testing?
• The API Testing is performed for the system, which has a collection of API that ought to be tested.

During Testing, a test of following things is looked at.
• Exploring boundary conditions and ensuring that the test harness varies parameters of the API calls in ways
that verify functionality and expose failures.
• Generating more value added parameter combinations to verify the calls with two or more parameters.
• Verifying the behaviour of the API which is considering the external environment conditions such as files,
peripheral devices, and so forth.
• Verifying the Sequence of API calls and check if the API's produce useful results from successive calls.

• Common Tests performed on API’s
• Return Value based on input condition - The return value from the API's are checked based on the input
condition.
• Verify if the API's does not return anything.
• Verify if the API triggers some other event or calls another API. The Events output should be tracked and
verified.
• Verify if the API is updating any data structure.

Usability Testing
• Usability testing, a non-functional testing technique that is a measure of how easily the system can be used by
end users. It is difficult to evaluate and measure but can be evaluated based on the below parameters:
• Level of Skill required to learn/use the software. It should maintain the balance for both novice and expert user.
• Time required to get used to in using the software.
• The measure of increase in user productivity if any.
• Assessment of a user's attitude towards using the software.

Exploratory Testing
• During testing phase where there is severe time pressure, Exploratory testing technique is adopted that
combines the experience of testers along with a structured approach to testing.
• Exploratory testing often performed as a black box testing technique, the tester learns things that together with
experience and creativity generate new good tests to run
• Benefits:
Following are the benefits of Exploratory Testing:
• Exploratory testing takes less preparation.
• Critical defects are found very quickly.
• The testers can use reasoning based approach on the results of previous results to guide their future testing on
the fly.

• Drawbacks:
Following are the Drawbacks of Exploratory Testing:
• Tests cannot be reviewed.
• It is difficult to keep track of what tests have been tested.
• It is unlikely to be performed in exactly the same manner and to repeat specific details of the earlier tests.

Adhoc Testing
• When a software testing performed without proper planning and documentation, it is said to be Adhoc Testing.
• Such kind of tests are executed only once unless we uncover the defects.
• Adhoc Tests are done after formal testing is performed on the application.
• Adhoc methods are the least formal type of testing as it is NOT a structured approach.
• Hence, defects found using this method are hard to replicate as there are no test cases aligned for those
scenarios.
• Testing is carried out with the knowledge of the tester about the application and the tester tests randomly
without following the specifications/requirements.
• Hence the success of Adhoc testing depends upon the capability of the tester, who carries out the test.
• The tester has to find defects without any proper planning and documentation, solely based on tester's
intuition.

When to Execute Adhoc Testing ?
• Adhoc testing can be performed when there is limited time to do exhaustive testing and usually performed
after the formal test execution.
• Adhoc testing will be effective only if the tester has in-depth understanding about the System Under Test.
Forms of Adhoc Testing :
1. Buddy Testing: Two buddies, one from development team and one from test team mutually work on
identifying defects in the same module.
• Buddy testing helps the testers develop better test cases while development team can also make design
changes early. This kind of testing happens usually after completing the unit testing.
2. Pair Testing: Two testers are assigned the same modules and they share ideas and work on the same systems
to find defects. One tester executes the tests while another tester records the notes on their findings.
3. Monkey Testing: Testing is performed randomly without any test cases in order to break the system.

• Various ways to make Adhoc Testing More Effective
1. Preparation: By getting the defect details of a similar application, the probability of finding defects in the
application is more.
2. Creating a Rough Idea: By creating a rough idea in place the tester will have a focussed approach. It is NOT
required to document a detailed plan as what to test and how to test.
3. Divide and Rule: By testing the application part by part, we will have a better focus and better understanding
of the problems if any.
4. Targeting Critical Functionalities: A tester should target those areas that are NOT covered while designing
test cases.
5. Using Tools: Defects can also be brought to the lime light by using profilers, debuggers and even task
monitors. Hence being proficient in using these tools one can uncover several defects.
6. Documenting the findings: Though testing is performed randomly, it is better to document the tests if time
permits and note down the deviations if any.
If defects are found, corresponding test cases are created so that it helps the testers to retest the scenario.

Static Testing
• The definition of testing outlines objectives that relate to evaluation, revealing defects
and quality.
As indicated in the definition two approaches can be used to achieve these objectives, static testing and
dynamic testing.
• With dynamic testing methods, software is executed using a set of input values and its output is then
examined and compared to what is expected. During static testing, software
• work products are examined manually, or with a set of tools, but not executed. As a consequence, dynamic
testing can only be applied to software code.

• What is Static Testing?
• Static Testing, a software testing technique in which the software is tested without executing the code
• Reviews:
• A review is a systematic examination of a document by one or more people with the main aim of finding and
removing errors early in the software development life cycle.
• Reviews are used to verify documents such as requirements, system designs, code, test plans and test cases.
Types of Review:
1.Walkthrough: A walkthrough is characterized by the author of the document under review guiding the
participants through the document and his or her thought processes, to achieve a common understanding and to
gather feedback.
• This is especially useful if people from outside the software discipline are present, who are not used to, or
cannot easily understand software development documents.
• The content of the document is explained step by step by the author, to reach consensus on changes or to
gather information.

• The specific goals of a walkthrough depend on its role in the creation of the document. In general the
following goals can be applicable:
• To present the document to stakeholders both within and outside the soft ware discipline, in order to gather
information regarding the topic under documentation;
• To explain (knowledge transfer) and evaluate the contents of the docu ment;
•To establish a common understanding of the document;
• To examine and discuss the validity of proposed solutions and the viability of alternatives, establishing
consensus.
Key characteristics of walkthroughs are:
• The meeting is led by the authors; often a separate scribe is present.
• Scenarios and dry runs may be used to validate the content.
• Separate pre-meeting preparation for reviewers is optional.

2. Technical review: Is a discussion meeting that focuses on achieving consensus about the technical content of
a document.
• The goals of a technical review are to:
•Aassess the value of technical concepts and alternatives in the product and project environment;
•Eestablish consistency in the use and representation of technical concepts;
• Ensure, at an early stage, that technical concepts are used correctly;
• Inform participants of the technical content of the document.

Key characteristics of a technical review are:
• It is a documented defect-detection process that involves peers and technical experts.
• It is often performed as a peer review without management partici pation.
• Ideally it is led by a trained moderator, but possibly also by a technical expert.
• A separate preparation is carried out during which the product is examined and the defects are found.
• More formal characteristics such as the use of checklists and a logging list or issue log are optional.

3. Inspection is the most formal review type. It is usually led by a trained moderator (certainly not by the
author).
• The document under inspection is prepared and checked thoroughly by the reviewers before the meeting,
comparing the work product with its sources and other referenced documents, and using rules and checklists.
• The generally accepted goals of inspection are to:
• Help the author to improve the quality of the document under inspection;
• Remove defects efficiently, as early as possible;
• Improve product quality, by producing documents with a higher level of quality;
• Create a common understanding by exchanging information among the inspection participants;
• Train new employees in the organization's development process;
•Learn from defects found and improve processes in order to prevent recur rence of similar defects;
• Sample a few pages or sections from a larger document in order to measure the typical quality of the document,
leading to improved work by individuals in the future, and to process improvements.

Key characteristics of an inspection are:
• It is usually led by a trained moderator (certainly not by the author).
• It uses defined roles during the process.
• It involves peers to examine the product.
• Rules and checklists are used during the preparation phase.
• A separate preparation is carried out during which the product is
examined and the defects are found.
• The defects found are documented in a logging list or issue log.
• A formal follow-up is carried out by the moderator applying exit
criteria.

BASICS OF TEST DESIGN TECHNIQUES:
• There are many different types of software testing technique, each with its own strengths and weaknesses.
• Each individual technique is good at finding particular types of defect and relatively poor at finding other
types.
• For example, a technique that explores the upper and lower limits of a single input range is more likely to find
boundary value defects than defects associated with combinations of inputs.
• Similarly, testing performed at different stages in the software development life cycle will find different types
of defects; component testing is more likely to find coding logic defects than system design defects.
• Each testing technique falls into one of a number of different categories. Broadly speaking there are two
main categories, static and dynamic.
• Dynamic techniques are subdivided into three more categories: specification-based (black-box, also known as
behavioral techniques), structure-based (white-box or structural techniques) and experience based.
Specification-based techniques include both functional and non-functional techniques (i.e. quality
characteristics).

Static testing techniques:
• Static testing techniques do not execute the code being examined and are generally used before any tests are
executed on the software.
• They could be called non-execution techniques.
• Most static testing techniques can be used to 'test' any form of document including source code, design
documents and models, functional specifications and requirement specifications.
• However, 'static analysis' is a tool-supported type of static testing that concentrates on testing formal
languages and so is most often used to statically test source code
• data-flow analysis: is a technique for gathering information about the possible set of values calculated at
various locations in a computer program
• control-flow analysis: is a technique for determining the order of operations in a computer program.

• Structure-based (white-box) testing techniques:
• Structure-based testing techniques (which are also dynamic rather than static) use the internal structure of the
software to derive test cases.
• They are commonly called 'white-box' or 'glass-box' techniques (implying you can see into the system) since
they require knowledge of how the software is implemented, that is, how it works.
• For example, a structural technique may be concerned with exercising loops in the software.
• Different test cases may be derived to exercise the loop once, twice, and many times.
• This may be done regardless of the functionality of the software

Statement testing
• Statement testing is a white box testing approach in which test scripts are designed to execute code
statements.
• The statement coverage is the measure of the percentage of statements of code executed by the test scripts out
of the total code statements in the application.
• The statement coverage is the least preferred metric for checking test coverage.
 Decision testing/branch testing
• Decision testing or branch testing is a white box testing approach in which test coverage is measured by the
percentage of decision points(e.g. if-else conditions) executed out of the total decision points in the
application.

Condition testing
• Testing the condition outcomes(TRUE or FALSE). So, getting 100% condition coverage required exercising
each condition for both TRUE and FALSE results using test scripts(For n conditions we will have 2n test
scripts).
 Multiple condition testing
• Testing the different combinations of condition outcomes. Hence for 100% coverage we will have 2^n test
scripts. This is very exhaustive and very difficult to achieve 100% coverage.

Experience-based testing techniques :
• In experience-based techniques, people's knowledge, skills and background are a prime contributor to the
test conditions and test cases.
• The experience of both technical and business people is important, as they bring different perspectives to the
test analysis and design process.
• Due to previous experience with similar systems, they may have insights into what could go wrong, which is
very useful for testing.
Exploratory Testing:
• Usually this process will be carried out by domain experts.
• They perform testing just by exploring the functionalities of the application without having the knowledge of
the requirements.
• Whilst using this technique, testers could explore and learn the system. High severity bugs are found very
quickly in this type of testing

Error Guessing:
• Error guessing is one of the testing techniques used to find bugs in a software application based on tester’s
prior experience. In Error guessing we don’t follow any specific rules.
Some of the examples are:
• Submitting a form without entering values.
• Entering invalid values such as entering alphabets in the numeric field.

Specification-based (black-box) testing techniques:
• The first of the dynamic testing techniques we will look at are the specification-based testing techniques.
• These are also known as 'black-box' or input/output-driven testing techniques because they view the software
as a Black-box with inputs and outputs, but they have no knowledge of how the system or component is
structured inside the box.
• In essence, the tester is concentrating on what the software does, not how it does it.
• Functional testing is concerned with what the system does, its features or functions.
• Non-functional testing is concerned with examining how well the system does something, rather than what it
does.
• Non-functional aspects (also known as quality characteristics or quality attributes) include performance,
usability, portability, maintainability, etc.
• Techniques to test these non-functional aspects are less procedural and less formalized than those of other
categories as the actual tests are more dependent on the type of system, what it does and the resources
available for the tests.

Equivalence Partitioning:
• It is also known as Equivalence Class Partitioning (ECP).
• Using equivalence partitioning test design technique, we divide the test conditions into class (group). From
each group we do test only one condition.
• Assumption is that all the conditions in one group works in the same manner. If a condition from a group
works then all of the conditions from that group work and vice versa.
• It reduces lots of rework and also gives the good test coverage. We could save lots of time by reducing total
number of test cases that must be developed.
• For example: A field should accept numeric value. In this case, we split the test conditions as Enter numeric
value, Enter alpha numeric value, Enter Alphabets, and so on. Instead of testing numeric values such as 0, 1,
2, 3, and so on.

Boundary Value Analysis:
• Using Boundary value analysis (BVA), we take the test conditions as partitions and design the test cases by
getting the boundary values of the partition.
• The boundary between two partitions is the place where the behavior of the application varies.
• The test conditions on either side of the boundary are called boundary values.
• In this we have to get both valid boundaries (from the valid partitions) and invalid boundaries (from the
invalid partitions).
For example: If we want to test a field which should accept only amount more than 10 and less than 20 then we
take the boundaries as 10-1, 10, 10+1, 20-1, 20, 20+1.
• Instead of using lots of test data, we just use 9, 10, 11, 19, 20 and 21.

Decision Table:
• Decision Table is aka Cause-Effect Table.
• This test technique is appropriate for functionalities which has logical relationships between inputs (if-else
logic).
• In Decision table technique, we deal with combinations of inputs. To identify the test cases with decision
table, we consider conditions and actions. We take conditions as inputs and actions as outputs.
State Transition Testing:
• Using state transition testing, we pick test cases from an application where we need to test different system
transitions.
• We can apply this when an application gives a different output for the same input, depending on what has
happened in the earlier state.
• Some examples are Vending Machine, Traffic Lights.
• Vending machine dispenses products when the proper combination of coins is deposited.
• Traffic Lights will change sequence when cars are moving / waiting

Where to apply the different categories of techniques
• Specification-based techniques are appropriate at all levels of testing (component testing through to
acceptance testing) where a specification exists.
• When performing system or acceptance testing, the requirements specification or functional specification
may form the basis of the tests.
• When performing component or integration testing, a design document or low-level specification forms the
basis of the tests.
• Structure-based techniques can also be used at all levels of testing.
• Developers use structure-based techniques in component testing and component integration testing, especially
where there is good tool support for code coverage.
• Structure-based techniques are also used in system and acceptance testing, but the structures are different.
• Experience-based techniques are used to complement specification-based and structure-based techniques, and
are also used when there is no specification, or if the specification is inadequate or out of date.

Designing test cases using MS-Excel.
• Test case formats may vary from one organization to another. But using a standard test case format for writing
test cases is one step closer to set up a testing process for your project.
• It also minimizes ad-hoc testing that is done without proper test case documentation.
• But even if you use standard templates, you need to set up test cases writing, review & approve, test execution
and most importantly test report preparation process, etc by using manual methods.
• Also if you have a process to review the test cases by the business team, then you must format these test cases
in a template that is agreed by both the parties.

Several standard fields of a sample Test Case template are listed below.
• Test case ID: Unique ID is required for each test case. Follow some convention to indicate the types of the
test. E.g. ‘TC_UI_1’ indicating ‘user interface test case #1’.
• Test priority (Low/Medium/High): This is very useful while test execution. Test priority for business rules and
functional test cases can be medium or higher whereas minor user interface cases can be of a low priority. Test
priority should always be set by the reviewer.
• Module Name: Mention the name of the main module or the sub-module.
• Test Designed By: Name of the Tester.
• Test Designed Date: Date when it was written.
• Test Executed By: Name of the Tester who executed this test. To be filled only after test execution.
• Test Execution Date: Date when the test was executed.
• Test Title/Name: Test case title. E.g. verify login page with a valid username and password.

• Test Summary/Description: Describe the test objective in brief.
• Pre-conditions: Any prerequisite that must be fulfilled before the execution of this test case. List all the pre-
conditions in order to execute this test case successfully.
• Dependencies: Mention any dependencies on the other test cases or test requirement.
• Test Steps: List all the test execution steps in detail. Write test steps in the order in which they should be
executed.
• Test Data: Use of test data as an input for this test case. You can provide different data sets with exact values
to be used as an input.
• Expected Result: What should be the system output after test execution? Describe the expected result in detail
including message/error that should be displayed on the screen.
• Post-condition: What should be the state of the system after executing this test case?
• Actual result: Actual test result should be filled after test execution. Describe the system behavior after test
execution.
• Status (Pass/Fail): If actual result is not as per the expected result, then mark this test as failed. Otherwise,
update it as passed.

• Notes/Comments/Questions: If there are some special conditions to support the above fields, which can’t be
described above or if there are any questions related to expected or actual results then mention them here.
• Add the following fields if necessary:
• Defect ID/Link: If the test status is failed, then include the link to the defect log or mention the defect number.
• Test Type/Keywords: This field can be used to classify the tests based on test types.
E.g. functional, usability, business rules etc.
• Requirements: Requirements for which this test case is being written for. Preferably the exact section number
of the requirement doc.
• Attachments/References: This field is useful for complex test scenario in order to explain the test steps or
expected result using a Visio diagram as a reference.
• Automation? (Yes/No): Whether this test case is automated or not. It is useful to track the automation status
when test cases are automated.

Unit 1.pptx

More Related Content

Similar to Unit 1.pptx

Recently uploaded

Unit 1.pptx