Timed Use Case Maps

Lecture Notes in Computer Science, 2007

Scenario-driven requirement specifications are widely used to capture and represent functional requirement. More recently, the Use Case Maps language (UCM), being standardized by ITU-T as part of the User Requirements Notation (URN) has gained on popularity within the software requirements community. UCM models focus on the description of functional and behavioral requirements as well as high-level designs at the early stages of system development processes. However, timing issues are often overlooked during the initial system design and treated as non-related behavioral issues and described therefore in separate models. We believe that timing aspects must be integrated into the system model during early development stages. In this paper, we present a novel approach to describe timing constraints in UCM specifications. We describe a formal operational semantics of Timed UCM in terms of Timed Automata (TA) that can be analyzed and verified with the UPPAAL model checker tool. Our approach is illustrated using a case study of the IP Multicast Routing Protocol.

Journal of Systems and Software, 2010

There is a general consensus on the importance of good Requirements Engineering (RE) for achieving high quality software. The modeling and analysis of requirements have been the main challenges during the development of complex systems. Although semi-formal, scenario driven approaches have raised the awareness and use of requirement engineering techniques, mostly because of their intuitive representation. Scenarios are a well established approach to describe functional requirements, uncovering hidden requirements and trade-offs, as well as validating and verifying requirements.

Lecture Notes in Computer Science, 2005

Scenario-driven requirement specifications are widely used to capture and represent functional requirements. Use Case Maps (UCM) is being standardized as part of the User Requirements Notation (URN), the most recent addition to ITU−T's family of languages. UCM models allow the description of functional requirements and high-level designs at early stages of the development process. Recognizing the importance of having a well defined semantic, we propose, in this paper, a concise and rigorous formal semantics for Use Case Maps (UCM). The proposed formal semantics addresses UCM's operational semantics and covers the key language functional constructs. These semantics are defined in terms of Multi-Agent Abstract State Machines that describes how UCM specifications are executed and eliminates ambiguities hidden in the informal language definition. The resulting operational semantics are embedded in an ASM-UCM simulation engine and are expressed in AsmL, an advanced ASM-based executable specification language. The proposed ASM-UCM engine provides an environment for executing and simulating UCM specifications. We illustrate our approach using an example of a simplified call connection.

Proceedings of the 7th International Conference on Informatics in Control, Automation and Robotics, 2010

This work presents a method for verifying temporal requirements of time-constrained systems. The method predates by establishing a new time constraints (properties) taxonomy. Then, a basis of observation patterns relative to the predefined requirements is developed. Our approach allows the automated verification of temporal requirements, initially expressed in a semi-formal formalism, through model transformation and modelchecking. The contributions of the paper are: the definition of a new time constraints (properties) typology as well as a basis of appropriate State Machines (SM) observation patterns. The second contribution consists in developing an algorithm for transforming UML SM with time annotations into Timed Automata (TA). In practice, in order to verify the temporal aspects of a given specification, the observation patterns relative to the investigated properties are instantiated to make appropriate observers. Then using our transformation algorithm, the system specification (denoted in the shape of an UML SM model) with time annotations as well as the obtained observers are translated into TA models. The TA system model is next synchronized with the TA observers. Thereby, the verification process is reduced to a reachability analysis.

Software Engineering, 2010

Timing diagrams provide an intuitive graphical specification for time constraints and causal dependencies between a system's objects. Such a view can provide useful insight during Requirements Engineering (RE). Formal Modeling techniques allow abstract system level models to be explored in revealing detail and provide feedback via verification and validation methods such as proofs of consistency, model checking and animation. Here, we bring these two modelling approaches together. In particular we present techniques to extend a graphical modeling capability for formal modeling into the realtime domain by developing a Timing diagram view for the Event-B formal method and its graphical front-end, UML-B. Translation schemes to Event-B and UML-B are proposed and presented. A case study of a lift system is used to demonstrate the translation in practice.

Lecture Notes in Computer Science, 2013

Non-functional requirements such as availability, reliability, and security are often crucial in designing and implementing distributed real-time systems. As a result, such non-functional requirements should be addressed as early as possible in the system development life-cycle. The widespread interest in dependability modeling and analysis techniques at the requirements elicitation and analysis stage provides the major motivation for this research. This paper presents a novel approach to describe high-level availability requirements using the Aspect-oriented Use Case Maps (AoUCM) language. AoUCM adds aspects-oriented concepts to the Use Case Maps (UCM) language, part of the ITU-T User Requirements Notation (URN) standard. The proposed approach relies on a mapping of availability architectural tactics to reusable AoUCM models, allowing availability tactics to be encapsulated early in the software development life-cylce. Initial tool support for the resulting availability extensions, is provided by the jUCMNav tool. We demonstrate the applicability of our approach using a case study of Lawful Intercept (LI), an IP router feature.

2012

This paper presents a novel process for formalizing UCM notation as an executable formal specification described in the Maude language Strategy, a recent extension of Maude. The main motivation of our work is essentially to provide a sound and rigorous description of complex systems described by UCM, which can help analysts, designers and developers, to automating their verification and validation processes and to assuring their quality.

2011

Formal specification of software systems has been very promising. Critics against the end results of formal methods, that is, producing quality software products, is certainly rare. Instead, reasons have been formulated to justify why the adoption of the technique in industry remains limited. Some of the reasons are: • Steap learning curve; formal techniques are said to be hard to use. • Lack of a step-by-step construction mechanism and poor guidance. • Difficulty to integrate the technique into the existing software processes. Z is, arguably, one of the successful formal specification techniques that was extended to Object-Z to accommodate object-orientation. The Z notation is based on first-order logic and a strongly typed fragment of Zermelo-Fraenkel set theory. Some attempts have been made to couple Z with semi-formal notations such as UML. However, the case of coupling Object-Z (and also Z) and the Use Case Maps (UCMs) notation is still to be explored. A Use Case Map (UCM) is a scenario-based visual notation facilitating the requirements definition of complex systems. A UCM may be generated either from a set of informal requirements, or from use cases normally expressed in natural language. UCMs have the potential to bring more clarity into the functional description of a system. It may furthermore eliminate possible errors in the user requirements. But UCMs are not suitable to reason formally about system behaviour. In this dissertation, we aim to demonstrate that a UCM can be transformed into Z and Object-Z, by providing a transformation framework. Through a case study, the impact of using UCM as an intermediate step in the process of producing a Z and Object-Z specification is explored. The aim is to improve on the constructivity of Z and Object-Z, provide more guidance, and address the issue of integrating them into the existing Software Requirements engineering process.

International Journal of Computer Applications, 2014

Modeling of real time software systems (RTSS) consist of different components with UML 2.0 leads to a design model using various diagrams. To get a consistent model, a consistency concept for different diagrams type is needed that takes into account real time constraints. Ensuring consistency of The Unified Modeling Language (UML) model is very crucial as it is effect to the quality of UML model and directly gives impact to good implementation of Information System. Although there are increasing researches on consistency management, there is still lack of researches of consistency driven by Use Case. With this motivation, in this paper, we have proposed few consistency rules between Use Case, Sequence and Timing diagrams which focus on the establishment of timing constraints. Elements of each diagram involved in the proposed rules are formalized. Using an example, we show how the diagrams fulfill our proposed consistency rules.

Event-B is a language for the formal development of reactive systems. At present the RODIN toolkit for Event-B is used for modeling requirements, specifying refinements and doing verification. In order to extend graphical requirements modeling capability into the real-time domain, where timing constraints are essential, we propose a Timing diagram (TD) [13] notation for Event-B. The UML 2.0 based notation provides an intuitive graphical specification capability for timing constraints and causal dependencies between system events. A translation scheme to Event-B is proposed and presented. Support for model refinement is provided. A partial case study is used to demonstrate the translation in practice.