MANUAL TESTING

Software :-
1. Collection of programs to perform certain operation.
2. Set of instructions , data for execution of specific task
Types of Software:-
a) System Software :-
1. Set of instructions which are dedicated to managing system (Computer / Mobile / Tablet etc …)
is called as system software.
2. Communicates with hardware devices
3. Controls and monitors various hardware resources like CPU, memory, peripheral devices like
monitor, printer etc.
4. Supports the development and execution of other application software.

Few examples of system software are:

 Operating system
 Programming language translators
 Communication software
 Compiler and Interpreters
 Command line shell

b) Application Software :-
1. Application software is a collection of one or more programs used to solve a specific task or to
fulfill certain requirement
2. This is used to develop various applications like games , websites , etc …

Few examples of application software are:

 Word processing software (MS WORD)

 Spreadsheet software (XCEL)
 Database software (Oracle , MySQl , etc …)
 Education software (…..)
 Entertainment software (Media Player Vlc , KM , … etc)
 Language based application development software (Java , .net , php , etc …)

Software-Company:-
1. There are two types of company
 Product Based:-
 Product based company is a company which makes their own products to provide the
solution based on market value to meet clients requirements
  Service Based:-
 Service based is a company which provides software products and services to their
Respective clients.
Product And Project:-
a) Product :-
i. A software application developed by vender company to meet multiple customers requirement
is called product.
ii. A software application that can be offered to market to solve a problem.
iii. A software application i.e. developed to satisfy customers need
iv. Requirements gather from market survey or its own
v. Develop the application with its own time and avails it for all.
b) Project :-
I. A software application developed by third party vendor company for specific customer
requirement is called project
II. Customer other term known as client
III. Takes requirements from particular client and develop application and handover application
to respective clients within given time period
Need of Testing:-
I. To ensure software is bug free . And it should not enter in to any failure state.
II. To ensure software meets our customer requirements
III. To ensure software meets end user expectations
IV. To ensure quality of the product
V. To ensure effective performance of software application or product.
Software-Testing:-
1) Software testing is defined as an activity to check whether the actual results match the expected
results and to ensure smooth execution of software system or application to meet the customer
satisfaction as well as client expectation
2) Software testing also helps to identify errors or defects and missing requirements in contrary to
the actual requirements. It can be either done manually or using automated tools.
3) It’s a integral part of software development process .
4) Main objective of testing is to release quality product to client.
Software Quality:-
I. Quality is defined as justification of all the requirements of a customer in a software product.
II. It is the degree of conformance to explicit or implicit requirements and expectations.
III. Explicit: clearly defined and documented
IV. Implicit: not clearly defined and documented but indirectly suggested
V. Requirements: business/product/software requirements
VI. Expectations: mainly end-user expectations
VII. Quality software is reasonably :-
 1) Bug free
2) Delivered on time
3) Within budget
4) Meeting requirements and/or expectation
5) Maintainable
Why Software has bugs :-
Following are the various reason for software having bugs .
 Miscommunication or No Communication :-
 The success of any software application depends on communication between stakeholders,
development and testing teams. Unclear requirements and misinterpretation of requirements
are two major factors causing defects in software.

 Also, defects are introduced in the development stage if exact requirements are not
communicated properly to development teams.

 Software Complexity
 The complexity of current software applications can be difficult for anyone without experience in
modern-day software development.

 Windows-type interfaces, Client-Server, and Distributed Applications, Data Communications,

enormous relational databases, and sheer size of applications have all contributed to the exponential
growth in software/system complexity.The use of object-oriented techniques can complicate instead of
simplifying a project unless it is well-engineered.

 Programming Errors :-
 Programmers, like anyone else, can make programming mistakes. Not all developers are domain
experts. Inexperienced programmers or programmers without proper domain knowledge can introduce
simple mistakes while coding.
 Lack of simple coding practices, unit testing, debugging are some of the common reasons why these
issues get introduced at the development stage.

 Changing Requirements:-
 The customer may not understand the effects of changes or may understand and request them
anyway – redesign, rescheduling of engineers, effects on other projects, work already completed
that may have to be redone or thrown out, hardware requirements that may be affected, etc.
 If there are many minor changes or any major changes, known and unknown dependencies
among parts of the project are likely to interact and cause problems, and the complexity of
keeping track of changes may result in errors. The enthusiasm of engineering staff may be
affected.
 In some fast-changing business environments, continuously modified requirements may be a
fact of life.
  In this case, management must understand the resulting risks, and QA and test engineers
must adapt and plan for continuous extensive testing to keep the inevitable bugs from running
out of control.

 Poorly Documented Code:-

 It’s tough to maintain and modify the code that is badly written or poorly documented; the result
is Software Bugs. In many organizations, management provides no incentive for programmers
to document their code or write clear, understandable code.
 In fact, it’s usually the opposite: they get points mostly for quickly turning out code, and there’s
job security if nobody else can understand it (‘if it was hard to write, it should be hard to read’).
 Any new programmer starting to work on this code may get confused due to the complexity of
the project and the poorly documented code. Many times it takes longer to make small changes
in poorly documented code as there is a huge learning curve before making any code change.

 Obsolete Automation Scripts:-

 Writing automation scripts takes a lot of time especially for complex scenarios. If automation
teams record/write any test script but forget to update it over the period of time that test could
become obsolete.
 If the automation test is not validating the results properly it won’t be able to catch the defects.

 Not having a proper test setup (test environment) for testing all requirements.
 Starting to write code or test cases without understanding the requirements clearly.
 The incorrect design which leads to issues being carried out in all phases of the Software Development
Cycle.
 Releasing software patches frequently without completing the Software Testing Life Cycle.
 Not providing training to resources for the skills needed for developing or testing the application
properly.
 Giving very little or no time for Regression Testing.
 Not Automating Repetitive Test Cases and depending on the testers for manual verification every time.
 Not prioritizing test execution.
 Not tracking the development and test execution progress continuously. Last-minute changes are likely
to introduce errors.
 The wrong assumption made while coding and testing stages.

Error:- An unexpected behavior from system by human action is called error

Defect/Bug:-Unexpected behavior of software or system application which deviates from expected behavior to
actual behavior is called defect
Failure:- A failure is the inability of a software system or component to perform its required functions
within specified performance requirements. When a defect reaches the end customer it is called a Failure.
Reason For Defects:- There are several reason for defects .Find some common reason mentioned below.
I. Misunderstanding on functionality
II. Code/Programming Error
III. Chang in requirements
Etc …..
Software Testing Roles and Responsibilities :-

Software Development life Cycle (SDLC) :-

A. The Software Development Lifecycle is a systematic process for building software that ensures the
quality and correctness of the software application.
B. SDLC process aims to produce high-quality software which meets customer expectations. The
software development should be complete in the pre-defined time frame and cost.
C. SDLC consists of a detailed plan which explains how to plan, build, and maintain specific software.
Every phase of the SDLC lifecycle has its own process and deliverables that feed into the next phase.
SDLC Phages:- Please refer below diagram for different SDLC phages

SDLC Phases Description:-

Requirement Gathering And Analysis:-
 This is the 1st phage in SDLC process.
 During this phase, all the relevant information is collected from the customer to develop a product as
per their expectation. Any ambiguities must be resolved in this phase only.
 This phase is the main focus of the project managers and stake holders. Meetings with managers,
stake holders and users are held in order to determine the requirements like; Who is going to use the
system? How will they use the system? What data should be input into the system? What data
 should be output by the system? These are general questions that get answered during a
requirements gathering phase.
 E.g. :- A customer wants to have an application which involves money transactions. In this case, the
requirement has to be clear like what kind of transactions will be done, how it will be done, in which
currency it will be done, etc. Once the requirement gathering is done, an analysis is done to check
the feasibility of the development of a product. In case of any ambiguity, a call is set up for further
discussion. Once the requirement is clearly understood, SRS (Software Requirement Specification)
document is created. This document should be thoroughly understood by the developers and also
should be reviewed by the customer for future reference.

Feasibility Study:-
 Once the requirement analysis phase is completed the next step is to define and document software
needs.
 This process conducted with the help of 'Software Requirement Specification' document also known
as 'SRS' document. It includes everything which should be designed and developed during the
project life cycle.
 There are mainly five types of feasibilities checks:
o Economic: Can we complete the project within the budget or not?
o Legal: Can we handle this project as cyber law and other regulatory framework/compliances.
o Operation feasibility: Can we create operations which is expected by the client?
o Technical: Need to check whether the current computer system can support the software
o Schedule: Decide that the project can be completed within the given schedule or not.

Design:-
 This is third phage of SDLC
 The system and software design documents are prepared as per the requirement specification
document. This helps to understand overall architecture
 This phase is treated as input for next SDLC model
 There are two types of design document
I. High-Level Design (HLD):-
a. Brief description and name of each module
b. An outline about the functionality of every module
c. Interface relationship and dependencies between modules
d. Database tables identified along with their key elements
e. Complete architecture diagrams along with technology details
II. Low-Level Design(LLD):-

a. Functional logic of the modules

b. Database tables, which include type and size
c. Complete detail of the interface
d. Addresses all types of dependency issues
e. Listing of error messages
 f. Complete input and outputs for every module

Coding:-

 It is the longest phase of the Software Development Life Cycle process.

 After the design activity, the next phase of the Software Development Life Cycle is the
implementation or development of the software application.
 Developers start coding according to the requirements and the design discussed in previous phases
using the given programming language
 In the coding phase, tasks are divided into units or modules and assigned to the various developers.
 Database admins create the necessary data in the database, front-end developers create the necessary
interfaces and GUI to interact with the back-end all based on guidelines and procedures defined by
the company.
 Developers also write unit tests for each component to test the new code that they have written, review
each other’s code, create builds and deploy software to an environment. This cycle of development is
repeated until the requirements are met.

Testing:-

 Testing is the last phase of the Software Development Life Cycle before the software is delivered to
customers.
 This phages comes after development phase. In this phase once development of software application
completes , whole application is deployed into test environment.
 The testing team starts testing the functionality of the entire system. This is done to verify that the
entire application works according to the customer requirement.
 During this phase, QA and testing team may find some bugs/defects which they communicate to
developers. The development team fixes the bug and send back to QA for a re-test. This process
continues until the software is bug-free, stable, and working according to the business needs of that
system.

Installation & Deployment:-

 Once the software testing phase is over and no bugs or errors left in the system then the final
deployment process starts.
 Once the product is tested, it is deployed in the production environment or first UAT (User
Acceptance testing) is done depending on the customer expectation.
 In the case of UAT, a replica of the production environment is created and the customer along with
the developers does the testing. If the customer finds the application as expected, then sign off is
provided by the customer to go live.

Maintenance:-

 Once the system is deployed, and customers start using the developed system, following 3 activities
occur
  Bug fixing - bugs are reported because of some scenarios which are not tested at all
 Upgrade - Upgrading the application to the newer versions of the Software
 Enhancement - Adding some new features into the existing software

UAT(USER ACCEPTANCE TESTING):-

 This type of testing is performed by the Client to certify the system with respect to the requirements
that was agreed upon. This testing happens in the final phase of testing before moving the software
application to the Market or Production environment.
 The main purpose of this testing is to validate the end to end business flow. It does NOT focus on
cosmetic errors, Spelling mistakes or System testing. This testing is carried out in a separate
testing environment with production data setup.
When it Is tested :-
 This is typically the last step before the product goes live or before the delivery of the product is
accepted. This is performed after the product itself is thoroughly tested (after system testing).

Who Performs:-
 Client
 End-user
Software Testing life Cycle (STLC) :-
A. STLC is an integral part of Software Development Life Cycle (SDLC). But, STLC deals only with the
testing phases.
B. STLC is a sequence of different activities performed by the testing team to ensure the quality of the
software or the product.

STLC Phases :-
 There are 6 phases in STLC . Each of these stages has a definite Entry and Exit criteria, Activities &
Deliverables associated with it.
 Refer below diagram for different phases in STLC.
STLC Phases Description :-
Requirement Analysis :
 Requirement Analysis is the very first step in Software Testing Life Cycle (STLC). During this
phase, test team or Test Manager gathers Business Requirement Specification Document (BRD) from
stakeholders like Business Analysist(BA)/client and share this to team.
 Test team studies/analyze the requirement documents from a testing point of view to identify the
testable requirements. If any conflict, missing or not understood any requirement, then QA team
follow up with the various stakeholders like Business Analyst, System Architecture, Client,
Technical Manager/Lead etc for better understanding of the document.
 Different types of requirements :-
1) Business Requirements – They are high-level requirements that are taken from the business case
from the projects.
2) Architectural & Design Requirements – These requirements are more detailed than business
requirements. It determines the overall design required to implement the business requirement.
3) System & Integration Requirements – It is detailed description of each and every requirement. It can
be in form of user stories which is really describing everyday business language. The requirements
are in abundant details so that developers can begin coding.
 Entry Criteria :-
Following documents should be available
1) Requirements Specification
2) Application architectural
3) User Acceptance criteria should be well defined.
 Activities :-
1) Prepare the list of questions or queries and get resolved from Business Analyst, System
Architecture, Client, Technical Manager/Lead etc.
2) Identify types of tests like Functional, Security, and Performance etc to be performed
3) Define the testing focus and priorities.
4) Prepare Requirement Traceability Matrix (RTM).Generally this is done by Test Manager or
Lead. But all team members have to update this throughout the test life cycle .
5) List down the Test environment details where testing activities will be carried out.
6) Checkout the Automation feasibility if required & prepare the Automation feasibility
report.
 Deliverables / Exit Criteria :-
 1) List of questions with all answers to be resolved from business i.e. testable requirements
2) Requirement Traceability Matrix (RTM)
3) Automation feasibility report (if applicable)
Test Planning :-
 Its is one of the important phase of Software testing life cycle . This phase also called as Test
Strategy phase.
 This test planning is a document which will be prepared by senior people like Test lead or sometimes by
test manager

 Generally this document provides 3 basic things

 What to test
 How to test
 When to test
 Entry Criteria :-
Following documents should be available
1) Requirements Documents
2) Automation feasibility report.
 Activities :-
This phase contains the following activities.
 Describes Objective of project
 Describes scope of testing
 Features / functionalities to be tested
 Features / functionalities not to be tested
 Describes different test methodology/approach/strategy to follow
 Describes different level of testing to be performed
 Bug triage
 Describes entry / exit / suspension / resumption criteria
 Selection of testing tool If required
 Test effort estimation
 Resource planning and determining roles and responsibilities.
 Define the test environment required for project.
 Preparation of test plan
 Deliverables :-
1) Test Plan document
2) Test Strategy document
3) Best suited Testing Approach
4) Number of Resources, skill required and their roles and responsibilities
5) Testing tool to be used
6) Effort estimation document