The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
fix(run): report Gradle tests in the test tree as they run (#1339)
l0ng-aic219c81bd805
diff --git a/src/features/run/gradleRun.test.ts b/src/features/run/gradleRun.test.tsindex 27584d19e..642091c3e 100644--- a/src/features/run/gradleRun.test.ts+++ b/src/features/run/gradleRun.test.ts@@ -1,7 +1,7 @@import { describe, expect, it } from "vitest";import type { GradleModel, RunConfig } from "@/platform/ipc";import { applicationConfig } from "./application";-import { DELEGATED_DEBUG, delegatedGradleConfig, wrapperGradleVersion } from "./gradleRun";+import { DELEGATED_DEBUG, delegatedGradleConfig, withTestEvents, wrapperGradleVersion } from "./gradleRun";import { jdwpLaunch } from "./javaDebug";import { isJvmApplication } from "@/platform/javaLaunch";@@ -122,3 +122,24 @@ describe("Build and run using: Gradle", () => {expect(jdwpLaunch(debug)!.args.filter((a) => a === DELEGATED_DEBUG)).toHaveLength(1);});});++describe("Gradle test runs", () => {+ const script = "/tmp/openidea-gradle-tests.gradle";+ it("add the init script that reports each test", () => {+ expect(+ withTestEvents({ kind: "gradle", command: "./gradlew", args: ["test", "--tests", "*OrderTest"] }, script).args,+ ).toEqual(["--init-script", script, "test", "--tests", "*OrderTest"]);+ expect(withTestEvents({ kind: "shell", command: "C:\\w\\gradlew.bat", args: ["test"] }, script).args).toEqual([+ "--init-script",+ script,+ "test",+ ]);+ });++ it("leave other runs and an added script alone", () => {+ const maven = { kind: "maven", command: "./mvnw", args: ["test"] };+ expect(withTestEvents(maven, script)).toBe(maven);+ const twice = withTestEvents({ kind: "gradle", command: "gradle", args: ["test"] }, script);+ expect(withTestEvents(twice, script)).toBe(twice);+ });+});diff --git a/src/features/run/gradleRun.ts b/src/features/run/gradleRun.tsindex 43a605007..1b1024b71 100644--- a/src/features/run/gradleRun.ts+++ b/src/features/run/gradleRun.ts@@ -6,6 +6,7 @@* the forked JVM (`-Dopenidea.run.debug`), not to the Gradle daemon.*/import RUN_SCRIPT from "./gradleRun.gradle?raw";+import TESTS_SCRIPT from "./gradleTests.gradle?raw";import { useBuildModel } from "@/platform/buildModel";import { call, commands, isTauri, type GradleModel, type RunConfig } from "@/platform/ipc";import { findJavaModule, isJvmApplication, parseJavaArgs } from "@/platform/javaLaunch";@@ -84,20 +85,47 @@ export function delegatedGradleConfig(config: RunConfig, module: string, ctx: De};}-/** Writes the init script where Gradle can read it; it never changes, so once per session. */-let scriptPath: Promise<string> | null = null;-function writeScript(): Promise<string> {- scriptPath ??= (async () => {- const { tempDir, join } = await import("@tauri-apps/api/path");- const path = await join(await tempDir(), "openidea-gradle-run.gradle");- await call(commands.fsDelete(path)).catch(() => {});- await call(commands.fsCreateFileBytes(path, Array.from(new TextEncoder().encode(RUN_SCRIPT))));- return path;- })().catch((e) => {- scriptPath = null;- throw e;- });- return scriptPath;+/** Writes an init script where Gradle can read it; it never changes, so once per session. */+const scriptPaths = new Map<string, Promise<string>>();+function writeScript(name: string, text: string): Promise<string> {+ let written = scriptPaths.get(name);+ if (!written) {+ written = (async () => {+ const { tempDir, join } = await import("@tauri-apps/api/path");+ const path = await join(await tempDir(), name);+ await call(commands.fsDelete(path)).catch(() => {});+ await call(commands.fsCreateFileBytes(path, Array.from(new TextEncoder().encode(text))));+ return path;+ })().catch((e) => {+ scriptPaths.delete(name);+ throw e;+ });+ scriptPaths.set(name, written);+ }+ return written;+}++const isGradleCommand = (config: Pick<RunConfig, "kind" | "command">) =>+ config.kind === "gradle" || /(^|[/\\])gradlew?(\.bat)?$/.test(config.command);++/** `config` with the init script (`script`) that reports each test as it runs, for a Gradle test run. */+export function withTestEvents<T extends Pick<RunConfig, "kind" | "command" | "args">>(config: T, script: string): T {+ if (!isGradleCommand(config) || config.args.includes(script)) return config;+ return { ...config, args: ["--init-script", script, ...config.args] };+}++/**+ * A Gradle test run reporting each test as it runs (`gradleTests.gradle`): Gradle prints only+ * failures, and its XML reports are complete only once a test task ends.+ */+export async function gradleTestLaunch<T extends RunConfig>(config: T): Promise<T> {+ if (!isTauri() || !config.isTest || !isGradleCommand(config)) return config;+ try {+ return withTestEvents(config, await writeScript("openidea-gradle-tests.gradle", TESTS_SCRIPT));+ } catch (e) {+ console.warn("Gradle test init script not written", e);+ return config;+ }}/**@@ -121,7 +149,10 @@ export async function gradleDelegation(config: RunConfig): Promise<RunConfig | nconfigurationCache: false,};if (!delegatedGradleConfig(config, module, ctx)) return null;- const [script, configurationCache] = await Promise.all([writeScript(), supportsConfigurationCache(ctx)]);+ const [script, configurationCache] = await Promise.all([+ writeScript("openidea-gradle-run.gradle", RUN_SCRIPT),+ supportsConfigurationCache(ctx),+ ]);return delegatedGradleConfig(config, module, { ...ctx, script, configurationCache });}diff --git a/src/features/run/gradleTests.gradle b/src/features/run/gradleTests.gradlenew file mode 100644index 000000000..76edcff6f--- /dev/null+++ b/src/features/run/gradleTests.gradle@@ -0,0 +1,44 @@+// OpenIDEA: reports each test of Gradle's Test tasks as a TeamCity service message on the+// build's output, for the Run window's test tree: Gradle itself prints only failures (or a+// project's own format), and writes its XML reports when a task ends. Test tasks always run,+// so a rerun never ends UP-TO-DATE without results.++def tc = { String s ->+ s == null ? '' : s.replace('|', '||').replace("'", "|'").replace('\n', '|n').replace('\r', '|r')+ .replace('[', '|[').replace(']', '|]')+}++allprojects {+ tasks.withType(Test).configureEach { Test task ->+ task.outputs.upToDateWhen { false }+ task.addTestListener(new TestListener() {+ void beforeSuite(TestDescriptor suite) {}++ void afterSuite(TestDescriptor suite, TestResult result) {}++ void beforeTest(TestDescriptor test) {+ println "##teamcity[testStarted name='${tc(test.name)}' className='${tc(test.className)}']"+ }++ void afterTest(TestDescriptor test, TestResult result) {+ def id = "name='${tc(test.name)}' className='${tc(test.className)}'"+ def type = result.resultType.toString()+ if (type == 'FAILURE') {+ def error = result.exception+ def trace = new StringWriter()+ error?.printStackTrace(new PrintWriter(trace))+ println "##teamcity[testFailed ${id} message='${tc(error?.toString())}' details='${tc(trace.toString())}']"+ } else if (type == 'SKIPPED') {+ println "##teamcity[testIgnored ${id}]"+ }+ println "##teamcity[testFinished ${id} duration='${result.endTime - result.startTime}']"+ }+ })+ task.addTestOutputListener(new TestOutputListener() {+ void onOutput(TestDescriptor test, TestOutputEvent output) {+ if (test.className == null) return+ println "##teamcity[testStdOut name='${tc(test.name)}' className='${tc(test.className)}' out='${tc(output.message)}']"+ }+ })+ }+}diff --git a/src/features/run/store.ts b/src/features/run/store.tsindex ff4ae8450..6c542050c 100644--- a/src/features/run/store.ts+++ b/src/features/run/store.ts@@ -43,7 +43,7 @@ import {} from "./testing";import { GoTestOutput } from "./testing/go";import { moveToReportedClasses } from "./testing/jvm";-import { TeamcityOutput } from "./testing/phpunit";+import { TeamcityOutput } from "./testing/teamcity";import type { TestStdout } from "./testing/types";import { recordTestStates } from "./testing/states";import { failedTestPaths, leafTestPaths, rerunFailedConfig, testsConfig } from "./testing/rerun";@@ -54,7 +54,7 @@ import { typeFor } from "./types";import { recordRun } from "./services";import { startedPort } from "./serverPort";import { tomcatBrowserUrl } from "./tomcat";-import { gradleDelegation } from "./gradleRun";+import { gradleDelegation, gradleTestLaunch } from "./gradleRun";import { openUrl } from "./navigate";import { tx } from "@/platform/i18n";@@ -567,8 +567,13 @@ function newRuntime(config: RunConfig): SessionRuntime {if (tests && parser) tests.apply(parser.feed(line));};const framework = tests && parser ? frameworkFor(config) : null;+ // PHPUnit `--teamcity` and Gradle's test init script report through service messages.const stdout =- framework === "go" ? new GoTestOutput(feed) : framework === "phpunit" ? new TeamcityOutput(feed) : null;+ framework === "go"+ ? new GoTestOutput(feed)+ : framework === "phpunit" || framework === "jvm"+ ? new TeamcityOutput(feed)+ : null;const runtime: SessionRuntime = {stdout,tests,@@ -802,7 +807,8 @@ export async function startRun(if ((options.launch || launch.isTest) && launch.emulateTerminal) launch = { ...launch, emulateTerminal: false };if (launch.emulateTerminal) rt.terminal = new TerminalOutput();patchSession(sessionId, { terminal: !!launch.emulateTerminal });- const started = launch.isTest ? withTestReporting(launch) : launch;+ const started = launch.isTest ? await gradleTestLaunch(withTestReporting(launch)) : launch;+ if (runtimes.get(sessionId)?.generation !== generation) return getSession(sessionId) ?? null;const processStarted = performance.now();const info = await startWithRemedies(started, () => call(commands.runStart(started, channel)));console.info("Run process started", { name: config.name, ms: performance.now() - processStarted });@@ -921,7 +927,9 @@ function finishSession(sessionId: string, code: number | null) {// Surefire / Gradle print only failures and class totals: per-test results come from the XML reports.if (frameworkFor(session.config) === "jvm") {const reports = await jvmReports(session);- rt.tests.apply(testReportEvents(reports));+ const tests = rt.tests;+ // Tests the run reported already (Gradle's init script, Surefire failures) keep their output.+ tests.apply(testReportEvents(reports).filter((e) => !("path" in e) || !tests.hasResult(e.path)));moveToReportedClasses(rt.tests,reports.map((r) => r.className),diff --git a/src/features/run/testing/jvm.ts b/src/features/run/testing/jvm.tsindex 71c6cf11e..8d442b537 100644--- a/src/features/run/testing/jvm.ts+++ b/src/features/run/testing/jvm.ts@@ -1,7 +1,11 @@-/** Gradle test logging (`Class > method() PASSED`) and Maven Surefire reports. */+/**+ * Gradle test logging (`Class > method() PASSED`), the Gradle test init script's service messages+ * (`gradleTests.gradle`) and Maven Surefire reports.+ */import { jvmFrameTarget } from "../links";import type { TestResults } from "./results";-import { parseDuration, type TestEvent, type TestOutputParser } from "./types";+import { serviceMessage, type ServiceMessage } from "./teamcity";+import { parseDuration, type TestEvent, type TestLocation, type TestOutputParser } from "./types";const GRADLE_RE = /^(\S[^>]*?(?:\s>\s[^>]+?)+)\s+(PASSED|FAILED|SKIPPED)(?:\s+\(([\d.]+\s*m?s)\))?$/;const GRADLE_SUMMARY_RE = /^(\d+) tests? completed(?:, (\d+) failed)?(?:, (\d+) skipped)?/;@@ -15,10 +19,62 @@ const SUREFIRE2_RE = /^(?:\[\w+\]\s+)?([\w$]+)\(([\w$.]+)\)\s+Time elapsed: ([\dconst SUREFIRE_CLASS_RE =/^(?:\[\w+\]\s+)?Tests run: (\d+), Failures: (\d+), Errors: (\d+), Skipped: (\d+), Time elapsed: ([\d.]+ s(?:ec)?).*?(?:-- in |- in )([\w$.]+)\s*$/;const SUREFIRE_TOTAL_RE = /^(?:\[\w+\]\s+)?Tests run: (\d+), Failures: (\d+), Errors: (\d+), Skipped: (\d+)\s*$/;+// `at org.junit…`, also behind a class loader or module (`at app//org.junit…`, `at java.base@21/java.lang…`).+const LIBRARY_FRAME_RE =+ /^\s*at\s+(?:\S*\/)?(?:org\.junit|junit\.|org\.opentest4j|kotlin\.|jdk\.internal|java\.|javax\.|sun\.|org\.gradle)/;++/** The source position of a stack frame in the project's code, null for library frames. */+function frameLocation(line: string): TestLocation | null {+ const f = FRAME_RE.exec(line);+ if (!f || LIBRARY_FRAME_RE.test(line)) return null;+ return f[2] ? jvmFrameTarget(f[1], f[2], Number(f[3])) : { path: f[4]!, line: Number(f[5]), resolve: "name" };+}++/**+ * Test events of the init script's messages. Tests are `[class, method]`, named as in the XML reports+ * (`add(int, int)[1]` → `add`); `outcomes` keeps each test's failure or skip until it finishes.+ */+function initScriptEvents({ kind, attrs }: ServiceMessage, outcomes: Map<string, "failed" | "skipped">): TestEvent[] {+ if (!attrs.className || !attrs.name) return [];+ const path = [attrs.className, attrs.name.split("(")[0]!.trim() || attrs.name];+ const key = path.join("\0");+ // A parameterized method's invocations share its node: one failure fails the method.+ const failed = outcomes.get(key) === "failed";+ switch (kind) {+ case "testStarted":+ if (!failed) outcomes.delete(key);+ return [{ type: "start", path }];+ case "testStdOut":+ case "testStdErr": {+ const text = (attrs.out ?? "").replace(/\r?\n$/, "");+ return text ? text.split(/\r?\n/).map((line) => ({ type: "output", path, line })) : [];+ }+ case "testFailed": {+ outcomes.set(key, "failed");+ const lines = (attrs.details || attrs.message || "").split("\n");+ const events: TestEvent[] = lines.map((line) => ({ type: "output", path, line }));+ const location = lines.map(frameLocation).find((l) => l);+ if (location) events.push({ type: "location", path, location });+ return events;+ }+ case "testIgnored":+ if (!failed) outcomes.set(key, "skipped");+ return [];+ case "testFinished": {+ const status = outcomes.get(key) ?? "passed";+ const durationMs = attrs.duration ? Number(attrs.duration) : undefined;+ return [{ type: "result", path, status, ...(durationMs === undefined ? {} : { durationMs }) }];+ }+ }+ return [];+}export function jvmParser(): TestOutputParser {let failure: string[] | null = null;let located = false;+ /** The init script reports every test: Gradle's own test logging would repeat them by simple class name. */+ let reported = false;+ const outcomes = new Map<string, "failed" | "skipped">();const startFailure = (path: string[]) => {failure = path;@@ -28,8 +84,18 @@ export function jvmParser(): TestOutputParser {return {feed(line) {const events: TestEvent[] = [];+ const message = serviceMessage(line);+ if (message) {+ reported = true;+ failure = null;+ return initScriptEvents(message, outcomes);+ }let m: RegExpExecArray | null;if ((m = GRADLE_RE.exec(line.trim())) && !line.startsWith(" ")) {+ if (reported) {+ failure = null;+ return events;+ }// `method()` is a JUnit 5 display name; the reports name the method.const path = m[1]!.split(/\s+>\s+/).map((p, i, all) => (i === all.length - 1 ? p.replace(/\(\)$/, "") : p));const status = m[2] === "PASSED" ? "passed" : m[2] === "FAILED" ? "failed" : "skipped";@@ -81,20 +147,10 @@ export function jvmParser(): TestOutputParser {return events;}events.push({ type: "output", path: failure, line });- const f = FRAME_RE.exec(line);- const libraryFrame =- /^\s*at\s+(?:org\.junit|junit\.|org\.opentest4j|kotlin\.|jdk\.internal|java\.|javax\.|sun\.|org\.gradle)/.test(- line,- );- if (f && !located && !libraryFrame) {+ const location = located ? null : frameLocation(line);+ if (location) {located = true;- events.push({- type: "location",- path: failure,- location: f[2]- ? jvmFrameTarget(f[1], f[2], Number(f[3]))- : { path: f[4]!, line: Number(f[5]), resolve: "name" },- });+ events.push({ type: "location", path: failure, location });}}return events;diff --git a/src/features/run/testing/parsers.test.ts b/src/features/run/testing/parsers.test.tsindex db5e1f30c..93e74d965 100644--- a/src/features/run/testing/parsers.test.ts+++ b/src/features/run/testing/parsers.test.ts@@ -399,6 +399,53 @@ OrderControllerTest > Paging > firstPage() SKIPPEDexpect(r.get("OrderTest")).toBeUndefined();});+ it("reports each test from the gradle init script's service messages", () => {+ const parser = jvmParser();+ const r = results(+ parser,+ `> Task :test+##teamcity[testStarted name='addsZero()' className='demo.CalcTest']+##teamcity[testStdOut name='addsZero()' className='demo.CalcTest' out='adding zero|n']+##teamcity[testFinished name='addsZero()' className='demo.CalcTest' duration='11']+##teamcity[testStarted name='fails()' className='demo.CalcTest']+##teamcity[testFailed name='fails()' className='demo.CalcTest' message='boom' details='org.opentest4j.AssertionFailedError: boom|n\tat app//org.junit.jupiter.api.AssertEquals.failNotEqual(AssertEquals.java:197)|n\tat app//demo.CalcTest.fails(CalcTest.java:21)|n']+##teamcity[testFinished name='fails()' className='demo.CalcTest' duration='4']+CalcTest > fails() FAILED+ org.opentest4j.AssertionFailedError at CalcTest.java:21+##teamcity[testStarted name='add(int)|[1|]' className='demo.ParamTest']+##teamcity[testFailed name='add(int)|[1|]' className='demo.ParamTest' message='no' details='no']+##teamcity[testFinished name='add(int)|[1|]' className='demo.ParamTest' duration='1']+##teamcity[testStarted name='add(int)|[2|]' className='demo.ParamTest']+##teamcity[testFinished name='add(int)|[2|]' className='demo.ParamTest' duration='1']+##teamcity[testStarted name='later()' className='demo.ParamTest']+##teamcity[testIgnored name='later()' className='demo.ParamTest']+##teamcity[testFinished name='later()' className='demo.ParamTest' duration='0']+`,+ );+ // Named like the XML reports, and not repeated under Gradle's simple class name.+ expect(r.roots.map((n) => n.name)).toEqual(["demo.CalcTest", "demo.ParamTest"]);+ expect(leaf(r, "demo.CalcTest", "addsZero")).toMatchObject({+ own: "passed",+ durationMs: 11,+ output: ["adding zero"],+ });+ const failed = leaf(r, "demo.CalcTest", "fails")!;+ expect(failed.own).toBe("failed");+ expect(failed.output[0]).toBe("org.opentest4j.AssertionFailedError: boom");+ expect(failed.location).toMatchObject({ path: "demo/CalcTest.java", line: 21, className: "demo.CalcTest" });+ expect(leaf(r, "demo.ParamTest", "add")?.own).toBe("failed");+ expect(leaf(r, "demo.ParamTest", "later")?.own).toBe("skipped");+ expect(r.hasResult(["demo.CalcTest", "fails"])).toBe(true);+ expect(r.hasResult(["demo.CalcTest", "other"])).toBe(false);+ });++ it("shows a test as running from its start", () => {+ const r = new TestResults();+ r.apply(jvmParser().feed("##teamcity[testStarted name='slow()' className='demo.SlowTest']"));+ expect(leaf(r, "demo.SlowTest", "slow")?.own).toBe("running");+ expect(r.hasResult(["demo.SlowTest", "slow"])).toBe(false);+ });+it("parses surefire reports", () => {const r = results(jvmParser(),diff --git a/src/features/run/testing/phpunit.test.ts b/src/features/run/testing/phpunit.test.tsindex 8a72967fb..1cf260464 100644--- a/src/features/run/testing/phpunit.test.ts+++ b/src/features/run/testing/phpunit.test.ts@@ -1,6 +1,7 @@import { describe, expect, it } from "vitest";import { createTestParser, frameworkFor, withTestReporting } from "./index";-import { phpunitArgs, phpunitFilter, phpunitParser, TeamcityOutput, withTeamcity } from "./phpunit";+import { phpunitArgs, phpunitFilter, phpunitParser, withTeamcity } from "./phpunit";+import { TeamcityOutput } from "./teamcity";import { TestResults } from "./results";import type { TestEvent } from "./types";diff --git a/src/features/run/testing/phpunit.ts b/src/features/run/testing/phpunit.tsindex eaf986c8f..c6fdbe81f 100644--- a/src/features/run/testing/phpunit.ts+++ b/src/features/run/testing/phpunit.ts@@ -3,24 +3,8 @@* suite and test event, with the exact `Class::method` names and failure details. Tests are reported as* `[...suites, test]`: the configured suite (`Unit`), the class, then the method (with its data set).*/-import { TestStdout, type TestEvent, type TestOutputParser } from "./types";--const MESSAGE_RE = /^\s*##teamcity\[(\w+)((?:\s+[\w.-]+='(?:[^|']|\|.)*')*)\s*\]\s*$/;-const ATTR_RE = /([\w.-]+)='((?:[^|']|\|.)*)'/g;--/** TeamCity escapes: `|n` `|r` `|'` `|[` `|]` `||` and `|0xNNNN`. */-function unescape(value: string): string {- return value.replace(/\|(0x[0-9a-fA-F]{4}|.)/g, (_, c: string) => {- if (c.startsWith("0x")) return String.fromCharCode(Number.parseInt(c, 16));- return c === "n" ? "\n" : c === "r" ? "\r" : c;- });-}--function attributes(text: string): Record<string, string> {- const out: Record<string, string> = {};- for (const m of text.matchAll(ATTR_RE)) out[m[1]!] = unescape(m[2]!);- return out;-}+import { serviceMessage } from "./teamcity";+import type { TestEvent, TestOutputParser } from "./types";/** `php_qn:///app/tests/FooTest.php::\App\FooTest::testBar` → the file. */function hintFile(hint: string | undefined): string | null {@@ -51,10 +35,9 @@ export function phpunitParser(): TestOutputParser {return {feed(line) {- const m = MESSAGE_RE.exec(line);- if (!m) return [];- const kind = m[1]!;- const a = attributes(m[2] ?? "");+ const message = serviceMessage(line);+ if (!message) return [];+ const { kind, attrs: a } = message;const name = a.name ?? "";const events: TestEvent[] = [];switch (kind) {@@ -188,10 +171,3 @@ export function phpunitFilter(paths: readonly (readonly string[])[]): string {}return `/(${[...parts].join("|")})$/`;}--/** Console text of a `--teamcity` run: the service messages only feed the test tree, as in PhpStorm. */-export class TeamcityOutput extends TestStdout {- constructor(feedLine: (line: string) => void) {- super(feedLine, (line) => (MESSAGE_RE.test(line) ? "" : line + "\n"));- }-}diff --git a/src/features/run/testing/results.ts b/src/features/run/testing/results.tsindex 468ff6364..e0c75aca7 100644--- a/src/features/run/testing/results.ts+++ b/src/features/run/testing/results.ts@@ -68,6 +68,12 @@ export class TestResults {return this.byId.get(id);}+ /** The test at `path` has finished with a result. */+ hasResult(path: readonly string[]): boolean {+ const own = this.byId.get(path.join(SEP))?.own;+ return !!own && own !== "running";+ }+/** Finds a test by a suffix of its path (pytest failure headers name `Class.test`). */findBySuffix(suffix: string[]): TestNode | undefined {let best: TestNode | undefined;diff --git a/src/features/run/testing/teamcity.ts b/src/features/run/testing/teamcity.tsnew file mode 100644index 000000000..cbb495b7d--- /dev/null+++ b/src/features/run/testing/teamcity.ts@@ -0,0 +1,37 @@+/**+ * TeamCity service messages (`##teamcity[testStarted name='…' …]`): PHPUnit's `--teamcity` output and+ * the Gradle test init script (`gradleTests.gradle`) report each test with them.+ */+import { TestStdout } from "./types";++const MESSAGE_RE = /^\s*##teamcity\[(\w+)((?:\s+[\w.-]+='(?:[^|']|\|.)*')*)\s*\]\s*$/;+const ATTR_RE = /([\w.-]+)='((?:[^|']|\|.)*)'/g;++/** TeamCity escapes: `|n` `|r` `|'` `|[` `|]` `||` and `|0xNNNN`. */+function unescape(value: string): string {+ return value.replace(/\|(0x[0-9a-fA-F]{4}|.)/g, (_, c: string) => {+ if (c.startsWith("0x")) return String.fromCharCode(Number.parseInt(c, 16));+ return c === "n" ? "\n" : c === "r" ? "\r" : c;+ });+}++export interface ServiceMessage {+ kind: string;+ attrs: Record<string, string>;+}++/** The service message on `line`, or null for any other output. */+export function serviceMessage(line: string): ServiceMessage | null {+ const m = MESSAGE_RE.exec(line);+ if (!m) return null;+ const attrs: Record<string, string> = {};+ for (const a of (m[2] ?? "").matchAll(ATTR_RE)) attrs[a[1]!] = unescape(a[2]!);+ return { kind: m[1]!, attrs };+}++/** Console text of a run reporting through service messages: the messages only feed the test tree. */+export class TeamcityOutput extends TestStdout {+ constructor(feedLine: (line: string) => void) {+ super(feedLine, (line) => (MESSAGE_RE.test(line) ? "" : line + "\n"));+ }+}