What is Domain Testing in Software Testing?

(with Example)

What is Domain Testing?

Domain Testing is a Software Testing process in which the application is tested by giving a minimum
number of inputs and evaluating its appropriate outputs. The primary goal of Domain testing is to check
whether the software application accepts inputs within the acceptable range and delivers required output.
It is a Functional Testing technique in which the output of a system is tested with a minimal number of
inputs to ensure that the system does not accept invalid and out of range input values. It is one of the most
important White Box Testing methods. It also verifies that the system should not accept inputs, conditions
and indices outside the specified or valid range.
Domain testing differs for each specific domain so you need to have domain specific knowledge in order
to test a software system.
In this tutorial, you will learn-
 Simpler Practice of Domain Testing
 Domain Testing Strategy
 Domain Testing Example
 Domain Testing Structure

Simpler Practice of Domain Testing

In domain testing, we divide a domain into sub-domains (equivalence classes) and then test using values
from each subdomain. For example, if a website (domain) has been given for testing, we will be dividing
the website into small portions (subdomain) for the ease of testing.
Domain might involve testing of any one input variable or combination of input variables.
Practitioners often study the simplest cases of domain testing less than two other names, “boundary
testing” and “equivalence class analysis.”
Boundary testing – Boundary value analysis (BVA) is based on testing at the boundaries between
partitions. We will be testing both the valid and invalid input values in the partition/classes.
Equivalence Class testing – The idea behind this technique is to divide (i.e. to partition) a set of test
conditions into groups or sets that can be considered the same (i.e. the system should handle them
equivalently), hence ‘equivalence partitioning.’
That simplified form applies for Domain testing –
1. Only to tests of input variables
2. Only when tested at the system level
3. Only when tested one at a time
4. Only when tested in a very superficial way
It can be simplified as below:
Variable Valid Class Equivalence Class Invalid Class Equivalence Class Boundaries & Special ca
X 0-100 0
100
<0 -1
>100 101
Explanation:
 1. If a field accepts ranges from 0-100, the field should not accept -1 and 101 as they are invalid
entries and beyond the boundaries.
2. The field should accept values such as 0,100 and any number between them.
Building table like these (in practice)
1. To build an equivalence class analysis over time put the information into a spreadsheet. Start by
listing variables. Add information about them as you obtain it.
2. The table should eventually contain all variables. This means, all input variables, all output
variables, and any intermediate variables that you can observe.
3. In practice, most tables that I have seen are incomplete. The best ones seen list all the variables
and add detail for critical variables.

Domain Testing Strategy

While domain testing, you need to consider following things,
1. What domain are we testing?
2. How to group the values into classes?
3. Which values of the classes to be tested?
4. How to determine the result?
What domain are we testing?
Any domain which we test has some input functionality and an output functionality. There will be some
input variables to be entered, and the appropriate output has to be verified.

Domain Testing Example

1. Consider a single input test scenario:
C = a+b, where a and b are input variables and C is the output variable.
Here in the above example, there is no need of classification or combination of the variables is required.
2. Consider the below multiple inputs and appropriate output scenario:
Consider a games exhibition for Children, 6 competitions are laid out, and tickets have to be given
according to the age and gender input. The ticketing is one of the modules to be tested in for the whole
functionality of Games exhibition.
According to the scenario, we got six scenarios based on the age and the competitions:
 1. Age >5 and <10, Boy should participate in Storytelling.
2. Age >5 and <10 , girl should participate in Drawing Competition.
3. Age >10 and <15, Boy should participate in Quiz.
4. Age >10 and <15 , girl should participate in Essay writing.
5. Age<5, both boys and girls should participate in Rhymes Competition.
6. Age >15, both boys and girls should participate in Poetry competition.
Here the input will be Age and Gender and hence the ticket for the competition will be issued. This case
partition of inputs or simply grouping of values come into the picture.
How to group the values into classes?
Partitioning some values means splitting it into non-overlapping subsets.
As we discussed earlier there are two types of partitioning:
1. Equivalence partitioning – Equivalence partitioning is a software testing technique that divides
the input data of a software unit into partitions of equivalent data from which test cases can be
derived. In principle, test cases are designed to cover each partition at least once.
2. Boundary value analysis – Boundary value analysis is a software testing technique in which
tests are designed to include representatives of boundary values in a range. The idea comes from
the boundary.
For the above example, we are partitioning the values into a subset or the subset. We are partitioning the
age into the below classes :
1. Class 1: Children with age group 5 to 10
2. Class 2 : Children with age group less than 5
3. Class 3: Children with age group age 10 to 15
4. Class 4: Children with age group greater than 15.
Which values of the classes to be tested?
The values picked up for testing should be Boundary values:
1. Boundaries are representatives of the equivalence classes we sample them from. They’re more
likely to expose an error than other class members, so they’re better representatives.
2. The best representative of an equivalence class is a value in between the range.
For the above example we have the following classes to be tested:
For example for the scenario #1:
1. Class 1: Children with age group 5 to 10 (Age >5 and <=10)
Boundary values:
1. Values should be Equal to or lesser than 10. Hence, age 10 should be included in this class.
2. Values should be greater than 5. Hence, age 5 should not be included in this class.
3. Values should be Equal to or lesser than 10. Hence, age 11 should not be included in this class.
4. Values should be greater than 5. Hence, age 6 should be included in this class.
5. Equivalence partition is referred when one has to test only one condition from each partition. In
this, we assume that if one condition in a partition works, then all the condition should work. In
the same way, if one condition in that partition does not work then we assume that none of the
other conditions will work. For example,
6. (Age >5 and <=10)
7. As the values from 6 to 10 are valid ones, one of the values among 6,7,8,9 and 10 have to be
picked up. Hence selected age “8” is a valid input age for the age group between (Age >5 and
<=10). This sort of partition is referred as equivalence partition.
Hence, if all the test cases of the above pass, the domain of issuing tickets in the competition get passed.
If not, the domain gets failed.

Domain Testing Structure

Usually, testers follow the below steps in a domain testing. These may be customized/ skipped according
to our testing needs.
 Identify the potentially interesting variables.
 Identify the variable(s) you can analyze now and order them (smallest to largest and vice versa).
 Create and identify boundary values and equivalence class values as above.
 Identify secondary dimensions and analyze each in a classical way. (In the above example,
Gender is the secondary dimension).
 Identify and test variables that hold results (output variables).
 Evaluate how the program uses the value of this variable.
 Identify additional potentially-related variables for combination testing.
 Imagine risks that don’t necessarily map to an obvious dimension.
 Identify and list unanalyzed variables. Gather information for later analysis.
 Summarize your analysis with a risk/equivalence table.
Summary:
Domain testing, as it is described above, requires knowledge of providing right input to achieve the
desired output. Thus, it is only possible to use it for small chunks of code.

Test Documentation in Software Testing (Example)

What is Test Documentation?

Test documentation is documentation of artifacts created before or during the testing of software. It helps
the testing team to estimate testing effort needed, test coverage, resource tracking, execution progress, etc.
It is a complete suite of documents that allows you to describe and document test planning, test design,
test execution, test results that are drawn from the testing activity.
What is Documentation Testing?
Documentation Testing involves testing of the documented artifacts that are usually developed before or
during the testing of Software.
Documentation for Software testing helps in estimating the testing effort required, test coverage,
requirement tracking/tracing, etc. This section includes the description of some commonly used
documented artifacts related to Software development and testing, such as:
 Test Plan
 Requirements
 Test Cases
 Traceability Matrix

For a newbie, it’s easy to assume that Testing is executing the various section of code on an ad-hoc basis
and verifying the results. But in the real world, Testing is a very formal activity and is documented in
detail. Test Documentation makes planning, review, and execution of testing easy as well as verifiable.
The degree of test formality depends on
 The type of application under test
 Standards followed by your organization
 The maturity of the development process.
Testing activities generally consume 30% to 50% of software development project effort.
Documentations help to identify Test process improvement that can be applied to future projects.

Examples of Test Documentation

Here, are important Types of Test Documentation:
ypes of Testing Documents Description
It is a high-level document which describes principles, methods and all the important t
Test policy
organization.
Test strategy A high-level document which identifies the Test Levels (types) to be executed for the projec
A test plan is a complete planning document which contains the scope, approach, resource
Test plan
testing activities.
Requirements Traceability
This is a document which connects the requirements to the test cases.
Matrix
Test Scenario Test Scenario is an item or event of a software system which could be verified by one or mo
It is a group of input values, execution preconditions, expected execution postcondition
/test-case.html
developed for a Test Scenario.
Test Data Test Data is a data which exists before a test is executed. It used to execute the test case.
Defect report is a documented report of any flaw in a Software System which fails to pe
Defect Report
function.
Test summary report is a high-level document which summarizes testing activities conducte
Test summary report
result.

Best practice to Achieve Test Documentation

 QA team needs to be involved in the initial phase of the project so that Test Documentation is
created in parallel
 Don’t just create and leave the document, but update whenever required
 Use version control to manage and track your documents
 Try to document what is needed for you to understand your work and what you will need to
produce to your stakeholders
 You should use a standard template for documentation like excel sheet or doc file
 Store all your project related documents at a single location. It should be accessible to every team
member for reference as well as to update when needed
 Not providing enough detail is also a common mistake while creating a test document

Advantages of Test Documentation

 The main reason behind creating test documentation is to either reduce or remove any
uncertainties about the testing activities. Helps you to remove ambiguity which often arises when
it comes to the allocation of tasks
 Documentation not only offers a systematic approach to software testing, but it also acts as
training material to freshers in the software testing process
 It is also a good marketing & sales strategy to showcase Test Documentation to exhibit a mature
testing process
 Test documentation helps you to offer a quality product to the client within specific time limits
 In Software Engineering, Test Documentation also helps to configure or set-up the program
through the configuration document and operator manuals
 Test documentation helps you to improve transparency with the client

Disadvantages of Test Documentation

 The cost of the documentation may surpass its value as it is very time-consuming
 Many times, it is written by people who can’t write well or who don’t know the material
 Keeping track of changes requested by the client and updating corresponding documents is tiring.
 Poor documentation directly reflects the quality of the product as a misunderstanding between the
client and the organization can occur
Summary
  Test documentation is documentation of artifacts created before or during the testing of software.
 The degree of test formality depends on 1) the type of application under test 2) standards
followed by your organization 3) the maturity of the development process.
 Important types of Test Documents are Test policy, Test strategy, Test plan, Test case etc.
 QA team needs to be involved in the initial phase of the project so that Test Documentation is
created in parallel
 The main reason behind creating test documentation is to either reduce or remove any
uncertainties about the testing activities.
 The cost of the documentation may surpass its value as it is very time-consuming
What Is Software Compatibility Testing?
Compatibility Testing Tutorial:
The computer has become an essential part of our lives. Several software applications have been
developed to help teach people in their careers, work, shopping, and in many other actions.

Online purchasing is very common nowadays. While selling the product or software, the online seller has
to keep in mind that the product he is selling should be bug-free otherwise seller might lose business and
reputation while the buyer of the software may waste his or her money in buying defective software.

To endure the competitive market, it is a necessity that the software or applications you provide to buyers
are worth the amount they are paying. To deliver a good quality product it is very important the
application or software goes through different stages of development in terms of quality, compatibility,
reliability, and delivery.

hat is Software compatibility?

Compatibility is the ability to live and work together without any discrepancy. Compatible software
applications also work on the same setup. For example, if the Google.com site is compatible, then it
should open in all browsers and operating systems.
What is Software Compatibility Testing?
Compatibility is non-functional testing to ensure customer satisfaction. It is to determine whether your
software application or product is proficient enough to run in different browsers, databases, hardware,
operating system, mobile devices, and networks.

The application could also impact due to different versions, resolution, internet speed and configuration,
etc. Hence it’s important to test the application in all possible manners to reduce failures and overcome
embarrassments of bug leakage. As a Non- functional test, Compatibility testing is to endorse that the
application runs properly in different browsers, versions, OS, and networks successfully.

Compatibility tests should always perform in a real environment instead of a virtual environment.
Test the compatibility of the application with different browsers and operating systems to guarantee
100% coverage.
Types Of Software Compatibility Testing
 Browser compatibility testing
 Hardware
 Networks
 Mobile Devices
 Operating System
 Versions
It is very popular in compatibility testing. It is to check the compatibility of the software application on
different browsers like Chrome, Firefox, Internet Explorer, Safari, Opera, etc.

Hardware
It is to check the application/ software compatibility with the different hardware configurations.

Network
It is to check the application in a different network like 3G, WIFI, etc.

Mobile Devices
It is to check if the application is compatible with mobile devices and their platforms like android, iOS,
windows, etc.

Operating Systems
It is to check if the application is compatible with different Operating Systems like Windows, Linux,
Mac, etc.

Versions
It is important to test software applications in different versions of the software. There are two different
types of version inspection.

Backward Compatibility Testing: Testing of the application or software in old or previous versions. It
is also known as downward compatible.
Forward Compatibility Testing: Testing of the application or software in new or upcoming versions. It
is also known as forward compatible
Why Do We perform Compatibility Testing?
Compatibility testing is to check whether the application working in the same way for all platforms.

Usually, the dev team and testing team test the application on a single platform. But the once application
is released in production, the customer may test our product on a different platform and they may find
bugs in the application which is not worthy in terms of quality.
To reduce such issues and not upset your customers it is important to test the application on all platforms.

When Should Perform Compatibility Testing?

When the build gets stable enough to test then we should perform compatibility testing.

Common Compatibility testing defects

 Changes in UI ( look and feel)
 Change in a font size
 Alignment related issues
 Change in CSS style and color
 Scroll bar related issues
 Content or label overlapping
 Broken tables or Frames
Pick what to test as compatibility testing

Make a note of the most important testing parameter for your application where you feel the application
can behave weirdly. Decide versions of browsers, operating systems, and devices where you would like to
test your application.

The best practice is to analyze the requirement and cross-check with the client or customer for the
browser matrix. Let the customer decide which all browsers, OS, and versions they would like us to test
the application.

With the help of Google Analytics or an alternative type of statistical analysis system set up on your
application can give you clear statistics of the widely used browser with their version and operating
system.
Select pages to test

Filter out the main urls, and pages of your application. The selection of the pages totally depends on your
application. You would require considering the majorly used modules as a part of compatibility testing. If
your application consists of a certain template format, it’s fine if you consider that only as a part of
compatibility testing.

How to perform Compatibility testing?

Test the application in the same browsers but in different versions. For Example, to test the
compatibility of the site ebay.com. Download different versions of Firefox and install them one by one
and test the eBay site. eBay site should behave equally the same in each version.
Test the application in different browsers but in different versions. For Example, testing of site
ebay.com in different available browsers like Firefox, Safari, Chrome, Internet Explorer and Opera, etc.
Conclusion
The use of compatibility testing is to make sure the software application is working fine in all aspects of
browsers, databases, hardware, operating system, mobile devices, and networks. Make a pattern to test
your application in equal intervals of time to confirm browser and operating system compatibility.

State Transition Testing – Diagram &

Technique (Example)

What is State Transition Testing?

State Transition Testing is a black box testing technique in which changes
made in input conditions cause state changes or output changes in the
Application under Test(AUT). State transition testing helps to analyze
behaviour of an application for different input conditions. Testers can provide
positive and negative input test values and record the system behavior.
It is the model on which the system and the tests are based. Any system
where you get a different output for the same input, depending on what has
happened before, is a finite state system.
State Transition Testing Technique is helpful where you need to test
different system transitions.

When to Use State Transition?

 This can be used when a tester is testing the application for a finite set of input values.
 When the tester is trying to test sequence of events that occur in the application under
test. I.e., this will allow the tester to test the application behavior for a sequence of input
values.
 When the system under test has a dependency on the events/values in the past.

When to Not Rely On State Transition?

 When the testing is not done for sequential input combinations.
 If the testing is to be done for different functionalities like exploratory testing

Four Parts Of State Transition Diagram

There are 4 main components of the State Transition Model as below
1) States that the software might get
2) Transition from one state to another

3) Events that origin a transition like closing a file or withdrawing

money

4) Actions that result from a transition (an error message or being

given the cash.)

State Transition Diagram and State Transition Table

There are two main ways to represent or design state transition, State transition diagram, and
state transition table.
In state transition diagram the states are shown in boxed texts, and the transition is represented
by arrows. It is also called State Chart or Graph. It is useful in identifying valid transitions.
In state transition table all the states are listed on the left side, and the events are described on the
top. Each cell in the table represents the state of the system after the event has occurred. It is also
called State Table. It is useful in identifying invalid transitions.

How to Make a State Transition (Examples of a State Transition)

Example 1:
Let’s consider an ATM system function where if the user enters the invalid password three times
the account will be locked.
In this system, if the user enters a valid password in any of the first three attempts the user will
be logged in successfully. If the user enters the invalid password in the first or second try, the
user will be asked to re-enter the password. And finally, if the user enters incorrect password
3rd time, the account will be blocked.
State transition diagram
In the diagram whenever the user enters the correct PIN he is moved to Access granted state, and
if he enters the wrong password he is moved to next try and if he does the same for the 3 rd time
the account blocked state is reached.
State Transition Table
Correct PIN Incorrect PIN
S1) Start S5 S2
st
S2) 1 attempt S5 S3
nd
S3) 2 attempt S5 S4
rd
S4) 3 attempt S5 S6
S5) Access Granted – –
S6) Account blocked – –
In the table when the user enters the correct PIN, state is transitioned to S5 which is Access
granted. And if the user enters a wrong password he is moved to next state. If he does the same
3rd time, he will reach the account blocked state.

What is State or Graph based Testing

State Based Testing:-
State Based means change of sate from one state to another.State based Testing is
useful to generate the test cases for state machines as it has a dynamic behavior
(multiple state) in its system. we Can explain this using state transition diagram.It is
a graphic representation of a state machine.

For eg we can take the behavior of mixer grinder. The state transition for this will be like
1. switch on -- turn towards 1 then 2 then 3 then turn backwards to 2 then 1 then off
2. switch on - directly turn backwards to 3 then turn towards to off then turn towards 1 then
2 then 3 then turn backwards to 2 then 1 then off
Each represents a state of machine. Like this we can draw state transition diagram. Valid test
cases can be generated by:
 Start from the start state
 Choose a path that leads to the next state
 If you encounter an invalid input in a given state, generate an error condition test
case
 Repeat the process till you reach the final state

Graph Based Testing:-

Graph based testing is useful to represent a transaction or work flows. consider a

example of a leave application by an employee.A typical leave application process can
be visualized as being made up of the following steps.

1. Employee desires leave

2. He applies leave application form
3. HR verify eligibility for leave
4. If it is eligible manager ensures feasibility
 If it is feasible manager approve leave
 If it is not feasible manager rejects leave
5.If it is not eligible manager rejects leave