Daniel Amyot, PhD student, University of Ottawa Scenarios As First-Class Entities Functional Entities Mapping Scenarios on Functional Entities Network.

Slides:



Advertisements
Similar presentations
International Telecommunication Union © ITU-T Study Group 17 Integrated Application of URN Daniel Amyot University of Ottawa, Canada
Advertisements

A System to Generate Test Data and Symbolically Execute Programs Lori A. Clarke September 1976.
ES Seminar1 Communicating Transaction Processes P.S. Thiagarajan National University of Singapore Joint Work with: Abhik Roychoudhury; ……
UML Diagrams Jung Woo. What is UML? Standard language for specifying, visualizing, constructing, and documenting the artifacts of software systems, business.
Documenting a Software Architecture By Eng. Mohanned M. Dawoud.
Software Design Deriving a solution which satisfies software requirements.
OOAD Using the UML - Use-Case Analysis, v 4.2 Copyright  Rational Software, all rights reserved 1/18 Use Case Analysis – continued Control Classes.
Software Engineering COMP 201
Lecture 5a: Sequence Interaction Diagrams CSE 111 Copyright W. Howden1.
Business Process Orchestration
Copyright W. Howden1 Lecture 4: Sequence Interaction Diagrams.
7M701 1 Class Diagram advanced concepts. 7M701 2 Characteristics of Object Oriented Design (OOD) objectData and operations (functions) are combined 
Unified Modeling (Part I) Overview of UML & Modeling
Bridging the gap between Interaction- and Process-Oriented Choreographies Talk by Ivan Lanese Joint work with Claudio Guidi, Fabrizio.
1 Ivan Lanese Computer Science Department University of Bologna Italy Concurrent and located synchronizations in π-calculus.
© Copyright Eliyahu Brutman Programming Techniques Course.
Future Plans for CPN Tools - General. 2 Plans for CPN Tools CPN’0624-Oct-2006 Version plans Improvements for current marking feedback Support for.
Software Process Activities. Process activities Real software processes are inter-leaved sequences of technical, collaborative and managerial activities.
Company LOGO Business Process Monitoring and Alignment An Approach Based on the User Requirements Notation and Business Intelligence Tools Pengfei Chen.
UML Sequence Diagrams Michael L. Collard, Ph.D. Department of Computer Science Kent State University.
S CHOOL OF I NFORMATION T ECHNOLOGY AND E NGINEERING U NIVERSITY OF O TTAWA, C ANADA Daniel Amyot Q.18/17 Rapporteur SITE, University of Ottawa, Canada.
Object-oriented methodology object models use case modeling unified modeling language the data dictionary the cornucopia case portfolio project Systems.
UCM-Based Generation of Test Goals Daniel Amyot, University of Ottawa (with Michael Weiss and Luigi Logrippo) RDA Project (funded.
1 CS 456 Software Engineering. 2 Contents 3 Chapter 1: Introduction.
Copyright 2002 Prentice-Hall, Inc. Modern Systems Analysis and Design Third Edition Jeffrey A. Hoffer Joey F. George Joseph S. Valacich Chapter 20 Object-Oriented.
Jan 20-21, 2005Weiss and Amyot, MCETECH 051 Designing and Evolving Business Models with the User Requirements Notation Michael Weiss (Carleton University)
Introduction A GENERAL MODEL OF SYSTEM OPTIMIZATION.
1 UML Basic Training. UML Basic training2 Agenda  Definitions: requirements, design  Basics of Unified Modeling Language 1.4  SysML.
Component frameworks Roy Kensmil. Historical trens in software development. ABSTRACT INTERACTIONS COMPONENT BUS COMPONENT GLUE THIRD-PARTY BINDING.
S CHOOL OF I NFORMATION T ECHNOLOGY AND E NGINEERING U NIVERSITY OF O TTAWA Feature Description and Feature Interaction Analysis with Use Case Maps and.
Chapter 5 Models and UML Notation for The Object-Oriented Approach.
UML diagrams What is UML UML diagrams –Static modeoing –Dynamic modeling 1.
©Ian Sommerville 2004Software Engineering, 7th edition. Chapter 14 Slide 1 Object-oriented Design.
For Goal-Driven Business Process Modeling Saeed A.Behnam,  Daniel Amyot, Gunter Mussbacher SITE, University of.
9-1 © Prentice Hall, 2007 Chapter 9: Analysis Classes Object-Oriented Systems Analysis and Design Joey F. George, Dinesh Batra, Joseph S. Valacich, Jeffrey.
TTCN-3 MOST Challenges Maria Teodorescu
Submodule construction in logics 1 Gregor v. Bochmann, University of Ottawa Using First-Order Logic to Reason about Submodule Construction Gregor v. Bochmann.
Early Availability Requirements Modeling using Use Case Maps KAMARUL ZAMAN BIN PANATIK MAN
CSC 480 Software Engineering Lecture 15 Oct 21, 2002.
SOFTWARE DESIGN. INTRODUCTION There are 3 distinct types of activities in design 1.External design 2.Architectural design 3.Detailed design Architectural.
1 Overview of the project: Requirement-Driven Development of Distributed Applications School of Information Technology and Engineering (SITE) University.
Gregor v. Bochmann, University of Ottawa Based on Powerpoint slides by Gunter Mussbacher(2009) with material from Amyot User Requirements Notation (URN)
Architecture View Models A model is a complete, simplified description of a system from a particular perspective or viewpoint. There is no single view.
Generating Software Documentation in Use Case Maps from Filtered Execution Traces Edna Braun, Daniel Amyot, Timothy Lethbridge University of Ottawa, Canada.
Software Engineering1  Verification: The software should conform to its specification  Validation: The software should do what the user really requires.
1 Technical & Business Writing (ENG-715) Muhammad Bilal Bashir UIIT, Rawalpindi.
Modeling the ODP Computational Viewpoint with UML 2.0: The Templeman Library Example José Raúl Romero, Antonio Vallecillo Universidad de Málaga, Spain.
Course: COMS-E6125 Professor: Gail E. Kaiser Student: Shanghao Li (sl2967)
Lecture 13.  Failure mode: when team understands requirements but is unable to meet them.  To ensure that you are building the right system Continually.
CSCI 3428: Software Engineering Tami Meredith UML Unified Modeling Language.
CS223: Software Engineering
Gerhard Dueck -- CS3013Analysis 1. Gerhard Dueck -- CS3013Analysis 2 Why analysis?  Yield a more precise specification of the requirements.  Introduce.
© 2000 D EMO D AY 2000 Page 1 Automatic Generation of Conformance Test Cases from Use Case Maps Strategic Technology Leïla Charfi, Luigi Logrippo & group.
Systems Architectures System Integration & Architecture.
Unified Modeling Language. What is UML? Standard language for specifying, visualizing, constructing, and documenting the artifacts of software systems,
1 © 2013 Cengage Learning. All Rights Reserved. This edition is intended for use outside of the U.S. only, with content that may be different from the.
© 2009 Artisan Software Tools. All rights reserved. Testing Solutions with UML/SysML Andrew Stuart, Matthew Hause.
UML (Unified Modeling Language)
Software Architecture
UML Diagrams By Daniel Damaris Novarianto S..
Object-Oriented Analysis and Design
SUPA/YMCA (Yang Models for Configuration and topology Abstraction)
Description of WIN Incoming Call Screening Service using Use Case Maps
University of Central Florida COP 3330 Object Oriented Programming
UML Diagrams Jung Woo.
Object-Oriented Analysis
Towards Next Generation Panel at SAINT 2002
Lecture 4: Sequence Interaction Diagrams
Chapter 20 Object-Oriented Analysis and Design
Software Architecture
Presentation transcript:

Daniel Amyot, PhD student, University of Ottawa Scenarios As First-Class Entities Functional Entities Mapping Scenarios on Functional Entities Network Entities Mapping Functional Entities to Network Entities Resulting Mapping: Scenarios to Network Entities Deriving Message Sequence Charts Towards Validation Towards Testing

Scenarios paths can be used as first-class entities. In this way, we can focus on causality relationships between responsibilities, without any reference or commitment to architectural components and messages. These scenarios are useful as thinking tools in the early steps of feature definitions. Features can be expressed as one or many high-level scenarios, as shown in Figure 1. T dial busy connect R1 R2 henceforth: dial =d, connect=c, busy=b Figure 1. A Use Case Map that represents a set of scenarios

Functional entities (FEs) collaborate with each other in order to describe features. We can use different collections of FEs for the design of one feature. Choices have to be made at this level (see Figure 2). Figure 2. Two collections of Functional Entities FE1 FE3 FE2 FE4 FE1 FE5FE6

The mapping of scenarios to architectures is done through responsibilities allocated to components (FEs in this case). For one specific collection of FEs (the left alternative in Figure 2), many mappings are possible. Figure 3 illus- trates two such mappings for our scenario. Very useful design information can be collected and reasoned about at this level of abstraction. Figure 3. Feature scenario on Functional Entities FE1 FE3 FE2 FE4 FE1 FE3 FE2 FE4 T d b c R1 R2R1 R2 d b c T

Functional entities are used in IN’s distributed functional plane. In the physical plane, the architectural components are called Network Entities (NEs). Again, many structures of NEs are possible for the support of features, as shown in Figure 4. Figure 4. Two collections of Network Entities, with channels NE1 NE2 NE1NE2 NE4NE5 NE3

FEs being mostly static (not mobile), they can be allocated to NEs. Figure 5 shows that for one specific structure of NEs (the left alternative in Figure 4), our collection of FEs can be distributed in many ways. Figure 5. Functional Entities on Network Entities NE1 NE3 NE1 NE3 FE1 FE3 FE2 FE4 FE1 FE2 FE4 FE3 NE2

From the mapping of scenarios to FEs and the mapping of FEs to NEs, we get the following result for free (Figure 6). Responsibilities become allocated to NEs, and communication channels that link NEs can be used to implement causal relationships between responsibilities. Figure 6. Scenarios bound to Functional Entities and Network Entities NE1 NE3 NE1 NE3 FE1 FE3 FE2 FE4 FE1 FE3 NE2 T d b c R1 R2 FE2 d c T R1 R2 FE4 b

In order to derive valid Message Sequence Charts (MSCs) from scenarios bound to a structure of NEs, we need to: define coordination messages and information flow between NEs satisfy the constraints imposed by the channels satisfy the constraints imposed by causal relations between responsibilities From the path in our scenario, MSCs can be generated according to the chosen structure, coordination, and information flow (Figure 7). Figure 7. Message Sequence Chart derived from our UCM scenario NE1 NE3 FE1 FE3 FE2 FE4 NE2 T d bc R1 R2 c d T m1 m2 R2 NE1NE2NE3

Figure 8. Two Message Sequence Charts derived from one UCM scenario R2 NE2 NE1 NE3 R1 b d c A different binding causes channel constraints to be satisfied differently from those of Figure 7 More complex coordination and information flow c d T m2 m1 R2 NE1NE2NE3 m3 T NE1NE2NE3 c d R2 m1 m2 m3m4 m5 m6 m7 T

Figure 9. Example: from UCMs to LOTOS structure and processes R2 NE2 NE1 NE3 R1 b d c The component structure is mapped to a composition of processes T Each compo- nent becomes a process that implements all traversing paths (possibly from many scenarios) specification Feature [T, R1, R2]… hide Chan12, Chan 23 in (NE1[T, Chan12] | | | NE3[Chan23]) | [Chan12, Chan23] | NE2[R1, R2, Chan12, Chan23] where (* Components as processes *) … endspec (*Feature*) process NE2[R1, R2, Chan12, Chan23]... hide b, c in Chan12 !m1; Chan23 !m2; NE2[…] Chan23 !m3; c; R2; NE2[…] Chan12 !m8; Chan23 !m9; NE2[…] Chan23 !m10; b; R1; NE2[…] endproc (*NE2*)

Many testing strategies, techniques, and tools can be used to validate the com- position of features with respect to their intended behaviour. Figure 10 shows two test cases, derived from the original UCM, that must be accepted by the Feature specification of Figure 9. Figure 10. Example: test cases generation from UCMs process Test1[T, R1, R2, success] : noexit := T !some_parameters; R1; success; stop endproc (*Test1*) process Test2[T, R1, R2, success] : noexit := T !other_parameters; R2; success; stop endproc (*Test2*) c b d R2 R1 T Other techniques could help validate, for instance, that specific partial traces exist (e.g., using goal-oriented execution: GOAL [T, R1]), or that some prop- erty, derived from the UCM, is satisfied by the resulting specification (e.g., using model checking: AG( ‘ T ’ -->AF ( ‘ R1 ’ v ‘ R2 ’ )))