Information Technology Reference
In-Depth Information
in the labels. The second approach is to adopt a state-labelling procedure that
augments states in the PTA or the LTS with data constraints.
Decomposition into Atomic Functions.
The decomposition approach works
as follows. Instead of using data-sensitive functions such as the “close” example
above, it can be decomposed into separate sub-functions, based on the different
ways it can affect the system state. The approach is analogous to the Category
Partition method used in functional testing [24]. So the “close” function could
be divided into “close” and “close last”, making the distinction between the two
different types of close behaviour. The data constraints remain implicit, but the
data state-based behaviour is represented more accurately by the labels.
This approach places a significant burden on the developer. They have to
be aware not only of the individual functions in the system, but also of their
potential to change the state of the system. Furthermore, the process of trace
collection becomes more intricate. It is no longer su
cient to simply list the
functions in the order in which they occur. Every time a data state-dependent
function is executed, the data state has to be interpreted, and mapped to the
appropriate re-labelled function name that represents the new sub-function. For
example, the execution of “close” could no longer be simply listed in the trace as
“close”, but would have to be mapped to either “close” or “close last” depending
on the current data state.
Labelling States with Data Constraints.
Both Dupont
et al.
[25,11] and
Lorenzoli
et al.
[26] describe techniques for integrating data-constraints into
the inference process. They deal with different settings; Dupont
et al.
assume
a forward-engineering scenario, where the developer can manually provide the
relevant rules for particular sets of states, whereas Lorenzoli
et al.
describe a
reverse-engineering scenario, where they have to mine data constraints from the
variable values in a given set of traces.
In the approach proposed by Dupont
et al.
, additional domain knowledge
about the system is added in the form of
fluents
. A fluent is in effect a proposition
that is given an initial state, and this state can be altered by a selection of events
in
Σ
. Given that the relevant fluents are specified for the initial state, the rest
of the states in the state machine can be annotated in terms of the fluents by
symbolic execution. Consequently, these state annotations can be fed into the
inference process, preventing states that correspond to distinct
data
states from
being merged.
Lorenzoli
et al.
approach the problem from a reverse-engineering angle. In
their setting, there is no well-informed developer who can supply suitable fluent-
like constraints. Instead, they extract data constraints from variable values in
execution traces. Data constraints are obtained with the Daikon tool [27], and
state comparisons take account of these constraints. Although they describe the
approach with respect to the problematic
k
-tails algorithm, there is no reason
why it cannot be adapted to other algorithms such as EDSM.
The approach proposed by Lorenzoli
et al.
, of extracting data constraints di-
rectly from the traces, is appealing. It provides additional information without
