Introducing Model-Driven Testing in Scrum Process ...

International Review on Computers and Software (I.RE.CO.S.), Vol. 12, N. 1 ISSN 1828-6003 January 2017

Introducing Model-Driven Testing in Scrum Process Using U2TP and AndroMDA Meryem Elallaoui1, Khalid Nafil2, Raja Touahni3 Abstract – In Scrum agile software development, the increasing complexity of the system and the short sprint cycle of a product makes it difficult to thoroughly test products and ensuring software quality. Furthermore, manual testing is time consuming and requires expertise. As a result, automated testing has emerged as a solution to face this challenge. In this paper, we present an approach to generate test cases from UML sequence diagrams integrated with the Scrum agile process. Previously, the authors presented a new technique for automatic generation of UML 2 sequence diagrams from a set of user stories. In this paper, we propose two new cartridges for AndroMDA Framework. The first cartridge for M2M transformation takes UML 2 sequence diagrams as input and produces U2TP sequence diagrams; and the second cartridge for M2T transformation takes U2TP sequence diagrams as input and generates test cases. Copyright © 2017 Praise Worthy Prize S.r.l. - All rights reserved.

Keywords: MDA (Model Driven Architecture), Scrum, U2TP (UML 2.0 Testing Profile), UML (Unified Modeling Language)

I.

U2TP consists in applying UML to create a system and specifying tests [9]. Model Driven Engineering (MDE) [10] is a development approach which conceives the whole software development cycle as a production process of iterative refinement and model integration. These models are placed at the core of the development process, so the different stages of development result in a succession of model transformations. Furthermore, Model-Based Testing (MBT) [11] represents a test automation technique that aims at improving the test quality and efficiency, therefore reducing its costs. A new technique for generating UML 2 sequence diagrams from a set of user stories has been presented in a previous work [12]. In this paper, the authors proposed an MDA approach for model transformation within scrum process, by implementing two new cartridges for AndroMDA [13] framework; a cartridge for model-tomodel (M2M) transformation and a cartridge for modelto-text (M2T) transformation. The first transformation takes as input the design model represented by UML 2 sequence diagrams and generates U2TP sequence diagrams, which correspond to our test model. The second transformation takes as input the test model generated and produces TestNG [14] test cases. This paper is organized as follows: after a short introduction, section 2 summarizes the related works. In section 3 the proposed methodology for test case generation is discussed. Section 4 describes the predictions resulting from the proposed approach and a discussion is given. Section 5 draws some conclusion and presents future work perspectives.

Introduction

Nowadays, many software development companies have been moving towards an agile methodology to overcome various problems encountered during the development [1]. The Scrum agile methodology is one of the most used methods. The main advantage of this method is that each sprint is integrated and tested. Test is not limited to running software only to identify errors. Testing allows to validate an application module throughout the life cycle of a product. Furthermore, manual testing is considered as time consuming [2], error prone and cost intensive. Automated testing techniques are more and more considered in recent years to face these challenges. To achieve this automation, several main development techniques must be applied. The agile methodology [3] is a project management methodology, based on iterative and incremental practices of software development, conducted collaboratively by qualified teams. Recently, it has found its place amongst the leading companies, and essentially among start-ups [4]. The agile philosophy is a mechanism based on a set of individual elements called practices [5]. The application of Model Driven Architecture (MDA) [6] is growing in the software industry. The Unified Modeling Language (UML) [7] has appeared as a standard for the creation of software systems, its version 2.0 can also be applied in designing test cases. But UML itself is not able to describe a test model thus it is necessary to apply an UML test profile called UML2.0 Testing Profile (U2TP) to do that [8].

Copyright © 2017 Praise Worthy Prize S.r.l. - All rights reserved

https://doi.org/10.15866/irecos.v12i1.11334

30

Meryem Elallaoui, K. Nafil, R. Touahni

II.

The main objective of this work is to check out the possible errors encountered when manual test cases generation from state machines or UML activity diagrams is performed. The study is validated by a controlled experiment with 84 student participants. [25] introduced a framework for generating test cases from UML class and sequence diagrams. They created class diagrams and sequence diagrams first, then these diagrams are exported into XML format. Required tags are identified and extracted from XML file and stored in a Data Table. Test cases are extracted from Data Table by using C# code. Rhmann and al. [26] proposed a method for generating test cases from sequence diagrams by the transformation of these diagrams into the sequence flow graph. The Flow Graph and Object Constraint Language (OCL) are used for generating test scenarios. The outputs of test case are specified by the final message obtained in the test scenario. They also calculate the cyclomatic complexity to validate the test cases generated. Seo and al. [27] suggested a technique for generating UTP test cases from sequence diagrams based on M2M transformation. They used activity diagrams to express sequence diagrams scenarios. Then they fragmented the activity diagram to produce a unit activity as test scenario. [28] Proposed a method that consisted in generating test cases from UML use cases, sequence diagrams and automata. The extraction of test scenarios and test cases is performed from the basic paths. The main objective of this method consisted in improving the accuracy and enhancing the efficiency of the test cases generation. [29] Proposed a technique for generating test cases based on Interaction Overview Diagram (IOD) and sequence diagram (SD). The combination of generated Message Sequence Dependency Graph (MSDG) from (SD) and Interaction Graph (IG) generated from (IOD) results in generating Sequence Interaction Graph (SIG), that describes an intermediate graph. They generated scenarios by the combination of (IG) and (MSDG). They used dominance concept for the test cases generation from scenarios. These are a few proposals about the combination of model based testing in agile development, but none of them uses U2TP. Katara and Kervinen [30] defined a technique to adapt the model based testing practices within software development companies based on an agile process. The methodology is constructed around a domain specific modeling language. The labelled transition systems (LTS) is used for behavioral modeling, allowing a complete functional specification. They also defined a test covering language. Rumpe [31] suggested to use UML models as a primary artifact for documenting design and identifying customer’s needs. Also the development of test cases, code generation and model transformation that represent centered concepts for agile process, and particularly for testing activities. Entin [32] suggested challenges related to the use of approaches for risk-based test case generation in an industrial Scrum project.

Related Work

Both model based testing and U2TP for test modeling can be applied to multiple domains. In this section, related research on model based testing in agile development and automatic test case generation from UML sequence diagrams is discussed. Several proposals for test case generation use UML sequence diagrams and model transformation as a basis. These transformations are performed using several tools. However, none of them uses only one tool for model-tomodel (M2M) and model-to-text (M2T) transformation. Javed [15] introduced a technique based on an MDA tool for the generation of unit test cases from the PlatformIndependent Model (PIM) [6]. Two transformations are achieved, a horizontal transformation using Tefkat [16] and a vertical transformation using MOFScript [17]. For generating a test cases from method call sequences, a prototype tool has been implemented. Baker and al. [18] proposed a method based on the UTP profile for modeling tests, and the transformation is manually performed. Dai [9] defined a series of concepts for UTP models from UML models. The test models can be transformed to Platform-Specific Test (PST) or to the test code. But there is no practical implementation for any tool as far as we know for this interesting proposal. Shanthi and al. [19] described an approach to generate test cases from UML sequence diagrams using Rational Rose and a genetic algorithm. The optimization is performed on the best test cases and their validation is achieved by priority. However, no tool has been developed for this purpose, which can be a good way to reduce software development costs. Panthi [20] proposes a technique for generating test cases from UML sequence diagrams. This technique consists in extracting the main features from sequence diagrams and writing java source codes for this feature. The extended finite state machine (EFSM) is built from this code. Test cases are generated using this source code, and different coverage criteria are derived for the generated test cases. Sumalatha [21] proposed a method to generate test cases automatically from sequence and activity diagrams. Sequence diagrams and activity diagrams are constructed using the rational Rose software. Others [22] proposed a literature review based on MBT with UML state chart diagram. They have presented a survey table which contains all the details, including the input of the model, the methodology used and the coverage criteria of each work. The authors used this technique in order to check the relation between state, event, action and behavior. [23] introduced a technique for the creation of test cases from UML sequence diagrams. They generated a sequence flow chart (SFC) from sequence diagrams. These (SFC) is converted to a message control flow graph (MCFG). The test paths are generated by traversing the MCFG, then the creation of test cases are made from these paths. The generation and optimization of test cases are performed by applying a genetic algorithm. [24] Introduced a manual test case derivation from UML state machines and activity diagrams. Copyright © 2017 Praise Worthy Prize S.r.l. - All rights reserved

International Review on Computers and Software, Vol. 12, N. 1

31

Meryem Elallaoui, K. Nafil, R. Touahni

The approach proposed a process of model definition through the entire life cycle of a multi-scrum project. However, this challenges offer only a manual possibility of assigning requirements to model elements. Renate Löffler and al. [33] defined a method based on UML diagrams for enhancing the documentation and identifying customer’s needs. For automated testing activities within scrum process, they generated test scripts from test models. Both sequence diagrams and interaction overview diagrams are used as a modeling notation and as test models for the generation of test scripts. This work is quite similar to the present one, but they do not use the U2TP. They generated acceptance testing using interaction overview diagrams and sequence diagrams, while we generated the TestNG test case from sequence diagrams in two steps. [12] In previous works the authors proposed an algorithm that takes as input a set of user stories stored in a text file, then analyzed the first line of the text file and searched the actor of the first user story to insert it in the XML file generated. In the same way action and benefit were searched. The XML file generated is transformed into a sequence diagram by using the UML 2 tool SDK plugin for Eclipse.

Fig. 1. Transformation process within Scrum sprint

III.1. UML 2.0 Testing Profile The meta-models used in our approach are: UML 2.0 and U2TP. The Unified Modelling Language (UML) diagram is a graphical representation, which focuses on a specific aspect of the model. UML diagrams have taken their place in the research world and can be applied for both system modelling and test cases designing. Figure 2 illustrates the set of PSM Meta-class implemented that represent U2TP stereotypes [8].

III. The Proposed Methodology A model driven testing approach within Scrum agile process to generate TestNG test cases is proposed, using sequence diagrams at two levels; the first is to generate a test model from a design model, and the second is to generate test cases codes from test models. To generate the test model, a user story was chosen from a list of requirements, then the PlatformIndependent Model (PIM) was generated. This design model (PIM) is transformed into a Platform-Independent Test (PIT) which represents our test model. This transformation is achieved by using a new cartridge for AndroMDA Framework that was implemented. An AndroMDA cartridge is a set of source code from template files and helper classes (named Metafaçades) packaged into the JAR file. The design model represents the input of the cartridge, which is described by sequence diagrams, and automatically generates U2TP test models. Finally, to generate TestNG test cases from PIT models, a second cartridge was used for the AndroMDA Framework that was implemented, which takes the test models U2TP as input and automatically generates test cases codes. TestNG is a java unit testing framework for a new generation. This framework introduces new functionalities that make it powerful, easier to implement and to integrate into the project. Various features offered by TestNG are powerful organization of tests, creating dependencies between tests, generalization of tests using factory, etc. Figure 1 illustrates the transformation process within sprint. The following subsections explain the transformations and the meta-models used for the two cartridges implementation.

Fig. 2. U2TP Meta class

The U2TP stereotypes implemented for the proposed cartridge are the following: SUT that was applied to the class attributes (TestContext) in order to form the system under test (SUT). The kinds of attributes to which the stereotype will be applied represent the characteristics of this system. Test components (TestComponent) are part of the test environment, and are applied to the class. Their role is to derive test cases by the stimulation of the system under test. TestContext consists in regrouping a set of test cases having the same context. It contains SUTs as attributes and the test cases as behaviours, especially interactions, and therefore sequence diagrams. TestContext can be applied to any classifier that can

Copyright © 2017 Praise Worthy Prize S.r.l. - All rights reserved

International Review on Computers and Software, Vol. 12, N. 1

32

Meryem Elallaoui, K. Nafil, R. Touahni

contain behaviours. DetermAlt refers to combined fragments where the operands are evaluated in the same order as they appear in the model. This stereotype is applied to the combined fragments. TestCase represents a behaviour and can be applied to the interactions. TestCase describes the interaction between testComponent and SUT in order to achieve the objectives of this test. Behaviours are contained in testContext and has access to all features of testContext. A test case returns a verdict. The verdict decides whether the test failed or not. It is usually made following a ValidationAction. The ValidationAction is applied to the CallOperationAction element of our model. This stereotype is dedicated to tests behaviour in order to fix verdicts. DataPool is used in the test cases, it represents a container for storing data. This stereotype is applied to a class and also to the properties or attributes. This will allow them to distinguish from other attributes, like

SUTs in testContext for example. DataSelector refers to operations, which enables selecting data from the DataPool. It is applied to the operations of the DataPool class. III.2. Model-to-Model transformation (M2M) For model-to-model transformation, the description of SUT is represented by scenarios, in the form of sequence diagrams. The transformation takes sequence diagrams as input and produces a test model. The generation of test model from AndroMDA transformation is composed of U2TP sequence diagrams, which represent the test behavior. For the implementation of the first cartridge (M2M), two metamodels are need: Metafaçades and PSMClass (Figure 3 and Figure 4).

Fig. 3. Meta-model representing the cartridge input

Fig. 4. Meta-model representing the cartridge output

Copyright © 2017 Praise Worthy Prize S.r.l. - All rights reserved

International Review on Computers and Software, Vol. 12, N. 1

33

Meryem Elallaoui, K. Nafil, R. Touahni

Every message has a StateInvariant. By using StateInvariant, different types of constraints can be specified, such as variables and values attributes. MessageOccurenceSpecification is responsible to send and receive signals of an event. It represents an occurrence. ExecutionOccurenceSpecification identifies the occurrence of sending and receiving signals, either operation calls. BehaviorExecutionSpecification allows the execution of a behavior. It is a type of execution specification which represents the activation period. These three occurrences represent fragments. The connection between messages and lifelines are performed through these fragments. A set of classes has been implemented in order to facilitate the generation process. The idea is to find all actors (TestComponent), and is done by extracting actors from a set of properties, and then creating lifelines. Lifelines communicate via messages, which are created using DataSelectorMessage method. Moreover, an ID was generated for each element. Listing 1 shows the steps followed for M2M transformation.

A message is specified by a type (synchronous, asynchronous or creation), and it can have several arguments (TArgumentFacade). The arguments are modeled by TArgumentFacade. Validating a test is expressed by TStateInvariantFacade by using the stereotype (ValidationAction). Combined fragments are represented by TCombinedFragmentFacade. A combined fragment is defined by TInteractionOperandFacade, which allows to determine the type of operators (Alt, Opt and Loop); and one or more operands which contain a set of events or other combined fragments. The condition for operand is described by guard TInteractionConstraintFacade type. The fragment in this case can be represented by TCombinedFragmentFacade, TStateInvariantFacade or TMessageEndFacade. The behavior of a UML sequence diagram is described by these fragments. AndroMDA uses Velocity as template generator. In the proposed approach, the templates needed to generate TestNG test cases are: - TestContext: allows the generation of classes for each model TestContext. - TestContextBase: is responsible for generating the base class, which allows others TestContext classes to inherit from this base class. - DataPool: generates interfaces of DataPool. - DataPoolImpl: enables the generation of the class that allows the implementation of the interface of DataPool. - TestNG: represents an XML file configuration for TestNG Framework, which consists in listing all TestContext implemented by the Framework. Listing 2 shows the pseudo code followed for the implementation of the second cartridge, which consists in transforming the test model in test cases code.

Listing 1. Pseudo-code for test model generation, taken from [34]

III.3. Model-to-Text transformation (M2T) This section will define the main elements for implementing the second cartridge (M2T). The needed Metafaçades to generate TestNG test cases from U2TP sequence diagrams are illustrated in Fig. 5. The UML class model is represented by the TClassFacade. The behavior of this class is modeled by TInteractionFacade. The basic elements in a sequence diagram are represented by TInteractionFragmentFacade, TMessageFacade and TLifeLineFacade. The communication between LifeLines is performed through messages. TMessageEventFacade represents events: receiveEvent and sendEvent, these two events are triggered by messages. Class attributes or properties of interaction correspond to each LifeLine.

Listing 2. Pseudo-code for generating the test cases code from the test model

Copyright © 2017 Praise Worthy Prize S.r.l. - All rights reserved

International Review on Computers and Software, Vol. 12, N. 1

34

Meryem Elallaoui, K. Nafil, R. Touahni

Fig. 5. Sequence diagram meta-model

IV.

the DataSelector operation. Figure 7 shows the U2TP test case generated for the ATM scenario. To obtain the test data for testing the messages insertCard (pass): result and withdrawCash (accountNumber, amount): result, the input data (pass, accountNumber and amount) and the expected result (expectedResult and expectedAmount) are needed, which are stored in the DataPool. For recovering data, the DataSelector operations (ds_insertCard (), dsr_ insertCard (), ds_withdrawCash (), ds1_withdrawCash (), and dsr_withdrawCash ()) are called. Finally, for checking the correct running of the system a ValidationAction was used.

Simulation Work and Discussion

IV.1. Testng Test Cases Code Generation To illustrate our method, an example of automated teller machine (ATM) was applied. Figure 6 shows the main scenario of the use case ATM system. The user is asked to enter his password, and the system verifies that the password entered is correct. If the password is correct, the user can withdraw money. By applying U2TP, actors are stereotyped with TestComponent and the system is stereotyped with SUT. The test data needed for the execution of test cases are stored in the DataPool. These data are retrieved by using

Fig. 6. UML sequence diagram for the use case ATM

Copyright © 2017 Praise Worthy Prize S.r.l. - All rights reserved

International Review on Computers and Software, Vol. 12, N. 1

35

Meryem Elallaoui, K. Nafil, R. Touahni

Fig. 7. Test case generated for ATM scenario

Figure 8 shows the TestNG test code generated for the ATM scenario. The transformation creates the header of the method (lines 1-18). The execution of the setUp method (line 18) is carried out first, and therefore this method is responsible for initializing all SUTs. For services, loading is done from context, otherwise instantiation will take place. TestContext (line 14) is the base class for all test context. TestNG automatically invoked all test cases, if this is services, they load them from Spring or EJB contexts. The expected result is stored in the dataPool. The values of pass, accountNumber and amount (lines 33, 38 and 39) are recovered from the DataPool via DataSelector " ds_insertCard (), ds_withdrawCash () and

ds1_withdrawCash ". The result returned by the SUT for the password (line 36) and the result obtained from the DataPool (line 35) are compared (line 37). The result returned by the SUT for withdrawCash (line 42) and the result obtained from the DataPool (line 41) are also compared (line 43). IV.2. Discussion The majority of research work in the literature focuses on applying the MDA approach to software development. However, the integration of the MDA approach in agile software development is few and far between.

Copyright © 2017 Praise Worthy Prize S.r.l. - All rights reserved

International Review on Computers and Software, Vol. 12, N. 1

36

Meryem Elallaoui, K. Nafil, R. Touahni

Fig. 8. TestNG automatically generated test code

In this work, the interest was to integrate the Model Driven Engineering (MDE) approach within the scrum agile process. The advantage of this technique lies in its ability to generate codes from UML diagrams. U2TP was chosen because it represents a good way to exchange and understand for developers and testers. The proposed approach is divided in two important stages, each stage is characterized by fast evolution and

interoperability. The first step is to generate a U2TP test model from a design model, these models are represented by UML sequence diagrams. The second step aims to generate TestNG test cases from the test model. For this two steps, two new cartridges for AndroMDA framework were implemented. MagicDraw [35] was used to produce a platform

Copyright © 2017 Praise Worthy Prize S.r.l. - All rights reserved

International Review on Computers and Software, Vol. 12, N. 1

37

Meryem Elallaoui, K. Nafil, R. Touahni

[4]

independent model (PIM) which represents the proposed UML design model. This design model is exported in UML format, then the first cartridge implemented reads a UML sequence diagram and generate platform independent test model (PIT), which represents our U2TP test model. The second cartridge that we have implemented reads a U2TP sequence diagram and generates a test case code. The benefit of integrating MDT lies in the capacity to link requirements and design, facilitating the generation of the results for developers in a common language, which combines the participants in the design process. This enables a coherent design communication and enriches the workflow. Furthermore, it allows to gain time because developers can perform tests in similar language to the one used to elaborate in UML. Using AndroMDA for both test code generation and model transformation represents the main advantage of our approach. AndroMDA consists in separating generated code and UML models from business logic in different directories. This enables to obtain both abstract modeling and code generation capability.

V.

[5]

[6] [7] [8] [9]

[10] [11]

[12]

[13] [14] [15]

Conclusion

In this work, a method for test automation into an agile process based on two transformations (M2M) and (M2T) was presented, and two meta-models U2TP (UML 2.0 Testing Profile) and UML 2 were used. The first transformation consists in generating U2TP test model from a design model, and the second transformation consists in generating TestNG test cases from the U2TP test model using the AndroMDA Framework. The authors believe that this method can facilitate the work of developers and testers, because the advantage of these two cartridges is that it allows to generate test codes, test models and also the system under test. There are some limitations of this approach: not all U2TP stereotypes were taken into account, such as verdict and arbiter, to decide if the test run was successful or not. In this paper, the first results were shown. The next step will be to apply the entire AndroMDA framework to an industrial project.

[16] [17] [18]

[19]

[20]

[21]

[22]

[23]

References [1]

[2]

[3]

T. J. Gandomani, H. Zulzalil, A. A. Abdul Ghani, A. B. M. Sultan, and K. Y. Sharif, How human aspects impress Agile software development transition and adoption, (2014) International Journal of Software Engineering and its Applications, vol. 8, pp. 129-148, http://dx.doi.org/10.14257/ijseia.2014.8.1.12 B. B. Agarwal, S. P. Taya, Software Project Management, Published by USP/Laxmi Publications (P) Ltd., New Delhi (2011) ISBN 10: 938085692X ISBN 13: 9789380856926 M. Lindvall, V. Basili, B. Boehm, P. Costa, K. Dangle, F. Shull, M. Zelkowitz, Empirical findings in agile methods. Extreme Programming and Agile Methods—XP/Agile Universe (2002), pp.81-92. ISBN: 3-540-44024-0.

[24]

[25]

Copyright © 2017 Praise Worthy Prize S.r.l. - All rights reserved

Agile in large enterprises. Available at: http://searchsoftwarequality.techtarget.com/feature/Implementing -Agile-in-very-large-enterprises J. Shore and S. Warden, the Art of Agile Development, Sebastopol, CA: O’Reilly, (2008). ISBN-10: 0-596-52767-5, ISBN-13:978-0-596-52767-9 OMG, Model Driven architecture, Available at: http://www.omg.org/mda/ OMG, Unified Modeling Language (UML), Available at: http://www.omg.org/spec/UML/2.5/PDF, (2015). OMG, UML Testing Profile (UTP), Available at: http://www.omg.org/spec/UTP /1.2/PDF, (2013). Dai, Z. R., Model-Driven Testing with UML 2.0, Proceedings of the Second European Workshop on Model Driven Architecture (MDA) with an Emphasis on Methodologies and Transformations (EWMDA-2), (Technical Report No. 17-04, 2004, Canterbury: Computing Laboratory, University of Kent) IEEE, IEEE Standard Glossary of Software Engineering Terminology, Tech. rep., IEEE, (1990). M. Utting and B. Legeard. Practical Model-Based Testing: A Tools Approach. Morgan Kaufmann, (2007). ISBN: 978-0-12372501-1. M. Elallaoui K. Nafil, R. Touahni, Automatic generation of UML sequence diagrams from user stories in Scrum process, in: 10th International Conference on Intelligent Systems: Theories and Applications, (2015). http://dx.doi.org/10.1109/SITA.2015.7358415 AndroMDA, Available at: http://www.andromda.org/ TestNG, Available at: http://testng.org/doc/index.html/ A. Z. Javed, P. A. Strooper, and G. N. Watson. Automated generation of test cases using model-driven architecture. In AST’07, page 3, Washington, DC, USA, (2007). IEEE Computer Society. http://dx.doi.org/10.1109/AST.2007.2 Tefkat, the EMF transformation engine, Available at: http://tefkat.sourceforge.net/ MOFScript, Available at: https://eclipse.org/gmt/mofscript/ P. Baker, Z. Dai, J. Grabowski, I. Schieferdecker, O. Haugen, C. Williams, Model-Driven Testing: Using the UML Testing Profile, Springer, (2007). http://dx.doi.org/10.1007/978-3-540-72563-3 Shanthi, A. V. K., MahanKumar, G., Automated Test Cases Generation from UML Sequence Diagram, International Conference on Software and Computer Applications (2012). Panthi, V., Automatic Test Case Generation using Sequence Diagram, (2012) International Journal of Applied Information Systems, 2(4), pp. 22–29. http://dx.doi.org/10.1007/978-81-322-0740-5_33 V.Mary Sumalatha, Dr G.S.V.P.Raju, UML based Automated Test Case Generation technique using Activity-Sequence diagram, The International Journal of Computer Science & Applications (TIJCSA), Volume 1, No. 9, November (2012), ISSN – 2278-1080 Y.D. Salman and N.L. Hashim, Automatic Test Case Generation from UML State Chart Diagram: A Survey, Advanced Computer and Communication Engineering Technology, Springer International Publishing, (2016), pp.123-134. http://dx.doi.org/10.1007/978-3-319-24584-3_12 A.K. Jena, S.K. Swain, D.P. Mohapatra, Test Case Creation from UML Sequence Diagram: A soft Computing Approach, Springer India, Intelligent Computing, Communication and Devices, Advances in Intelligent Systems and Computing 308, (2015). http://dx.doi.org/10.1007/978-81-322-2012-1_13 M. Felderer, A. Herrmann, Manual test case derivation from UML activity diagrams and state machines: A controlled experiment, Information and Software Technology, (2015), pp. 115. http://dx.doi.org/10.1016/j.infsof.2014.12.005 S.A.A. Shah, R.K. Shahzad, S.S.A. Bukhari, M. Humayun, Automated Test Case Generation Using UML Class & Sequence Diagram, British Journal of Applied Science & Technology, (2016), 15(3), pp.1-12. http://dx.doi.org/10.9734/BJAST/2016/24860

International Review on Computers and Software, Vol. 12, N. 1

38

Meryem Elallaoui, K. Nafil, R. Touahni

[26] W. Rhmann, V. Saxena, Test Case Generation from UML Sequence Diagram for Aadhaar Card Number based ATM System, International Journal of Applied Information Systems (IJAIS), (2016) , Vol. 11, No. 4. http://dx.doi.org/10.5120/ijais2016451599 [27] Seo, Y., Cheon, E.Y., Kim, J-A., Kim, H.S., Techniques to generate UTP-based Test Cases from Sequence Diagrams Using M2M (Model-to-Model) Transformation, Computer and Information Science (ICIS), IEEE/ACIS 15th international conference, (2016). http://dx.doi.org/10.1109/ICIS.2016.7550832 [28] C. Zhang, Z. Duan, B. Yu, C. Tian, M. Ding, A Test Case Generation Approach Based on Sequence Diagram and Automata Models, (2016) Chinese Journal of Electronics, Vol. 25, No. 2, pp. 234-240. http://dx.doi.org/10.1049/cje.2016.03.007 [29] A.K. Jena, S.K. Swain, D.P. Mohapatra, Model Based Test Case Generation from UML Sequence and Interaction Overview Diagrams, (2015) Springer India, Computational Intelligence in Data Mining, Vol. 2, pp. 247-257. http://dx.doi.org/10.1007/978-81-322-2208-8_23 [30] Mika K., Antti K., Making Model-Based Testing More Agile: A Use Case Driven Approach. In Haifa Verification Conference, pp. 219-234, (2006). http://dx.doi.org/10.1007/978-3-540-70889-6_17 [31] B. Rumpe, Agile test-based modeling. In Software Engineering Research and Practice, pp. 10-15, (2006). Available at: https://arxiv.org/ftp/arxiv/papers/1409/1409.6616.pdf [32] Entin, V., Winder, M., Bo Z., Christmann, S., Introducing modelbased testing in an industrial scrum project, 7th International Workshop on Automation of Software Test (AST), pp.43,49, 2-3 June (2012). http://dx.doi.org/10.1109/IWAST.2012.6228989 [33] Löffler, R., Güldali, B., Geisen, S.: Towards Model-based Acceptance Testing for Scrum. Software-technik-Trends, GI, (2010). Available at: http://pi.informatik.unisiegen.de/stt/30_3/01_Fachgruppenberichte/TAV/03_TAV30Papi erLoeffler.pdf [34] Lamancha, B. P., Mateo, P. R., de Guzman, I. R., Usaola, M. P., and Velthius, M. P., Automated model-based testing using the UML testing profile and QVT, in Proceedings of the 6th International Workshop on Model-Driven Engineering, Verification and Validation, ser. MoDeVVa ’09. New York, NY, USA: ACM, (2009), pp. 6:1–6:10 [35] Magicdraw, http://www.nomagic.com/products/magicdraw.html

Authors’ information 1

Ibn Tofail University- Faculty of Sciences, LSTED Laboratory Kenitra, Morocco. E-mail: [email protected] 2

ENSIAS, University Mohamed V in Rabat, Rabat, Morocco. E-mail: [email protected] 3

Ibn Tofail University- Faculty of Sciences, LSTED Laboratory Kenitra, Morocco. E-mail: [email protected] Meryem Elallaoui is currently a phD student at Systems of Telecommunication and Engineering Decision Laboratory (LSTED) at Ibn Tofail University, Kenitra-Morocco. Her main research fields are model-based testing and model driven engineering in the domain of agile software development. She has Master’s degree in Computer Science - Software Quality at Ibn Tofail University, Kenitra-Morocco. Khalid Nafil is a professor in the National Higher School of IT (ENSIAS). He has received his ph.D in Computer Science from Mohammed V University, Rabat-Morocco. Dr. Nafil's research focus is software engineering. He has investigated issues in software design, web engineering, cost estimation, serious games and software testing. Raja Touahni is a professor in faculty of sciences at Ibn Tofail University, KenitraMorocco. Dr. Touahni's research focus is Data processing. She has investigated issues in image data analysis, classification, data mining and segmentation;

Copyright © 2017 Praise Worthy Prize S.r.l. - All rights reserved

International Review on Computers and Software, Vol. 12, N. 1

39