Importance of Software Testing.......................................................................................

2
Basics of Quality Assurance (QA) in Sofware Development..........................................3
Writing Good Test Cases and Finding Bugs effectively.................................................4
Tips and Tricks for doing AdHoc Testing.......................................................................8
Best practices in Software Testing.................................................................................11
Importance of Software Test Automation using tools such as QTP..............................13
Importance of Software Testing

In Internet, We can see lot of articles explaining/listing loss made by poor low-
quality software products.

For example, how will you feel if a bug in a bank software shows your bank
balance as 0 instead of some thousands?
And if you are a student, what will you be your state if your marksheet shows
your score as 0 instead of some good score?

Here, we will be feeling good if we see some notification (e.g Not able to show
your balance due to some unexpected error/Couldn't print your marksheet
because of unexpected issue)
instead of seeing wrong data.

Testing plays an important role to avoid these situations.

So we can say that testing is necessary/important even when it couldn't

guarantee 100% error free software application.

And also,

- Cost of fixing the bug will be more if it is found in later stage than it is found
earlier.

- Quality can be ensured by testing only. In the competitive market,only Quality

product can exist for long time.

Testing will be necessary even if it is not possible to do 100% testing for an

application.

One more important reason for doing testing is user/production environment will
be completely different from development environment.

For example, a webpage developer may be using FireFox as browser for doing
his webpage development. But the user may be using different browser such as
Internet Explorer, Safari, Chrome and Opera.

The web page appearing good in FireFox may not appear good in other browsers
(particularly IE). So ultimately, user will not be happy even if the developer puts
more efforts to develop the webpage. As we know that Users satisfaction is more
important for growth of any business, testing becomes more important.
So we can assume/treat the Testers as the representatives of the Users.

↑ Grab this Headline Animator

Read Software Testing News and Articles. Follow Software Testing News

Basics of Quality Assurance (QA) in Sofware

Development

Quality Assurance is the most important factor in any business or industry.

Same thing is applicable for Software development also.
Spending some additional money for getting high quality product will definitely
give more profit.

But anyway, it is not true that expensive products are high-quality products. Even
inexpensive product can be high-quality product if it meets Customer’s
needs/expectation.

The quality assurance cycle consists of four steps: Plan, Do, Check, and Act.
These steps are commonly abbreviated as PDCA.

The four quality assurance steps within the PDCA model are

• Plan: Establish objectives and processes required to deliver the desired

results.

• Do: Implement the process developed.

• Check: Monitor and evaluate the implemented process by testing the

results against the predetermined objectives
 • Act: Apply actions necessary for improvement if the results require
changes.

For getting appropriate quality output in software development we need to follow

SQA (Software Quality Assurance) process in each phase (Planning,
Requirement Analysis, Design, Development, Integration & Test, Implementation
and Maintenance) of the software development lifecycle.

We should follow below solutions to avoid many software development problems.

• Solid requirements - Clear, complete, attainable, detailed and testable

requirements that are agreed by all players (Customer,developers and
Testers).
• Realistic schedules - Allocate enough time for planning, design,testing,
bug fixing, re-testing and documentation.

• Adequate testing - Start testing early, re-test after fixes/changes.

• Avoid unnecessary changes in initial requirements once after starting the

coding

• Require walk-through and inspections

To understand very basic things in software testing this knol will be useful.

↑ Grab this Headline Animator

Read Software Testing News and Articles. Follow Software Testing News

Writing Good Test Cases and Finding Bugs

effectively
To develop bug free software application, writing good test cases is essential.

Here, we will see how to write good test cases.

Before seeing this, we should understand what is Good Test Case.

There won't be any solid definition for "Good Test Case".

I will consider a Test Case as "Good" only when a Tester feels happy to follow
the steps in the Test Case which is written by another Tester.

Because, Test Cases will be useful only when it is used by the people.
If a test case is poorly written with excessive unwanted steps, then most of the
Testers won't read it fully. Just they will read few lines and will execute it based
on their own understanding which will be mostly wrong.

On the other hand, if it is having less details then it is difficult to execute it.

As of now, I am thinking below things for writing effective Test Cases.

• Before start writing test cases, become familiar with the (AUT) Application
Under Test. You will become familiar with Application by doing some
adhoc/exploratory testing.

• We should read the requirements clearly and completely. If we have any

questions in the Requirements it should be clarified by appropriate person
(e.g Customer or Business Team). And also, it is good practice to gather
some basic domain knowledge before getting into reading requirements
and writing Test Cases. And also, we can have discussion/meeting with
developers/business team

• Very Important thing is, we should use only simple language or style to
write the Test cases so that any one can easily understand without any
ambiguity

• Give meaningful and easily understandable Test case ID/number.

For example, if you are writing Test case for testing Login module you can
Test Case ID as below.
 1a - for testing positive scenario such as entering valid username and
valid password.
1b - for testing negative scenario such as entering invalid username and
invalid password.

By giving Test Case number as above instead of giving sequential

number, we can easily add any new case such as below one without
needing to adjust/modify number of any other subsequent test cases.

1c- for testing negative scenario such as entering valid username and
invalid password.

• And also, if we have any similar module we can give separate sequence
number for specifying the module.

For example, assume that we are having separate login modules for User
and Admin with little changes.
In this case we can give number as below,
1.1-First case in User module.
1.2-Second case in User module.
2.1-First case in Admin module
2.2-Second case in Admin module.

If Test Description/Steps/Expected Results of 2.1 is mostly same as 1.1

then we should refer 1.1 in 2.1 instead writing the sample details again.

By doing like this, we can avoid redundant details to have clear test case
document.

• Test Description should be short and it should uniquely represent the

current test scenario without any ambiguity.

• In any situation, don't use "if condition" in the Test steps. Always
address only one scenario in one test case. It will be helpful to have
unambiguous Expected Result.

• Give some sample test data that will be useful for executing the test
cases.
• If the Test Case requires any Preconditions/prerequisite don't forget to
mention them.
The best way is, we should arrange/order the Test Cases such that the
need for specifying precondition is minimum.

For example, we need to write test case for testing user creation, user
modification and user deletion.

For doing user modification and user deletion we should have already
created user as precondition.

If we arrange the Test cases in below mentioned order, we can avoid the
need for specifying any preconditions/prerequisites.
1-Test case for creating user.
2-Test case for verifying duplicate/existing user when adding another user
with same username.
3-Test case for modifying user.
4-Test case for deleting user.

• Keep Traceability Matrix to make sure that we have written test cases for
covering all requirements.

• Once after completing all positive scenarios, think about all possibilities of
negative scenarios to have test cases which will effectively find most of
the bugs.

For doing this we can refer alternate flow section of use case document,
and we can think about different data, boundary conditions, different
navigations paths and multi user environment.

• In the test case document, we can give link to screenshots explaining the
steps and/or expected results with pictures. But anyway, it is not good
practice to place the screenshots within the Test Case document itself
unless it is very essential

• Many tools are available to capture the screenshots with user action as
video. We can make use of them to keep video explaining the steps and
 expected results clearly in case the test case requires any complex steps.
We can give link to this video from the test case document.

↑ Grab this Headline Animator

Tips and Tricks for doing AdHoc Testing

It is always not possible to follow proper testing such as writing Test Plan and
writing Test cases.

In some cases we may need to go with adHoc Testing. because of time

constraint or resource constraint.

AdHoc Testing is the part of Exploratory testing.

It is done without doing Planning and Documentation.

Adhoc testing will help to find the defects earlier. We know that earlier a defect is
found the cheaper it is to fix it.

Here I am listing some tips for doing adhoc testing effectively.

• In case of UI (User Interface) testing, test all navigation including Back

button navigation.

Go thro' all the pages of the application to find any broken links and also
make sure that each and every page is having proper links to reach other
pages either directly or indirectly.

• Check whether all the images are having alt attribute

• See the the application screen or webpage by changing/setting different

screen resolution in your computer monitor
• Test the webpage in many different web browsers such as Internet
Explorer, FireFox, chrome, safari, etc.

• Test the tab order and default focus in all the pages

• Try to enter/save test data having special characters such as single

quotes, double quotes and comma

• You can try to enter text with HTML tags such as < and > also in the
textbox

• Try to load a authenticated webpage directly by entering url in the browser

without doing login

• Try all the possibilities of boundary values such entering lot of data in
textbox and entering negative values in numeric fields.

• Remember to navigate the application from two different

machines/browsers simultaneously, especially concentrate to test
concurrent database saving/updating operation.

• If possible/necessary, test the application in different OS (Operating

System)

• If your webpage uses flash files, try to see the behavior of your webpage
when it is loaded in a machine which is not having flash player.
• Instead of testing everything from your local machine, just try to test some
screens by hosting your site in some remote machine. It will help to
identify unexpected issues which may occur due to network latency.

• Test Session timeout, Cookie expiry and script execution timeout.

• Try to refresh your confirmation screen many times to verify whether the
multiple refresh saves/inserts the data multiple times.

• Test with different Date and Time format if you webpage/application has
date and time entry fields. And, think about Time zone also.

• Make sure that Number/Currency/Name format is correctly displayed in all

pages uniformly.

• When testing edit/modify/update feature, modify values of all fields and

make sure that everything is getting updated correctly.

• Whenever testing Delete feature make sure that all the related data also
getting deleted. For example, when deleting question and answers also
will be deleted.

And, make sure that necessary constraints are enforced correctly. For
example, deletion of questions should not be allowed if the questions are
already used in some other modules.

↑ Grab this Headline Animator

Best practices in Software Testing
There are lot of materials available in internet to explain best practices in
Software Testing.

Here I am writing only the very essential things for medium level projects based
on my experience/view point.

• We should start our testing activities at beginning of Software

development itself.
Understanding Scope/purpose of the project will help to judge the
degree/level of testing required.

• Testers should go thro' the requirements in detail without missing any

points given by the client before writing test cases.

• The test cases should be updated immediately once the client gives new
requirement or changes the requirements.

• The test case document should cover all the requirements even if some
requirements are non-testable. These non-testable items should be
marked as non-testable. Keeping traceability matrix document will
helpful to achieve this.

• The Test case document should help to clearly identify

hierarchy/arrangement of test cases. It should have clear approach to
arrange test cases if many test cases exist with similar steps. It is not
advisable to copy & paste the similar test cases many times, instead we
can specify only the additional/different steps.

• Description of each test case should be written clearly after

understanding the context/module of description. Steps should be written
only after manually executing them. Expected results should not have
any ambiguity. If required, Prerequisite/preconditions should be
mentioned.
• Planning and creating test plan document is essential even for small
short-term projects. The test plan document need not contain all the
details, but it should contain at least very basic components such as
scope,schedule, risks, environments, testers

• Planning of development/test/staging environments should be done

clearly. And it is very important to move the code and maintain version of
code in each environment without any ambiguity/confusion. Testers
should know which version of code/data is available in each environment

• Test execution should be done carefully based on the test cases. It is very
important to use appropriate test data. It is better to create different set
of test data during test case creation itself. The test data should cover
valid format,invalid format and boundary values.
Test result(pass/fail) should be clearly updated for each test case. It is
good practice to mention Actual behavior if the test case fails.

The test results should be communicated to the other parties

(developers,business/client) daily even if all the test cases are not
executed. In this case, we should add a note to indicate that the test
execution is still in progress.

The test execution summary document/mail should clearly mention date of

execution, environment, test name and test result.

• In case, most of test cases are getting failed continuously, there is no

meaning of continuing the execution. Execution should be resumed once
after fixing the major issues.

• It will be nice if we highlight the testing status (pass,fail,yetToStart) in

appropriate color. But anyway, just highlighting the test case with
appropriate color without specifying status is not a good practice. Because
while taking single color printout of the test report, it is difficult to see the
status from the color.
 • It is good practice to do some adhoc testing in addition to the test case
execution.

• Clear/proper communication/co-ordination within the Testing team and

also with other teams (developers, client/business)is very essential.

• The bug report should be prepared very clearly with all essential details,
especially with the steps/testdata for reproducing the bug. The bug report
should help the developers to reproduce the bug and to fix it.

• Doing re-test and small regression test is essential whenever a reported

bug is fixed

• It is not good if we do all the testing manually, as manual testing will take
more time/effort and it is difficult to manage, and also it not consistent or
repeatable. So it is better to automate the test cases using test tools such
as QTP(Quick Test professional). Even we can use simple shell scripts
and vbscript to automate some part of the testing.

↑ Grab this Headline Animator

Read Software Testing News and Articles. Follow Software Testing News

Importance of Software Test Automation using

tools such as QTP
Software Testing plays an important role in Software Development lifecycle.
Doing manual testing is not enough. We should go for Automation Testing also.

• "To Error is Human" is the fact which drives the need for automation
testing. Because, manual testers may not execute the test cases correctly.
There will be lot of possibilities for making mistakes. They may give
 wrong input data due to typo, or they may not notice the actual behavior
of the system correctly, or they may not report the test result correctly, or
they may miss to execute some test cases, or they may forget to run some
preconditions, or they may change the sequence of test case execution in
case sequence is important.

• Another important factor is, Automation test scripts will be used as a way
of storing domain/project/task Knowledge gained by the Test Engineers.
Say for example, if a Tester works in project for one year, he might have
spent more time for learning the domain, purpose of the project, modules
in the project, flow of all functionalities. He will be familiar with known
issues and challenges.
If this Tester leaves from the project, the knowledge gained by him also
will leave.
It is very difficult for the newly joining Tester to understand everything from
the Test Case document.

If automation test scripts are already available then the new Tester can
just start the testing by running the automation scripts, without gaining
much knowledge about the project.

He can understand the flow/data by seeing the execution of the

automation test scripts. But anyway, he should gain project/domain
knowledge to enhance/update the automation scripts further.
So we can say that test automation is a way of storing knowledge.

• Automation tool such as QTP (Quick Test Professional) has feature for
storing screenshot of each and every page navigated during the
execution. So it can be used as a proof for completion of testing, and also
we can refer the screenshots of previous executions if there is any need to
refer them.

• Test report can be automatically written to a customized report page which

will ensure accuracy of the report and also it can improve look & feel of the
report.

• The very important advantage of automation testing over manual testing

is, execution speed. Test execution can be completed quickly and also we
 can execution the scripts in night time also without human involvement. So
ultimately total time needed for testing can be reduced which will
significantly help for timely project completion.

• There may be requirement of doing some testing at specific time. It can be

easily achieved by putting execution of those automation test scripts in a
task scheduler/crone job. The tool such as QTP supports automation
object model to achieve this.

• The functional test automation scripts will be useful for doing performance
testing also. Because many performance test tools will support
reusing/calling of these test scripts.

• Some type of testing involves comparing large amount of data between

previous version and current version as part of regression testing.
Practically it may not possible for doing it manually. This problem can be
easily solved by simple shell script or any other scripts such as vbs, wsh.

• As the automation test tools support Data Driven Testing, Test execution
can be done repeatedly with many different data sets.

There are lot of automation test tools are available for doing Functional,
Regression and Performance Testing. Test complete, SilkTest,SilkPerformer,
QARun, QALoad, TestPartner, WinRunner, LoadRunner, QTP, Rational Robot
and openSTA are some of them. QTP is most widely used now as it supports
vbscript and it can be used for testing many different applications just by adding
required add-ins.

For learning QTP, visit our blog qualitypoint.blogspot.com