XML-Based Techniques for Requirements Engineering

A commonly used approach in requirements engineering to analyze, understand and represent software requirements is the scenario-based approach. A scenario is defined as "an ordered set of interactions between the users and the system". The concept of scenario has been included in the Unified Modeling Language (UML), now a standard notation for object-oriented software engineering methodologies. Unfortunately, no methodology has yet been adopted as a standard for scenario representation.

Available tools that support requirements specification and analysis mostly focus on the graphical representation of specifications, using diagrams like the UseCase diagrams (defined in UML). Nevertheless, diagrams cannot express many system details that may result useful in the successive development steps. In these tools, scenarios are often written as simple tables and text documents. The documents are difficult to read, since they contain a mix of natural language statements, semi-standard names and expressions, and raw cross references.

The first result of our research is the Scenario Description Markup Language (SDML). SDML is an XML language that can be used to describe and manipulate scenarios.

The main features of SDML are:

• Standardization. SDML comes from the analysis of many different ways of writing scenarios that can be found in the literature. Since there is no common standard in this area, we tried to integrate all the known scenario description techniques in a unique, complete formalism.
• Powerful Notation. SDML currently supports advanced techniques of scenario description, including composition (parallel, sequential, nondeterministic), iteration, inclusion, extension, multiple variants, time-triggered actions, etc.
• Semantics. SDML gives a simple, precise and unambiguous semantics to all the scenario-related structures. This means that scenarios formalized in SDML are easy to understand or process automatically.
• Structuring. Text documents used to describe scenarios cannot represent the intrinsic structuring of these objects. Indeed, this structuring is very useful to understand the scenario and reuse its components. SDML, as all XML languages, has a very high level of structuring.
• Cross-Referencing. XML-based cross references in SDML documents allow an easy browsing through all the scenario documentation.
• Automatic Manipulation. SDML documents can be read and written by code very easily. No information is lost in this process. Moreover, SDML data can be easily handled by software applications using the XML DOM libraries.
• Compatibility. Many applications used in the software engineering process support custom and not-standard XML notations as output. SDML, like all XML languages, can be easily translated in any other format (also non XML) using the powerful XSLT technology.
• Reusability. SDML documents and resources are very modular. For instance, the "domain knowledge" used in scenarios description (e.g., the actors, their properties, the items they can interact with and the interaction modalities) is separated from the scenario itself, and stored in particular namespaces, so it can be directly reused in similar projects.

SDML has been defined using the XML Schema formalism. We also developed several examples of scenarios formalized through SDML, that can be viewed as source XML or using the dynamic visualization stylesheet (see below) from the SDML examples page.

We are currently developing several tools to support SDML. At the same time, we plan to give extensions to SDML to support the representation of advanced features like non-functional requirements.

Scenario Documentation

Starting from the SDML descriptions, we can easily obtain very expressive graphical and textual representations of the scenarios that can be useful to test the integration between the system components. The representations are built using the latest XML and HTML technologies, so they are all web-compatible: this is very important, since it facilitates the information sharing.

• We developed an XSLT stylesheet that creates a tabular description of scenarios using Dynamic HTML. The representation hypertextual, e.g. it allows navigation from references to actors to actor definitions and between objects contained in the namespaces imported by the SDML document, and has a customizable detail level: included scenarios and variants can be viewed only as references or expanded inline.
• We plan to generate graphical view on the scenarios and their composition rules, using UML-like graphic primitives. Our idea is to use the SVG ( Scalable Vector Graphics) XML language to create web compatible lightweight graphics directly from SDML using another XSLT stylesheet.

Visual Editing

SDML files can be directly handwritten, but this process could become too complex for large software projects. We are developing a visual editor to describe, manipulate and compose scenario specifications formalized using SDML.

Testing and Validation Support

The testing phase verifies the consistency, soundness and completeness of requirement specifications. Today, software tests, in particular system and performance tests, are created using ad-hoc methodologies, and the generation of test cases is not systematic.

Thanks to the SDML structure, test cases can be generated automatically or semi-automatically from scenarios written during the requirements specification phase. To support this generation process, we are developing

• an XSLT transformation stylesheet that creates standard test-case documents from the scenario description.
• a support XML language that can be used to represent test cases. In this way, we may transform the SDML scenarios in new documents written with such language, which can be in turn displayed as standard test-case documents. This would allow manipulations and/or integrations on test cases without effecting the original scenarios.

Statecharts

We designed an algorithm to automatically create object statecharts from the scenarios describing the behavior of a particular object. The output of this algorithm is a statechart-specific language, namely SCDML. We are currently implementing the algorithm in a Java program, and we plan to use the generated statacharts to further verify automatically the specification consistency.