Skip to content

Commit 8f2c8e3

Browse files
nisargjhaveriroblourens
nisargjhaveri
and
roblourens
authored
Allow different exception breakpoints from multiple debuggers to be shown at once (microsoft#158355)
* Update exception breakpoints based on active debug session - Keep track of all exception breakpoints, instead of the ones from last started session - Update breakpoints view when focused debugger changes to show the correct set of exception breakpoints - Store all exception breakpoints in model for restoring enablement later - Only send the correct set of breakpoints for each debug adapter when updated * Show last session's exception breakpoints even when the session is not active * Add more tests for exception breakpoints in multiple sessions * tsdoc commetns Co-authored-by: Rob Lourens <roblourens@gmail.com>
1 parent 896c32b commit 8f2c8e3

File tree

8 files changed

+161
-33
lines changed

8 files changed

+161
-33
lines changed

‎src/vs/workbench/contrib/debug/browser/breakpointsView.ts‎

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -63,8 +63,8 @@ function createCheckbox(disposables: IDisposable[]): HTMLInputElement {
6363
}
6464

6565
const MAX_VISIBLE_BREAKPOINTS = 9;
66-
export function getExpandedBodySize(model: IDebugModel, countLimit: number): number {
67-
const length = model.getBreakpoints().length + model.getExceptionBreakpoints().length + model.getFunctionBreakpoints().length + model.getDataBreakpoints().length + model.getInstructionBreakpoints().length;
66+
export function getExpandedBodySize(model: IDebugModel, sessionId: string | undefined, countLimit: number): number {
67+
const length = model.getBreakpoints().length + model.getExceptionBreakpointsForSession(sessionId).length + model.getFunctionBreakpoints().length + model.getDataBreakpoints().length + model.getInstructionBreakpoints().length;
6868
return Math.min(countLimit, length) * 22;
6969
}
7070
type BreakpointItem = IBreakpoint | IFunctionBreakpoint | IDataBreakpoint | IExceptionBreakpoint | IInstructionBreakpoint;
@@ -117,7 +117,7 @@ export class BreakpointsView extends ViewPane {
117117
this.breakpointSupportsCondition = CONTEXT_BREAKPOINT_SUPPORTS_CONDITION.bindTo(contextKeyService);
118118
this.breakpointInputFocused = CONTEXT_BREAKPOINT_INPUT_FOCUSED.bindTo(contextKeyService);
119119
this._register(this.debugService.getModel().onDidChangeBreakpoints(() => this.onBreakpointsChange()));
120-
this._register(this.debugService.getViewModel().onDidFocusSession(() => this.updateBreakpointsHint()));
120+
this._register(this.debugService.getViewModel().onDidFocusSession(() => this.onBreakpointsChange()));
121121
this._register(this.debugService.onDidChangeState(() => this.onStateChange()));
122122
this.hintDelayer = this._register(new RunOnceScheduler(() => this.updateBreakpointsHint(true), 4000));
123123
}
@@ -273,8 +273,9 @@ export class BreakpointsView extends ViewPane {
273273
const containerModel = this.viewDescriptorService.getViewContainerModel(this.viewDescriptorService.getViewContainerByViewId(this.id)!)!;
274274

275275
// Adjust expanded body size
276-
this.minimumBodySize = this.orientation === Orientation.VERTICAL ? getExpandedBodySize(this.debugService.getModel(), MAX_VISIBLE_BREAKPOINTS) : 170;
277-
this.maximumBodySize = this.orientation === Orientation.VERTICAL && containerModel.visibleViewDescriptors.length > 1 ? getExpandedBodySize(this.debugService.getModel(), Number.POSITIVE_INFINITY) : Number.POSITIVE_INFINITY;
276+
const sessionId = this.debugService.getViewModel().focusedSession?.getId();
277+
this.minimumBodySize = this.orientation === Orientation.VERTICAL ? getExpandedBodySize(this.debugService.getModel(), sessionId, MAX_VISIBLE_BREAKPOINTS) : 170;
278+
this.maximumBodySize = this.orientation === Orientation.VERTICAL && containerModel.visibleViewDescriptors.length > 1 ? getExpandedBodySize(this.debugService.getModel(), sessionId, Number.POSITIVE_INFINITY) : Number.POSITIVE_INFINITY;
278279
}
279280

280281
private updateBreakpointsHint(delayed = false): void {
@@ -363,7 +364,8 @@ export class BreakpointsView extends ViewPane {
363364

364365
private get elements(): BreakpointItem[] {
365366
const model = this.debugService.getModel();
366-
const elements = (<ReadonlyArray<IEnablement>>model.getExceptionBreakpoints()).concat(model.getFunctionBreakpoints()).concat(model.getDataBreakpoints()).concat(model.getBreakpoints()).concat(model.getInstructionBreakpoints());
367+
const sessionId = this.debugService.getViewModel().focusedSession?.getId();
368+
const elements = (<ReadonlyArray<IEnablement>>model.getExceptionBreakpointsForSession(sessionId)).concat(model.getFunctionBreakpoints()).concat(model.getDataBreakpoints()).concat(model.getBreakpoints()).concat(model.getInstructionBreakpoints());
367369

368370
return elements as BreakpointItem[];
369371
}

‎src/vs/workbench/contrib/debug/browser/debugService.ts‎

Lines changed: 15 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -152,8 +152,12 @@ export class DebugService implements IDebugService {
152152
this.disposables.add(this.viewModel.onDidFocusStackFrame(() => {
153153
this.onStateChange();
154154
}));
155-
this.disposables.add(this.viewModel.onDidFocusSession(() => {
155+
this.disposables.add(this.viewModel.onDidFocusSession((session: IDebugSession | undefined) => {
156156
this.onStateChange();
157+
158+
if (session) {
159+
this.setExceptionBreakpointFallbackSession(session.getId());
160+
}
157161
}));
158162
this.disposables.add(Event.any(this.adapterManager.onDidRegisterDebugger, this.configurationManager.onDidSelectConfiguration)(() => {
159163
const debugUxValue = (this.state !== State.Inactive || (this.configurationManager.getAllConfigurations().length > 0 && this.adapterManager.hasEnabledDebuggers())) ? 'default' : 'simple';
@@ -715,6 +719,8 @@ export class DebugService implements IDebugService {
715719
}
716720
}
717721
}
722+
723+
this.model.removeExceptionBreakpointsForSession(session.getId());
718724
}));
719725
}
720726

@@ -1046,8 +1052,13 @@ export class DebugService implements IDebugService {
10461052
await this.sendInstructionBreakpoints();
10471053
}
10481054

1049-
setExceptionBreakpoints(data: DebugProtocol.ExceptionBreakpointsFilter[]): void {
1050-
this.model.setExceptionBreakpoints(data);
1055+
setExceptionBreakpointFallbackSession(sessionId: string) {
1056+
this.model.setExceptionBreakpointFallbackSession(sessionId);
1057+
this.debugStorage.storeBreakpoints(this.model);
1058+
}
1059+
1060+
setExceptionBreakpointsForSession(session: IDebugSession, data: DebugProtocol.ExceptionBreakpointsFilter[]): void {
1061+
this.model.setExceptionBreakpointsForSession(session.getId(), data);
10511062
this.debugStorage.storeBreakpoints(this.model);
10521063
}
10531064

@@ -1121,9 +1132,8 @@ export class DebugService implements IDebugService {
11211132
}
11221133

11231134
private sendExceptionBreakpoints(session?: IDebugSession): Promise<void> {
1124-
const enabledExceptionBps = this.model.getExceptionBreakpoints().filter(exb => exb.enabled);
1125-
11261135
return sendToOneOrAllSessions(this.model, session, async s => {
1136+
const enabledExceptionBps = this.model.getExceptionBreakpointsForSession(s.getId()).filter(exb => exb.enabled);
11271137
if (s.capabilities.supportsConfigurationDoneRequest && (!s.capabilities.exceptionBreakpointFilters || s.capabilities.exceptionBreakpointFilters.length === 0)) {
11281138
// Only call `setExceptionBreakpoints` as specified in dap protocol #90001
11291139
return;

‎src/vs/workbench/contrib/debug/browser/debugSession.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -312,7 +312,7 @@ export class DebugSession implements IDebugSession {
312312

313313
this.initialized = true;
314314
this._onDidChangeState.fire();
315-
this.debugService.setExceptionBreakpoints((this.raw && this.raw.capabilities.exceptionBreakpointFilters) || []);
315+
this.debugService.setExceptionBreakpointsForSession(this, (this.raw && this.raw.capabilities.exceptionBreakpointFilters) || []);
316316
} catch (err) {
317317
this.initialized = true;
318318
this._onDidChangeState.fire();

‎src/vs/workbench/contrib/debug/common/debug.ts‎

Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -600,7 +600,18 @@ export interface IDebugModel extends ITreeElement {
600600
areBreakpointsActivated(): boolean;
601601
getFunctionBreakpoints(): ReadonlyArray<IFunctionBreakpoint>;
602602
getDataBreakpoints(): ReadonlyArray<IDataBreakpoint>;
603+
604+
/**
605+
* Returns list of all exception breakpoints.
606+
*/
603607
getExceptionBreakpoints(): ReadonlyArray<IExceptionBreakpoint>;
608+
609+
/**
610+
* Returns list of exception breakpoints for the given session
611+
* @param sessionId Session id. If falsy, returns the breakpoints from the last set fallback session.
612+
*/
613+
getExceptionBreakpointsForSession(sessionId?: string): ReadonlyArray<IExceptionBreakpoint>;
614+
604615
getInstructionBreakpoints(): ReadonlyArray<IInstructionBreakpoint>;
605616
getWatchExpressions(): ReadonlyArray<IExpression & IEvaluate>;
606617

@@ -1054,7 +1065,7 @@ export interface IDebugService {
10541065

10551066
setExceptionBreakpointCondition(breakpoint: IExceptionBreakpoint, condition: string | undefined): Promise<void>;
10561067

1057-
setExceptionBreakpoints(data: DebugProtocol.ExceptionBreakpointsFilter[]): void;
1068+
setExceptionBreakpointsForSession(session: IDebugSession, data: DebugProtocol.ExceptionBreakpointsFilter[]): void;
10581069

10591070
/**
10601071
* Sends all breakpoints to the passed session.

‎src/vs/workbench/contrib/debug/common/debugModel.ts‎

Lines changed: 63 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1056,14 +1056,17 @@ export class DataBreakpoint extends BaseBreakpoint implements IDataBreakpoint {
10561056

10571057
export class ExceptionBreakpoint extends BaseBreakpoint implements IExceptionBreakpoint {
10581058

1059+
private supportedSessions: Set<string> = new Set();
1060+
10591061
constructor(
10601062
public readonly filter: string,
10611063
public readonly label: string,
10621064
enabled: boolean,
10631065
public readonly supportsCondition: boolean,
10641066
condition: string | undefined,
10651067
public readonly description: string | undefined,
1066-
public readonly conditionDescription: string | undefined
1068+
public readonly conditionDescription: string | undefined,
1069+
private fallback: boolean = false
10671070
) {
10681071
super(enabled, undefined, condition, undefined, generateUuid());
10691072
}
@@ -1075,14 +1078,44 @@ export class ExceptionBreakpoint extends BaseBreakpoint implements IExceptionBre
10751078
result.enabled = this.enabled;
10761079
result.supportsCondition = this.supportsCondition;
10771080
result.condition = this.condition;
1081+
result.fallback = this.fallback;
10781082

10791083
return result;
10801084
}
10811085

1086+
setSupportedSession(sessionId: string, supported: boolean): void {
1087+
if (supported) {
1088+
this.supportedSessions.add(sessionId);
1089+
}
1090+
else {
1091+
this.supportedSessions.delete(sessionId);
1092+
}
1093+
}
1094+
1095+
/**
1096+
* Used to specify which breakpoints to show when no session is specified.
1097+
* Useful when no session is active and we want to show the exception breakpoints from the last session.
1098+
*/
1099+
setFallback(isFallback: boolean) {
1100+
this.fallback = isFallback;
1101+
}
1102+
10821103
get supported(): boolean {
10831104
return true;
10841105
}
10851106

1107+
/**
1108+
* Checks if the breakpoint is applicable for the specified session.
1109+
* If sessionId is undefined, returns true if this breakpoint is a fallback breakpoint.
1110+
*/
1111+
isSupportedSession(sessionId?: string): boolean {
1112+
return sessionId ? this.supportedSessions.has(sessionId) : this.fallback;
1113+
}
1114+
1115+
matches(filter: DebugProtocol.ExceptionBreakpointsFilter) {
1116+
return this.filter === filter.filter && this.label === filter.label && this.supportsCondition === !!filter.supportsCondition && this.conditionDescription === filter.conditionDescription && this.description === filter.description;
1117+
}
1118+
10861119
override toString(): string {
10871120
return this.label;
10881121
}
@@ -1340,26 +1373,45 @@ export class DebugModel implements IDebugModel {
13401373
return this.exceptionBreakpoints;
13411374
}
13421375

1376+
getExceptionBreakpointsForSession(sessionId?: string): IExceptionBreakpoint[] {
1377+
return this.exceptionBreakpoints.filter(ebp => ebp.isSupportedSession(sessionId));
1378+
}
1379+
13431380
getInstructionBreakpoints(): IInstructionBreakpoint[] {
13441381
return this.instructionBreakpoints;
13451382
}
13461383

1347-
setExceptionBreakpoints(data: DebugProtocol.ExceptionBreakpointsFilter[]): void {
1384+
setExceptionBreakpointsForSession(sessionId: string, data: DebugProtocol.ExceptionBreakpointsFilter[]): void {
13481385
if (data) {
1349-
if (this.exceptionBreakpoints.length === data.length && this.exceptionBreakpoints.every((exbp, i) =>
1350-
exbp.filter === data[i].filter && exbp.label === data[i].label && exbp.supportsCondition === data[i].supportsCondition && exbp.conditionDescription === data[i].conditionDescription && exbp.description === data[i].description)) {
1351-
// No change
1352-
return;
1353-
}
1386+
let didChangeBreakpoints = false;
1387+
data.forEach(d => {
1388+
let ebp = this.exceptionBreakpoints.filter((exbp) => exbp.matches(d)).pop();
1389+
1390+
if (!ebp) {
1391+
didChangeBreakpoints = true;
1392+
ebp = new ExceptionBreakpoint(d.filter, d.label, !!d.default, !!d.supportsCondition, undefined /* condition */, d.description, d.conditionDescription);
1393+
this.exceptionBreakpoints.push(ebp);
1394+
}
13541395

1355-
this.exceptionBreakpoints = data.map(d => {
1356-
const ebp = this.exceptionBreakpoints.filter(ebp => ebp.filter === d.filter).pop();
1357-
return new ExceptionBreakpoint(d.filter, d.label, ebp ? ebp.enabled : !!d.default, !!d.supportsCondition, ebp?.condition, d.description, d.conditionDescription);
1396+
ebp.setSupportedSession(sessionId, true);
13581397
});
1359-
this._onDidChangeBreakpoints.fire(undefined);
1398+
1399+
if (didChangeBreakpoints) {
1400+
this._onDidChangeBreakpoints.fire(undefined);
1401+
}
13601402
}
13611403
}
13621404

1405+
removeExceptionBreakpointsForSession(sessionId: string): void {
1406+
this.exceptionBreakpoints.forEach(ebp => ebp.setSupportedSession(sessionId, false));
1407+
}
1408+
1409+
// Set last focused session as fallback session.
1410+
// This is done to keep track of the exception breakpoints to show when no session is active.
1411+
setExceptionBreakpointFallbackSession(sessionId: string): void {
1412+
this.exceptionBreakpoints.forEach(ebp => ebp.setFallback(ebp.isSupportedSession(sessionId)));
1413+
}
1414+
13631415
setExceptionBreakpointCondition(exceptionBreakpoint: IExceptionBreakpoint, condition: string | undefined): void {
13641416
(exceptionBreakpoint as ExceptionBreakpoint).condition = condition;
13651417
this._onDidChangeBreakpoints.fire(undefined);

‎src/vs/workbench/contrib/debug/common/debugStorage.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -59,7 +59,7 @@ export class DebugStorage {
5959
let result: ExceptionBreakpoint[] | undefined;
6060
try {
6161
result = JSON.parse(this.storageService.get(DEBUG_EXCEPTION_BREAKPOINTS_KEY, StorageScope.WORKSPACE, '[]')).map((exBreakpoint: any) => {
62-
return new ExceptionBreakpoint(exBreakpoint.filter, exBreakpoint.label, exBreakpoint.enabled, exBreakpoint.supportsCondition, exBreakpoint.condition, exBreakpoint.description, exBreakpoint.conditionDescription);
62+
return new ExceptionBreakpoint(exBreakpoint.filter, exBreakpoint.label, exBreakpoint.enabled, exBreakpoint.supportsCondition, exBreakpoint.condition, exBreakpoint.description, exBreakpoint.conditionDescription, !!exBreakpoint.fallback);
6363
});
6464
} catch (e) { }
6565

‎src/vs/workbench/contrib/debug/test/browser/breakpoints.test.ts‎

Lines changed: 60 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -100,10 +100,10 @@ suite('Debug - Breakpoints', () => {
100100
const modelUri1 = uri.file('/myfolder/my file first.js');
101101
const modelUri2 = uri.file('/secondfolder/second/second file.js');
102102
addBreakpointsAndCheckEvents(model, modelUri1, [{ lineNumber: 5, enabled: true }, { lineNumber: 10, enabled: false }]);
103-
assert.strictEqual(getExpandedBodySize(model, 9), 44);
103+
assert.strictEqual(getExpandedBodySize(model, undefined, 9), 44);
104104

105105
addBreakpointsAndCheckEvents(model, modelUri2, [{ lineNumber: 1, enabled: true }, { lineNumber: 2, enabled: true }, { lineNumber: 3, enabled: false }]);
106-
assert.strictEqual(getExpandedBodySize(model, 9), 110);
106+
assert.strictEqual(getExpandedBodySize(model, undefined, 9), 110);
107107

108108
assert.strictEqual(model.getBreakpoints().length, 5);
109109
assert.strictEqual(model.getBreakpoints({ uri: modelUri1 }).length, 2);
@@ -137,7 +137,7 @@ suite('Debug - Breakpoints', () => {
137137
assert.strictEqual(bp.enabled, true);
138138

139139
model.removeBreakpoints(model.getBreakpoints({ uri: modelUri1 }));
140-
assert.strictEqual(getExpandedBodySize(model, 9), 66);
140+
assert.strictEqual(getExpandedBodySize(model, undefined, 9), 66);
141141

142142
assert.strictEqual(model.getBreakpoints().length, 3);
143143
});
@@ -213,22 +213,75 @@ suite('Debug - Breakpoints', () => {
213213
test('exception breakpoints', () => {
214214
let eventCount = 0;
215215
model.onDidChangeBreakpoints(() => eventCount++);
216-
model.setExceptionBreakpoints([{ filter: 'uncaught', label: 'UNCAUGHT', default: true }]);
216+
model.setExceptionBreakpointsForSession("session-id-1", [{ filter: 'uncaught', label: 'UNCAUGHT', default: true }]);
217217
assert.strictEqual(eventCount, 1);
218-
let exceptionBreakpoints = model.getExceptionBreakpoints();
218+
let exceptionBreakpoints = model.getExceptionBreakpointsForSession("session-id-1");
219219
assert.strictEqual(exceptionBreakpoints.length, 1);
220220
assert.strictEqual(exceptionBreakpoints[0].filter, 'uncaught');
221221
assert.strictEqual(exceptionBreakpoints[0].enabled, true);
222222

223-
model.setExceptionBreakpoints([{ filter: 'uncaught', label: 'UNCAUGHT' }, { filter: 'caught', label: 'CAUGHT' }]);
223+
model.setExceptionBreakpointsForSession("session-id-2", [{ filter: 'uncaught', label: 'UNCAUGHT' }, { filter: 'caught', label: 'CAUGHT' }]);
224224
assert.strictEqual(eventCount, 2);
225-
exceptionBreakpoints = model.getExceptionBreakpoints();
225+
exceptionBreakpoints = model.getExceptionBreakpointsForSession("session-id-2");
226226
assert.strictEqual(exceptionBreakpoints.length, 2);
227227
assert.strictEqual(exceptionBreakpoints[0].filter, 'uncaught');
228228
assert.strictEqual(exceptionBreakpoints[0].enabled, true);
229229
assert.strictEqual(exceptionBreakpoints[1].filter, 'caught');
230230
assert.strictEqual(exceptionBreakpoints[1].label, 'CAUGHT');
231231
assert.strictEqual(exceptionBreakpoints[1].enabled, false);
232+
233+
model.setExceptionBreakpointsForSession("session-id-3", [{ filter: 'all', label: 'ALL' }]);
234+
assert.strictEqual(eventCount, 3);
235+
assert.strictEqual(model.getExceptionBreakpointsForSession("session-id-3").length, 1);
236+
exceptionBreakpoints = model.getExceptionBreakpoints();
237+
assert.strictEqual(exceptionBreakpoints[0].filter, 'uncaught');
238+
assert.strictEqual(exceptionBreakpoints[0].enabled, true);
239+
assert.strictEqual(exceptionBreakpoints[1].filter, 'caught');
240+
assert.strictEqual(exceptionBreakpoints[1].label, 'CAUGHT');
241+
assert.strictEqual(exceptionBreakpoints[1].enabled, false);
242+
assert.strictEqual(exceptionBreakpoints[2].filter, 'all');
243+
assert.strictEqual(exceptionBreakpoints[2].label, 'ALL');
244+
});
245+
246+
test('exception breakpoints multiple sessions', () => {
247+
let eventCount = 0;
248+
model.onDidChangeBreakpoints(() => eventCount++);
249+
250+
model.setExceptionBreakpointsForSession("session-id-4", [{ filter: 'uncaught', label: 'UNCAUGHT', default: true }, { filter: 'caught', label: 'CAUGHT' }]);
251+
model.setExceptionBreakpointFallbackSession("session-id-4");
252+
assert.strictEqual(eventCount, 1);
253+
let exceptionBreakpointsForSession = model.getExceptionBreakpointsForSession("session-id-4");
254+
assert.strictEqual(exceptionBreakpointsForSession.length, 2);
255+
assert.strictEqual(exceptionBreakpointsForSession[0].filter, 'uncaught');
256+
assert.strictEqual(exceptionBreakpointsForSession[1].filter, 'caught');
257+
258+
model.setExceptionBreakpointsForSession("session-id-5", [{ filter: 'all', label: 'ALL' }, { filter: 'caught', label: 'CAUGHT' }]);
259+
assert.strictEqual(eventCount, 2);
260+
exceptionBreakpointsForSession = model.getExceptionBreakpointsForSession("session-id-5");
261+
let exceptionBreakpointsForUndefined = model.getExceptionBreakpointsForSession(undefined);
262+
assert.strictEqual(exceptionBreakpointsForSession.length, 2);
263+
assert.strictEqual(exceptionBreakpointsForSession[0].filter, 'caught');
264+
assert.strictEqual(exceptionBreakpointsForSession[1].filter, 'all');
265+
assert.strictEqual(exceptionBreakpointsForUndefined.length, 2);
266+
assert.strictEqual(exceptionBreakpointsForUndefined[0].filter, 'uncaught');
267+
assert.strictEqual(exceptionBreakpointsForUndefined[1].filter, 'caught');
268+
269+
model.removeExceptionBreakpointsForSession("session-id-4");
270+
assert.strictEqual(eventCount, 2);
271+
exceptionBreakpointsForUndefined = model.getExceptionBreakpointsForSession(undefined);
272+
assert.strictEqual(exceptionBreakpointsForUndefined.length, 2);
273+
assert.strictEqual(exceptionBreakpointsForUndefined[0].filter, 'uncaught');
274+
assert.strictEqual(exceptionBreakpointsForUndefined[1].filter, 'caught');
275+
276+
model.setExceptionBreakpointFallbackSession("session-id-5");
277+
assert.strictEqual(eventCount, 2);
278+
exceptionBreakpointsForUndefined = model.getExceptionBreakpointsForSession(undefined);
279+
assert.strictEqual(exceptionBreakpointsForUndefined.length, 2);
280+
assert.strictEqual(exceptionBreakpointsForUndefined[0].filter, 'caught');
281+
assert.strictEqual(exceptionBreakpointsForUndefined[1].filter, 'all');
282+
283+
const exceptionBreakpoints = model.getExceptionBreakpoints();
284+
assert.strictEqual(exceptionBreakpoints.length, 3);
232285
});
233286

234287
test('instruction breakpoints', () => {

‎src/vs/workbench/contrib/debug/test/common/mockDebug.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -93,7 +93,7 @@ export class MockDebugService implements IDebugService {
9393
throw new Error('Method not implemented.');
9494
}
9595

96-
setExceptionBreakpoints(data: DebugProtocol.ExceptionBreakpointsFilter[]): void {
96+
setExceptionBreakpointsForSession(session: IDebugSession, data: DebugProtocol.ExceptionBreakpointsFilter[]): void {
9797
throw new Error('Method not implemented.');
9898
}
9999

0 commit comments

Comments
 (0)