activity, so, there is need of automatic test case generation strategy. In automatic test case generation, different UML diagrams are used by researcher for testing purpose. Design models in software testing are used to finds defects at early stage of the software development. Quality of generated test cases depends on which extent they cover the functionality of the system under test. UML is used to model the requirements of the system. UMLsequence diagrams are important for visualizing the dynamic aspects of the system. Sequencediagram represents the flow of control among objects during interaction between objects. Sequencediagram is an interaction diagram and can be viewed as a table in which objects are placed at X axis and messages are in increasing order of time at Y axis . Sequencediagram contains different flow of control elements like alt, par, loop, etc. Various researchers have proposed many test case generation techniques from different UML diagrams. Initially, OCL is an extension of UML and a formal language. OCL may now be used with OMG meta model including UML . OCL describes rule that are applied to UML. OCL is an extension to UML as a formal specification language. OCl is a précised text based language which provides constraint and object query expression for any UML models. OCL provides expressions without ambiguity which usually occurs in using natural language. Liet al.  presented a new approach of test case generation from UMLsequencediagram and OCL expression. Authors constructed a tree from the sequencediagram. Then they traversed the tree to find out conditional predicates. OCL is used to define the pre and post conditions. Function minimization techniques are applied to generate test data on conditional predicates
Abstract: Unified Modeling Language (UML) is a visual modeling language. It has now become the de-facto industry standard for object-oriented (OO) software development which consists of designing and coding of the software. It has gained popularity among software practitioners because of its benefits, such as, cost reduction and accuracy. So, automatic code generation from UML diagrams is more beneficial because it eliminates the chances of introduction of human errors in the translation process and also reduces the time required for coding. This paper proposes an approach to code generation from UML diagrams. It mainly focuses on the UMLsequencediagram as the model and the transformation of UMLdiagram to XMI is done with help of some pre-existing tool. The meta-elements are extracted from the XMI file with the help of the methods explained in the work. The output will be the java files having the consistent and redundancy free code equivalent to the given sequencediagram.
As the demand of the new software increase in the current field of software engineering, new technics and methods are needed for fulfilling the needs of the market. In order to make this possible in the case of design model, in which the models are converted to the corresponding code, the code generation approach is used. The work, deals with the generation of the code for the UMLsequencediagram, with the help of the XMI file of the corresponding sequencediagram using the BOUML tool. Simple sequence flow can be extracted from the XMI file efficiently, but the conditional and looping statements are avoided. But these statements can be included into the sequence by complex programing methods with the help of this XMI file generated .
through sender’s protocol stack. In the proto- col stack, it passes through a stack of protocol layers. Each layer formats or transforms in- formation using protocol rules. So the infor- mation could be sent through some medium or mediator. The recipient receives information and passes it through its protocol stack, but in reverse direction, so that the information can be transformed to its original state. Figure 13 shows the communicator protocol stack struc- ture in the GeneralProtocol Package, whereas Figure 14 shows an UMLsequencediagram depicting the protocol layer interactions while sending information from source to recipient.
The proposed idea will generate cases (test cases) from UMLsequencediagram in earlier phase i.e. in designing phase. In life cycle of software, firstly the design comes which further is converted into coding phase. If the test cases will be generated in designing phase and if any error is seen during the design of software, it can be corrected easily before coding, so error will be prevented to occur in next phase and will prevent it from increasing that will save our time and cost on fixing it. The most of emphasis should be put on prioritization part so as to make our software good and effective.
The survey of previous research on modeling methodology for business processes reveals that there is a need for more attention to the details of a process model. Appropriate tools, proper methodologies, and formal modeling languages are the basic requirements for handling the problems of process modeling in order to procure a comprehensive and transparent business process model. It must be reminded that no modeling construct can thoroughly cover different aspects of a process model. Hence, to represent a process model transparently and accurately necessitates the selection of a proper set of modeling languages. Furthermore, in business process architecture, ranging from the top level to the lowest level, the process model provides detailed information on the role of the participants, data input/output, and control/decision flow. Therefore, a proper modeling language should be selected to cover more details of the business process. The combination of IDEF0 and UML-Use Case diagram was applied for defining the upper level of process models. BPMN and UML-Sequencediagram were utilized for designing the detailed process model with regard to the two phases of the proposed methodology; it was found that the combination of these modeling languages could complete each other in modeling business process. Table 12 shows that how the above-mentioned modeling languages completed each other to cover full perspectives of the business process model. This combination of modeling languages, as well as worksheets, guaranteed the consistency and accuracy within modeling business process (Table 12).
path in Software under Test (SUT). Weights are assigned to edge of CFG by applying 80-20 rules. Xanthakis et al.  present genetic algorithm to generate the test data. Genetic algorithms are used for generation of test data for structure. A path is selected by the user and the relevant branches are executed from program. Fitness function is calculated by summation of branch predicated. V. Mary Sumalatha, G.S.V.P. Raju  presents the test case generation by means of UMLsequencediagram using genetic algorithm from which best test cases optimized. Genetic algorithm applied on sequence graph. All paths discover from source to destination with loops and calculate the fitness value. Sangeeta Sabherwal  proposed a technique for prioritization of test cases scenario derived from activity diagram and state chart diagram using genetic algorithm concepts, stack and information flow (IF) diagram. Stack based application is adopted for assigning the weight to each node of activity and state chart diagram. Bo Zhang and Chen Wang  use simulated annealing algorithm into genetic algorithm to generate the test data for path testing. A simulated annealing algorithm is inspired by the annealing of metals. In this method, solid is heated from high temperature and cooled down slowly to maintain thermodynamic equilibrium of system. The adaptive genetic simulated annealing algorithm is proposed by Zhang to automatically generate the test data. The steps if this algorithm is shown in his paper. The fitness value, crossover, mutation another modification are applied in genetic algorithm procedure. M. Harman  focused on automated test data generation using search based software engineering. Automated test data generation using genetic algorithm is based on search based software engineering. Sultan H. Aljahdali  presented the limitation of genetic algorithm in software testing. The majority of software test-data generation techniques are based on genetic algorithm. It attempts to compare and classify the combinatorial problems according to genetic algorithm feature and parameters.
can exhibit different responses depending on the concurrency conditions. Due to concurrency there may be test explosion. Synchronization and deadlock create problems when concurrently running objects want to interact with each other. The UMLSequenceDiagram, Activity Diagram and State Chart Diagram can be used for testing concurrency. However State Chart Diagram is useful for unit testing and results a large number of test cases, due to consideration of each and every state that an object undergoes during its operation, where as the SequenceDiagram can be useful for integration testing and results a less number of test cases. The SequenceDiagram is also useful in detecting scenario as well as interaction faults. The Activity Diagram is useful for representing complex sequence of parallel and conditional activities. The Activity Diagram is also useful in detecting faults in loop and synchronization faults present in concurrent systems, where the different concurrent processes need to be synchronized properly.
Unified Modeling Language (UML)  was originally designed to sketch the structure of object-oriented software systems. But UML is not precise enough for model execution. Executable UML  bridges the gap between the UML-based design models and the implementation. Executable UML allows user to precisely describe a software system. The executable models can be compiled or translated to a less abstract programming language, which can be deployed on various platforms for specific implementation. Executable UML also allow directly executing UML models. With executable UML, we can clearly grasp what the system is doing early, enable testing of the system as the system is built, and find the flaws in the design which can be immediately corrected, rather than later when it is too costly to correct them. OCL is a formal language used to describe expressions on UML models . It rises to meet part of the requirements for constraint, query and checking of UML models. However, OCL is still not sufficient for model execution, since it is designed to be a specification language and is side-effect free.
RDF (Resource Description Framework) and RDF Schema (collectively called RDF(S)) are the norma- tive language to describe the Web resource information. How to construct RDF(S) from the existing data sources is becoming an important research issue. In particular, UML (Unified Modeling Language) is being widely applied to data modeling in many application domains, and how to construct RDF(S) from the existing UML models becomes an important issue to be solved in the context of Semantic Web. By comparing and analyzing the characteristics of UML and RDF ( S ) , this paper pro- poses an approach for constructing RDF ( S ) from UML and implements a prototype construction tool. First, we give the formal definitions of UML and RDF ( S ) . After that, a construction approach from UML to RDF ( S ) is proposed, a construction example is provided, and the analyses and discussions about the approach are done. Further, based on the proposed approach, a prototype construction tool is implemented, and the experiment shows that the approach and the tool are feasible.
basis for the ADBdesign prototype  and its equivalent ATL-based implemen- tation . However, these attempts had flaws regarding the cardinality of the generated associations since all business objects were treated without mak- ing a distinction between existing and generated objects. Additionally, in these papers the semantic capacity of UML AD was not sufficiently identified to en- able definition of the transformation rules for automated generation of object- object associations. Recently, we have been considering the semantic capacity of object flows and actions for automated generation of associations and have performed an analysis related to: (i) the nature of action nodes based on the number of different types of input and output objects, and (ii) the weight of ob- ject flows. By introducing the classification of actions into SISO, MISO, SIMO and MIMO actions and making a distinction between existing and generated input objects, we have defined the formal rules for generation of object-object associations . However, in that paper we did not consider the activation of existing objects and the subsequent usage of activated existing objects.
For test case generation from use cases another approach is discussed here. The approach is based on the rule for test cases that each scenario or instance of a use case should correspond to a test case and this approach brings the advantage of preventing the consequences of incomplete, incorrect and missing test cases as other approaches also provide. The approach offers first building a system boundary diagram depicting the interfaces between the software being tested and the individuals, systems and other interfaces; secondly use cases are generated for all actors defined in system boundary diagram. At the end, test cases are generated in a way that there exist at least two test cases for one use case which are successful execution of test case and unsuccessful execution of test case. Clearly, much more test cases can be generated for a use case for exceptions and alternative courses .
the formula. That is, using the terminology we developed in Section 1.3, whether or not the structure is a logical model of the formula. The structure is typically a model (in the non-technical sense) of some system, and the formula states a property we would like the system to have. The structure is usually graph-like, with nodes representing system states and edges representing transitions. Modal and temporal logics are typically used to express the desired properties. It seems natural to verify UML models by deriving a structure from the prescriptive parts (StateMachines, Activities), and formulae from the descriptive parts (Interactions). This is the approach taken in [CF05], [XLB01] and [MC01]. In the first pa- per [CF05], Couzinier and F¨eraud translate example sequence and state machine diagrams into TLA+. This extension of Lamport’s temporal logic of actions is the input language for the model checker TLC. The second paper [XLB01], by Xie Levin and Browne, develops an automated translation from a UML subset with classes and state machines into the specification language of the COSPAN model checker. It also develops an OCL like language for expressing the desired system properties. Model transformations are applied to the UML model to reduce the state space of the resulting structure. In the third paper [MC01], McUmber and Cheng set up a general scheme for translating UML into formal languages using model transformation. This scheme, makes use of a notion of homomorphism for models. If we incorporate the insight that models map homomorphically into their metamodels, the scheme can be depicted as in Figure 7.6. Given a source model s instantiating a metamodel S, with S in turn mapped homomorphically into a target metamodel T, the task is to find an instance t of T. The dashed line is the required instance translation, which is partly specified by rules. The main specific transla- tion presented in this paper is into the input language of the Spin model checker.
mutually exclusive manner in every topology. One of the main problems of the distributed computing environment is the occurrence of the deadlock. To avoid this task in a mutual exclusion manner, the concept has been applied in such a manner that it controls the execution of the processes which show that they may not create a deadlock condition throughout their condition. Critical section principles -13] are used to avoid this problem. Network has been represented by graph and an algorithm has been designed to trace Hamiltonian cycles in G(n, p) graphs . The proposed algorithm works in a synchronous distributed environment. From the literature, it is also observed that first time Unified Modeling Language (UML) is proposed in the year 2002 for parallel and distributed applications i.e. in the field of Advanced Computer Architecture by Pallana and Fahringer -. They described the activity diagram, class diagram for process executing in parallel or distributed node. On the other hand and due to evolution of object-orientation, OMG - group has released UML specification in year 2001 after the development of various kinds of UML diagrams by Booch et al. -. Recently Saxena et al. - have also used the UML representation for the various kinds of network topologies and computed the performance of 2D mesh, torus and hypercube, topologies which are used for static interconnection of computer systems.
In this research, the result would be only use case, activity and state diagram. Software design can be achieved by analysis of functional requirements. UML is a general-purpose modeling language that models real-world objects . The unified Modeling Language (UML) has become a de-facto standard notation for describing analysis and design models of object-oriented software systems . As UML is becoming the de-facto language for software design, it is important to have a sufficiently rich linguistic structure to model security specifications accurately .
There are many researchers involved in doing research on managing syntactical and horizontal inconsistency between UML diagrams. However, limitations such as huge complexity of the UML that contains different notations, different types of diagram for different view of a system and lack of UML syntax and semantics are some of the sources of inconsistencies problem in a UML model. Therefore, in order to improve the validating consistency of the UML model requires constant improvements. Numerous approaches related to consistency specification and inconsistency detection has been carried out. However, current solutions using simplified version of the UML result in poor integration between the consistency management with CASE tool environment. Therefore, improvement on consistency rules specification requires the rules to be specified over standard UML elements that adhered to the UML models. Thus, in overcoming the drawbacks as mentioned before, this research focuses on formalizing syntactical rules for part of the UML elements adhering to four (4) UML diagrams; use case diagram, activity diagram, sequencediagram and class diagram, into logical specification. Syntactical rules for each of the UML elements are defined in logical specification to give more precise description to their natural language descriptions. The UML elements are then used to formalize twelve (12) horizontal consistency rules that will be used in detecting inconsistencies between those four (4) UML diagrams. The consistency rules are integrated into UML Checker and are used to validate the UML model. The next chapter discusses the literature on the existing approaches related to consistency management.
The information about a system is distributed across several model views of a system, captured through a large number of diagrams. UML models are intended to help reduce the complexity of a problem, with the increase in product sizes and complexities. Still, the UML models themselves become large and complex involving thousands of interactions across hundreds of objects. Many present day software products are state based. In such systems, the system behaviour is determined by its state. In other words, a system can respond differently to the same event in different states. Therefore, unless a system is made to assume all its possible states and tested, it would not be possible to uncover state-based bugs. Adequate system testing of such software requires satisfactory coverage of system states and transitions. Generation of test specifications to meet these coverage criteria can be accomplished by using the state model of a system. It is a major problem to meet the requirement specification for the Systematic production of high-quality software. However, it is a non-trivial task to manually construct the state model of a system. Therefore, with continually increasing system sizes, the issue of automatic design of system test cases is assuming prime importance . A properly generated test suite may not only locate the errors in a software system, but also help in reducing the high cost associated with software testing. The UML state model of an actual system is usually extremely complex and comprises of a large number of states and transitions. Possibly for this reason, state models of complete systems are rarely constructed by system developers . In case of component-based software development, test case generation based on program source code proves to be inadequate, where even the source code may not be available to the developers. Hence, it is important to generate test cases based on design specifications .
By defining Use Cases in this manner, the system is defined as a set of requirements rather than a solution. You do not describe how the system must work. You describe what the sys- tem must be able to do. The Use Cases describe only those features visible and meaningful to the actors who use the system. Keeping this in mind will help you avoid functional decompo- sition, the breaking down of procedures and tasks into smaller and smaller processes until you have described all the internal workings of the system. One of the pitfalls of systems development is going over budget, which happens when you don’t limit the scope of each task or you make a model too inclusive. The UML provides seven diagrams, in addition to the Use Case Model, for fully describing the solution for the system, so remember that you can save some work for later.