UBET TUTORIAL
Table of Contents
1. Purpose of this
tutorial
2. Background
concepts
What is a Use Case?
What is a Scenario?
What is a Message Sequence Chart?
How are Use Cases, Scenarios and MSCs represented in
uBET?
3. Our example Use
Case
4. Conventions
5.
Starting the uBET tool set
6.
Pointing uBET to the tutorial files
7.
Thinking through the problem -- the `sunny day' approach
8.
Capturing additional Scenarios
Using UCE: linking an MSC to a node
Using UCE: labelling edges
Using UCE: linking a sub-Use Case (sub-graph)
to a node
Using UCE: inlining a sub-Use Case
9.
Selecting and Naming scenarios in a Use Case
Selecting a Scenario (Path)
Naming the Scenario
Converting the Scenario to a long MSC
10. Checking Scenarios and MSCs
Race
Conditions
More on queue semantics
Viewing message ordering
11.
Linking objects in MSE and UCE to text requirements in MSword
12.
Using an ObjecTime Model
13.
Exporting graphics to MSword and FrameMaker documents
.GIF export for MSword documents
.MIF export for FrameMaker documents
14. Conclusions
15.
References
The purpose of this tutorial is to show, through a familiar example, how Use Cases and Message Sequence Charts are described using the Use Case Behaviour Engineering Toolset (UBET) tool set. The uBET tools are very light on methodology, having been designed to aid thinking and in so doing not to constrain users to any particular approach or thought process. So, while we've described some thinking-type approaches that one could employ while using these tools, none in particular is recommended and users are free to use any approach that promotes thinking through and capturing the problem.
This tutorial assumes that you are running uBET Release 2.0 on Windows 95.
return to the Table of Contents
In the context of the uBET tool set, a Use Case is a description of a distinct and bounded feature of a system. In an automatic teller application, for instance, the Use Cases of interest might be `withdrawal', `deposit', `transfer', and `account balance'. A Use Case may have branching to cover exceptions. Typically there might be a `sunny day' path through the Use Case, to which exception handling branches are attached. For the `withdrawal' feature of the automatic teller, the sunny day path is the case where the amount of money requested does not exceed the balance available for withdrawal, and exceptions would include a case where the amount of money requested exceeds the account balance or the case where the amount of money requested exceeds the dollar amount of bills stored in the machine.
A Scenario is a non-branching thread or path through a Use Case. If a Use Case has conditional branching, then there will be more than one possible Scenario in the Use Case. The sunny day path that shows the expected behaviour for a Use Case is a Scenario, as are the paths that depict exception handling.
Message Sequence Charts (MSCs) show time-sequence interactions between
processes1. The processes are
represented by vertical lines with boxed labels containing the process
names at the top of each line, and the interactions, which can be thought
of as messages or events, are shown with horizontal lines. The sending
side of a message has no arrow and the receiving side of a message has an
arrow. Time progresses in a downward direction.
Figure 1 is an example MSC from
telephony application.

In this example a switch is controlling two lines and the MSC begins at the point where line_1 is accepting an incoming call initiated by line_2, by sending an `answer' message to the switch. The switch in turn sends notification to line_2 that the call has been accepted by line_1 by sending an `answer' message. Line_1 suspends the call via a `suspend' message, and the switch waits without notifying line_2 in case line_1 decides to resume. Line_1 resumes the call by sending a `resume' message and then information is transferred; represented as the `talk' message.
A graphical MSC depicts a visual order for message sends and receives. For instance, since time progresses downwards, from a visual inspection of the MSC in Figure 1 it is assumed that line_2 receives the `answer' message before the `talk' message. However, whether line_2 must always receive the answer message before the `talk' message depends on the queue semantics that are assumed for message sends and receives. Later on we will discuss how to check for such inconsistencies, which we refer to as race conditions, and how to change queue semantics.
An MSC can be thought of as a Scenario fragment. That is, a small MSC with no conditional branching. MSCs are combined to form Use Cases. Paths selected through Use Cases are Scenarios.
return to the Table of Contents
Use Cases are depicted by directed graphs in uBET. The Use Case Editor (UCE) interface provides a means for defining these graphs. uBET directed graphs may have start and stop nodes. Nodes are connected by edges which are depicted as arrows. Each node represents either an underlying MSC or another graph (a sub-graph or sub-Use Case).
Scenarios are represented as a single path through a Use Case. We'll look at how Scenarios are selected and some uses for them later in this tutorial.
MSCs, such as the one shown in Figure 1, are created via the Message Sequence Editor (MSE) interface of uBET. MSCs in uBET are stored in `.itu' files in the ITU Z.120 standard (MSC'92) form[1].
Figure 2 shows the relationship
between Use Cases, Scenarios and MSCs. If it's not clear from this
description, then it will be become clearer when we build an example using
these concepts.

The graph on the right side of Figure 2 is a Use Case that represents a Withdrawal. There are three possible Scenarios in this Use Case. One of these Scenarios, the case where the amount requested does not exceed the amount available for withdrawal from the account and does not exceed the amount of cash in the ATM machine, is highlighted in bold lines. In another Scenario, which is not highlighted, the amount requested exceeds the amount available for withdrawal from the account and the customer is prompted to retry. In a third Scenario, the amounted requested exceeds the cash reserves of the ATM machine, and an "Out of Order" status message is displayed on the ATM interface. Each node may be linked to another graph object (a sub-Use Case) or to an MSC. In this example the `requestWithdrawal' node the `verifyAmount' node, and the `dispense' nodes are linked to MSCs which show interactions between the participating entities involved in this Use Case. Each MSC is non-branching, but by selecting a path (Scenario) through the Use Case, a longer MSC representation of the Scenario can be created, as shown in Figure 2.
return to the Table of Contents
Since the automatic teller application is overused, we will use another
familiar interactive system. Our example will be a system that receives
and fills orders for packaged software. The processes
participating in this system are represented by the
Figure 3. A brief description of the
purpose of the process is included in each box.

The boxes could be departments in the company, if the system is not
automated, or they could be software modules or objects if the application
is automated. The presence of lines between the boxes indicate that
communication, in the form of messages, occurs between the connected
boxes. If the lines are labelled with text describing the type of
communication occurring, then this diagram could be thought of as an OO
entity relationship diagram. At any rate, drawing such a diagram is a good
place to start because it shows the context for the application being
described and the players in the application. The Customer and
Customer Lawyer, which are shaded gray is the only components
outside of this System.
return to the Table of
Contents
Selection
When the instructions use the term `select' you should left button-click the object specified (if you have a right-handed mouse, other-wise you should right button-click for `select').
Opening Menus
When the instructions use the phrase `open the menu' you should right button-click on the object mentioned in order to open the menu for that object (this assumes that you are using a right-handed mouse; if you aren't then you should left click to open the menu).
Buttons
The names of buttons on the MSE and UCE interfaces are underlined in the text. For instance "press +Proc" is a reference to the button labelled "+Proc" on the MSE interface.
return to the Table of Contents
Presumably, you've already installed uBET on your machine. If not, you will need to download the Windows 95 version of the uBET Release 2.0 software from our WEB site and install it on your PC.
Select the `Start' button and then select the uBET entry on the start-up menu. Three items appear on the submenu for uBET. Select the entry labelled `UCE'. This will start the UCE tool.
return to the Table of Contents
You will be building Use Cases and MSCs from scratch as part of this tutorial. However, since we need a large number of these to show all the capabilities of uBET, you will use some already prepared Use Case and MSC files that came with your uBET software distribution.
These files are in three sub-directories under the directory named
`tutorial' as shown. For instance, if you chose the default directory for
your uBET installation these files will be located as shown in
Figure 4:

The design directory contains `.itu' files (MSCs) and `.ucg' files (Use Cases). The docs directory contains MSword documents that contain enumerated requirements that we will link to the MSCs and Use Cases. The model directory contains the output of an ObjecTime model of the Software Ordering System that will be used later to populate name fields. Using ObjecTime model output to populate name fields is optional. Free-form naming is supported, however, if the system design is being modelled using the ObjecTime tool, it may be preferable to use actor and message names consistent with the design model under development.
To keep an unaltered copy of the original tutorial distribution (since you will be modifying the contents of the files under the tutorial directory), you will need to create a new directory on your machine and copy the tutorial directory and its sub-directories to that new directory.
So that uBET will know which directories you want to save and retrieve files from during this tutorial, we will set the working directories as follows:
On UCE tool interface, select File->Preferences to open the Preference Dialogue.
Set MP_DESIGNS to the copy you made of the design directory. You may use Browse... to find this directory. When using Browse... to find a directory you must actually select a file within the desired directory in order to the directory name and path to be copied to the MP_DESIGNS field.
Set MP_MODEL to the copy you made of the model directory, using Browse... if you prefer.
Set MP_DOCS to the copy you made of the docs directory, using Browse... if you prefer.
return to the Table of Contents
There are many possible ways to start thinking about the application to be described. For many problems it's sensible to start out with the case where the feature to be described is functioning as desired; the case where everything goes well -- all resources required are available, messages sent are also received and are error free, and all processes involved respond to requests as anticipated and in a timely manner. This is what we define as the `sunny day' case or `sunny day' Scenario. It is a non-branching path through the larger, branching Use Case. It's a good place to start for many problems and that's how we'll proceed for this example.
Let's assume that our first impressions of this application are that it is a two phase process. Potential customers inquire about the company's software products, and the System responds by sending them literature. After reviewing the literature, the customer makes a request to purchase the software and the company responds by shipping the software to the customer then sending a bill to the customer. We can build an MSC that captures these early thoughts about the interactions for this sunny day Scenario. To do this, start up the uBET's MSE tool as follows:
Select: Start->Programs->uBET->MSE
The MSE interface will appear. Create five processes by clicking +Proc five times. We will name these processes according to the names we gave our components in the box diagram.
To name the processes, you need to open the menu for each process and
then select the menu item `Properties' to open the Properties sheet for
the process. Move your mouse over the text label in a process box, hold
down the menu button until the menu appears. Drag the cursor over the
`Properties' item on the menu so that it highlights, then release the menu
button. The properties window will appear. In the Label: field,
replace the text with `Customer', then press return or select OK. Continue
naming the processes until they are named as follows:

We'll add some events between the components. The first event is the customer's request for literature on our software products. This request is made to the Dispatcher.
Select + Msg. The cursor will change to a
.
Position the cursor over vertical process bar labelled `Customer'. Select
and hold down while moving the cursor to the right until it is positioned
over the vertical process bar labelled `Dispatcher'. Release the left
button. A red message arrow will appear.
We'll name the event we just added.
Move the cursor over the message label then hold down the right mouse
button until the menu appears. Position the cursor over the Properties
item on the menu so that it highlights, then release the right mouse
button. The properties window will appear. Enter the message name
`requestLiterature' in the Label: field, then press return or click OK.
Note that spaces are allowed in message or process names, and you can set
your preferences (File->Preferences) to allow spaces, however, we don't
recommend this practice since the standards don't allow it. The message
name will appear on the message we just added. Continue adding messages
and labelling them until your MSC looks as follows:

Save your work. Select File->Save and enter the file name `sunnyDay' in the file name field. By default, this file will be saved as an `itu' type file which means that it can be reread and displayed by MSE at a later time. The `.itu' extension is added automatically so you don't need to specify it as part of the file name.
return to the Table of Contents
Let's consider this MSC to see if we have left anything out and to see whether there may be points in the MSC at which conditional branching should occur. For instance, after the fourth message, `shipLiterature', the Customer may want to see a presentation or try out an evaluation copy of the software. The customer may want to negotiate price if a large volume of licenses is being purchased and legal representatives may need to get involved to work out a contract. These are things we didn't think of previously but that we may want to capture in our Use Case. Also, at any point in the process of considering placing an order the customer may decide against the idea and exit the Use Case.
Let's assume that the order of these additional activities in the context of the `inquiry', and `order' activities we already considered is: Inquiry, Presentation, Evaluation, Negotiate, Order. The Customer may still progress directly from Inquiry to Order, or from Presentation to Negotiate, or other combinations. We can now use UCE to capture our mental model of how these interactions relate.
Select Start->Programs->uBET->UCE
The uBET UCE interface will appear. Select +Node and the cursor will
turn into a
. Move
the cursor into the white drawing space, then left click at a spot where
you would like to place a node. The node will be automatically labelled,
but you can change it by editing the Label: field on the node's property
sheet. The property sheet is opened in the same way as it is opened in
MSE. Change the node's name to `Inquiry'. Now add four other nodes to
represent the other activities that we discovered for this Use Case.
Assign each a different name: `Presentation', `Eval,' `Negotiate,' and
`Order'. If you don't like the placement of the nodes they can be moved by
positioning the cursor over the node to be moved (make sure +Edit is
highlighted first). Select/hold-down and move the node to where you want
to place it, then release the button. To have the nodes automatically
arranged by uBET's underlying graph layout program select Redraw. Note
also that a manually rendered graph layout does not persist between
editing sessions of a UCE graph. The graph layout program will
automatically position the nodes when a `.ucg' file is opened in UCE. The
`redraw' capability becomes more important as graphs become complex
because it creates clean layouts for very complex graphs by minimizing
line intersections.
Now we will add edges to represent conditional branching.
Select +Edge. The cursor will change to a
.
Position the cursor over the `Inquiry' node. Select the `Inquiry' node on
the text label or outline. The `Inquiry' node will be red filled to show
that it has been selected. Select the `Presentation' node. An edge will be
created between these two nodes.
An MSC (file ending in `.itu'), or a sub-Use Case (file ending in `.ucg') can be linked to a node. Let's link an MSC to the `Presentation' Node. The MSC we'll link is one that came with the tutorial as part of the software distribution.
Move the cursor over the `Presentation' node. Open the `Properties' sheet (to do this right button-click/hold down while the cursor is positioned over the `Presentation' node). Select Browse next to the `MSC Link' field. Double-select the file named `Presentation' within the `tutorial' directory. This file name and the full path to it will be copied to the `MSC Link' field. Select OK, and the `Properties' sheet will be closed. Notice that the presentation node's outline is now blue to indicate that this node is linked to an MSC.
You can open the linked MSC from the `Properties' sheet of a node, or from the UCE.
Open the Properties sheet for the `Presentation' node and move the
cursor until the menu item `Edit file presentation.itu' is highlighted.
Release the mouse button. The MSE tool window will open and the
`presentation.itu' MSC will be displayed. Select File->Exit to close
the MSC and MSE tool window.
Edges can be labelled. Edge labels can be thought of as `global conditions'; labels that describe the overall state, across all processes, of the interaction we are describing via the Use Case. For this example the edge labels would describe the state of the interaction with the Customer.
Position the cursor of the edge label for the edge between `Inquiry'
node and `Presentation' node (a default edge label is always generated by
UCE when the edge is created). Open the Properties sheet for the edge.
Enter in the text `Req_Present' in the Label field, then press the return
key or select OK to confirm the change and close the properties window.
The text of all labels in the Use Case can be shown or hidden by toggling
+Text.
A Use Case (graph) that is perhaps becoming too complex can be
decomposed into a parent graph with an arbitrary number of levels of
subtending sub-Use Cases (sub-graphs). For our Software Ordering System,
the Use Case decomposition is shown in Figure
7:

In the decomposition of the `Customer' Use Case, shown in Figure 7: the ovals represent graphs (Use Cases or sub-Use Cases) and the rectangles represent MSC fragments.
We will now link a sub-Use Case to a node.
Open the `Properties' sheet for the `Eval' node. Select Browse next to the Subgraph File field. Double-select the file named `evaluation.ucg' within the `tutorial' directory. This file name and the full path to it will be copied to the Subgraph Link:' field. Select OK, and the Properties sheet will be closed. Notice that the `Eval' node's fill is now yellow to indicate that this node is linked to a sub-Use Case (sub-graph).
You can open the linked sub-Use Case (sub-graph) from the `Properties' sheet of a node, or directly from the node's menu.
To open the linked sub-Use Case from the UCE interface, open the menu
for the `Eval' node and move the cursor until the menu item `Edit
C:\Program Files\LT\uBET\tutorial\design\evaluation.ucg' is highlighted.
Release the mouse button. A new UCE tool window will open and the
`evaluation.ucg' sub-Use Case will be displayed. Note that this sub-Use
Case has a start node, named `MP_START' and an end node, named `MP_STOP'.
All graphs that will be linked to parent graphs must have start and end
nodes. Start nodes are created by selecting +Start and end nodes are
created by selecting +End. Use File->Exit to close the MSC and the MSE
tool window.
The contents of a sub-Use Case can be viewed in the context of the parent Use Case by using the `inlining' capability of uBET. We'll `inline' the `evaluation.umg' sub-Use Case within the parent Use Case we are building.
Open the Menu for the `Eval' node and move the cursor until the menu item `inline evaluation.ucg' is highlighted. Release the mouse button. After a second or two the contents of the sub-Use Case `evaluation.ucg' will be shown in the context of the parent Use Case.
The nodes from the sub-Use Case are shown in a different color to differentiate them from the nodes of the parent Use Case. Up to ten different colors are supported allowing ten different sub-Use Cases to be discriminated between when `inlined' with the parent Use Case. Note that when the sub-Use Case is `inlined' within the parent, the MP_START nodes and MP_END nodes are omitted. This is because the purpose of these nodes in sub-Use Cases is to enable UCE to link the nodes within a sub-Use Case to the appropriate parent Use Case nodes when `inlining'.
Note that nodes that have linked sub-Use Cases are filled with yellow, nodes that have linked MSCs are outlined in blue, and nodes that have no links as yet are outlined in black. Also, if you move the cursor over a node that has a linked object, the file name containing and full path to the linked object will be displayed on the screen.
At this juncture you may continue building the parent Use Case to get
more practice with constructing Use Cases using UCE, or you may open the
completed parent Use Case to experiment with some other features of the
uBET tool. If you choose to continue building the parent Use Case,
Figure 8 should serve as a guide for
how to complete the Use Case. If you choose to forego practising Use Case
construction at this point, then move on to Section
9.

return to the Table of Contents
We'll save and close the parent Use Case we were building.
Select File->Save and enter the file name `practice', or any file name unique to the tutorial directory. Click OK.
We'll now open the completed parent Use Case, called `customer' for the Software Ordering system.
Select File->Open and select the `.ucg' file named `customer.ucg'.
The nodes in this Use Case either have linked MSCs (denoted by blue outlines) or linked sub-Use Cases (denoted by yellow filling). We are now going to select a Scenario by selecting a path through the Use Case. Selecting a Scenario generates a single non-branching MSC from all the smaller MSC fragments linked to individual nodes.
Let's assume that we are not interested in any scenarios that include `time-out' conditions. Note that the parent Use Case contains some edges that are labelled `timeout'. We can de-emphasize this part of the Use Case and thereby emphasize the remainder of the Use Case that we are interested in.
Open the Properties sheet for any of the edges labelled `timeout'. Select Hide all these then OK.
There are two ways of selecting Scenarios (paths). You can invoke a `shortest path' selection between any two nodes.
Select the 'Define Scenarios' button. Select the text label within the node `Inquiry' and then select the text label within the node `Support'. The shortest path between these to nodes (the path with the least intervening nodes) will be selected and highlighted in green.
You can also manually select a Scenario.
Select the 'Define Scenarios' button. Select the node `Inquiry' then 'Presentation' then 'Order' then 'Support'. The path you've selected will be highlighted in green.
You can save and name this Scenario. Select the 'Scenarios' Menu button, and then select the 'Create Scenarios' menu item. In the 'Scenario Name' field, type the name 'Typical Customer', then click the 'Create' button. Double click the white background of the drawing area to clear the Typical Customer scenario. To redisplay the Typical Customer scenario, click Scenarios->Display Scenario... and double-click the name of the scenario.
Converting the Scenario to a long MSC:
We'll generate an MSC representation of the Scenario we just selected and named.
With the path still highlighted in green, select Scenario->MSC. An MSE window will be opened and a single longer MSC will be shown which is a concatenation of all the MSCs in sequence along the path you selected. Note that boxes containing text appear intermittently in this longer MSC. These denote the end of an MSC fragment and were added manually to show where MSC fragments start and end when MSCs are displayed in the context of Scenarios. We will try adding text boxes to MSCs later.
Race Conditions can be detected in MSC fragments or in Scenarios (longer MSCs constructed from MSC fragments). The methods for analyzing MSCs in general and detecting race conditions is based on work by Rajeev Alur, Gerard Holzmann, and Doron Peled and is documented in [2], [3], [4], and [5]. We'll experiment with the MSC fragment shown in Figure 1.
Using the MSE interface, select File->Open, and select the file named `call.itu'
Select Checks->Set Checking Preferences.
Under Semantics, Select the radio button next to 1 non-FIFO/process. By selecting this box we are specifying the queue semantics for send and receive events. `1 non-FIFO/process' means that each receiving process is assumed to have a single input non-FIFO queue; that is, for a receiving process, all sending processes share the same input queue and the order in which messages arrived is not considered by the receiving process in taking messages off the input queue.
Leave all the check boxes under the heading Restrictions unselected, so that all three types of race conditions will be highlighted.
The race types are:
R<->R same sender (Type 1) - races between messages with the same sender-same receiver.
R<->R different sender (Type 2) - races between messages with different senders-same receiver.
R<->S (Type 3) - races between receives and sends where the receiver and the sender are the same process.
We'll look at the race conditions for these selections.
Select Races. A new window will come up that shows the race conditions that were detected during this check. For this MSC with this choice of queue semantics, six race conditions were detected. A race condition implies that the visual order suggested by the MSC cannot be assumed to always be true due to the queue semantics in use and due to message transmission and processing delays.
Moving the cursor to the Race window, select on `Race 1'. Note that the selected race is highlighted on the MSC. In this case, since we picked queue semantics `1 non-FIFO/process', even though the `answer' message is guaranteed to have been received by process `switch' before the message `suspend' because both have the same sending process, because process `switch' uses non-FIFO rules for removing messages from queue, it cannot be assumed that the process `switch' sees `answer' before `resume'.
Now, select `Race 3' to see another type of race condition. Looking on the MSC, a race is depicted between the receipt of the `suspend' message by `switch' and the sending of the `answer' message by switch. This means that it is not always true that the `suspend' message is received after the `answer' has been sent. Actually this race condition exists for all the queue semantics choices.
Finally, select `Race 6' to see a type 2 race condition. Looking at the MSC, a race is depicted between the receipt of `answer' by line_2 and the receipt of `talk' by line_2. This implies that for the `1 non-FIFO/process' queue semantics we selected, it is not always true that line_2 receives `answer' before it receives `talk', as is implied by the MSC.
After looking at each race condition, if you decide that you don't care about certain race conditions you can place them in coregions so that they are to be ignored in future checks. We will now enclose the receives of `suspend' and `answer' in a coregion in order to document that we don't care that it is not always true that switch sends `answer' before `suspend' is received.
Select Edit->Add Coregion. The cursor will change to a
.
Move the cursor to a position just above the `answer' message, and just to
the left of the `switch' process. Select/hold-down the left mouse button
and drag a box to just under the `suspend message'. A red box indicates
that the coregion has been defined to contain these two receives.
Now when you perform a check this race condition will not be flagged.
There are four types of queue semantics to choose from in MSE. The names appear on the Check Parameters Window (accessed via Checks->Set Checking Parameters) and can be described as follows:
1 FIFO/process - each receiving process has one queue and the receiving process uses FIFO rules for removing messages from that queue.
1 FIFO/source - each receiving process has one queue per sending process and all the input queues use FIFO rules for removing messages.
1 non-FIFO/process - each receiving process has one queue and the receiving process uses non-FIFO rules for removing messages from that queue.
1 non-FIFO/source - each receiving process has one queue per sending
process and all the input queues use non-FIFO rules for removing message
from those queues.
Another aid to understanding the temporal relationship of messages is to view the messages that are guaranteed to have been sent and received before a given message or after a given message. Let's try that.
Reopen the `Checking Parameters' Window by selecting Check->Set Checking Parameters. Select the diamond shaped box next to Show Related Events. Moving the MSE interface, open the menu for the second `answer' message; the message that originates at the `switch' process and terminates at the `line_2 process. A short menu will pop up. Select Show Predecessors/Successors. Make sure that you click the arrow in a spot that is not below the message label, otherwise the message label menu will be brought up.
You will see that the selected message has a red box superimposed over its send side, a green box shape is superimposed over the other `answer' message on the send side, and a green circle shape is superimposed over the receive side of the other `answer message. This is interpreted to mean that both the `send' and the `receive' of the first answer message is guaranteed to have occurred before `send' and `receive' of the second answer message, for the currently selected queue semantics. If there were any related message sends or receives following the second message, this would be highlighted in yellow.
You can also view the message sends and receives that are unrelated to the message in question.
On the `Checking Parameters' Window, select the radio button next to Show Unrelated Events. Moving the MSE window, open the menu for the second `answer' message; the message that originates at the `switch' process and terminates at the `line_2' process.
Again, the selected message is highlighted with red. All unrelated message sends and receives, both before and after the second `answer' message, are highlighted in green. Since the first `answer' message is a related message, its sends and receives are not highlighted.
You can experiment more with the checking capabilities of MSE using other .itu files delivered with the tutorial or in the `examples' directory or by building some .itu files yourself. Try different queue semantics and look at the race conditions that are found.
return to the Table of Contents
Graphical objects within MSE and UCE can be hypertext linked to objects in MSword documents. MSword `bookmarks' are used within the MSword target document as anchors for the hypertext links. This uBET capability makes it possible to link a MSE process, such as `shipping' to a document that describes the requirements, architecture or interfaces of the `Shipping' component.
Links from text boxes on process lines within MSCs can be used to link
to the associated temporal (event-driven) requirement that applies upon
reception of a message. For instance, in the `order.itu' file depicted in
Figure 9. We may want to link the
receipt of a message such as `shipRequest' to a text requirement.
Figure 9 depicts 3 such requirements
links related to message receives.

Some example requirements documents in MSword are in the tutorial directory you received with the software. We'll create the hypertext links to the enumerated requirements in those documents. Open the `order.itu' file in MSE.
Select +Text and the cursor turns into a
.
Move the cursor to the `Shipping' process line, just below the receipt of
`shipRequest'. Select on the process line at that position. A rectangular
text box will appear. Open the Properties sheet for the text box.
In the Text: field enter the string `Shipping methods depend on volume'. This is a summary of the more detailed requirement in the MSword document and serves as a reminder.
Under the Reference Tags and Associated Documents, select New. The Create New Reference Tag window will open.
Select Browse next to the Doc: field. Double select the file `billingReq.doc'. The file name and path will be copied into the Doc: field.
In the Tag: field type in `Billing_Rel1_0100', then select Create.
Now when you move the cursor over the text box in the MSC, the link pops up.
Open the menu for the link and move the mouse until the Open References menu item is highlighted. Move the mouse to the right so that the references (just one in this case) are displayed. Release the mouse button when the cursor is positioned over the desired reference. MSword (must be Office 96 Version for the present), if installed on your system, will be opened and the cursor will be positioned on the requirement labelled `Billing_Rel1_0100'.
The anchors in the MSword document that uBET uses for hyperlinking are
MSword `bookmarks'. To create the bookmark for requirement
`Billing_Rel1_0100' a bookmark of the same name was created at the site of
the requirement label in the `billingReq.doc' file. MSword online help
provides instructions on how to add, modify, delete, and view bookmarks.
return to the Table of Contents
(This section should be skipped if you do not intend to use the ObjecTime tool.2)
The linear form model produced by ObjecTime Release 4.4 may optionally be imported into uBET. uBET analyzes the linear form models then uses the extracted actor names, actor hierarchy, port, binding and protocol definitions to populate uBET's menus of label names for processes (i.e. actors in ObjecTime) and messages. ObjecTime model names are only used if the MP_MODEL preference is set. Recall that we set this preference back in Section 6 so that MP_MODEL is set to point to the file named `customer_interactions.obt'.
The box diagram shown in Figure 3 is similar to an ObjecTime model in that it shows the structural components, which are called `actors' in ObjecTime and shows connections (call `bindings' in ObjecTime) between the `actors'. In an ObjecTime model, additional information shown would include ports on `actors', conjugation of ports, and multiplicity of ports. These are not shown in Figure 3.
We will use imported actor names from an ObjecTime model to name a process in an MSC.
Open the MSC named `lostSale.itu' in the MSE interface. Open the Properties Sheet for the middle process named `Process_3'. Select OT Actors and the Actor List window will open.3 Double-Select the list item `Cl...' which is the parent class for the Software Ordering System. The `...' sequence following the class name `Cl' indicates that this class is a container class; it contains other classes. Double-Select the list item `Shipping (Shipping)' then select Done.
We will use imported message names from an ObjecTime model to name messages in an MSC.
Open the menu for the message labelled `Message_2' sent from `Sales' to `Billing'. Select ObjecTime Messages from the menu. The port-binding name-port specifications appear in the `Port List'. In this case there is only one `port-binding name-port' defined between `Sales' and `Shipping'. Double-select the port specification. The `Message List' window opens. Double-select the message named `stopShipping'.
Use the ObjecTime message name in the same way to rename `Message_7' to `contractFiled'.
If MSCs elements are named using extracted ObjecTime model information
they be re-imported back into ObjecTime where they can be compared against
run-time execution MSC traces using ObjecTime's MSC comparison utility or
they may be used as input to ObjecTime's Automated Test Harness Generator,
where the behaviour of processes that are designated as being members of
the test harness (rather than the object under test) is automatically
generated from message sends and receives specified in uBET MSCs.
return
to the Table of Contents
MSCs and Use Case Graphs can be exported as .GIF files and imported into
MSword documents, or as .MIF files for import into FrameMaker documents.
If you mainly work with MSword documents, try out the .GIF export below.
If you mainly work with FrameMaker documents, try out the .MIF export
below.
In UCE, open the `customer.ucg' file. Select File->Export, and the Export Window will pop up. Leave the File Name field as defaulted. Under Export Formats select GIF Format. Leave the Options selections as defaulted. The Show Reference Tags option (available for .GIF and Color Postscript outputs only) causes the output to include the names of reference Tags to marked requirements in MSword documents.The Postscript Font Size options only apply if you have elected Color Postscript and the Show Reference Tags option.
Open the `billingReq.doc' file in MSword. Place the insertion point underneath the heading `Use Case Overview'.
Select Insert->Picture then select Browse to find the .GIF file you
just created. Select GIF in the Convert From box.
In UCE, open the `customer.ucg' file. Select File->Export, and the Export Window will pop up. Leave the File Name field as defaulted. Under Export Formats select FrameMaker MIF Format. Leave the Options selections as defaulted. The Postscript Font Size options only apply if you exporting to Color Postscript. The show Reference Tags option causes the output to display the names of reference Tags to marked requirements in MSword documents. If you are using FrameMaker for your requirements then you are probably not using the reference Tags capability since we don't support reference tagging with hyperlinks for FrameMaker at this point in time.
Open the `billingReq.fm' file in FrameMaker. Place the insertion point underneath the heading `Use Case Overview'.
Select File->Import->File and then select the `customer.mif' file. On the bottom of the Import box, select Copy into Document. The graphic will be imported into the document within an automatically generated anchored frame. This graphic, unlike the .GIF graphic, can be edited using FrameMaker's graphics tools.
return to the Table of Contents
uBET is supported by a very small team in the PAVE organization. We exist only through the grace of Type 3 funding4 and to survive, must prove our value to Lucent by developing a strong and vocal user base. Under the current business model, efforts such as ours, even if they are adding value, cannot receive Type 3 funding indefinitely, and must eventually get financial support directly from projects within the Lucent Business Units. If you like what we've provided with these tools and if they are assisting you in accomplishing your work, we would appreciate your support, whether it be to fund us or to provide testimonials when we go to get Type 3 funding. We have modestly ambitious plans to enhance the uBET toolset and are interested in your feedback about these tools and your thoughts about new directions we could take.
Now you know enough about uBET to start capturing your own Use Cases and MSCs. Happy tooling!
Feedback on the uBET tools should be directed to: margaret@lucent.com
return to the Table of Contents
Lucent Technologies Copyright ©1998. All rights reserved.