CoCalc -- cellOperations.test.ts

GitHub Repository: microsoft/vscode
Path: blob/main/src/vs/workbench/contrib/notebook/test/browser/cellOperations.test.ts
³²⁹⁶ views
1
/*---------------------------------------------------------------------------------------------
2
 *  Copyright (c) Microsoft Corporation. All rights reserved.
3
 *  Licensed under the MIT License. See License.txt in the project root for license information.
4
 *--------------------------------------------------------------------------------------------*/
5

6
import assert from 'assert';
7
import { FoldingModel, updateFoldingStateAtIndex } from '../../browser/viewModel/foldingModel.js';
8
import { changeCellToKind, computeCellLinesContents, copyCellRange, insertCell, joinNotebookCells, moveCellRange, runDeleteAction } from '../../browser/controller/cellOperations.js';
9
import { CellEditType, CellKind, SelectionStateType } from '../../common/notebookCommon.js';
10
import { withTestNotebook } from './testNotebookEditor.js';
11
import { Range } from '../../../../../editor/common/core/range.js';
12
import { ResourceTextEdit } from '../../../../../editor/browser/services/bulkEditService.js';
13
import { ResourceNotebookCellEdit } from '../../../bulkEdit/browser/bulkCellEdits.js';
14
import { ILanguageService } from '../../../../../editor/common/languages/language.js';
15
import { ITextBuffer, ValidAnnotatedEditOperation } from '../../../../../editor/common/model.js';
16
import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../base/test/common/utils.js';
17

18
suite('CellOperations', () => {
19
	ensureNoDisposablesAreLeakedInTestSuite();
20

21
	test('Move cells - single cell', async function () {
22
		await withTestNotebook(
23
			[
24
				['# header a', 'markdown', CellKind.Markup, [], {}],
25
				['var b = 1;', 'javascript', CellKind.Code, [], {}],
26
				['# header b', 'markdown', CellKind.Markup, [], {}],
27
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
28
				['var c = 3;', 'javascript', CellKind.Code, [], {}]
29
			],
30
			async (editor, viewModel) => {
31
				viewModel.updateSelectionsState({ kind: SelectionStateType.Index, focus: { start: 1, end: 2 }, selections: [{ start: 1, end: 2 }] });
32
				const cell = viewModel.cellAt(1);
33
				assert.ok(cell);
34
				await moveCellRange({ notebookEditor: editor, cell: cell }, 'down');
35
				assert.strictEqual(viewModel.cellAt(2)?.getText(), 'var b = 1;');
36
				assert.strictEqual(cell, viewModel.cellAt(2));
37
			});
38
	});
39

40
	test('Move cells - multiple cells in a selection', async function () {
41
		await withTestNotebook(
42
			[
43
				['# header a', 'markdown', CellKind.Markup, [], {}],
44
				['var b = 1;', 'javascript', CellKind.Code, [], {}],
45
				['# header b', 'markdown', CellKind.Markup, [], {}],
46
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
47
				['var c = 3;', 'javascript', CellKind.Code, [], {}]
48
			],
49
			async (editor, viewModel) => {
50
				viewModel.updateSelectionsState({ kind: SelectionStateType.Index, focus: { start: 1, end: 2 }, selections: [{ start: 0, end: 2 }] });
51
				await moveCellRange({ notebookEditor: editor }, 'down');
52
				assert.strictEqual(viewModel.cellAt(0)?.getText(), '# header b');
53
				assert.strictEqual(viewModel.cellAt(1)?.getText(), '# header a');
54
				assert.strictEqual(viewModel.cellAt(2)?.getText(), 'var b = 1;');
55
			});
56
	});
57

58
	test('Move cells - move with folding ranges', async function () {
59
		await withTestNotebook(
60
			[
61
				['# header a', 'markdown', CellKind.Markup, [], {}],
62
				['var b = 1;', 'javascript', CellKind.Code, [], {}],
63
				['# header b', 'markdown', CellKind.Markup, [], {}],
64
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
65
				['var c = 3;', 'javascript', CellKind.Code, [], {}]
66
			],
67
			async (editor, viewModel, ds) => {
68
				const foldingModel = ds.add(new FoldingModel());
69
				foldingModel.attachViewModel(viewModel);
70
				updateFoldingStateAtIndex(foldingModel, 0, true);
71
				updateFoldingStateAtIndex(foldingModel, 1, true);
72
				viewModel.updateFoldingRanges(foldingModel.regions);
73
				editor.setHiddenAreas([{ start: 1, end: 2 }]);
74
				editor.setHiddenAreas(viewModel.getHiddenRanges());
75

76
				viewModel.updateSelectionsState({ kind: SelectionStateType.Index, focus: { start: 0, end: 1 }, selections: [{ start: 0, end: 1 }] });
77
				await moveCellRange({ notebookEditor: editor }, 'down');
78
				assert.strictEqual(viewModel.cellAt(0)?.getText(), '# header b');
79
				assert.strictEqual(viewModel.cellAt(1)?.getText(), '# header a');
80
				assert.strictEqual(viewModel.cellAt(2)?.getText(), 'var b = 1;');
81
			});
82
	});
83

84

85
	test('Copy/duplicate cells - single cell', async function () {
86
		await withTestNotebook(
87
			[
88
				['# header a', 'markdown', CellKind.Markup, [], {}],
89
				['var b = 1;', 'javascript', CellKind.Code, [], {}],
90
				['# header b', 'markdown', CellKind.Markup, [], {}],
91
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
92
				['var c = 3;', 'javascript', CellKind.Code, [], {}]
93
			],
94
			async (editor, viewModel) => {
95
				viewModel.updateSelectionsState({ kind: SelectionStateType.Index, focus: { start: 1, end: 2 }, selections: [{ start: 1, end: 2 }] });
96
				await copyCellRange({ notebookEditor: editor, cell: viewModel.cellAt(1)! }, 'down');
97
				assert.strictEqual(viewModel.length, 6);
98
				assert.strictEqual(viewModel.cellAt(1)?.getText(), 'var b = 1;');
99
				assert.strictEqual(viewModel.cellAt(2)?.getText(), 'var b = 1;');
100
			});
101
	});
102

103
	test('Copy/duplicate cells - target and selection are different, #119769', async function () {
104
		await withTestNotebook(
105
			[
106
				['# header a', 'markdown', CellKind.Markup, [], {}],
107
				['var b = 1;', 'javascript', CellKind.Code, [], {}],
108
				['# header b', 'markdown', CellKind.Markup, [], {}],
109
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
110
				['var c = 3;', 'javascript', CellKind.Code, [], {}]
111
			],
112
			async (editor, viewModel) => {
113
				viewModel.updateSelectionsState({ kind: SelectionStateType.Index, focus: { start: 0, end: 1 }, selections: [{ start: 0, end: 1 }] });
114
				await copyCellRange({ notebookEditor: editor, cell: viewModel.cellAt(1)!, ui: true }, 'down');
115
				assert.strictEqual(viewModel.length, 6);
116
				assert.strictEqual(viewModel.cellAt(1)?.getText(), 'var b = 1;');
117
				assert.strictEqual(viewModel.cellAt(2)?.getText(), 'var b = 1;');
118
			});
119
	});
120

121
	test('Copy/duplicate cells - multiple cells in a selection', async function () {
122
		await withTestNotebook(
123
			[
124
				['# header a', 'markdown', CellKind.Markup, [], {}],
125
				['var b = 1;', 'javascript', CellKind.Code, [], {}],
126
				['# header b', 'markdown', CellKind.Markup, [], {}],
127
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
128
				['var c = 3;', 'javascript', CellKind.Code, [], {}]
129
			],
130
			async (editor, viewModel) => {
131
				viewModel.updateSelectionsState({ kind: SelectionStateType.Index, focus: { start: 1, end: 2 }, selections: [{ start: 0, end: 2 }] });
132
				await copyCellRange({ notebookEditor: editor, cell: viewModel.cellAt(1)! }, 'down');
133
				assert.strictEqual(viewModel.length, 7);
134
				assert.strictEqual(viewModel.cellAt(0)?.getText(), '# header a');
135
				assert.strictEqual(viewModel.cellAt(1)?.getText(), 'var b = 1;');
136
				assert.strictEqual(viewModel.cellAt(2)?.getText(), '# header a');
137
				assert.strictEqual(viewModel.cellAt(3)?.getText(), 'var b = 1;');
138
			});
139
	});
140

141
	test('Copy/duplicate cells - move with folding ranges', async function () {
142
		await withTestNotebook(
143
			[
144
				['# header a', 'markdown', CellKind.Markup, [], {}],
145
				['var b = 1;', 'javascript', CellKind.Code, [], {}],
146
				['# header b', 'markdown', CellKind.Markup, [], {}],
147
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
148
				['var c = 3;', 'javascript', CellKind.Code, [], {}]
149
			],
150
			async (editor, viewModel, ds) => {
151
				const foldingModel = ds.add(new FoldingModel());
152
				foldingModel.attachViewModel(viewModel);
153
				updateFoldingStateAtIndex(foldingModel, 0, true);
154
				updateFoldingStateAtIndex(foldingModel, 1, true);
155
				viewModel.updateFoldingRanges(foldingModel.regions);
156
				editor.setHiddenAreas([{ start: 1, end: 2 }]);
157
				editor.setHiddenAreas(viewModel.getHiddenRanges());
158

159
				viewModel.updateSelectionsState({ kind: SelectionStateType.Index, focus: { start: 0, end: 1 }, selections: [{ start: 0, end: 1 }] });
160
				await copyCellRange({ notebookEditor: editor, cell: viewModel.cellAt(1)! }, 'down');
161
				assert.strictEqual(viewModel.length, 7);
162
				assert.strictEqual(viewModel.cellAt(0)?.getText(), '# header a');
163
				assert.strictEqual(viewModel.cellAt(1)?.getText(), 'var b = 1;');
164
				assert.strictEqual(viewModel.cellAt(2)?.getText(), '# header a');
165
				assert.strictEqual(viewModel.cellAt(3)?.getText(), 'var b = 1;');
166
			});
167
	});
168

169
	test('Copy/duplicate cells - should not share the same text buffer #102423', async function () {
170
		await withTestNotebook(
171
			[
172
				['# header a', 'markdown', CellKind.Markup, [], {}],
173
				['var b = 1;', 'javascript', CellKind.Code, [], {}]
174
			],
175
			async (editor, viewModel) => {
176
				viewModel.updateSelectionsState({ kind: SelectionStateType.Index, focus: { start: 1, end: 2 }, selections: [{ start: 1, end: 2 }] });
177
				await copyCellRange({ notebookEditor: editor, cell: viewModel.cellAt(1)! }, 'down');
178
				assert.strictEqual(viewModel.length, 3);
179
				const cell1 = viewModel.cellAt(1);
180
				const cell2 = viewModel.cellAt(2);
181
				assert.ok(cell1);
182
				assert.ok(cell2);
183
				assert.strictEqual(cell1.getText(), 'var b = 1;');
184
				assert.strictEqual(viewModel.cellAt(2)?.getText(), 'var b = 1;');
185

186
				(cell1.textBuffer as ITextBuffer).applyEdits([
187
					new ValidAnnotatedEditOperation(null, new Range(1, 1, 1, 4), '', false, false, false)
188
				], false, true);
189
				assert.notStrictEqual(cell1.getText(), cell2.getText());
190
			});
191
	});
192

193
	test('Join cell with below - single cell', async function () {
194
		await withTestNotebook(
195
			[
196
				['# header a', 'markdown', CellKind.Markup, [], {}],
197
				['var b = 1;', 'javascript', CellKind.Code, [], {}],
198
				['# header b', 'markdown', CellKind.Markup, [], {}],
199
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
200
				['var c = 3;', 'javascript', CellKind.Code, [], {}]
201
			],
202
			async (editor, viewModel, accessor) => {
203
				viewModel.updateSelectionsState({ kind: SelectionStateType.Index, focus: { start: 3, end: 4 }, selections: [{ start: 3, end: 4 }] });
204
				const ret = await joinNotebookCells(editor, { start: 3, end: 4 }, 'below');
205
				assert.strictEqual(ret?.edits.length, 2);
206
				assert.deepStrictEqual(ret?.edits[0], new ResourceTextEdit(viewModel.cellAt(3)!.uri, {
207
					range: new Range(1, 11, 1, 11), text: viewModel.cellAt(4)!.textBuffer.getEOL() + 'var c = 3;'
208
				}));
209
				assert.deepStrictEqual(ret?.edits[1], new ResourceNotebookCellEdit(editor.textModel.uri,
210
					{
211
						editType: CellEditType.Replace,
212
						index: 4,
213
						count: 1,
214
						cells: []
215
					}
216
				));
217
			});
218
	});
219

220
	test('Join cell with above - single cell', async function () {
221
		await withTestNotebook(
222
			[
223
				['# header a', 'markdown', CellKind.Markup, [], {}],
224
				['var b = 1;', 'javascript', CellKind.Code, [], {}],
225
				['# header b', 'markdown', CellKind.Markup, [], {}],
226
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
227
				['var c = 3;', 'javascript', CellKind.Code, [], {}]
228
			],
229
			async (editor, viewModel, accessor) => {
230
				viewModel.updateSelectionsState({ kind: SelectionStateType.Index, focus: { start: 3, end: 4 }, selections: [{ start: 3, end: 4 }] });
231
				const ret = await joinNotebookCells(editor, { start: 4, end: 5 }, 'above');
232
				assert.strictEqual(ret?.edits.length, 2);
233
				assert.deepStrictEqual(ret?.edits[0], new ResourceTextEdit(viewModel.cellAt(3)!.uri, {
234
					range: new Range(1, 11, 1, 11), text: viewModel.cellAt(4)!.textBuffer.getEOL() + 'var c = 3;'
235
				}));
236
				assert.deepStrictEqual(ret?.edits[1], new ResourceNotebookCellEdit(editor.textModel.uri,
237
					{
238
						editType: CellEditType.Replace,
239
						index: 4,
240
						count: 1,
241
						cells: []
242
					}
243
				));
244
			});
245
	});
246

247
	test('Join cell with below - multiple cells', async function () {
248
		await withTestNotebook(
249
			[
250
				['var a = 1;', 'javascript', CellKind.Code, [], {}],
251
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
252
				['var c = 3;', 'javascript', CellKind.Code, [], {}]
253
			],
254
			async (editor, viewModel, accessor) => {
255
				viewModel.updateSelectionsState({ kind: SelectionStateType.Index, focus: { start: 1, end: 2 }, selections: [{ start: 0, end: 2 }] });
256
				const ret = await joinNotebookCells(editor, { start: 0, end: 2 }, 'below');
257
				assert.strictEqual(ret?.edits.length, 2);
258
				assert.deepStrictEqual(ret?.edits[0], new ResourceTextEdit(viewModel.cellAt(0)!.uri, {
259
					range: new Range(1, 11, 1, 11), text: viewModel.cellAt(1)!.textBuffer.getEOL() + 'var b = 2;' + viewModel.cellAt(2)!.textBuffer.getEOL() + 'var c = 3;'
260
				}));
261
				assert.deepStrictEqual(ret?.edits[1], new ResourceNotebookCellEdit(editor.textModel.uri,
262
					{
263
						editType: CellEditType.Replace,
264
						index: 1,
265
						count: 2,
266
						cells: []
267
					}
268
				));
269
			});
270
	});
271

272
	test('Join cell with above - multiple cells', async function () {
273
		await withTestNotebook(
274
			[
275
				['var a = 1;', 'javascript', CellKind.Code, [], {}],
276
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
277
				['var c = 3;', 'javascript', CellKind.Code, [], {}]
278
			],
279
			async (editor, viewModel, accessor) => {
280
				viewModel.updateSelectionsState({ kind: SelectionStateType.Index, focus: { start: 2, end: 3 }, selections: [{ start: 1, end: 3 }] });
281
				const ret = await joinNotebookCells(editor, { start: 1, end: 3 }, 'above');
282
				assert.strictEqual(ret?.edits.length, 2);
283
				assert.deepStrictEqual(ret?.edits[0], new ResourceTextEdit(viewModel.cellAt(0)!.uri, {
284
					range: new Range(1, 11, 1, 11), text: viewModel.cellAt(1)!.textBuffer.getEOL() + 'var b = 2;' + viewModel.cellAt(2)!.textBuffer.getEOL() + 'var c = 3;'
285
				}));
286
				assert.deepStrictEqual(ret?.edits[1], new ResourceNotebookCellEdit(editor.textModel.uri,
287
					{
288
						editType: CellEditType.Replace,
289
						index: 1,
290
						count: 2,
291
						cells: []
292
					}
293
				));
294
			});
295
	});
296

297
	test('Delete focus cell', async function () {
298
		await withTestNotebook(
299
			[
300
				['var a = 1;', 'javascript', CellKind.Code, [], {}],
301
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
302
				['var c = 3;', 'javascript', CellKind.Code, [], {}]
303
			],
304
			async (editor, viewModel) => {
305
				editor.setFocus({ start: 0, end: 1 });
306
				editor.setSelections([{ start: 0, end: 1 }]);
307
				runDeleteAction(editor, viewModel.cellAt(0)!);
308
				assert.strictEqual(viewModel.length, 2);
309
			});
310
	});
311

312
	test('Delete selected cells', async function () {
313
		await withTestNotebook(
314
			[
315
				['var a = 1;', 'javascript', CellKind.Code, [], {}],
316
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
317
				['var c = 3;', 'javascript', CellKind.Code, [], {}]
318
			],
319
			async (editor, viewModel) => {
320
				editor.setFocus({ start: 0, end: 1 });
321
				editor.setSelections([{ start: 0, end: 2 }]);
322
				runDeleteAction(editor, viewModel.cellAt(0)!);
323
				assert.strictEqual(viewModel.length, 1);
324
			});
325
	});
326

327
	test('Delete focus cell out of a selection', async function () {
328
		await withTestNotebook(
329
			[
330
				['var a = 1;', 'javascript', CellKind.Code, [], {}],
331
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
332
				['var c = 3;', 'javascript', CellKind.Code, [], {}],
333
				['var d = 4;', 'javascript', CellKind.Code, [], {}],
334
			],
335
			async (editor, viewModel) => {
336
				editor.setFocus({ start: 0, end: 1 });
337
				editor.setSelections([{ start: 2, end: 4 }]);
338
				runDeleteAction(editor, viewModel.cellAt(0)!);
339
				assert.strictEqual(viewModel.length, 3);
340
			});
341
	});
342

343
	test('Delete UI target', async function () {
344
		await withTestNotebook(
345
			[
346
				['var a = 1;', 'javascript', CellKind.Code, [], {}],
347
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
348
				['var c = 3;', 'javascript', CellKind.Code, [], {}]
349
			],
350
			async (editor, viewModel) => {
351
				editor.setFocus({ start: 0, end: 1 });
352
				editor.setSelections([{ start: 0, end: 1 }]);
353
				runDeleteAction(editor, viewModel.cellAt(2)!);
354
				assert.strictEqual(viewModel.length, 2);
355
				assert.strictEqual(viewModel.cellAt(0)?.getText(), 'var a = 1;');
356
				assert.strictEqual(viewModel.cellAt(1)?.getText(), 'var b = 2;');
357
			});
358
	});
359

360
	test('Delete UI target 2', async function () {
361
		await withTestNotebook(
362
			[
363
				['var a = 1;', 'javascript', CellKind.Code, [], {}],
364
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
365
				['var c = 3;', 'javascript', CellKind.Code, [], {}],
366
				['var d = 4;', 'javascript', CellKind.Code, [], {}],
367
				['var e = 5;', 'javascript', CellKind.Code, [], {}],
368
			],
369
			async (editor, viewModel) => {
370
				editor.setFocus({ start: 0, end: 1 });
371
				editor.setSelections([{ start: 0, end: 1 }, { start: 3, end: 5 }]);
372
				runDeleteAction(editor, viewModel.cellAt(1)!);
373
				assert.strictEqual(viewModel.length, 4);
374
				assert.deepStrictEqual(editor.getFocus(), { start: 0, end: 1 });
375
				assert.deepStrictEqual(viewModel.getSelections(), [{ start: 0, end: 1 }, { start: 2, end: 4 }]);
376
			});
377
	});
378

379
	test('Delete UI target 3', async function () {
380
		await withTestNotebook(
381
			[
382
				['var a = 1;', 'javascript', CellKind.Code, [], {}],
383
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
384
				['var c = 3;', 'javascript', CellKind.Code, [], {}],
385
				['var d = 4;', 'javascript', CellKind.Code, [], {}],
386
				['var e = 5;', 'javascript', CellKind.Code, [], {}],
387
			],
388
			async (editor, viewModel) => {
389
				editor.setFocus({ start: 0, end: 1 });
390
				editor.setSelections([{ start: 2, end: 3 }]);
391
				runDeleteAction(editor, viewModel.cellAt(0)!);
392
				assert.strictEqual(viewModel.length, 4);
393
				assert.deepStrictEqual(editor.getFocus(), { start: 0, end: 1 });
394
				assert.deepStrictEqual(viewModel.getSelections(), [{ start: 1, end: 2 }]);
395
			});
396
	});
397

398
	test('Delete UI target 4', async function () {
399
		await withTestNotebook(
400
			[
401
				['var a = 1;', 'javascript', CellKind.Code, [], {}],
402
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
403
				['var c = 3;', 'javascript', CellKind.Code, [], {}],
404
				['var d = 4;', 'javascript', CellKind.Code, [], {}],
405
				['var e = 5;', 'javascript', CellKind.Code, [], {}],
406
			],
407
			async (editor, viewModel) => {
408
				editor.setFocus({ start: 2, end: 3 });
409
				editor.setSelections([{ start: 3, end: 5 }]);
410
				runDeleteAction(editor, viewModel.cellAt(0)!);
411
				assert.strictEqual(viewModel.length, 4);
412
				assert.deepStrictEqual(editor.getFocus(), { start: 1, end: 2 });
413
				assert.deepStrictEqual(viewModel.getSelections(), [{ start: 2, end: 4 }]);
414
			});
415
	});
416

417

418
	test('Delete last cell sets selection correctly', async function () {
419
		await withTestNotebook(
420
			[
421
				['var a = 1;', 'javascript', CellKind.Code, [], {}],
422
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
423
				['var c = 3;', 'javascript', CellKind.Code, [], {}]
424
			],
425
			async (editor, viewModel) => {
426
				editor.setFocus({ start: 2, end: 3 });
427
				editor.setSelections([{ start: 2, end: 3 }]);
428
				runDeleteAction(editor, viewModel.cellAt(2)!);
429
				assert.strictEqual(viewModel.length, 2);
430
				assert.deepStrictEqual(editor.getFocus(), { start: 1, end: 2 });
431
			});
432
	});
433

434
	test('#120187. Delete should work on multiple distinct selection', async function () {
435
		await withTestNotebook(
436
			[
437
				['var a = 1;', 'javascript', CellKind.Code, [], {}],
438
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
439
				['var c = 3;', 'javascript', CellKind.Code, [], {}],
440
				['var d = 4;', 'javascript', CellKind.Code, [], {}]
441
			],
442
			async (editor, viewModel) => {
443
				editor.setFocus({ start: 0, end: 1 });
444
				editor.setSelections([{ start: 0, end: 1 }, { start: 3, end: 4 }]);
445
				runDeleteAction(editor, viewModel.cellAt(0)!);
446
				assert.strictEqual(viewModel.length, 2);
447
				assert.deepStrictEqual(editor.getFocus(), { start: 0, end: 1 });
448
			});
449
	});
450

451
	test('#120187. Delete should work on multiple distinct selection 2', async function () {
452
		await withTestNotebook(
453
			[
454
				['var a = 1;', 'javascript', CellKind.Code, [], {}],
455
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
456
				['var c = 3;', 'javascript', CellKind.Code, [], {}],
457
				['var d = 4;', 'javascript', CellKind.Code, [], {}],
458
				['var e = 5;', 'javascript', CellKind.Code, [], {}],
459
			],
460
			async (editor, viewModel) => {
461
				editor.setFocus({ start: 1, end: 2 });
462
				editor.setSelections([{ start: 1, end: 2 }, { start: 3, end: 5 }]);
463
				runDeleteAction(editor, viewModel.cellAt(1)!);
464
				assert.strictEqual(viewModel.length, 2);
465
				assert.deepStrictEqual(editor.getFocus(), { start: 1, end: 2 });
466
			});
467
	});
468

469
	test('Change cell kind - single cell', async function () {
470
		await withTestNotebook(
471
			[
472
				['# header a', 'markdown', CellKind.Markup, [], {}],
473
				['var b = 1;', 'javascript', CellKind.Code, [], {}],
474
				['# header b', 'markdown', CellKind.Markup, [], {}],
475
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
476
				['var c = 3;', 'javascript', CellKind.Code, [], {}]
477
			],
478
			async (editor, viewModel) => {
479
				viewModel.updateSelectionsState({ kind: SelectionStateType.Index, focus: { start: 1, end: 2 }, selections: [{ start: 1, end: 2 }] });
480
				await changeCellToKind(CellKind.Markup, { notebookEditor: editor, cell: viewModel.cellAt(1)!, ui: true });
481
				assert.strictEqual(viewModel.cellAt(1)?.cellKind, CellKind.Markup);
482
			});
483
	});
484

485
	test('Change cell kind - multi cells', async function () {
486
		await withTestNotebook(
487
			[
488
				['# header a', 'markdown', CellKind.Markup, [], {}],
489
				['var b = 1;', 'javascript', CellKind.Code, [], {}],
490
				['# header b', 'markdown', CellKind.Markup, [], {}],
491
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
492
				['var c = 3;', 'javascript', CellKind.Code, [], {}]
493
			],
494
			async (editor, viewModel) => {
495
				viewModel.updateSelectionsState({ kind: SelectionStateType.Index, focus: { start: 1, end: 2 }, selections: [{ start: 1, end: 2 }] });
496
				await changeCellToKind(CellKind.Markup, { notebookEditor: editor, selectedCells: [viewModel.cellAt(3)!, viewModel.cellAt(4)!], ui: false });
497
				assert.strictEqual(viewModel.cellAt(3)?.cellKind, CellKind.Markup);
498
				assert.strictEqual(viewModel.cellAt(4)?.cellKind, CellKind.Markup);
499
			});
500
	});
501

502

503
	test('split cell', async function () {
504
		await withTestNotebook(
505
			[
506
				['var b = 1;', 'javascript', CellKind.Code, [], {}]
507
			],
508
			(editor, viewModel) => {
509
				assert.deepStrictEqual(computeCellLinesContents(viewModel.cellAt(0)!, [{ lineNumber: 1, column: 4 }]), [
510
					'var',
511
					' b = 1;'
512
				]);
513

514
				assert.deepStrictEqual(computeCellLinesContents(viewModel.cellAt(0)!, [{ lineNumber: 1, column: 4 }, { lineNumber: 1, column: 6 }]), [
515
					'var',
516
					' b',
517
					' = 1;'
518
				]);
519

520
				assert.deepStrictEqual(computeCellLinesContents(viewModel.cellAt(0)!, [{ lineNumber: 1, column: 1 }]), [
521
					'',
522
					'var b = 1;'
523
				]);
524

525
				assert.deepStrictEqual(computeCellLinesContents(viewModel.cellAt(0)!, [{ lineNumber: 1, column: 11 }]), [
526
					'var b = 1;',
527
					'',
528
				]);
529
			}
530
		);
531
	});
532

533
	test('Insert cell', async function () {
534
		await withTestNotebook(
535
			[
536
				['# header a', 'markdown', CellKind.Markup, [], {}],
537
				['var b = 1;', 'javascript', CellKind.Code, [], {}],
538
				['# header b', 'markdown', CellKind.Markup, [], {}],
539
				['var b = 2;', 'javascript', CellKind.Code, [], {}],
540
				['var c = 3;', 'javascript', CellKind.Code, [], {}]
541
			],
542
			async (editor, viewModel, _ds, accessor) => {
543
				const languageService = accessor.get(ILanguageService);
544

545
				const insertedCellAbove = insertCell(languageService, editor, 4, CellKind.Code, 'above', 'var a = 0;');
546
				assert.strictEqual(viewModel.length, 6);
547
				assert.strictEqual(viewModel.cellAt(4), insertedCellAbove);
548

549
				const insertedCellBelow = insertCell(languageService, editor, 1, CellKind.Code, 'below', 'var a = 0;');
550
				assert.strictEqual(viewModel.length, 7);
551
				assert.strictEqual(viewModel.cellAt(2), insertedCellBelow);
552
			});
553
	});
554
});
555

556
Product

Resources

Company
