General Definitions

Use Case:

·         (UML 1.4) A use case is a kind classifier representing a coherent unit of functionality provided by a system, a subsystem, or a class as manifested by sequences of messages exchanged among the system (subsystem, class) and one or more outside interactors (called actors) together with actions performed by the system (subsystem, class).

·         A joint action with multiple participant objects that represent a meaningful business task, usually written in a structured narrative style. Like any joint action, a use case can be refined into a finer grain sequence of actions.

·         The specification of a sequence of actions, including variants, that a system (or other entity) can perform, interacting with actors of the system.

·         (Rational Unified Process 2001) Services provided by the system to its actors. Use cases capture the system functional requirements and may have associated performance requirements.

Association relationship: (UML 1.4) The participation of an actor in a use case; that is instances of the actor and instances of the use case communicate with each other. This is the only relationship between actors and use cases.

Extend relationship: (UML 1.4) An extend relationship from use case A to use case B indicates that an instance of use case B may be augmented (subject to specific conditions specified in the extension) by the behaviour specified by A.

Generalization relationship: (UML 1.4) A generalization from use case C to use case D indicates that C is a specialization of D.

Include relationship: (UML 1.4) An include relationship from use case E to use case F indicates that an instance of the use case E will also contain the behaviour as specified by F.

“Trace” relationship: A kind of dependency that indicates a historical relationship between two elements that represent the same concept at different semantic levels or from different points of view. The related elements abstract the same part of the system but in different models.

Essential Use Case: Captures the intentions of a user in a technology- and implementation-independent manner.

System Use Case: Captures the high-level implementation decisions.

Actor: (UML 1.4): An actor defines a coherent set of roles that users of an entity can play when interacting with the entity. An actor may be considered to play a separate role with regard to each use case with which it communicates.

Use Case Template

Not all attributes are required.

Use case name: The name should implicitly express the user’s intent or purpose of the use case.

Use case identifier: A unique identifier, UC# should be used.

Description: Summary of the use case.

Domain: The domain that this use case applies to.

Participants/Actors: The list of actors associated with the use case, such as Initiator and Receiver . Actors can be people or systems.

Parameters: Parameters that the initiating actor passes to the use case.

Pre-conditions: A list of the conditions, if any, that must be met before a use case may be invoked.

Post-conditions: A list of the conditions, if any, that will be true after the use case finished successfully.

Trigger: The action upon the system that starts the use case, such as a time event.

Priority: Criticality of the use case to the system/organization.

Frequency: How often the use case is invoked by the actor.

Performance: Performance criteria

Channel to Actors: Examples are interactive, static files, database.

Included Uses Cases: A list of the use cases that this use case includes. An include association is a generalization relationship denoting the inclusion of the behaviour described by a use case within another use case. This is modeled using a use case association with the <<include>> stereotype. Also known as a uses or a has-a relationship.

Extended Use Cases: The use case that this use case extends, if any. An extend association is a conditional generalization relationship. An extending use case continues the behaviour of a base use case subject to specific conditions. The extending use case accomplishes this by inserting additional action sequences into the base use case sequence. This is modeled using a use case association with the <<extend>> stereotype.

Generalization Use Cases: The use case to which this use case is a generalization.

Basic Flow/Course of Action: The main path of logic that an actor follows through a use case.

Alternate Flows/Courses of Action: The infrequently used path of logic is a use case, paths that are the result of an alternate way of work, an exception, or an error condition.

Assumptions: Any important assumptions about the domain.

Status: The current status of the development of this use case, such as work in progress, ready for review.

Change History: A list of issues or action items, if any, that are related to the development of this use case.

Issues: A list if issues or action items, if any, that are related to the development of this use case.

Decisions: A list of critical decisions pertaining to the content of the use case.