Deriving component-level behavior models from scenario-based requirements

Use-case scenarios, with notations such as UML sequence diagrams, are widely used to specify the desired behaviors of a software system. Scenarios are often complemented with formalized system properties (e.g., event invariants). These intuitive requirements notations only partially specify the system-to-be by prohibiting or requiring certain behaviors, while leaving other behaviors uncategorized into either of those. During early stages of a system's life cycle, engineers iteratively specify and elaborate the scenario-based requirements by elaborating existing and eliciting new scenarios. In parallel, engineers design the system's software architecture, consisting of multiple independently running components, that should be consistent with and satisfy the elicited requirements.;Although intuitive, the existing requirements notations allow engineers to specify behaviors with unintended semantic side-effects. In particular, the current practices support reasoning about and specification of behaviors exclusively at the system level, in contrast to the fact that a system consists of interacting components. This runs the risk of arriving at an inconsistent requirements specification (i.e., one that is not realizable as a composition of the system's components), which can prove costly if left unresolved. Furthermore, the lack of a direct mapping from requirements to a specification of components' behaviors duplicates the specification effort as the same behaviors need to be specified both as a part of requirements and architecture specifications. This also hampers the traceability that should ideally exist from requirements to the eventual implementation.;To address the shortcomings of the current practices, this dissertation implements three strategies to enable transitioning from a scenario-based requirements specification to a set of component-level behavior models: (1) heuristically creating component MTSs from a system-level scenario-based specifications, (2) enhancing the way scenarios are specified, and (3) mapping the refinements performed on a system MTS to refinements to-be-performed on component-level MTSs. The component models are specified as modal transition systems (MTS) --- a partial-behavior modeling formalisms that accurately captures the required, prohibited, and undefined behaviors of the system components.;The implementations of the three strategies are intended for different development contexts and work with different inputs: 1. A heuristic algorithm that synthesizes a set of component MTSs from a set of existential scenarios and event invariants. 2. Component-aware Triggered Scenarios (caTS), a triggered-scenario language that enables expressing reactive behaviors of system components. 3. A framework that, given a system MTS refinement based on a new requirement, propagates that refinement to a set of component MTSs. The MTSs produced using these techniques can be used for automated analyses (e.g., requirements consistency checking) and requirements elicitation, while ensuring traceability and consistency between the requirements and architecture specifications. To assist traceability and consistency checking between the system specifications and the eventual system implementation, this dissertation proposes Trace-Enhanced MTS Inference (TEMI) algorithm that extracts component MTSs from the observed system executions.;The proposed techniques have been theoretically evaluated to analyze their complexity, as well as to establish their correctness and completeness. The techniques have been applied on a number of real-world and automatically generated case studies. The results suggest that the generated MTSs accurately capture those component implementations that (1) necessarily provide the behavior required by the scenarios, (2) restrict behavior forbidden by the requirements specification, and (3) leave the behavior that is neither explicitly required nor forbidden as undefined. Furthermore, the proposed techniques help to detect potential specification flaws as they are specified, correct the existing errors, and prevent future inconsistencies. The techniques also scale to larger system specifications than the prior state-of-the-art in terms of the running times required to generate component MTSs and the specification effort required to specify the desired behaviors. Finally, the performed evaluations confirm that the TEMI algorithm produces models of significantly higher quality than the state-of-the-art in dynamic model inference.