AJ

[Link] some software failures. How can we minimize such failures?

A major problem of the software industry is its inability to develop error-free software. Had
software developers ever been asked to certify that the software developed is error-free, no
software would have ever been released. Hence ‘software crises’ has become a fixture of
everyday life with many well-publicized failures that have had not only major economic
impact but also have become the cause of loss of life. Some of the failures are discussed in
subsequent sections.
[Link] Explosion of the Ariane 5 Rocket
The Ariane 5 rocket was designed by European Space Agency and it was launched on June 4,
1996. It was an unmanned rocket and unfortunately exploded only after 40 seconds of its take
An enquiry board was constituted to find the reasons of the explosion. The board
identified the cause and mentioned in its report that: “The failure of the Ariane 5
was caused by the complete loss of guidance and altitude information, 37 seconds after start of
the main engine ignition sequence (30 seconds after lift-off). This loss of information was due
to specification and design errors in the software of the inertial reference system. The extensive
reviews and tests carried out during the Ariane 5 development programme did not include
adequate analysis and testing of the inertial reference system or of the complete flight control
system, which could have detected the potential failure”
[Link] Y2K Problem
The Y2K problem was the most critical problem of the last century. The whole world was
expecting something drastic on January 1, 2000. Significant sums of money were spent by
software companies to get rid of this problem. What was the problem? It was simply the case
of using two digits for the year instead of four digits. For instance, 1965 was considered as 65.
The developers could not imagine the problem of year 2000. What would happen on January
1, 2000? The last two digits i.e. 00 may belong to any century like 1800, 1900, 2000, 2100,
etc. The simple ignorance or a faulty design decision to use only the last two digits for the year
resulted into the serious Y2K problem. Most of the software was re-tested and modified or
discarded, depending on the situation
[Link] USA Star-Wars Program
‘Patriot missile’ was the result of the USA ‘Star Wars’ program. This missile was used for the
first time in the Gulf war against the Scud missile of Iraq. Surprisingly, ‘Patriot missiles’ failed
many times to hit the targeted Scud missile. One of the failures killed 28 American soldiers in
Dhahran, Saudi Arabia. An investigation team was constituted to identify the cause of failure.
The team re-looked at every dimension of the product and found the reason for the failure. The
cause of the failure was a software fault. There was a slight timing error in the system’s clock
after 14 hours of its operation.
4 .Failure of London Ambulance System
The London Ambulance Service was a challenging task that used to
cover an area of 600 square miles and handled 1500 emergency calls per day. Due to such a
failure, there was a partial or no ambulance cover for many hours. The position of the vehicles
was incorrectly recorded and multiple vehicles were sent to the same location. Everywhere
people were searching for an ambulance and nobody knew the reason for non-arrival of
ambulances at the desired sites. The enquiry committee clearly pointed out the administrative
negligence and over-reliance on ‘cosy assurances’ of the software company.
[Link] Software Failures
Financial software is an essential part of any company’s IT infrastructure. However, many
companies have suffered failures in the accounting system due to errors in the financial software.
The failures range from producing the wrong information to the complete system failure. Thereis
widespread dissatisfaction over the quality of financial software. If a system gives information
in the incorrect format, it may have an adverse impact on customer satisfaction.
 AJ

[Link] of Windows XP
“Microsoft released Windows XP on October 25, 2001. That same day, what
may be a record, the company posted 18 megabyte of patches on its website for bug fixes,
compatibility updates, and enhancements. Two patches fixed important security holes. Or
rather, one of them did; the other patch did not work. Microsoft advised (still advises) users to
back up critical files before installing patches.” This situation is quite embarrassing and clearly
explains the sad situation of the software companies. The developers were either too careless
or in a great hurry to fix such obvious faults.

[Link] is regression testing? Discuss various categories of selective re-test problem

When we develop software, we use development testing to obtain confidence in the correctness
of the software. Development testing involves constructing a test plan that describes how we
should test the software and then, designing and running a suite of test cases that satisfy the
requirements of the test plan. When we modify software, we typically re-test it. This process
of re-testing is called regression testing.
Hence, regression testing is the process of re-testing the modified parts of the software and
ensuring that no new errors have been introduced into previously tested source code due to
these modifications. Therefore, regression testing tests both the modified source code and other
parts of the source code that may be affected by the change. It serves several purposes like:
[Link] confidence in the correctness of the modified program.
[Link] errors in the modified program.
[Link] the quality and reliability of the software.
[Link] the software’s continued operation
[Link] All Test Cases
This is the simplest technique where we do not want to take any risk. We want to run all test
cases for any change in the program. This is the safest technique, without any risk. A program
may fail many times and every time we will execute the entire test suite. This technique is
practical only when the size of the test suite is small. For any reasonable or large sized test
suite, it becomes impractical to execute all test cases
[Link] Test Cases Randomly
We may select test cases randomly to reduce the size of the test suite. We decide how many
test cases are required to be selected depending upon time and available resources. When we
decide the number, the same number of test cases is selected randomly. If the number is large,
we may get a good number of test cases for execution and testing may be of some use. But, if
the number is small, testing may not be useful at all. In this technique, our assumption is that
all test cases are equally good in their fault detection ability. However, in most of the situations,
this assumption may not be true. We want to re-test the source code for the purpose of checking
the correctness of the modified portion of the program. Many randomly selected test cases may
not have any relationship with the modified portion of the program. However, random selection
may be better than no regression testing at all.
[Link] Modification Traversing Test Cases
We select only those test cases that execute the modified portion of the program and the portion
which is affected by the modification(s). Other test cases of the test suite are discarded.
Actually, we want to select all those test cases that reveal faults in the modified program.
These test cases are known as fault revealing test cases. There is no effective technique by
which we can find fault revealing test cases for the modified program. This is the best selection
approach, which we want, but we do not have techniques for the same. Another lower objective may
be to select those test cases that reveal the difference in the output of the original program and the
modified program. These test cases are known as modification revealing test cases. These test cases
target that portion of the source code which makes the output of the original program and the
modified program differ
 AJ

[Link] between the V-shaped software life cycle model and the waterfall model

[Link] some characteristics which the SRS document must address. How can these
be incorporated in a checklist?

[Link] :
In the SRS document, every requirement stated in the document should correctly represent an
expectation from the proposed software. All applicable safety and security requirements must be
identified. Also, all the inputs and outputs of each requirement are required and sufficient for the
specified processing. For example, If there’s a client requirement for the software to respond to all
buttons pressed within 2 seconds, but the SRS states that ‘the software shall respond to all buttons
pressed within 20 seconds’, then that will be referred to as incorrectness in the documentation.
[Link] :
The SRS document may contain some ambiguity in the software requirements. For example, If a
requirement conveys more than one meaning of a thing, then it will be a serious problem so, to avoid
this ambiguity, every requirement must have a single meaning only. Hence, the software requirement
 AJ

statement should be short, correct, precise, and clear. The SRS document checklist must focus on
ambiguous words to avoid ambiguity.
[Link] :
The SRS document should be complete in all aspects it must have all the important functional
requirements (like hardware faults, I/O errors, computational errors, processing overload, buffer
overflow, events failing to occur, etc.) and non-functional requirements needed for the software and
this completeness of the SRS document must be checked thoroughly through a checklist.
[Link] :
In the SRS document, the consistency of the document can be maintained if all the stated
requirements do not vary from the other stated requirements. Every object is referred to with a unique
name and is defined by one set of characteristics that are not in conflict with one another. Also, if the
Mathematical equations, acronyms, and abbreviations are defined and used consistently, then the
document will be consistent. The checklist must highlight the issues related to inconsistency and
should be designed to find inconsistencies.
[Link] :
In the SRS document, it is said to be verifiable, if and only if, every requirement stated in the
document is verifiable. The non-verifiable requirements include statements like ‘good interfaces’,
‘excellent response time’, ‘usually’, ‘well’, etc, which should not be used. The requirements
terminology like “shall”, “will”, “may”, etc. should be used. In the document, we should only use
measurable terms and must avoid all the indefinite terms.
[Link] :
The SRS document can be traceable if the source of every requirement is defined correctly as it may
help in future development. Traceability may help to structure the document and should find a place in
the design of the checklist.
[Link] :
In the SRS document, some of the requirements may not be feasible to implement due to technical
reasons or lack of resources so, those such requirements should be identified and accordingly removed
from the SRS document. A document checklist can also help us to find some other non-feasible
requirements in the software. Like for example, the data expected from external sources must exist at
the defined sources, or the data sent to external destinations is expected at those destinations
otherwise, the requirements may not be feasible to implement.

[Link] the testing tools

[Link] RUNNER
1. Load Runner: One of the best automated performance testing tool.
2. Uses ANSI C as the default programming language and other languages like Java
and VB.
3. No need to install it on the server under test. It uses native monitors.
4. Supports all types of protocols (HTTP, FTP and SMTP).
5. Easy to analyze the results and creating scripts.
As we know Load Runner was acquired by Hewlett-Packard organization. One of the best and
most used tool by many organizations. Though it's a paid tool, for perfect and easiness in use this
tool is the best.
For every tool, there is a testing process to test an application. For the Load Runner , the best
process to fo llow is

Components of Load Runner:

1) Vuser Generator
2) Controller
 AJ

3)Analyzer

VUser Generator:
The first component and the basic component is "Vuser Generator". In Load Runner tool, humans are
replaced by Vusers who are the replica of humans. More number of Vusers can be worked on a single
work station with different scenarios. Load runner can accommodate hundreds or even thousands of
Vusers with different scenarios.
With the help of Vuser script, users can perform the tests. User can record and
playback the application for script generation. By modification or editing the
scripts, user can create different scenarios for different Vusers. With this load test
can be made simple and easy with one workstation.
Load runner supports scripting languages like ANSI C, VB Script, JAVA etc..
C and VB scripting are the most used ones in load runner. In recent versions of
load runner JAVA scripting has been implemented, which can be widely used.

Controller:
In Load Runner ‘Controller’ is used to control the VUsers with single work
station with different scenarios assigned to VUsers.
Analysis:
After the performance test the user can view the results of the test in
[Link] into the concepts of Load Runner
Developing Vuser Script is a five step process:
Record a Vuser script
Vuser Script Enhancement – by adding the control statements and other functions
Run time Settings Configuration
Running of Vuser Script on Stand Alone machine – Verify that the script runs correctly
Integration of Vuser Script – into a LoadRunner scenario or Performance Center or
Tuning module session or Business process monitor profile etc

WINRUNNER
WinRunner is a testing tool to do functional/regression testing. Using WinRunner, you can
record GUI operations. While recording, WinRunner automatically creates a test script. This test
script can be run automatically later on for carrying out unattended testing. The important
aspects of WinRunner are:
• You can do functional/regression testing of a variety of application software written in
programming languages such as PowerBuilder, Visual Basic, C/C++, and Java. You can also
carry out the testing on ERP/CRM software packages.
• You can do the testing in all flavors of Windows operating systems and different
browser environments such as Internet Explorer and Netscape Navigator
•You can record the GUI operations in the 'record' mode. WinRunner automatically
creates a tesi script. This test can be modified if required and can be executed later on in
unattendaAmode. The recovery manager enables the application to be brought to a known
state in case there is a problem during the unattended testing. Rapid Test Script Wizard
creates the test scripts automatically.
• You can add checkpoints to compare actual and expected results. The checkpoints can
be GUI checkpoints, bitmap checkpoints and web links.
• It provides a facility for synchronization of test cases.
• Data Driver Wizard provides the facility to convert a recorded test into a data driven
test. So, you c*i replace data with variables within a test script. For example, you can test a
login process by taking the input for username and password fields from a database.
• Database checkpoints are used to verify data in a database during automated testing.
 AJ

The records that are inserted, deleted, modified, or updated will be highlighted so that you can
ensure database integrity and transaction accuracy.
• The Virtual Object Wizard of WinRunner is used to teach WinRunner to recognize,
record, and replay custom objects.
• The reporting tools provide the facility to generate automatically the test reports and
analyze the defects.
• WinRunner can be integrated with the testing management tool Test Director to
automate many of the activities in the testing process

[Link] are the Seven Steps for Testing Process

Testing Stage 1 – Test Plan
Software testing should always begin with establishing a well-thought-out test plan to ensure an
efficient execution of the entire testing process. An efficient test plan must include clauses concerning
the amount of work to be done, deadlines and milestones to be met, methods of testing, and other
formalities like contingencies and risks.

Deliverable: A document outlining the testing strategy, including the people involved, the scope of
testing, and the subsequent phases of testing the project will follow.

Testing Stage 2 – Analysis

At this stage, a functional validation matrix is made. The in-house or outsourced testing team analyzes
the requirements and test cases that are to be automated and which one need to be tested manually.
Like all other different stages of testing, this one has a crucial effect on the outcome of the project and
therefore needs a lot of attention.
Deliverable: A list of testable requirements and the required types and stages of testing needed to
complete the project and ensure deeper coverage; a requirement traceability matrix.

Testing Stage 3 – Design

If the testing team has reached this stage, it means that there is no confusion or misunderstanding
concerning the test plan, validation matrix, or test cases. At the Designing step of the software testing
stages, the testing team makes suitable scripts for automated test cases and generates test data for both
automated and manual test cases.

Deliverable: A document containing the test data for manual and automated testing that is relevant to
the software product being tested.

Testing Stage 4 – Development

At this stage, scripting is provided. In particular cases, development stage also includes unit tests and
generating of performance and stress test plans. Usually it happens when testing starts together with
the software development process. The team will also create a testing environment at this testing
phase.
Deliverable: A list of hardware and software requirements making up the test environment for the
project.
Testing Stage 5 – Execution
 AJ

As soon as the entire scripting has been made, its execution begins. First, the testing team executes
unit tests, and then functionality tests. They identify bugs on the superficial level and report them to
the software developers. After that, detailed testing is carried out. The execution part of the test stages
is completed when test and bug reports are made up.
Deliverables: Execution report & defect report.
Testing Stage 6 – Bug fixing
When the testing team identifies the bugs, they send it to development team. If the development team
considers fixing the bugs, the testing team has to retest the software in order to check that no new
bugs have been created while fixing using, among other things, regression testing.
Deliverable: Incident report.
Testing Stage 7 – Software is implemented
This is the final one of the testing stages and takes place all test cases are executed and all procedures
are carried out. The software is delivered to the end user who tests it and reports if any bugs take
place.
Deliverable: Test summary report & test closure report.

[Link] and explain some Automation and Testing Tools

[Link]:
Selenium is an open-source framework widely used for automating web browsers. It provides a suite
of tools and libraries for testing web applications across various browsers and platforms.
Key Features: Supports multiple programming languages (Java, Python, C#, etc.), provides a
WebDriver API for browser automation, and has a large community for support and extensions.
[Link]:
Cypress is an end-to-end testing framework focused on web applications. It’s known for its fast test
execution and real-time reloading, allowing developers to see test results as they code.
Key Features: Provides a built-in test runner, interactive debugging, and a user-friendly API for
writing tests in JavaScript. Ideal for front-end testing.
[Link]:
Playwright is an open-source automation framework for testing web applications in multiple
browsers, including Chromium, Firefox, and WebKit. It aims for reliability and speed in testing.
Key Features: Supports multiple programming languages, provides a unified API for cross-browser
testing, and offers features like automatic waiting and network interception.
[Link]:
Cucumber is a behavior-driven development (BDD) tool that promotes collaboration between
technical and non-technical team members. It uses plain-text scenarios to define and automate tests.
Key Features: Supports various programming languages, integrates with popular testing frameworks,
and encourages the creation of human-readable, executable specifications.
[Link]:
Tosca is a comprehensive test automation tool that covers functional, regression, and performance
testing. It incorporates artificial intelligence (AI) to improve test maintenance and execution.
Key Features: Offers model-based automation, supports multiple technologies, and provides a test
data management feature for efficient testing.
[Link]:
Appium is a leading mobile application automation tool. It allows testing of Android and iOS apps
using a single codebase and is well-suited for cross-platform mobile testing.
Key Features: Supports multiple programming languages, integrates with various testing
frameworks, and provides a wide range of capabilities for mobile app testing.
[Link] Studio:
Katalon Studio is a user-friendly automation tool known for its quick setup and ease of use. It covers
web, mobile, and API testing, making it suitable for comprehensive testing needs.
 AJ

Key Features: Offers a scriptless automation approach, supports popular programming languages, and
provides a rich set of built-in keywords for test creation.
[Link]:
Karate is a specialized tool designed for API testing. It combines API test automation, mock testing,
and performance testing in a single platform, making it highly versatile for API-related tasks.
Key Features: Uses a simple syntax for API testing, supports both JSON and XML, and allows for
easy integration with Continuous Integration (CI) tools.
[Link]:
SoapUI is a dedicated tool for testing APIs and web services. It offers a wide range of features for
functional and performance testing of REST and SOAP APIs.
Key Features: Supports REST and SOAP protocols, includes a user-friendly interface for test
creation, and provides in-depth reporting and analytics for performance testing.
[Link]:
TestComplete is a robust automation tool for testing desktop, web, and mobile applications. It’s
known for its scriptless automation capabilities and extensive support for different technologies.
Key Features: Offers a record-and-playback feature, supports multiple scripting languages, and
integrates seamlessly with popular CI/CD tools for automated testing.

[Link] Verification Testing, Validation Testing.

verification is the process of determining if the software in question is designed and developed
according to specified requirements. Specifications act as inputs for the software development
process. The code for any software application is written based on the specifications document.
Verification is done to check if the software being developed has adhered to these specifications at
every stage of the development life cycle. The verification ensures that the code logic is in line with
specifications.
Depending on the complexity and scope of the software application, the software testing team uses
different methods of verification, including inspection, code reviews, technical reviews, and
walkthroughs. Software testing teams may also use mathematical models and calculations to make
predictive statements about the software and verify its code logic.
Further, verification checks if the software team is building the product right. Verification is a
continuous process that begins well in advance of validation processes and runs until the software
application is validated and released.

The main advantages of the verification are:

It acts as a quality gateway at every stage of the software development process.
It enables software teams to develop products that meet design specifications and customer needs.
It saves time by detecting the defects at the early stage of software development.
It reduces or eliminates defects that may arise at the later stage of the software development process.
A walkthrough of verification of a mobile application
There are three phases in the verification testing of a mobile application development:
Requirements verification is the process of verifying and confirming that the requirements are
complete, clear, and correct. Before the mobile application goes for design, the testing team verifies
business requirements or customer requirements for their correctness and completeness.

Design verification is a process of checking if the design of the software meets the design
specifications by providing evidence. Here, the testing team checks if layouts, prototypes,
navigational charts, architectural designs, and database logical models of the mobile application meet
the functional and non-functional requirements specifications.
 AJ

Code verification is a process of checking the code for its completeness, correctness, and
consistency. Here, the testing team checks if construction artifacts such as source code, user
interfaces, and database physical model of the mobile application meet the design specification.

Validation
Validation is often conducted after the completion of the entire software development process. It
checks if the client gets the product they are expecting. Validation focuses only on the output; it does
not concern itself about the internal processes and technical intricacies of the development process.
Validation helps to determine if the software team has built the right product. Validation is a one-time
process that starts only after verifications are completed. Software teams often use a wide range of
validation methods, including White Box Testing (non-functional testing or structural/design testing)
and Black Box Testing (functional testing).
White Box Testing is a method that helps validate the software application using a predefined series of
inputs and data. Here, testers just compare the output values against the input values to verify if the
application is producing output as specified by the requirements.
There are three vital variables in the Black Box Testing method (input values, output values, and
expected output values). This method is used to verify if the actual output of the software meets the
anticipated or expected output.

The main advantages of validation processes are:

It ensures that the expectations of all stakeholders are fulfilled.
It enables software teams to take corrective action if there is a mismatch between the actual product
and the anticipated product.
It improves the reliability of the end-product.
A walkthrough of validation of a mobile application
Validation emphasizes checking the functionality, usability, and performance of the mobile
application.

Functionality testing checks if the mobile application is working as expected. For instance, while
testing the functionality of a ticket-booking application, the testing team tries to validate it through:
[Link], running, and updating the application from distribution channels like Google Play and the
App Store
[Link] tickets in the real-time environment (fields testing)
[Link] testing
Usability testing checks if the application offers a convenient browsing experience. User interface
and navigations are validated based on various criteria which include satisfaction, efficiency, and
effectiveness.
Performance testing enables testers to validate the application by checking its reaction and speed
under the specific workload. Software testing teams often use techniques such as load testing, stress
testing, and volume testing to validate the performance of the mobile application.
 AJ

[Link] are genetic algorithms? How are they different from traditional exhaustive
search based algorithms
The genetic algorithm is a method for solving both constrained and unconstrained optimization
problems that is based on natural selection, the process that drives biological evolution. The genetic
algorithm repeatedly modifies a population of individual solutions. At each step, the genetic algorithm
selects individuals from the current population to be parents and uses them to produce the children for
the next generation. Over successive generations, the population "evolves" toward an optimal
solution. You can apply the genetic algorithm to solve a variety of optimization problems that are not
well suited for standard optimization algorithms, including problems in which the objective function
is discontinuous, nondifferentiable, stochastic, or highly nonlinear. The genetic algorithm can address
problems of mixed integer programming, where some components are restricted to be integer-valued.
 AJ

Set-B
[Link] are the limitations of testing? Discuss with the help of examples
We want to test everything before giving the software to the customers. This ‘everything’ is
very illusive and has many meanings. What do we understand when we say ‘everything’? We
may expect one, two or all of the following when we refer to ‘everything’:
(i) Execute every statement of the program
(ii) Execute every true and false condition
(iii) Execute every condition of a decision node
(iv) Execute every possible path
(v) Execute the program with all valid inputs
(vi) Execute the program with all invalid inputs

[Link] in the Software Requirement and Specification Document

These issues are very difficult to identify. If 6+9=20 is written in the SRS document and our
program prints output as 20 when 6 and 9 are inputs, is it a bug? If the program prints output
as 15, when inputs are 6 and 9, how can we interpret? In this case, the actual output is so
obvious that interpretation may not require time to take a correct decision. But in most of the
situations, outputs are not so obvious. Some requirements may be misunderstood and some
may be missed. Ambiguities of natural languages (like English) may give more than one
meaning to a sentence and make life difficult for testers. Hence, problems in writing good SRS
have also become one of the problems of software testing
2. Logical Bugs
How do we handle logical bugs? An interesting example is given in Figure 1.9. In this function,
statement “d = c++;” given in line number 4 is incorrect. As per requirements, it should have
been “d = ++c”; but due to a typographical mistake and ignorance, “d = c++;” has been written.
This is a logical error and cannot be detected by the compiler. Here, confusion is due to the use
of prefix and postfix operators. A prefix operator first adds 1 to the operand and then the result
is assigned to the variable on the left. On the other hand, a postfix operator first assigns the
value to the variable on the left and then increment the operand .In this function the
postfix operator is used instead of the prefix operator. The function returns the integer value of
‘flag’.
1. int funct1 (int c)
2. {
3. int d, flag;
4. d = c ++ ; // should be d = ++ c; as per requirements
5. if (d < 20000)
6. flag = 1 ;
7. else
8. flag = 0;
9. return (flag);
10. }
3. Difficult to Measure the Progress of Testing
How to measure the progress of testing? Normally we count various things to measure and
interpret these counts. Is experiencing more failures good news or bad news? The answer could
be either. A higher number of failures may indicate that testing was thorough and very few
faults remain in the software. Or, it may be treated as an indication of poor quality of the
software with lots of faults; even though many have been exposed, lots of them still remain.
These counts may be illusive and may not help us to measure the progress of testing.
This difficulty of measuring the progress of testing leads to another issue i.e. when to stop
testing and release the software to the customer(s)? This is a sensitive decision and should be
based on the status of testing
 AJ

3. What are logical bugs? How are they different from syntax bugs?
A logical bug disrupts the intended workflow of software and causes it to behave incorrectly. These
bugs can result in unexpected software behavior and even sudden crashes. Logical bugs primarily take
place due to poorly written code or
misinterpretation of business logic.
Example of logical bugs include:
Assigning a value to the wrong variable
Dividing two numbers instead of adding
them together resulting in unexpected
output

A logic error represents a mistake in the

software flow and causes the software to
behave incorrectly. This type of error can
cause the program to produce an incorrect
output, or even hang or crash. Unlike
syntax errors, logic errors will not prevent
a program from compiling.

A common logic error is the infinite loop.

Due to poorly written code, the program
repeats a sequence endlessly until it crashes
or halts due to external intervention, such
as the user closing a browser window or
turning the power off.

[Link] a checklist for user documentation verification?

A checklist always helps the review process. A generic checklist for user documentation is
given . However, this may be modified depending on the nature, complexity and
applicability of the project.
 AJ

[Link] are various strategies for data validity? Discuss with the help of an example?
Valid data means correct data which is expected in every software. The software should
provide checks for validating data entered into the system. Whenever and wherever we attempt
to enter invalid data, an appropriate message should be displayed. Ideally, the software should
only allow the entry of valid data into the system. If we are able to do so with a good design,
we may be able to minimize many problems
[Link] Only Known Valid Data
We all want to enter valid data into the system. If our software accepts only correct data, our
design is a successful design. If it does not happen, we may enter invalid data into the system,
which may further complicate many issues. Invalid data may force the software to behave
unexpectedly and may lead to a failure. Hence, software should accept only input(s) that is /
are known to be safe and expected
[Link] Known Bad Data
We should be able to identify the correctness of the data. If the input data is not as expected,
the software should reject it and an appropriate error message should be displayed. We should
check the data type from the form itself. If the integer type x is the input and we enter x as a
float, an error should immediately be displayed. The software should accept values in the
specified range
 AJ

[Link] All Data

Data sanitization is the process of purifying (filtering) undesirable data in order to make it
harmless and safe for the system. We may sanitize data at the input stage where data is entered
by the user. We may also sanitize the data at the output stage where data is displayed to the
user in such a way that it becomes more useful and meaningful. For example, when an integer
variable is used, its lower and upper permissible limits must be specified and provisions should
be made in the program to prevent the entry of any value outside the permissible limit. These
limits are hardware dependent and may change, if not earlier specified. In case of Boolean
variable, provision should be made in the program to reject any value which is not from the
following list:
List = (true, false, 0, 1, yes, no)
Hence, we should attempt to make undesired data harmless, especially when dealing with
rejecting bad inputs. This may be easy to write but extremely difficult to do in practice. It is
advisable to reject undesired data if we want to play safe and secure.

[Link] Java Testing Tools in details

1. Arquillian
Arquillian is a highly innovative and extendible testing platform for JVM that allows developers
to easily create automated integration, functional and acceptance tests for Java. Arquillian allows
you to run test in the run-time so you don’t have to manage the run-time from the test (or the
build). Arquillian can be used to manage the life cycle of the container (or containers),bundling
test cases, dependent classes and resources. It is also capable of deploying archive into containers
and execute tests in the containers and capture results and create reports.
Arquillian integrates with familiar testing frameworks such as JUnit 4, TestNG 5 and allows tests
to be launched using existing IDE, and because of its modular design it is capable of running Ant
and Maven test plugins.
2. JTest
JTest also known as ‘Parasoft JTest’ is an automated Java software testing and static analysis
software made by Parasoft. JTest includes functionality for Unit test-case generation and
execution, static code analysis, data flow static analysis, and metrics analysis, regression testing,
run-time error detection.
There are also features that allow you to peer code review process automation and run-time error
detection for e.g.: Race conditions, exceptions, resource and memory leaks, security attack
vulnerabilities.
3. The Grinder
‘The Grinder’ is a Java load testing framework that was designed to make sure it was easy to run
 AJ

and distributed test’s using many load injector machines. The Grinder can Load test on anything
that has a Java API. This includes HTTP web servers, SOAP and REST web services, and
application servers and including custom protocols and the test scripts are written in the powerful
Jython and Clojure languages. The GUI console for The Grinder allows you to have multiple
load injectors to be monitored and controlled and Automatic management of client connections
and cookies, SSL, Proxy aware and Connection throttling.
It is freely available under a BSD-style open-source license. You can find out more on their
website.
4. TestNG
TestNG is a testing framework designed for the Java programming language and inspired by
JUnit and NUnit. TestNG was primarily designed to cover a wider range of test categories such
as unit, functional, end-to-end, integration, etc. It also introduced some new functionality that
make it more powerful and easier to use, such as: Annotations, Running tests in big thread pools
with various policies available, code testing in a multi thread safe, flexible test configurations,
data-driven testing support for parameters, and more.
TestNG is supported by a variety of tools and plug-ins such as Eclipse, IDEA, Maven, etc
5. Junit
JUnit is a unit testing framework designed for the Java programming language. JUnit has played
an important role in the development of test-driven development frameworks. It is one of a
family of unit testing frameworks which is collectively known as the xUnit that originated with
SUnit.
JUnit is linked as a JAR at compile-time and can be used to write repeatable tests
6. JWalk
JWalk is designed as a unit testing toolkit for the Java programming language. It has been
designed to support a testing paradigm called Lazy Systematic Unit Testing. The JWalkTester
tool performs any tests of any compiled Java class, supplied by a programmer. It is capable of
testing conformance to a lazy specification, by static and dynamic analysis, and from hints by the
programmer behind the code.
7. Mockito
Mockito is designed as a open source testing framework for Java which is available under a MIT
License. Mockito allows programmers to create and test double objects (mock objects) in
automated unit tests for the purpose of Test-driven Development (TDD) or Behavior Driven
Development (BDD).
8. Power mock
PowerMock is a Java Framework for unit testing of source code and It runs as an extension of
other Mocking frameworks like Mockito or Easy Mock but comes with more powerful
capabilities. Power Mock utilizes a custom class loader and bytecode manipulator to enable
mocking of static methods, removal of static initializes, constructors, final classes and methods
and private methods. It as been primarily designed to extend the existing API’s with a small
number of methods and annotations to enable the extra features.
9. JMeter
JMeter is a software that can perform load test, performance-oriented business (functional) test,
regression test, etc., on different protocols or technologies. JMeter is a Java desktop application with a
graphical interface that uses the Swing graphical API. It can therefore run on any environment /
workstation that accepts a Java virtual machine,
for example − Windows, Linux, Mac, etc.

[Link] the significance of virus and firewall testing.

Virus threats are the most sophisticated types of threats to web applications that may enter
from the network. A virus is a program that modifies other programs by attaching itself to the
program, which may infect the other programs when the host program executes. The virus may
 AJ

perform any function such as deleting files and programs. The goal of testing the web application
against virus threats is to verify the methods of virus prevention, detection and removal. Virus
testing ensures that:
(i) The antivirus software prevents the virus from entering into the system.
(ii) The antivirus software efficiently detects an infection, removes all traces of that
infection from the program and restores the program to its original state.
(iii) Periodical updates and scans are conducted to keep the system updated and prevent
new virus es from penetrating into the system

Computer networks have grown rapidly with the evolution of the internet. Internet
connectivity has become a necessity for many organizations. Although the internet provides an
organization access to the outside world, it also provides the intruders an opportunity to access
the organization’s Local Area Network (LAN). If the systems are affected from a security
failure, they must be recovered which may consume lots of effort and resources. Firewalls are
an effective means of protecting a network from intruders. It is placed between the organization’s
internal network and the external network. It serves as a security wall
between the outside world and the organization’s internal network. The aim of this wall is to
protect the LAN from the internet-based security threats and it serves as a single point where
all security checks are imposed. The firewall may be a single computer or a set of computers
may be combined to serve as a firewall

The idea of firewall testing is to break the system by bypassing the security mechanisms to
gain access to the organization’s sensitive information. This enables the tester to check the
effectiveness of the firewall. Firewall testing ensures that the zones of risks are identified
correctly, packet filtering occurs according to the designed rules, penetration within the
boundaries established by the firewall is not possible and events are timely logged to keep
track of an intruder.
Security testing requires an experienced tester having thorough knowledge of internet related
security issues. The security expert needs to check security issues including authentication,
unauthorized access, confidentiality, virus, firewalls and recovery from failure
 AJ

[Link] the advantages of automated test data generation over manual test data
generation
1. Cost-Saving
Contrary to the popular myth, automated testing is more cost-effective than manual. Manual testing
doesn’t allow you to run repetitive tests. In fact, the cost of testing your application manually rises as
time goes. By contrast, automated testing is cheaper in the long-term perspective, because once
you’ve created your test scripts, you can reuse them 24/7 without any additional cost. True, the initial
adoption of automaton may be somewhat expensive, but it will pay off quickly.
You have to keep in mind that the size of automated testing ROI depends on the level of automation
adoption. The more automated test cases you generate and use, the higher the return on investment.
But don’t forget that there are cases when manual testing is essential too.
[Link] Development and Delivery
Test automation will help you save your time. Automated tests are completed rapidly and can be run
repeatedly. In other words, you don’t have to wait for weeks to execute the tests all over again – just a
few hours will be enough.
To fast test execution and the repeatable nature of tests, automated testing increases the speed of
development. Here are some of the advantages you get by speeding up the testing process with
automation:
3. Increased Productivity
Automated tests don’t require any human intervention while running, meaning that you can test your
app at nighttime and harvest the results the next morning. Because automated tests can run repeatedly
on their own, software developers and QAs are able to spend less time on testing. Basically, with
automation, your engineers can focus on critical tasks. Everyone knows that fixing the existing app
functionality is not as exciting as creating new features.
4. More Accurate Tests
With test automation, you are more likely to have error-free releases. Thanks to minimized human
intervention, automated testing is more accurate than testing applications manually. The thing is, a
human tester can make mistakes during any step of evaluation. But the machine won’t. Generated test
cases are more precise than human testers, which means that by eliminating human errors, you will
reduce the risk of failure.
5. High App Quality and Performance
Thanks to the extensive test coverage, automated testing will ensure your app’s high quality and
performance. It allows you to run thousands of automated test cases simultaneously, so you can easily
test your app against multiple platforms, on several devices at a time. And if you want to make the
most out of test parallelism and concurrency, go for cloud-based device farms. They can help you
cover all the required variants of OS and hardware configurations.
6. Immediate Feedback
Another benefit of automated testing is instant feedback. With fast test execution, developers get
testing reports instantly, so whenever a failure occurs, they will react to it quickly. Forget about
struggling to decipher the code written three weeks ago.
Immediate feedback is especially useful when your application is already on the market. If you need
to fix some bugs quickly, manual testing will only slow the process down. By contrast, test
automation will help you make quick updates to your application. As a result, automated testing
brings high team responsiveness, better user experience and higher customer satisfaction.

7. CI/CD and DevOps Implementation

You can’t ignore test automation if you think about implementing the Continuous Delivery and
DevOps practices, because automated testing is the key to both of them. In the CI/CD pipeline, every
developer’s commit to the source code has to be tested, and there’s no way of doing it quickly and
efficiently except for test automation. So, having adopted automated testing, you will find switching
to Continuous Testing and Delivery easy.
 AJ

Too bad, you may have trouble orchestrating test automation across the CI/CD pipeline. It just gets
hard to manage when the complexity of code and the number of test cases grow. The good news is
that you can use AI-powered solutions that will assist you with ‘smart’ testing orchestration.
Moreover, AI can help you overcome test automation bottlenecks and enhance the benefits of
automated testing.

What is software testing? Is it possible to do complete testing?

Software Testing is a method to assess the functionality of the software program. The process
checks whether the actual software matches the expected requirements and ensures the software is
bug-free. The purpose of software testing is to identify the errors, faults, or missing requirements in
contrast to actual requirements. It mainly aims at measuring the specification, functionality, and
performance of a software program or application.
When someone wants you to perform complete testing then some questions arise very frequently ie.
“is complete testing really possible”? What does complete testing actually Mean?
Complete testing means “To test the software in such a way that no possibility of the bug is left in the
software at the end.“ Testing of the software depends on the test cases prepared and test cases which
are yet to be prepared are in the hands of the tester according to the software and client requirement.
These are the following types of coverages :
1. Statement coverage: In Statement coverage, every statement should be covered at least once.
2. Branch coverage: In this, every branch should be covered at least once.
3. Decision coverage: In this decision coverage, all the conditions whether true or false should be
executed. But at one, time condition can be true or false it cannot be true or false simultaneously.

These are the following reasons due to which complete testing is impossible:
1. The input domain is too large.
The input domain contains :
1.1 All valid input.
1.2 All Invalid input.
To test all valid and invalid input is very large operation and time consuming as well.
2. Deadline constraints: Usually people stop testing when time or money constraints arrive.
3. We can’t test all the combination of input
There can be multiple combinations of input which include the combination of valid and invalid input,
invalid and invalid input, valid and valid input.
4. We can’t test all paths. It becomes very difficult and time-consuming to test all paths.
For eg:
We have to test multiplication between two numbers. The first number should be between (0-N) and
the second number is between (0-AND) so the total no of the combination will be (n*n). Suppose to
test one input combination it is taking 1 sec so, test n input condition it will take n sec which makes
complete testing impossible.

5. Who should do the testing of the software? Is there any international standard?
Testing a software system may not be the responsibility of a single person. Actually, it is a
team work and the size of the team is dependent on the complexity, criticality and functionality
of the software under test. The software developers should have a reduced role in testing, if
possible. The concern here is that the developers are intimately involved with the development
of the software and thus it is very difficult for them to point out errors from their own creations.
Beizer explains this situation effectively when he states, “There is a myth that if we
were really good at programming, there would be no bugs to catch. If we could really
concentrate; if everyone used structured programming, top down design, decision figures; if
 AJ

programs were written in SQUISH; if we had the right silver bullets, then there would be no
bugs. So goes the myth. There are bugs, the myth says because we are bad at what we do; and
if we are bad at it, we should feel guilty about it. Therefore, testing and test design amount to
an admission of failures, which instils a goodly dose of guilt. The tedium of testing is just
punishment for our errors.
The testing persons must be cautious, curious, critical but non-judgmental and good
communicators. One part of their job is to ask questions that the developers might not be able
to ask themselves or are awkward, irritating, insulting or even threatening to the developers.
Some of the questions are:
(i) How is the software?
(ii) How good is it?
(iii) How do you know that it works? What evidence do you have?
(iv) What are the critical areas?
(v) What are the weak areas and why?
(vi) What are serious design issues?
(vii) What do you feel about the complexity of the source code?

Will exhaustive testing (even if possible for a very small program) guarantee that the program is
100% correct?
Exhaustive Testing is one of the software testing techniques, where the testing team tests all possible
input combinations for the software. Exhausting testing is about testing everything from top to
bottom and covering every possible scenario. Exhaustive Testing helps in making the application
more robust and successful and ensures that the application does not fail or crash in the most possible
cases.
Exhaustive Testing means testing the application as a whole and covering every possible thing but it is
not possible due to various reasons like:
Time-consuming: Sometimes there are a large number of input values and manually it is not possible
to test the application for all input combinations as it is time-consuming.
Complex: It is complex testing due to large input possible combinations to test a scenario and
practically it is not possible.
Design issues: The internal technical design of the application does not allow it to enter or behave
differently in particular situations. Like, a static variable will behave differently in its module and
other modules.
Time constraint: Time constraint is one of the big reasons that makes exhaustive testing impossible.
Sometimes the behavior of the application is affected by the climate, temperature, etc, and this turns
in result variation.
Different users: It is not possible to test the input combinations as per the type of users.
Testing situations: It is not possible to generate all input values of the probable output due to certain
testing situations.
Manual testing: Manual exhaustive testing is not possible as it takes the tester to his extreme edges to
test the application
 AJ

What are the objectives of testing? Why is the psychology of the testing person important?
[Link] bugs as soon as feasible in any situation.
[Link] errors in a project’s and product’s final versions.
[Link] to see whether the customer requirements criterion has been satisfied.
[Link] but not least, the primary purpose of testing is to gauge the project and product level of quality.
[Link] of Bugs and Errors
[Link] Quality Product
[Link] with Requirement
[Link] Confidence in the Product
[Link] Growth
It is mainly dependent on the mindset of the developers and testers, as well as the quality of
communication between them. Moreover, the psychology of testing improves mutual understanding
among team members and helps them work towards a common goal.
The three sections of the psychology of testing are:
1. The mindset of Developers and Testers:-The software development life cycle is a combination of
various activities, which are performed by different individuals using their expertise and knowledge.
It is not an unknown fact that to accomplish the success, development of software, people with
different skills and mindset are required.
Developers synthesize code. They build up things, putting pieces together and figuring out fun and
unique ways of combining those distinct little bits to do wonderful and amazing things.
But Testers are all about analysis. Once it has all been put together, the tester likes to take it apart
again, piece by piece, this time looking for those little corners, edges, and absurdities that hide in
those weird and strange interactions that come from those new and amazing ways of putting pieces
together.
2. Communication in a Constructive Manner
Testers and test managers need to have good interpersonal skills to be able to communicate effectively
about the defects, failures, test results, test progress and risks and to build positive relationships
among colleagues.
Communication, if done in a polite and respectful manner can help build a strong and reliable
relationship between the team members and help them avoid any misunderstanding.
3. Self-testing and Independent testing
Comparison of the mindsets of a tester and a programmer does not mean that a tester cannot be a
programmer, or that a programmer cannot be the tester, although they often are separate roles. In fact,
programmers are the testers. They always test the component which they built.
While testing their own code they find many problems so the programmers, architect, and developers
always test their own code before giving it to anyone.

What is a use case? How is it different from a use case diagram? What are the components of a
use case diagram?
A use case is a graphical representation of actions that describes behaviour of a system to do a
particular task.
A use case is started by a user for a specific purpose and completes when that purpose is
satisfied. It describes a sequence of actions a system performs to produce an observable output
for the interacting user (actor).
The real value of a use case is the dynamic relationship between the actor
and the system. A well written use case clarifies how a system is used by the
actor for a given goal or reason
A use case describes who (any user) does what (interaction) with the system, for what goal,
without considering the internal details of the system. A complete set of use cases explains the
various ways to use the system. Hence, use cases define expected behaviours of the system and
helps us to define the scope of the system.
 AJ

Use case diagram is also used along with use cases to explain the functionality of the system.
This is a graphical representation and gives the top view of the system along with its users and
use cases. Use case diagram may be decomposed into a further level of abstraction. Use cases
and use case diagrams are normally used together to define the behaviour of a system
A use case diagram visually explains what happens when an actor interacts with the system.
Actor represents the role of a user that interacts with the system. They are outsiders to the
system and can be human beings, other systems, devices, etc.
A use case diagram is a type of behavioral diagram that shows the interactions between a system and
its users, or actors. It is used to represent and model the functionality of a system. The main purpose
of a use case diagram is to capture the functional requirements of a system. They are often used
during the analysis and design phases of software development.

The four main components of a use case diagram are actors, the system itself, relationships, and use
cases.
Actors: Actors are the users of a system. They can be people, organizations, or other systems. An
actor can be a primary user or a secondary user of a system.
System: This refers to the system that is being modeled. It is the main focus of the use case diagram.
Relationships: Relationships show the interaction between the actors and the system. They are often
represented by lines or arrows.
Use Cases: Use cases are the actions that a system performs. They are often represented by
rectangles.

How do we write use cases? Describe the basic and alternative flows in a use case. Discuss any
popular template for writing a use case.
[Link] who is going to be using the website.
[Link] one of those users.
[Link] what that user wants to do on the site. Each thing the use does on the site becomes a use
case.
[Link] each use case, decide on the normal course of events when that user is using the site.
[Link] the basic course in the description for the use case. Describe it in terms of what the user
does and what the system does in response that the user should be aware of.
[Link] the basic course is described, consider alternate courses of events and add those to "extend"
the use case.
[Link] for commonalities among the use cases. Extract these and note them as common course use
cases.
[Link] the steps 2 through 7 for all other users.

Actors interact with the use cases for predefined purposes. Hence, each actor does something
with the system and the system responds accordingly. Each step is considered as a sequence of
events and is called a flow. There are two types of flows:
(i) Basic Flow: It is the main flow and describes the sequence of events that takes place
most of the time between the actor and the system to achieve the purpose of the use case.
(ii) Alternative Flows: If the basic flow is not successful due to any condition, the system takes an
alternative flow. An alternative flow may occur due to failure of an expected service because of
occurrence of exceptions/errors. There may be more than one alternative flow of a use case, but may
not occur most of the time. Any alternative flow takes place under certain conditions in order to fulfil
the purpose of a use case.
 AJ

Explain the various steps for the generation of test cases from the use cases. Why do we identify
variables in a use case?
[Link] of Scenario Diagrams
A use case scenario is an instance of a use case or a complete path through the use case The basic flow
is one scenario and every alternative path gives another scenario. Use case scenarios may also be
generated due to various combinations of alternative flows. In fig
The basic flow is represented by a straight arrow and the alternative flows by the curves.
Some alternative flows return to the basic flow, while others end the use case. At the end of the
basic flow, a post-condition is generated while at the starting of the basic flow, a pre-condition
is required to be set.
There are the following basic and alternative flows in login use case:
Basic flow: (i) Login (ii) Change password
Alternative flows: i) Invalid Login Id/password (ii) Invalid entry (iii) User
2 .Creation of Use Case Scenario Matrix
Use case scenario diagrams generate many scenarios due to the basic flow, every alternative
flow along with the basic flow and various combinations of the basic and alternative flows. A
scenario matrix gives all possible scenarios of the use case scenario diagram

[Link] of Variables in a Use Case

We have to identify all input variables which have been used in every use case. For a login use
case, we use ‘login Id’ and ‘password’ as inputs for entering into the use case. These are two
input variables for the ‘Login’ use case. A variable may also be used as a selection variable
where many options are available for a variable. A selection variable may be values of buttons
available which provide input to the use case at some intermediate step of the use case. For
example, ‘Updation confirmed?’ will provide two options to an actor ‘Yes/No’ and thus based
on this selection input, the decision on whether updation is to be made or not, is made. We may
select a semester from a drop down menu. The following variables are used in the login use
case:
(i)Login Id (ii) Password (iii) Old password (iv) New password (v) Confirm password
[Link] of Different Input States of a Variable
 AJ

An input variable may have different states and the behaviour of the system may change if the
state of a variable is changed. Any variable may have at least two states i.e. valid state and
invalid state. If we consider the ‘Login Id’ variable of the login use case, it is expected that the
“Login Id should be alphanumeric of length 11 characters and only digits from 0 to 9 are
allowed. Alphabets, special characters and blank spaces are not allowed.” Hence, one state is
the valid login Id as per the given directions and another state is the invalid login Id which is
different from the given directions
[Link] of Test Case Matrix
We identify all variables and their different states for the purpose of designing test cases. One
way to do so is to create a test case matrix where rows of the matrix contain test cases and the
first column contains the scenario name and description and the remaining columns may
contain the various input variables including the selection variables. The last column contains
the expected output when these inputs are given to the system.
[Link] Actual Values to Variables
In test case matrix, we have written only ‘valid input’, ‘invalid input’ and ‘not applicable (n/a)’
in the input value columns of various variables. Now, we want to assign actual values in these
columns in order to use them at the time of execution to get the actual output. We may also add
two additional columns with titles ‘Actual output’ and ‘Pass/fail’ which will be used at the time
of executing these test cases.

What are the guidelines for generating the validity checks? Explain with the help of an example
[Link] Type
If input x is defined as an integer, then x should also be checked for float, char, double, etc.
values. We should clearly state what can be accepted as an input. In the login form,
we should clearly state the type of both the inputs i.e. Login Id and password. For example, the Login
Id input should be numeric and should not accept alphabets, special characters and blank spaces.
Similarly, the password input will accept alphabets, digits, hyphen and underscore but will not accept
blank spaces. We should generate validity checks for every ‘do’ and every ‘do not’ case.
[Link] Range
The range of inputs should also be clearly specified. If x is defined as an integer, its range, (say 1
x 100) should also be defined. Validity checks may be written for conditions when x 1 and x >
100. For example, in login form, length of the login-id is defined as 11 digits and the password as
4 to 15 digits. We should generate validity checks for both valid and invalid range of inputs.
[Link] Data Conditions
Some special conditions may need to be checked for specified inputs. For example, in the
e-mail address, ‘@’ and ‘.’symbols are essential and must be checked. We should write validity
checks for such special symbols which are essential for any specific input.
[Link] Data Inputs
Some inputs are compulsory for the execution of a program. These mandatory fields should be
identified and validity checks be written accordingly. In the login form, both inputs (login Id
and password) are mandatory. Some fields (data inputs) may not be mandatory like telephone
number in a student registration form. We should provide validity checks to verify that
mandatory fields are entered by the user.
[Link] Specific Checks
Some validity checks should be written on the basis of the expected functionality. In the URS, no two
semesters should have a common paper. The roll number should be used as a login Id. A student cannot
select more than the required number of elective papers in a semester. These domain specific issues should
be written as validity checks in order to verify their correctness.
 AJ

Why should we do database testing? Write some advantages and applications of data base
testing.
In many software applications, we create and maintain databases. Items are added, viewed,
edited and deleted regularly as per requirements of the users. These operations are generally
performed using the interface forms where special provisions are provided for such operations.
These interface forms provide graphical interface to the users so that the user can add/edit/
delete/view information to and from the database easily, efficiently and in a user-friendly
manner. When a user wants to add an item, he/she is expected to be connected to the database.
Similar types of actions are required for other operations like ‘delete an item’, ‘edit an item’ or
‘view an item’. As a tester, we may like to verify the following:
(i) Is an item added in the database after the execution of ‘Add’ operation?
(ii) Is an operation deleted from the database after the execution of ‘Delete’ operation?
(iii) Is an item edited as desired in the database after the execution of ‘Edit’ operation?
(iv) Is an item viewed as expected after correctly retrieving from the database after the
execution of ‘View’ operation?
Advantages:-
[Link] testing ensures that your product works without any glitches.
[Link] enables you to efficiently and effectively discover issues or bugs during the early stages of
development.
[Link] makes use of advanced management solutions.
[Link] can be used with concurrency read and write.
[Link] data accuracy [Link] detection of errors
[Link] performance [Link] security:
[Link]-effective
Applications:-
[Link] JMeter. [Link] [Link] [Link] Factory
[Link] for Oracle [Link] Data Studio

Is it necessary to perform regression testing? Highlight some issues and difficulties of regression
testing.
Regression testing is important because it can help catch defects very early on when the cost of
remediation is still very low.
A regression testing strategy is your attempt to implement regression testing and make sure it is
effective and providing value to the organization.
Regression testing is vital for improving software product quality and enhancing the end-user
experience by ensuring that code changes do not impact the older or existing product functionality.
Using appropriate regression testing tools eliminates software defects early in the software
deployment cycle.
[Link] Testing take more time
There’s no way around it – regression testing involves running the same tests over and over again.
This can demoralize testers and over time, they might miss tests, ignore or misinterpret them.
2. Regression Testing Perceived as Having Little Value
Regression testing does not provide immediate value. Management asks: “why are we testing the
same features we built months or years ago? Why not spend the efforts on new features that generate
new revenue?” Testing teams often find themselves trying to justify the time spent on regression
testing – and often end up neglecting it and spending time on mission-critical activities.
3. High Cost
If regression testing is manual, it represents a high ongoing manpower cost. Organizations essentially
need to pay one or more tester’s salary just to run regression tests. If it’s automatic, there is an upfront
 AJ

cost in development, troubleshooting the regression test suite, and tooling – unless you use open
source, which usually translates into higher development and setup costs.
4. Time to Completion
Regression tests need to be run after every development iteration. If they are done manually (or even
semi-manually), they can take a few days to weeks for a complex product. In a world with dev sprints
averaging two weeks, can grind progress to a halt. Even if regression testing is fully automated, it can
slow down build times and become a bottleneck in the agile feedback cycle if they are not optimized.
5. Visibility:-Many organizations do not clearly define goals for their regression testing and the
metrics behind those goals. Testers do regression testing, but it is not clear how well it is done, and
what is the impact on the stability and quality of the software

Explain the various steps of the regression testing process. Which step is the most importa
Process of Regression testing:
Firstly, whenever we make some changes to the source code for any reasons like adding new
functionality, optimization, etc. then our program when executed fails in the previously designed test
suite for obvious reasons. After the failure, the source code is debugged in order to identify the bugs
in the program. After identification of the bugs in the source code, appropriate modifications are
made. Then appropriate test cases are selected from the already existing test suite which covers all the
modified and affected parts of the source code. We can add new test cases if required. In the end
regression testing is performed using the selected test cases.

Select all test cases: In this technique, all the test cases are selected from the already existing test
suite. It is the most simple and safest technique but not much efficient.
Select test cases randomly: In this technique, test cases are selected randomly from the existing test-
suite but it is only useful if all the test cases are equally good in their fault detection capability which
is very rare. Hence, it is not used in most of the cases.
Select modification traversing test cases: In this technique, only those test cases are selected which
covers and tests the modified portions of the source code the parts which are affected by these
modifications.
Select higher priority test cases: In this technique, priority codes are assigned to each test case of the
test suite based upon their bug detection capability, customer requirements, etc. After assigning the
priority codes, test cases with highest priorities are selected for the process of regression [Link]
case with highest priority has highest rank. For example, test case with priority code 2 is less
important than test case with priority code 1.
 AJ

What are the factors responsible for requirement changes? How are the requirements traced?
[Link] Defined Requirement Development Process [Link] Requirements
[Link] Technology. [Link] problems.
[Link] Changes [Link] Stakeholders.
[Link] optimistic budget or schedule [Link] not adequately defined
[Link] product lifecycle stages not addressed [Link] needs

Requirements are traced forward through other development artifacts, including test cases, test runs,
and issues. Requirements are traced backward to the source of the requirement, such as a stakeholder
or a regulatory compliance mandate.
The purpose of requirements traceability is to verify that requirements are met. It also accelerates
development. That’s because it’s easier to get visibility over your requirements.
Traceability is also important for analysis. If a requirement changes, then you can use traceability to
determine the impact of change. You’ll see what the requirement is connected to. And you’ll be able
to see how changing that requirement will impact related issues or tests.
Many organizations do this by creating a traceability matrix. This establishes an audit trail, which is
critical in regulated industries.
Requirement Traceability Matrix (RTM) is a document that maps and traces user requirement with
test cases. It captures all requirements proposed by the client and requirement traceability in a single
document, delivered at the conclusion of the Software development life cycle. The main purpose of
Requirement Traceability Matrix is to validate that all requirements are checked via test cases such
that no functionality is unchecked during Software testing.

How is risk analysis used in testing? How can we prioritize test cases using risk factor
Unexpected behaviours of a software programme always carry huge information and most of
the time they disturb every associate person. No one likes such unexpected behaviour and
everyone prays that they never face these situations in their professional career. In practice, the
situation is entirely different and developers do face such unexpected situations frequently and,
moreover, work hard to find the solutions of the problems highlighted by these unexpected
behaviours.
We may be able to minimize these situations, if we are able to minimize the risky areas of
the software. Hence, risk analysis has become an important area and in most of the projects we
are doing it to minimize the risk
[Link] is Risk?
Tomorrow’s problems are today’s risks. Therefore, a simple definition of risk is a problem that
may cause some loss or threaten the success of the project, but, which has not happened yet.
Risk is defined as the “probability of occurrence of an undesirable event and the impact of
occurrence of that event.” To understand whether an event is really risky needs an understanding
of the potential consequences of the occurrences / non-occurrences of that event. Risks may
delay and over-budget a project. Risky projects may also not meet specified quality levels.
Hence, there are two things associated with risk as given below:
(i) Probability of occurrence of a problem (i.e. an event)
(ii) Impact of that problem
Risk analysis is a process of identifying the potential problems and then assigning a
‘probability of occurrence of the problem’ value and ‘impact of that problem’ value for each
identified problem. Both of these values are assigned on a scale of 1 (low) to 10 (high). A factor
‘risk exposure’ is calculated for every problem which is the product of ‘probability of
occurrence of the problem’ value and ‘impact of that problem’ value. The risks may be ranked
on the basis of its risk exposure
 AJ

Explain the ‘code coverage prioritization’ technique. What are the test cases selection criteria?
Write the modification algorithm which is used to minimize and prioritize test cases.
Test Cases Selection Criteria
The technique is based on version specific test case prioritization where information about
changes in the program is known. Hence, prioritization is focused around the changes in the
modified program. We may like to execute all modified lines of source code with a minimum
number of selected test cases. This technique identifies those test cases that:
(i) Execute the modified lines of source code at least once
(ii) Execute the lines of source code after deletion of deleted lines from the execution
history of the test case and are not redundant.
The technique uses two algorithms one for ‘modification’ and the other for ‘deletion’. The
following information is available with us and has been used to design the technique:
(i) Program P with its modified program P .
(ii) Test suite T with test cases t1, t2, t3,…..tn.
(iii) Execution history (number of lines of source code covered by a test case) of each test
case of test suite T.
(iv) Line numbers of lines of source code covered by each test case are stored in a two
dimensional array (t11, t12, t13,……tij

a) What is usability testing? What steps must be followed in usability testing? (b) What is the
purpose of preparing a questionnaire in usability testing?
Identification of Participants
Who are the target users of a web application? It is important for an organization to identify
the characteristics of the participating users. Such characteristics may include age, gender,
profession and application specific experience.
We must remember two things when identifying the participants, that is, selection of the
right number and type of participants. The number of participants depends upon the degree of
confidence required, time and resources available, and availability of participants. We must
select an appropriate number of participants from different groups of target users as each group
of users will use the website with a different purpose.
Development of Usability Testing Questionnaire
This step involves the preparation of a questionnaire for conducting usability testing. A
usability testing test plan specifies a pre-defined set of tasks the participants are expected to
follow. Preparation of the questionnaire is an important activity and should take into
 AJ

consideration the usability features of the web application. The participant’s feedback and
reactions are recorded in the questionnaire. The research questions must include the participant’s
likes and dislikes about the website.
Setting up Environment for Conducting Test
This step involves deciding and setting up the location for conducting usability tests. The
decision of location and setups is based on various factors such as
(i) Whether the tester’s interaction with the user is required or not?
(ii) Whether enough space is available at the developer’s/ tester’s site in order to conduct
usability tests?
(iii) Is the location of the site easily accessible to target participants?
(iv) What equipment’s will be required for conducting the tests?
(v) How many participants and observers will be required?
(vi) Will the identity of the organization result in biased results?
(vii) What is the availability of the participants?
(viii) Is testing required at multiple geographic locations
Conducting the Test
This step consists of the execution of usability testing. These questions may be tailored as per the type
of a web application. The initial background details of the web application should not be given to the
user. The body language of the observer should not influence the participant.
The execution of usability tests should also involve the observation of reactions of the
participants as they perform the intended tasks. The observer must carefully observe the
emotions of the participants.
Analyse the Results and Observations
The process of generation of usability testing report involves organizing, summarizing and
analysing the collected data. This report contains a summary of the user’s preferences, list of
errors and difficulties encountered, identification of customer trends, and analysis of recordings.
Finally the observations are statistically analyzed and based on these analysis recommendations
are proposed. The tasks that do not meet the desired specifications are identified and prioritized.
The goal of usability testing is to improve the quality of the web application as per usability
Specifications

What is security testing? Explain the primary requirements that must be fulfilled by a web
application during security testing.
Security is the procedure used to protect information from various threats. It is very important
to protect sensitive and critical information and data while communicating over the network.
The user wants implementation of a safeguard to protect personal, sensitive and financial
information. We want data to be accurate, reliable and protected against unauthorized access.
Security involves various threats such as unauthorized users, malicious users, message sent
to an unintended user, etc
The primary requirement of security includes:
(i) Authentication: Is the information sent from an authenticated user?
(ii) Access Control: Is data protected from unauthorized users?
(iii) Integrity: Does the user receive exactly what is sent?
(iv) Delivery: Is the information delivered to the intended user?
(v) Reliability: What is the frequency of a failure? How much time does the network take
to recover from a failure? What measures are taken to counter catastrophic failure?
(vi) Non-repudiation: Is the receiver able to prove that the data received came from a
specific sender?
A web application must fulfil the above mentioned primary security requirements. Testing
the threats and vulnerabilities in a web application is an important activity. The tester must
check the web application against all known internet threats.
 AJ

What aspects must be covered in order to ensure database correctness in database testing?
Explain with the help of an example.
In database testing, the following aspects of correctness must be ensured:
(i) Are the database operations performed correctly?
(ii) Is concurrent users’ access to the database handled correctly?
(iii) Is the database fault tolerant?
(iv) Are the performance requirements such as throughput and response time met?
(v) Are backup and recovery procedures designed and ensure uninterrupted services to
the user?
(vi) Does the database restore to a consistent state after crash recovery?
(vii) Does the database have enough space and memory to store records and handle multiple
administrative and user operations?
Database testing may include generation of new records, monitoring of system performance
and verification of performance of the database processor

What is database testing? Identify administrative and user operations of an online purchase of a
website.
In web applications, many applications are database driven, for example, e-commerce related
websites or business-to-business applications. It is important for these applications to work properly
and provide security to the user’s sensitive data such as personal details and credit card information.
Testing data-centric web applications is important to ensure their error-free operation and increased
customer satisfaction. For example, consider the example for purchasing items from an online store.
If the user performs a search based on some keywords and price preferences, a database query is
created by the database server. Suppose due to some programming fault in the query, the query does
not consider the price preferences given by the customer, this will produce erroneous results. These
kinds of faults must be tested and removed during database testing.
Important issues in database testing may include:
(i) Data validation
 AJ

(ii) Data consistency

(iii) Data integrity
(iv) Concurrency control and recovery
(v) Data manipulation operations such as addition, deletion, updation and retrieval of data.
(vi) Database security
A database must be tested for administrative level operations such as adding, deleting and
updating an item in the database, and user operations such as searching an item from the
database or providing personal details. In the example of the online shopping website, the most
common administrative operations and user operations include:
Administrative operations
(i) Inserting a new item into the database
(ii) Deleting an existing item from the database
(iii) Updating an existing item from the database
(iv) Viewing an existing item from the database
User operations
(i) Searching items from the database
(ii) Registering into the website involves storing the user’s personal details
(iii) Placing an order involves storing user preferences and purchase details into the
database
(iv) Providing feedback involves storing information in the database
(v) Tracking status of the order placed

What is post deployment testing? How are surveys helpful in post deployment testing? Explain
the criteria that must be followed for deciding which suggested idea must be implemented.
Post-deployment testing may reveal those problems which went undetected before deployment
of the web application. Despite all the planning and testing carried out before deployment,
obtaining user opinion is important for improvement of a website and it ensures that the
website adapts to the needs of the user. User feedback may come in various forms, ranging
from reporting of faults to suggestions for improvement of the website.
The effective way to obtain a user’s opinion is to get a questionnaire or survey filled by the
user. The questionnaire/survey can be used to detect trends and may provide valuable
information for improvement of the website.
A survey consisting of general questions which must be asked from the user. The response obtained
from this survey may help the developer/owner of the website to improve the website.
Once the user’s opinion is obtained, it is important to identify useful fault reporting, suggestions
and recommendations. The following criteria can be used to decide which suggestion needs
attention:
1. How many users have given the same suggestion or Frequency of suggestion:
recommendation? If a small number of users are making the same request, then we must
think twice before implementing the suggestion.
2. Who is providing the suggestion? It is vital to make sure that Source of feedback:
suggestions come from regular users and not accidental users.
3. Is the suggested idea worth implementing? The Cost of implementing the suggestion:
correctness of the proposed change and its impact on the cost and schedule must be
analyzed carefully. The benefits of implementing the suggested idea to the business must
be determined.
4. Will implementing the suggestion increase Impact of implementing the suggestion:
complexity of the website? Will the change be compatible with the other functionalities
of the website? It is important to obtain the answers to these questions as the results of
implementing a change are sometimes unpredictable.
 AJ

Define usability. List and explain various attributes of usability.

What factors are considered while performing usability testing?
Usability is concerned with the degree to which the software fulfils the user’s specifications
and expectations. It is the measurement of the amount of satisfaction of the user. It also
assesses the extent to which the user finds the software easy to use, learn and understand.
Usability can be divided into one or more attributes such as accuracy, efficiency, completeness,
learnability, satisfaction, clarity and accuracy of online help and written documentation

What are the key areas in testing a web application? (b) Which conventional testing techniques
are applicable in testing a web application?
Web applications are difficult and complex as compared to traditional client-server applications. They
are required to be tested on different browsers and varied platforms. It is important and critical to
identify the areas that need special focus while testing a web application. A web application needs to
be tested for: (i) Functionalit (ii) Usability
(iii) Browser compatibility (iv) Security
(v) Load and stress (vi) Storage and Database
There are numerous issues that need to be considered that are specific to web application, hence,
only a sub-set of conventional testing techniques are applicable for testing a web application
1. FUNCTIONAL TESTING
Functional testing involves checking of the specified functionality of a web application. The
Functional test cases for web applications may be generated using boundary value analysis,
equivalence class testing, decision table testing and many other technique
The example of eCommerce application sells products such as computers, mobile phones, cameras,
electronics, etc. For each item it lists the name, quality, price and brief description. It also displays an
image of the item. The user may browse through the product and search any product by its name,
price or any other descriptive keyword. The user is required to register on the website to obtain access
to the online shopping cart
2. USER INTERFACE TESTING
User interface testing tests that the user interaction features work correctly. These features
include hyperlinks, tables, forms, frames and user interface items such as text fields, radio
buttons, check boxes, list boxes, combo boxes, command buttons and dialog boxes.
User interface testing ensures that the application handles mouse and keyboard events correctly
and displays hyperlinks, tables, frames, buttons, menus, dialog boxes, error message boxes,
and toolbars properly.
 AJ

3. Usability Testing
Usability is one of the quality attributes that a web application must possess. It is important to develop
a website that is easy to use. Whenever the user browses an online shopping website, several
questions may come to his/her mind. What is the credibility and reputation of the website? Are
shipping charges applicable? In how many days a product will be delivered? Is there any guidance on
how to place an order? In case of any problem, is there any grievance redressal mechanism? These
kinds of usability issues are faced by everyone who tries to purchase an item from an online shopping
website
4. CONFIGURATION AND COMPATIBILITY TESTING
One of the significant challenges of web testing is that it must ensure the proper functioning of a web
application on all the supported platforms and suitable environments. In the standalone desktop
computer environment, testing an application is an easy task, whereas the web application’s
environment significantly increases the testing effort due to rise in complexity and expectation. The
goal of configuration and compatibility testing is to detect faults in the application while it is tested on
varied platforms and environments. The performance and system’s requirement specifications formed
during the start of the project provides a baseline for creating configuration and compatibility test
cases.
5. SECURITY TESTING
Security is the procedure used to protect information from various threats. It is very important
to protect sensitive and critical information and data while communicating over the network.
The user wants implementation of a safeguard to protect personal, sensitive and financial information.
We want data to be accurate, reliable and protected against unauthorized access.
6. PERFORMANCE TESTING
One of the key advantages of web application is that numerous users can have access to the
application simultaneously. Hence, the performance of the application during the peak periods must
be tested and monitored carefully. Several factors that may influence performance include:
(i) Response time (ii) Memory available (iii) Network bandwidth (iv) Number of users
(v) User type (vi) Time to download (vii) Varied client machine configurations
7. DATABASE TESTING
In web applications, many applications are database driven, for example, e-commerce related
websites or business-to-business applications. It is important for these applications to work properly
and provide security to the user’s sensitive data such as personal details and credit card information.
Important issues in database testing may include:
(i) Data validation (ii) Data consistency (iii) Data integrity
(iv) Concurrency control and recovery (v) Database security
(vi)Data manipulation operations such as addition, deletion, updation and retrieval of data.

What are several factors that influence major components of a performance test report? 118 (a)
What is load testing? What metrics must be captured during load testing? (b) What do you
understand by the following terms? (a) Response time (b) Throughput (c) Web page views per
week (c) List some commercially available load testing tools.
(i) Response time
(ii) Memory available
(iii) Network bandwidth
(iv) Number of users
(v) User type
(vi) Time to download
(vii) Varied client machine configurations

Load testing involves testing the web application under real world scenarios by simulating
numerous users accessing the web application simultaneously. It tests the web application by
 AJ

providing it maximum load. The development of plans for load testing should begin as early
as possible during the software life cycle. Early testing will help in detection of problems prior
to deployment of the web application
n. Load testing may follow the following steps in order to
ensure reasonable performance during peak hours:
(i) Defining the environment for a load test
(ii) Defining the testing strategy and determining the number of users
(iii) Identifying potential metrics
(iv) Choosing the right tool and executing the load test
(v) Interpreting the results

Response time :-It measures the total time it takes after sending the request till the first response is
received.
Throughput:- It provides the amount of data sent by the application to the virtual users, measured in
bytes.
Web page views per week:- It counts the number of web pages viewed per week

Microsoft’s ACT, Neolys’ NeoLoad, Radview’s WebLoad, Red Gate’s ANTS profiler, Yahoo’s
Yslow, Webperformer’s Web Performance Load Tester and Empirix’s e-Test

Describe the procedure to conduct configuration and compatibility testing for a web application.
The process of testing involves several key steps. This is to ensure a thorough examination of
software compatibility. Let's see them.
[Link] target platforms.
The testing team determines the specific operating systems, browsers, and devices as the software will
be tested. For example, during functional testing, they select the appropriate configurations.
[Link] up the proper test environment.
The necessary hardware, software, and network configurations are set up. It is to replicate real-world
usage.
[Link] Compatibility Tests.
Various test versions are performed to test compatibility. Therefore, in this comprehensive approach,
the testing includes checking for functionality, etc.
[Link] and report any issues.
Any inconsistencies or problems encountered during the testing process are meticulously documented.
And reported to the software development team.
[Link] and resolve compatibility issues.
The development team analyzes the reported issues and, consequently, works on resolving them. They
ensure seamless compatibility across platforms.
[Link] and verify the fixes.
Once the compatibility issues are addressed, the software undergoes retesting. This is to verify that the
fixes have resolved the problems.
[Link] regression testing.
Regression tests are conducted to ensure no new issues. Additionally, they are performed to ensure it
does not conflict with other functionalities.
[Link] compatibility across platforms.
The software undergoes thorough testing on various platforms, devices, and environments. As a result,
it validates its compatibility and guarantees a consistent user experience.
[Link] and adapt to platform updates.
Continuous monitoring is essential to identify and address compatibility issues. It may arise due to
updates in operating systems, browsers, etc.
 AJ

[Link] the test results and finalize.

The test results, in addition to any remaining concerns, are documented. This documentation serves as
a valuable reference for future development and testing endeavors.

What is the most important type of testing which we consider when we test a web application?
Justify your answer.
Functional testing involves checking of the specified functionality of a web application. The
functional testing techniques are presented in chapter 2. Functional test cases for web
applications may be generated using boundary value analysis, equivalence class testing,
decision table testing and many other techniques.
Functionality testing is virtually the most basic, yet extremely crucial for any application – including
web. Functionality testing ensures a web application is working properly and correctly. Web testing
tools will inspect factors like making sure every link on the website points to the right page.

Functional testing covers:

Unit Testing: This stage of functional testing validates small and individual areas of the application in
the early stages of development to reduce the chance of escalating to more severe bugs later on
Smoke Testing, Build Verification Testing and Confidence Testing: After each build, this test is run
to verify the web application is stable and ready for further testing to avoid wasting testing efforts
Sanity Testing: Once the build verification is complete, this test checks the new code introduced and
specific functionalities
Regression Testing: Retest a selective list of test cases to identify areas that reacts more severe to
changes and ensure existing features stay functional
Integration Testing: locate faults on the linkage of interconnected modules (E.g., being redirected to
a Mailbox page after successfully signing up)
Usability Testing: Used to find areas for improvement to the overall UX design according to a real
user’s behavior and feedback

Describe the following metrics: (a) Information quality (b) Link quality (c) Image quality (d)
Content percentage (e) Wrapped links

Information quality :-Content appropriateness (i.e. relevance, language and tone) Information
quality (IQ) is the quality of the content of information systems. It is often pragmatically defined as:
"The fitness for use of the information provided". IQ frameworks also provides a tangible approach to
assess and measure DQ/IQ in a robust and rigorous manner
a multidimensional concept that encompasses critical relationships among multiple attributes, such as
timeliness, accuracy, relevancy, and others.
Image quality :-Image appropriateness and optimization (size and resolution)
Image quality can refer to the level of accuracy with which different imaging systems capture,
process, store, compress, transmit and display the signals that form an image. Another definition
refers to image quality as "the weighted combination of all of the visually significant attributes of an
image"
Link quality:- Link clarity and relevance
A quality link, or high-quality link, is one that sources from a high-quality website. Backlinks are one
of the pillars of an effective SEO strategy. They are essential to driving organic traffic and increasing
your site’s authority. In addition, search engines consider them one of their top three ranking factors.
Content percentage:- Portion of a page devoted to content
The composition of a page consists of the arrangement of all visual elements on a webpage like links,
words, percentage related to how much size does the page consuming, etc.
Wrapped links:- Links spanning multiple lines
 AJ

Explain three-tier architecture of a web application.

Three-Tier Architecture is an is an well established software application design pattern which will
organizes the application in the three logical and physical computing tiers as following:
[Link] Tier
[Link] Tier
[Link] Tier

Presentation Tier
It is the user interface and topmost tier in the architecture. Its purpose is to take request from the client
and displays information to the client. It communicates with other tiers using a web browser as it
gives output on the browser. If we talk about Web-based tiers then these are developed using
languages like- HTML, CSS, JavaScript.

Application Tier
It is the middle tier of the architecture also known as the logic tier as the information/request gathered
through the presentation tier is processed in detail here. It also interacts with the server that stores the
data. It processes the client’s request, formats, it and sends it back to the client. It is developed using
languages like- Python, Java, PHP, etc.

Data Tier
It is the last tier of the architecture also known as the Database Tier. It is used to store the processed
information so that it can be retrieved later on when required. It consists of Database Servers like-
Oracle, MySQL, DB2, etc. The communication between the Presentation Tier and Data-Tier is done
using middle-tier i.e. Application Tier.
Three-Tier Application In Web Development
Web Server: Web server is an presentation tier of an three-tier architecture which servers as an
presentation tier or UI (User Interface) tier. This content can be static or dynamic based on there
requirement such as an e-commerce site where users can add products to their shopping cart, enter
payment details, or create an account.
Application Server: Application tier is an middle tier which consists the full logical that is required
for the business which will process the user inputs and so on. It will performs the logic’s like queries
the inventory database to return product availability or adds details to a customer’s profile.
Database server: This is back-end tier of an web application it consists all the data so this tier mostly
there will be data base such as MySQL, Oracle, DB2 or PostgreSQL.
 AJ

Testing with WinRunner Involves Six Stages:-

Create the GUI Map
The first stage is to create the GUI map so WinRunner can recognize the GUI objects in
the application being tested. Use the Rapid Test Script wizard to review the user interface of your
application and systematically add descriptions of every GUI object to the GUI map.
Alternatively, you can add descriptions of individual objects to the GUI map by clicking objects
while recording a test.
Note that when you work in GUI Map per Test mode, you can skip this step.
Create Tests
Next, you create test scripts by recording, programming, or a combination of both. While
recording tests, insert checkpoints where you want to check the response of the application being
tested. You can insert checkpoints that check GUI objects, bitmaps, and databases. During this
process, WinRunner captures data and saves it as expected results—the expected response of the
application being tested.
Debug Tests
You run tests in Debug mode to make sure they run smoothly. You can set breakpoints, monitor
variables, and control how tests are run to identify and isolate defects. Test results are saved in
the debug folder, which you can discard once you’ve finished debugging the test.
When WinRunner runs a test, it checks each script line for basic syntax errors, like incorrect
syntax or missing elements in If, While, Switch, and For statements. You can use the Syntax
Check options Tools Syntax Check) to check for these types of syntax errors before running
your test.
Run Tests
You run tests in Verify mode to test your application. Each time WinRunner encounters a checkpoint
in the test script, it compares the current data of the application being tested to the expected data
captured earlier. If any mismatches are found, WinRunner captures them as actual results.
View Results
You determine the success or failure of the tests. Following each test run, WinRunner
displays the results in a report. The report details all the major events that occurred during the
run, such as checkpoints, error messages, system messages, or user messages.
If mismatches are detected at checkpoints during the test run, you can view the expected results
and the actual results from the Test Results window. In cases of bitmap mismatches, you can also
view a bitmap that displays only the difference between the expected and actual results.
Report Defects
If a test run fails due to a defect in the application being tested, you can report
information about the defect directly from the Test Results window.
This information is sent via e-mail to the quality assurance manager, who tracks the defect until
it is fixed

What is the testing process?

Testing is the process of executing a program or part of a program with the intention of finding errors.
The different phases of a test life cycle are Test Planning and Control, Test Analysis and Design, Test
Implementation and Execution, Evaluating Exit Criteria and Reporting, and Test [Link]
testing follows a common process. Tasks or steps include defining the test environment, developing
test cases, writing scripts, analyzing test results and submitting defect [Link] can be time-
consuming. Manual testing or ad-hoc testing may be enough for small builds.
AJ