Refactoring & cleanup of whole codebase

Improves report summary and annotations

__tests__/__outputs__/dotnet-trx.md

@@ -5,7 +5,7 @@
 |:---|---:|---:|---:|---:|
 |[DotnetTests.XUnitTests.CalculatorTests](#r0s0)|3✔️|3❌|1✖️|110ms|
 ### <a id="user-content-r0s0" href="#r0s0">DotnetTests.XUnitTests.CalculatorTests</a> ❌
-**7** tests were completed in **109.5761ms** with **3** passed, **3** failed and **1** skipped.
+**7** tests were completed in **110ms** with **3** passed, **3** failed and **1** skipped.
 
 |Result|Test|Time|
 |:---:|:---|---:|

__tests__/__outputs__/jest-test-results.md

@@ -404,7 +404,7 @@
 |packages/pretty-format/src/__tests__/react.test.tsx|55✔️|||325ms|
 |packages/pretty-format/src/__tests__/ReactElement.test.ts|3✔️|||64ms|
 ### <a id="user-content-r0s75" href="#r0s75">e2e/__tests__/jestChangedFiles.test.ts</a> ❌
-**10** tests were completed in **9045ms** with **9** passed, **1** failed and **0** skipped.
+**10** tests were completed in **9.045s** with **9** passed, **1** failed and **0** skipped.
 
 |Result|Test|Time|
 |:---:|:---|---:|
@@ -419,7 +419,7 @@
 |✔️|monitors only root paths for hg|281ms|
 |✔️|handles a bad revision for "changedSince", for hg|949ms|
 ### <a id="user-content-r0s98" href="#r0s98">e2e/__tests__/onlyChanged.test.ts</a> ❌
-**9** tests were completed in **22281ms** with **8** passed, **1** failed and **0** skipped.
+**9** tests were completed in **22.281s** with **8** passed, **1** failed and **0** skipped.
 
 |Result|Test|Time|
 |:---:|:---|---:|

__tests__/__snapshots__/dart-json.test.ts.snap

@@ -1,126 +1,106 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`dart-json tests matches report snapshot 1`] = `
-Object {
+TestRunResult {
-  "annotations": Array [
+  "path": "fixtures/dart-json.json",
-    Object {
+  "suites": Array [
-      "annotation_level": "failure",
+    TestSuiteResult {
-      "end_line": 13,
+      "groups": Array [
-      "message": "Expected: <2>
+        TestGroupResult {
+          "name": "Test 1",
+          "tests": Array [
+            TestCaseResult {
+              "error": undefined,
+              "name": "Test 1 Passing test",
+              "result": "success",
+              "time": 36,
+            },
+          ],
+        },
+        TestGroupResult {
+          "name": "Test 1 Test 1.1",
+          "tests": Array [
+            TestCaseResult {
+              "error": Object {
+                "line": 13,
+                "message": "Expected: <2>
   Actual: <1>
-
+",
-
+                "path": "test/main_test.dart",
-package:test_api          expect
+                "stackTrace": "package:test_api          expect
 test\\\\main_test.dart 13:9  main.<fn>.<fn>.<fn>
 ",
-      "path": "test/main_test.dart",
+              },
-      "start_line": 13,
+              "name": "Test 1 Test 1.1 Failing test",
-      "title": "[test\\\\main_test.dart] Test 1 Test 1.1 Failing test",
+              "result": "failed",
-    },
+              "time": 20,
-    Object {
+            },
-      "annotation_level": "failure",
+            TestCaseResult {
-      "end_line": 2,
+              "error": Object {
-      "message": "Exception: Some error
+                "line": 2,
-
+                "message": "Exception: Some error",
-package:darttest/main.dart 2:3  throwError
+                "path": "lib/main.dart",
+                "stackTrace": "package:darttest/main.dart 2:3  throwError
 test\\\\main_test.dart 17:9        main.<fn>.<fn>.<fn>
 ",
-      "path": "lib/main.dart",
+              },
-      "start_line": 2,
+              "name": "Test 1 Test 1.1 Exception in target unit",
-      "title": "[test\\\\main_test.dart] Test 1 Test 1.1 Exception in target unit",
+              "result": "failed",
-    },
+              "time": 6,
-    Object {
-      "annotation_level": "failure",
-      "end_line": 24,
-      "message": "Exception: Some error
-
-test\\\\main_test.dart 24:7  main.<fn>.<fn>
-",
-      "path": "test/main_test.dart",
-      "start_line": 24,
-      "title": "[test\\\\main_test.dart] Test 2 Exception in test",
-    },
-    Object {
-      "annotation_level": "failure",
-      "end_line": 5,
-      "message": "TimeoutException after 0:00:00.000001: Test timed out after 0 seconds.
-
-dart:isolate  _RawReceivePortImpl._handleMessage
-",
-      "path": "test/second_test.dart",
-      "start_line": 5,
-      "title": "[test\\\\second_test.dart] Timeout test",
-    },
-  ],
-  "testRuns": Array [
-    TestRunResult {
-      "path": "fixtures/dart-json.json",
-      "suites": Array [
-        TestSuiteResult {
-          "groups": Array [
-            TestGroupResult {
-              "name": "Test 1",
-              "tests": Array [
-                TestCaseResult {
-                  "name": "Test 1 Passing test",
-                  "result": "success",
-                  "time": 36,
-                },
-              ],
-            },
-            TestGroupResult {
-              "name": "Test 1 Test 1.1",
-              "tests": Array [
-                TestCaseResult {
-                  "name": "Test 1 Test 1.1 Failing test",
-                  "result": "failed",
-                  "time": 20,
-                },
-                TestCaseResult {
-                  "name": "Test 1 Test 1.1 Exception in target unit",
-                  "result": "failed",
-                  "time": 6,
-                },
-              ],
-            },
-            TestGroupResult {
-              "name": "Test 2",
-              "tests": Array [
-                TestCaseResult {
-                  "name": "Test 2 Exception in test",
-                  "result": "failed",
-                  "time": 12,
-                },
-              ],
             },
           ],
-          "name": "test\\\\main_test.dart",
-          "totalTime": undefined,
         },
-        TestSuiteResult {
+        TestGroupResult {
-          "groups": Array [
+          "name": "Test 2",
-            TestGroupResult {
+          "tests": Array [
-              "name": null,
+            TestCaseResult {
-              "tests": Array [
+              "error": Object {
-                TestCaseResult {
+                "line": 24,
-                  "name": "Timeout test",
+                "message": "Exception: Some error",
-                  "result": "failed",
+                "path": "test/main_test.dart",
-                  "time": 37,
+                "stackTrace": "test\\\\main_test.dart 24:7  main.<fn>.<fn>
-                },
+",
-                TestCaseResult {
+              },
-                  "name": "Skipped test",
+              "name": "Test 2 Exception in test",
-                  "result": "skipped",
+              "result": "failed",
-                  "time": 14,
+              "time": 12,
-                },
-              ],
             },
           ],
-          "name": "test\\\\second_test.dart",
-          "totalTime": undefined,
         },
       ],
-      "totalTime": 3760,
+      "name": "test\\\\main_test.dart",
+      "totalTime": undefined,
+    },
+    TestSuiteResult {
+      "groups": Array [
+        TestGroupResult {
+          "name": null,
+          "tests": Array [
+            TestCaseResult {
+              "error": Object {
+                "line": 5,
+                "message": "TimeoutException after 0:00:00.000001: Test timed out after 0 seconds.",
+                "path": "test/second_test.dart",
+                "stackTrace": "dart:isolate  _RawReceivePortImpl._handleMessage
+",
+              },
+              "name": "Timeout test",
+              "result": "failed",
+              "time": 37,
+            },
+            TestCaseResult {
+              "error": undefined,
+              "name": "Skipped test",
+              "result": "skipped",
+              "time": 14,
+            },
+          ],
+        },
+      ],
+      "name": "test\\\\second_test.dart",
+      "totalTime": undefined,
     },
   ],
+  "totalTime": 3760,
 }
 `;

__tests__/dart-json.test.ts

@@ -1,30 +1,29 @@
 import * as fs from 'fs'
 import * as path from 'path'
 
-import {parseDartJson} from '../src/parsers/dart-json/dart-json-parser'
+import {DartJsonParser} from '../src/parsers/dart-json/dart-json-parser'
-import {ParseOptions} from '../src/parsers/parser-types'
+import {ParseOptions} from '../src/test-parser'
 import {getReport} from '../src/report/get-report'
 import {normalizeFilePath} from '../src/utils/file-utils'
 
-const fixturePath = path.join(__dirname, 'fixtures', 'dart-json.json')
-const outputPath = path.join(__dirname, '__outputs__', 'dart-json.md')
-const xmlFixture = {
-  path: normalizeFilePath(path.relative(__dirname, fixturePath)),
-  content: fs.readFileSync(fixturePath, {encoding: 'utf8'})
-}
-
 describe('dart-json tests', () => {
   it('matches report snapshot', async () => {
     const opts: ParseOptions = {
-      annotations: true,
+      parseErrors: true,
       trackedFiles: ['lib/main.dart', 'test/main_test.dart', 'test/second_test.dart'],
       workDir: 'C:/Users/Michal/Workspace/dorny/test-check/reports/dart/'
     }
 
-    const result = await parseDartJson([xmlFixture], opts)
+    const fixturePath = path.join(__dirname, 'fixtures', 'dart-json.json')
+    const outputPath = path.join(__dirname, '__outputs__', 'dart-json.md')
+    const filePath = normalizeFilePath(path.relative(__dirname, fixturePath))
+    const fileContent = fs.readFileSync(fixturePath, {encoding: 'utf8'})
+
+    const parser = new DartJsonParser(opts)
+    const result = await parser.parse(filePath, fileContent)
     expect(result).toMatchSnapshot()
 
-    const report = getReport(result.testRuns)
+    const report = getReport([result])
     fs.mkdirSync(path.dirname(outputPath), {recursive: true})
     fs.writeFileSync(outputPath, report)
   })

__tests__/dotnet-trx.test.ts

@@ -1,8 +1,8 @@
 import * as fs from 'fs'
 import * as path from 'path'
 
-import {parseDotnetTrx} from '../src/parsers/dotnet-trx/dotnet-trx-parser'
+import {DotnetTrxParser} from '../src/parsers/dotnet-trx/dotnet-trx-parser'
-import {ParseOptions} from '../src/parsers/parser-types'
+import {ParseOptions} from '../src/test-parser'
 import {getReport} from '../src/report/get-report'
 import {normalizeFilePath} from '../src/utils/file-utils'
 
@@ -10,21 +10,20 @@ describe('dotnet-trx tests', () => {
   it('matches report snapshot', async () => {
     const fixturePath = path.join(__dirname, 'fixtures', 'dotnet-trx.trx')
     const outputPath = path.join(__dirname, '__outputs__', 'dotnet-trx.md')
-    const xmlFixture = {
+    const filePath = normalizeFilePath(path.relative(__dirname, fixturePath))
-      path: normalizeFilePath(path.relative(__dirname, fixturePath)),
+    const fileContent = fs.readFileSync(fixturePath, {encoding: 'utf8'})
-      content: fs.readFileSync(fixturePath, {encoding: 'utf8'})
-    }
 
     const opts: ParseOptions = {
-      annotations: true,
+      parseErrors: true,
       trackedFiles: ['DotnetTests.Unit/Calculator.cs', 'DotnetTests.XUnitTests/CalculatorTests.cs'],
       workDir: 'C:/Users/Michal/Workspace/dorny/test-check/reports/dotnet/'
     }
 
-    const result = await parseDotnetTrx([xmlFixture], opts)
+    const parser = new DotnetTrxParser(opts)
+    const result = await parser.parse(filePath, fileContent)
     expect(result).toMatchSnapshot()
 
-    const report = getReport(result.testRuns)
+    const report = getReport([result])
     fs.mkdirSync(path.dirname(outputPath), {recursive: true})
     fs.writeFileSync(outputPath, report)
   })
@@ -32,21 +31,20 @@ describe('dotnet-trx tests', () => {
   it('report from FluentValidation test results matches snapshot', async () => {
     const fixturePath = path.join(__dirname, 'fixtures', 'external', 'FluentValidation.Tests.trx')
     const outputPath = path.join(__dirname, '__outputs__', 'fluent-validation-test-results.md')
-    const xmlFixture = {
+    const filePath = normalizeFilePath(path.relative(__dirname, fixturePath))
-      path: normalizeFilePath(path.relative(__dirname, fixturePath)),
+    const fileContent = fs.readFileSync(fixturePath, {encoding: 'utf8'})
-      content: fs.readFileSync(fixturePath, {encoding: 'utf8'})
-    }
 
     const opts: ParseOptions = {
       trackedFiles: [],
-      annotations: true,
+      parseErrors: true,
       workDir: ''
     }
 
-    const result = await parseDotnetTrx([xmlFixture], opts)
+    const parser = new DotnetTrxParser(opts)
+    const result = await parser.parse(filePath, fileContent)
     expect(result).toMatchSnapshot()
 
-    const report = getReport(result.testRuns, {listTests: 'failed'})
+    const report = getReport([result], {listTests: 'failed'})
     fs.mkdirSync(path.dirname(outputPath), {recursive: true})
     fs.writeFileSync(outputPath, report)
   })

__tests__/jest-junit.test.ts

@@ -1,8 +1,8 @@
 import * as fs from 'fs'
 import * as path from 'path'
 
-import {parseJestJunit} from '../src/parsers/jest-junit/jest-junit-parser'
+import {JestJunitParser} from '../src/parsers/jest-junit/jest-junit-parser'
-import {ParseOptions} from '../src/parsers/parser-types'
+import {ParseOptions} from '../src/test-parser'
 import {getReport} from '../src/report/get-report'
 import {normalizeFilePath} from '../src/utils/file-utils'
 
@@ -10,45 +10,43 @@ describe('jest-junit tests', () => {
   it('report from ./reports/jest test results matches snapshot', async () => {
     const fixturePath = path.join(__dirname, 'fixtures', 'jest-junit.xml')
     const outputPath = path.join(__dirname, '__outputs__', 'jest-junit.md')
-    const xmlFixture = {
+    const filePath = normalizeFilePath(path.relative(__dirname, fixturePath))
-      path: normalizeFilePath(path.relative(__dirname, fixturePath)),
+    const fileContent = fs.readFileSync(fixturePath, {encoding: 'utf8'})
-      content: fs.readFileSync(fixturePath, {encoding: 'utf8'})
-    }
 
     const opts: ParseOptions = {
-      annotations: true,
+      parseErrors: true,
       trackedFiles: ['__tests__/main.test.js', '__tests__/second.test.js', 'lib/main.js'],
       workDir: 'C:/Users/Michal/Workspace/dorny/test-check/reports/jest/'
     }
 
-    const result = await parseJestJunit([xmlFixture], opts)
+    const parser = new JestJunitParser(opts)
+    const result = await parser.parse(filePath, fileContent)
     expect(result).toMatchSnapshot()
 
-    const report = getReport(result.testRuns)
+    const report = getReport([result])
     fs.mkdirSync(path.dirname(outputPath), {recursive: true})
     fs.writeFileSync(outputPath, report)
   })
 
   it('report from facebook/jest test results matches snapshot', async () => {
     const fixturePath = path.join(__dirname, 'fixtures', 'external', 'jest', 'jest-test-results.xml')
-    const filesPath = path.join(__dirname, 'fixtures', 'external', 'jest', 'files.txt')
+    const trackedFilesPath = path.join(__dirname, 'fixtures', 'external', 'jest', 'files.txt')
     const outputPath = path.join(__dirname, '__outputs__', 'jest-test-results.md')
-    const xmlFixture = {
+    const filePath = normalizeFilePath(path.relative(__dirname, fixturePath))
-      path: normalizeFilePath(path.relative(__dirname, fixturePath)),
+    const fileContent = fs.readFileSync(fixturePath, {encoding: 'utf8'})
-      content: fs.readFileSync(fixturePath, {encoding: 'utf8'})
-    }
 
-    const trackedFiles = fs.readFileSync(filesPath, {encoding: 'utf8'}).split(/\n\r?/g)
+    const trackedFiles = fs.readFileSync(trackedFilesPath, {encoding: 'utf8'}).split(/\n\r?/g)
     const opts: ParseOptions = {
+      parseErrors: true,
       trackedFiles,
-      annotations: true,
       workDir: '/home/dorny/dorny/jest/'
     }
 
-    const result = await parseJestJunit([xmlFixture], opts)
+    const parser = new JestJunitParser(opts)
+    const result = await parser.parse(filePath, fileContent)
     expect(result).toMatchSnapshot()
 
-    const report = getReport(result.testRuns, {listTests: 'failed'})
+    const report = getReport([result], {listTests: 'failed'})
     fs.mkdirSync(path.dirname(outputPath), {recursive: true})
     fs.writeFileSync(outputPath, report)
   })

dist/index.js

@@ -35,10 +35,11 @@ const core = __importStar(__nccwpck_require__(2186));
 const github = __importStar(__nccwpck_require__(5438));
 const fs = __importStar(__nccwpck_require__(5747));
 const fast_glob_1 = __importDefault(__nccwpck_require__(3664));
+const get_annotations_1 = __nccwpck_require__(5867);
+const get_report_1 = __nccwpck_require__(3737);
 const dart_json_parser_1 = __nccwpck_require__(4528);
 const dotnet_trx_parser_1 = __nccwpck_require__(2664);
 const jest_junit_parser_1 = __nccwpck_require__(1113);
-const get_report_1 = __nccwpck_require__(3737);
 const file_utils_1 = __nccwpck_require__(2711);
 const git_1 = __nccwpck_require__(9844);
 const github_utils_1 = __nccwpck_require__(3522);
@@ -81,23 +82,32 @@ async function main() {
     const octokit = github.getOctokit(token);
     const sha = github_utils_1.getCheckRunSha();
     // We won't need tracked files if we are not going to create annotations
-    const annotations = maxAnnotations > 0;
+    const parseErrors = maxAnnotations > 0;
-    const trackedFiles = annotations ? await git_1.listFiles() : [];
+    const trackedFiles = parseErrors ? await git_1.listFiles() : [];
-    const opts = {
+    const options = {
         trackedFiles,
         workDir,
-        annotations
+        parseErrors
     };
-    const parser = getParser(reporter);
+    core.info(`Using test report parser '${reporter}'`);
+    const parser = getParser(reporter, options);
     const files = await getFiles(path);
     if (files.length === 0) {
         core.setFailed(`No file matches path '${path}'`);
         return;
     }
-    core.info(`Using test report parser '${reporter}'`);
+    const results = [];
-    const result = await parser(files, opts);
+    for (const file of files) {
-    github_utils_1.enforceCheckRunLimits(result, maxAnnotations);
+        core.info(`Processing test report ${file}`);
-    const isFailed = result.testRuns.some(tr => tr.result === 'failed');
+        const content = await fs.promises.readFile(file, { encoding: 'utf8' });
+        const tr = await parser.parse(file, content);
+        results.push(tr);
+    }
+    core.info('Creating report summary');
+    const summary = get_report_1.getReport(results, { listSuites, listTests });
+    core.info('Creating annotations');
+    const annotations = get_annotations_1.getAnnotations(results, maxAnnotations);
+    const isFailed = results.some(tr => tr.result === 'failed');
     const conclusion = isFailed ? 'failure' : 'success';
     const icon = isFailed ? markdown_utils_1.Icon.fail : markdown_utils_1.Icon.success;
     core.info(`Creating check run '${name}' with conclusion '${conclusion}'`);
@@ -108,38 +118,42 @@ async function main() {
         status: 'completed',
         output: {
             title: `${name} ${icon}`,
-            summary: get_report_1.getReport(result.testRuns, { listSuites, listTests }),
+            summary,
-            annotations: result.annotations
+            annotations
         },
         ...github.context.repo
     });
+    const passed = results.reduce((sum, tr) => sum + tr.passed, 0);
+    const failed = results.reduce((sum, tr) => sum + tr.failed, 0);
+    const skipped = results.reduce((sum, tr) => sum + tr.skipped, 0);
+    const time = results.reduce((sum, tr) => sum + tr.time, 0);
     core.setOutput('conclusion', conclusion);
+    core.setOutput('passed', passed);
+    core.setOutput('failed', failed);
+    core.setOutput('skipped', skipped);
+    core.setOutput('time', time);
     if (failOnError && isFailed) {
         core.setFailed(`Failed test has been found and 'fail-on-error' option is set to ${failOnError}`);
     }
 }
-function getParser(reporter) {
+function getParser(reporter, options) {
     switch (reporter) {
         case 'dart-json':
-            return dart_json_parser_1.parseDartJson;
+            return new dart_json_parser_1.DartJsonParser(options);
         case 'dotnet-trx':
-            return dotnet_trx_parser_1.parseDotnetTrx;
+            return new dotnet_trx_parser_1.DotnetTrxParser(options);
         case 'flutter-machine':
-            return dart_json_parser_1.parseDartJson;
+            return new dart_json_parser_1.DartJsonParser(options);
         case 'jest-junit':
-            return jest_junit_parser_1.parseJestJunit;
+            return new jest_junit_parser_1.JestJunitParser(options);
         default:
             throw new Error(`Input variable 'reporter' is set to invalid value '${reporter}'`);
     }
 }
 async function getFiles(pattern) {
-    const paths = (await Promise.all(pattern.split(',').map(async (pat) => fast_glob_1.default(pat, { dot: true })))).flat();
+    const tasks = pattern.split(',').map(async (pat) => fast_glob_1.default(pat, { dot: true }));
-    const files = Promise.all(paths.map(async (path) => {
+    const paths = await Promise.all(tasks);
-        core.info(`Reading test report '${path}'`);
+    return paths.flat();
-        const content = await fs.promises.readFile(path, { encoding: 'utf8' });
-        return { path, content };
-    }));
-    return files;
 }
 exports.getFiles = getFiles;
 run();
@@ -172,12 +186,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.parseDartJson = void 0;
+exports.DartJsonParser = void 0;
 const core = __importStar(__nccwpck_require__(2186));
 const file_utils_1 = __nccwpck_require__(2711);
-const markdown_utils_1 = __nccwpck_require__(6482);
 const dart_json_types_1 = __nccwpck_require__(7887);
-const test_results_1 = __nccwpck_require__(8407);
+const test_results_1 = __nccwpck_require__(2768);
 class TestRun {
     constructor(path, suites, success, time) {
         this.path = path;
@@ -220,148 +233,141 @@ class TestCase {
         return this.testDone !== undefined ? this.testDone.time - this.testStart.time : 0;
     }
 }
-async function parseDartJson(files, options) {
+class DartJsonParser {
-    const testRuns = files.map(f => getTestRun(f.path, f.content));
+    constructor(options) {
-    const testRunsResults = testRuns.map(getTestRunResult);
+        this.options = options;
-    return {
-        testRuns: testRunsResults,
-        annotations: options.annotations ? getAnnotations(testRuns, options.workDir, options.trackedFiles) : []
-    };
-}
-exports.parseDartJson = parseDartJson;
-function getTestRun(path, content) {
-    core.info(`Parsing content of '${path}'`);
-    const lines = content.split(/\n\r?/g);
-    const events = lines
-        .map((str, i) => {
-        if (str.trim() === '') {
-            return null;
-        }
-        try {
-            return JSON.parse(str);
-        }
-        catch (e) {
-            const col = e.columnNumber !== undefined ? `:${e.columnNumber}` : '';
-            new Error(`Invalid JSON at ${path}:${i + 1}${col}\n\n${e}`);
-        }
-    })
-        .filter(evt => evt != null);
-    let success = false;
-    let totalTime = 0;
-    const suites = {};
-    const tests = {};
-    for (const evt of events) {
-        if (dart_json_types_1.isSuiteEvent(evt)) {
-            suites[evt.suite.id] = new TestSuite(evt.suite);
-        }
-        else if (dart_json_types_1.isGroupEvent(evt)) {
-            suites[evt.group.suiteID].groups[evt.group.id] = new TestGroup(evt.group);
-        }
-        else if (dart_json_types_1.isTestStartEvent(evt) && evt.test.url !== null) {
-            const test = new TestCase(evt);
-            const suite = suites[evt.test.suiteID];
-            const group = suite.groups[evt.test.groupIDs[evt.test.groupIDs.length - 1]];
-            group.tests.push(test);
-            tests[evt.test.id] = test;
-        }
-        else if (dart_json_types_1.isTestDoneEvent(evt) && !evt.hidden) {
-            tests[evt.testID].testDone = evt;
-        }
-        else if (dart_json_types_1.isErrorEvent(evt)) {
-            tests[evt.testID].error = evt;
-        }
-        else if (dart_json_types_1.isDoneEvent(evt)) {
-            success = evt.success;
-            totalTime = evt.time;
-        }
     }
-    return new TestRun(path, Object.values(suites), success, totalTime);
+    async parse(path, content) {
-}
+        const tr = this.getTestRun(path, content);
-function getTestRunResult(tr) {
+        const result = this.getTestRunResult(tr);
-    const suites = tr.suites.map(s => {
+        return Promise.resolve(result);
-        return new test_results_1.TestSuiteResult(s.suite.path, getGroups(s));
+    }
-    });
+    getTestRun(path, content) {
-    return new test_results_1.TestRunResult(tr.path, suites, tr.time);
+        core.info(`Parsing content of '${path}'`);
-}
+        const lines = content.split(/\n\r?/g);
-function getGroups(suite) {
+        const events = lines
-    const groups = Object.values(suite.groups).filter(grp => grp.tests.length > 0);
+            .map((str, i) => {
-    groups.sort((a, b) => { var _a, _b; return ((_a = a.group.line) !== null && _a !== void 0 ? _a : 0) - ((_b = b.group.line) !== null && _b !== void 0 ? _b : 0); });
+            if (str.trim() === '') {
-    return groups.map(group => {
+                return null;
-        group.tests.sort((a, b) => { var _a, _b; return ((_a = a.testStart.test.line) !== null && _a !== void 0 ? _a : 0) - ((_b = b.testStart.test.line) !== null && _b !== void 0 ? _b : 0); });
+            }
-        const tests = group.tests.map(t => new test_results_1.TestCaseResult(t.testStart.test.name, t.result, t.time));
+            try {
-        return new test_results_1.TestGroupResult(group.group.name, tests);
+                return JSON.parse(str);
-    });
+            }
-}
+            catch (e) {
-function getAnnotations(testRuns, workDir, trackedFiles) {
+                const col = e.columnNumber !== undefined ? `:${e.columnNumber}` : '';
-    const annotations = [];
+                new Error(`Invalid JSON at ${path}:${i + 1}${col}\n\n${e}`);
-    for (const tr of testRuns) {
+            }
-        for (const suite of tr.suites) {
+        })
-            for (const group of Object.values(suite.groups)) {
+            .filter(evt => evt != null);
-                for (const test of group.tests) {
+        let success = false;
-                    if (test.error) {
+        let totalTime = 0;
-                        const err = getAnnotation(test, suite, workDir, trackedFiles);
+        const suites = {};
-                        if (err !== null) {
+        const tests = {};
-                            annotations.push(err);
+        for (const evt of events) {
-                        }
+            if (dart_json_types_1.isSuiteEvent(evt)) {
-                    }
+                suites[evt.suite.id] = new TestSuite(evt.suite);
+            }
+            else if (dart_json_types_1.isGroupEvent(evt)) {
+                suites[evt.group.suiteID].groups[evt.group.id] = new TestGroup(evt.group);
+            }
+            else if (dart_json_types_1.isTestStartEvent(evt) && evt.test.url !== null) {
+                const test = new TestCase(evt);
+                const suite = suites[evt.test.suiteID];
+                const group = suite.groups[evt.test.groupIDs[evt.test.groupIDs.length - 1]];
+                group.tests.push(test);
+                tests[evt.test.id] = test;
+            }
+            else if (dart_json_types_1.isTestDoneEvent(evt) && !evt.hidden) {
+                tests[evt.testID].testDone = evt;
+            }
+            else if (dart_json_types_1.isErrorEvent(evt)) {
+                tests[evt.testID].error = evt;
+            }
+            else if (dart_json_types_1.isDoneEvent(evt)) {
+                success = evt.success;
+                totalTime = evt.time;
+            }
+        }
+        return new TestRun(path, Object.values(suites), success, totalTime);
+    }
+    getTestRunResult(tr) {
+        const suites = tr.suites.map(s => {
+            return new test_results_1.TestSuiteResult(s.suite.path, this.getGroups(s));
+        });
+        return new test_results_1.TestRunResult(tr.path, suites, tr.time);
+    }
+    getGroups(suite) {
+        const groups = Object.values(suite.groups).filter(grp => grp.tests.length > 0);
+        groups.sort((a, b) => { var _a, _b; return ((_a = a.group.line) !== null && _a !== void 0 ? _a : 0) - ((_b = b.group.line) !== null && _b !== void 0 ? _b : 0); });
+        return groups.map(group => {
+            group.tests.sort((a, b) => { var _a, _b; return ((_a = a.testStart.test.line) !== null && _a !== void 0 ? _a : 0) - ((_b = b.testStart.test.line) !== null && _b !== void 0 ? _b : 0); });
+            const tests = group.tests.map(t => this.getTest(t));
+            return new test_results_1.TestGroupResult(group.group.name, tests);
+        });
+    }
+    getTest(tc) {
+        const error = this.getError(tc);
+        return new test_results_1.TestCaseResult(tc.testStart.test.name, tc.result, tc.time, error);
+    }
+    getError(test) {
+        var _a, _b, _c, _d, _e, _f;
+        if (!this.options.parseErrors || !test.error) {
+            return undefined;
+        }
+        const { workDir, trackedFiles } = this.options;
+        const message = (_b = (_a = test.error) === null || _a === void 0 ? void 0 : _a.error) !== null && _b !== void 0 ? _b : '';
+        const stackTrace = (_d = (_c = test.error) === null || _c === void 0 ? void 0 : _c.stackTrace) !== null && _d !== void 0 ? _d : '';
+        const src = this.exceptionThrowSource(stackTrace, trackedFiles);
+        let path;
+        let line;
+        if (src !== undefined) {
+            ;
+            (path = src.path), (line = src.line);
+        }
+        else {
+            const testStartPath = this.getRelativePathFromUrl((_e = test.testStart.test.url) !== null && _e !== void 0 ? _e : '', workDir);
+            if (trackedFiles.includes(testStartPath)) {
+                path = testStartPath;
+            }
+            line = (_f = test.testStart.test.line) !== null && _f !== void 0 ? _f : undefined;
+        }
+        return {
+            path,
+            line,
+            message,
+            stackTrace
+        };
+    }
+    exceptionThrowSource(ex, trackedFiles) {
+        // imports from package which is tested are listed in stack traces as 'package:xyz/' which maps to relative path 'lib/'
+        const packageRe = /^package:[a-zA-z0-9_$]+\//;
+        const lines = ex.split(/\r?\n/).map(str => str.replace(packageRe, 'lib/'));
+        // regexp to extract file path and line number from stack trace
+        const re = /^(.*)\s+(\d+):\d+\s+/;
+        for (const str of lines) {
+            const match = str.match(re);
+            if (match !== null) {
+                const [_, pathStr, lineStr] = match;
+                const path = file_utils_1.normalizeFilePath(pathStr);
+                if (trackedFiles.includes(path)) {
+                    const line = parseInt(lineStr);
+                    return { path, line };
                 }
             }
         }
     }
-    return annotations;
+    getRelativePathFromUrl(file, workDir) {
-}
+        const prefix = 'file:///';
-function getAnnotation(test, testSuite, workDir, trackedFiles) {
+        if (file.startsWith(prefix)) {
-    var _a, _b, _c, _d, _e, _f;
+            file = file.substr(prefix.length);
-    const stack = (_b = (_a = test.error) === null || _a === void 0 ? void 0 : _a.stackTrace) !== null && _b !== void 0 ? _b : '';
-    let src = exceptionThrowSource(stack, trackedFiles);
-    if (src === null) {
-        const file = getRelativePathFromUrl((_c = test.testStart.test.url) !== null && _c !== void 0 ? _c : '', workDir);
-        if (!trackedFiles.includes(file)) {
-            return null;
         }
-        src = {
+        if (file.startsWith(workDir)) {
-            file,
+            file = file.substr(workDir.length);
-            line: (_d = test.testStart.test.line) !== null && _d !== void 0 ? _d : 0
-        };
-    }
-    return {
-        annotation_level: 'failure',
-        start_line: src.line,
-        end_line: src.line,
-        path: src.file,
-        message: `${markdown_utils_1.fixEol((_e = test.error) === null || _e === void 0 ? void 0 : _e.error)}\n\n${markdown_utils_1.fixEol((_f = test.error) === null || _f === void 0 ? void 0 : _f.stackTrace)}`,
-        title: `[${testSuite.suite.path}] ${test.testStart.test.name}`
-    };
-}
-function exceptionThrowSource(ex, trackedFiles) {
-    // imports from package which is tested are listed in stack traces as 'package:xyz/' which maps to relative path 'lib/'
-    const packageRe = /^package:[a-zA-z0-9_$]+\//;
-    const lines = ex.split(/\r?\n/).map(str => str.replace(packageRe, 'lib/'));
-    // regexp to extract file path and line number from stack trace
-    const re = /^(.*)\s+(\d+):\d+\s+/;
-    for (const str of lines) {
-        const match = str.match(re);
-        if (match !== null) {
-            const [_, fileStr, lineStr] = match;
-            const file = file_utils_1.normalizeFilePath(fileStr);
-            if (trackedFiles.includes(file)) {
-                const line = parseInt(lineStr);
-                return { file, line };
-            }
         }
+        return file;
     }
-    return null;
-}
-function getRelativePathFromUrl(file, workdir) {
-    const prefix = 'file:///';
-    if (file.startsWith(prefix)) {
-        file = file.substr(prefix.length);
-    }
-    if (file.startsWith(workdir)) {
-        file = file.substr(workdir.length);
-    }
-    return file;
 }
+exports.DartJsonParser = DartJsonParser;
 
 
 /***/ }),
@@ -427,13 +433,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.exceptionThrowSource = exports.parseDotnetTrx = void 0;
+exports.DotnetTrxParser = void 0;
 const core = __importStar(__nccwpck_require__(2186));
 const xml2js_1 = __nccwpck_require__(6189);
 const file_utils_1 = __nccwpck_require__(2711);
-const markdown_utils_1 = __nccwpck_require__(6482);
 const parse_utils_1 = __nccwpck_require__(7811);
-const test_results_1 = __nccwpck_require__(8407);
+const test_results_1 = __nccwpck_require__(2768);
 class TestClass {
     constructor(name) {
         this.name = name;
@@ -458,113 +463,109 @@ class Test {
         }
     }
 }
-async function parseDotnetTrx(files, options) {
+class DotnetTrxParser {
-    const testRuns = [];
+    constructor(options) {
-    const testClasses = [];
+        this.options = options;
-    for (const file of files) {
-        const trx = await getTrxReport(file);
-        const tc = getTestClasses(trx);
-        const tr = getTestRunResult(file.path, trx, tc);
-        testRuns.push(tr);
-        testClasses.push(...tc);
     }
-    return {
+    async parse(path, content) {
-        testRuns,
+        const trx = await this.getTrxReport(path, content);
-        annotations: options.annotations ? getAnnotations(testClasses, options.workDir, options.trackedFiles) : []
+        const tc = this.getTestClasses(trx);
-    };
+        const tr = this.getTestRunResult(path, trx, tc);
-}
+        return tr;
-exports.parseDotnetTrx = parseDotnetTrx;
-async function getTrxReport(file) {
-    core.info(`Parsing content of '${file.path}'`);
-    try {
-        return (await xml2js_1.parseStringPromise(file.content));
     }
-    catch (e) {
+    async getTrxReport(path, content) {
-        throw new Error(`Invalid XML at ${file.path}\n\n${e}`);
+        core.info(`Parsing content of '${path}'`);
-    }
+        try {
-}
+            return (await xml2js_1.parseStringPromise(content));
-function getTestRunResult(path, trx, testClasses) {
+        }
-    const times = trx.TestRun.Times[0].$;
+        catch (e) {
-    const totalTime = parse_utils_1.parseIsoDate(times.finish).getTime() - parse_utils_1.parseIsoDate(times.start).getTime();
+            throw new Error(`Invalid XML at ${path}\n\n${e}`);
-    const suites = testClasses.map(tc => {
-        const tests = tc.tests.map(t => new test_results_1.TestCaseResult(t.name, t.result, t.duration));
-        const group = new test_results_1.TestGroupResult(null, tests);
-        return new test_results_1.TestSuiteResult(tc.name, [group]);
-    });
-    return new test_results_1.TestRunResult(path, suites, totalTime);
-}
-function getTestClasses(trx) {
-    var _a;
-    const unitTests = {};
-    for (const td of trx.TestRun.TestDefinitions) {
-        for (const ut of td.UnitTest) {
-            unitTests[ut.$.id] = ut.TestMethod[0];
         }
     }
-    const unitTestsResults = trx.TestRun.Results.flatMap(r => r.UnitTestResult).flatMap(unitTestResult => ({
+    getTestClasses(trx) {
-        unitTestResult,
+        var _a;
-        testMethod: unitTests[unitTestResult.$.testId]
+        const unitTests = {};
-    }));
+        for (const td of trx.TestRun.TestDefinitions) {
-    const testClasses = {};
+            for (const ut of td.UnitTest) {
-    for (const r of unitTestsResults) {
+                unitTests[ut.$.id] = ut.TestMethod[0];
-        let tc = testClasses[r.testMethod.$.className];
+            }
-        if (tc === undefined) {
-            tc = new TestClass(r.testMethod.$.className);
-            testClasses[tc.name] = tc;
         }
-        const output = r.unitTestResult.Output;
+        const unitTestsResults = trx.TestRun.Results.flatMap(r => r.UnitTestResult).flatMap(unitTestResult => ({
-        const error = (output === null || output === void 0 ? void 0 : output.length) > 0 && ((_a = output[0].ErrorInfo) === null || _a === void 0 ? void 0 : _a.length) > 0 ? output[0].ErrorInfo[0] : undefined;
+            unitTestResult,
-        const duration = parse_utils_1.parseNetDuration(r.unitTestResult.$.duration);
+            testMethod: unitTests[unitTestResult.$.testId]
-        const test = new Test(r.testMethod.$.name, r.unitTestResult.$.outcome, duration, error);
+        }));
-        tc.tests.push(test);
+        const testClasses = {};
+        for (const r of unitTestsResults) {
+            let tc = testClasses[r.testMethod.$.className];
+            if (tc === undefined) {
+                tc = new TestClass(r.testMethod.$.className);
+                testClasses[tc.name] = tc;
+            }
+            const output = r.unitTestResult.Output;
+            const error = (output === null || output === void 0 ? void 0 : output.length) > 0 && ((_a = output[0].ErrorInfo) === null || _a === void 0 ? void 0 : _a.length) > 0 ? output[0].ErrorInfo[0] : undefined;
+            const duration = parse_utils_1.parseNetDuration(r.unitTestResult.$.duration);
+            const test = new Test(r.testMethod.$.name, r.unitTestResult.$.outcome, duration, error);
+            tc.tests.push(test);
+        }
+        const result = Object.values(testClasses);
+        result.sort((a, b) => a.name.localeCompare(b.name));
+        for (const tc of result) {
+            tc.tests.sort((a, b) => a.name.localeCompare(b.name));
+        }
+        return result;
     }
-    const result = Object.values(testClasses);
+    getTestRunResult(path, trx, testClasses) {
-    result.sort((a, b) => a.name.localeCompare(b.name));
+        const times = trx.TestRun.Times[0].$;
-    for (const tc of result) {
+        const totalTime = parse_utils_1.parseIsoDate(times.finish).getTime() - parse_utils_1.parseIsoDate(times.start).getTime();
-        tc.tests.sort((a, b) => a.name.localeCompare(b.name));
+        const suites = testClasses.map(testClass => {
+            const tests = testClass.tests.map(test => {
+                const error = this.getError(test);
+                return new test_results_1.TestCaseResult(test.name, test.result, test.duration, error);
+            });
+            const group = new test_results_1.TestGroupResult(null, tests);
+            return new test_results_1.TestSuiteResult(testClass.name, [group]);
+        });
+        return new test_results_1.TestRunResult(path, suites, totalTime);
     }
-    return result;
+    getError(test) {
-}
+        if (!this.options.parseErrors || !test.error) {
-function getAnnotations(testClasses, workDir, trackedFiles) {
+            return undefined;
-    const annotations = [];
+        }
-    for (const tc of testClasses) {
+        const message = test.error.Message[0];
-        for (const t of tc.tests) {
+        const stackTrace = test.error.StackTrace[0];
-            if (t.error) {
+        let path;
-                const src = exceptionThrowSource(t.error.StackTrace[0], workDir, trackedFiles);
+        let line;
-                if (src === null) {
+        const src = this.exceptionThrowSource(stackTrace);
-                    continue;
+        if (src) {
+            path = src.path;
+            line = src.line;
+        }
+        return {
+            path,
+            line,
+            message,
+            stackTrace: `${message}\n${stackTrace}`
+        };
+    }
+    exceptionThrowSource(stackTrace) {
+        const lines = stackTrace.split(/\r*\n/);
+        const re = / in (.+):line (\d+)$/;
+        const { workDir, trackedFiles } = this.options;
+        for (const str of lines) {
+            const match = str.match(re);
+            if (match !== null) {
+                const [_, fileStr, lineStr] = match;
+                const filePath = file_utils_1.normalizeFilePath(fileStr);
+                const file = filePath.startsWith(workDir) ? filePath.substr(workDir.length) : filePath;
+                if (trackedFiles.includes(file)) {
+                    const line = parseInt(lineStr);
+                    return { path: file, line };
                 }
-                annotations.push({
-                    annotation_level: 'failure',
-                    start_line: src.line,
-                    end_line: src.line,
-                    path: src.file,
-                    message: markdown_utils_1.fixEol(t.error.Message[0]),
-                    title: `[${tc.name}] ${t.name}`
-                });
             }
         }
     }
-    return annotations;
 }
-function exceptionThrowSource(ex, workDir, trackedFiles) {
+exports.DotnetTrxParser = DotnetTrxParser;
-    const lines = ex.split(/\r*\n/);
-    const re = / in (.+):line (\d+)$/;
-    for (const str of lines) {
-        const match = str.match(re);
-        if (match !== null) {
-            const [_, fileStr, lineStr] = match;
-            const filePath = file_utils_1.normalizeFilePath(fileStr);
-            const file = filePath.startsWith(workDir) ? filePath.substr(workDir.length) : filePath;
-            if (trackedFiles.includes(file)) {
-                const line = parseInt(lineStr);
-                return { file, line };
-            }
-        }
-    }
-    return null;
-}
-exports.exceptionThrowSource = exceptionThrowSource;
 
 
 /***/ }),
@@ -594,119 +595,194 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.exceptionThrowSource = exports.parseJestJunit = void 0;
+exports.JestJunitParser = void 0;
 const core = __importStar(__nccwpck_require__(2186));
 const xml2js_1 = __nccwpck_require__(6189);
-const markdown_utils_1 = __nccwpck_require__(6482);
 const file_utils_1 = __nccwpck_require__(2711);
-const test_results_1 = __nccwpck_require__(8407);
+const test_results_1 = __nccwpck_require__(2768);
-async function parseJestJunit(files, options) {
+class JestJunitParser {
-    const junit = [];
+    constructor(options) {
-    const testRuns = [];
+        this.options = options;
-    for (const file of files) {
-        const ju = await getJunitReport(file);
-        const tr = getTestRunResult(file.path, ju);
-        junit.push(ju);
-        testRuns.push(tr);
     }
-    return {
+    async parse(path, content) {
-        testRuns,
+        const ju = await this.getJunitReport(path, content);
-        annotations: options.annotations ? getAnnotations(junit, options.workDir, options.trackedFiles) : []
+        return this.getTestRunResult(path, ju);
-    };
-}
-exports.parseJestJunit = parseJestJunit;
-async function getJunitReport(file) {
-    core.info(`Parsing content of '${file.path}'`);
-    try {
-        return (await xml2js_1.parseStringPromise(file.content));
     }
-    catch (e) {
+    async getJunitReport(path, content) {
-        throw new Error(`Invalid XML at ${file.path}\n\n${e}`);
+        core.info(`Parsing content of '${path}'`);
-    }
+        try {
-}
+            return (await xml2js_1.parseStringPromise(content));
-function getTestRunResult(path, junit) {
+        }
-    const suites = junit.testsuites.testsuite.map(ts => {
+        catch (e) {
-        const name = ts.$.name.trim();
+            throw new Error(`Invalid XML at ${path}\n\n${e}`);
-        const time = parseFloat(ts.$.time) * 1000;
-        const sr = new test_results_1.TestSuiteResult(name, getGroups(ts), time);
-        return sr;
-    });
-    const time = parseFloat(junit.testsuites.$.time) * 1000;
-    return new test_results_1.TestRunResult(path, suites, time);
-}
-function getGroups(suite) {
-    const groups = [];
-    for (const tc of suite.testcase) {
-        let grp = groups.find(g => g.describe === tc.$.classname);
-        if (grp === undefined) {
-            grp = { describe: tc.$.classname, tests: [] };
-            groups.push(grp);
         }
-        grp.tests.push(tc);
     }
-    return groups.map(grp => {
+    getTestRunResult(path, junit) {
-        const tests = grp.tests.map(tc => {
+        const suites = junit.testsuites.testsuite.map(ts => {
-            const name = tc.$.name.trim();
+            const name = ts.$.name.trim();
-            const result = getTestCaseResult(tc);
+            const time = parseFloat(ts.$.time) * 1000;
-            const time = parseFloat(tc.$.time) * 1000;
+            const sr = new test_results_1.TestSuiteResult(name, this.getGroups(ts), time);
-            return new test_results_1.TestCaseResult(name, result, time);
+            return sr;
         });
-        return new test_results_1.TestGroupResult(grp.describe, tests);
+        const time = parseFloat(junit.testsuites.$.time) * 1000;
-    });
+        return new test_results_1.TestRunResult(path, suites, time);
-}
+    }
-function getTestCaseResult(test) {
+    getGroups(suite) {
-    if (test.failure)
+        const groups = [];
-        return 'failed';
+        for (const tc of suite.testcase) {
-    if (test.skipped)
+            let grp = groups.find(g => g.describe === tc.$.classname);
-        return 'skipped';
+            if (grp === undefined) {
-    return 'success';
+                grp = { describe: tc.$.classname, tests: [] };
-}
+                groups.push(grp);
-function getAnnotations(junitReports, workDir, trackedFiles) {
+            }
-    const annotations = [];
+            grp.tests.push(tc);
-    for (const junit of junitReports) {
+        }
-        for (const suite of junit.testsuites.testsuite) {
+        return groups.map(grp => {
-            for (const tc of suite.testcase) {
+            const tests = grp.tests.map(tc => {
-                if (!tc.failure) {
+                const name = tc.$.name.trim();
-                    continue;
+                const result = this.getTestCaseResult(tc);
+                const time = parseFloat(tc.$.time) * 1000;
+                const error = this.getTestCaseError(tc);
+                return new test_results_1.TestCaseResult(name, result, time, error);
+            });
+            return new test_results_1.TestGroupResult(grp.describe, tests);
+        });
+    }
+    getTestCaseResult(test) {
+        if (test.failure)
+            return 'failed';
+        if (test.skipped)
+            return 'skipped';
+        return 'success';
+    }
+    getTestCaseError(tc) {
+        if (!this.options.parseErrors || !tc.failure) {
+            return undefined;
+        }
+        const stackTrace = tc.failure[0];
+        let path;
+        let line;
+        const src = this.exceptionThrowSource(stackTrace);
+        if (src) {
+            path = src.path;
+            line = src.line;
+        }
+        return {
+            path,
+            line,
+            stackTrace
+        };
+    }
+    exceptionThrowSource(stackTrace) {
+        const lines = stackTrace.split(/\r?\n/);
+        const re = /\((.*):(\d+):\d+\)$/;
+        const { workDir, trackedFiles } = this.options;
+        for (const str of lines) {
+            const match = str.match(re);
+            if (match !== null) {
+                const [_, fileStr, lineStr] = match;
+                const filePath = file_utils_1.normalizeFilePath(fileStr);
+                const path = filePath.startsWith(workDir) ? filePath.substr(workDir.length) : filePath;
+                if (trackedFiles.includes(path)) {
+                    const line = parseInt(lineStr);
+                    return { path, line };
                 }
-                for (const ex of tc.failure) {
+            }
-                    const src = exceptionThrowSource(ex, workDir, trackedFiles);
+        }
-                    if (src === null) {
+    }
+}
+exports.JestJunitParser = JestJunitParser;
+
+
+/***/ }),
+
+/***/ 5867:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.getAnnotations = void 0;
+const markdown_utils_1 = __nccwpck_require__(6482);
+function getAnnotations(results, maxCount) {
+    var _a, _b, _c, _d;
+    if (maxCount === 0) {
+        return [];
+    }
+    // Collect errors from TestRunResults
+    // Merge duplicates if there are more test results files processed
+    const errors = [];
+    const mergeDup = results.length > 1;
+    for (const tr of results) {
+        for (const ts of tr.suites) {
+            for (const tg of ts.groups) {
+                for (const tc of tg.tests) {
+                    const err = tc.error;
+                    if (err === undefined) {
                         continue;
                     }
-                    annotations.push({
+                    const path = (_a = err.path) !== null && _a !== void 0 ? _a : tr.path;
-                        annotation_level: 'failure',
+                    const line = (_b = err.line) !== null && _b !== void 0 ? _b : 0;
-                        start_line: src.line,
+                    if (mergeDup) {
-                        end_line: src.line,
+                        const dup = errors.find(e => path === e.path && line === e.line && err.stackTrace === e.stackTrace);
-                        path: src.file,
+                        if (dup !== undefined) {
-                        message: markdown_utils_1.fixEol(ex),
+                            dup.testRunPaths.push(tr.path);
-                        title: `[${suite.$.name}] ${tc.$.name.trim()}`
+                            continue;
+                        }
+                    }
+                    errors.push({
+                        testRunPaths: [tr.path],
+                        suiteName: ts.name,
+                        testName: tc.name,
+                        stackTrace: err.stackTrace,
+                        message: (_d = (_c = err.message) !== null && _c !== void 0 ? _c : getFirstNonEmptyLine(err.stackTrace)) !== null && _d !== void 0 ? _d : 'Test failed',
+                        path,
+                        line
                     });
                 }
             }
         }
     }
+    // Limit number of created annotations
+    errors.splice(maxCount + 1);
+    const annotations = errors.map(e => {
+        const message = [
+            'Failed test found in:',
+            e.testRunPaths.map(p => `  ${p}`).join('\n'),
+            'Error:',
+            ident(markdown_utils_1.fixEol(e.message), '  ')
+        ].join('\n');
+        return enforceCheckRunLimits({
+            path: e.path,
+            start_line: e.line,
+            end_line: e.line,
+            annotation_level: 'failure',
+            title: `${e.suiteName} ► ${e.testName}`,
+            raw_details: markdown_utils_1.fixEol(e.stackTrace),
+            message
+        });
+    });
     return annotations;
 }
-function exceptionThrowSource(ex, workDir, trackedFiles) {
+exports.getAnnotations = getAnnotations;
-    const lines = ex.split(/\r?\n/);
+function enforceCheckRunLimits(err) {
-    const re = /\((.*):(\d+):(\d+)\)$/;
+    err.title = markdown_utils_1.ellipsis(err.title || '', 255);
-    for (const str of lines) {
+    err.message = markdown_utils_1.ellipsis(err.message, 65535);
-        const match = str.match(re);
+    if (err.raw_details) {
-        if (match !== null) {
+        err.raw_details = markdown_utils_1.ellipsis(err.raw_details, 65535);
-            const [_, fileStr, lineStr, colStr] = match;
-            const filePath = file_utils_1.normalizeFilePath(fileStr);
-            const file = filePath.startsWith(workDir) ? filePath.substr(workDir.length) : filePath;
-            if (trackedFiles.includes(file)) {
-                const line = parseInt(lineStr);
-                const column = parseInt(colStr);
-                return { file, line, column };
-            }
-        }
     }
-    return null;
+    return err;
+}
+function getFirstNonEmptyLine(stackTrace) {
+    const lines = stackTrace.split(/\r?\n/g);
+    return lines.find(str => !/^\s*$/.test(str));
+}
+function ident(text, prefix) {
+    return text
+        .split(/\n/g)
+        .map(line => prefix + line)
+        .join('\n');
 }
-exports.exceptionThrowSource = exceptionThrowSource;
 
 
 /***/ }),
@@ -824,7 +900,7 @@ function getSuitesReport(tr, runIndex, options) {
     const nameLink = `<a id="${trSlug.id}" href="${trSlug.link}">${tr.path}</a>`;
     const icon = getResultIcon(tr.result);
     sections.push(`## ${nameLink} ${icon}`);
-    const time = `${(tr.time / 1000).toFixed(3)}s`;
+    const time = markdown_utils_1.formatTime(tr.time);
     const headingLine2 = `**${tr.tests}** tests were completed in **${time}** with **${tr.passed}** passed, **${tr.failed}** failed and **${tr.skipped}** skipped.`;
     sections.push(headingLine2);
     const suites = options.listSuites === 'failed' ? tr.failedSuites : tr.suites;
@@ -861,7 +937,8 @@ function getTestsReport(ts, runIndex, suiteIndex, options) {
     const tsNameLink = `<a id="${tsSlug.id}" href="${tsSlug.link}">${tsName}</a>`;
     const icon = getResultIcon(ts.result);
     sections.push(`### ${tsNameLink} ${icon}`);
-    const headingLine2 = `**${ts.tests}** tests were completed in **${ts.time}ms** with **${ts.passed}** passed, **${ts.failed}** failed and **${ts.skipped}** skipped.`;
+    const tsTime = markdown_utils_1.formatTime(ts.time);
+    const headingLine2 = `**${ts.tests}** tests were completed in **${tsTime}** with **${ts.passed}** passed, **${ts.failed}** failed and **${ts.skipped}** skipped.`;
     sections.push(headingLine2);
     for (const grp of groups) {
         const tests = options.listTests === 'failed' ? grp.failedTests : grp.tests;
@@ -903,7 +980,7 @@ function getResultIcon(result) {
 
 /***/ }),
 
-/***/ 8407:
+/***/ 2768:
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -996,10 +1073,11 @@ class TestGroupResult {
 }
 exports.TestGroupResult = TestGroupResult;
 class TestCaseResult {
-    constructor(name, result, time) {
+    constructor(name, result, time, error) {
         this.name = name;
         this.result = result;
         this.time = time;
+        this.error = error;
     }
 }
 exports.TestCaseResult = TestCaseResult;
@@ -1140,9 +1218,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.enforceCheckRunLimits = exports.getCheckRunSha = void 0;
+exports.getCheckRunSha = void 0;
 const github = __importStar(__nccwpck_require__(5438));
-const markdown_utils_1 = __nccwpck_require__(6482);
 function getCheckRunSha() {
     if (github.context.payload.pull_request) {
         const pr = github.context.payload.pull_request;
@@ -1151,16 +1228,6 @@ function getCheckRunSha() {
     return github.context.sha;
 }
 exports.getCheckRunSha = getCheckRunSha;
-function enforceCheckRunLimits(result, maxAnnotations) {
-    // Limit number of created annotations
-    result.annotations.splice(maxAnnotations + 1);
-    // Limit number of characters in annotation fields
-    for (const err of result.annotations) {
-        err.title = markdown_utils_1.ellipsis(err.title || '', 255);
-        err.message = markdown_utils_1.ellipsis(err.message, 65535);
-    }
-}
-exports.enforceCheckRunLimits = enforceCheckRunLimits;
 
 
 /***/ }),

src/main.ts

@@ -2,14 +2,19 @@ import * as core from '@actions/core'
 import * as github from '@actions/github'
 import * as fs from 'fs'
 import glob from 'fast-glob'
-import {parseDartJson} from './parsers/dart-json/dart-json-parser'
+
-import {parseDotnetTrx} from './parsers/dotnet-trx/dotnet-trx-parser'
+import {ParseOptions, TestParser} from './test-parser'
-import {parseJestJunit} from './parsers/jest-junit/jest-junit-parser'
+import {TestRunResult} from './test-results'
+import {getAnnotations} from './report/get-annotations'
 import {getReport} from './report/get-report'
-import {FileContent, ParseOptions, ParseTestResult} from './parsers/parser-types'
+
+import {DartJsonParser} from './parsers/dart-json/dart-json-parser'
+import {DotnetTrxParser} from './parsers/dotnet-trx/dotnet-trx-parser'
+import {JestJunitParser} from './parsers/jest-junit/jest-junit-parser'
+
 import {normalizeDirPath} from './utils/file-utils'
 import {listFiles} from './utils/git'
-import {enforceCheckRunLimits, getCheckRunSha} from './utils/github-utils'
+import {getCheckRunSha} from './utils/github-utils'
 import {Icon} from './utils/markdown-utils'
 
 async function run(): Promise<void> {
@@ -56,28 +61,39 @@ async function main(): Promise<void> {
   const sha = getCheckRunSha()
 
   // We won't need tracked files if we are not going to create annotations
-  const annotations = maxAnnotations > 0
+  const parseErrors = maxAnnotations > 0
-  const trackedFiles = annotations ? await listFiles() : []
+  const trackedFiles = parseErrors ? await listFiles() : []
 
-  const opts: ParseOptions = {
+  const options: ParseOptions = {
     trackedFiles,
     workDir,
-    annotations
+    parseErrors
   }
 
-  const parser = getParser(reporter)
+  core.info(`Using test report parser '${reporter}'`)
-  const files = await getFiles(path)
+  const parser = getParser(reporter, options)
 
+  const files = await getFiles(path)
   if (files.length === 0) {
     core.setFailed(`No file matches path '${path}'`)
     return
   }
 
-  core.info(`Using test report parser '${reporter}'`)
+  const results: TestRunResult[] = []
-  const result = await parser(files, opts)
+  for (const file of files) {
+    core.info(`Processing test report ${file}`)
+    const content = await fs.promises.readFile(file, {encoding: 'utf8'})
+    const tr = await parser.parse(file, content)
+    results.push(tr)
+  }
 
-  enforceCheckRunLimits(result, maxAnnotations)
+  core.info('Creating report summary')
-  const isFailed = result.testRuns.some(tr => tr.result === 'failed')
+  const summary = getReport(results, {listSuites, listTests})
+
+  core.info('Creating annotations')
+  const annotations = getAnnotations(results, maxAnnotations)
+
+  const isFailed = results.some(tr => tr.result === 'failed')
   const conclusion = isFailed ? 'failure' : 'success'
   const icon = isFailed ? Icon.fail : Icon.success
 
@@ -89,45 +105,47 @@ async function main(): Promise<void> {
     status: 'completed',
     output: {
       title: `${name} ${icon}`,
-      summary: getReport(result.testRuns, {listSuites, listTests}),
+      summary,
-      annotations: result.annotations
+      annotations
     },
     ...github.context.repo
   })
 
+  const passed = results.reduce((sum, tr) => sum + tr.passed, 0)
+  const failed = results.reduce((sum, tr) => sum + tr.failed, 0)
+  const skipped = results.reduce((sum, tr) => sum + tr.skipped, 0)
+  const time = results.reduce((sum, tr) => sum + tr.time, 0)
+
   core.setOutput('conclusion', conclusion)
+  core.setOutput('passed', passed)
+  core.setOutput('failed', failed)
+  core.setOutput('skipped', skipped)
+  core.setOutput('time', time)
+
   if (failOnError && isFailed) {
     core.setFailed(`Failed test has been found and 'fail-on-error' option is set to ${failOnError}`)
   }
 }
 
-function getParser(reporter: string): ParseTestResult {
+function getParser(reporter: string, options: ParseOptions): TestParser {
   switch (reporter) {
     case 'dart-json':
-      return parseDartJson
+      return new DartJsonParser(options)
     case 'dotnet-trx':
-      return parseDotnetTrx
+      return new DotnetTrxParser(options)
     case 'flutter-machine':
-      return parseDartJson
+      return new DartJsonParser(options)
     case 'jest-junit':
-      return parseJestJunit
+      return new JestJunitParser(options)
     default:
       throw new Error(`Input variable 'reporter' is set to invalid value '${reporter}'`)
   }
 }
 
-export async function getFiles(pattern: string): Promise<FileContent[]> {
+export async function getFiles(pattern: string): Promise<string[]> {
-  const paths = (await Promise.all(pattern.split(',').map(async pat => glob(pat, {dot: true})))).flat()
+  const tasks = pattern.split(',').map(async pat => glob(pat, {dot: true}))
-
+  const paths = await Promise.all(tasks)
-  const files = Promise.all(
+  return paths.flat()
-    paths.map(async path => {
-      core.info(`Reading test report '${path}'`)
-      const content = await fs.promises.readFile(path, {encoding: 'utf8'})
-      return {path, content}
-    })
-  )
-
-  return files
 }
 
 run()

src/parsers/dart-json/dart-json-parser.ts

@@ -1,8 +1,7 @@
 import * as core from '@actions/core'
-import {Annotation, FileContent, ParseOptions, TestResult} from '../parser-types'
+import {ParseOptions, TestParser} from '../../test-parser'
 
 import {normalizeFilePath} from '../../utils/file-utils'
-import {fixEol} from '../../utils/markdown-utils'
 
 import {
   ReportEvent,
@@ -24,8 +23,9 @@ import {
   TestRunResult,
   TestSuiteResult,
   TestGroupResult,
-  TestCaseResult
+  TestCaseResult,
-} from '../../report/test-results'
+  TestCaseError
+} from '../../test-results'
 
 class TestRun {
   constructor(readonly path: string, readonly suites: TestSuite[], readonly success: boolean, readonly time: number) {}
@@ -68,159 +68,143 @@ class TestCase {
   }
 }
 
-export async function parseDartJson(files: FileContent[], options: ParseOptions): Promise<TestResult> {
+export class DartJsonParser implements TestParser {
-  const testRuns = files.map(f => getTestRun(f.path, f.content))
+  constructor(readonly options: ParseOptions) {}
-  const testRunsResults = testRuns.map(getTestRunResult)
 
-  return {
+  async parse(path: string, content: string): Promise<TestRunResult> {
-    testRuns: testRunsResults,
+    const tr = this.getTestRun(path, content)
-    annotations: options.annotations ? getAnnotations(testRuns, options.workDir, options.trackedFiles) : []
+    const result = this.getTestRunResult(tr)
+    return Promise.resolve(result)
   }
-}
 
-function getTestRun(path: string, content: string): TestRun {
+  private getTestRun(path: string, content: string): TestRun {
-  core.info(`Parsing content of '${path}'`)
+    core.info(`Parsing content of '${path}'`)
-  const lines = content.split(/\n\r?/g)
+    const lines = content.split(/\n\r?/g)
-  const events = lines
+    const events = lines
-    .map((str, i) => {
+      .map((str, i) => {
-      if (str.trim() === '') {
+        if (str.trim() === '') {
-        return null
+          return null
-      }
+        }
-      try {
+        try {
-        return JSON.parse(str)
+          return JSON.parse(str)
-      } catch (e) {
+        } catch (e) {
-        const col = e.columnNumber !== undefined ? `:${e.columnNumber}` : ''
+          const col = e.columnNumber !== undefined ? `:${e.columnNumber}` : ''
-        new Error(`Invalid JSON at ${path}:${i + 1}${col}\n\n${e}`)
+          new Error(`Invalid JSON at ${path}:${i + 1}${col}\n\n${e}`)
+        }
+      })
+      .filter(evt => evt != null) as ReportEvent[]
+
+    let success = false
+    let totalTime = 0
+    const suites: {[id: number]: TestSuite} = {}
+    const tests: {[id: number]: TestCase} = {}
+
+    for (const evt of events) {
+      if (isSuiteEvent(evt)) {
+        suites[evt.suite.id] = new TestSuite(evt.suite)
+      } else if (isGroupEvent(evt)) {
+        suites[evt.group.suiteID].groups[evt.group.id] = new TestGroup(evt.group)
+      } else if (isTestStartEvent(evt) && evt.test.url !== null) {
+        const test: TestCase = new TestCase(evt)
+        const suite = suites[evt.test.suiteID]
+        const group = suite.groups[evt.test.groupIDs[evt.test.groupIDs.length - 1]]
+        group.tests.push(test)
+        tests[evt.test.id] = test
+      } else if (isTestDoneEvent(evt) && !evt.hidden) {
+        tests[evt.testID].testDone = evt
+      } else if (isErrorEvent(evt)) {
+        tests[evt.testID].error = evt
+      } else if (isDoneEvent(evt)) {
+        success = evt.success
+        totalTime = evt.time
       }
+    }
+
+    return new TestRun(path, Object.values(suites), success, totalTime)
+  }
+
+  private getTestRunResult(tr: TestRun): TestRunResult {
+    const suites = tr.suites.map(s => {
+      return new TestSuiteResult(s.suite.path, this.getGroups(s))
     })
-    .filter(evt => evt != null) as ReportEvent[]
 
-  let success = false
+    return new TestRunResult(tr.path, suites, tr.time)
-  let totalTime = 0
+  }
-  const suites: {[id: number]: TestSuite} = {}
-  const tests: {[id: number]: TestCase} = {}
 
-  for (const evt of events) {
+  private getGroups(suite: TestSuite): TestGroupResult[] {
-    if (isSuiteEvent(evt)) {
+    const groups = Object.values(suite.groups).filter(grp => grp.tests.length > 0)
-      suites[evt.suite.id] = new TestSuite(evt.suite)
+    groups.sort((a, b) => (a.group.line ?? 0) - (b.group.line ?? 0))
-    } else if (isGroupEvent(evt)) {
+
-      suites[evt.group.suiteID].groups[evt.group.id] = new TestGroup(evt.group)
+    return groups.map(group => {
-    } else if (isTestStartEvent(evt) && evt.test.url !== null) {
+      group.tests.sort((a, b) => (a.testStart.test.line ?? 0) - (b.testStart.test.line ?? 0))
-      const test: TestCase = new TestCase(evt)
+      const tests = group.tests.map(t => this.getTest(t))
-      const suite = suites[evt.test.suiteID]
+      return new TestGroupResult(group.group.name, tests)
-      const group = suite.groups[evt.test.groupIDs[evt.test.groupIDs.length - 1]]
+    })
-      group.tests.push(test)
+  }
-      tests[evt.test.id] = test
+
-    } else if (isTestDoneEvent(evt) && !evt.hidden) {
+  private getTest(tc: TestCase): TestCaseResult {
-      tests[evt.testID].testDone = evt
+    const error = this.getError(tc)
-    } else if (isErrorEvent(evt)) {
+    return new TestCaseResult(tc.testStart.test.name, tc.result, tc.time, error)
-      tests[evt.testID].error = evt
+  }
-    } else if (isDoneEvent(evt)) {
+
-      success = evt.success
+  private getError(test: TestCase): TestCaseError | undefined {
-      totalTime = evt.time
+    if (!this.options.parseErrors || !test.error) {
+      return undefined
+    }
+
+    const {workDir, trackedFiles} = this.options
+    const message = test.error?.error ?? ''
+    const stackTrace = test.error?.stackTrace ?? ''
+    const src = this.exceptionThrowSource(stackTrace, trackedFiles)
+    let path
+    let line
+
+    if (src !== undefined) {
+      ;(path = src.path), (line = src.line)
+    } else {
+      const testStartPath = this.getRelativePathFromUrl(test.testStart.test.url ?? '', workDir)
+      if (trackedFiles.includes(testStartPath)) {
+        path = testStartPath
+      }
+      line = test.testStart.test.line ?? undefined
+    }
+
+    return {
+      path,
+      line,
+      message,
+      stackTrace
     }
   }
 
-  return new TestRun(path, Object.values(suites), success, totalTime)
+  private exceptionThrowSource(ex: string, trackedFiles: string[]): {path: string; line: number} | undefined {
-}
+    // imports from package which is tested are listed in stack traces as 'package:xyz/' which maps to relative path 'lib/'
+    const packageRe = /^package:[a-zA-z0-9_$]+\//
+    const lines = ex.split(/\r?\n/).map(str => str.replace(packageRe, 'lib/'))
 
-function getTestRunResult(tr: TestRun): TestRunResult {
+    // regexp to extract file path and line number from stack trace
-  const suites = tr.suites.map(s => {
+    const re = /^(.*)\s+(\d+):\d+\s+/
-    return new TestSuiteResult(s.suite.path, getGroups(s))
+    for (const str of lines) {
-  })
+      const match = str.match(re)
-
+      if (match !== null) {
-  return new TestRunResult(tr.path, suites, tr.time)
+        const [_, pathStr, lineStr] = match
-}
+        const path = normalizeFilePath(pathStr)
-
+        if (trackedFiles.includes(path)) {
-function getGroups(suite: TestSuite): TestGroupResult[] {
+          const line = parseInt(lineStr)
-  const groups = Object.values(suite.groups).filter(grp => grp.tests.length > 0)
+          return {path, line}
-  groups.sort((a, b) => (a.group.line ?? 0) - (b.group.line ?? 0))
-
-  return groups.map(group => {
-    group.tests.sort((a, b) => (a.testStart.test.line ?? 0) - (b.testStart.test.line ?? 0))
-    const tests = group.tests.map(t => new TestCaseResult(t.testStart.test.name, t.result, t.time))
-    return new TestGroupResult(group.group.name, tests)
-  })
-}
-
-function getAnnotations(testRuns: TestRun[], workDir: string, trackedFiles: string[]): Annotation[] {
-  const annotations: Annotation[] = []
-  for (const tr of testRuns) {
-    for (const suite of tr.suites) {
-      for (const group of Object.values(suite.groups)) {
-        for (const test of group.tests) {
-          if (test.error) {
-            const err = getAnnotation(test, suite, workDir, trackedFiles)
-            if (err !== null) {
-              annotations.push(err)
-            }
-          }
         }
       }
     }
   }
 
-  return annotations
+  private getRelativePathFromUrl(file: string, workDir: string): string {
-}
+    const prefix = 'file:///'
-
+    if (file.startsWith(prefix)) {
-function getAnnotation(
+      file = file.substr(prefix.length)
-  test: TestCase,
-  testSuite: TestSuite,
-  workDir: string,
-  trackedFiles: string[]
-): Annotation | null {
-  const stack = test.error?.stackTrace ?? ''
-  let src = exceptionThrowSource(stack, trackedFiles)
-  if (src === null) {
-    const file = getRelativePathFromUrl(test.testStart.test.url ?? '', workDir)
-    if (!trackedFiles.includes(file)) {
-      return null
     }
-    src = {
+    if (file.startsWith(workDir)) {
-      file,
+      file = file.substr(workDir.length)
-      line: test.testStart.test.line ?? 0
     }
-  }
+    return file
-
-  return {
-    annotation_level: 'failure',
-    start_line: src.line,
-    end_line: src.line,
-    path: src.file,
-    message: `${fixEol(test.error?.error)}\n\n${fixEol(test.error?.stackTrace)}`,
-    title: `[${testSuite.suite.path}] ${test.testStart.test.name}`
   }
 }
-
-function exceptionThrowSource(ex: string, trackedFiles: string[]): {file: string; line: number} | null {
-  // imports from package which is tested are listed in stack traces as 'package:xyz/' which maps to relative path 'lib/'
-  const packageRe = /^package:[a-zA-z0-9_$]+\//
-  const lines = ex.split(/\r?\n/).map(str => str.replace(packageRe, 'lib/'))
-
-  // regexp to extract file path and line number from stack trace
-  const re = /^(.*)\s+(\d+):\d+\s+/
-  for (const str of lines) {
-    const match = str.match(re)
-    if (match !== null) {
-      const [_, fileStr, lineStr] = match
-      const file = normalizeFilePath(fileStr)
-      if (trackedFiles.includes(file)) {
-        const line = parseInt(lineStr)
-        return {file, line}
-      }
-    }
-  }
-
-  return null
-}
-
-function getRelativePathFromUrl(file: string, workdir: string): string {
-  const prefix = 'file:///'
-  if (file.startsWith(prefix)) {
-    file = file.substr(prefix.length)
-  }
-  if (file.startsWith(workdir)) {
-    file = file.substr(workdir.length)
-  }
-  return file
-}

src/parsers/dotnet-trx/dotnet-trx-parser.ts

@@ -1,11 +1,10 @@
 import * as core from '@actions/core'
-import {ErrorInfo, Outcome, TestMethod, TrxReport} from './dotnet-trx-types'
-
-import {Annotation, FileContent, ParseOptions, TestResult} from '../parser-types'
 import {parseStringPromise} from 'xml2js'
 
+import {ErrorInfo, Outcome, TestMethod, TrxReport} from './dotnet-trx-types'
+import {ParseOptions, TestParser} from '../../test-parser'
+
 import {normalizeFilePath} from '../../utils/file-utils'
-import {fixEol} from '../../utils/markdown-utils'
 import {parseIsoDate, parseNetDuration} from '../../utils/parse-utils'
 
 import {
@@ -13,8 +12,9 @@ import {
   TestRunResult,
   TestSuiteResult,
   TestGroupResult,
-  TestCaseResult
+  TestCaseResult,
-} from '../../report/test-results'
+  TestCaseError
+} from '../../test-results'
 
 class TestClass {
   constructor(readonly name: string) {}
@@ -41,125 +41,117 @@ class Test {
   }
 }
 
-export async function parseDotnetTrx(files: FileContent[], options: ParseOptions): Promise<TestResult> {
+export class DotnetTrxParser implements TestParser {
-  const testRuns: TestRunResult[] = []
+  constructor(readonly options: ParseOptions) {}
-  const testClasses: TestClass[] = []
 
-  for (const file of files) {
+  async parse(path: string, content: string): Promise<TestRunResult> {
-    const trx = await getTrxReport(file)
+    const trx = await this.getTrxReport(path, content)
-    const tc = getTestClasses(trx)
+    const tc = this.getTestClasses(trx)
-    const tr = getTestRunResult(file.path, trx, tc)
+    const tr = this.getTestRunResult(path, trx, tc)
-    testRuns.push(tr)
+    return tr
-    testClasses.push(...tc)
   }
 
-  return {
+  private async getTrxReport(path: string, content: string): Promise<TrxReport> {
-    testRuns,
+    core.info(`Parsing content of '${path}'`)
-    annotations: options.annotations ? getAnnotations(testClasses, options.workDir, options.trackedFiles) : []
+    try {
-  }
+      return (await parseStringPromise(content)) as TrxReport
-}
+    } catch (e) {
-
+      throw new Error(`Invalid XML at ${path}\n\n${e}`)
-async function getTrxReport(file: FileContent): Promise<TrxReport> {
-  core.info(`Parsing content of '${file.path}'`)
-  try {
-    return (await parseStringPromise(file.content)) as TrxReport
-  } catch (e) {
-    throw new Error(`Invalid XML at ${file.path}\n\n${e}`)
-  }
-}
-
-function getTestRunResult(path: string, trx: TrxReport, testClasses: TestClass[]): TestRunResult {
-  const times = trx.TestRun.Times[0].$
-  const totalTime = parseIsoDate(times.finish).getTime() - parseIsoDate(times.start).getTime()
-
-  const suites = testClasses.map(tc => {
-    const tests = tc.tests.map(t => new TestCaseResult(t.name, t.result, t.duration))
-    const group = new TestGroupResult(null, tests)
-    return new TestSuiteResult(tc.name, [group])
-  })
-
-  return new TestRunResult(path, suites, totalTime)
-}
-
-function getTestClasses(trx: TrxReport): TestClass[] {
-  const unitTests: {[id: string]: TestMethod} = {}
-  for (const td of trx.TestRun.TestDefinitions) {
-    for (const ut of td.UnitTest) {
-      unitTests[ut.$.id] = ut.TestMethod[0]
     }
   }
 
-  const unitTestsResults = trx.TestRun.Results.flatMap(r => r.UnitTestResult).flatMap(unitTestResult => ({
+  private getTestClasses(trx: TrxReport): TestClass[] {
-    unitTestResult,
+    const unitTests: {[id: string]: TestMethod} = {}
-    testMethod: unitTests[unitTestResult.$.testId]
+    for (const td of trx.TestRun.TestDefinitions) {
-  }))
+      for (const ut of td.UnitTest) {
-
+        unitTests[ut.$.id] = ut.TestMethod[0]
-  const testClasses: {[name: string]: TestClass} = {}
+      }
-  for (const r of unitTestsResults) {
-    let tc = testClasses[r.testMethod.$.className]
-    if (tc === undefined) {
-      tc = new TestClass(r.testMethod.$.className)
-      testClasses[tc.name] = tc
     }
-    const output = r.unitTestResult.Output
+
-    const error = output?.length > 0 && output[0].ErrorInfo?.length > 0 ? output[0].ErrorInfo[0] : undefined
+    const unitTestsResults = trx.TestRun.Results.flatMap(r => r.UnitTestResult).flatMap(unitTestResult => ({
-    const duration = parseNetDuration(r.unitTestResult.$.duration)
+      unitTestResult,
-    const test = new Test(r.testMethod.$.name, r.unitTestResult.$.outcome, duration, error)
+      testMethod: unitTests[unitTestResult.$.testId]
-    tc.tests.push(test)
+    }))
+
+    const testClasses: {[name: string]: TestClass} = {}
+    for (const r of unitTestsResults) {
+      let tc = testClasses[r.testMethod.$.className]
+      if (tc === undefined) {
+        tc = new TestClass(r.testMethod.$.className)
+        testClasses[tc.name] = tc
+      }
+      const output = r.unitTestResult.Output
+      const error = output?.length > 0 && output[0].ErrorInfo?.length > 0 ? output[0].ErrorInfo[0] : undefined
+      const duration = parseNetDuration(r.unitTestResult.$.duration)
+      const test = new Test(r.testMethod.$.name, r.unitTestResult.$.outcome, duration, error)
+      tc.tests.push(test)
+    }
+
+    const result = Object.values(testClasses)
+    result.sort((a, b) => a.name.localeCompare(b.name))
+    for (const tc of result) {
+      tc.tests.sort((a, b) => a.name.localeCompare(b.name))
+    }
+
+    return result
   }
 
-  const result = Object.values(testClasses)
+  private getTestRunResult(path: string, trx: TrxReport, testClasses: TestClass[]): TestRunResult {
-  result.sort((a, b) => a.name.localeCompare(b.name))
+    const times = trx.TestRun.Times[0].$
-  for (const tc of result) {
+    const totalTime = parseIsoDate(times.finish).getTime() - parseIsoDate(times.start).getTime()
-    tc.tests.sort((a, b) => a.name.localeCompare(b.name))
+
+    const suites = testClasses.map(testClass => {
+      const tests = testClass.tests.map(test => {
+        const error = this.getError(test)
+        return new TestCaseResult(test.name, test.result, test.duration, error)
+      })
+      const group = new TestGroupResult(null, tests)
+      return new TestSuiteResult(testClass.name, [group])
+    })
+
+    return new TestRunResult(path, suites, totalTime)
   }
 
-  return result
+  private getError(test: Test): TestCaseError | undefined {
-}
+    if (!this.options.parseErrors || !test.error) {
+      return undefined
+    }
 
-function getAnnotations(testClasses: TestClass[], workDir: string, trackedFiles: string[]): Annotation[] {
+    const message = test.error.Message[0]
-  const annotations: Annotation[] = []
+    const stackTrace = test.error.StackTrace[0]
-  for (const tc of testClasses) {
+    let path
-    for (const t of tc.tests) {
+    let line
-      if (t.error) {
+
-        const src = exceptionThrowSource(t.error.StackTrace[0], workDir, trackedFiles)
+    const src = this.exceptionThrowSource(stackTrace)
-        if (src === null) {
+    if (src) {
-          continue
+      path = src.path
+      line = src.line
+    }
+
+    return {
+      path,
+      line,
+      message,
+      stackTrace: `${message}\n${stackTrace}`
+    }
+  }
+
+  private exceptionThrowSource(stackTrace: string): {path: string; line: number} | undefined {
+    const lines = stackTrace.split(/\r*\n/)
+    const re = / in (.+):line (\d+)$/
+    const {workDir, trackedFiles} = this.options
+
+    for (const str of lines) {
+      const match = str.match(re)
+      if (match !== null) {
+        const [_, fileStr, lineStr] = match
+        const filePath = normalizeFilePath(fileStr)
+        const file = filePath.startsWith(workDir) ? filePath.substr(workDir.length) : filePath
+        if (trackedFiles.includes(file)) {
+          const line = parseInt(lineStr)
+          return {path: file, line}
         }
-        annotations.push({
-          annotation_level: 'failure',
-          start_line: src.line,
-          end_line: src.line,
-          path: src.file,
-          message: fixEol(t.error.Message[0]),
-          title: `[${tc.name}] ${t.name}`
-        })
       }
     }
   }
-  return annotations
-}
-
-export function exceptionThrowSource(
-  ex: string,
-  workDir: string,
-  trackedFiles: string[]
-): {file: string; line: number} | null {
-  const lines = ex.split(/\r*\n/)
-  const re = / in (.+):line (\d+)$/
-
-  for (const str of lines) {
-    const match = str.match(re)
-    if (match !== null) {
-      const [_, fileStr, lineStr] = match
-      const filePath = normalizeFilePath(fileStr)
-      const file = filePath.startsWith(workDir) ? filePath.substr(workDir.length) : filePath
-      if (trackedFiles.includes(file)) {
-        const line = parseInt(lineStr)
-        return {file, line}
-      }
-    }
-  }
-
-  return null
 }

src/parsers/jest-junit/jest-junit-parser.ts

@@ -1,9 +1,8 @@
 import * as core from '@actions/core'
-import {Annotation, FileContent, ParseOptions, TestResult} from '../parser-types'
+import {ParseOptions, TestParser} from '../../test-parser'
 import {parseStringPromise} from 'xml2js'
 
 import {JunitReport, TestCase, TestSuite} from './jest-junit-types'
-import {fixEol} from '../../utils/markdown-utils'
 import {normalizeFilePath} from '../../utils/file-utils'
 
 import {
@@ -11,124 +10,107 @@ import {
   TestRunResult,
   TestSuiteResult,
   TestGroupResult,
-  TestCaseResult
+  TestCaseResult,
-} from '../../report/test-results'
+  TestCaseError
+} from '../../test-results'
 
-export async function parseJestJunit(files: FileContent[], options: ParseOptions): Promise<TestResult> {
+export class JestJunitParser implements TestParser {
-  const junit: JunitReport[] = []
+  constructor(readonly options: ParseOptions) {}
-  const testRuns: TestRunResult[] = []
 
-  for (const file of files) {
+  async parse(path: string, content: string): Promise<TestRunResult> {
-    const ju = await getJunitReport(file)
+    const ju = await this.getJunitReport(path, content)
-    const tr = getTestRunResult(file.path, ju)
+    return this.getTestRunResult(path, ju)
-    junit.push(ju)
-    testRuns.push(tr)
   }
 
-  return {
+  private async getJunitReport(path: string, content: string): Promise<JunitReport> {
-    testRuns,
+    core.info(`Parsing content of '${path}'`)
-    annotations: options.annotations ? getAnnotations(junit, options.workDir, options.trackedFiles) : []
+    try {
-  }
+      return (await parseStringPromise(content)) as JunitReport
-}
+    } catch (e) {
-
+      throw new Error(`Invalid XML at ${path}\n\n${e}`)
-async function getJunitReport(file: FileContent): Promise<JunitReport> {
-  core.info(`Parsing content of '${file.path}'`)
-  try {
-    return (await parseStringPromise(file.content)) as JunitReport
-  } catch (e) {
-    throw new Error(`Invalid XML at ${file.path}\n\n${e}`)
-  }
-}
-
-function getTestRunResult(path: string, junit: JunitReport): TestRunResult {
-  const suites = junit.testsuites.testsuite.map(ts => {
-    const name = ts.$.name.trim()
-    const time = parseFloat(ts.$.time) * 1000
-    const sr = new TestSuiteResult(name, getGroups(ts), time)
-    return sr
-  })
-
-  const time = parseFloat(junit.testsuites.$.time) * 1000
-  return new TestRunResult(path, suites, time)
-}
-
-function getGroups(suite: TestSuite): TestGroupResult[] {
-  const groups: {describe: string; tests: TestCase[]}[] = []
-  for (const tc of suite.testcase) {
-    let grp = groups.find(g => g.describe === tc.$.classname)
-    if (grp === undefined) {
-      grp = {describe: tc.$.classname, tests: []}
-      groups.push(grp)
     }
-    grp.tests.push(tc)
   }
 
-  return groups.map(grp => {
+  private getTestRunResult(path: string, junit: JunitReport): TestRunResult {
-    const tests = grp.tests.map(tc => {
+    const suites = junit.testsuites.testsuite.map(ts => {
-      const name = tc.$.name.trim()
+      const name = ts.$.name.trim()
-      const result = getTestCaseResult(tc)
+      const time = parseFloat(ts.$.time) * 1000
-      const time = parseFloat(tc.$.time) * 1000
+      const sr = new TestSuiteResult(name, this.getGroups(ts), time)
-      return new TestCaseResult(name, result, time)
+      return sr
     })
-    return new TestGroupResult(grp.describe, tests)
-  })
-}
 
-function getTestCaseResult(test: TestCase): TestExecutionResult {
+    const time = parseFloat(junit.testsuites.$.time) * 1000
-  if (test.failure) return 'failed'
+    return new TestRunResult(path, suites, time)
-  if (test.skipped) return 'skipped'
+  }
-  return 'success'
-}
 
-function getAnnotations(junitReports: JunitReport[], workDir: string, trackedFiles: string[]): Annotation[] {
+  private getGroups(suite: TestSuite): TestGroupResult[] {
-  const annotations: Annotation[] = []
+    const groups: {describe: string; tests: TestCase[]}[] = []
-  for (const junit of junitReports) {
+    for (const tc of suite.testcase) {
-    for (const suite of junit.testsuites.testsuite) {
+      let grp = groups.find(g => g.describe === tc.$.classname)
-      for (const tc of suite.testcase) {
+      if (grp === undefined) {
-        if (!tc.failure) {
+        grp = {describe: tc.$.classname, tests: []}
-          continue
+        groups.push(grp)
-        }
+      }
-        for (const ex of tc.failure) {
+      grp.tests.push(tc)
-          const src = exceptionThrowSource(ex, workDir, trackedFiles)
+    }
-          if (src === null) {
+
-            continue
+    return groups.map(grp => {
-          }
+      const tests = grp.tests.map(tc => {
-          annotations.push({
+        const name = tc.$.name.trim()
-            annotation_level: 'failure',
+        const result = this.getTestCaseResult(tc)
-            start_line: src.line,
+        const time = parseFloat(tc.$.time) * 1000
-            end_line: src.line,
+        const error = this.getTestCaseError(tc)
-            path: src.file,
+        return new TestCaseResult(name, result, time, error)
-            message: fixEol(ex),
+      })
-            title: `[${suite.$.name}] ${tc.$.name.trim()}`
+      return new TestGroupResult(grp.describe, tests)
-          })
+    })
+  }
+
+  private getTestCaseResult(test: TestCase): TestExecutionResult {
+    if (test.failure) return 'failed'
+    if (test.skipped) return 'skipped'
+    return 'success'
+  }
+
+  private getTestCaseError(tc: TestCase): TestCaseError | undefined {
+    if (!this.options.parseErrors || !tc.failure) {
+      return undefined
+    }
+
+    const stackTrace = tc.failure[0]
+    let path
+    let line
+
+    const src = this.exceptionThrowSource(stackTrace)
+    if (src) {
+      path = src.path
+      line = src.line
+    }
+
+    return {
+      path,
+      line,
+      stackTrace
+    }
+  }
+
+  private exceptionThrowSource(stackTrace: string): {path: string; line: number} | undefined {
+    const lines = stackTrace.split(/\r?\n/)
+    const re = /\((.*):(\d+):\d+\)$/
+
+    const {workDir, trackedFiles} = this.options
+    for (const str of lines) {
+      const match = str.match(re)
+      if (match !== null) {
+        const [_, fileStr, lineStr] = match
+        const filePath = normalizeFilePath(fileStr)
+        const path = filePath.startsWith(workDir) ? filePath.substr(workDir.length) : filePath
+        if (trackedFiles.includes(path)) {
+          const line = parseInt(lineStr)
+
+          return {path, line}
         }
       }
     }
   }
-  return annotations
-}
-
-export function exceptionThrowSource(
-  ex: string,
-  workDir: string,
-  trackedFiles: string[]
-): {file: string; line: number; column: number} | null {
-  const lines = ex.split(/\r?\n/)
-  const re = /\((.*):(\d+):(\d+)\)$/
-
-  for (const str of lines) {
-    const match = str.match(re)
-    if (match !== null) {
-      const [_, fileStr, lineStr, colStr] = match
-      const filePath = normalizeFilePath(fileStr)
-      const file = filePath.startsWith(workDir) ? filePath.substr(workDir.length) : filePath
-      if (trackedFiles.includes(file)) {
-        const line = parseInt(lineStr)
-        const column = parseInt(colStr)
-        return {file, line, column}
-      }
-    }
-  }
-
-  return null
 }

src/parsers/parser-types.ts

@@ -1,28 +0,0 @@
-import {TestRunResult} from '../report/test-results'
-
-export type Annotation = {
-  path: string
-  start_line: number
-  end_line: number
-  start_column?: number
-  end_column?: number
-  annotation_level: 'notice' | 'warning' | 'failure'
-  message: string
-  title?: string
-  raw_details?: string
-}
-
-export type ParseTestResult = (files: FileContent[], options: ParseOptions) => Promise<TestResult>
-
-export type FileContent = {path: string; content: string}
-
-export interface ParseOptions {
-  annotations: boolean
-  workDir: string
-  trackedFiles: string[]
-}
-
-export interface TestResult {
-  testRuns: TestRunResult[]
-  annotations: Annotation[]
-}

src/report/get-annotations.ts

@@ -0,0 +1,111 @@
+import {ellipsis, fixEol} from '../utils/markdown-utils'
+import {TestRunResult} from '../test-results'
+
+type Annotation = {
+  path: string
+  start_line: number
+  end_line: number
+  start_column?: number
+  end_column?: number
+  annotation_level: 'notice' | 'warning' | 'failure'
+  message: string
+  title?: string
+  raw_details?: string
+}
+
+interface TestError {
+  testRunPaths: string[]
+  suiteName: string
+  testName: string
+  path: string
+  line: number
+  stackTrace: string
+  message: string
+}
+
+export function getAnnotations(results: TestRunResult[], maxCount: number): Annotation[] {
+  if (maxCount === 0) {
+    return []
+  }
+
+  // Collect errors from TestRunResults
+  // Merge duplicates if there are more test results files processed
+  const errors: TestError[] = []
+  const mergeDup = results.length > 1
+  for (const tr of results) {
+    for (const ts of tr.suites) {
+      for (const tg of ts.groups) {
+        for (const tc of tg.tests) {
+          const err = tc.error
+          if (err === undefined) {
+            continue
+          }
+          const path = err.path ?? tr.path
+          const line = err.line ?? 0
+          if (mergeDup) {
+            const dup = errors.find(e => path === e.path && line === e.line && err.stackTrace === e.stackTrace)
+            if (dup !== undefined) {
+              dup.testRunPaths.push(tr.path)
+              continue
+            }
+          }
+
+          errors.push({
+            testRunPaths: [tr.path],
+            suiteName: ts.name,
+            testName: tc.name,
+            stackTrace: err.stackTrace,
+            message: err.message ?? getFirstNonEmptyLine(err.stackTrace) ?? 'Test failed',
+            path,
+            line
+          })
+        }
+      }
+    }
+  }
+
+  // Limit number of created annotations
+  errors.splice(maxCount + 1)
+
+  const annotations = errors.map(e => {
+    const message = [
+      'Failed test found in:',
+      e.testRunPaths.map(p => `  ${p}`).join('\n'),
+      'Error:',
+      ident(fixEol(e.message), '  ')
+    ].join('\n')
+
+    return enforceCheckRunLimits({
+      path: e.path,
+      start_line: e.line,
+      end_line: e.line,
+      annotation_level: 'failure',
+      title: `${e.suiteName} ► ${e.testName}`,
+      raw_details: fixEol(e.stackTrace),
+      message
+    })
+  })
+
+  return annotations
+}
+
+function enforceCheckRunLimits(err: Annotation): Annotation {
+  err.title = ellipsis(err.title || '', 255)
+  err.message = ellipsis(err.message, 65535)
+  if (err.raw_details) {
+    err.raw_details = ellipsis(err.raw_details, 65535)
+  }
+  return err
+}
+
+function getFirstNonEmptyLine(stackTrace: string): string | undefined {
+  const lines = stackTrace.split(/\r?\n/g)
+  return lines.find(str => !/^\s*$/.test(str))
+}
+
+function ident(text: string, prefix: string): string {
+  return text
+    .split(/\n/g)
+    .map(line => prefix + line)
+    .join('\n')
+}

src/report/get-report.ts

@@ -1,5 +1,5 @@
 import * as core from '@actions/core'
-import {TestExecutionResult, TestRunResult, TestSuiteResult} from './test-results'
+import {TestExecutionResult, TestRunResult, TestSuiteResult} from '../test-results'
 import {Align, formatTime, Icon, link, table} from '../utils/markdown-utils'
 import {slug} from '../utils/slugger'
 
@@ -112,7 +112,7 @@ function getSuitesReport(tr: TestRunResult, runIndex: number, options: ReportOpt
   const icon = getResultIcon(tr.result)
   sections.push(`## ${nameLink} ${icon}`)
 
-  const time = `${(tr.time / 1000).toFixed(3)}s`
+  const time = formatTime(tr.time)
   const headingLine2 = `**${tr.tests}** tests were completed in **${time}** with **${tr.passed}** passed, **${tr.failed}** failed and **${tr.skipped}** skipped.`
   sections.push(headingLine2)
 
@@ -161,7 +161,8 @@ function getTestsReport(ts: TestSuiteResult, runIndex: number, suiteIndex: numbe
   const icon = getResultIcon(ts.result)
   sections.push(`### ${tsNameLink} ${icon}`)
 
-  const headingLine2 = `**${ts.tests}** tests were completed in **${ts.time}ms** with **${ts.passed}** passed, **${ts.failed}** failed and **${ts.skipped}** skipped.`
+  const tsTime = formatTime(ts.time)
+  const headingLine2 = `**${ts.tests}** tests were completed in **${tsTime}** with **${ts.passed}** passed, **${ts.failed}** failed and **${ts.skipped}** skipped.`
   sections.push(headingLine2)
 
   for (const grp of groups) {

src/test-parser.ts

@@ -0,0 +1,11 @@
+import {TestRunResult} from './test-results'
+
+export interface ParseOptions {
+  parseErrors: boolean
+  workDir: string
+  trackedFiles: string[]
+}
+
+export interface TestParser {
+  parse(path: string, content: string): Promise<TestRunResult>
+}

src/test-results.ts

@@ -83,7 +83,19 @@ export class TestGroupResult {
 }
 
 export class TestCaseResult {
-  constructor(readonly name: string, readonly result: TestExecutionResult, readonly time: number) {}
+  constructor(
+    readonly name: string,
+    readonly result: TestExecutionResult,
+    readonly time: number,
+    readonly error?: TestCaseError
+  ) {}
 }
 
 export type TestExecutionResult = 'success' | 'skipped' | 'failed' | undefined
+
+export interface TestCaseError {
+  path?: string
+  line?: number
+  message?: string
+  stackTrace: string
+}

src/utils/github-utils.ts

@@ -1,9 +1,6 @@
 import * as github from '@actions/github'
 import {EventPayloads} from '@octokit/webhooks'
 
-import {TestResult} from '../parsers/parser-types'
-import {ellipsis} from './markdown-utils'
-
 export function getCheckRunSha(): string {
   if (github.context.payload.pull_request) {
     const pr = github.context.payload.pull_request as EventPayloads.WebhookPayloadPullRequestPullRequest
@@ -12,14 +9,3 @@ export function getCheckRunSha(): string {
 
   return github.context.sha
 }
-
-export function enforceCheckRunLimits(result: TestResult, maxAnnotations: number): void {
-  // Limit number of created annotations
-  result.annotations.splice(maxAnnotations + 1)
-
-  // Limit number of characters in annotation fields
-  for (const err of result.annotations) {
-    err.title = ellipsis(err.title || '', 255)
-    err.message = ellipsis(err.message, 65535)
-  }
-}