improve encapsulation of CommandContext

src/BuildTaskProvider.ts

@@ -130,7 +130,7 @@ export class BuildTaskProvider implements vscode.TaskProvider {
                     onDidWrite: writeEmitter.event,
                     onDidClose: closeEmitter.event,
                     close: async () => {
-                        commandContext?.cancellationToken.cancel();
+                        commandContext?.cancel();
                     },
                 };
                 resolved(pty);

src/CommandManagement/AtomicCommand.ts

@@ -50,13 +50,13 @@ export class AtomicCommand {
         try {
             if (this._mutex.isLocked()) {
                 if (this._executingCommand == "autowatcher") {
-                    this._prevCommandContext?.cancellationToken.cancel();
+                    this._prevCommandContext?.cancel();
                     this._mutex.cancel();
                 } else {
                     throw UserCommandIsExecuting;
                 }
             } else {
-                this._prevCommandContext?.cancellationToken.cancel();
+                this._prevCommandContext?.cancel();
             }
             release = await this._mutex.acquire();
             if (currentOperationID !== this.latestOperationID)
@@ -75,11 +75,11 @@ export class AtomicCommand {
         }
     }
 
-    private async withCancellation(closure: () => Promise<void>, cancellation: vscode.CancellationTokenSource) {
+    private async withCancellation(closure: () => Promise<void>, cancellation: vscode.CancellationToken) {
         let dis: vscode.Disposable;
         return new Promise<void>(async (resolve, reject) => {
             try {
-                dis = cancellation.token.onCancellationRequested(e => {
+                dis = cancellation.onCancellationRequested(e => {
                     dis.dispose();
                     reject(UserTerminatedError);
                 })
@@ -107,13 +107,13 @@ export class AtomicCommand {
                     );
                 }
                 if (choice === "Terminate") {
-                    this._prevCommandContext?.cancellationToken.cancel();
+                    this._prevCommandContext?.cancel();
                     this._mutex.cancel();
                 } else {
                     throw UserCommandIsExecuting;
                 }
             } else {
-                this._prevCommandContext?.cancellationToken.cancel();
+                this._prevCommandContext?.cancel();
             }
             releaser = await this._mutex.acquire();
             if (currentOperationID !== this.latestOperationID)

src/CommandManagement/CommandContext.ts

@@ -4,12 +4,19 @@ import { Executor, ExecutorMode, ExecutorReturnType } from "../execShell";
 export const UserTerminatedError: Error = new Error("Terminated");
 
 export class CommandContext {
-    cancellationToken: vscode.CancellationTokenSource;
-    private executor: Executor;
+
+    private _cancellationTokenSource: vscode.CancellationTokenSource;
+    private _executor: Executor;
+    public get executor(): Executor {
+        return this.executor;
+    }
+    public get cancellationToken(): vscode.CancellationToken {
+        return this._cancellationTokenSource.token;
+    }
 
     constructor(cancellationToken: vscode.CancellationTokenSource, executor: Executor) {
-        this.cancellationToken = cancellationToken;
-        this.executor = executor;
+        this._cancellationTokenSource = cancellationToken;
+        this._executor = executor;
     }
 
     public async execShell(
@@ -20,8 +27,8 @@ export class CommandContext {
         returnType = ExecutorReturnType.statusCode,
         mode: ExecutorMode = ExecutorMode.verbose
     ): Promise<boolean | string> {
-        return await this.executor.execShell(
-            this.cancellationToken.token,
+        return await this._executor.execShell(
+            this._cancellationTokenSource.token,
             commandName,
             fileOrCommand,
             args,
@@ -30,4 +37,8 @@ export class CommandContext {
             mode
         )
     }
+
+    public cancel() {
+        this._cancellationTokenSource.cancel();
+    }
 }

src/Debug/DebugAdapterTracker.ts

@@ -64,7 +64,7 @@ export class DebugAdapterTracker implements vscode.DebugAdapterTracker {
             await DebugAdapterTracker.updateStatus(this.sessionID, "stopped");
             const terminationContext = new CommandContext(new vscode.CancellationTokenSource(), new Executor());
             await terminateCurrentIOSApp(terminationContext, this.sessionID, true);
-            this.commandContext?.cancellationToken.cancel();
+            this.commandContext?.cancel();
         } finally {
             try {
                 await vscode.debug.stopDebugging(this.debugSession);

src/Debug/DebugConfigurationProvider.ts

@@ -59,7 +59,7 @@ export class DebugConfigurationProvider implements vscode.DebugConfigurationProv
         });
     }
 
-    async startIOSTestsDebugger(isDebuggable: boolean) {
+    async startIOSTestsDebugger(isDebuggable: boolean, testRun: vscode.TestRun) {
         const appSessionId = getSessionId(`All tests: ${isDebuggable}${this.counterID}`);
         let debugSession: vscode.DebugConfiguration = {
             type: "xcode-lldb",
@@ -76,20 +76,19 @@ export class DebugConfigurationProvider implements vscode.DebugConfigurationProv
                 if (e === appSessionId)
                     resolve(true);
             });
-            vscode.debug.startDebugging(undefined, debugSession);
+            vscode.debug.startDebugging(undefined, debugSession, { testRun: testRun });
         });
     }
 
-    async startIOSTestsForCurrentFileDebugger(tests: string[], isDebuggable: boolean) {
+    async startIOSTestsForCurrentFileDebugger(tests: string[], isDebuggable: boolean, testRun: vscode.TestRun) {
         const appSessionId = `${getSessionId(tests.join(","))}_${isDebuggable}${this.counterID}`;
         let debugSession: vscode.DebugConfiguration = {
             type: "xcode-lldb",
             name: "iOS: Run Tests & Debug: Current File",
             request: "launch",
             target: "testsForCurrentFile",
             isDebuggable: isDebuggable,
-            appSessionId: appSessionId,
-            testsToRun: tests
+            appSessionId: appSessionId
         };
 
         let dis: vscode.Disposable | undefined;
@@ -98,7 +97,7 @@ export class DebugConfigurationProvider implements vscode.DebugConfigurationProv
                 if (e === appSessionId)
                     resolve(true);
             });
-            vscode.debug.startDebugging(undefined, debugSession);
+            vscode.debug.startDebugging(undefined, debugSession, { testRun: testRun });
         });
     }
 

src/TestsProvider/TestProvider.ts

@@ -13,12 +13,12 @@ import { error } from 'console';
 
 export class TestProvider {
     projectManager: ProjectManager
-    executeTests: (tests: string[] | undefined, isDebuggable: boolean) => Promise<boolean>;
+    executeTests: (tests: string[] | undefined, isDebuggable: boolean, testRun: vscode.TestRun) => Promise<boolean>;
     context = new TestTreeContext();
     asyncParser = new TestCaseAsyncParser()
     asyncTestCaseParser = new TestCaseProblemParser();
 
-    constructor(projectManager: ProjectManager, executeTests: (tests: string[] | undefined, isDebuggable: boolean) => Promise<boolean>) {
+    constructor(projectManager: ProjectManager, executeTests: (tests: string[] | undefined, isDebuggable: boolean, testRun: vscode.TestRun) => Promise<boolean>) {
         this.projectManager = projectManager;
         this.executeTests = executeTests;
     }
@@ -97,7 +97,7 @@ export class TestProvider {
                             }
                             console.log("log");
                         });
-                    await this.executeTests(request.include === undefined ? undefined : tests, request.profile?.kind === vscode.TestRunProfileKind.Debug);
+                    await this.executeTests(request.include === undefined ? undefined : tests, request.profile?.kind === vscode.TestRunProfileKind.Debug, run);
                 }
                 catch (err) {
                     console.log(`Run with error: ${err}`);

src/extension.ts

@@ -61,8 +61,7 @@ async function initialize(atomicCommand: AtomicCommand, projectManager: ProjectM
     }
 }
 
-const projectExecutor = new Executor();
-const atomicCommand = new AtomicCommand(projectExecutor);
+const atomicCommand = new AtomicCommand(new Executor());
 const problemDiagnosticResolver = new ProblemDiagnosticResolver();
 
 let debugConfiguration: DebugConfigurationProvider;
@@ -131,11 +130,11 @@ export async function activate(context: vscode.ExtensionContext) {
         debugSessionEndEvent.event
     );
 
-    testProvider = new TestProvider(projectManager, async (tests, isDebuggable) => {
+    testProvider = new TestProvider(projectManager, async (tests, isDebuggable, testRun) => {
         if (tests) {
-            return await debugConfiguration.startIOSTestsForCurrentFileDebugger(tests, isDebuggable);
+            return await debugConfiguration.startIOSTestsForCurrentFileDebugger(tests, isDebuggable, testRun);
         } else {
-            return await debugConfiguration.startIOSTestsDebugger(isDebuggable);
+            return await debugConfiguration.startIOSTestsDebugger(isDebuggable, testRun);
         }
     });
     testProvider.activateTests(context);