Free Practice Questions for the OMG Certification OMG-OCUP2-FOUND100 Exam (2026 Updated)

In UML 2, a class diagram is used to depict the structure of a system by showing the system's classes, their attributes, operations (or methods), and the relationships among the classes. The constraint {age > = 18} in the Person class diagram indicates a condition that must hold true for the instances of the Person class whenever they are used in the context of a BankAccount . This constraint is an invariant of the Person class that specifies the rule for the attribute age .

Now, let's consider the provided options and explain why option B is correct:

A. The preferred age to open a bank account is 18 years old or older – This statement is incorrect because the diagram does not indicate a preference; it indicates a constraint or a rule.

B. Only customers who are 18 years old or older can open a bank account – This is the correct statement. The {age > = 18} constraint next to the age attribute of the Person class signifies that any instance of Person associated with a BankAccount must be at least 18 years old. Since Person is connected to BankAccount with the role name customer , this implies that only persons who are at least 18 can be customers of a bank account.

C. The age condition should only hold when the setAge(Integer) function is called – This statement is incorrect because the constraint {age > = 18} is not a condition that applies only when the setAge operation is invoked. Instead, it is a class invariant that must always hold true for any instance of Person .

D. An object of Customer with age set to 18 or greater will raise an exception – This is incorrect because the UML diagram specifies a constraint, not an exception condition. The constraint ensures validity, not the raising of an exception.

The answer is verified according to the UML 2 Foundation documents, such as the UML 2.5 specification, where class diagrams and constraints are defined. The specification states that constraints are semantic conditions or restrictions expressed in natural language text or in a machine-readable language that must hold true for the system being modeled (UML 2.5 specification, section 7.9).

In the context of a UML (Unified Modeling Language) model, the class named 'Employee' represents a template for all entities that are classified as employees within the business enterprise model. Therefore, the correct answer is:

B. The set of all employees of the company

The term 'Employee' in the class diagram is a UML Class, which is defined as a description of a set of objects that share the same attributes, operations, relationships, and semantics (UML 2.5 specification, section 9.2). A class in UML is a blueprint from which individual objects (instances of the class) are created. It is not a representation of any single employee, an anonymous employee, or a diagram of an employee, but rather the conceptual model that defines the properties and behaviors of all employee instances in the domain being modeled.

Modeling as part of the software analysis and design process offers several advantages, one of the primary being the reduction in the risk of inconsistent or improper implementations. By using models, developers can visualize the structure and behavior of the system before actual coding begins, allowing for the identification and correction of potential issues in the early stages of development. This practice helps ensure that all components of the software work together as intended, reducing the likelihood of bugs and inconsistencies that could arise if parts of the system were developed in isolation. UML, as a standardized modeling language, provides a coherent and universally understood set of diagrams and symbols, which facilitates clear communication among team members and stakeholders, further mitigating the risk of misunderstandings that could lead to improper implementations.

In the given UML package diagram fragment, various elements are listed with stereotypes indicating their nature («class», «interface»). Stereotypes are used in UML to extend the vocabulary of UML in order to create new kinds of building blocks. They are typically enclosed in guillemets (« »).

The last element, 'six', does not have a stereotype indicating whether it's a class, interface, or some other kind of element. This lack of a stereotype leads to ambiguity about the nature of 'six'. Therefore, the fragment is considered invalid due to this omission.

All the other options do not constitute an error in the UML fragment: A) A list of elements is allowed in a package body. B) Visibility is not required for every element, especially within package diagrams. C) Interfaces are allowed in packages. D) Private elements are allowed in a package. E) Protected elements are also allowed in a package.

Therefore, the correct answer is:

F. Element six is missing its stereotype.

The diagram fragment shows an instance specification for an Employee . The different prefixes before each attribute indicate the visibility of that attribute:

+ Public: Visible to everyone.

- Private: Visible only within the defining class.

# Protected: Visible to subclasses and package.

~ Package: Visible to all classes within the same package.

Given these visibility indicators, the attribute with the private visibility is -salary: Real . This means that the salary attribute is the one that is hidden outside of the current:Employee classifier and cannot be accessed by entities that do not belong to the Employee class.

Therefore, the correct answer is:

C. salary

In the UML diagram given, we see two classes, ClassA and ClassB , with ClassB inheriting from ClassA . ClassA has two attributes, position of type Integer and description of type String . ClassB introduces an additional attribute, version of type Real .

Looking at the instance specifications (the right part of the diagram), we have three instances: a1 of type ClassA , b1 of type ClassB , and b2 also of type ClassB .

In UML, an instance specification must comply with the structure of its classifier, which means an instance of ClassA must show slots for both position and description , whereas an instance of ClassB must show slots for position , description , and version .

In the provided diagram, instance a1 of ClassA only shows a slot for position . This is an error because it does not show a slot for description , which is a defined attribute of ClassA . To correct this error, we would need to add a description slot to a1 .

This means that the correct answer is:

B. Add a description slot to a1.

The other options do not correct the error in the model:

A) Specifying unique values for position does not address the missing description slot in a1 . C) Changing the type of ClassB.version from Real to Integer is not required by any UML constraint in the context given. D) Changing the type of ClassA.position from Integer to Real does not address the missing description slot in a1 and is unrelated to the inheritance structure.

The provided image depicts a block diagram with a signal, decisions, and actions. Here's a breakdown of the elements and why answer choice A is the most accurate:

Signal:  Represented by a vertical arrow labeled "Signal", indicating an external stimulus that triggers the process.

Decision Diamond labeled "x > 0":  This diamond represents a decision point based on the condition "x greater than 0". The flow splits into two paths based on whether the condition is True (Yes) or False (No).

Paths from the Decision:

The True (Yes) path leads to an action labeled "a".

The False (No) path leads to an action labeled "b".

Action c:  This action is positioned below the decision diamond.

Analysis of Action c's Execution:

Upon receiving a Signal, the decision point is evaluated.

Depending on the value of x:

If x is greater than 0 (True path), action "a" is executed.

If x is not greater than 0 (False path), action "b" is executed.

In either case (True or False), after the corresponding action (a or b) finishes, action "c" is then executed once.

Other Answer Choices Analysis:

B. Two or more Signals must be received...  The diagram suggests execution upon receiving one Signal.

C. Action c will get executed twice...  The diagram indicates c executes only once after either a or b.

D. Nothing can be said...  The diagram conveys a clear sequence of actions based on the signal and the decision.

UML 2 Foundation concepts for activity diagrams, there are three valid action notations shown. Here's a breakdown of the elements and why answer D is the most accurate:

The diagram displays an activity diagram with a main flow and a fork followed by a join.

Main Flow:  This starts with an action labeled "Fill Order".

Fork:  The path splits into two branches after "Fill Order".

Branch 1:  This branch leads to an action labeled "Print Paycheck".

Branch 2:  This branch leads to an action labeled "Send Invoice".

Join:  The two branches converge into a join element.

Following the Join:  An action labeled "End" is present after the join.

Explanation for Valid Actions:

Fill Order:  This clearly represents an action within the activity diagram.

Print Paycheck:  This is another valid action on a separate branch.

Send Invoice:  Similarly, this is an action on the other branch.

Explanation for Why Other Options are Incorrect:

A. 0:  There are clearly multiple actions depicted in the diagram.

B. 1:  There are more than one valid action shown.

C. 2:  While there are actions before the fork, there's also a valid action ("End") after the join.

E. 4:  Counting the join element as an action results in an overcount. Joins represent control flow elements to synchronize multiple paths, not actions themselves.

References

UML 2.5.1 Specification (Superstructure) : Sections on Activity Diagrams and Actions  https://www.omg.org/spec/UML/2.5.1/

The image depicts a state machine with the following states:

S1

S11

S2

S21

The state machine transitions are labeled as follows:

gxSH - This triggers the transition from the initial state to S1.

E - This event triggers the transition from S11 to S21.

exS1 - This signifies exiting state S1.

exS11 - This signifies exiting state S11.

entS2 - This signifies entering state S2.

entS21 - This signifies entering state S21.

actnE - This indicates an action associated with the E event.

Given the state machine is currently in state S11 and an event of type E occurs, here's the sequence of behavior executions:

actnE : The action associated with event E is executed.

exS11 : The state machine exits state S11.

exS1 : Since S11 is nested within S1, exiting S11 also implicitly triggers exiting S1.

entS2 : The state machine enters state S2.

entS21 : The state machine enters the nested state S21.

Justification for excluding other options:

Option A (actnE; exS1; exS11: entS21; entS2) has the order of entering S2 and S21 reversed.

Option C (exS11; actnE; entS2) omits the execution of the action associated with event E.

Option D (gxSH; exS1; actnE; entS2) includes the irrelevant initial transition trigger (gxSH).

Option E (exS11; exS1; actnE; entS2; entS21) has an extra exiting of state S1, which is not part of the valid transition path.

Following the state transitions and action triggers depicted in the state machine diagram, option B accurately reflects the sequence of behaviors that occur when event E triggers a transition from state S11.

An event occurrence in a UML Sequence Diagram refers to specific points in time where messages are sent or received. Each message send and each message receipt is counted as one event occurrence.

In the provided diagram for InteractionP, we have the following event occurrences:

The send event of m1() .

The receive event of m1() by :Two .

The send event of m2() .

The receive event of m2() by :One .

Counting these, we see that there are a total of 4 event occurrences specified in InteractionP.

Therefore, the correct answer is:

C. 4

In UML class diagrams, relationships between classes are represented in a number of different ways, including generalization, association, and composition.

Looking at the provided options, let's analyze each one:

A. responsiblePerson inherits from Person – This is incorrect because the responsiblePerson is an attribute of the Task class, not a class itself, so it cannot inherit from Person .

B. Client and Manager have nothing in common – This is incorrect because both Client and Manager are specialized types of Person as indicated by the generalization arrows pointing to Person .

C. responsiblePerson can not refer to an object of class Client – This is incorrect. responsiblePerson is typed by Person , which means that it can refer to an instance of any subclass of Person , including Client .

D. The object referred to as responsiblePerson can be a Manager – This is correct. Since responsiblePerson is an attribute of the Task class with the type Person , and Manager is a subclass of Person , responsiblePerson can indeed refer to an instance of Manager .

The correct answer is based on the UML 2 Foundation specification that describes how attributes are typed by classes and can refer to instances of these classes or their subclasses (UML 2.5 specification, sections 9.3.3 and 9.5.3). The generalization relationship (represented by a triangle followed by a line) establishes a hierarchy between a more general element and a more specific element, which in this case means that Client and Manager are both specific types of Person and can be used wherever Person is expected (UML 2.5 specification, section 9.4.5).

A key characteristic that should apply to any useful model, including those created with UML, is that it abstracts away irrelevant details. This abstraction is crucial for managing complexity by focusing on the essential aspects of the system that are relevant to the current perspective or analysis task. By removing unnecessary information, the model remains understandable and manageable, even as the underlying system grows in complexity. This principle helps maintain a clear and concise representation of the system, enabling stakeholders to focus on strategic decisions without being overwhelmed by details.

An execution occurrence specification in UML sequence diagrams is represented by a thin rectangle on a lifeline. It shows that an instance is performing an action over a period of time.

In the provided sequence diagram, we can see three such thin rectangles on lifeline 'b', which indicates that there are three execution occurrence specifications.

One for the message that comes from 'a' to 'b'.

Another one for the message that 'b' sends to 'c'.

And the last one for the return message from 'c' to 'b'.

There are no execution occurrence specifications on lifelines 'a' and 'c'.

Therefore, the correct answer is:

D. 3

The second diagram fragment you provided includes two enumeration types, YesNo and Answer, where YesNo is a generalization of Answer. The class Query has an attribute 'response' of type Answer. Given that YesNo is a generalization of Answer, the possible values for 'response' include the literals of Answer plus those inherited from YesNo. Since Answer includes 'Maybe', and YesNo includes 'Yes' and 'No', all three are valid values for 'response'.

References:

UML 2.x Superstructure Specification: Discusses attributes and their types, the concept of generalization, and how attributes of a generalized type can take on values from their own literals as well as those from their parent in the hierarchy.

UML 2.x Infrastructure Specification: Explains the foundational modeling constructs related to enumeration, classes, and attributes, which provides the basis for determining the legal values of an attribute based on its type's enumeration literals.

The sequence diagram provided shows two messages being sent: m2() and m1() . The vertical placement of messages on a sequence diagram typically indicates the order of message passing; however, if there is no horizontal line connecting the lifelines or an explicit ordering constraint provided, it suggests that the messages are asynchronous and there is no specified order between them.

In this diagram, there is no horizontal line connecting the lifelines for o2 and o3 , nor is there any other notation that would imply a strict ordering. This means that the messages m2() and m1() can occur in any order, and the interaction is still considered valid.

Therefore, the correct answer is:

C. An execution of InteractionF can be valid no matter the order in which o2 and o3 receive their respective messages.

In UML Use Case diagrams, there are specific relationships that are valid between actors and use cases, as well as between the use cases themselves:

Associations between actors and use cases indicate that an actor participates in the use case. It is depicted as a solid line.

Includes are dependencies that specify that one use case (the base) includes the behavior of another use case (the included). It is depicted with a dashed arrow with the stereotype «include».

Extends are dependencies where one use case (the extension) conditionally adds to the behavior of another use case (the base). It is depicted with a dashed arrow with the stereotype «extend».

Let's analyze the provided options:

A) This diagram shows simple associations between actors and use cases, which is a valid relationship in UML use case diagrams.

B) This diagram attempts to use include relationships directly between actors and use cases, which is not correct. The «include» relationship is used between use cases, not between an actor and a use case.

C) This diagram shows a solid line arrow from one use case to another, which is not a recognized relationship in UML use case diagrams.

D) This diagram attempts to use extend relationships directly between actors and use cases, which is not correct. The «extend» relationship is used between use cases, not between an actor and a use case.

Therefore, the only diagram that contains only valid relationships according to UML standards is Option A.

In UML, a behavioral feature is a feature of a classifier that specifies an aspect of the behavior of its instances. A behavioral feature is implemented (realized) by a method. Operations are a kind of behavioral feature; they are the specifications of transformations or queries that can be requested from an object of the classifier.

Here's why the other options are not correct:

A) "Method" is not a behavioral feature; it is a realization of one. B) "Function" is more of a programming concept than a UML term and would likely be modeled as an operation if it's part of a classifier. D) "Constraint" is not a behavioral feature but a restriction on some aspect of a classifier or a stereotype. E) "Method Invocation" is not a feature; it's an action that invokes a method. F) "Classifier behavior" is a broader concept that defines the behavior characteristic of classifiers as a whole, not a behavioral feature in itself.

Therefore, the correct answer is:

C. Operation

Option C shows a UML diagram where a class ( One ) appears to have an aggregation relationship with itself. In UML, an aggregation is a special type of association that represents a whole-part relationship between the aggregate (whole) and a component part. However, it does not make sense for a class to aggregate itself; such a relationship implies that instances of the same class are parts of each other, which is conceptually invalid.

Let's consider the other options: A) This diagram shows a class contained within another, which is a valid use of nesting classes. B) This diagram shows a composition relationship, which is a form of aggregation with a stronger lifecycle dependency between the whole and the part. This is a valid relationship in UML. D) This diagram shows a class containing two nested classes, one of which contains another nested class. This is also a valid representation of nested classes in UML.

Therefore, the correct answer is:

C. Option C

The provided image depicts a block diagram of a sensor controller represented as a state machine. The state machine transitions between the following states:

Initializing

Calibrating

Ready

Acquiring Data

The question specifies the state machine starts in the Ready state and the acquireData event triggers the transition.

Analyzing the image, we can identify the following behaviors for the scenario:

logStatus : This behavior is depicted in the diagram as the first action upon exiting the Ready state. It most likely logs the current state of the sensor controller.

deploy : The transition from Ready to Acquiring Data triggers the  deploy  behavior. This likely involves preparing the sensor for data acquisition.

scanTarget : Upon entering the Acquiring Data state, the  scanTarget  behavior is initiated. This suggests the sensor controller is actively collecting data from the target.

Therefore, the complete sequence of behaviors is logStatus , followed by deploy , and lastly scanTarget , before reaching the Acquiring Data state.

Justification for excluding other options:

Option A (deploy only) excludes the initial state logging and target scanning actions.

Option B (logStatus.deploy) excludes the target scanning upon entering the Acquiring Data state.

Option C (deploy, scanTarget) omits the initial state logging.

Option E (logStatus.deploy.scanTarget.logStatus) includes an extra  logStatus  action after target scanning, which is not supported by the diagram.

In conclusion, based on the state machine diagram and the behavior descriptions, option D (logStatus.deploy.scanTarget) accurately reflects the sequence of actions that occur before the sensor controller arrives at the Acquiring Data state.

ML 2 Foundation concepts for activity diagrams, there are eight object nodes in total. Here's a breakdown of the elements:

Object Nodes:

Order:  This rectangle near the start of the diagram represents an object node.

Cust Name:  This rectangle following the "Get Customer Details" action is another object node.

Order Details:  This rectangle after the "Get Order Details" action is an object node as well.

New Order:  The rectangle positioned after the decision diamond (approved) is an object node.

Repeat  (text near the decision diamond): This is not an object node. It likely indicates a loopback or repetition, but it doesn't represent an object itself.

Cust Order:  The rectangle after the "Place Order" action is an object node.

Invoice:  The rectangle following the "Create Invoice" action is an object node.

OrderAck:  The rectangle at the end signifies another object node.

Counting the Nodes:

There are eight rectangles that represent object nodes in the diagram (Order, Cust Name, Order Details, New Order, Cust Order, Invoice, OrderAck).

References

UML 2.5.1 Specification (Superstructure) : Sections on Activity Diagrams and Object Nodes  https://www.omg.org/spec/UML/2.5.1/

Abstraction in UML and software modeling often incorporates the technique of information hiding. Information hiding is a principle that supports abstraction by ensuring that unnecessary details about software components are not exposed to other parts of the system. This encapsulation strengthens modularity and keeps various parts of the program independent of one another, which simplifies complexity in large systems. Abstraction and information hiding are closely related; abstraction focuses on the high-level structure of the system, while information hiding protects the internal states and functionality of components, allowing changes without extensive impact on other system parts.

In the context of the given scenario, the Use Case "Manage customer information" appears to be a general use case that encompasses the functionalities of adding, deleting, and updating customer information. The specific functionalities are represented by separate use cases, namely "Add new customer", "Delete customer", and "Update customer information".

In UML Use Case diagrams, the «include» relationship should be used when a use case implicitly requires the capabilities of another. However, when the use case is a higher-level description that can be further elaborated into more specific use cases, the «extend» relationship is more appropriate, but in the reverse direction as shown in Option B.

Option B correctly uses the generalization relationship which is not depicted by any arrows or lines but by a whole-part structure, indicating that the specific use cases are a part of the general "Manage customer information" use case.

Option A shows the "Manage customer information" use case extending the specific use cases, which is not correct given the context.

Option C incorrectly uses «include» relationships, implying that the "Manage customer information" use case always requires the included use cases.

Option D has the «extend» relationships backward, which is not aligned with the scenario described.

Therefore, the correct answer is:

B. Option B

An OpaqueExpression in UML 2 is used to specify behavior in a textual form when it is not necessary to specify which language is used, or when it is not possible to use graphical notation. According to the UML 2 specification, an OpaqueExpression is not limited to any particular language; it can represent expressions written in any language.

The key characteristics of an OpaqueExpression are as follows:

The 'body' of an OpaqueExpression is a sequence of strings, where each string could be written in a different language. This means it has the capacity to include multiple languages simultaneously.

The 'language' attribute is optional and is used to indicate the languages of the respective 'body' parts.

The allowance for any language is clearly stated in the UML 2 Infrastructure Specification. OpaqueExpression is designed to be a flexible way to capture expressions that are not readily expressible in UML or when using a language outside the scope of UML (e.g., mathematical expressions, programming languages, or other domain-specific languages).