Stéphane S. Somé

Supporting use case based requirements engineering

Use cases that describe possible interactions involving a system and its environment are increasingly being accepted as effective means for functional requirements elicitation and analysis. In the current practice, informal definitions of use cases are used and the analysis process is manual. In this paper, we present an approach supported by a tool for use cases based requirements engineering. Our approach includes use cases formalization, a restricted form of natural language for use cases description, and the derivation of an executable specification as well as a simulation environment from use cases.

Use cases based requirements validation with scenarios

Use cases are analytical descriptions of how a system should react in interaction with actors. Use cases are appropriate as specification of a system required behavior. A scenario is an example of execution of a system that may be defined with the intention that it should be supported or the intention that it should be avoided. As such, scenarios are appropriate for requirements validation. This paper presents an approach where use cases and scenarios are used to complement each other for requirements engineering. Use cases define what a system should do, and scenarios are used to validate use cases.

Parsing minimization when extracting information from code in the presence of conditional compilation

Exploring and understanding a software system requires extracting meaningful information from it. This in turn involves syntactical analysis of source code, an activity that can be complicated by the use of conditional compilation. In this paper we discuss difficulties when parsing code with conditional compilation. We argue that the effective way to ensure the extraction of all meaningful information from a source file is to parse a set of versions of that file defined by conditional compilation. We then describe a heuristic-based approach to minimize the amount of parsing.

A UML profile for goal-oriented modeling

The Unified Modeling Language (UML) does not fully address the needs of some important modeling domains, including goals and non-functional requirements (NFR). However, UML can be extended and tailored through the definition of profiles. In this paper, we propose a UML profile for the Goal-oriented Requirement Language (GRL), the goal/NFR notation of the User Requirements Notation (URN), recently standardized by ITU-T as Recommendation Z.151. Our profile is based on the abstract metamodel of GRL defined in accordance with ITU-T Recommendation Z.111 (meta-metamodel). This GRL metamodel has already been successfully tested and implemented in the jUCMNav Eclipse plug-in (a URN modeling tool). The profiling approach used in this paper adheres to the guidelines for UML profile design defined in ITU-T Recommendation Z.119. The resulting profile has been implemented in a UML 2 tool, namely IBM Rational Tau 4.0, and validated with case studies. Our experience and lessons learned are also discussed.

An approach for supporting system-level test scenarios generation from textual use cases

This paper presents an approach for system-level test scenarios generation from use cases in text form. Test scenarios are linear sequences of events used as intermediate representations toward complete test cases. A restricted form of natural language is used for use cases description. We start by generating control flow-based state machines from each use case. These state machines are then connected in a global system-level state machine according to derived sequencing relations between use cases. We infer sequencing relations based on a comparison of use cases pre-conditions and post-conditions. Test scenarios are generated using depth-first traversal of the generated control flow-based state machines according to criteria inspired from traditional white-box code coverage.

A service creation environment based on scenarios

Abstract Scenarios are often constructed for illustrating example runs through reactive system. Scenarios that describe possible interactions between a system and its environment are widely used in requirement engineering, as a means for users to communicate their functional requirements. Various software development methods use scenarios to define user requirements, but often lack tool support. Existing tools are graphical editors rather than tool support for design. This paper presents a service creation environment for elicitation, integration, verification and validation of scenarios. A semi-formal language is defined for user oriented scenario representation, and a prototype tool implementing an algorithm that integrates them for formal specification generation. This specification is then used to automatically find and report inconsistencies in the scenarios.

An environment for use cases based requirements engineering

Use cases that describe possible interactions involving a system and its environment are increasingly being accepted as effective means for requirements elicitation and analysis. In the current practice, informal definitions of use cases are used and the analysis process is manual. We present UCEd an environment for use cases based requirements engineering. UCEd includes tools for use cases edition in conjunction with a domain model, use cases integration and use cases simulation.

An approach for aspect-oriented use case modeling

A use case model is a specification of a systems requirements consisting in use cases, actors and relationships. A use case captures stakeholders concerns as required interactions between a system and its actors. Use case models may however include concerns that crosscut across several use cases. We propose an <<aspect>> relation for the modularization and composition of these crosscutting concerns. The composition approach is formally established by mappings to Petri nets, and is implemented as an extension to an existing use case modeling tool.

Enhancement of a use cases based requirements engineering approach with scenarios

Use cases and scenarios are sometimes considered as analogous. In this paper, we take the position that use cases and scenarios are different but play complementary roles in requirements engineering. A use case is a collection of scenarios. Use cases are appropriate as specification of a system required behavior in interaction with its actors. A scenario is an example of execution involving a system and its actors. A scenario may be defined with the intention that it should be supported or the intention that it should be avoided. Scenarios can thus be used to validate functional as well as non-functional requirements specification. We present an integration of scenarios to a use case based requirements engineering approach and discuss the merits of such integration.

Enhancing program comprehension with recovered state models

State transition machines are high-level behavior descriptions often used as modeling tools for the design and implementation of a large class of software systems. Some of the state transition machine implementation approaches are such that the static structure of the resulting code closely matches that of the original state transition machines. Therefore, having a representation of the original state transition machines is likely to improve the corresponding code understandability. We present an approach supported by a prototype tool, to extract state transition machines by static analysis of source code. An objective of this work is to enhance program comprehension with visual representations of the behavior of the programs being analyzed.