1.
State:
A state is defined as: “A combination of circumstances
or attributes belonging for the time being to a person
or thing.” For example, a moving automobile whose
engine is running can have the following states with
respect to its transmission.
Reverse gear
Neutral gear
First gear
Second gear
Third gear
Fourth gear State graph – Example
Working: We create a state transition diagram with: o
States (e.g., Logged In) o Events (e.g., Click "Logout") o
Transitions (e.g., from Logged In → Logged Out) Then
test whether every transition gives the correct output
or not.State Testing is a technique where a software
application is tested by observing the behavior when it
transitions from one state to another based on certain
events or actions.
Principles of state testing:
✅ State testing is similar to path testing in flow
graphs.
✅ Testing all states/paths is impractical.
✅ "Grand tour" is inefficient — hard to complete
early due to bugs and unnecessary later.
✅ Long test sequences make verification difficult.
2.path:
A path in software testing is a sequence of
statements executed from the start to the end of the
program.
Path product:
✅ Flow graphs show control flow connectivity.
✅ Links are given names (lowercase italic letters).
✅ Link names act as weights, helping convert the
graph into algebraic expressions.
✅ Paths are traced by concatenating link names.
✅ This gives a symbolic expression for all possible
paths from entry to exit.
Advantages: Ensures maximum code is tested.
Detects unreachable code and missing logic
branches.
Disadvantages: For large programs, number of
paths grows exponentially (called path explosion).
Difficult to manage manually without tools.
4. Transaction Testing & Techniques
✅ Definition:
A transaction is a set of operations performed as a
unit. (E.g., in a banking app: login → transfer →
logout is one transaction)
Transaction testing checks whether the transaction
executes correctly from start to end, maintaining
data integrity.
✅ Importance:
Most business applications are transaction-based
(e.g., ecommerce, banking).
Ensures proper order, accuracy, and completion of
steps.
✅ Techniques: 1. Transaction Flow Graph (TFG):
Diagram showing each user action and possible
paths.
2. Valid and Invalid Sequences: Test different orders
to ensure only allowed sequences are accepted. 3.
Path Testing on TFG: Ensure each transaction flow is
covered.
✅ Example: Ticket Booking App:
Login → Search Train → Select Train → Pay →
Logout Test should: Ensure steps execute in order.
Show error if skipped or repeated.
✅ Advantages:
Mimics real user behavior.
Ensures end-to-end functionality works.
✅ Disadvantages:
Complex if app has many optional or repeated
steps.
Requires accurate documentation of all
transaction flows.
5.data flow:
DATA FLOW TESTING: o Data flow testing is the
name given to a family of test strategies based on
selecting paths through the program's control flow
in order to explore sequences of events related to the
status of data objects.
o For example, pick enough paths to assure that
every data object has been initialized prior to use or
that all defined objects have been used
forsomething.
o Motivation: It is our belief that, just as one would
not feel confident about a program without
executing every statement in it as part of some test,
one should not feel confident about a program
without having seen the effect of using the value
produced by each and every computation.
Data flow strategies:
1. All-defs coverage: Test all variable definitions. 2.
All-uses coverage: Test every place a variable is
used. 3. All du-paths coverage: Cover all
definition-to-use paths for each variable. ✅
Example: int x; // declared x = 5; // def if (x > 0)
// use (predicate) y = x + 1; // use
(computation)
6.domain testing:
Domain Testing :
It is a software testing technique where
minimum numbers of inputs are used to access
appropriate output of a system, to ensure the
system does not accept invalid input values. The
system is expected to give required outputs
blocking the invalid inputs.
✅ Importance of Domain Testing (Key Points):
✅ Covers Input Space: Ensures all possible
input areas are tested.
✅ Detects Errors: Identifies issues in specific
input ranges.
✅ Prevents Bugs: Helps avoid vulnerabilities
by understanding input limits.
✅ Improves Efficiency: Focuses testing on
critical input areas for better results.
✅ Mnemonic:
“C.E.P.E.” – Cover, Error, Prevent, Efficient
(Cover input, catch Errors, Prevent bugs, Efficient
testing)
Structure of Domain Testing:
1. ✅ Determine the Domain
– Understand the software's environment
and requirements with stakeholders.
2. ✅ Split the Domain
– Divide into smaller, testable parts (input
sets, states, scenarios).
3. ✅ Choose Test Cases
– Pick representative cases to cover all
domain partitions.
4. ✅ Design Test Data
– Create realistic data, especially boundary
and error-prone values.
5. ✅ Run Test Cases
– Execute tests, compare actual results with
expected outcomes.
6. ✅ Boundary Value Analysis
– Focus on edge values (min/max) where
bugs often hide.
7. ✅ Error Handling Check
– Ensure the software responds properly to
invalid/unexpected inputs.
8. ✅ Automation (if needed)
– Use tools to test complex or repetitive
scenarios efficiently.
✅ Mnemonic:
"Don’t Split Cheese During Rainy Bad Evenings
Always"
(Determine, Split, Choose, Design, Run,
Boundary, Error, Automation)
