OMG OMG-OCUP2-ADV300 OMG Certified UML Professional 2 (OCUP 2) - Advanced Level Exam Practice Test

In UML, modeling individual things (such as instances) involves making statements about them. Here are the details for each option:

• A. A UML Model can contain individual things (e.g. Instances) UML does not prescribe the level of detail to be used in the description.
• B. A UML Model can contain statements about individual things If a thing is an instance of a Classifier, these statements must be consistent (all mandatory Properties must be defined, all Constraints must be satisfied).
• C. A UML Model can contain statements about individual things These statements can be incomplete, imprecise, and abstract, but not wrong.
• D. A UML Model can contain statements about individual things. These statements can be incomplete, imprecise, abstract, may turn out to be wrong, or even be asserted as counterfactual.
• E. A UML Model can only contain statements about sets of individual things (e.g. Classifiers).

References:

• UML 2.5.1 Specification

Remember that UML is a modeling language, and its primary purpose is to capture and communicate information about systems and their components. The level of detail, precision, and correctness can vary based on the modeling context and the specific use case. Therefore, option D best reflects the UML approach to modeling individual things.

Please note that the information provided here is based on UML 2.5.1, and it’s essential to consult the official UML specification for the most accurate and up-to-date details.

The class templateListshown in the diagram fragment is a parametrized class with two template parameters:Tandn. The signature of the class template includes both of these parameters. The template parameterTrepresents a type that can be bound to a specific class when the template is instantiated, whilenrepresents an integer value that specifies the multiplicity of elements that can be contained in the list. Therefore, the signature of the class templateListis the ordered set{T, n: Integer}, which includes both the type parameterTand the integer parameternindicating the maximum number of elements the list can hold.

fUML (Foundational UML) is a subset of the standard Unified Modeling Language (UML) that includes standard, precise execution semantics. This subset encompasses typical structural modeling constructs of UML such as classes, associations, data types, and enumerations, as well as the ability to model behavior using UML activities composed from a set of primitive actions. Therefore, a model constructed in fUML is executable in the same sense as a program in a traditional programming language, but with the level of abstraction and richness of expression of a modeling language2.

In addition to ObjectFlow, which is used to denote the flow of objects between activities in a UML Activity diagram, data movement can also be facilitated through:

• A.Pin is a point on a node that is used to accept or provide objects or data, but does not move data by itself.
• B.Correct. Variables can be used to hold and move data within an activity, facilitating state maintenance or transitions between different actions.
• C.Property, while it holds data, typically pertains to classes or components, not activities.
• D.ControlFlow dictates the order of execution but does not inherently move data.

References:

• UML Specification: Activity Diagrams section.
• Details on how data can be managed within activities can be explored in the UML 2.5 Documentation, particularly under Activity and Object Nodes.

 In the context of the Meta-Object Facility (MOF), a metamodel is essentially a model that defines the structure and semantics of a modeling language. It is a set of constructs and rules that describe how models can be constructed for a particular domain or purpose. The MOF itself is an example of a metamodel because it provides the language for defining other metamodels, such as the UML metamodel1.

In the context of the diagram, "clientNo" is placed next to the association line between "ExamCompany" and "Examinee," which indicates that "clientNo" is a qualifier of the association. In UML, a qualifier is used to refine the association between two classes by providing a way to access linked objects based on some attribute value. The qualifier essentially acts as a key in an associative array or map, allowing access to instances of the associated class. In this case, "clientNo" is likely used to uniquely identify examinees associated with an exam company. This use of qualifiers is detailed in the UML 2.x Superstructure Specification, which describes how qualifiers can be used to specify refined access to linked objects within an association.

In UML, a simple State can indeed be redefined, but the specifics of how it is redefined matter:

• Ais incorrect as redefinition of States, including simple States, is permitted.
• Bis correct. A simple State can be effectively removed or altered through redefinition in a derived StateMachine, which could include changing its type or characteristics.
• Csuggests that a simple State can be turned into a composite State. While theoretically possible in the context of redefinition, this option might be considered a significant alteration that could be misleading without additional context.
• Dis incorrect; UML does support State Redefinition.

References:

• UML Specification, particularly the sections on Redefinition and StateMachines.
• Detailed rules on state redefinition are outlined in the UML 2.5 Documentation, specifically under StateMachine specializations.

UML allows the introduction of new concepts that are not part of the standard UML metamodel by creating a profile. To add capabilities for modeling requirements and tracing relationships in UML, a profile can be created where a Class is stereotyped to represent a requirement, and a Dependency is stereotyped to represent the trace relationship. This approach is both practical and conforms to the UML standard's mechanisms for extending the language. It is a common practice to create such profiles for requirements engineering within the UML framework. This conforms to the UML 2 Superstructure Specification, which provides guidelines on creating and applying profiles and stereotypes.

A stereotype in UML is a powerful extension mechanism that allows developers to tailor UML models for particular domains or platforms. Stereotypes can adapt UML model elements by adding constraints, changing notation, and adding attributes and operations. However, they cannot remove existing constraints from a model element12.

• Notation Change (A): Stereotypes can indeed change the notation of a model element to make it more expressive or domain-specific. For example, a stereotype could be used to visually distinguish between different kinds of classes in a class diagram1.
• Adding Constraints (B): Stereotypes can add new constraints to a model element to specify additional rules or requirements that are not defined by the standard UML1.
• Removing Constraints ©: This is not a capability of stereotypes. Constraints define rules that must be followed, and once they are part of a model element, they cannot be removed by a stereotype. Instead, they are an intrinsic part of the model’s definition1.
• Adding Attributes and Operations (D): Stereotypes can be used to add attributes and operations to a model element, which allows for the specification of additional properties or behaviors that are not part of the standard UML metamodel1.

In summary, while stereotypes are versatile and can extend the capabilities of UML model elements in various ways, they do not have the ability to remove constraints that are already applied to those elements. This is because constraints are consideredfundamental rules that govern the integrity of the model, and removing them would potentially violate the model’s correctness or completeness1.

The provided diagram fragment seems to indicate a situation involving a template. In UML, a template is a parameterizable element, and a bound element is a specific manifestation of that template wherein the parameters have been replaced with actual values or types. If 'List' is a template class, it cannot be directly used as a type. Instead, one must use a bound element of the List, meaning the template parameters of List must be bound to actual types before it can beused. For instance, if List is a template expecting a type T, then a concrete class might be List or List, where Customer or Order are actual types replacing the template parameter T. This use of templates and bound elements is according to the UML specification, which details how templates are defined and instantiated within UML models.

The term “computationally complete” in the context of fUML refers to a subset of UML that is expressive enough to define models that can be executed automatically by a computer using an execution tool. This means that the subset includes all the necessary elements and constructs to specify the behavior of a system in a way that can be understood and run by a machine without further interpretation

In UML, the{subsets}keyword is used to indicate that one property is a subset of another property. In the provided diagram fragment, the association end-b {subsets part}indicates that the propertybon classAis a subset of the propertyparton classB. This means that the elements associated withAthroughbare contained within the larger set associated withBthroughpart. This kind of relationship is typically used in more complex class models where a part-whole hierarchy is represented, and it allows the model to show that certain associations are more specific subsets of a more general association. This usage is explained in the UML 2.x Superstructure Specification, where the semantics of association subsets are defined.

In UML, the concept used to represent a model element such as a class or an activity is known as a Classifier. A Classifier in UML is a term that categorizes a group of model elements that have similar structural features, which include attributes and associations, and similar behavioral features, which include operations and methods1. The term applies not only to specific UML model elements but to all classifiers, encompassing a variety of elements such as classes, components, interfaces, and even activities1.

For instance, a class is a classifier because it describes a set of objects with similar properties (attributes), common behavior (operations), common relationships to other objects, and common semantics. An activity, which is a behavior, can also be considered a classifier because it describes a sequence of actions or flow of controland data1. Therefore, the correct answer is C. Classifier, as it is the overarching concept that includes both structural and behavioral elements within UML.

The correct answer is C, which uses a transformation edge to indicate that when an order is closed, information is transformed or processed to notify the customer. This is expressed in UML with an object flow that has a transformation property, which specifies how an object is transformed from one state to another as it flows along the edge. Thisis appropriate for a scenario where closing an order leads to the creation of a customer notice, implying some form of transformation or processing of the order information to generate the notice.

References:

• UML 2.5 Specification: The UML 2.5 specification details how object flows with transformations can be used to show that one piece of data is transformed into another as it flows from one action to another.

In UML, profiles are applied to specific model elements to adapt the UML metamodel to different domains or platforms. The provided diagram shows a UML package diagram within which the «Versioning» profile is applied to the "Business Logic" package, and the «DBProfile» is applied to the "Data" package. This is a correct use of profiles in UML as they allow the customization of parts of a model by applying additional constraints and stereotypes to specific packages or classes. There is no restriction in UML that a profile cannot be applied to multiple packages in the model simultaneously, and profiles do not necessarily need to be members of the namespace of the model they are applied to; they can be defined externally. Therefore, the scenario presented is a correct application of two different profiles to two distinct packages within the same model, conforming to the UML 2.x Superstructure Specification.

Given that the system is inStateA1, the sequence of triggers that will move the system toStateCmust take into account the transitions and their associated triggers as defined in the UML state diagram. Starting fromStateA1, the triggera5will cause a transition withinStateA, followed bya6, which moves toStateA2. The triggera5is not relevant as it is an internal transition inStateA1. Then,a3(the exit action forStateA) anda2would be followed to leaveStateAaltogether. Once out ofStateA,a1is used to transition toStateB, wherea10is an entry action, not a trigger. Finally, to get fromStateBtoStateC, the triggersa11followed bya12are needed. This sequence of triggers reflects the correct usage of exit, entry, and transition triggers as defined by UML state machine semantics.

In UML, a template is a parameterizable element, and the parameters for a template are typically classes or other classifiers. According to the UML 2.x Superstructure Specification, all subclasses of Classifier can potentially be used as template parameters. This includes classes, components, datatypes, interfaces, signals, and more. The specification provides the flexibility to define template parameters that are specialized types, allowing for powerful and reusable designs. The ability to parameterize these elements is foundational to creating generic and reusable model elements, which is a core capability of the UML's templating mechanism.

In UML, theisSubstitutableproperty of a generalization relationship indicates whether instances of the child classifier can be used wherever instances of the parent classifier are expected, that is, whether the subclass is substitutable for the superclass. When this property is set to false, it means that the child classifier cannot be substituted for the parent classifier. This property is part of the UML metamodel for generalization and affects how inheritance is interpreted in terms of substitutability, as described in the UML 2.x Superstructure Specification.

The reason for fUML to be compact is to facilitate the definition of clear semantics. A smaller, more focused subset of UML allows for a more precise and unambiguous specification of the execution semantics. This clarity is essential for ensuring that models are executed consistently and as intended across different tools and platforms2. The compact nature of fUML helps inachieving this goal by limiting the scope to the essential elements necessary for execution, thereby reducing complexity and potential for misinterpretation.

In UML, the «bind» relationship is used to specify that a class is a template instantiation of a template class, where actual parameters are bound to the formal parameters of the template class1. However, in the case of the relationship between a concrete class like Vector and an abstract class like AbstractList, the correct relationship should be Generalization, not «bind».

Generalization is a taxonomic relationship between a more general classifier and a more specific classifier. Each instance of the specific classifier is also an instance of the general classifier1. Thus, Vector being a concrete implementation of AbstractList, should inherit from AbstractList, which is correctly represented by a Generalization relationship in UML.

The other options can be evaluated as follows:

• Option A: The upper limit for the size of PhontyQueue is a design decision that should be based on the requirements and use cases of the application. It is not inherently incorrect in UML to have a specific upper limit.
• Option C: The Generalization relationship is correctly used between PriorityQueue and AbstractQueue as it represents inheritance in UML.
• Option D: While it is true that template parameters are typically defined at the top of the hierarchy, the statement is too absolute. In UML, template parameters can be added to specialized classes, but it depends on the specific design and requirements. Therefore, without additional context, this statement cannot be deemed universally valid.

In conclusion, the most applicable and valid review comment is option B, which correctly identifies the misuse of the «bind» relationship in the context of the class diagram provided.

In the given diagram,myType1is shown redefiningprop1, which was originally of typeInteger. Given thatIntegeris a subtype ofNumber, andmyType1is used in a redefinition context, it implies thatmyType1must also be a subtype ofNumber. In UML, when a property is redefined, the redefining property must be type compatible with the property it redefines. Therefore,myType1could be substituted by any subtype ofNumber, which includesInteger,Real, and all their subtypes (Short,Long,Float,Double, etc.). This is based on the UML principle of type conformance in property redefinition, as specified in the UML 2.x Superstructure Specification.

The compiled model resulting from the Action Language for Foundational UML (fUML) must have the equivalent effect as a model resulting from the mapping to fUML. In other words, the compiled model should behave in the same way as if it were directly executed using the fUML execution semantics

"QueryCustomerFromParcel" is annotated with the «transformation» stereotype, which indicates that it is a behavior element that specifies how to convert input objects into output objects. Therefore, the answer is D, a Behavior element, for example, an Activity, State Machine, or OpaqueBehavior. In UML, the «transformation» stereotype is applied to specify that an action or activity is responsible for transforming an input (in this case, "Parcel") into an output ("Customer"), typically by employing a specific behavior element.

References:

• UML 2.5 Specification: Section on Object Flows describes how transformations can be used within activity diagrams to turn inputs into outputs using behavior elements.

In UML, combined fragments are used to model complex sequence flows by grouping a set of interactions together. Each type of combined fragment has a different semantic use.

The 'assert' combined fragment specifies that the sequence of events inside the fragment must occur exactly as shown, with no deviations or alternatives. This implies that all possible valid traces in the sequence are exactly those specified within the 'assert' fragment; there are no optional or alternative flows.

References include:

• UML 2.5 Specification (formal/2017-12-05), specifically the section on Combined Fragments and their semantics.
• UML Sequence Diagrams: Overview of Graphical Notation, which discusses the purpose of different combined fragments.

The scope of fUML (Foundational UML) is to define execution semantics for a subset of the UML 2 metamodel that provides a shared foundation for higher-level UML modeling concepts. This includes the precise definition of the execution semantics of that subset, which is intended to be used by a wide range of system types, including physically distributed and concurrent systems without assumptions about global synchronization1.

In the given UML activity diagram, "action 1" is an action that executes the classifier behavior (intrinsic behavior) of an instance. The correct UML action that represents this behavior is:

• A. CallBehaviorActionis used to call a behavior directly, but not necessarily the classifier behavior of the input object.
• B. CallOperationActionis used to call an operation, which is not the intrinsic behavior of an instance.
• C. StartObjectBehaviorActionis the correct answer. This action starts the execution of the classifier behavior of an object.
• D. CallClassifierBehaviorActionis not a standard UML action.

References:

• UML Specification: Actions section, which explains the various types of actions including the StartObjectBehaviorAction.
• Further details about actions that initiate behaviors of objects can be found in the UML 2.5 Documentation, specifically in the chapters discussing Actions in Activity diagrams.

The UML diagram fragment provided shows a UML profile with a required extension from the metaclassClassto the stereotypeDisplayArea, which in turn has two subclassesFrameandForm. The use of{required}indicates that whenever an instance ofClassis extended by theDisplayAreastereotype, it becomes mandatory to do so. However, this does not enforce that every instance ofClassmust be linked toDisplayAreaor its subclasses (FrameorForm). It only means that if theDisplayAreastereotype is applied, it is required. Therefore, there is no obligation for every instance ofClassor its subclasses to be stereotyped asDisplayArea,Frame, orForm. It's also worth noting that the last option (E) could be considered true in some interpretations of UML, but given the options provided and common UML practices, option D is more accurate.