Memory Management

The module allocates memory dynamically for:

• Handle structures
• Test suite structures and their properties
• Test case structures
• String data (names, IDs, messages, timestamps)

All memory is freed when a handle is closed or when the module is terminated. The module maintains a linked list of handles to allow multiple concurrent XML output streams.

Timestamp Handling

The module supports multiple timestamp formats for test suite creation:

• Current time: Automatically uses the current system time
• RISC OS time: Accepts a RISC OS 5-byte quin (centiseconds since 1900-01-01)
• Unix time: Accepts a Unix epoch timestamp (seconds since 1970-01-01)
• ISO 8601: Accepts a pre-formatted ISO 8601 timestamp string

RISC OS time values are converted to ISO 8601 format using the Territory_ConvertDateAndTime SWI for local time conversion, with manual adjustment for UTC epoch differences.

XML Output

The module generates JUnit-compatible XML output with the following structure:

• XML declaration with UTF-8 encoding
• Root testsuites element with aggregate statistics
• Individual testsuite elements with properties and test cases
• Test case elements with optional failure or error child elements

The XML is written incrementally as test cases are closed, reducing memory usage for large test suites.

Loading the Module

To load the module manually:

• *RMEnsure JUnitXML 0.01 RMLoad JUnitXML

The module will be loaded from the usual module search path. Once loaded, the SWI calls described above can be used to create and manage JUnit XML output.

Typical Usage Pattern

A typical usage pattern for generating JUnit XML output:

1. Call JUnitXML_Create to obtain a handle
2. Call JUnitXML_TestSuite with operation Create to start a test suite

3. For each test case:

   • Call JUnitXML_TestCase with operation Create
   • Call JUnitXML_TestCase with operation Close
4. Call JUnitXML_TestSuite with operation Close to finish the test suite
5. Call JUnitXML_Close to close the handle and write the final XML

Killing the Module

To kill the module:

• *RMKill JUnitXML

All open handles will be closed and their resources freed when the module is killed.

Complete Example in C

This example shows how to create a simple JUnit XML file with one test suite containing three test cases:

#include <stdio.h>

#include "swis.h"

#include "kernel.h"



#define JUnitXML_Create_FilenameGiven  (1 << 0)

#define JUnitXML_TestSuite_OpCreate    0

#define JUnitXML_TestSuite_OpClose     1

#define JUnitXML_TestCase_OpCreate     0

#define JUnitXML_TestCase_OpClose      1

#define JUNIT_STATUS_SUCCESS           1

#define JUNIT_STATUS_FAILURE           2



int main(void)

{

    _kernel_swi_regs r;

    _kernel_oserror *err;

    int handle;



    /* Create a handle with output filename */

    r.r[0] = JUnitXML_Create_FilenameGiven;

    r.r[1] = (int)"TestResults.xml";

    err = _kernel_swi(0x5AC00, &r, &r); /* JUnitXML_Create */

    if (err) {

        printf("Failed to create handle: %s\\n", err->errmess);

        return 1;

    }

    handle = r.r[0];



    /* Create a test suite */

    r.r[0] = JUnitXML_TestSuite_OpCreate; /* Create, current time */

    r.r[1] = handle;

    r.r[2] = (int)"suite1";

    r.r[3] = (int)"MyTestSuite";

    err = _kernel_swi(0x5AC01, &r, &r); /* JUnitXML_TestSuite */

    if (err) {

        printf("Failed to create suite: %s\\n", err->errmess);

        return 1;

    }



    /* Create test case 1: success */

    r.r[0] = JUnitXML_TestCase_OpCreate | (JUNIT_STATUS_SUCCESS << 4);

    r.r[1] = handle;

    r.r[2] = (int)"test1";

    r.r[3] = (int)"MyTestClass";

    r.r[4] = (int)"test_addition";

    r.r[5] = 0;

    r.r[6] = 0;

    err = _kernel_swi(0x5AC02, &r, &r); /* JUnitXML_TestCase */

    if (err) goto error;



    /* Close test case 1 */

    r.r[0] = JUnitXML_TestCase_OpClose;

    r.r[1] = handle;

    r.r[2] = 25; /* 25 centiseconds */

    err = _kernel_swi(0x5AC02, &r, &r);

    if (err) goto error;



    /* Create test case 2: failure */

    r.r[0] = JUnitXML_TestCase_OpCreate | (JUNIT_STATUS_FAILURE << 4);

    r.r[1] = handle;

    r.r[2] = (int)"test2";

    r.r[3] = (int)"MyTestClass";

    r.r[4] = (int)"test_subtraction";

    r.r[5] = (int)"AssertionError";

    r.r[6] = (int)"Expected 3 but got 4";

    err = _kernel_swi(0x5AC02, &r, &r);

    if (err) goto error;



    /* Close test case 2 */

    r.r[0] = JUnitXML_TestCase_OpClose;

    r.r[1] = handle;

    r.r[2] = 30;

    err = _kernel_swi(0x5AC02, &r, &r);

    if (err) goto error;



    /* Close the test suite */

    r.r[0] = JUnitXML_TestSuite_OpClose | (1 << 7); /* Duration present */

    r.r[1] = handle;

    r.r[2] = 100; /* 100 centiseconds total */

    err = _kernel_swi(0x5AC01, &r, &r);

    if (err) goto error;



    /* Close the handle */

    r.r[0] = 0;

    err = _kernel_swi(0x5AC03, &r, &r); /* JUnitXML_Close */

    if (err) goto error;



    printf("JUnit XML file created successfully\\n");

    return 0;



error:

    printf("Error: %s\\n", err ? err->errmess : "Unknown");

    return 1;

}

Example Output

The above C code would generate XML similar to:

<?xml version="1.0" encoding="UTF-8"?>

<testsuites>

  <testsuite name="MyTestSuite" package=""

           id="suite1" tests="2" failures="1" errors="0" skipped="0"

           time="1.00" timestamp="2026-03-27T10:30:00Z">

    <testcase id="test1" classname="MyTestClass" name="test_addition"

            time="0.25"/>

    <testcase id="test2" classname="MyTestClass" name="test_subtraction"

            time="0.30">

      <failure type="AssertionError">Expected 3 but got 4</failure>

    </testcase>

  </testsuite>

</testsuites>