Model-Based Testing - Testing Experience

functionality. The Login_SM_oracle_state is the oracle method
generated from Login_SM through the SM2Oracle transformation.
Figure 3 shows the JUnit code automatically generated through
the Test2Code transformation. It includes two methods: Login_
testDP (to get the test data) and Login_test (the test case). This
method uses the oracle method to obtain the expected result.
MATE framework
The only requirement to apply the MATE methodology is the
availability of tools that allow model edition, transformation and
visualization. Several commercial and free UML modeling tools
have improved editors to generate all the required models. The
selected modeling tool must allow describing UML models and
applying UML profiles, as well as to export and import XMI files
following the UML meta-model, from which these models are
built. Examples in this article are depicted using IBM Rational
Software Architect.
Furthermore, core of the MATE methodology is model transformation,
which MATE supports by means of the framework described
in Figure 4. Transformations are implemented at these levels:
▪ Scenario to test scenario: The input for this model-to-model
transformation is a scenario described with UML sequence
diagrams. It produces a test model composed of a class diagram
representing the test architecture (UTP test architecture)
and a sequence diagram representing the test behavior
(U2TP test behavior). The involved objects correspond to instances
of the class diagram. This transformation is implemented
using a QVT transformation and is represented as
Scenario2Test in Figure 4. The test model obtained conforms
to the UML Testing Profile. More information about this
transformation can be found in [9].
▪ Test scenario to test code: This model-to-text transformation
takes the test scenario as input and produces as output some
Figure 4
www.testingexperience.com
JUnit executable test code to test the system. This transformation
is implemented using a MOF2text transformation
and is represented as Test2Code in Figure 4. More information
about this transformation can be found in [10].
▪ State machine to oracle method: UML state machines are
used to describe the test oracle; first, the state machine is
augmented with specific information for testing using the
Oracle Test Profile. Then, the model-to-text transformation
translates the UML state machine (with the profile applied)
into a method in the same language in which the application
is developed; finally this method calculates the expected
result. This transformation is implemented using MOF2text
transformation and is represented as SM2Oracle in Figure 4.
Conclusions
MATE helps the tester in test case automation by using UML models
that describe the system under test. The test model and its
corresponding test code are derived following a model-driven
approach. The result is a complete suite of executable test cases
with the following information:
▪ Parameterized input test data: The tester stores the input
test data in the dataPool, and the test case automatically retrieves
it. The operation in the dataPool returns all the input
data for that test case, and the test case is executed for each
set of inputs.
▪ Automated calculus of the expected result: Two methods are
obtained from an UML state machine: one to calculate the
expected result, and another to get the expected result.
▪ Test case procedure: The test case procedure is automatically
generated from the sequence diagram representing
the functionality under test, and it uses the information
about the test input and the expected result. The test case
procedure focuses on functional testing. Then, the interaction
between the system and the actors is tested. As a result,
the JUnit generated method recovers the test input from the
dataPool; this method calls the operations to test in the SUT
with the test input, uses the oracle methods
to calculate the expected result, and finally
validates the presence or absence of errors
by means of one or more assert XUnit statements.
References
1. Dalal, S.R., et al. Model-based testing in
practice. in International Conference on
Software Engineering. 1999: IEEE.
2. Dias Neto, A.C., et al. A survey on modelbased
testing approaches: a systematic
review. in Workshop on Empirical Assessment
of Software Engineering Languages
and Technologies. 2007: ACM.
3. Prasanna, M., et al., A survey on automatic
test case generation. Academic
Open Internet Journal, 2005. 15: p. 1-5.
The Magazine for Professional Testers
31