IF/ELSE, FOR, WHILE, TRY/EXCEPT, BREAK, CONTINUE, and Control Flow: Core Concepts and Mental Model

1. The practical problem: automation needs decisions without becoming a hidden program

Chapters 01–09 established suites, keywords, variables, standard libraries, and deterministic lifecycle ownership. Real automation still needs decisions: skip an item that is not actionable, iterate over synthetic inputs, poll a bounded local state, or recover from one expected failure while preserving all others.

Robot Framework now has native control structures for these cases. The design risk is not lack of power; it is putting so much branching and recovery logic in a test that the executable specification stops communicating business intent. This chapter therefore treats control flow as an observable, bounded orchestration tool, not a second general-purpose language.

2. Define the objects before writing conditions

3. Native structure map

4. Expression evaluation: ${var} replacement and $var access are not the same

IF and WHILE conditions are evaluated as Python expressions. With ${name}, Robot first replaces the variable with its string representation and then evaluates the resulting expression. This is convenient for numbers but fragile for arbitrary strings, multiline values, quotes, and complex objects. The special $name syntax gives the evaluator the actual object.

*** Test Cases ***
Safer String Condition
    VAR    ${state}    ready
    IF    $state == "ready"
        Log    State is ready.
    END

Numeric Replacement Can Be Fine
    VAR    ${count}    ${3}
    IF    ${count} > 0
        Log    Positive count.
    END

5. Status propagation is the real behavior

An IF whose condition is false is not a failure; its body simply does not execute. A normal FOR completes with PASS unless a keyword fails or a loop-control statement changes the path. A WHILE that hits its configured limit normally fails. A TRY failure becomes handled only when an EXCEPT branch matches and that handler itself succeeds.

Therefore “the log reached the next line” is not enough evidence. Inspect the error message, which branch matched, loop status, final test status, and surrounding lifecycle cleanup.

6. WHILE is bounded by default—but set a deliberate limit anyway

Robot Framework 7.4.2 has a built-in default of 10,000 WHILE iterations. That safety net is much too large to serve as a domain policy. A production test should set a meaningful count or time budget tied to the operation being modeled.

*** Keywords ***
Advance Until Ready
    [Arguments]    ${max_attempts}=5
    VAR    ${attempt}    ${0}
    VAR    ${state}      warming
    WHILE    $state != "ready"    limit=${max_attempts}
        ${attempt}=    Evaluate    $attempt + 1
        ${state}=      Simulate State    ${attempt}
        Log    attempt=${attempt}; state=${state}
    END
    RETURN    ${state}

7. BREAK and CONTINUE belong to the loop body

BREAK exits the current FOR or WHILE. CONTINUE skips the rest of the current iteration. Both may be nested inside IF or TRY, but they must still be syntactically in the loop body. Calling a helper keyword that itself contains BREAK is invalid; a helper should instead return a decision that the loop body acts on.

FOR    ${item}    IN    alpha    skip    stop    omega
    IF    $item == "skip"    CONTINUE
    IF    $item == "stop"    BREAK
    Log    processing=${item}
END

8. TRY/EXCEPT matches Robot error messages—not Python exception classes

Robot Framework error recovery deals primarily with keyword failure messages. Exact matching is the default. Pattern modes such as GLOB, REGEXP, and START are available when the variable portion of an expected message must be tolerated. Invalid syntax and failures that stop the whole execution cannot be caught with ordinary EXCEPT.

TRY
    Fail    transient: service warming
EXCEPT    transient:*    type=GLOB    AS    ${error}
    Log    Recovered expected failure: ${error}
ELSE
    Log    No failure occurred.
FINALLY
    Log    Local cleanup/evidence step.
END

9. Put control flow at the narrowest readable layer

10. Why this matters in DevOps

CI needs deterministic control flow. A green pipeline is trustworthy only if a branch cannot silently hide a failed assertion, a retry loop cannot run forever, and recovery is limited to known transient conditions. Bounded control flow also improves parallelism planning because each test has an understandable upper execution cost.

11. Knowledge check

12. Summary and next step

Native control flow changes which Robot statements execute while lifecycle and external-state ownership remain separate. Conditions are Python expressions, loops must be bounded, BREAK/CONTINUE belong to the active loop body, and TRY/EXCEPT should recover only explicitly expected failures. Lesson 2 turns that model into a synthetic state-processing workflow with observable traces.

Further reading

• Robot Framework 7.4.2 User Guide — control structures — FOR, WHILE, BREAK/CONTINUE, IF/ELSE, TRY/EXCEPT, and readability guidance.
• Robot Framework 7.4.2 User Guide — WHILE loops — expression evaluation, limits, on_limit, and output-size considerations.
• Robot Framework 7.4.2 User Guide — TRY/EXCEPT — exact/pattern matching, AS, ELSE, FINALLY, and uncatchable failures.
• Robot Framework 7.4.2 User Guide — evaluating expressions — ${var} replacement versus $var access and evaluation namespace behavior.
• Robot Framework 7.4.2 BuiltIn — legacy-compatible conditional/loop-control helpers and native-syntax recommendations.
• Robot Framework project site — current stable release stream.