Unit 7

Unit V (2016-17) System Testing & Interaction Testing Vishwesh Jayashekar
UNIT 5
SYSTEM TESTING, INTERACTION TESTING
System Testing, Interaction Testing Threads, Basic concepts for requirements specification,
Finding threads, Structural strategies and functional strategies for thread testing, SATM test
threads, System testing guidelines, ASF (Atomic System Functions) testing example. Context
of interaction, A taxonomy of interactions, Interaction, composition, and determinism,
Client/Server Testing.
Of the three levels of testing (Unit testing, Integration testing, and System testing),
the system level is closest to everyday experience. We test many things: a used car before we
buy it, an on-line network service before we subscribe, and so on. A common pattern in these
familiar forms is that we evaluate a product in terms of our expectations; not with respect to a
specification or a standard. Consequently, the goal is not to find faults, but to demonstrate
performance or correct behavior. Because of this, we tend to approach system testing from a
functional standpoint rather than from a structural one. Since it is so intuitively familiar,
system testing in practice tends to be less formal than it might be, and this is compounded by
the reduced testing interval that usually remains before a delivery deadline.
We will see the system testing in terms of Threads of system-level behavior. We

begin with further elaboration on the thread concept, highlighting some of the practical
problems of thread-based system testing. Since system testing is closely coupled with
requirements specification, we will discuss how to find threads in common notations. All of
this leads to an orderly thread-based system testing strategy that exploits the symbiosis
between functional and structural testing; we will apply the strategy to our SATM system.
5.1 Threads
Here are several views of a thread:
 A scenario of normal usage
 A system level test case
 Behavior that results from a sequence of system level inputs
Page 1 of 46
Software Testing (10CS842)
 An interleaved sequence of port input and output events

 A sequence of transitions in a state machine description of the system
 A sequence of machine instructions
Threads have distinct level
System Testing
Integration Testing
System level
threads Unit Testing
Integration level
threads Unit level threads
 A Unit-Level threads is usefully understood as an execution-time path of source

instructions or as a sequence of DD-path.
 An Integration-Level threads is a sequence of module execution and messages.
 A System-Level thread is a sequence of atomic system functions.
 A sequence of atomic system functions implies an interleaved sequence of ports

input and output events
A computer runs many applications at once,

each instance of an application is known as a
process. Each process is made of 1 or more
threads, each thread is a sequence of code, this
NOTE: code is often responsible for one aspect of the
program, or one task a program has been given.
Page 2 of 46
5.1.1 Thread Possibilities
Here are four candidate threads in our SATM system:
• Entry of a digit
1
• Entry of a Personal Identification Number (PIN)

2
• A simple transaction: ATM Card Entry, PIN entry, select transaction
type (deposit, withdraw), present account details (checking or
3 savings, amount), conduct the operation, and report the results.
• An ATM session, containing two or more simple transactions.

4
1. Digit entry is a good example of a minimal atomic system function. It begins with a
port input event (the digit keystroke) and ends with a port output event (the screen
digit echo), so it qualifies as a stimulus/response pair. This level of granularity is too
fine for the purposes of system testing. We saw this to be an appropriate level for
integration testing.
2. The second candidate, PIN Entry, is a good example of an upper limit to integration
testing, and at the same time, a starting point of system testing. PIN Entry is a good
example of an atomic system function. It is also a good example of a family of
stimulus/response pairs. PIN Entry entails a sequence of system level inputs and
outputs:
a. A screen requesting PIN digits
b. An interleaved sequence of digit keystrokes and screen responses
c. The possibility of cancellation by the customer before the full PIN is entered
d. A system disposition: A customer has three chances to enter the correct PIN. Once a
correct PIN has been entered, the user sees a screen requesting the transaction
Page 3 of 46
type; otherwise a screen, a screen advises the customer that the ATM card will
not be returned, and no access to ATM functions is provided.
3. The third candidate, the simple transaction, has a sense of end-to-end completion. A
customer could never execute PIN alone, customer may require to enter even card enter
too, but the simple transaction is commonly executed. This is good example of a system-
level thread; note that it involves the interaction of several ASFs.
4. The fourth and last candidate, session is actually a sequence of threads. This is he part of
system testing.
5.1.2 Thread Definitions
Thread
Definitions
Unit Source & System Thread

ASF Graph
Thread Sink ASF Thread Graph
MM-Path
ASF
Let’s see each and every thread in details:
Definition 1
A unit thread is a path in the program graph of a unit.
There are two levels of threads used in integration testing: MM-Paths and Atomic
System Functions (ASF). MM-Paths are defined as paths in the directed graph in which
module execution paths are nodes, and edges show execution time sequence.
 An MM-Path is a path in the MM-Path graph of a set of units.

 An atomic system function (ASF) is an action that is observable at the system level in
terms of port input and output events.
Definition 2
Given a system defined in terms of atomic system functions, the ASF Graph of the
Page 4 of 46
system is the directed graph in which nodes are atomic system functions and edges represent
sequential flow.
Definition 3
A source ASF is an atomic system function that appears as a source node in the ASF
graph of a system; similarly, a sink ASF is an atomic system function that appears as a sink
node in the ASF graph.
In the SATM system, the Card Entry ASF is a source ASF, and the session
termination ASF is a sink ASF.
Definition 4
A system thread is a path from a source ASF to a sink ASF in the ASF graph of a
system.
Definition 5
Given a system defined in terms of system threads, the Thread Graph of the system
is the directed graph in which nodes are system threads and edges represent sequential
execution of individual threads.
5.2 Basis Concepts for Requirements Specification
Here we discuss system testing with respect to a basis set of requirements

specification constructs: data, actions, ports, events, and threads. Every system can be
expressed in terms of these five fundamental concepts. We examine these fundamental
concepts here to see how they support the tester's process of thread identification.
5.2.1 Data
 When a system is described in terms of its data, the focus is on the information used
and created by the system.
 We describe data in terms of variables, data structures, fields, records, data stores,
and files.
 Entity/relationship models are the most common choice at the highest level, and some
form of a regular expression is used at a more detailed level.
Page 5 of 46
 Data refers to information that is either initialized, stored, updated, or (possibly)

destroyed.
 In the SATM system, initial data describe the various accounts (PANs) and their
PINs, and each account has a data structure with information such as the account
balance. As ATM transactions occur, the results are kept as created data and used in
the daily posting of terminal data to the central bank. For many systems, the data
centered view dominates. These systems are often developed in terms of CRUD
actions (Create, Retrieve, Update, and Delete).
 Sometimes threads can be identified directly from the data model.
 Relationships between data entities can be one-to-one, one-to-many, many-to-one, or
many-to-many; these distinctions all have implications for threads that process the
data. For example, if bank customers can have several accounts, each account will
need a unique PIN. If several people can access the same account, they will need
ATM cards with identical PANs.
5.2.2 Actions
 Actions have inputs and outputs, and these can be either data or port events. Here are
some methodology- specific synonyms for actions: transform, data transform, control
transform, process, activity, task, method, and service. Actions can also be
decomposed into lower level actions. The input/output view of actions is exactly the
basis of functional testing, and the decomposition (and eventual implementation) of
actions is the basis of structural testing.
5.2.3 Ports / Devices

 Every system has ports (and port devices); these are the sources and destinations of
system level inputs and outputs (port events). The slight distinction between ports and
port devices is sometimes helpful to testers. Technically, a port is the point at which
an I/O device is attached to a system, as in serial and parallel ports, network ports,
and telephone ports. Physical actions (keystrokes and light emissions from a screen)
occur on port devices, and these are translated from physical to logical (or logical to
physical). In the absence of actual port devices, much of system testing can be
accomplished by "moving the port boundary inward" to the logical instances of port
events. From now on, we will just use the term "port" to refer to port devices. The
Page 6 of 46
ports in the SATM system include the digit and cancel keys, the function keys, the
display screen, the deposit and withdrawal doors, the card and receipt slots, and
several less obvious devices, such as the rollers that move cards and deposit
envelopes into the machine, the cash dispenser, the receipt printer, and so on.
5.2.4 Events
 Events are somewhat schizophrenic: they have some characteristics of data and some
of actions. An event is a system level input (or output) that occurs at a port. Like
data, events can be inputs to or outputs of actions. Events can be discrete (such as
SATM keystrokes) or they can be continuous (such as temperature, altitude, or
pressure). Discrete events necessarily have a time duration, and this can be a critical
factor in real-time systems. We might picture input events as destructive read- out
data, but it's a stretch to imagine output events as destructive write operations.
 Events are like actions in the sense that they are the translation point between real-
world physical events and internal logical manifestations of these. Port input events
are physical-to-logical translations, and symmetrically, port output events are
logical-to-physical translations. System testers should focus on the physical side of
events, not the logical side (the focus of integration testers). There are situations
where the context of present data values changes the logical meaning of physical
events. In the SATM system, for example, the port input event of depressing button
B1 means "Balance" when screen 5 is being displayed, "checking" when screen 6 is
being displayed, and "yes" when screens 10, 11, and 14 are being displayed. We
refer to such situations as "context sensitive port events", and we would expect to test
such events in each context.
5.2.5 Threads
 Unfortunately for testers, threads are the least frequently used of the five
fundamental constructs. Since we test threads, it usually falls to the tester to find
them in the interactions among the data, events, and actions. About the only place
that threads appear per se in a requirements specification is when rapid prototyping is
used in conjunction with a scenario recorder. It's easy to find threads in control
models, as we will soon see. The problem with this is that control models are just
that — they are models, not the reality of a system.
Page 7 of 46
5.2.6 Relationships Among Basis Concepts
 Figure 5.1 is an entity/relationship model of our basis concepts. Notice that all relationships
are many-to-many: Data and Events are generalized into an entity; the two relationships to
the Action entity are for inputs and outputs. The same event can occur on several ports, and
typically many events occur on a single port. Finally, an action can occur in several threads,
and a thread is composed of several actions. This diagram demonstrates some of the
difficulty of system testing. Testers must use events and threads to ensure that all the many-
to-many relationships among the five basis concepts are correct.
Figure 5.1 E/R model of basis concepts
5.2.7 Modeling with Basis Concepts

 All flavors of requirements specification develop models of a system in terms of the
basis concepts.
 Figure 5.2 shows three fundamental forms of requirements specification models:
structural, contextual, and behavioral.
 Structural models are used for development; these express the functional
decomposition and data decomposition, and the interfaces among components.
 Contextual models are often the starting point of structural modeling. They
emphasize system ports and, to a lesser extent, actions, and threads very indirectly.
 Behavior models (also called control models) are where four of the five basis
constructs come together.
Page 8 of 46
 Selection of an appropriate control model is the essence of requirements

specification: models that are too weak cannot express important system behaviors,
while models that are too powerful typically obscure interesting behaviors.
Figure 5.2 Modeling relationships among basic constructs.
5.3 Finding Threads
The finite state machine models of the SATM system are the best place to look for
system testing threads. We'll start with a hierarchy of state machines; the upper level is
shown in Figure 5.3.
Figure 5.3 Top-level SATM state machine
Page 9 of 46
At this level, states correspond to stages of processing, and transitions are caused by
logical (rather than port) events. The Card Entry "state" for example, would be decomposed
into lower levels that deal with details like jammed cards, cards that are upside-down, stuck
card rollers, and checking the card against the list of cards for which service is offered. Once
the details of a macro-state are tested, we use an easy thread to get to the next macro-state.
The PIN Entry state is decomposed into the more detailed view in Figure 5.4.
At this level, we focus on the PIN retry mechanism; all of the output events are true
port events, but the input events are still logical events. The states and edges are numbered
for reference later when we discuss test coverage.
To start the thread identification process, we first list the port events shown on the
state transitions; they appear in Table 5.1.
Figure 5.4 PIN entry finite state machine
Port Input Events Port Output Events

Legitimate card Display screen 1 (Actually screen 2)
Wrong card Display screen 2 (Actually screen 1)
Correct PIN Display screen 3 (Actually screen 5)
Incorrect PIN Display screen 4 (Actually screen 4)
Cancelled Display screen 5
Table 5.1 Events in the PIN Entry Finite State Machine
Page 10 of 46
Notice that Correct PIN and Incorrect PIN are really compound port input events. We
can't actually enter an entire PIN, we enter digits, and at any point, we might hit the cancel
key. These more detailed possibilities are shown in Figure 5.5.
Figure 5.5 PIN try finite state machine
The port events in the PIN Try finite state machine are in Table 5.2.
The "x" in the state names in the PIN Try machine refers to which try (first, second,
or third) is passing through the machine.
In addition to the true port events in the PIN Try finite state machine, there are three
logical output events (Correct PIN, Incorrect PIN, and Canceled); these correspond exactly
to the higher level events in Figure 5.4.
Page 11 of 46

Digit echo “X-------“
Cancel echo “XX-----“
echo “XXX---“
echo “XXXX-“
Table 5.2 Port Events in the PIN Entry Finite State Machine
The hierarchy of finite state machines multiplies the number of threads. There are 156
distinct paths form the First PIN Try state to the Await Transaction Choice or Card Entry
states in Figure 5.4. Of these, 31 correspond to eventually correct PIN entries (1 on the first
try, 5 on the second try, and 25 on the third try); the other 125 paths correspond to those
with incorrect digits or with cancel keystrokes.
Tables T3 and T4 follow two paths through the hierarchic state machines. Table 5.3
corresponds to a thread in which a PIN is correctly entered on the first try. Table 5.4 corresponds to
a thread in which a PIN is incorrectly entered on the first try, cancels after the third digit on the
second try, and gets it right on the third try. To make the test case explicit, we assume a pre-condition
that the expected PIN is '1234'.

Screen 2 displayed with “--------“
1 pressed
Screen 2 displayed with “X------“
2 pressed
Screen 2 displayed with “XX----“
3 pressed
Screen 2 displayed with “XXX--“
4 pressed
Screen 2 displayed with “XXXX“
(Correct PIN) Screen 5 displayed
Table 5.3 Port Event Sequence for Correct PIN on First Try
Page 12 of 46

1 pressed
2 pressed
3 pressed
5 pressed
(Incorrect PIN) Screen 3 displayed
(Second Try) Screen 2 displayed with “--------“
1 pressed
2 pressed
3 pressed
Cancel key pressed
(End of second try) Screen 3 displayed
1 pressed
2 pressed
3 pressed
4 pressed
(Correct PIN) Screen 5 displayed
Table 5.4 Port Event Sequence for Correct PIN on First Try
Page 13 of 46
5.4 Structural Strategies for Thread Testing

While generating thread test cases is easy, deciding which ones to actually use is more
complex. (If you have an automatic test executor, this is not a problem.) We have the same
path explosion problem at the system level that we had at the unit level. Just as we did there,
we can use the directed graph insights to make an intelligent choice of threads to test.
5.4.1 Bottom-Up Threads
When we organize state machines in a hierarchy, we can work from the bottom up.
There are six paths in the PIN Try state machine. If we traverse these six, we test for three
things: correct recognition and echo of entered digits, response to the cancel keystroke, and
matching expected and entered PINs. These paths are described in Table 5.5 as sequences of
the transitions in Figure 5.5. A thread that traverses the path is described in terms of its input
keystrokes, thus the input sequence 1234 corresponds to the thread described in more detail in
Table 5.3, and here the cancel keystroke is indicated with a 'C'.
Input Event Sequence Path of Transitions

1234 x1, x2, x3, x4, x5
1235 x1, x2, x3, x4, x6
C x7, 11
1C x1, x8, x11
12C x1, x2, x9, 11
123C x1, x2, x3, x10, x11
Table 5.5 Thread Paths in the PIN Try FSM
Once this portion is tested, we can go up a level to the PIN Entry machine (Figure 5.4),
where there are four paths. These four are concerned with the three try mechanism and the
sequence of screens presented to the user. In Table 5.6, the paths in the PIN Entry state
machine (Figure 5.4) are named as transition sequences.
Page 14 of 46
Input Event Sequence Path of Transitions

1234 1
12351234 2, 3
1235C1234 2, 4, 5
CCC 2, 4, 6
Table 5.6 Thread Paths in the PIN Entry FSM
What really happens with the '1235' input sequence in Table 5.5? It traverses an
interesting path in the PIN Try machine, and then it "returns" to the PIN Entry machine
where it is seen as a logical event (incorrect PIN), which causes a transition to state 2.2
(Second PIN Try). If no additional keystrokes occur, this machine would remain in state 2.2.
We show how to overcome such situations next.
5.4.2 Node and Edge Coverage Metrics
Because the finite state machines are directed graphs, we can use the same test coverage
metrics that we applied at the unit level. The hierarchic relationship means that the upper level
machine must treat the lower machine as a procedure that is entered and returned.
The two obvious choices are node coverage and edge coverage. Table 5.7 is extended from
Table 5.4 to show the node and edge coverage of the three-try thread.
Port Input Events Port Output Events Nodes Edges

Screen 2 displayed with “--------“ 2.1 A
1 pressed 2.1.1
Screen 2 displayed with “X------“ x1
2 pressed 2.1.2
Screen 2 displayed with “XX----“ x2
3 pressed 2.1.3
Screen 2 displayed with “XXX--“ x3
5 pressed 2.1.4
Screen 2 displayed with “XXXX“ x4
(Incorrect PIN) Screen 3 displayed 2.1.5, 2.2 x6, 2
Page 15 of 46
(Second Try) Screen 2 displayed with “--------“ 2.2

1 pressed 2.2.1
2 pressed 2.2.2
3 pressed 2.2.3
Cancel key pressed 2.2.4 x10
(End of second try) Screen 3 displayed 2.2.6 x11
Screen 2 displayed with “--------“ 2.3 4
1 pressed 2.3.1
2 pressed 2.3.2
3 pressed 2.3.3
4 pressed 2.3.4
Screen 2 displayed with “XXXX“ x4
(Correct PIN) Screen 5 displayed 2.3.5, 3 x5, 5
Table 5.7 Node and Edge Traversal of a Thread
Here we have two kinds of incidence tables, one is Thread/State Incidence and another
one is Thread/Transition Incidence as shown in Table 5.8 and Table 5.9.
Input 2.1 2.x.1 2.x.2 2.x.3 2.x.4 2.x.5 2.x.6 2.2 2.3 3 1
Events
1234 X X X X X X X
12351234 X X X X X X X X
C1234 X X X X X X X X X
1C12C1234 X X X X X X X X X X
123C1C1C X X X X X X X X
Table 5.8 Thread/State Incidence
Page 16 of 46
Input X X X X X X X X X X1 X1 1 2 3 4 5 6
Events 1 2 3 4 5 6 7 8 9 0 1
1234 X X X X X X
1235123 X X X X X X X X
4
C1234 X X X X X X X X X
1C12C12 X X X X X X X X X X X
34
123C1C1 X X X X X X X X X
C
Table 5.9 Thread/Transition Incidence
5.5 Functional Strategies for Thread Testing

The finite state machine based approaches to thread identification are clearly useful,
but what if no behavioral model exists for a system to be tested? The testing craftsperson has
two choices: develop a behavioral model, or resort to the system level analogs of functional
testing. Recall that when functional test cases are identified, we use information from the
input and output spaces as well as the function itself. We describe functional threads here in
terms of coverage metrics that are derived from three of the basis concepts (events, ports, and
data).
5.5.1 Event-Based Thread Testing
Consider the space of port input events. There are five port input thread coverage
metrics of interest. Attaining these levels of system test coverage requires a set of threads such
that:
PI1: each port input event occurs
PI2: common sequences of port input events occur
PI3: each port input event occurs in every "relevant" data context
PI4: for a given context, all "inappropriate" input events occur
PI5: for a given context, all possible input events
The PI1 metric is a bare minimum and is inadequate for most systems. PI2 coverage
is the most common, and it corresponds to the intuitive view of system testing because it
Page 17 of 46
deals with "normal use". It is difficult to quantify, however. What is a "common" sequence of
input events? What is an uncommon one?
We can also define two coverage metrics based on port output

events:
• PO1: each port output event occurs
• PO2: each port output event occurs for each cause
PO1 coverage is an acceptable minimum. It is particularly effective when a system

has a rich variety of output messages for error conditions. (The SATM system does not.) PO2
coverage is a good goal, but it is hard to quantify; we will revisit this in Chapter 16 when we
examine thread interaction. For now, note that PO2 coverage refers to threads that interact
with respect to a port output event.. Usually a given output event only has a small number of
causes. In the SATM system, screen 10 might be displayed for three reasons: the terminal
might be out of cash, it may be impossible to make a connection with the central bank to get
the account balance, or the withdrawal door might be jammed. In practice, some of the most
difficult faults found in field trouble reports are those in which an output occurs for an
unsuspected cause. One example: my local ATM system (not the SATM) has a screen that
informs me that "Your daily withdrawal limit has been reached". This screen should occur
when I attempt to withdraw more than $300 in one day. When I see this screen, I used to
assume that my wife has made a major withdrawal (thread interaction), so I request a lesser
amount. I found out that the ATM also produces this screen when the amount of cash in the
dispenser is low. Rather than provide a lot of cash to the first users, the central bank prefers to
provide less cash to more users.
5.5.2 Port-Based Thread Testing

 Port-based testing is a useful complement to event-based testing.
 With port-based testing, we ask, for each port, what events can occur at that port.
 We then seek threads that exercise input ports and output ports with respect to the
event lists for each port.
 Port-based testing is particularly useful for systems in which the port devices come
from external suppliers.
 The main reason for port-based testing can be seen in the entity/relationship model
Page 18 of 46
of the basis constructs (as shown in the Figure 5.1).

 The many-to-many relationship between ports and events should be exercised in both
directions.
 Event based testing covers the one-to-many relationship from events to ports, and
conversely, port-based testing covers the one-to many relationship from ports to
events.
 The SATM system fails us at this point; there is no SATM event that occurs at more
than one port.
5.5.3 Data-Based Thread Testing

 Port and event based testing work well for systems that are primarily event driven.
 Such systems are sometimes called "reactive" systems because they react to port input
events, and often the reaction is in the from of port output events.
 Reactive systems have two important characteristics:
o They are long running and
o They maintain a relationship with their environment.
 Typically, event driven, reactive systems do not have a very interesting data model,
so data model based threads aren't particularly useful.
 Good for systems where data is of primary importance. This model is static and
transformational i.e., it supports transactions on a database and this system uses E/R
model.
 To discuss something familiar, we use the entity/relationship (E/R) model of a simple
library system as shown in Figure 5.6.
Page 19 of 46
Figure 5.6 E/R model of a library.
 Here are some typical transactions in the library system:

1. Add a book to the library.
2. Delete a book from the library.
3. Add a borrower to the library.
4. Delete a borrower from the library.
5. Loan a book to a borrower.
6. Process the return of a book from a borrower.
 These transactions are all mainline threads; in fact, they represent families of threads.
 For example, suppose the book loan transaction is attempted for a borrower whose
current number of checked out books is at the lending limit. We might also try to
return a book that was never owned by the library. One more: suppose we delete a
borrower that has some unreturned books. All of these are interesting threads to test,
and all are at the system level.
 We can identify each of these examples, and many more, by close attention to the
information in the entity/relationship (E/R) model. As we did with event-based
testing, we describe the following sets of threads in terms of data-based coverage
metrics.
DM1: Exercise the cardinality of every relationship.

DM2: Exercise the participation of every relationship.
DM3: Exercise the functional dependencies among relationships.
Page 20 of 46
Explanation to DM1:
 Cardinality refers of the four possibilities of relationship: one-to-one, one-to-many,
many-to-one, and many-to-many.
 In the library example, both the loan and the writes relationships are many-to-many,
meaning that one author can write many books, and one book can have many authors;
and that one book can be loaned to many borrowers and one borrower can borrow
many books. Each of these possibilities results in a useful system testing thread.
Explanation to DM2:
 Participation refers to whether or not every instance of an entity participates in a
relationship.
 In the writes relationship, both the Book and the Author entities have mandatory
participation i.e., we cannot have a book with no authors, or an author of no books.
 In some modeling techniques, participation is expressed in terms of numerical limits;
the Author entity, for example, might be expressed as "at least 1 and at most 12".
 When such information is available, it leads directly to obvious boundary value

system test threads.
Explanation to DM3:
 Sometimes transactions determine explicit logical connections among relationships;
these are known as functional dependencies.
 For example, we cannot loan a book that is not possessed by the library, and we
would not delete a book that is out on loan. Also, we would not delete a borrower
who still has some books checked out.
 These kinds of dependencies are reduced when the database is normalized, but they
still exist, and they lead to interesting system test threads.
Page 21 of 46
5.6 SATM Test Threads

If we apply the discussion of this chapter to the SATM system, we get a set of
threads that constitutes a thorough system level test. We develop such a set of threads here in
terms of an overall state model in which states correspond to key atomic system functions.
The macro-level states are: Card Entry, PIN Entry, Transaction Request, (and processing),
and Session Management. The stated order is the testing order, because these stages are in
prerequisite order. (We cannot enter a PIN until successful card entry, we cannot request a
transaction until successful PIN entry, and so on.) We also need some pre-condition data
that define some actual accounts with PANs, Expected PINs, and account balances. These
are given in Table 5.10. Two less obvious pre-conditions are that the ATM terminal is
initially displaying screen 1 and the total cash available to the withdrawal dispenser is $500
(in $10 notes).
PAN Expected PIN Checking Saving

Balance Balance
100 1234 $1000.0 $800.0
200 4567 $100.0 $90.0
300 6789 $25.0 $20.0
Table 5.10 SATM Test Data
We will express threads in tables in which pairs of rows correspond to port inputs and
expected port outputs at each of the four major stages. We start with three basic threads,
one for each transaction type (balance inquiry, deposit, and withdrawal).
In thread 1, a valid card with PAN = 100 is entered, which causes screen 2 to be
displayed. The PIN digits '1234' are entered, and since they match the expected PIN for
the PAN, screen 5 inviting a transaction selection is displayed. When button B1 is
Page 22 of 46
touched the first time (requesting a balance inquiry), screen 6 asking which account is
displayed. When B1 is pressed the second time (checking), screen 14 is displayed and
the checking account balance ($1000.00) is printed on the receipt. When B2 is pushed,
screen 15 is displayed, the receipt is printed, the ATM card is ejected, and then screen 1
is displayed.
Thread 2 is a deposit to checking: Same PAN and PIN, but B2 is touched when
screen 5 is displayed, and B1 is touched when screen 6 is displayed. The amount 25.00 is
entered when screen 7 is displayed and then screen 13 is displayed. The deposit door
opens and the deposit envelope is placed in the deposit slot. Screen 14 is displayed, and
when B2 is pushed, screen 15 is displayed, the receipt showing the new checking
account balance of $1025.00 is printed, the ATM card is ejected, and then screen 1 is
displayed.
Thread 3 is a withdrawal from savings: Again the same PAN and PIN, but B3 is
touched when screen 5 is displayed, and B2 is touched when screen 6 is displayed. The
amount 30.00 is entered when screen 7 is displayed and then screen 11 is displayed. The
withdrawal door opens and three $10 notes are dispensed. Screen 14 is displayed, and
when B2 is pushed, screen 15 is displayed, the receipt showing the new savings account
balance of $770.00 is printed, the ATM card is ejected, and then screen 1 is displayed.
Page 23 of 46
A few of these detailed descriptions are needed to show the pattern; the remaining
threads are described in terms of input and output events that are the objective of the test
thread.
Thread 4 is the shortest thread in the SATM system, it consists of an invalid card,
which is immediately rejected.
Following the macro-states along thread 1, we next perform variations on PIN Entry. We
get four new threads from Table 9, which yield edge coverage in the PIN Entry finite state
machines.
Page 24 of 46
Moving to the Transaction Request stage, there are variations with respect to the type of
transaction (balance, deposit, or withdraw), the account (checking or savings) and
several that deal with the amount requested. Threads 1, 2, and 3 cover the type and
account variations, so we focus on the amount-driven threads. Thread 9 rejects the
attempt to withdraw an amount not in $10 increments, Thread 10 rejects the attempt to
withdraw more than the account balance, and Thread 11 rejects the attempt to withdraw
more cash than the dispenser contains.
Page 25 of 46
Having exercised the transaction processing portion, we proceed to the session

management stage, where we test the multiple transaction option.
Page 26 of 46
5.7 System Testing Guidelines

If we disallow compound sessions (more than one transaction) and if we disregard
the multiplicity due to Amount Entry possibilities, there are 435 distinct threads per valid
account in the SATM system. Factor in the effects of compound sessions and the Amount
Entry possibilities and there are tens of thousands of possible threads for the SATM system.
We end this chapter with three strategies to deal with the thread explosion problem.
5.7.1 Pseudo-Structural System Testing

When we studied unit testing, we saw that the combination of functional and
structural testing yields a desirable cross-check. We can only claim pseudo-structural testing
[Jorgensen 94], because the node and edge coverage metrics are defined in terms of a
control model of a system, and are not derived directly from the system implementation.
(Recall we started out with a concern over the distinction between reality and models of
reality.)
In general, behavioral models are only approximations of a system's reality, which
is why we could decompose our models down to several levels of detail. If we made a true
structural model, its size and complexity would make it too cumbersome to use. The big
weakness of pseudo-structural metrics is that the underlying model may be a poor choice.
The three most common behavioral models (decision tables, finite state machines, and Petri
nets) are appropriate, respectively, to transformational, interactive, and concurrent systems.
Decision tables and finite state machines are good choices for ASF testing. If an ASF
is described using a decision table, conditions typically include port input events, and
actions are port output events. We can then devise test cases that cover every condition,
every action, or most completely, every rule. As we saw for finite state machine models, test
cases can cover every state, every transition, or every path.
Thread testing based on decision tables is cumbersome. We might describe threads as

sequences of rules from different decision tables, but this becomes very messy to track in
terms of coverage. We need finite state machines as a minimum, and if there is any form of
interaction, Petri nets are a better choice. There we can devise thread tests that cover every
place, every transition, and every sequence of transitions.
Page 27 of 46
5.7.2 Operational profiles

One way to determine the operational profile of a system is to use a decision tree. This
works well particularly well when system behavior is modeled in hierarchic state machines, as
we did with the SATM system. For any state, we find or estimate the probability of each
outgoing transition (the sum of these must be 1). When a state is decomposed into a lower level,
the probabilities at the lower level become “split edges” at the upper level. Figure 5.7 shows the
result of this with hypothetical transition probabilities.
Figure 5.7 Transition probabilities for the SATM system
5.7.3 Progression vs. Regression Testing

The most common approach to regression testing is to simply repeat the system tests.
We can refine this by choosing test threads with respect to the goals of regression and
progression testing. With progression testing, we are testing new territory, so we expect a
higher failure rate than with regression testing.
Page 28 of 46
Another difference is that because we expect to find more faults with progression
testing, we need to be able to locate the faults. This requires test cases with a diagnostic
capability – that is, tests that can fail only in a few ways.
5.8 ASF Testing Example

 The first step in ASF (Atomic System Function) testing is to identify the system level
input and output events; these are shown in Table 5.11 and Table 5.12.
 The next step is to identify a trial set of atomic system functions (ASFs). Table 5.13
contains a trial set.
 The nature of this set of ASFs is shown in Figure 5.8.
Figure 5.8 ASF Sequences in NextDate.
 The ASF graph shows all the ways valid months, days, and years can be entered, but
the transition to ASF-8 (or ASF-9) depends on the history of previous ASFs.
 Table 5.14 contains a second set of ASFs.
Event Input Event Description Statement Numbers
e0 Start program event 1
e1 Enter a valid month 67
e2 Enter an invalid month 67
e3 Enter a valid day 69
e4 Enter an invalid day 69
e5 Enter a valid year 71
e6 Enter an invalid year 71
Table 5.11 NextDate Input Events
Page 29 of 46
Event Output Event Description Statement Numbers

e7 Welcome message 2
e8 Print today’s date 4
e9 Print tomorrow’s date 6
e10 “month OK” 39
e11 “month out of range” 41
e12 “day OK” 47
e13 “day out of range” 71
e14 “year OK” 54
e15 “year out of range” 56
e16 “date OK” 60
e17 “please enter a valid date” 62
e18 “enter a month” 66
e19 “enter a day” 68
e20 “enter a year” 70
e21 “Day is month, day, year” 89
Table 5.12 NextDate Output Events
Atomic System Function Inputs Outputs

ASF-1 start program e0 e7
ASF-2 enter a valid month e1 e10
ASF-3 enter an invalid month e2 e11
ASF-4 enter a valid day e3 e12
ASF-5 enter an invalid day e4 e13
ASF-6 enter a valid year e5 e14
ASF-7 enter an invalid year e6 e15
ASF-8 print for valid input
ASF-9 print for invalid input
Table 5.13 First Attempt at ASFs for NextDate
Atomic System Function Inputs Outputs

ASF-1 start program e0 e7
ASF-2 enter a date with an invalid e2,e3,e5 e11,e12,e14,e17
month, rest OK
ASF-3 enter a date with an invalid day, e1,e4,e5 e10,e13,e14,e17
rest OK
ASF-4 enter a date with an invalid year, e1,e3,e6 e10,e12,e15,e17
rest OK
ASF-5 enter a date with valid month, e1,e3,e5 e10,e12,e14,e16,e21
day, and year
ASF-6 enter a date with valid month,
Page 30 of 46
rest invalid
ASF-7 enter a date with valid day, rest
invalid
ASF-8 enter a date with valid year, rest
invalid
ASF-9 enter a date with invalid month,
day, and year
Table 5.14 Second Attempt at ASFs for NextDate
5.9 Interaction Testing

Faults and failures due to interaction are the bane of testers. Their subtlety makes
them difficult to recognize and even more difficult to reveal by testing. These are deep
faults, ones that remain in a system even after extensive thread testing. Unfortunately, faults
of interaction most frequently occur as failures in delivered systems that have been in use for
some time. Typically they have a very low probability of execution, and they occur only
after a large number of threads have been executed. Most of this chapter is devoted to
describing forms of interaction, not to testing them. As such, it is really more concerned
with requirements specification that with testing. The connection is important: knowing
how to specify interactions is the first step in detecting and testing for them. This chapter is
also a somewhat philosophical and mildly mathematical discussion of faults and failures of
interaction; we cannot hope to test something if we don't understand it. We begin with an
important addition to our five basis constructs, and use this to develop a taxonomy of types
of interaction. Next, we develop a simple extension to conventional Petri nets that reflects
the basis constructs, and then we illustrate the whole discussion with the SATM and Saturn
Windshield Wiper systems, and sometimes with examples from telephone systems. We
conclude by applying the taxonomy to an important application type: client-server systems.
5.9.1 Context of Interaction

Part of the difficulty of specifying and testing interactions is that they are so common.
Think of all the things that interact in everyday life: people, automobile drivers, regulations,
chemical compounds, and abstractions, to name just a few. We are concerned with
interactions in software controlled systems (particularly the unexpected ones), so we start by
restricting our discussion to interactions among our basis system constructs: actions, data,
events ports, and threads.
Page 31 of 46
One way to establish a context for interaction is to view it as a relationship among

the five constructs. If we did this, we would find that the relation Interacts With is a
reflexive relationship on each entity (data interacts with data, actions with other actions, and
so on). It also is a binary relationship between data and events, data and threads, and events
and threads. The data modeling approach isn't a dead-end, however. Whenever a data model
contains such pervasive relationships, that are a clue that an important entity is missing. If
we add some tangible reality to our fairly abstract constructs, we get a more useful
framework for our study of interaction. The missing element is location, and location has
two components: time and position. Data modeling provides another choice: we can treat
location as sixth basic entity, or as an attribute of the other five. We choose the attribute
approach here.
What does it mean for location (time and position) to be an attribute of any of the
five basis constructs? This is really a short-coming of nearly all requirements specification
notations and techniques. (This is probably also the reason that interactions are seldom
recognized and tested.) Information about location is usually created when a system is
implemented. Sometimes location is mandated as a requirement — when this happens, the
requirement is really a forced implementation choice. We first clarify the meaning of the
components of location: time and position.
We can take two views of time: as an instant or as a duration. The instantaneous

view lets us describe when something happens — it is a point when time is an axis. The
duration view is an interval on the time axis. When we think about durations, we usually are
interested in the length of the time interval, not the endpoints (the start and finish times).
Both views are useful. Because threads execute, they have a duration; they also have points
in time when they execute. Similar observations apply to events. Often events have very
short durations, and this problematic if the duration is so short that the event isn't recognized
by the system.
The position aspect is easier. We could take a very tangible, physical view of position
and describe it in terms of some coordinate system. Position can be a three dimensional
Cartesian coordinate system with respect to some origin, or it could be a longitude-latitude-
Page 32 of 46
elevation geographic point. For most systems, it is more helpful to slightly abstract position
into processor residence. Taken together, time and position tell the tester when and where
something happens, and this is essential to understand interactions.
Before we develop our taxonomy, we need some ground rules about threads and
processors. For now, a processor is something that executes threads or a device where
events occur.
1. Since threads execute, they have strictly positive time duration. We usually speak of
the execution time of a thread, but we might also be interested in when a thread occurs
(executes). Actions are degenerate cases of threads; therefore, actions also have durations
2. In a single processor, two threads cannot execute simultaneously. This resembles a
fundamental precept of physics: no two bodies may occupy the same space at the same
time. Sometimes threads appear to be simultaneous, as in time sharing on a single
processor; in fact, time shared threads are interleaved. Even though threads cannot
execute simultaneously on a single processor, events can be simultaneous. (This is really
problematic for testers.)
3. Events have strictly positive time duration. When we consider events to be actions
that execute on port devices, this reduces to the first ground rule.
4. Two (or more) input events can occur simultaneously, but an event cannot occur
simultaneously in two (or more) processors. This is immediately clear if we consider port
devices to be separate processors.
5. In a single processor, two output events cannot begin simultaneously. This is a
direct consequence of output events being caused by thread executions. We need both the
instantaneous and duration views of time to fully explain this ground rule. Suppose two
output events are such that the duration of one is much greater than the duration of the
other. The durations may overlap (because they occur on separate devices), but the start
times cannot be identical.
6. A thread cannot span more than one processor. This convention helps in the
definition of threads. by confining a thread to a single processor, we create a natural
endpoint for threads; this also results in more simple threads rather than fewer complex
threads. In a multi-processing setting, this choice also results in another form of quiescence
— trans-processor quiescence.
Page 33 of 46
5.10 A Taxonomy of Interaction

There are four basic types of interaction:
 Static interactions in a single processor system
 Static interactions in multiprocessor system
 Dynamic interactions in a single processor system
 Dynamic interactions in multiprocessor system
Let us discuss each in brief.
5.10.1 Static Interaction in a Single Processor

 Of the five basic constructs, only two have no duration i.e., ports and data.
 Ports are physical devices; therefore, we can view them as separate processors.
 Data items interact in logical way, and these are important to testers.
 Note that static interaction does not depend on time.
 In the following definitions, let p and q are propositions about data items. As
example, we might take p and q to be:
p: AccountBalance = $10.00
q: Sales < $1800.00
Definition:
Propositions p and q are:
o Contraries if they cannot both be true.
o Sub-contraries if they cannot both be false.
o Contradictories if exactly one is true.
o q is a sub-altern of p if the truth of p guarantees the truth of q
These relationships are known to logicians as the “square of opposition”, which is
shown in Figure 5.9, where p, q, r, and s are all propositions.
Page 34 of 46
Figure 5.9 The square of opposition.
 Static interactions in a single processor are exactly analogues to combinatorial

circuit; they are also well represented by decision tables and unmarked event driven
petri nets (EDPNs).
5.10.2 Static Interaction in a Multiple Processor

Call forwarding provides a better example of static, distributed interaction. Suppose
we have three telephone subscribers in separate cities:
Subscriber A is in Bengaluru.
Subscriber B is in Chennai.
Subscriber C is in Mumbai.
We further suppose that each subscriber has call forwarding service, and that calls
are forwarded as follows: calls to A are forwarded to B, calls to B are forwarded to C, and
calls to C are forwarded to A.
 This call forwarding data is contrary, means cannot all be true.
 Call forwarding data is local to the telephone office that provides the service; it is set
by a thread when a subscriber defines a new forwarding destination. This means that
none of the offices knows of call forwarding data in the other offices; we have
distributed contraries.
 This is a fault, but it does not become a failure until someone (other than A, B, or C)
places a call to any phone in this call forwarding loop.
 Such a call, say to subscriber B, generates a call forwarding thread in B’s local
telephone office, which results in a call to C’s directory number. This generates
another thread in C’s telephone office, and so on.
Page 35 of 46
5.10.3 Dynamic Interaction in Single Processor

 Interactions in the dynamic quadrants forces consideration of the implications of
time.
 Among other things, this means we must expand from the data-only interaction to
interactions among data, events, and threads.
 The notion of n-connectedness in a directed graph serves perfectly. Figure 5.10
shows the four forms of n-connectedness in a directed graph.
Figure 5.10 Forms of n-connectedness.

 Even the data-data interactions exhibits forms of n-connectedness.
 Data that are logically independent are 0-connected, and sub alternates are 2-
connected. The other three relationships, contraries, contradictories, and
subcontraries, all pertain to 3-connected data.
 Six potential pairs of concepts can interact: data-data, data-events, data-threads,
events-events, events-threads, and threads-threads.
 Each of these is further qualified by four degrees of n-connectedness, resulting in 24
elements (6*4) to our taxonomy for this quadrant.
 Here are few example:
o 1-connected data with data: Occurs when two or more data items are inputs to
the same action.
o 2-connected data with data: Occurs when a data item is used in a computation
(as in dataflow testing)
o 3-connected data with data: Occurs when data are deeply related, as in
repetition and semaphores.
o 1-connected data with events: Context-sensitive port input events. And so on.
Page 36 of 46
 Threads can only interact in two ways, via events or via data. We will see this more
clearly using EDPNs after we make another definition.
Definition
In an EDPN, the external inputs are the places with indegree = 0, and the external
outputs are the places with outdegree = 0.
In the EDPN in Figure 5.11, p1 and p2 are the only external inputs, and p5, p9 and
p10 are the only external outputs.
Figure 5.11 External inputs and outputs in an EDPN.

 Suppose, for example, that in one SATM thread, a keystroke on the Cancel key is
named as port input event p2, and in another thread the same event is called p6.
 When these two threads are composed, the synonyms must be collapsed onto a single
name.
 Once synonyms are resolved, the individual threads are drawn as EDPNs. Because
threads interact only with respect to their external inputs and outputs, we next
identify the sets of external inputs and outputs of each thread.
Page 37 of 46
 The interaction of these sets contains the events and places at which the composed
threads can interact. This process is illustrated in Figure 5.12 and 5.13.
Figure 5.12 Two EDPN threads.

 Thread 1 is the sequence <s1, s2>, and thread 2 is the sequence <s3>.
 The external inputs of these threads are the sets EI1={p1, d1} and EI2={p1, d2}, and
external outputs of these threads are the sets EO1={p3,d4} and EO2={p3,d4}.
 Intersecting these, we get the sets EI=EI1 ∩ EI2={p1} and EO=EO1 ∩ EO2
={p3,d4}.
 The sets EI and EO contain the external inputs and outputs at which threads 1 and 2
may possibly interact.
 We can formalize this process into another definition. Let T1 and T2 be two EDPN
threads in which synonym places have been resolved, and with external input and
output sets EI1, EI2, EO1, and EO2.
 Furthermore, let T be the composition of threads T1 and T2, where EI = EI1 ∩ EI2
and EO=EO1 ∩ EO2 are the external input and output sets of the composed thread T.
Page 38 of 46
Figure 5.13 Composition of EDPN threads.

Definition
The threads T1 and T2 are:
o 0-connected if EI1 ∩ EI2 = Ɵ, EO1 ∩ EO2 = Ɵ, EI1 ∩ EO2 = Ɵ, and EO1 ∩ EI2 =
Ɵ.
o 1-connected if either EI ≠ Ɵ or EO ≠ Ɵ.
o 2-connected if either EI1 ∩ EO2 ≠ Ɵ or EO1 ∩ EI2 ≠ Ɵ.
o 3-connected if both EI1 ∩ EO2 ≠ Ɵ and EO1 ∩ EI2 ≠ Ɵ.
5.10.4 Dynamic Interaction in Multiple Processors

 Dynamic interaction on multiple processors needs the expressive power of
communicating finite state machines or some form of Petri nets.
 We will see this interaction in the Saturn Windshield Wiper System.
 The windshield wiper on the Saturn automobile is controlled by a lever and a dial.
 The liver has four positions, OFF, INT (intermittent), LOW, and HIGH; and dial has
three positions say 1, 2, and 3.
 The dial positions indicate three intermittent speeds, and the dial position is relevant
only when the lever is at the INT position.
 The below Table 5.15 shows the windshield wiper speeds in wiper per minute for the
lever and dial positions.
Page 39 of 46
Table 5.15 Windshield wiper table

 If we think about the Saturn windshield wiper system, we find three natural,
interacting devices: the liver, the dial, and the wiper.
 Two events occur on the lever: it can be moved up one position or it can be moved
down one position.
 Similarly, two events occur on the dial: it can be moved clockwise or anticlockwise
direction.
 We can show these operations in the Table 5.16.
Table 5.16 Port Input Events in the Saturn Windshield Wiper.

 The wiper device produces six port output events i.e., the six different wiper speeds
in per minutes. These are shown in the Table 5.17.
Table 5.17 Port Output Events in the Saturn Windshield Wiper.

 The finite state machines for the lever and the dial are given in the Figure 5.14.
Notice we can easily show the events that cause the transitions, but some of the
associated outputs which are indicated by question mark are indeterminate.
 For example, when we move the lever from OFF to INT, we cannot tell specific
output port event because we do not know the state of dial machine.
 Similarly, we cannot tell the output port events in the dial machine, because we do
not know if the lever is in the INT position.
Page 40 of 46
Figure 5.14 Lever and Dial finite state machine.

 We will use EDPNs to compose the lever and dial finite state machines.
 The EDPN of the lever finite machine is shown in the Figure 5.15 and the EDPN of
the dial finite machine is shown in the Figure 5.16.
Figure 5.15 Lever EDPN Figure 5.16 Dial EDPN
 The EDPN transitions, places, and events used in Figure 5.17 are summarized in
Table 5.18.
 In the lever EDPN (Figure 5.15), transitions to the OFF, LOW, and HIGH states
Page 41 of 46
require no interaction with the dial EDPN to determine the associated port output
events (p5, p9, and p10).
 Also transition to the INT state (s1 and s5) has no output port events.
 In the dial EDPN (Figure 5.16), the three dial positions are the three data places, and
the dial events (p3 and p4) are inputs that cause transitions.
 The dial EDPN has no port output events, because these are never output of
transitions in the dial EDPN.
Figure 5.17 EDPN for the windshield wiper system. Table 5.18 EDPN windshield wiper
elements.
 The interaction between the lever and the dial EDPNs is shown in Figure 5.17. It
shows places d2, d5, d6, and d7 are the INT state, transitions s11, s12 and s13 are the
dial positions states, and port events p6, p7, and p8 are the three intermittent wiper
speeds.
 The edges with arrowheads at each end (for example in between d2 and s11) indicate
that the places are inputs to and outputs of the associated transitions.
Page 42 of 46
5.11 Interaction, Composition, and Determinism
The question of non-determinism looms as a backdrop to deep questions in science

and philosophy. Einstein didn't believe in non-determinism; he once commented that he
doubted that God would play dice with the universe. Non-determinism generally refers to
consequences of random events, asking in effect, if there are truly random events (inputs),
can we ever predict their consequences? The logical extreme of this debate ends in the
philosophical/theological question of free will versus pre-destination. Fortunately, for testers,
the software version of non-determinism is less severe. You might want to consider this
section to be a technical editorial. It is based on my experience and analysis using the OSD
framework. I find it yields reasonable answers to the problem of non- determinism; you may
too.
Let's start with a working definition if determinism; here are two possibilities:
1. A system is deterministic if, given its inputs, we can always predict its outputs.
2. A system is deterministic if it always produces the same outputs for a given set of inputs.
Since the second view (repeatable outputs) is less stringent than the first (predictable
outputs), we'll use it as our working definition. Then a non-deterministic system is one in
which there is at least one set of inputs that results in two distinct sets of outputs. It's easy to
devise a non-deterministic finite state machine; Figure 5.18 is one example
Figure 5.18 A nondeterministic finite state machine
When the machine in Figure 5.18 is in state d1, if event e1 occurs, there is a transition
either to state d2 or to d3.
If it is so easy to create a non-deterministic finite state machine, why all the fuss about
determinism in the first place? (It turns out that we can always find a deterministic
Page 43 of 46
equivalent to any non- deterministic finite state machine anyway.) Finite state machines are
models of reality; they only approximate the behavior of a real system. This is why it is so
important to choose an appropriate model — we would like to use the best approximation.
Roughly speaking, decision tables are the mode I of choice for static interactions, finite state
machines suffice for dynamic interactions in a single processor, and some form of Petri net
is needed for dynamic interactions in multiple processors. Before going on, we should
indicate instances of non-determinism in the other two models. A multiple hit decision table
is one in which the inputs (variables in the condition stub) are such that more than one rule is
selected. In Petri nets, non-determinism occurs when more than one transition is enabled.
The choice of which rule executes or which transition fires is made by an external agent.
(Notice that the choice is actually an input!)
Our question of non-determinism reduces to threads in an OSD net, and this is where
interactions, composition, and determinism come together. To ground our discussion in
something "real", consider the SATM threads we used earlier:
T1: withdraw $40.00
T2: withdraw $60.00
T3: deposit $30.00
Threads T1, T2, and T3 interact via a data place for the account balance, and they may be executed
in different processors. The initial balance is $50.00.
Begin with thread TI; if no other thread executes, it will execute correctly, leaving a
balance of $10.00. Suppose we began with thread T2; we should really call it "attempt to
withdraw $60.00", because, if no other thread executes, it will result in the insufficient funds
screen. We should really separate T2 into two threads, T2.1 which is a successful
withdrawal that ends with the display of screen 11 (take cash), and T2.2 which is a failed
withdrawal that ends with the display of screen 8 (insufficient funds). Now let's add some
interaction with thread T3. Threads T2 and T3 are 2- connected via the balance data place.
If T3 executes before T2 reads the balance data, then T2.1 occurs, otherwise T2.2 occurs.
The difference between the two views of determinism is visible here: When the OSD net of T2
begins to execute, we cannot predict the outcome (T2.1 or T2.2), so by the first definition, this
is non-deterministic. By the second definition, however, we can recreate the interaction
(including times) between T2 and T2. If we do, and we capture the behavior as a marking of
the composite OSD net, we will satisfy the repeatable definition of determinism.
Page 44 of 46
5.12 Client-Server Testing

Client-server systems are difficult to test because they exhibit the most difficult
form of interactions, the dynamic ones across multiple processors. Here we can enjoy the
benefits of our strong theoretical development. Client-server systems always entail at least
two processors, one where the server software exists and executes, and one (usually several)
where the client software executes. The main components are usually a database
management system, application programs that use the database, and presentation programs
that produce user-defined output. The position of these components results in the fat server
vs. fat client distinction [Lewis 94] (see Figure 5.19).
Figure 5.19 Fat Clients and Servers
Client-server systems also include a network to connect the clients with the server,
the network software, and a graphical user interface (GUI) for the clients. To make matters
worse, we can differentiate homogeneous and heterogeneous CS systems in terms of client
processors that are identical or diverse. The multiple terminal version of the SATM system
would be a fat client system, since the central bank does very little of the transaction
processing.
Page 45 of 46
Possible Questions:
1. What is thread? Explain different levels of threads.
2. Explain threads with its different definitions.
3. Explain the basic concepts for requirements specification. (June/July 2016) (10 M)
4. With a neat diagram explain top level, PIN entry and PIN try finite state machine of
SATM system.
5. Explain about structural strategies for thread testing.
6. Explain about functional strategies for thread testing. (June/July 2014) (10M),
(June/July 2015) (10M).
7. Explain different SATM threads.
8. Explain the operational profile of SATM system and mention the difference between
progression and regression testing.
9. What is ASF and explain with testing example.
10. Explain the 6 basic rules of thread taxonomy.
11. Explain static interaction in a single and multiple processors.
12. Explain dynamic interaction in a single and multiple processors.
13. Write a short note on ‘taxonomy of interactions’ and ‘Client/Server testing’.
(June/July 2016) (10 M)
14. Explain about client/server testing. (June/July 2014) (10M), (June/July 2015) (10M).
***
Page 46 of 46

Unit 7

Uploaded by

Copyright:

Available Formats

Unit 7

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Unit 7

Uploaded by

Copyright:

Available Formats

Unit V (2016-17) System Testing & Interaction Testing Vishwesh Jayashekar

We will see the system testing in terms of Threads of system-level behavior. We

 An interleaved sequence of port input and output events

Threads have distinct level

 A Unit-Level threads is usefully understood as an execution-time path of source

 An Integration-Level threads is a sequence of module execution and messages.

 A System-Level thread is a sequence of atomic system functions.

 A sequence of atomic system functions implies an interleaved sequence of ports

A computer runs many applications at once,

5.1.1 Thread Possibilities

Here are four candidate threads in our SATM system:

• Entry of a Personal Identification Number (PIN)

• An ATM session, containing two or more simple transactions.

5.1.2 Thread Definitions

Unit Source & System Thread

Let’s see each and every thread in details:

 An MM-Path is a path in the MM-Path graph of a set of units.

5.2 Basis Concepts for Requirements Specification

Here we discuss system testing with respect to a basis set of requirements

 Data refers to information that is either initialized, stored, updated, or (possibly)

5.2.3 Ports / Devices

5.2.6 Relationships Among Basis Concepts

Figure 5.1 E/R model of basis concepts

5.2.7 Modeling with Basis Concepts

 Selection of an appropriate control model is the essence of requirements

Figure 5.2 Modeling relationships among basic constructs.

5.3 Finding Threads

Figure 5.3 Top-level SATM state machine

Figure 5.4 PIN entry finite state machine

Port Input Events Port Output Events

Table 5.1 Events in the PIN Entry Finite State Machine

Figure 5.5 PIN try finite state machine

Port Input Events Port Output Events

Port Input Events Port Output Events

Port Input Events Port Output Events

5.4 Structural Strategies for Thread Testing

5.4.1 Bottom-Up Threads

Input Event Sequence Path of Transitions

Table 5.5 Thread Paths in the PIN Try FSM

Input Event Sequence Path of Transitions

Table 5.6 Thread Paths in the PIN Entry FSM

5.4.2 Node and Edge Coverage Metrics

Port Input Events Port Output Events Nodes Edges

(Second Try) Screen 2 displayed with “--------“ 2.2

Table 5.7 Node and Edge Traversal of a Thread

Table 5.8 Thread/State Incidence

Table 5.9 Thread/Transition Incidence

5.5 Functional Strategies for Thread Testing

5.5.1 Event-Based Thread Testing

We can also define two coverage metrics based on port output

PO1 coverage is an acceptable minimum. It is particularly effective when a system

5.5.2 Port-Based Thread Testing

of the basis constructs (as shown in the Figure 5.1).

5.5.3 Data-Based Thread Testing

Figure 5.6 E/R model of a library.

 Here are some typical transactions in the library system:

DM1: Exercise the cardinality of every relationship.

 When such information is available, it leads directly to obvious boundary value

5.6 SATM Test Threads