master: removing missing subtests

.vscode/tasks.json

@@ -9,7 +9,7 @@
       "command": "mkdir",
       "args": ["-p", "out/tmp/workspaceFolder", "out/cpp"],
       "windows": {
-        "args": ["out\\tmp\\workspaceFolder", , "out\\cpp"]
+        "args": ["out\\tmp\\workspaceFolder", "out\\cpp"]
       },
       "presentation": {
         "echo": false,

CHANGELOG.md

@@ -6,9 +6,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## [Unreleased]
 
+## [4.0.8]
+
 ### Added
 
 - `envFile` now supports `.env` format too. (determines from the end of the filename)
+- removing missing SubCases / Sections
 
 ## [4.0.7] - 2021-11-27
 

src/AbstractTest.ts

@@ -151,11 +151,6 @@ export abstract class AbstractTest {
 
   ///
 
-  public resolve(): Promise<void> {
-    if (this._subTests) this._item.children.replace([...this._subTests].map(x => x[1].item));
-    return Promise.resolve();
-  }
-
   private _subTests: Map<string /*id*/, SubTest> | undefined = undefined;
 
   public async getOrCreateSubTest(
@@ -196,10 +191,27 @@ export abstract class AbstractTest {
     this._item.children.replace([]);
     this._subTests = undefined;
   }
+
+  public removeMissingSubTests(subTestTree: SubTestTree): void {
+    this._item.children.forEach(c => {
+      const subSections = subTestTree.get(c.id);
+      if (subSections) {
+        const subTest = this._subTests?.get(c.id);
+        if (subTest) subTest.removeMissingSubTests(subSections);
+      } else {
+        this._item.children.delete(c.id);
+        this._subTests?.delete(c.id);
+      }
+    });
+  }
 }
 
 ///
 
+export type SubTestTree = Map<string, SubTestTree>;
+
+///
+
 export class SubTest extends AbstractTest {
   constructor(
     shared: SharedWithTest,

src/framework/Catch2Executable.ts

@@ -8,7 +8,7 @@ import { AbstractExecutable, HandleProcessResult } from '../AbstractExecutable';
 import { Catch2Test } from './Catch2Test';
 import { WorkspaceShared } from '../WorkspaceShared';
 import { RunningExecutable } from '../RunningExecutable';
-import { AbstractTest } from '../AbstractTest';
+import { AbstractTest, SubTestTree } from '../AbstractTest';
 import { CancellationFlag, Version } from '../Util';
 import { TestGrouping } from '../TestGroupingInterface';
 import { TestResultBuilder } from '../TestResultBuilder';
@@ -433,12 +433,16 @@ class TestCaseListingProcessor implements XmlTagProcessor {
 ///
 
 abstract class TagProcessorBase implements XmlTagProcessor {
-  constructor(public readonly builder: TestResultBuilder, protected readonly shared: WorkspaceShared) {}
+  constructor(
+    public readonly builder: TestResultBuilder,
+    protected readonly shared: WorkspaceShared,
+    protected readonly sections: SubTestTree,
+  ) {}
 
   public onopentag(tag: XmlTag): void | XmlTagProcessor | Promise<void | XmlTagProcessor> {
     const procCreator = TagProcessorBase.openTagProcessorMap.get(tag.name);
     if (procCreator) {
-      return procCreator(tag, this.builder, this.shared);
+      return procCreator(tag, this.builder, this.shared, this.sections);
     } else if (procCreator === null) {
       // known tag, do nothing
     } else {
@@ -491,11 +495,12 @@ abstract class TagProcessorBase implements XmlTagProcessor {
         tag: XmlTag,
         builder: TestResultBuilder,
         shared: WorkspaceShared,
+        sections: SubTestTree,
       ) => void | XmlTagProcessor | Promise<void | XmlTagProcessor>)
   > = new Map([
     [
       'OverallResult',
-      (tag: XmlTag, builder: TestResultBuilder, _shared: WorkspaceShared) => {
+      (tag: XmlTag, builder: TestResultBuilder, _shared: WorkspaceShared, _sections: SubTestTree): void => {
         builder.setDurationMilisec(parseFloat(tag.attribs.durationInSeconds) * 1000);
         if (tag.attribs.success === 'true') {
           builder.passed();
@@ -525,8 +530,12 @@ abstract class TagProcessorBase implements XmlTagProcessor {
     ],
     [
       'Section',
-      (tag: XmlTag, builder: TestResultBuilder, shared: WorkspaceShared): Promise<XmlTagProcessor> =>
-        SectionProcessor.create(shared, builder, tag.attribs),
+      (
+        tag: XmlTag,
+        builder: TestResultBuilder,
+        shared: WorkspaceShared,
+        sections: SubTestTree,
+      ): Promise<XmlTagProcessor> => SectionProcessor.create(shared, builder, tag.attribs, sections),
     ],
     [
       'BenchmarkResults',
@@ -599,18 +608,14 @@ abstract class TagProcessorBase implements XmlTagProcessor {
 
 ///
 
-//type SectionTree = Map<string, SectionTree>;
-
 class TestCaseTagProcessor extends TagProcessorBase {
-  //TODO:private readonly sections: SectionTree = new Map();
-
   public constructor(
     shared: WorkspaceShared,
     builder: TestResultBuilder,
     private readonly test: Catch2Test,
     private readonly attribs: Record<string, string>,
   ) {
-    super(builder, shared);
+    super(builder, shared, new Map());
   }
 
   async begin(): Promise<void> {
@@ -619,24 +624,37 @@ class TestCaseTagProcessor extends TagProcessorBase {
   }
 
   end(): void {
+    this.builder.test.removeMissingSubTests(this.sections);
     this.builder.build();
   }
 }
 
 ///
 
 class SectionProcessor extends TagProcessorBase {
-  public static async create(shared: WorkspaceShared, testBuilder: TestResultBuilder, attribs: Record<string, string>) {
+  public static async create(
+    shared: WorkspaceShared,
+    testBuilder: TestResultBuilder,
+    attribs: Record<string, string>,
+    sections: SubTestTree,
+  ) {
     if (typeof attribs.name !== 'string' || !attribs.name) throw Error('Section must have name attribute');
 
     const subTest = await testBuilder.test.getOrCreateSubTest(attribs.name, undefined, attribs.filename, attribs.line);
     const subTestBuilder = testBuilder.createSubTestBuilder(subTest);
-    return new SectionProcessor(shared, subTestBuilder);
+
+    let subSections = sections.get(attribs.name);
+    if (subSections === undefined) {
+      subSections = new Map();
+      sections.set(attribs.name, subSections);
+    }
+
+    return new SectionProcessor(shared, subTestBuilder, subSections);
   }
 
-  private constructor(shared: WorkspaceShared, testBuilder: TestResultBuilder) {
+  private constructor(shared: WorkspaceShared, testBuilder: TestResultBuilder, sections: SubTestTree) {
     testBuilder.started();
-    super(testBuilder, shared);
+    super(testBuilder, shared, sections);
   }
 
   public end(): void {

src/framework/DOCExecutable.ts

@@ -14,6 +14,7 @@ import { XmlParser, XmlTag, XmlTagProcessor } from '../util/XmlParser';
 import { assert, debugAssert, debugBreak } from '../util/DevelopmentHelper';
 import { TestResultBuilder } from '../TestResultBuilder';
 import { TestItemParent } from '../TestItemManager';
+import { SubTestTree } from '../AbstractTest';
 
 export class DOCExecutable extends AbstractExecutable {
   public constructor(shared: WorkspaceShared, execInfo: RunnableProperties, docVersion: Version | undefined) {
@@ -318,12 +319,13 @@ abstract class TagProcessorBase implements XmlTagProcessor {
     public readonly builder: TestResultBuilder,
     protected readonly shared: WorkspaceShared,
     protected readonly caseData: CaseData,
+    protected readonly subCases: SubTestTree,
   ) {}
 
   public onopentag(tag: XmlTag): void | XmlTagProcessor | Promise<void | XmlTagProcessor> {
     const procCreator = TagProcessorBase.openTagProcessorMap.get(tag.name);
     if (procCreator) {
-      return procCreator(tag, this.builder, this.caseData, this.shared);
+      return procCreator(tag, this.builder, this.caseData, this.shared, this.subCases);
     } else if (procCreator === null) {
       // known tag, do nothing
     } else {
@@ -371,6 +373,7 @@ abstract class TagProcessorBase implements XmlTagProcessor {
         builder: TestResultBuilder,
         caseData: CaseData,
         shared: WorkspaceShared,
+        subCases: SubTestTree,
       ) => void | XmlTagProcessor | Promise<void | XmlTagProcessor>)
   > = new Map([
     [
@@ -380,9 +383,10 @@ abstract class TagProcessorBase implements XmlTagProcessor {
         builder: TestResultBuilder,
         caseData: CaseData,
         shared: WorkspaceShared,
+        subCases: SubTestTree,
       ): void | XmlTagProcessor | Promise<XmlTagProcessor> => {
         // if name is missing we don't create subcase for it
-        if (tag.attribs.name) return SubCaseProcessor.create(shared, builder, tag.attribs, caseData);
+        if (tag.attribs.name) return SubCaseProcessor.create(shared, builder, tag.attribs, caseData, subCases);
       },
     ],
     [
@@ -438,7 +442,7 @@ class TestCaseTagProcessor extends TagProcessorBase {
     private readonly attribs: Record<string, string>,
     _option: Option,
   ) {
-    super(builder, shared, {});
+    super(builder, shared, {}, new Map());
   }
 
   public async begin(): Promise<void> {
@@ -474,6 +478,7 @@ class TestCaseTagProcessor extends TagProcessorBase {
       }
 
       this.builder[result]();
+      TODO: this.builder.test.removeMissingSubTests(this.subCases);
       this.builder.build();
     } else {
       return super.onopentag(tag);
@@ -489,6 +494,7 @@ class SubCaseProcessor extends TagProcessorBase {
     testBuilder: TestResultBuilder,
     attribs: Record<string, string>,
     parentCaseData: CaseData,
+    subCases: SubTestTree,
   ): Promise<SubCaseProcessor> {
     if (typeof attribs.name !== 'string' || !attribs.name) throw Error('Section must have name attribute');
 
@@ -501,13 +507,24 @@ class SubCaseProcessor extends TagProcessorBase {
     const subTest = await testBuilder.test.getOrCreateSubTest(attribs.name, label, attribs.filename, attribs.line);
     const subTestBuilder = testBuilder.createSubTestBuilder(subTest);
 
-    return new SubCaseProcessor(shared, subTestBuilder, parentCaseData);
+    let subSubCases = subCases.get(attribs.name);
+    if (subSubCases === undefined) {
+      subSubCases = new Map();
+      subCases.set(attribs.name, subSubCases);
+    }
+
+    return new SubCaseProcessor(shared, subTestBuilder, parentCaseData, subSubCases);
   }
 
-  private constructor(shared: WorkspaceShared, testBuilder: TestResultBuilder, parentCaseData: CaseData) {
+  private constructor(
+    shared: WorkspaceShared,
+    testBuilder: TestResultBuilder,
+    parentCaseData: CaseData,
+    subCases: SubTestTree,
+  ) {
     testBuilder.started();
 
-    super(testBuilder, shared, parentCaseData);
+    super(testBuilder, shared, parentCaseData, subCases);
   }
 
   //doctest does not provide result for sub-cases, no point to build

src/main.ts

@@ -20,7 +20,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
     if (item) {
       const testData = testItemManager.map(item);
       if (testData) {
-        return testData.resolve();
+        return Promise.resolve(); //testData.resolve();
       } else {
         log.errorS('Missing TestData for item', item.id, item.label);
         return Promise.resolve();