@allurereport/reader 3.0.0-beta.10

package/dist/allure2/model.d.ts

@@ -0,0 +1,78 @@
+export interface Attachment {
+    name?: string;
+    type?: string;
+    source?: string;
+}
+export declare enum Status {
+    FAILED = "failed",
+    BROKEN = "broken",
+    PASSED = "passed",
+    SKIPPED = "skipped"
+}
+export declare enum Stage {
+    SCHEDULED = "scheduled",
+    RUNNING = "running",
+    FINISHED = "finished",
+    PENDING = "pending",
+    INTERRUPTED = "interrupted"
+}
+export declare enum ParameterMode {
+    HIDDEN = "hidden",
+    MASKED = "masked",
+    DEFAULT = "default"
+}
+export interface Label {
+    name?: string;
+    value?: string;
+}
+export interface Link {
+    name?: string;
+    url?: string;
+    type?: string;
+}
+export interface Parameter {
+    name?: string;
+    value?: string;
+    excluded?: boolean;
+    mode?: ParameterMode;
+}
+export interface StatusDetails {
+    message?: string;
+    trace?: string;
+    known?: boolean;
+    muted?: boolean;
+    flaky?: boolean;
+    actual?: string;
+    expected?: string;
+}
+interface ExecutableItem {
+    name?: string;
+    status?: Status;
+    statusDetails?: StatusDetails;
+    stage?: Stage;
+    description?: string;
+    descriptionHtml?: string;
+    steps?: StepResult[];
+    attachments?: Attachment[];
+    parameters?: Parameter[];
+    start?: number;
+    stop?: number;
+}
+export type FixtureResult = ExecutableItem;
+export type StepResult = ExecutableItem;
+export interface TestResult extends ExecutableItem {
+    uuid?: string;
+    historyId?: string;
+    fullName?: string;
+    testCaseId?: string;
+    labels?: Label[];
+    links?: Link[];
+}
+export interface TestResultContainer {
+    uuid?: string;
+    name?: string;
+    children?: string[];
+    befores?: FixtureResult[];
+    afters?: FixtureResult[];
+}
+export {};

package/dist/allure2/model.js

@@ -0,0 +1,21 @@
+export var Status;
+(function (Status) {
+    Status["FAILED"] = "failed";
+    Status["BROKEN"] = "broken";
+    Status["PASSED"] = "passed";
+    Status["SKIPPED"] = "skipped";
+})(Status || (Status = {}));
+export var Stage;
+(function (Stage) {
+    Stage["SCHEDULED"] = "scheduled";
+    Stage["RUNNING"] = "running";
+    Stage["FINISHED"] = "finished";
+    Stage["PENDING"] = "pending";
+    Stage["INTERRUPTED"] = "interrupted";
+})(Stage || (Stage = {}));
+export var ParameterMode;
+(function (ParameterMode) {
+    ParameterMode["HIDDEN"] = "hidden";
+    ParameterMode["MASKED"] = "masked";
+    ParameterMode["DEFAULT"] = "default";
+})(ParameterMode || (ParameterMode = {}));

package/dist/attachments/index.d.ts

@@ -0,0 +1,2 @@
+import type { ResultsReader } from "@allurereport/reader-api";
+export declare const attachments: ResultsReader;

package/dist/attachments/index.js

@@ -0,0 +1,8 @@
+const readerId = "attachments";
+export const attachments = {
+    read: async (visitor, data) => {
+        await visitor.visitAttachmentFile(data, { readerId });
+        return true;
+    },
+    readerId: () => readerId,
+};

package/dist/cucumberjson/index.d.ts

@@ -0,0 +1,2 @@
+import type { ResultsReader } from "@allurereport/reader-api";
+export declare const cucumberjson: ResultsReader;

package/dist/cucumberjson/index.js

@@ -0,0 +1,306 @@
+import { BufferResultFile } from "@allurereport/reader-api";
+import * as console from "node:console";
+import { randomUUID } from "node:crypto";
+import { ensureArray, ensureInt, ensureString, isArray, isNonNullObject, isString } from "../utils.js";
+import { STEP_NAME_PLACEHOLDER, TEST_NAME_PLACEHOLDER } from "./model.js";
+const NS_IN_MS = 1000000;
+const readerId = "cucumberjson";
+const allureStepStatusPriorityOrder = {
+    failed: 0,
+    broken: 1,
+    unknown: 2,
+    skipped: 3,
+    passed: 4,
+};
+const cucumberStatusToAllureStatus = {
+    unknown: "unknown",
+    passed: "passed",
+    skipped: "skipped",
+    pending: "skipped",
+    ["undefined"]: "broken",
+    ambiguous: "broken",
+    failed: "failed",
+};
+const allureStepMessages = {
+    unknown: "The result of the step is unknown",
+    passed: "The step passed",
+    skipped: "The step was skipped because the previous step hadn't passed",
+    pending: "The step signalled pending during execution",
+    ["undefined"]: "The step didn't match any definition",
+    ambiguous: "The step matched more than one definition",
+    failed: "The step failed",
+};
+export const cucumberjson = {
+    read: async (visitor, data) => {
+        const originalFileName = data.getOriginalFileName();
+        if (originalFileName.endsWith(".json")) {
+            try {
+                const parsed = await data.asJson();
+                if (parsed) {
+                    let oneOrMoreFeaturesParsed = false;
+                    for (const feature of parsed) {
+                        oneOrMoreFeaturesParsed || (oneOrMoreFeaturesParsed = await processFeature(visitor, originalFileName, feature));
+                    }
+                    return oneOrMoreFeaturesParsed;
+                }
+            }
+            catch (e) {
+                console.error("error parsing", originalFileName, e);
+                return false;
+            }
+        }
+        return false;
+    },
+    readerId: () => readerId,
+};
+const processFeature = async (visitor, originalFileName, feature) => {
+    if (isCucumberFeature(feature)) {
+        const preProcessedFeature = preProcessFeature(feature);
+        for (const scenario of feature.elements) {
+            await processScenario(visitor, originalFileName, preProcessedFeature, scenario);
+        }
+        return true;
+    }
+    return false;
+};
+const processScenario = async (visitor, originalFileName, feature, scenario) => {
+    const preProcessedScenario = preProcessScenario(scenario);
+    if (shouldProcessScenario(preProcessedScenario)) {
+        const preProcessedSteps = await preProcessSteps(visitor, scenario.steps ?? []);
+        await visitor.visitTestResult(mapCucumberScenarioToAllureTestResult(feature, preProcessedScenario, preProcessedSteps), {
+            readerId,
+            metadata: { originalFileName },
+        });
+    }
+};
+const shouldProcessScenario = ({ type }) => type !== "background";
+const preProcessSteps = async (visitor, steps) => {
+    const preProcessedSteps = [];
+    for (const step of steps) {
+        preProcessedSteps.push(await preProcessOneStep(visitor, step));
+    }
+    return preProcessedSteps;
+};
+const preProcessOneStep = async (visitor, step) => {
+    const { keyword, name, result } = step;
+    const { status, duration, error_message: errorMessage } = result ?? {};
+    return {
+        name: ensureString(name)?.trim(),
+        keyword: ensureString(keyword)?.trim(),
+        status: status ?? "unknown",
+        duration: ensureInt(duration),
+        errorMessage,
+        attachments: await processStepAttachments(visitor, step),
+    };
+};
+const processStepAttachments = async (visitor, step) => [
+    await processStepDocStringAttachment(visitor, step.doc_string),
+    await processStepDataTableAttachment(visitor, step.rows),
+    ...(await processCucumberJsStepArguments(visitor, step.arguments)),
+    ...(await processStepEmbeddingAttachments(visitor, step)),
+].filter((s) => typeof s !== "undefined");
+const processStepDocStringAttachment = async (visitor, docString) => {
+    if (docString) {
+        const { value, content, content_type: contentType } = docString;
+        const resolvedValue = ensureString(value ?? content);
+        if (resolvedValue && resolvedValue.trim()) {
+            return await visitBufferAttachment(visitor, "Description", Buffer.from(resolvedValue), ensureString(contentType) || "text/markdown");
+        }
+    }
+};
+const processStepDataTableAttachment = async (visitor, rows) => {
+    if (isArray(rows)) {
+        const content = formatDataTable(rows);
+        return await visitBufferAttachment(visitor, "Data", Buffer.from(content), "text/csv");
+    }
+};
+const processCucumberJsStepArguments = async (visitor, stepArguments) => {
+    const attachments = [];
+    if (isArray(stepArguments)) {
+        for (const stepArgument of stepArguments) {
+            if (isNonNullObject(stepArgument)) {
+                if ("content" in stepArgument) {
+                    attachments.push(await processStepDocStringAttachment(visitor, stepArgument));
+                }
+                else if ("rows" in stepArgument) {
+                    attachments.push(await processStepDataTableAttachment(visitor, stepArgument.rows));
+                }
+            }
+        }
+    }
+    return attachments;
+};
+const processStepEmbeddingAttachments = async (visitor, { embeddings }) => {
+    const attachments = [];
+    const checkedEmbeddings = ensureArray(embeddings) ?? [];
+    const getName = checkedEmbeddings.length > 1 ? (i) => `Embedding ${i}` : () => "Embedding";
+    const embeddingsWithNames = checkedEmbeddings.map((e, i) => [e, getName(i + 1)]);
+    for (const [embedding, fallbackName] of embeddingsWithNames) {
+        if (isNonNullObject(embedding)) {
+            attachments.push(await visitBufferAttachment(visitor, ensureString(embedding.name, fallbackName), Buffer.from(ensureString(embedding.data, ""), "base64"), ensureString(embedding.mime_type, "application/octet-stream")));
+        }
+    }
+    return attachments;
+};
+const visitBufferAttachment = async (visitor, name, content, contentType) => {
+    const fileName = randomUUID();
+    await visitor.visitAttachmentFile(new BufferResultFile(content, fileName), { readerId });
+    return {
+        type: "attachment",
+        contentType,
+        originalFileName: fileName,
+        name,
+    };
+};
+const formatDataTable = (rows) => {
+    return rows
+        .filter((isNonNullObject))
+        .map(formatDataTableRow)
+        .filter(isString)
+        .join("\r\n");
+};
+const formatDataTableRow = ({ cells }) => {
+    const checkedCells = ensureArray(cells);
+    return checkedCells ? checkedCells.map(formatDataTableCell).join(",") : undefined;
+};
+const formatDataTableCell = (cell) => {
+    const escapedCell = ensureString(cell, "").replaceAll(String.raw `"`, String.raw `""`);
+    return `"${escapedCell}"`;
+};
+const isCucumberFeature = ({ keyword, elements }) => typeof keyword === "string" && keyword.toLowerCase() === "feature" && Array.isArray(elements);
+const pairWithAllureSteps = (preProcessedCucumberSteps) => preProcessedCucumberSteps.map((c) => {
+    return {
+        preProcessedStep: c,
+        allureStep: createAllureStepResult(c),
+    };
+});
+const mapCucumberScenarioToAllureTestResult = (preProcessedFeature, scenario, preProcessedSteps) => {
+    const postProcessedSteps = pairWithAllureSteps(preProcessedSteps);
+    return {
+        fullName: calculateFullName(preProcessedFeature, scenario),
+        name: scenario.name ?? TEST_NAME_PLACEHOLDER,
+        description: scenario.description,
+        duration: convertDuration(calculateTestDuration(postProcessedSteps)),
+        steps: postProcessedSteps.map(({ allureStep }) => allureStep),
+        labels: calculateTestLabels(preProcessedFeature, scenario),
+        ...resolveTestResultStatusProps(postProcessedSteps),
+    };
+};
+const calculateTestLabels = ({ name: featureName, tags: featureTags }, { tags: scenarioTags }) => {
+    const labels = [];
+    if (featureName) {
+        labels.push({ name: "feature", value: featureName });
+    }
+    labels.push(...featureTags.map((value) => ({ name: "tag", value })), ...scenarioTags.map((value) => ({ name: "tag", value })));
+    return labels;
+};
+const preProcessFeature = (feature) => {
+    return {
+        id: ensureString(feature.id),
+        name: ensureString(feature.name),
+        uri: ensureString(feature.uri),
+        tags: parseTags(feature.tags),
+    };
+};
+const parseTags = (tags) => {
+    return (ensureArray(tags) ?? [])
+        .filter((isNonNullObject))
+        .map(({ name }) => name)
+        .filter(isString);
+};
+const preProcessScenario = (scenario) => {
+    return {
+        id: ensureString(scenario.id),
+        name: ensureString(scenario.name),
+        description: ensureString(scenario.description),
+        tags: parseTags(scenario.tags),
+        type: scenario.type,
+    };
+};
+const calculateFullName = ({ uri: featureUri, name: featureName, id: featureId }, { name: scenarioName, id: scenarioId }) => {
+    if (!scenarioName && !scenarioId) {
+        return randomUUID();
+    }
+    const featurePart = featureUri || featureName || featureId;
+    if (featurePart) {
+        const scenarioPart = scenarioName || scenarioId;
+        return `${featurePart}#${scenarioPart}`;
+    }
+    return scenarioId || scenarioName;
+};
+const calculateTestDuration = (cucumberAllureStepData) => cucumberAllureStepData.reduce((testDuration, { preProcessedStep: { duration } }) => typeof testDuration === "undefined" ? duration : testDuration + (duration ?? 0), undefined);
+const resolveTestResultStatusProps = (cucumberAllureSteps) => {
+    const stepsData = getCucumberAllureStepWithMaxPriorityStatus(cucumberAllureSteps);
+    return stepsData
+        ? resolveResultOfTestFromStepsData(stepsData)
+        : {
+            status: "unknown",
+            message: "Step results are missing",
+        };
+};
+const resolveResultOfTestFromStepsData = ({ preProcessedStep: { status: cucumberStatus, errorMessage }, allureStep: { name, status }, }) => ({
+    status: status ?? "unknown",
+    ...resolveTestMessageAndTrace(name, cucumberStatus, errorMessage),
+});
+const resolveTestMessageAndTrace = (allureStepName, status, errorMessage) => status !== "passed"
+    ? {
+        message: resolveTestMessage(status, allureStepName),
+        trace: errorMessage,
+    }
+    : {};
+const resolveTestMessage = (cucumberStepStatus, allureStepName) => {
+    switch (cucumberStepStatus) {
+        case "failed":
+            return `The step '${allureStepName}' failed`;
+        case "skipped":
+            return "One or more steps of the scenario were skipped";
+        case "pending":
+            return `The step '${allureStepName}' signalled pending during execution`;
+        case "undefined":
+            return `The step '${allureStepName}' didn't match any definition`;
+        case "ambiguous":
+            return `The step '${allureStepName}' matched more than one definition`;
+        case "unknown":
+        default:
+            return `The result of the step '${allureStepName}' is unknown`;
+    }
+};
+const getCucumberAllureStepWithMaxPriorityStatus = (cucumberAllureSteps) => {
+    switch (cucumberAllureSteps.length) {
+        case 0:
+            return undefined;
+        case 1:
+            return cucumberAllureSteps[0];
+        default:
+            return cucumberAllureSteps.reduce(statusPriorityReducingFn);
+    }
+};
+const statusPriorityReducingFn = (testDefiningStep, currentStep) => allureStepStatusPriorityOrder[testDefiningStep.allureStep.status] <=
+    allureStepStatusPriorityOrder[currentStep.allureStep.status]
+    ? testDefiningStep
+    : currentStep;
+const createAllureStepResult = ({ keyword, name, status, duration, errorMessage, attachments, }) => ({
+    type: "step",
+    name: getAllureStepName(keyword, name),
+    steps: attachments,
+    ...mapCucumberStepResultToStepProps(status, duration, errorMessage),
+});
+const getAllureStepName = (keyword, name) => {
+    if (!name) {
+        return keyword ? `${keyword} <${STEP_NAME_PLACEHOLDER.toLowerCase()}>` : STEP_NAME_PLACEHOLDER;
+    }
+    return keyword ? `${keyword} ${name}` : name;
+};
+const mapCucumberStepResultToStepProps = (status, duration, errorMessage) => ({
+    status: cucumberStatusToAllureStatus[status ?? "unknown"] ?? "unknown",
+    duration: convertDuration(duration),
+    ...resolveStepMessageAndTrace(status, errorMessage),
+});
+const resolveStepMessageAndTrace = (status, errorMessage) => status !== "passed" || errorMessage
+    ? {
+        message: allureStepMessages[status ?? "unknown"] ?? allureStepMessages.unknown,
+        trace: errorMessage,
+    }
+    : {};
+const convertDuration = (duration) => typeof duration !== "undefined" ? nsToMs(duration) : undefined;
+const nsToMs = (ns) => Math.round(ns / NS_IN_MS);

package/dist/cucumberjson/model.d.ts

@@ -0,0 +1,65 @@
+export declare const TEST_NAME_PLACEHOLDER = "The scenario's name is not defined";
+export declare const STEP_NAME_PLACEHOLDER = "The step's name is not defined";
+export type CucumberFeature = {
+    description: string;
+    elements: CucumberFeatureElement[];
+    id: string;
+    keyword: string;
+    line: number;
+    name: string;
+    tags?: unknown;
+    uri: string;
+};
+export type CucumberFeatureElement = {
+    after?: CucumberStep[];
+    before?: CucumberStep[];
+    description: string;
+    id?: string;
+    keyword: string;
+    line: number;
+    name: string;
+    steps?: CucumberStep[];
+    tags?: unknown;
+    type: string;
+};
+export type CucumberStep = {
+    doc_string?: CucumberDocString;
+    embeddings?: unknown;
+    keyword?: string;
+    line?: number;
+    match?: CucumberStepMatch;
+    name?: string;
+    output?: string[];
+    result: CucumberStepResult;
+    rows?: unknown;
+    arguments?: unknown;
+};
+export type CucumberDocString = {
+    content_type?: string;
+    line?: number;
+    value?: string;
+    content?: string;
+};
+export type CucumberDatatableRow = {
+    cells: unknown;
+};
+export type CucumberStepResult = {
+    duration?: number;
+    error_message?: string;
+    status: string;
+};
+export type CucumberStepMatch = {
+    location: string;
+};
+export type CucumberTag = {
+    line: number;
+    name: unknown;
+};
+export type CucumberEmbedding = {
+    data: unknown;
+    mime_type: unknown;
+    name?: unknown;
+};
+export type CucumberJsStepArgument = CucumberDocString | {
+    rows: CucumberDatatableRow[];
+};

package/dist/cucumberjson/model.js

@@ -0,0 +1,2 @@
+export const TEST_NAME_PLACEHOLDER = "The scenario's name is not defined";
+export const STEP_NAME_PLACEHOLDER = "The step's name is not defined";

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./allure1/index.js";
+export * from "./allure2/index.js";
+export * from "./cucumberjson/index.js";
+export * from "./junitxml/index.js";
+export * from "./xcresult/index.js";
+export * from "./attachments/index.js";
+export type * from "./model.js";

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from "./allure1/index.js";
+export * from "./allure2/index.js";
+export * from "./cucumberjson/index.js";
+export * from "./junitxml/index.js";
+export * from "./xcresult/index.js";
+export * from "./attachments/index.js";

package/dist/junitxml/index.d.ts

@@ -0,0 +1,2 @@
+import type { ResultsReader } from "@allurereport/reader-api";
+export declare const junitXml: ResultsReader;

package/dist/junitxml/index.js

@@ -0,0 +1,158 @@
+import { BufferResultFile } from "@allurereport/reader-api";
+import { XMLParser } from "fast-xml-parser";
+import * as console from "node:console";
+import { randomUUID } from "node:crypto";
+import { ensureString } from "../utils.js";
+import { isEmptyElement, isStringAnyRecord, isStringAnyRecordArray } from "../xml-utils.js";
+const MS_IN_S = 1000;
+const DEFAULT_TEST_NAME = "The test's name is not defined";
+const STDOUT_ATTACHMENT_NAME = "System output";
+const STDERR_ATTACHMENT_NAME = "System error";
+const SUITE_PACKAGE_NAME = "package";
+const SUITE_PARENT_LABEL_NAME = "parentSuite";
+const SUITE_LABEL_NAME = "suite";
+const TEST_CLASS_LABEL_NAME = "testClass";
+const arrayTags = new Set(["testsuite.testcase", "testsuites.testsuite", "testsuites.testsuite.testcase"]);
+const xmlParser = new XMLParser({
+    parseTagValue: false,
+    ignoreAttributes: false,
+    attributeNamePrefix: "",
+    removeNSPrefix: true,
+    allowBooleanAttributes: true,
+    isArray: (tagName, jPath) => arrayTags.has(jPath),
+});
+const readerId = "junit";
+export const junitXml = {
+    read: async (visitor, data) => {
+        if (data.getOriginalFileName().endsWith(".xml")) {
+            try {
+                const content = await data.asUtf8String();
+                if (!content) {
+                    return false;
+                }
+                const parsed = xmlParser.parse(content);
+                if (!isStringAnyRecord(parsed)) {
+                    return false;
+                }
+                return await parseRootElement(visitor, parsed);
+            }
+            catch (e) {
+                console.error("error parsing", data.getOriginalFileName(), e);
+                return false;
+            }
+        }
+        return false;
+    },
+    readerId: () => readerId,
+};
+const parseRootElement = async (visitor, xml) => {
+    const { testsuite: testSuite } = xml;
+    if (isEmptyElement(testSuite)) {
+        return true;
+    }
+    if (testSuite === undefined) {
+        const { testsuites: testSuites } = xml;
+        if (isEmptyElement(testSuites)) {
+            return true;
+        }
+        if (!isStringAnyRecord(testSuites)) {
+            return false;
+        }
+        const { testsuite: testSuitesArray } = testSuites;
+        if (isEmptyElement(testSuitesArray)) {
+            return true;
+        }
+        if (!isStringAnyRecordArray(testSuitesArray)) {
+            return false;
+        }
+        for (const testSuitesArrayElement of testSuitesArray) {
+            await parseTestSuite(visitor, testSuitesArrayElement, true);
+        }
+        return true;
+    }
+    if (!isStringAnyRecord(testSuite)) {
+        return false;
+    }
+    await parseTestSuite(visitor, testSuite, false);
+    return true;
+};
+const parseTestSuite = async (visitor, testSuite, isAggregated) => {
+    const { name, package: packageAttribute, testcase } = testSuite;
+    if (!isStringAnyRecordArray(testcase)) {
+        return;
+    }
+    for (const testcaseElement of testcase) {
+        await parseTestCase(visitor, { name: ensureString(name), suitePackage: ensureString(packageAttribute) }, testcaseElement, isAggregated);
+    }
+};
+const parseTestCase = async (visitor, { name: suiteName, suitePackage }, testCase, isAggregated) => {
+    const { "name": nameAttribute, failure, error, skipped, "classname": classNameAttribute, time, "system-out": systemOutAttribute, "system-err": systemErrAttribute, } = testCase;
+    const name = ensureString(nameAttribute);
+    const className = ensureString(classNameAttribute);
+    const systemOut = ensureString(systemOutAttribute);
+    const systemErr = ensureString(systemErrAttribute);
+    const { status, message, trace } = getStatus(failure, error, skipped);
+    await visitor.visitTestResult({
+        name: name ?? DEFAULT_TEST_NAME,
+        fullName: convertFullName(className, name),
+        duration: convertDuration(time),
+        status,
+        message,
+        trace,
+        steps: await parseAttachments(visitor, systemOut, systemErr),
+        labels: convertLabels({ suitePackage, suiteName, className, isAggregated }),
+    }, { readerId });
+};
+const convertFullName = (className, name) => (className && name ? `${className}.${name}` : undefined);
+const parseAttachments = async (visitor, systemOut, systemErr) => {
+    const attachments = [];
+    if (systemOut) {
+        attachments.push(await visitPlainTextAttachment(visitor, STDOUT_ATTACHMENT_NAME, systemOut));
+    }
+    if (systemErr) {
+        attachments.push(await visitPlainTextAttachment(visitor, STDERR_ATTACHMENT_NAME, systemErr));
+    }
+    return attachments;
+};
+const visitPlainTextAttachment = async (visitor, name, content) => {
+    const fileName = randomUUID();
+    await visitor.visitAttachmentFile(new BufferResultFile(Buffer.from(content), fileName), { readerId });
+    return {
+        type: "attachment",
+        contentType: "text/plain",
+        originalFileName: fileName,
+        name,
+    };
+};
+const convertLabels = ({ suitePackage, suiteName, className, isAggregated, }) => {
+    const labels = [];
+    if (suitePackage) {
+        labels.push({ name: SUITE_PACKAGE_NAME, value: suitePackage });
+        if (isAggregated) {
+            labels.push({ name: SUITE_PARENT_LABEL_NAME, value: suitePackage });
+        }
+    }
+    if (suiteName) {
+        labels.push({ name: SUITE_LABEL_NAME, value: suiteName });
+    }
+    if (className) {
+        labels.push({ name: TEST_CLASS_LABEL_NAME, value: className });
+    }
+    return labels;
+};
+const convertDuration = (timeAttribute) => {
+    const time = ensureString(timeAttribute);
+    return time ? Math.round(parseFloat(time) * MS_IN_S) : undefined;
+};
+const getStatus = (failure, error, skipped) => maybeParseStatus("failed", failure) ??
+    maybeParseStatus("broken", error) ??
+    maybeParseStatus("skipped", skipped) ?? { status: "passed" };
+const maybeParseStatus = (status, element) => {
+    if (isEmptyElement(element)) {
+        return { status };
+    }
+    if (isStringAnyRecord(element)) {
+        const { message, "#text": trace } = element;
+        return { status, message: ensureString(message), trace: ensureString(trace) };
+    }
+};