![]() ![]() The evaluation of various scenarios from industrial case studies demonstrates that the proposed approach efficiently translates the behaviour models into formal specifications and properties. Moreover, our approach can provide the developers more informative and comprehensive feedback regarding the inconsistency issues, and therefore, help them to efficiently identify and resolve the problems. The generated formal specifications and properties can directly be used by existing model checkers for detecting any discrepancy between the input models and yield corresponding counterexamples. To alleviate this issue, we define and develop a fully automated transformation of behaviour models into formal specifications and properties. Unfortunately, creating formal consistency constraints and specifications is currently done manually, and therefore, labour-intensive and error prone. Because the containment checking is based on model checking, it requires both formal consistency constraints and specifications of these models. We interpret the containment checking problem as a model checking problem, which has not received special treatment in the literature so far. In this article, we introduce a containment checking approach to verify whether a certain low-level behaviour model, typically created by refining and enhancing a high-level model, still is consistent with the specification provided in its high-level counterpart. ![]() It is thus crucial to detect these inconsistencies at early phases of the software development process, and especially as soon as refined models deviate from their abstract counterparts. Because of the involvement of different stakeholders in constructing these models and their independent evolution, inconsistencies might occur between the models. Models are extensively used in many areas of software engineering to represent the behaviour of software systems at different levels of abstraction. Weĭiscuss various challenges in our approach and show the applicability of our Properties and descriptions that can be directly used by model checkers. Inputs and devising automated mappings of behavior models onto formal Our approach presented in this paper aims at alleviating theĪforementioned challenges by considering the behavior models as verification Well as consistency constraints, which is a tedious and error-prone task whenĭone manually. Lessen the burden of creating formal specifications of the behavior models as Specified in the high-level counterparts. System's behaviors described by the low-level models satisfy what has been Techniques, we propose containment checking as a means to assess whether the In this context, we focus on behavior models that is, weĪim to ensure that the refined, low-level behavior models conform to theĬorresponding high-level behavior models. As a consequence, the refined models can deviateįrom the original models over time, especially when the two kinds of modelsĮvolve independently. The developers will refine and enrich these high-level Software system using high-level models that are technology- and We propose a rule based coordination framework where negotiation and synchronization aspects are specified in terms of, respectively, constraint solving, and transactions.Business analysts and domain experts are often sketching the behaviors of a The situation can be summarized in the following table: We claim that these two aspects, negotiation and synchronization, can be elegantly supported in a rule-based framework by two mechanisms which, in the past, have been successfully integrated with rules: respectively, constraint propagation (and solving) and transactions. Working out which tasks have to be done (the “what” part) often requires a negotiation between the coordinator and the external systems which are supposed to then perform the tasks as for sequentializing the tasks in an appropriate order (the “when” part), it requires some form of synchronization. Abstracting the “how” part of activities from the “what” and “when” make coordination particularly amenable to the declarative kind of specifications offered by rule-based frameworks. Coordination systems generally do not provide any tools to support the technological aspect instead, they are open systems which can (or have the ambition to) interoperate with various other systems and platforms which implement the actual actions. The technological aspect concerns how tasks are actually performed. ![]() The behavioral aspect concerns when particular tasks are to be executed. Usually, task coordination systems distinguish several aspects of task execution: the functional aspect is concerned by what tasks are to be performed by the system. ![]()
0 Comments
Leave a Reply. |