Compositional Specifications for ioco Testing

TL;DR

This paper introduces a compositional approach to IOCO-based model testing that reduces integration testing effort by inferring system correctness from component testing, leveraging new composition and hiding operations.

Contribution

It proposes novel composition and hiding operations inspired by contract-based design, enabling more efficient and effective component-based testing in asynchronous systems.

Findings

Preserves behaviors compatible under composition and hiding.

Reduces integration testing by inferring correctness from component tests.

Detects potential weaknesses in specifications.

Abstract

Model-based testing is a promising technology for black-box software and hardware testing, in which test cases are generated automatically from high-level specifications. Nowadays, systems typically consist of multiple interacting components and, due to their complexity, testing presents a considerable portion of the effort and cost in the design process. Exploiting the compositional structure of system specifications can considerably reduce the effort in model-based testing. Moreover, inferring properties about the system from testing its individual components allows the designer to reduce the amount of integration testing. In this paper, we study compositional properties of the IOCO-testing theory. We propose a new approach to composition and hiding operations, inspired by contract-based design and interface theories. These operations preserve behaviors that are compatible under composition and hiding, and prune away incompatible ones. The resulting specification characterizes the input sequences for which the unit testing of components is sufficient to infer the correctness of component integration without the need for further tests. We provide a methodology that uses these results to minimize integration testing effort, but also to detect potential weaknesses in specifications. While we focus on asynchronous models and the IOCO conformance relation, the resulting methodology can be applied to a broader class of systems.

Tables

Table 1. TABLE I: Sizes of specification models and their compositions.

Model	# tran	# states
$A$	10	6
$B$	10	6
$d\left(A\right)$	31	9
$d\left(B\right)$	28	9
$A^{\prime \prime }$	22	10
$B^{\prime }$	14	6
$h_{\Sigma }\left(d\left(A\right)\parallel d\left(B\right)\right)$	76	34
${\hat{h}}_{\Sigma }\left(A^{\prime \prime }\otimes B^{\prime }\right)$	24	12

Equations

$$\begin{array}[]{lcl}q\xrightarrow{\mu}q^{\prime}&\equiv&(q,\mu,q^{\prime})\in T\\ q\xrightarrow{\mu_{1}\cdot\ldots\cdot\mu_{n}}q^{\prime}&\equiv&\exists q_{0},\ldots,q_{n}\;\textrm{st.}\;q=q_{0}\xrightarrow{\mu_{1}}q_{1}\\ &&\xrightarrow{\mu_{2}}\ldots\xrightarrow{\mu_{n}}q_{n}=q^{\prime}\\ q\xrightarrow{\mu_{1}\cdot\ldots\cdot\mu_{n}}&\equiv&\exists q^{\prime}\;\textrm{st.}\;q\xrightarrow{\mu_{1}\cdot\ldots\cdot\mu_{n}}q^{\prime}\\ q\not\xrightarrow{\mu_{1}\cdot\ldots\cdot\mu_{n}}&\equiv&\neg\exists q^{\prime}\;\textrm{st.}\;q\xrightarrow{\mu_{1}\cdot\ldots\cdot\mu_{n}}q^{\prime}\\ q\xRightarrow{\epsilon}q^{\prime}&\equiv&q=q^{\prime}\;\textrm{or}\;q\xrightarrow{\tau\cdot\ldots\cdot\tau}q^{\prime}\\ q\xRightarrow{a}q^{\prime}&\equiv&\exists q_{1},q_{2}\;\textrm{st.}\;q\xRightarrow{\epsilon}q_{1}\xrightarrow{a}q_{2}\xRightarrow{\epsilon}q^{\prime}\\ q\xRightarrow{a_{1}\cdot\ldots\cdot a_{n}}q^{\prime}&\equiv&\exists q_{0},\ldots,q_{n}\;\textrm{st.}\;q=q_{0}\xRightarrow{a_{1}}q_{1}\\ &&\xRightarrow{a_{2}}\ldots\xRightarrow{a_{n}}q_{n}=q^{\prime}\\ q\xRightarrow{a_{1}\cdot\ldots\cdot a_{n}}&\equiv&\exists q^{\prime}\;\textrm{st.}\;q\xRightarrow{a_{1}\cdot\ldots\cdot a_{n}}q^{\prime}\\ q\not\xRightarrow{a_{1}\cdot\ldots\cdot a_{n}}&\equiv&\neg\exists q^{\prime}\;\textrm{st.}\;q\xRightarrow{a_{1}\cdot\ldots\cdot a_{n}}q^{\prime}\\ \end{array}$$

$$(q_1,q_2){\stackrel{\mu }{\to }}_{A_{1\parallel 2}}(q_1^{\prime },q_2)\text{lx@proof@logical@and}{q}_1{\stackrel{\mu }{\to }}_{A_1}{q}_1^{\prime }\mu \in (L_1\cup \{\tau \})\backslash L_2$$

$$(q_1,q_2){\stackrel{\mu }{\to }}_{A_{1\parallel 2}}(q_1,q_2^{\prime })\text{lx@proof@logical@and}{q}_2{\stackrel{\mu }{\to }}_{A_2}{q}_2^{\prime }\mu \in (L_2\cup \{\tau \})\backslash L_1$$

$$(q_1,q_2){\stackrel{\mu }{\to }}_{A_{1\parallel 2}}(q_1^{\prime },q_2^{\prime })\text{lx@proof@logical@and}{q}_1{\stackrel{\mu }{\to }}_{A_1}{q}_1^{\prime }{q}_2{\stackrel{\mu }{\to }}_{A_2}{q}_2^{\prime }\mu \in L_1\cap L_2$$

$$\forall \sigma \in \text{Straces}(S),\text{out}({\hat{q}}_I\text{after}\sigma )\subseteq \text{out}({\hat{q}}_S\text{after}\sigma ).$$

$$\begin{array}[]{lcl}I_{1}\;\textbf{ioco}\;S_{1}\wedge I_{2}\;\textbf{ioco}\;S_{2}&\not\rightarrow&(I_{1}\parallel I_{2})\;\textbf{ioco}\;(S_{1}\parallel S_{2})\\ I_{1}\;\textbf{ioco}\;S^{*}_{1}\wedge I_{2}\;\textbf{ioco}\;S^{*}_{2}&\rightarrow&(I_{1}\parallel I_{2})\;\textbf{ioco}\;(S^{*}_{1}\parallel S^{*}_{2}).\end{array}$$

$$\begin{array}[]{lcl}I\ \textbf{ioco}\ S&\not\rightarrow&h_{\Sigma}(I)\ \textbf{ioco}\ h_{\Sigma}(S)\\ I\ \textbf{ioco}\ S^{*}&\rightarrow&h_{\Sigma}(I)\ \textbf{ioco}\ h_{\Sigma}(S^{*}).\end{array}$$

$$I_1\text{ioco}{S}_1\wedge I_2\text{ioco}{S}_2\to (I_1\otimes I_2)\text{ioco}(S_1\otimes S_2).$$

$$I\text{ioco}S\to {\hat{h}}_{\Sigma }(I)\text{ioco}{\hat{h}}_{\Sigma }(S).$$

$$I_1\text{ioco}{S}_1\wedge I_2\text{ioco}{S}_2\to {\hat{h}}_{\Sigma }(I_1\otimes I_2)\text{ioco}{\hat{h}}_{\Sigma }(S_1\otimes S_2).$$

Full text

In this paper, we study compositional properties of the ioco-testing theory. We propose a new approach to composition and hiding operations, inspired by contract-based design and interface theories. These operations preserve behaviors that are compatible under composition and hiding, and prune away incompatible ones. The resulting specification characterizes the input sequences for which the unit testing of components is sufficient to infer the correctness of component integration without the need for further tests. We provide a methodology that uses these results to minimize integration testing effort, but also to detect potential weaknesses in specifications. While we focus on asynchronous models and the ioco conformance relation, the resulting methodology can be applied to a broader class of systems.

I Introduction

Modern software and hardware system design usually involves the integration of interacting components that work together in order to realize some requested behavior. Fig. 1 illustrates two components $I_{1}$ and $I_{2}$ that are composed together to form the system $I$. The complexity of the individual components together with their elaborate cooperation protocols often results in behavioral faults. Therefore, verification and validation methods are applied to ensure that the embedded system satisfies its specification. This is in particular true for safety-critical designs, for which correctness evidence is imposed by the regulation bodies (see for example the automotive standard ISO 26262 [1]).

Up to date, design simulation combined with testing remains the preferred technique in industry to demonstrate the correctness of software and hardware systems. Typically, verification engineers need to first test individual system components (unit testing of $I_{1}$ and $I_{2}$), and then test the complete system (integration testing of $I$). This process relies on verification engineers manually generating test vectors from specifications given as informal (natural language) requirements. This process is inherently time consuming, ad-hoc and prone to human errors. As a result, testing represents the main bottleneck in the design of complex systems today.

Model-based testing is a technology that provides formalization and automation to the test case generation and execution process, thus reducing time and cost of systems design. In model-based testing a system-under-test (SUT), denoted by $I$, is tested for conformance to its formal specification model $S$, derived from informal requirements. While $S$ is a formal object, $I$ is a “black-box”, a physical implementation with unknown internal structure. The SUT $I$ can be accessed by the tester only through its external interface. In order to reason about the compliance of $I$ to $S$, one needs to use the testing assumption (see [2]), stating that $I$ can be modeled in the same formalism as $S$ and that $I$ is receptive (input-enabled), i.e. it accepts all inputs at any point in time. In contrast to $I$, $S$ does not need to be receptive. Lack of input (under-specification) in a given state of the specification models the assumption that the external environment for $I$ does not provide that input. If the environment nevertheless emits this input action, the specification allows $I$ to freely choose its response.

In this paper, we focus on the ioco-testing theory [2], a model-based testing framework for input/output labeled transition systems (IOLts). The ioco-testing theory is centered around the input/output conformance relation ioco. Informally, we say that an implementation $I$ ioco-conforms to its specification $S$ if any experiment derived from $S$ and executed on $I$ leads to an output in $I$ that is foreseen by $S$. In the ioco-testing theory, the lack of outputs or internal transitions is observable via a quiescence action.

In its original form, ioco-testing does not take the compositional aspects of systems into account. For example, in Fig. 1, $I$ is the result of composing the components $I_{1}$ and $I_{2}$. Typically, the actions over which the two components synchronize ($e$ and $d$ in the example) are hidden and become unobservable to the tester after integration. In order to cope with costly testing of large systems, results of unit testing individual components need to be used to infer properties about the composed system, to avoid or at least minimize expensive integration tests. The compositional ioco-testing problem can be formulated as follows: if $I_{1}$ ioco-conforms to its specification model $S_{1}$ and $I_{2}$ ioco-conforms to its specification model $S_{2}$, can we infer that $I$ also ioco-conforms to $S$, where $I$ and $S$ denote the composed implementation and specification after hiding synchronization actions?

This question was first addressed in [3]. The authors show that in the general case neither parallel composition of specifications nor hiding of actions are compositional in the ioco-testing theory. This result is not surprising. Parallel composition is an operation tailored to receptive models. We argue that it is not an appropriate operator for composing under-specified models where one component can generate an output which is not expected as an input by the other. In addition, the hiding operation introduces partial observation over the actual state of the SUT and can result in confusion regarding the under-specified parts of the system. The authors of [3] propose two alternative restrictions to the specification models in order to preserve compositionality of ioco. The first option is to disallow under-specification of inputs. This is a very strong requirement in practice, since components are usually designed to operate in constrained environments. The second option allows starting with under-specification, but requires demonic completion of specification models — an operation which makes the assumptions about the component’s environment explicit and thus makes the specification model input-enabled. We claim that demonic completion can hide important information from the tester about the poor quality of a specification and thus obscure its original intent.

We propose a different approach to compositional ioco-testing which, in contrast to [3], does not restrict the specification models. We define two operations — friendly composition and hiding — that are tailored to the integration of non-receptive specifications. They are based on a game-theoretic optimistic approach, inspired by interface theories [4, 5]. The result of the friendly composition is the overall specification that integrates the component specifications while pruning away any inputs that lead to incompatible interactions between the components. The friendly hiding operation prunes away inputs that lead to states which are ambiguous with respect to under-specification after hiding. After composing the component specifications followed by hiding of synchronizing actions, the resulting specification defines all input sequences for which no integration testing is needed — the correct integration follows from the conformance of the individual components to their specification. In addition to these technical results, this paper provides guidelines to identify specifications that are poorly modeled for compositional testing. We argue that pruned input sequences often indicate weaknesses in the specification and can be addressed by: (1) strengthening the specifications; (2) making more outputs observable; and (3) integration testing. Indeed, the proper formalization of requirements resulting in high-quality component specifications is crucial for exploiting the compositional nature of systems in testing. Investing efforts in improving models can considerably minimize expensive integration tests. We discuss methodological aspects of using our technical results to improve component models and to tailor them to compositional testing.

In Section II, we further motivate the problem of compositional testing with ioco and provide an informal overview of our approach, illustrating it with a vending machine example. We also identify modeling issues and discuss problems related to compositional ioco-testing and sketch possible solutions. Section III recalls the basics of the ioco-testing theory including the known results about compositional ioco-testing. We provide the formal presentation of our approach in Section IV and evaluate it in Section V. We present related work in more detail in Section VI, and finally conclude the paper in Section VII, giving future perspectives for our work. The proofs are presented in a separate report [6].

II Overview and Motivating Example

In this section, we develop the example of a drink vending machine, which we use to (1) further motivate the problem; (2) highlight the difficulties of compositional testing within the ioco-theory; and (3) provide an informal overview of our proposed approach to tackle the problem.

The drink vending machine consists of the user interface and the drink maker components. The user interface specification $S_{1}$ is shown in Fig. 2 (a). $S_{1}$ requires that the user first inserts a coin (coin?)111We consistently use the symbol ? to denote an input, and the symbol ! to denote an output action., and then selects either a tee (utee?) or a coffee (ucoffee?). After choosing the coffee, the user can also request milk (umilk?) for the coffee. The drink request (mtee!, mcoffee! or mcoffeemilk!) is forwarded to the drink maker, and the user interface waits for an acknowledgment (done?) that the drink was delivered to the user. When the drink is ready, the user interface emits a message (msg!) to the user and returns to its initial state.

The drink maker specification $S_{2}$, depicted in Fig. 2 (b), waits for a drink request (mcoffee? or mcoffeemilk?) from the user interface. Upon receiving the drink request, $S_{2}$ signals the delivery of the drink to the user (actions coffee! and coffeemilk!) and finally an acknowledgment (done!) is sent to the user interface. Note that $S_{2}$ is under-specified in its initial state $A$ — it omits the action mtee? and thus makes an assumption that the user interface never requests a tee.

We note that in states $1$ and $2$ of $S_{1}$, and state $A$ of $S_{2}$ only inputs are allowed. In the ioco-testing theory, such states are called quiescent, where the quiescence denotes the absence of observable outputs and internal actions. The absence of outputs is considered to be observable, and is marked as a special $\delta$ action (green self-loops in Fig. 2). Since quiescence is usually not explicitly modeled by the designer, we omit marking quiescent transitions in the rest of the section.

Specifications $S_{1}$ and $S_{2}$ give a certain freedom in implementing user interface and drink machine components. In particular, implementations can choose how to treat under-specified (unexpected) inputs. For instance, $S_{1}$ assumes that the user inserts a coin before choosing the drink. If the user swaps the order of actions, and first orders a drink, $S_{1}$ allows the implementation to react to this input in an arbitrary way. Fig. 3 depicts possible implementations $I_{1}$ and $I_{2}$ of their respective specifications $S_{1}$ and $S_{2}$. The user interface implementation $I_{1}$ closely follows its specification and silently ignores all unexpected inputs (marked in blue). For example, if the user requests a coffee before inserting a coin (in state $1$), this request is silently consumed by $I_{1}$. This implementation is ioco-conformant to its specification because it never generates an output which is not foreseen by $S_{1}$. Similarly to $I_{1}$, the drink maker implementation $I_{2}$ also silently consumes unexpected inputs in all states, except in the state $A$. In the initial state, $I_{2}$ reacts to a tee request (mtee?) by moving to the state $B$, from which a coffee (coffee!) is delivered to the user. Although preparing a coffee upon a tee request may not be a logical behavior, it is ioco-conformant to $S_{2}$ — the specification does not impose any particular reaction to the tee request in its initial state, giving to correct implementations complete freedom of handling such input.

In the classic ioco-theory [3], specifications are combined with the parallel composition operation for input/output transitions systems [7]. Informally, parallel composition of two specifications is their Cartesian product, where each specification is allowed to take local actions independently, but the two specifications must synchronize on shared actions. Fig. 4 (a) depicts the parallel composition of $S_{1}$ and $S_{2}$, where mtee, mcoffee, mcoffeemilk and done are the shared actions. In addition to parallel composition, we may wish to hide shared actions, which are often only used to synchronize components, but are not observable by the external user. In the vending machine example, the user can observe inputs to the vending machine (inserting a coin and choosing the drink) and the outputs from the machine (the actual drink and the acknowledgment message). The actions mtee, mcoffee, mcoffeemilk and done are used for proper synchronization between the user interface and the drink maker components and are not visible to the user. Fig. 4 (b) depicts the parallel composition of specifications $S_{1}$ and $S_{2}$ in which the shared actions are hidden (denoted by the special action $\tau$). Fig. 5 (a) and (b) show the parallel composition of the component implementations without and with hiding of the synchronization actions, respectively.

While $I_{1}$ is ioco-conformant to $S_{1}$ and $I_{2}$ is ioco-conformant to $S_{2}$, the composition of $I_{1}$ and $I_{2}$ is not ioco-conformant to the composition of $S_{1}$ and $S_{2}$ (with or without hiding of shared actions), as shown in [3]. We now explain the reasons for non-compositionality of ioco in the vending machine example.

Assuming that shared actions are not hidden, consider a test case starting with the input sequence $\emph{coin?}\cdot\emph{utee?}$. According to the specification (Fig. 4 (a)), the only allowed observation after reading this sequence is quiescence, since state $3A$ does not have any outgoing transitions labeled by an output action. However, the composed implementation (Fig. 5 (a)) emits mtee!, an output action not allowed by the specification after reading the same sequence. It follows that ioco-conformance is not preserved by parallel composition.

Parallel composition is an operation tailored to combining receptive components — whenever a component outputs a shared action the other component is by definition able to consume it from any of its local states. This is not the case for non-receptive models. Indeed, $S_{1}$ emits the shared action mtee! in its local state $3$, while the drink maker specification $S_{2}$ is not ready to consume it in its local state $A$, i.e. the assumption of $S_{2}$ is not fulfilled by $S_{1}$. This results in a “deadlock” state $3A$ in the parallel composition of $S_{1}$ and $S_{2}$. However, the intended meaning of under-specifying the action mtee? in the state $A$ of $S_{2}$ is that $S_{2}$ is free to choose any reaction to this unexpected action. This is in contrast to what happens in state $3A$ of the composed specification.

We now consider the case when the shared actions are hidden. After reading the input sequence $\emph{coin?}\cdot\emph{ucoffee?}$, the state of the composed system after hiding is not uniquely defined — it can be either $4A$ or $6B$ (Fig. 5 (b)) since the user cannot observe whether the hidden action mcoffee! has taken place. Note that the specification (Fig. 4 (b)) leaves the input umilk? unspecified in $6B$, but not in $4A$, thus resulting in an ambiguity on what an external observer can expect as the reaction to this input. In fact, according to the ioco-theory, the only allowed observable output after executing the sequence $\emph{coin?}\cdot\emph{ucoffee?}\cdot\emph{umilk?}$ is coffeemilk!, while the composed implementation can output both coffeemilk! (if in state $6C$) or coffee! (if in state $6B$).

In [3], the authors propose two solutions to the above anomalies. Both solutions guarantee that ioco-conformance is preserved by parallel composition and hiding. The first solution requires specification models to be receptive. We claim that this restriction is too strong — under-specification of inputs is one of the most powerful modeling tools for specifying open systems. A component is almost always expected to work correctly only in constrained contexts, and under-specification of inputs allows to exactly define a valid operating environment. The second solution allows non-receptive models, but requires their demonic completion — an operation that makes the model effectively input-enabled. Demonic completion results in adding transitions labeled with the under-specified inputs from every state to a newly inserted “sink” portion of the graph. The sink portion essentially self-loops with all inputs and outputs. Demonic completion makes the intended meaning of input under-specification explicit: when a system receives an unexpected input, it has the full freedom to choose its reaction to this input. Fig. 6 depicts parts of the demonically completed specifications $S_{1}$ and $S_{2}$.

While demonic completion preserves the intended meaning of specifications, we argue that it does not provide a fully satisfactory solution to compositional ioco-testing. First, the resulting specification after demonic completion increases in size. Although linear, this increase is still important for extensively under-specified models. For instance, $S_{1}$ has $7$ states and $9$ transitions, while its size increases to $10$ states and $55$ transitions after completion. Second, demonic completion obfuscates the distinction between foreseen and unspecified interactions between components. In Fig. 6 (a) the information that the input action ucoffee? is not expected in state $6$ is lost.

This lack of distinction between foreseen and unexpected interactions between components masks the fact that we often deal with component specifications of poor quality. This results in a composition which does not faithfully represent the intended behavior of the overall system. In particular, composition with hiding of demonically completed specifications may result in many vacuous behaviors. We illustrate this problem with the example from Fig. 6. After composing demonically completed variants of $S_{1}$ and $S_{2}$, and hiding the synchronization action mcoffee, the external observer cannot distinguish between states $4A$ and $6B$, which in contrast to the original composition (see Fig. 4 (b)), now both admit the input action umilk?. However, umilk? triggers a transition from $6B$ to the state $D_{1}B$, from which the demonically completed specification $S_{1}$ allows all possible behaviors, including the one in which the acknowledgment message is sent back to the user without any drink being served.

We propose an alternative approach to composition and hiding that provides additional information to the designer. It is inspired by interface theories [4, 5]. We provide a new composition operation, called the friendly composition, which takes an optimistic approach to combining two specifications. Following the optimistic approach, two specifications are compatible for composition, if there exists some context in which they can interact while both satisfying their guarantees. We have seen in Fig. 4 (a) that the interaction of two specifications (user interface and drink maker) results in states in which one component is allowed to emit an output which is not expected by the other component (action $\emph{mtee}!$ in the state $3A$). We declare such states as ambiguous states, and compute the maximal compound environment which avoids such states. The algorithm that computes the friendly composition of two specifications prunes all states from which the environment cannot prevent the composed system from reaching an ambiguous state. The resulting composite specification combines the compatible interactions of two component specifications. Fig. 7 (a) depicts the friendly composition of $S_{1}$ and $S_{2}$, where red dashed transitions and states are the ones pruned away from their parallel composition.

Similarly to friendly composition, we define the friendly hiding operation, which prunes away from the specification with hidden actions all the states that can become ambiguous when interacting with an external environment. The resulting specification is depicted in Fig. 7 (b), where red dashed transition and states are pruned away from the composite specification of $S_{1}$ and $S_{2}$ after hiding.

The main technical contribution of this paper is the definition of the friendly composition and friendly hiding operations, for which we show that they preserve ioco-conformance. In contrast to combining demonic completion with parallel composition and hiding, our approach results in composite specifications of smaller size. The resulting composite specification defines behaviors for which no integration testing is needed. Apart from the technical contribution, we argue that friendly composition and hiding expose weaknesses of component specifications to the designer. The pruned behaviors after applying friendly composition and hiding indicate that assumptions made by individual component specifications may be too weak and deserve more careful analysis. We claim that the time spent on improving the quality of the component specifications so that they allow compositional testing is rewarded with the avoidance of integration tests. We distinguish between the following scenarios in using our approach to derive better compositional specifications.

Scenario A: the designer can guarantee that the composed system will be used in the context defined by the assumptions of the friendly-composed specification and that the ambiguous interactions will never take place. In this case, no additional integration testing is needed. In the vending machine example, this would mean that the designer has the possibility of disabling the tee and milk request buttons.

Scenario B: by hiding shared actions information about the internal state of the SUT may be lost, resulting in ambiguous states. Better observability can be achieved by keeping some shared actions visible to the external environment. From the technical point of view, keeping the mcoffee! action visible in the vending machine specification allows for compositional testing.

Scenario C: the designer cannot guarantee that the composed system will be used in the context defined by the friendly-composed specification assumptions. In this case, the specification is too weak and needs a revision. In our example, the race between the input action umilk? and the output action mcoffee! in $S_{1}$ indicates a poor specification. We propose a different specification, which requires an additional action and in which the user is expected to make all requests before the machine is able to process them.

III Preliminaries

In this section, we define labeled transition systems, parallel composition and hiding operations, input/output conformance relation (ioco), and recall the previous results on compositional properties of ioco.

III-A Labeled Transition Systems

An input/output labeled transition system (IOLts) is a formal model for specifying reactive systems. An IOLts $A$ is a tuple $(Q,L^{I},L^{O},T,\hat{q})$, where $Q$ is a countable set of states, $L^{I}$ and $L^{O}$ are disjoint countable sets of input and output labels, $\hat{q}\in Q$ is the initial state and $T$ is the transition relation. We denote by $L=L^{I}\cup L^{O}$ the set of all labels of an IOLts. To avoid ambiguity we may use subscripts, like $Q_{A}$, to indicate that an element belongs to an IOLts $A$. We consider IOLts with possibly silent transitions, denoted by $\tau$, hence the transition relation is defined as $T\subseteq Q\times(L\cup\{\tau\})\times Q$, with $\tau\not\in L$. An IOLts is said to be receptive, denoted by R-IOLts, if for all $q\in Q$ and for all $a\in L^{I}$, there exists an outgoing transition from $q$ labeled by $a$. For instance, specifications $S_{1}$ and $S_{2}$ in Fig. 2 are IOLts, while implementations $I_{1}$ and $I_{2}$ in Fig. 3 are R-IOLts. Strongly-convergent IOLts are transition systems that do not have loops consisting of only silent transitions. We use the standard abbreviated notation, where $\mu\in L\cup\{\tau\}$ and $a\in L$

[TABLE]

A sequence $\sigma\in(L\cup\{\tau\})^{+}$ is an execution of an IOLts $A$ if $\hat{q}_{A}\xrightarrow{\sigma}$. A sequence $\sigma\in L^{*}$ is a trace of $A$ if $\hat{q}_{A}\xRightarrow{\sigma}$. We denote by $\textbf{Traces}(A)$ the set of all traces of $A$. The sequence $\emph{coin}\cdot\emph{ucoffee}\cdot\tau\cdot\emph{coffee}$ is an execution of the specification shown in Fig. 4 (b), while $\emph{coin}\cdot\emph{ucoffee}\cdot\emph{coffee}$ is its trace. Given a subset of labels $L^{\prime}\subseteq L$ and $\sigma$ a sequence over $L$, we denote by $\sigma_{\downarrow L^{\prime}}$ the projection $\sigma$ to the set of labels $L^{\prime}$.

We say that a state $q\in Q$ of $A$ is quiescent, denoted by $\delta(q)$, if it has no outgoing output or internal actions. Quiescent states emit a special quiescence action $\delta$, which indicates that $A$ cannot proceed without input from the environment. The suspension automata are IOLts, where quiescent actions are made explicit. Formally, given an IOLts $A=(Q,L^{I},L^{O},T,\hat{q})$, its suspension automaton $A_{\delta}$ is the IOLts $A_{\delta}=(Q,L^{I},L^{O}\cup\{\delta\},T\cup T_{\delta},\hat{q})$, where $T_{\delta}=\{q\xrightarrow{\delta}q~{}|~{}\delta(q)\}$. We denote by $\textbf{Straces}(A)$ the set $\{\sigma\in(L\cup\{\delta\})^{*}~{}|~{}\hat{q}\xRightarrow{\sigma}_{A_{\delta}}\}$ of traces of $A_{\delta}$, also called suspension traces. Specifications $S_{1}$ and $S_{2}$ shown in Fig. 2 show explicitly quiescence actions, where for example $\delta\cdot\emph{coin}\cdot\delta$ is in $\textbf{Straces}(S_{1})$.

III-B Parallel Composition

Two components can be integrated if their input/output actions do not conflict. In particular, we require that the intersection of their input (output) label sets is empty. Formally, we say that two IOLts $A_{1}$ and $A_{2}$ are composable if $L^{I}_{1}\cap L^{I}_{2}=L^{O}_{1}\cap L^{O}_{2}=\emptyset$. When two composable IOLts are composed, they synchronize on shared actions and move independently on other actions. Formally, parallel composition is defined as follows.

Definition 1** (Parallel composition)**

Let $A_{1}=(Q_{1},L^{I}_{1},L^{O}_{1},T_{1},\hat{q}_{1})$ and $A_{2}=(Q_{2},L^{I}_{2},L^{O}_{2},T_{2},\hat{q}_{2})$ be two composable IOLts. Their parallel composition, denoted by $A_{1}\parallel A_{2}$, is the IOLts $(Q_{1\parallel 2},L^{I}_{1\parallel 2},L^{O}_{1\parallel 2},T_{1\parallel 2},\hat{q}_{1\parallel 2})$, where $Q_{1\parallel 2}=Q_{1}\times Q_{2}$, $L^{I}_{1\parallel 2}=(L^{I}_{1}\backslash L^{O}_{2})\cup(L^{I}_{2}\backslash L^{O}_{1})$, $L^{O}_{1\parallel 2}=L^{O}_{1}\cup L^{O}_{2}$, $\hat{q}_{1\parallel 2}=(\hat{q}_{1},\hat{q}_{2})$, and $T_{1\parallel 2}$ is defined by the rules:

[TABLE]

[TABLE]

[TABLE]

The specification $S_{1}\parallel S_{2}$ shown in Fig. 4 (a) represents the parallel composition of specifications $S_{1}$ and $S_{2}$.

III-C Hiding

The parallel composition of two components is often followed by hiding some of the actions on which they synchronize. We follow the process algebraic approach in which parallel composition and hiding operations are two separate operations, and formally define hiding as follows.

Definition 2** (Hiding)**

Let $A=(Q,L^{I},L^{O},T,\hat{q})$ be an IOLts and $\Sigma\subseteq L^{O}$ be the subset of output actions. The hiding of $\Sigma$ in $A$, denoted by $h_{\Sigma}(A)$, is the tuple $(Q,L^{I},L^{O}\setminus\Sigma,h_{\Sigma}(T),\hat{q})$, where $h_{\Sigma}(T)$ is obtained from $T$ by replacing every transition $(q,a,q^{\prime})\in T$ labeled by an output action $a\in\Sigma$ by the transition $(q,\tau,q^{\prime})$.

The specification $h_{\Sigma}(S_{1}\parallel S_{2})$ shown in Fig. 4 (b) represents the hiding of $\Sigma$ in $S_{1}\parallel S_{2}$, where $\Sigma=\{\emph{mtee},\emph{mcoffee},\emph{mcoffeemilk},\emph{done}\}$.

III-D Input/Output Conformance Relation

Given an IOLts $A$, the set $\textbf{out}(q)\equiv\{a\in L^{O}~{}|~{}q\xrightarrow{a}~{}\}\cup\{\delta~{}|~{}\delta(q)\}$ is the set of all outputs (including $\delta$ if $q$ is quiescent) that are defined when the system is in state $q$. The set $q\;\textbf{after}\;\sigma\equiv\{q^{\prime}~{}|~{}q\xRightarrow{\sigma}_{A_{\delta}}q^{\prime}\}$ denotes the set of states that can be reached in $A$ from $q$ after reading $\sigma$ in its suspension automaton $A_{\delta}$. We now present the formal definition of the ioco relation.

Definition 3

Given a R-IOLts $I$ and an IOLts $S$, we say that $I\;\textbf{ioco}\;S$ iff

[TABLE]

In the vending machine example, both $I_{1}\;\textbf{ioco}\;S_{1}$ and $I_{2}\;\textbf{ioco}\;S_{2}$, where $S_{1}$ and $S_{2}$ are depicted in Fig. 2 (a) and (b), and $I_{1}$ and $I_{2}$ are depicted in Fig. 3 (a) and (b), respectively. We now recall the results from [3] which state that ioco is not preserved in general under parallel composition and hiding, but is preserved if all the specifications are receptive. Receptiveness of specifications can be achieved by demonic completion (see [3] for its formal definition).

Theorem 1** ([3])**

Given two composable R-IOLts $I_{1}$ and $I_{2}$, two composable IOLts $S_{1}$ and $S_{2}$ and two composable R-IOLts $S^{*}_{1}$ and $S^{*}_{2}$, we have

[TABLE]

Theorem 2** ([3])**

Given a R-IOLts $I$, an IOLts $S$ and a R-IOLts $S^{*}$, defined over the alphabet $L$, and a subset $\Sigma\subseteq L^{O}$, we have

[TABLE]

Consider the vending machine example, in which $I_{1}\;\textbf{ioco}\;S_{1}$ and $I_{2}\;\textbf{ioco}\;S_{2}$, the sequence $\sigma=\emph{coin}\cdot\emph{utee}$ and the compositions of specifications and implementations before and after hiding (see Fig. 4 and 5). The available output after executing $\sigma$ on $I_{1}\parallel I_{2}$ is mcoffee, while the composed specification $S_{1}\parallel S_{2}$ allows only $\delta$ after executing the same sequence, hence $I_{1}\parallel I_{2}$ does not ioco-conform to $S_{1}\parallel S_{2}$. After hiding the actions $\Sigma=\{\emph{mtee},\emph{mcoffee},\emph{mcoffeemilk},\emph{done}\}$ in the composition, we obtain additional traces which are not ioco-conformant. For instance, after executing the sequence $\emph{coin}\cdot\emph{ucoffee}\cdot\emph{umilk}$ in $h_{\Sigma}(I_{1}\parallel I_{2})$, the possible outputs are coffee and coffeemilk, while the specification $h_{\Sigma}(S_{1}\parallel S_{2})$ allows only the action coffeemilk after executing the same sequence.

We note that demonic completion introduces new “chaotic” states to the original specification, from which all behaviors are allowed. Exploring chaotic states in test case generation is not useful. In order to avoid their exploration [3] defines the set of Utraces. Intuitively, Utraces restricts Straces by eliminating underspecified traces. We obtain the uioco conformance relation by replacing Straces with Utraces in the definition of ioco. However, it turns out that uioco does not preserve compositional properties (see [6] for details).

IV Optimistic Approach to Composition and Hiding

In this section, we formalize the friendly composition and hiding operations, presented informally in Section II.

IV-A Friendly Environments

We have seen in Section III that parallel composition and hiding can introduce ambiguous states, and that ioco is not preserved under these two operations. An ambiguous state results from the parallel composition of two IOLts in which one emits an action that the other one is not ready to accept.

Definition 4** (Ambiguous state)**

Given two composable IOLts $A$ and $B$, a pair $(q_{A},q_{B})\in Q_{A}\times Q_{B}$ is an ambiguous state if there exists a shared action $\alpha\in L_{A}\cap L_{B}$ such that either: (1) $\alpha\in L^{O}_{A}$, $q_{A}\xrightarrow{\alpha}{}$ and $q_{B}\not\xrightarrow{\alpha}{}$; or (2) $\alpha\in L^{O}_{B}$, $q_{B}\xrightarrow{\alpha}{}$ and $q_{A}\not\xrightarrow{\alpha}{}$.

In the parallel composition $S_{1}\parallel S_{2}$ of the vending machine example, depicted in Fig. 4 (a), the state $3A$ is ambiguous because $S_{1}$ emits the output action mtee!, while $S_{2}$ does not accept it.

Inspired by contract-based design and interface theories, we propose an optimistic approach to composition and hiding. In this optimistic setting, we look for a friendly environment which steers the specification away from ambiguous states. A friendly environment is helpful towards the systems, by always accepting the system’s outputs and never providing actions that the system cannot accept as inputs.

Definition 5** (Friendly environment)**

*Given an IOLts $A=(Q,L^{I},L^{O},T,\hat{q})$, a friendly environment for $A$ is a strongly-convergent IOLts $E=(Q_{E},L^{O},L^{I},T_{E},\hat{q}_{E})$ such that $A\parallel E$ does not have ambiguous states. *

A composition-friendly environment does not allow a composed system to reach an ambiguous state in the composition.

Definition 6** (Composition-friendly environment)**

Given a composed IOLts $A\parallel B$, a composition-friendly environment for $A\parallel B$ is its friendly environment such that for all ambiguous states $(q_{A},q_{B})\in Q_{A\parallel B}$, for all $q_{E}\in E$, $((q_{A},q_{B}),q_{E})$ is not reachable in $(A\parallel B)\parallel E$.

A friendly environment is maximal if it admits more behaviors than any other friendly environment. The maximal friendly environment is used to compute the largest portion of the specification that is guaranteed to preserve conformance under composition and hiding. The resulting specification characterizes all sequences for which integration testing is not necessary.

Definition 7** (Maximal friendly environment)**

A friendly environment $E$ for an IOLts $A$ is said to be maximal if for all friendly environments $E^{\prime}$ for $A$ it holds $\textbf{Traces}(E^{\prime})\subseteq\textbf{Traces}(E)$.

The IOLts fragment that interacts correctly with its friendly environment $E$ is called its $E$-reachable fragment. It is obtained by composing the IOLts with $E$, while keeping the original meaning of inputs and outputs.

Definition 8** (Environment reachable fragment)**

Let $A$ be an IOLts and $E$ be its friendly environment. The $E$-reachable fragment of $A$ is an IOLts $(Q,L^{I},L^{O},T,\hat{q})$, where $Q=Q_{A\parallel E}$, $\hat{q}=\hat{q}_{A\parallel E}$, $L^{I}=L^{I}_{A}$, $L^{O}=L^{O}_{A}$, and $T=T_{A\parallel E}$.

IV-B Friendly Composition, Friendly Hiding and ioco

We are now ready to formally define friendly composition and hiding, and show that ioco is a pre-congruence for these two operations. We use the maximal friendly environment to restrict the classical parallel composition and hiding operations to a fragment that guarantees avoiding ambiguous states.

Definition 9** (Friendly composition)**

Given two composable IOLts $A$ and $B$, we say that they are compatible if there exists a composition-friendly environment $E$ for $A\parallel B$. Given two compatible IOLts $A$ and $B$, their friendly composition, denoted by ${A}\otimes{B}$, is an $E$-reachable fragment of $A\parallel B$, where $E$ is the maximal composition-friendly environment for $A\parallel B$.

Lemma 1

For any two compatible IOLts $A$ and $B$, there exists a maximal composition-friendly environment for $A\parallel B$.

Definition 10** (Friendly hiding)**

Given an IOLts $A$ and $\Sigma\subseteq L^{O}$, the friendly $\Sigma$-hiding of $A$, denoted by $\hat{h}_{\Sigma}(A)$, is an $E$-reachable fragment of $h_{\Sigma}(A)$, where $E$ is the maximal friendly environment for $h_{\Sigma}(A)$.

The specifications $S_{1}\otimes S_{2}$ and $\hat{h}_{\Sigma}(S_{1}\otimes S_{2})$ depicted in Fig. 7 (a) and (b) represent friendly composition of $S_{1}$ and $S_{2}$, followed by the friendly hiding of the synchronization actions $\Sigma=\{\emph{mtee},\emph{mcoffee},\emph{mcoffeemilk},\emph{done}\}$.

We note that for receptive models, the friendly composition and friendly hiding coincide with the parallel composition and hiding. We state the main technical contributions of the paper — that ioco relation is preserved under friendly composition and friendly hiding.

Theorem 3

Given two compatible R-IOLts $I_{1}$ and $I_{2}$ and two compatible IOLts $S_{1}$ and $S_{2}$, we have

[TABLE]

Theorem 4

Given a R-IOLts $I$ and an IOLts $S$ defined over the set $L^{O}$ of output labels and $\Sigma\subseteq L^{O}$, we have

[TABLE]

Corollary 1

Given two compatible R-IOLts $I_{1}$ and $I_{2}$, two compatible IOLts $S_{1}$ and $S_{2}$, and $\Sigma\subseteq L^{O}_{1\parallel 2}$, we have

[TABLE]

IV-C Computing Friendly Composition and Hiding

In this section, we present the algorithms for effectively computing the friendly composition and hiding. We first create the deterministic maximal friendly environment $E$ for an IOLts $A$. It is constructed by swapping input and output labels of $A$ and applying a variant of the subset construction that determinizes the IOLts afterwards.

Our variant of the subset construction works as follows. Consider an IOLts $A$, the standard subset construction $C$ of $A$, and a state $S$ of $C$. When $C$ is in $S$, the maximal environment must accept all output transitions from $S$. In contrast, the environment provides an input to $C$ only if all states in $S$ can accept it. As we can see, $E$ quantifies existentially over outputs in $A$ and universally over inputs in $A$.

Definition 11** (Maximal deterministic friendly environment)**

The maximal deterministic friendly environment of an IOLts $A=(Q,L^{I},L^{O},T,\hat{q})$ is an IOLts $E_{\textrm{max}}(A)=(2^{Q},L^{O},L^{I},T_{E},\hat{Q})$, where $\hat{Q}=\hat{q}\;\textbf{after}\;\epsilon$, and $(S,\alpha,S^{\prime})\in T_{E}$ if: 1) $S^{\prime}=S\;\textbf{after}\;\alpha$; 2) $\alpha\in L^{I}$ implies that $q\xrightarrow{\alpha}$ for all $q\in S$; and 3) $\alpha\in L^{O}$ implies that there exists $q\in S$ such that $q\xrightarrow{\alpha}$.

Algorithm 1 constructs the friendly composition for IOLts $A_{1}$ and $A_{2}$ or returns the information that they are not compatible. First, it constructs the maximal deterministic friendly environment $E_{\textrm{max}}(A_{1}\parallel A_{2})$. The algorithm then computes the set Amb of states in $E_{\textrm{max}}(A_{1}\parallel A_{2})$ that contain an ambiguous state from $A_{1}\parallel A_{2}$ and prunes away all states in $E_{\textrm{max}}(A_{1}\parallel A_{2})$ that reach Amb by a trace of output labels in $A_{1}\parallel A_{2}$. If the initial state is removed in the process, then no friendly environment for $A_{1}\parallel A_{2}$ exists. Otherwise, $E$ is the resulting maximal composition-friendly environment for $A_{1}\parallel A_{2}$ and the $E$-reachable fragment of $A_{1}\parallel A_{2}$ is their friendly composition. The friendly composition ${A_{1}}\otimes{A_{2}}$ constructed by the algorithm is of size at most $|A_{1}|\cdot|A_{2}|\cdot 2^{|A_{1}|\cdot|A_{2}|}$ and if $A_{1}$ and $A_{2}$ are both deterministic, then ${A_{1}}\otimes{A_{2}}$ is of size $|A_{1}|\cdot|A_{2}|.$

Algorithm 2 computes the friendly $\Sigma$-hiding of an IOLts $A$, where $\Sigma\subseteq L^{O}_{A}$. To obtain the maximal deterministic friendly environment, we simply hide actions in $A$, determinize it and then construct its maximal friendly environment $E$. The friendly hiding $\hat{h}_{\Sigma}(A)$ computed by the algorithm is of size $2^{|A|}$ and if $A$ is deterministic, then $\hat{h}_{\Sigma}(A)$ is of size $|A|$. We note that there always exists a friendly environment $E$ for arbitrary $A$. It suffices that $E$ accepts all outputs from $A$ and does not provide any inputs.

V Evaluation

To evaluate our approach to compositional testing in the ioco-theory, we implemented a proof-of-concept tool for computing friendly composition and hiding. We applied the tool to the alternating bit protocol taken from the CADP examples repository [8]. We were interested in the quality of the component specifications with respect to compositional testing. We also compared the size of the friendly composition of the component specifications to the size of the specification obtained by the demonic completion approach.

The alternating bit protocol is a data transfer protocol supporting re-transmission of lost or corrupted messages. For the sake of simplicity, we assume a perfect link (no corruption of messages). The protocol consists of a sender $A$ and a receiver $B$. Initially, the sender $A$ waits for data to be transmitted (Put?). Upon receiving the data, it sends it to $B$ together with a sequence bit (Data0!) and waits for an acknowledgment (Ack0?). If the acknowledgment does not arrive before a time-out, $A$ re-transmits the data. This behavior is modeled by a $\tau$-transition, which abstracts away the actual time-out value. Once $A$ receives the acknowledgment, it flips the sequence bit and repeats the procedure (Data1! and Ack1?).

Receiver $B$ behaves in a similar way. It first waits for data marked with the sequence bit (Data0?) and possibly takes a time-out transition. Upon receiving the data, it sends it to the external environment (Put!) and, in a next step, sends an acknowledgment marked with the same sequence bit to the sender (Data0!). The receiver then repeats the procedure with the flipped sequence bit.

Sender $A$ and receiver $B$ (cf. Fig. 8) are not compatible, i.e. no friendly environment guarantees the correctness of the protocol. There is a number of composition-ambiguous states in the parallel composition of $A$ and $B$, mainly due to the time-out ($\tau$) transitions. For instance, $A$ can be either in state $1$ or $2$ after reading the trace $\emph{Put}\cdot\emph{Data0}$. In state $2$, $A$ expects the input Ack0? which is not the case in state $1$, where $A$ is ready to re-transmit Data0! and is brought to after a time-out. Similar problems occur with the receiver $B$ due to its own time-out transitions.

It follows that the specifications for $A$ and $B$ are too weak for compositional testing. In order to strengthen the specification of $A$, we need to improve the handling of the race between re-transmitting data to $B$ and receiving the acknowledgment from $B$. We tackle the problem by making the assumptions about the handling of an acknowledgment more explicit and introduce additional states in the specification. The similar time-out problem of receiver $B$ is handled in a slightly different way: time-out is no longer modeled as a $\tau$-transition but as a self-loop that allows $B$ continuous re-transmission of acknowledgments to $A$, while waiting for new data. The strengthened specifications $A^{\prime}$ and $B^{\prime}$ of the sender and receiver are depicted in Fig. 9 (a) and (b). Their friendly composition (Fig. 9 (c)) contains no composition-ambiguous state.

Hiding all synchronization actions (Data and Ack) in $A^{\prime}\otimes B^{\prime}$ introduces new ambiguous states. A friendly environment cannot observe the internal state of $A^{\prime}\otimes B^{\prime}$ and decide when the protocol is ready to receive new data items (Put? action). The easy way to overcome this problem is to add constraints to the original specification of the sender that say how to handle the input Put? when the sender is in a non-observable state. The solution we use in this example, however, is to strengthen the sender specification by adding an output action Ready! which tells the external environment that it is ready to accept new data. The resulting specification $A^{\prime\prime}$ is depicted in Fig. 10 (a). The new specification requires a hand-shake between the protocol and the environment and results in the friendly composition $\hat{h}_{\Sigma}(A^{\prime\prime}\otimes B^{\prime})$ followed by the friendly hiding of $\Sigma=\{\emph{Ack0},\emph{Ack1},\emph{Data0},\emph{Data1}\}$. The composite specification $\hat{h}_{\Sigma}(A^{\prime\prime}\otimes B^{\prime})$ does not encounter any ambiguous states. It follows that any implementation of sender $A^{\prime\prime}$ and receiver $B^{\prime}$ can be tested individually and that their composition is correct-by-construction, without need for additional integration tests.

We finally compare the size of $\hat{h}_{\Sigma}(A^{\prime\prime}\otimes B^{\prime})$ to the one of $h_{\Sigma}(d(A)\parallel d(B))$, where $d(A)$ and $d(B)$ denote the demonically completed variants of $A$ and $B$. The results are shown in Table I. We first observe that by applying our approach we obtain specifications of smaller size than by demonically completing the component specifications and then applying parallel composition and hiding. This is in particular visible when comparing the size of $h_{\Sigma}(d(A)\parallel d(B))$ ($76$ transitions and $34$ states), to the one of $\hat{h}_{\Sigma}(A^{\prime\prime}\otimes B^{\prime})$ ($24$ transitions and $12$ states). We note that in our approach, only foreseen interactions between components are taken into account, which is not the case with the demonic completion approach. While our framework may require manual improvement of the component specifications, we argue that this is the right procedure to arrive at specifications of good quality for compositional testing. Although more automated, the demonic completion approach to compositional testing admits many useless implementations.

To summarize, the case study shows that the alternating bit protocol specification was not modeled with compositional testing in mind. Parts of the sender and receiver specifications are not sufficiently specified for cooperative interactions and do not admit compositional testing with ioco. We improved the specifications by strengthening the assumptions where needed. We note that despite the strengthening, the improved specifications are not input-enabled.

We finally remark that although the individual component specifications are strongly convergent, their composition with hiding is not. This may be a problem for testing with quiescence in general (see [2]) but does not affect our work as presented here: we only require friendly environments to be strongly-convergent.

VI Related Work

This paper is inspired by [3] and extends it by defining new composition and hiding operations adapted for under-specified models and preserving compositional properties of ioco. Compositional properties of the real-time conformance relation tioco were studied in [9]. In order to preserve compositional testing with tioco, specifications are required to be receptive. Compositional properties of the cspio conformance relation for model-based testing with CSP specifications were studied in [10]. CSP operations are shown to be monotonic with respect to cspio when the specifications are input-enabled, or the implementations are not receptive, and after each trace, the input actions accepted by the implementation are a subset of those offered by the specification. The compositional testing problem for systems modeled as networks of abstract components, based on coalgebraic definitions, was considered in [11]. Once again, specifications must be receptive to preserve compositional properties in testing. Assume-guarantee reasoning is combined with ioco in [12] in order to allow compositional testing. This work is complementary to ours, as it starts from a global specification of the complete system, and uses assumptions about components to divide and conquer the testing process. A methodology to reduce the efforts of integration testing is presented in [13]. It combines model-based integration with model-based testing, but does not provide formal arguments that support the proposed approach.

This paper is also inspired by the interface theories [4, 5]. In contrast to interface automata, used in the context of contract-based design, this work focuses on compositional properties in testing. Instead of iterative design through stepwise refinement, the ioco-theory assumes the existence of an implementation. We consider ioco with its explicit treatment of quiescence as the refinement relation, rather than alternation simulation used in interface automata. The integration of specifications in the ioco-theory separates parallel composition from hiding, thus allowing for multicast and broadcast communication. In interface automata, parallel composition and hiding are combined into a single operation, thus allowing point-to-point communication only. We also mention similar frameworks in contract-based design: synchronous interfaces with and without shared variables [14], synchronous relational interfaces [15], and real-time interfaces [16, 17].

VII Conclusion and Future Perspectives

We proposed a novel approach to compositional testing for ioco based on friendly composition and hiding. Our framework characterizes foreseen interactions between components and minimizes the effort needed for integration testing. In addition to the technical results, this paper gives new insights to compositional testing in general and the associated difficulties. In particular, we use our approach to provide guidelines for identifying weaknesses in component specifications and improving them with compositional testing in mind. Since high-level specifications are typically much smaller than the actual implementations, we argue that this additional effort in model analysis is rewarded with a reduction of effort in expensive integration testing.

In our framework, we assume that the composition of component specifications is the specification of the integrated system. In the future, we will study how to exploit our results when the overall system is specified with a separate model. In particular, we will investigate whether our results can be combined with [12]. In addition, we will study whether we can weaken the notion of the ambiguous states, while preserving compositional properties of ioco. Although we considered asynchronous models and ioco-theory, we are confident that our results can be adapted to different modeling frameworks and conformance relations. In fact, many issues related to compositional testing come from the power of the IOLts model, where components compete in executing the actions without much restrictions. We will adapt our work to the synchronous data-flow systems, which we believe have more robust properties with respect to composition and hiding.

Acknowledgments

This research was funded in part by the European Research Council (ERC) under grant agreement 267989 (QUAREM), by the ARTEMIS JU under grant agreement numbers 269335 (MBAT) and 295373 (nSafeCer), and by the Austrian Science Fund (FWF) project S11402-N23 (RiSE).