Beginners Guide To Software Testing
Printed From: One Stop Testing
Category: Software Testing @ OneStopTesting
Forum Name: Beginners @ OneStopTesting
Forum Discription: New to the Club...!!! Don't Worry, We are here for you...!!! Learn the very basics of Software Testing and other pertinent Informations.
URL: http://forum.onestoptesting.com/forum_posts.asp?TID=7022
Printed Date: 01Jul2025 at 11:33am
Topic: Beginners Guide To Software Testing
Posted By: Mithi25
Subject: Beginners Guide To Software Testing
Date Posted: 17Sep2009 at 11:26pm
FOREWORD
Beginners Guide To Software Testing introduces a practical approach to
testing software. It bridges the gap between theoretical knowledge and
real world implementation. This article helps you gain an insight to
Software Testing - understand technical aspects and the processes
followed in a real working environment.
Who will benefit?
Beginners.
For those of you who wish to mould your theoretical software
engineering knowledge into practical approach to working in the real
world.
Those who wish to take up Software Testing as a profession.
Developers!
This is an era where you need to be an “All rounder”. It is
advantageous for developers to posses testing capabilities to test the
application before hand. This will help reduce overhead on the testing
team.
Already a Tester! You can refresh all your testing basics and techniques and gear up for Certifications in Software Testing
An earnest suggestion: No matter which profession you choose, it is advisable that you posses the following skills:
- Good communication skills – oratory and writing
- Fluency in English
- Good Typing skills
By the time you finish reading this article, you will be aware of all
the techniques and processes that improves your efficiency, skills and
confidence to jump start into the field of Software Testing.
1. Overview
The Big Picture
All software problems can be termed as bugs. A software bug usually
occurs when the software does not do what it is intended to do or does
something that it is not intended to do. Flaws in specifications,
design, code or other reasons can cause these bugs. Identifying and
fixing bugs in the early stages of the software is very important as
the cost of fixing bugs grows over time. So, the goal of a software
tester is to find bugs and find them as early as possible and make sure
they are fixed.
Testing is context-based and risk-driven. It requires a methodical and
disciplined approach to finding bugs. A good software tester needs to
build credibility and possess the attitude to be explorative,
troubleshooting, relentless, creative, diplomatic and persuasive.
As against the perception that testing starts only after the completion
of coding phase, it actually begins even before the first line of code
can be written. In the life cycle of the conventional software product,
testing begins at the stage when the specifications are written, i.e.
from testing the product specifications or product spec. Finding bugs
at this stage can save huge amounts of time and money.
Once the specifications are well understood, you are required to design
and execute the test cases. Selecting the appropriate technique that
reduces the number of tests that cover a feature is one of the most
important things that you need to take into consideration while
designing these test cases. Test cases need to be designed to cover all
aspects of the software, i.e. security, database, functionality
(critical and general) and the user interface. Bugs originate when the
test cases are executed.
As a tester you might have to perform testing under different
circumstances, i.e. the application could be in the initial stages or
undergoing rapid changes, you have less than enough time to test, the
product might be developed using a life cycle model that does not
support much of formal testing or retesting. Further, testing using
different operating systems, browsers and the configurations are to be
taken care of.
Reporting a bug may be the most important and sometimes the most
difficult task that you as a software tester will perform. By using
various tools and clearly communicating to the developer, you can
ensure that the bugs you find are fixed.
Using automated tools to execute tests, run scripts and tracking bugs
improves efficiency and effectiveness of your tests. Also, keeping pace
with the latest developments in the field will augment your career as a
software test engineer.
What is software? Why should it be tested?
Software is a series of instructions for the computer that perform a
particular task, called a program; the two major categories of software
are system software and application software. System software is made
up of control programs. Application software is any program that
processes data for the user (spreadsheet, word processor, payroll,
etc.).
A software product should only be released after it has gone through a
proper process of development, testing and bug fixing. Testing looks at
areas such as performance, stability and error handling by setting up
test scenarios under controlled conditions and assessing the results.
This is why exactly any software has to be tested. It is important to
note that software is mainly tested to see that it meets the customers’
needs and that it conforms to the standards. It is a usual norm that
software is considered of good quality if it meets the user
requirements.
What is Quality? How important is it?
Quality can briefly be defined as “a degree of excellence”. High
quality software usually conforms to the user requirements. A
customer’s idea of quality may cover a breadth of features -
conformance to specifications, good performance on
platform(s)/configurations, completely meets operational requirements
(even if not specified!), compatibility to all the end-user equipment,
no negative impact on existing end-user base at introduction time.
Quality software saves good amount of time and money. Because software
will have fewer defects, this saves time during testing and maintenance
phases. Greater reliability contributes to an immeasurable increase in
customer satisfaction as well as lower maintenance costs. Because
maintenance represents a large portion of all software costs, the
overall cost of the project will most likely be lower than similar
projects.
Following are two cases that demonstrate the importance of software quality:
Ariane 5 crash June 4, 1996- Maiden flight of the European Ariane 5 launcher crashed about 40 seconds after takeoff
- Loss was about half a billion dollars
- Explosion was the result of a software error
- Uncaught exception due to floating-point error: conversion from a
64-bit integer to a 16-bit signed integer applied to a larger than
expected number
- Module was re-used without proper testing from Ariane 4
- Error was not supposed to happen with Ariane 4
- No exception handler
Mars Climate Orbiter - September 23, 1999 - Mars Climate Orbiter, disappeared as it began to orbit Mars.
- Cost about $US 125-million
- Failure due to error in a transfer of information between a team in Colorado and a team in California
- One team used English units (e.g., inches, feet and pounds) while the other used metric units for a key spacecraft operation.
What exactly does a software tester do?
Apart from exposing faults (“bugs”) in a software product confirming
that the program meets the program specification, as a test engineer
you need to create test cases, procedures, scripts and generate data.
You execute test procedures and scripts, analyze standards and evaluate
results of system/integration/regression testing. You also...
· Speed up development process by identifying bugs at an early stage (e.g. specifications stage)
· Reduce the organization's risk of legal liability
· Maximize the value of the software
· Assure successful launch of the product, save money, time and
reputation of the company by discovering bugs and design flaws at an
early stage before failures occur in production, or in the field
· Promote continual improvement
What makes a good tester?
As software engineering is now being considered as a technical
engineering profession, it is important that the software test
engineer’s posses certain traits with a relentless attitude to make
them stand out.
Here are a few.
· Know the technology. Knowledge
of the technology in which the application is developed is an added
advantage to any tester. It helps design better and powerful test cases
basing on the weakness or flaws of the technology. Good testers know
what it supports and what it doesn’t, so concentrating on these lines
will help them break the application quickly.
· Perfectionist and a realist.
Being a perfectionist will help testers spot the problem and being a
realist helps know at the end of the day which problems are really
important problems. You will know which ones require a fix and which
ones don’t.
· Tactful, diplomatic and persuasive. Good
software testers are tactful and know how to break the news to the
developers. They are diplomatic while convincing the developers of the
bugs and persuade them when necessary and have their bug(s) fixed. It
is important to be critical of the issue and not let the person who
developed the application be taken aback of the findings.
· An explorer. A
bit of creativity and an attitude to take risk helps the testers
venture into unknown situations and find bugs that otherwise will be
looked over.
· Troubleshoot. Troubleshooting and figuring
out why something doesn’t work helps testers be confident and clear in
communicating the defects to the developers.
· Posses people skills and tenacity.
Testers can face a lot of resistance from programmers. Being socially
smart and diplomatic doesn't mean being indecisive. The best testers
are both-socially adept and tenacious where it matters.
· Organized.
Best testers very well realize that they too can make mistakes and
don’t take chances. They are very well organized and have checklists,
use files, facts and figures to support their findings that can be used
as an evidence and double-check their findings.
· Objective and accurate. They
are very objective and know what they report and so convey impartial
and meaningful information that keeps politics and emotions out of
message. Reporting inaccurate information is losing a little
credibility. Good testers make sure their findings are accurate and
reproducible.
· Defects are valuable. Good testers learn
from them. Each defect is an opportunity to learn and improve. A defect
found early substantially costs less when compared to the one found at
a later stage. Defects can cause serious problems if not managed
properly. Learning from defects helps – prevention of future problems,
track improvements, improve prediction and estimation.
Guidelines for new testers·
. Testing can’t show that bugs don’t exist. An
important reason for testing is to prevent defects. You can perform
your tests, find and report bugs, but at no point can you guarantee
that there are no bugs.
· It is impossible to test a program completely. Unfortunately
this is not possible even with the simplest program because – the
number of inputs is very large, number of outputs is very large, number
of paths through the software is very large, and the specification is
subjective to frequent changes.
· You can’t guarantee quality. As
a software tester, you cannot test everything and are not responsible
for the quality of the product. The main way that a tester can fail is
to fail to report accurately a defect you have observed. It is
important to remember that we seldom have little control over quality.
· Target environment and intended end user. Anticipating
and testing the application in the environment user is expected to use
is one of the major factors that should be considered. Also,
considering if the application is a single user system or multi user
system is important for demonstrating the ability for immediate
readiness when necessary. The error case of Disney’s Lion King
illustrates this. Disney Company released it first multimedia CD-ROM
game for children, The Lion King Animated Storybook. It was highly
promoted and the sales were huge. Soon there were reports that buyers
were unable to get the software to work. It worked on a few systems –
likely the ones that the Disney programmers used to create the game –
but not on the most common systems that the general public used.
· No application is 100% bug free. It
is more reasonable to recognize there are priorities, which may leave
some less critical problems unsolved or unidentified. Simple case is
the Intel Pentium bug. Enter the following equation into your PC’s
calculator: (4195835 / 3145727) * 3145727 – 4195835. If the answer is
zero, your computer is just fine. If you get anything else, you have an
old Intel Pentium CPU with a floating-point division bug.
· Be the customer.
Try to use the system as a lay user. To get a glimpse of this, get a
person who has no idea of the application to use it for a while and you
will be amazed to see the number of problems the person seem to come
across. As you can see, there is no procedure involved. Doing this
could actually cause the system to encounter an array of unexpected
tests – repetition, stress, load, race etc.
· Build your credibility.
Credibility is like quality that includes reliability, knowledge,
consistency, reputation, trust, attitude and attention to detail. It is
not instant but should be built over time and gives voice to the
testers in the organization. Your keys to build credibility – identify
your strengths and weaknesses, build good relations, demonstrate
competency, be willing to admit mistakes, re-assess and adjust.
· Test what you observe. It
is very important that you test what you can observe and have access
to. Writing creative test cases can help only when you have the
opportunity to observe the results. So, assume nothing.
· Not all bugs you find will be fixed. Deciding
which bugs will be fixed and which won’t is a risk-based decision.
Several reasons why your bug might not be fixed is when there is no
enough time, the bug is dismissed for a new feature, fixing it might be
very risky or it may not be worth it because it occurs infrequently or
has a work around where the user can prevent or avoid the bug. Making a
wrong decision can be disastrous.
· Review competitive products. Gaining
a good insight into various products of the same kind and getting to
know their functionality and general behavior will help you design
different test cases and to understand the strengths and weaknesses of
your application. This will also enable you to add value and suggest
new features and enhancements to your product.
· Follow standards and processes. As
a tester, your need to conform to the standards and guidelines set by
the organization. These standards pertain to reporting hierarchy,
coding, documentation, testing, reporting bugs, using automated tools
etc.
2. Introduction
Software Life Cycle
The software life cycle typically includes the following: requirements
analysis, design, coding, testing, installation and maintenance. In
between, there can be a requirement to provide Operations and support
activities for the product.
Requirements Analysis.
Software organizations provide solutions to customer requirements by
developing appropriate software that best suits their specifications.
Thus, the life of software starts with origin of requirements. Very
often, these requirements are vague, emergent and always subject to
change.
Analysis is performed to - To conduct in
depth analysis of the proposed project, To evaluate for technical
feasibility, To discover how to partition the system, To identify which
areas of the requirements need to be elaborated from the customer, To
identify the impact of changes to the requirements, To identify which
requirements should be allocated to which components.
Design and Specifications. The
outcome of requirements analysis is the requirements specification.
Using this, the overall design for the intended software is developed.
Activities in this phase -
Perform Architectural Design for the software, Design Database (If
applicable), Design User Interfaces, Select or Develop Algorithms (If
Applicable), Perform Detailed Design.
Coding. The
development process tends to run iteratively through these phases
rather than linearly; several models (spiral, waterfall etc.) have been
proposed to describe this process.
Activities in this phase
- Create Test Data, Create Source, Generate Object Code, Create
Operating Documentation, Plan Integration, Perform Integration.
Testing. The
process of using the developed system with the intent to find errors.
Defects/flaws/bugs found at this stage will be sent back to the
developer for a fix and have to be re-tested. This phase is iterative
as long as the bugs are fixed to meet the requirements.
Activities in this phase
- Plan Verification and Validation, Execute Verification and validation
Tasks, Collect and Analyze Metric Data, Plan Testing, Develop Test
Requirements, Execute Tests.
Installation. The so
developed and tested software will finally need to be installed at the
client place. Careful planning has to be done to avoid problems to the
user after installation is done.
Activities in this phase - Plan Installation, Distribution of Software, Installation of Software, Accept Software in Operational Environment.
Operation and Support.
Support activities are usually performed by the organization that
developed the software. Both the parties usually decide on these
activities before the system is developed.
Activities in this phase - Operate the System, Provide Technical Assistance and Consulting, Maintain Support Request Log.
Maintenance.
The process does not stop once it is completely implemented and
installed at user place; this phase undertakes development of new
features, enhancements etc.
Activities in this phase - Reapplying Software Life Cycle.
Various Life Cycle Models
The way you approach a particular application for testing greatly
depends on the life cycle model it follows. This is because, each life
cycle model places emphasis on different aspects of the software i.e.
certain models provide good scope and time for testing whereas some
others don’t. So, the number of test cases developed, features covered,
time spent on each issue depends on the life cycle model the
application follows.
No matter what the life cycle model is, every application undergoes the same phases described above as its life cycle.
Following are a few software life cycle models, their advantages and disadvantages.
Waterfall Model
Strengths:
•Emphasizes completion of one phase before moving on
•Emphasises early planning, customer input, and design
•Emphasises testing as an integral part of the life cycle •Provides quality gates at each life cycle phase
Weakness:
•Depends on capturing and freezing requirements early in the life cycle
•Depends on separating requirements from design
•Feedback is only from testing phase to any previous stage
•Not feasible in some organizations
•Emphasises products rather than processes
Prototyping Model
Strengths:
•Requirements can be set earlier and more reliably
•Requirements can be communicated more clearly and completelybetween developers and clients
•Requirements and design options can be investigated quickly and with low cost
•More requirements and design faults are caught early
Weakness:
•Requires a prototyping tool and expertise in using it – a cost for the development organisation
•The prototype may become the production system
Spiral Model
Strengths:
•It promotes reuse of existing software in early stages of development
•Allows quality objectives to be formulated during development
•Provides preparation for eventual evolution of the software product
•Eliminates errors and unattractive alternatives early.
•It balances resource expenditure.
•Doesn’t involve separate approaches for software development and software maintenance.
•Provides a viable framework for integrated Hardware-software system development.
Weakness:
•This process needs or usually associated with Rapid Application Development, which is very difficult practically.
•The process is more difficult to manage and needs a very different
approach as opposed to the waterfall model (Waterfall model has
management techniques like GANTT charts to assess)
Software Testing Life Cycle
Software Testing Life Cycle consist of six (generic) phases: 1)
Planning, 2) Analysis, 3) Design, 4) Construction, 5) Testing Cycles,
6) Final Testing and Implementation and 7) Post Implementation. Each
phase in the life cycle is described with the respective activities.
Planning.
Planning High Level Test plan, QA plan (quality goals), identify –
reporting procedures, problem classification, acceptance criteria,
databases for testing, measurement criteria (defect quantities/severity
level and defect origin), project metrics and finally begin the
schedule for project testing. Also, plan to maintain all test cases
(manual or automated) in a database.
Analysis. Involves
activities that - develop functional validation based on Business
Requirements (writing test cases basing on these details), develop test
case format (time estimates and priority assignments), develop test
cycles (matrices and timelines), identify test cases to be automated
(if applicable), define area of stress and performance testing, plan
the test cycles required for the project and regression testing, define
procedures for data maintenance (backup, restore, validation), review
documentation.
Design. Activities in the design phase
- Revise test plan based on changes, revise test cycle matrices and
timelines, verify that test plan and cases are in a database or
requisite, continue to write test cases and add new ones based on
changes, develop Risk Assessment Criteria, formalize details for Stress
and Performance testing, finalize test cycles (number of test case per
cycle based on time estimates per test case and priority), finalize the
Test Plan, (estimate resources to support development in unit testing).
Construction (Unit Testing Phase). Complete all plans,
complete Test Cycle matrices and timelines, complete all test cases
(manual), begin Stress and Performance testing, test the automated
testing system and fix bugs, (support development in unit testing), run
QA acceptance test suite to certify software is ready to turn over to
QA.
Test Cycle(s) / Bug Fixes (Re-Testing/System
Testing Phase). Run the test cases (front and back end), bug reporting,
verification, revise/add test cases as required.
Final Testing and Implementation (Code
Freeze Phase). Execution of all front end test cases - manual and
automated, execution of all back end test cases - manual and automated,
execute all Stress and Performance tests, provide on-going defect
tracking metrics, provide on-going complexity and design metrics,
update estimates for test cases and test plans, document test cycles,
regression testing, and update accordingly.
Post Implementation. Post
implementation evaluation meeting can be conducted to review entire
project. Activities in this phase - Prepare final Defect Report and
associated metrics, identify strategies to prevent similar problems in
future project, automation team - 1) Review test cases to evaluate
other cases to be automated for regression testing, 2) Clean up
automated test cases and variables, and 3) Review process of
integrating results from automated testing in with results from manual
testing.
-------------
http://www.quick2sms.com - Send Unlimited FREE SMS to Any Mobile Anywhere in INDIA,
Click Here
|
|