Collections, String, DateTime, OperatingSystem, Process, and XML Libraries: Diagnostics, Failure Modes, and Production Practices

1. Diagnostic sequence: isolate the owning layer

1. Preserve the first failing output.xml, log.html, console output, process result, and any owned scratch files.
2. Record Robot/Python/library versions and the exact command/output directory.
3. Confirm the executed suite, input variables, current platform, and disposable target root.
4. Validate Robot parse/import/keyword resolution before blaming the OS.
5. Inspect variable values/scopes and collection ownership.
6. Inspect path normalization, file existence, child process state, rc/stdout/stderr, or parsed XML model.
7. Only then inspect CI/container/parallel resource differences.
8. Apply one minimal correction and rerun the smallest controlled case.

2. Failure mode: command injection through concatenated shell text

*** Settings ***
Library    Process

*** Test Cases ***
Unsafe Pattern
    ${target}=    Set Variable    harmless.txt && echo injected
    Run Process    checker ${target}    shell=True

The defect is architectural: ${target} is no longer merely data once inserted into shell text. Fix it by keeping the executable and each argument in separate cells and leaving shell=False.

Run Process    checker    ${target}

3. Failure mode: deleting outside the disposable workspace

Remove Directory ${path} recursive=True is powerful enough to remove an entire tree. Never “fix” a cleanup failure by broadening the path or suppressing the error. Normalize the candidate path, compare it to a known disposable root, require a recognizable run-specific segment, and only then remove it.

${candidate}=    Normalize Path    ${WORKSPACE}    case_normalize=True
${root}=         Normalize Path    ${TEMPDIR}    case_normalize=True
Should Start With    ${candidate}    ${root}${/}
Should Contain       ${candidate}    rf08-artifact-lab-
Remove Directory     ${candidate}    recursive=True

4. Failure mode: process leaks

A foreground Run Process normally waits for completion. A background Start Process creates a lifecycle obligation. The suite must wait for readiness, retain the handle/alias, and terminate or wait for the child during teardown. “The CI job ended” is not a cleanup strategy in persistent runners.

*** Settings ***
Library    Process
Suite Teardown    Terminate All Processes    kill=True

*** Test Cases ***
Background Fixture Skeleton
    ${handle}=    Start Process    ${PYTHON}    -c    import time; time.sleep(30)    alias=fixture
    Process Should Be Running    fixture
    Terminate Process    fixture    kill=True
    Process Should Be Stopped    fixture

5. Failure mode: stdout/stderr capacity and blocked output

For normal-sized output, Process captures streams in memory. For large or unlimited output, redirect them to files under the owned workspace. Robot Framework 7.3 improved internal handling and removed the earlier lower-limit deadlock issue, but memory and output volume are still finite resources.

${result}=    Run Process
...    ${PYTHON}
...    -c
...    print("bounded")
...    stdout=${WORKSPACE}/stdout.txt
...    stderr=${WORKSPACE}/stderr.txt
Should Be Equal As Integers    ${result.rc}    0
File Should Exist    ${result.stdout_path}

6. Failure mode: assuming every byte stream is UTF-8

A process normally decodes output using a console-oriented encoding; files have their own encodings. If a producer emits a known different encoding, configure that boundary instead of adding errors=ignore everywhere. Silent replacement can turn corruption into a green test.

7. Failure mode: platform-specific paths or accidental working-directory dependence

Use OperatingSystem path keywords and automatic variables rather than hard-coded C:\... or /tmp/... paths. Remember that automatic slash normalization applies to path arguments, not arbitrary shell strings. A suite that passes locally only because it was started from one specific directory is not reproducible.

8. Failure mode: shared temp filenames under parallel execution

${TEMPDIR}/result.txt is not worker-safe if multiple runs share the same machine. Add a run/worker identifier or use a library/API that creates unique temporary resources. Keep cleanup scoped to that unique resource. Chapter 24 will formalize Pabot worker isolation; this chapter establishes the underlying state rule.

9. Failure mode: accidental shared collection mutation

*** Settings ***
Library    Collections

*** Variables ***
@{COMPONENTS}    api    worker

*** Test Cases ***
Broken Shared Mutation
    Append To List    ${COMPONENTS}    scheduler
    # A later test now observes mutated suite data.

Repair by copying at the test/keyword ownership boundary and mutating the copy. Do not “reset” a global list after every test; that merely hides the shared-state design.

10. Failure mode: fragile XML string comparison

If the requirement is “artifact id is A-1 and name is demo,” assert those fields. Whole-file string equality makes indentation and serializer behavior part of the contract by accident. Conversely, if exact bytes are the signed artifact requirement, use byte/checksum validation deliberately rather than semantic XML equality.

11. Intentionally broken diagnostic exercise

Create a copy of Lesson 2’s workflow and introduce these three faults one at a time: use a shared ${TEMPDIR}/rf08-artifact-lab without run ID; make the child exit with code 9; change XML id to B-2. Preserve separate evidence directories for each failure. Diagnose each failure at its owning layer before editing anything else.

robot --outputdir evidence/fail-process --variable RUN_ID:diag-1 suites/broken.robot
robot --outputdir evidence/fail-xml     --variable RUN_ID:diag-2 suites/broken.robot

12. Production practices

• Use Process with shell disabled unless shell semantics are a reviewed requirement.
• Give each run/worker an isolated scratch root.
• Guard recursive delete operations with normalized-path assertions.
• Set finite process timeouts for tools that can hang; define terminate/kill behavior intentionally.
• Redirect potentially large child output to owned files.
• Use explicit encodings and UTC conventions where evidence crosses systems.
• Do not log secret environment/file/process values merely for diagnosis.
• Prefer structural XML assertions for semantic requirements.

13. Knowledge check

14. Summary and next step

You can now diagnose standard-library failures by state owner instead of applying global workarounds. Lesson 5 consolidates the chapter with a guarded local artifact-processing checkpoint, an evidence packet, prediction steps, a deliberate process failure, and cleanup proof.

Further reading

• Robot Framework 7.4.2 Collections — list/dictionary mutation, copying, comparison, and current type-conversion behavior.
• Robot Framework 7.4.2 String — text/bytes transformation and encoding-related keywords.
• Robot Framework 7.4.2 DateTime — timestamps, time intervals, conversion, LOCAL/UTC handling, and result formats.
• Robot Framework 7.4.2 OperatingSystem — portable file/directory/environment operations and deprecated process-running keywords.
• Robot Framework 7.4.2 Process — structured process invocation, result objects, output redirection, timeouts, and cleanup.
• Robot Framework 7.4.2 XML — parsing, XPath-style element lookup, verification, mutation, and explicit save semantics.
• Robot Framework 7.4.2 release — stable release baseline used in these lessons.