UML `alt` Fragment vs Per-Message Guards for Deterministic Sequence Traces

Direct answer

Prefer a UML 2.x alt combined fragment with interaction constraints over per-message guards when generating deterministic executable traces. The alt fragment groups alternatives into a single conditional construct that test engines can export more reliably than scattered guards. Per-message guards lack standardized expression language and evaluation order, so multiple guards can be true simultaneously or be dropped during export. However, alt is not automatically deterministic: the simulator must select exactly one true operand, and without an otherwise operand every guard can evaluate false and produce no trace.

Confirmed facts

• UML 2.x does not standardize the expression language for interaction constraints; OCL is common but optional.
• An alt operand carries an interaction constraint; per-message guards attach to individual messages and have no standardized evaluation order.
• Without otherwise, an alt fragment can yield zero traces when all explicit guards are false.
• Combined fragments generally export to test execution engines as conditional branches; scattered per-message guards are more likely to be flattened or discarded.

Likely explanation

The ambiguity comes from separating the UML notation from the execution tool. alt is structurally stronger because it forces alternatives into one declared set, but the engine still decides the outcome when zero, one, or multiple operand constraints are true. OCL is more portable than a proprietary action language only if the target code generator can evaluate OCL constraints.

Steps for this case

1. Model the alternatives inside one alt combined fragment, with one interaction constraint per operand.
2. Add an otherwise operand if every simulated run must emit exactly one trace; otherwise treat an all-false run as a coverage gap.
3. Write guards in OCL only if your target engine supports OCL evaluation; otherwise use the engine's supported Boolean action language and document its evaluation order.
4. Export XMI and confirm each alt operand carries an interaction constraint and that otherwise maps to an else branch in the target engine.
5. Run a simulation with every explicit guard set to false and record whether the engine emits no trace, selects otherwise, or reports an error.

Missing diagnostic detail

Does your target test execution engine evaluate alt operand constraints, or does it only support message-level guards? This determines whether OCL in an alt fragment is executable or whether you must use per-message guards in the engine's native action language.

Assumptions and uncertainty

• Assumes UML 2.x sequence diagrams and a model-based testing pipeline that simulates or generates code from the diagram.
• OCL portability is uncertain because OCL execution support in code-generation pipelines is less universal than simple Boolean action-language guards.
• Multiple true alt operands are not automatically resolved by UML; the simulator may choose the first, choose randomly, or fail. Confirm your simulator's tie-breaking rule before relying on alt for determinism.
• An otherwise operand can mask incomplete guard coverage and reduce fault detection.
• Treat this as a conservative draft pending verification against your specific engine.

Verification

1. Inspect exported XMI: each alt operand should carry an interaction constraint; otherwise should map to an else branch.
2. Set all explicit guards false and observe trace output: no trace, otherwise selection, or error.
3. Check tool documentation for guard expression language and simultaneous-true-guard resolution.