CoCalc -- chatEditingModifiedNotebookEntry.test.ts

GitHub Repository: microsoft/vscode
Path: blob/main/src/vs/workbench/contrib/chat/test/browser/chatEditingModifiedNotebookEntry.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 { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../base/test/common/utils.js';
8
import { adjustCellDiffAndOriginalModelBasedOnCellAddDelete, adjustCellDiffAndOriginalModelBasedOnCellMovements, adjustCellDiffForKeepingADeletedCell, adjustCellDiffForKeepingAnInsertedCell, adjustCellDiffForRevertingADeletedCell, adjustCellDiffForRevertingAnInsertedCell } from '../../browser/chatEditing/notebook/helpers.js';
9
import { ICellDiffInfo } from '../../browser/chatEditing/notebook/notebookCellChanges.js';
10
import { nullDocumentDiff } from '../../../../../editor/common/diff/documentDiffProvider.js';
11
import { ObservablePromise, observableValue } from '../../../../../base/common/observable.js';
12
import { CellEditType, CellKind, ICell, ICellEditOperation, NotebookCellsChangeType } from '../../../notebook/common/notebookCommon.js';
13
import { ITextModel } from '../../../../../editor/common/model.js';
14
import { URI } from '../../../../../base/common/uri.js';
15
import { hash } from '../../../../../base/common/hash.js';
16
import { generateUuid } from '../../../../../base/common/uuid.js';
17

18
suite('ChatEditingModifiedNotebookEntry', function () {
19
	suite('Keep Inserted Cell', function () {
20

21
		const keep = () => Promise.resolve(true);
22
		const undo = () => Promise.resolve(true);
23
		const diff = observableValue('cell1', nullDocumentDiff);
24
		const appliedEdits: ICellEditOperation[] = [];
25
		setup(() => {
26
			appliedEdits.length = 0;
27
		});
28
		ensureNoDisposablesAreLeakedInTestSuite();
29
		function createModifiedModel(id: string): ObservablePromise<ITextModel> {
30
			return `Modified:${id}` as any;
31

32
		}
33
		function createOriginalModel(id: string): ObservablePromise<ITextModel> {
34
			return `Original:${id}` as any;
35

36
		}
37
		function applyEdits(edits: ICellEditOperation[]): boolean {
38
			appliedEdits.push(...edits);
39
			return true;
40
		}
41

42
		function createModifiedCellDiffInfo(modifiedCellIndex: number, originalCellIndex: number): ICellDiffInfo {
43
			return {
44
				diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel(`InsertedOriginal:${originalCellIndex}`), originalCellIndex,
45
				modifiedCellIndex, modifiedModel: createModifiedModel(`InsertedModified:${modifiedCellIndex}`),
46
			};
47
		}
48
		test('Keep first inserted', async function () {
49
			const cellsDiffInfo: ICellDiffInfo[] = [
50
				{
51
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
52
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('New0'),
53
				},
54
				{
55
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
56
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
57
				},
58
			];
59

60
			const result = adjustCellDiffForKeepingAnInsertedCell(0,
61
				cellsDiffInfo, {} as any,
62
				applyEdits, createModifiedCellDiffInfo);
63

64
			assert.deepStrictEqual(appliedEdits, [
65
				{ editType: CellEditType.Replace, index: 0, cells: [{}], count: 0 },
66
			]);
67
			assert.deepStrictEqual(result, [
68
				{
69
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel(`InsertedOriginal:0`), originalCellIndex: 0,
70
					modifiedCellIndex: 0, modifiedModel: createModifiedModel(`InsertedModified:0`),
71
				},
72
				{
73
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 1,
74
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
75
				},
76
			]);
77
		});
78
		test('Keep first inserted with multiple cells', async function () {
79
			const cellsDiffInfo: ICellDiffInfo[] = [
80
				{
81
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
82
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('New0'),
83
				},
84
				{
85
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
86
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
87
				},
88
				{
89
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('1'), originalCellIndex: 1,
90
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
91
				},
92
				{
93
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
94
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('1'),
95
				},
96
				{
97
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 2,
98
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('2'),
99
				},
100
			];
101

102
			const result = adjustCellDiffForKeepingAnInsertedCell(0,
103
				cellsDiffInfo, {} as any,
104
				applyEdits, createModifiedCellDiffInfo);
105

106
			assert.deepStrictEqual(appliedEdits, [
107
				{ editType: CellEditType.Replace, index: 0, cells: [{}], count: 0 },
108
			]);
109
			assert.deepStrictEqual(result, [
110
				{
111
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('InsertedOriginal:0'), originalCellIndex: 0,
112
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('InsertedModified:0'),
113
				},
114
				{
115
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 1,
116
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
117
				},
118
				{
119
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('1'), originalCellIndex: 2,
120
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
121
				},
122
				{
123
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
124
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('1'),
125
				},
126
				{
127
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 3,
128
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('2'),
129
				},
130
			]);
131
		});
132
		test('Keep second inserted with multiple cells', async function () {
133
			const cellsDiffInfo: ICellDiffInfo[] = [
134
				{
135
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
136
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('New0'),
137
				},
138
				{
139
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
140
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
141
				},
142
				{
143
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('1'), originalCellIndex: 1,
144
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
145
				},
146
				{
147
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
148
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('1'),
149
				},
150
				{
151
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 2,
152
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('2'),
153
				},
154
			];
155

156
			const result = adjustCellDiffForKeepingAnInsertedCell(2,
157
				cellsDiffInfo, {} as any,
158
				applyEdits, createModifiedCellDiffInfo);
159

160
			assert.deepStrictEqual(appliedEdits, [
161
				{ editType: CellEditType.Replace, index: 2, cells: [{}], count: 0 },
162
			]);
163
			assert.deepStrictEqual(result, [
164
				{
165
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
166
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('New0'),
167
				},
168
				{
169
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
170
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
171
				},
172
				{
173
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('1'), originalCellIndex: 1,
174
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
175
				},
176
				{
177
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('InsertedOriginal:2'), originalCellIndex: 2,
178
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('InsertedModified:2'),
179
				},
180
				{
181
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 3,
182
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('2'),
183
				},
184
			]);
185
		});
186
	});
187

188
	suite('Revert Inserted Cell', function () {
189

190
		const keep = () => Promise.resolve(true);
191
		const undo = () => Promise.resolve(true);
192
		const diff = observableValue('cell1', nullDocumentDiff);
193
		const appliedEdits: ICellEditOperation[] = [];
194
		setup(() => {
195
			appliedEdits.length = 0;
196
		});
197
		ensureNoDisposablesAreLeakedInTestSuite();
198
		function createModifiedModel(id: string): ObservablePromise<ITextModel> {
199
			return `Modified:${id}` as any;
200

201
		}
202
		function createOriginalModel(id: string): ObservablePromise<ITextModel> {
203
			return `Original:${id}` as any;
204

205
		}
206
		function applyEdits(edits: ICellEditOperation[]): boolean {
207
			appliedEdits.push(...edits);
208
			return true;
209
		}
210

211
		test('Delete first inserted', async function () {
212
			const cellsDiffInfo: ICellDiffInfo[] = [
213
				{
214
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
215
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('New0'),
216
				},
217
				{
218
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
219
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
220
				},
221
			];
222

223
			const result = adjustCellDiffForRevertingAnInsertedCell(0,
224
				cellsDiffInfo,
225
				applyEdits);
226

227
			assert.deepStrictEqual(appliedEdits, [
228
				{ editType: CellEditType.Replace, index: 0, cells: [], count: 1 },
229
			]);
230
			assert.deepStrictEqual(result, [
231
				{
232
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
233
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
234
				},
235
			]);
236
		});
237
		test('Delete first inserted with multiple cells', async function () {
238
			const cellsDiffInfo: ICellDiffInfo[] = [
239
				{
240
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
241
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('New0'),
242
				},
243
				{
244
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
245
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
246
				},
247
				{
248
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('1'), originalCellIndex: 1,
249
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
250
				},
251
				{
252
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
253
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('1'),
254
				},
255
				{
256
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 2,
257
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('2'),
258
				},
259
			];
260

261
			const result = adjustCellDiffForRevertingAnInsertedCell(0,
262
				cellsDiffInfo,
263
				applyEdits);
264

265
			assert.deepStrictEqual(appliedEdits, [
266
				{ editType: CellEditType.Replace, index: 0, cells: [], count: 1 },
267
			]);
268
			assert.deepStrictEqual(result, [
269
				{
270
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
271
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
272
				},
273
				{
274
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('1'), originalCellIndex: 1,
275
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
276
				},
277
				{
278
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
279
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('1'),
280
				},
281
				{
282
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 2,
283
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('2'),
284
				},
285
			]);
286
		});
287
		test('Delete second inserted with multiple cells', async function () {
288
			const cellsDiffInfo: ICellDiffInfo[] = [
289
				{
290
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
291
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('New0'),
292
				},
293
				{
294
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
295
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
296
				},
297
				{
298
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('1'), originalCellIndex: 1,
299
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
300
				},
301
				{
302
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
303
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('1'),
304
				},
305
				{
306
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 2,
307
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('2'),
308
				},
309
			];
310

311
			const result = adjustCellDiffForRevertingAnInsertedCell(2,
312
				cellsDiffInfo,
313
				applyEdits);
314

315
			assert.deepStrictEqual(appliedEdits, [
316
				{ editType: CellEditType.Replace, index: 2, cells: [], count: 1 },
317
			]);
318
			assert.deepStrictEqual(result, [
319
				{
320
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
321
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('New0'),
322
				},
323
				{
324
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
325
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
326
				},
327
				{
328
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('1'), originalCellIndex: 1,
329
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
330
				},
331
				{
332
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 2,
333
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('2'),
334
				},
335
			]);
336
		});
337
		test('Delete second inserted with multiple cells (subsequent inserts)', async function () {
338
			const cellsDiffInfo: ICellDiffInfo[] = [
339
				{
340
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
341
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('New0'),
342
				},
343
				{
344
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
345
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
346
				},
347
				{
348
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('1'), originalCellIndex: 1,
349
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
350
				},
351
				{
352
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
353
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('1'),
354
				},
355
				{
356
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
357
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('3'),
358
				},
359
				{
360
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 2,
361
					modifiedCellIndex: 4, modifiedModel: createModifiedModel('4'),
362
				},
363
			];
364

365
			const result = adjustCellDiffForRevertingAnInsertedCell(2,
366
				cellsDiffInfo,
367
				applyEdits);
368

369
			assert.deepStrictEqual(appliedEdits, [
370
				{ editType: CellEditType.Replace, index: 2, cells: [], count: 1 },
371
			]);
372
			assert.deepStrictEqual(result, [
373
				{
374
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
375
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('New0'),
376
				},
377
				{
378
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
379
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
380
				},
381
				{
382
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('1'), originalCellIndex: 1,
383
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
384
				},
385
				{
386
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
387
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('3'),
388
				},
389
				{
390
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 2,
391
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('4'),
392
				},
393
			]);
394
		});
395
	});
396

397
	suite('Keep Deleted Cell', function () {
398

399
		const keep = () => Promise.resolve(true);
400
		const undo = () => Promise.resolve(true);
401
		const diff = observableValue('cell1', nullDocumentDiff);
402
		const appliedEdits: ICellEditOperation[] = [];
403
		setup(() => {
404
			appliedEdits.length = 0;
405
		});
406
		ensureNoDisposablesAreLeakedInTestSuite();
407
		function createModifiedModel(id: string): ObservablePromise<ITextModel> {
408
			return `Modified:${id}` as any;
409

410
		}
411
		function createOriginalModel(id: string): ObservablePromise<ITextModel> {
412
			return `Original:${id}` as any;
413

414
		}
415
		function applyEdits(edits: ICellEditOperation[]): boolean {
416
			appliedEdits.push(...edits);
417
			return true;
418
		}
419

420
		test('Keep first deleted cell', async function () {
421
			const cellsDiffInfo: ICellDiffInfo[] = [
422
				{
423
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('0'), originalCellIndex: 0,
424
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
425
				},
426
				{
427
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('1'), originalCellIndex: 1,
428
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
429
				},
430
				{
431
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
432
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('New0'),
433
				},
434
				{
435
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 2,
436
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
437
				},
438
			];
439

440
			const result = adjustCellDiffForKeepingADeletedCell(0,
441
				cellsDiffInfo,
442
				applyEdits);
443

444
			assert.deepStrictEqual(appliedEdits, [
445
				{ editType: CellEditType.Replace, index: 0, cells: [], count: 1 },
446
			]);
447
			assert.deepStrictEqual(result, [
448
				{
449
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('1'), originalCellIndex: 0,
450
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
451
				},
452
				{
453
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
454
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('New0'),
455
				},
456
				{
457
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 1,
458
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
459
				},
460
			]);
461
		});
462
		test('Keep second deleted cell', async function () {
463
			const cellsDiffInfo: ICellDiffInfo[] = [
464
				{
465
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('0'), originalCellIndex: 0,
466
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
467
				},
468
				{
469
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('1'), originalCellIndex: 1,
470
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
471
				},
472
				{
473
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
474
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('New0'),
475
				},
476
				{
477
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 2,
478
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
479
				},
480
			];
481

482
			const result = adjustCellDiffForKeepingADeletedCell(1,
483
				cellsDiffInfo,
484
				applyEdits);
485

486
			assert.deepStrictEqual(appliedEdits, [
487
				{ editType: CellEditType.Replace, index: 1, cells: [], count: 1 },
488
			]);
489
			assert.deepStrictEqual(result, [
490
				{
491
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('0'), originalCellIndex: 0,
492
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
493
				},
494
				{
495
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
496
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('New0'),
497
				},
498
				{
499
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 1,
500
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
501
				},
502
			]);
503
		});
504

505
		test('Keep first deleted with multiple cells', async function () {
506
			const cellsDiffInfo: ICellDiffInfo[] = [
507
				{
508
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
509
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('New0'),
510
				},
511
				{
512
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
513
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
514
				},
515
				{
516
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('1'), originalCellIndex: 1,
517
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
518
				},
519
				{
520
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
521
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('1'),
522
				},
523
				{
524
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 2,
525
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('2'),
526
				},
527
			];
528

529
			const result = adjustCellDiffForKeepingADeletedCell(1,
530
				cellsDiffInfo,
531
				applyEdits);
532

533
			assert.deepStrictEqual(appliedEdits, [
534
				{ editType: CellEditType.Replace, index: 1, cells: [], count: 1 },
535
			]);
536
			assert.deepStrictEqual(result, [
537
				{
538
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
539
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('New0'),
540
				},
541
				{
542
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
543
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
544
				},
545
				{
546
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
547
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('1'),
548
				},
549
				{
550
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 1,
551
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('2'),
552
				},
553
			]);
554
		});
555
	});
556

557
	suite('Revert Deleted Cell', function () {
558

559
		const keep = () => Promise.resolve(true);
560
		const undo = () => Promise.resolve(true);
561
		const diff = observableValue('cell1', nullDocumentDiff);
562
		const appliedEdits: ICellEditOperation[] = [];
563
		setup(() => {
564
			appliedEdits.length = 0;
565
		});
566
		ensureNoDisposablesAreLeakedInTestSuite();
567
		function createModifiedModel(id: string): ObservablePromise<ITextModel> {
568
			return `Modified:${id}` as any;
569

570
		}
571
		function createOriginalModel(id: string): ObservablePromise<ITextModel> {
572
			return `Original:${id}` as any;
573

574
		}
575
		function applyEdits(edits: ICellEditOperation[]): boolean {
576
			appliedEdits.push(...edits);
577
			return true;
578
		}
579
		function createModifiedCellDiffInfo(modifiedCellIndex: number, originalCellIndex: number): ICellDiffInfo {
580
			return {
581
				diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel(`InsertedOriginal:${originalCellIndex}`), originalCellIndex,
582
				modifiedCellIndex, modifiedModel: createModifiedModel(`InsertedModified:${modifiedCellIndex}`),
583
			};
584
		}
585

586
		test('Revert first deleted cell', async function () {
587
			const cellsDiffInfo: ICellDiffInfo[] = [
588
				{
589
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('0'), originalCellIndex: 0,
590
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
591
				},
592
				{
593
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('1'), originalCellIndex: 1,
594
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
595
				},
596
				{
597
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
598
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('New0'),
599
				},
600
				{
601
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 2,
602
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
603
				},
604
			];
605

606
			const result = adjustCellDiffForRevertingADeletedCell(0,
607
				cellsDiffInfo,
608
				{} as any,
609
				applyEdits,
610
				createModifiedCellDiffInfo);
611

612
			assert.deepStrictEqual(appliedEdits, [
613
				{ editType: CellEditType.Replace, index: 0, cells: [{}], count: 0 },
614
			]);
615
			assert.deepStrictEqual(result, [
616
				{
617
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('InsertedOriginal:0'), originalCellIndex: 0,
618
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('InsertedModified:0'),
619
				},
620
				{
621
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('1'), originalCellIndex: 1,
622
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
623
				},
624
				{
625
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
626
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('New0'),
627
				},
628
				{
629
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 2,
630
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('0'),
631
				},
632
			]);
633
		});
634
		test('Revert second deleted cell', async function () {
635
			const cellsDiffInfo: ICellDiffInfo[] = [
636
				{
637
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('0'), originalCellIndex: 0,
638
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
639
				},
640
				{
641
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('1'), originalCellIndex: 1,
642
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
643
				},
644
				{
645
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
646
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('New0'),
647
				},
648
				{
649
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 2,
650
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
651
				},
652
			];
653

654
			const result = adjustCellDiffForRevertingADeletedCell(1,
655
				cellsDiffInfo,
656
				{} as any,
657
				applyEdits,
658
				createModifiedCellDiffInfo);
659

660
			assert.deepStrictEqual(appliedEdits, [
661
				{ editType: CellEditType.Replace, index: 0, cells: [{}], count: 0 },
662
			]);
663
			assert.deepStrictEqual(result, [
664
				{
665
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('0'), originalCellIndex: 0,
666
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
667
				},
668
				{
669
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('InsertedOriginal:1'), originalCellIndex: 1,
670
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('InsertedModified:0'),
671
				},
672
				{
673
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
674
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('New0'),
675
				},
676
				{
677
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 2,
678
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('0'),
679
				},
680
			]);
681
		});
682

683
		test('Revert first deleted with multiple cells', async function () {
684
			const cellsDiffInfo: ICellDiffInfo[] = [
685
				{
686
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
687
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('New0'),
688
				},
689
				{
690
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
691
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('New1'),
692
				},
693
				{
694
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
695
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('0'),
696
				},
697
				{
698
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('1'), originalCellIndex: 1,
699
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
700
				},
701
				{
702
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
703
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('1'),
704
				},
705
				{
706
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 2,
707
					modifiedCellIndex: 4, modifiedModel: createModifiedModel('2'),
708
				},
709
			];
710

711
			const result = adjustCellDiffForRevertingADeletedCell(1,
712
				cellsDiffInfo,
713
				{} as any,
714
				applyEdits,
715
				createModifiedCellDiffInfo);
716

717
			assert.deepStrictEqual(appliedEdits, [
718
				{ editType: CellEditType.Replace, index: 3, cells: [{}], count: 0 },
719
			]);
720
			assert.deepStrictEqual(result, [
721
				{
722
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
723
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('New0'),
724
				},
725
				{
726
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
727
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('New1'),
728
				},
729
				{
730
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
731
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('0'),
732
				},
733
				{
734
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('InsertedOriginal:1'), originalCellIndex: 1,
735
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('InsertedModified:3'),
736
				},
737
				{
738
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
739
					modifiedCellIndex: 4, modifiedModel: createModifiedModel('1'),
740
				},
741
				{
742
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('2'), originalCellIndex: 2,
743
					modifiedCellIndex: 5, modifiedModel: createModifiedModel('2'),
744
				},
745
			]);
746
		});
747
	});
748

749
	suite('Cell Addition', function () {
750

751
		const keep = () => Promise.resolve(true);
752
		const undo = () => Promise.resolve(true);
753
		const diff = observableValue('cell1', nullDocumentDiff);
754
		const appliedEdits: ICellEditOperation[] = [];
755
		setup(() => {
756
			appliedEdits.length = 0;
757
		});
758
		ensureNoDisposablesAreLeakedInTestSuite();
759
		function createModifiedModel(id: string): ObservablePromise<ITextModel> {
760
			return `Modified:${id}` as any;
761

762
		}
763
		function createOriginalModel(id: string): ObservablePromise<ITextModel> {
764
			return `Original:${id}` as any;
765

766
		}
767
		function applyEdits(edits: ICellEditOperation[]): boolean {
768
			appliedEdits.push(...edits);
769
			return true;
770
		}
771

772
		function createICell(cellKind: CellKind, source: string): ICell {
773
			const handle = hash(generateUuid());
774
			return {
775
				uri: URI.parse(`file:///path/${handle}`),
776
				handle,
777
				cellKind,
778
				language: cellKind === CellKind.Markup ? 'markdown' : 'python',
779
				outputs: [],
780
				metadata: {},
781
				getHashValue: () => {
782
					return hash(`${handle}=>${cellKind}=>${source}`);
783
				},
784
				getValue: () => {
785
					return source;
786
				},
787
				internalMetadata: {},
788
			} as any;
789
		}
790
		function createModifiedCellDiffInfo(modifiedCellIndex: number, originalCellIndex: number): ICellDiffInfo {
791
			return {
792
				diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel(`InsertedOriginal:${originalCellIndex}`), originalCellIndex,
793
				modifiedCellIndex, modifiedModel: createModifiedModel(`InsertedModified:${modifiedCellIndex}`),
794
			};
795
		}
796
		test('Insert a new cell into an unchanged notebook', async function () {
797
			const cellsDiffInfo: ICellDiffInfo[] = [
798
				{
799
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
800
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
801
				},
802
				{
803
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 1,
804
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('1'),
805
				},
806
			];
807

808
			const cell = createICell(CellKind.Code, 'print("Hello World")');
809
			const result = adjustCellDiffAndOriginalModelBasedOnCellAddDelete([0, 0, [cell]],
810
				cellsDiffInfo, 3, 2, applyEdits, createModifiedCellDiffInfo);
811
			assert.deepStrictEqual(appliedEdits, [
812
				{
813
					editType: CellEditType.Replace,
814
					index: 0,
815
					cells: [{
816
						cellKind: CellKind.Code,
817
						language: 'python',
818
						outputs: [],
819
						mime: undefined,
820
						metadata: {},
821
						internalMetadata: {},
822
						source: cell.getValue(),
823
					}], count: 0
824
				}
825
			]);
826
			assert.deepStrictEqual(result, [
827
				{
828
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel(`InsertedOriginal:0`), originalCellIndex: 0,
829
					modifiedCellIndex: 0, modifiedModel: createModifiedModel(`InsertedModified:0`),
830
				},
831
				{
832
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 1,
833
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
834
				},
835
				{
836
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 2,
837
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('1'),
838
				},
839
			]);
840
		});
841
		test('Insert a new cell into a notebook with 3 cells deleted', async function () {
842
			const cellsDiffInfo: ICellDiffInfo[] = [
843
				{
844
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
845
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
846
				},
847
				{
848
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('1'), originalCellIndex: 1,
849
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
850
				},
851
				{
852
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('2'), originalCellIndex: 2,
853
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
854
				},
855
				{
856
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('3'), originalCellIndex: 3,
857
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
858
				},
859
				{
860
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
861
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('New1'),
862
				},
863
				{
864
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('4'), originalCellIndex: 4,
865
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('4'),
866
				},
867
				{
868
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('5'), originalCellIndex: 5,
869
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('5'),
870
				},
871
				{
872
					diff, keep, undo, type: 'modified', originalModel: createOriginalModel('6'), originalCellIndex: 6,
873
					modifiedCellIndex: 4, modifiedModel: createModifiedModel('6'),
874
				},
875
			];
876
			const cell = createICell(CellKind.Code, 'print("Hello World")');
877
			const result = adjustCellDiffAndOriginalModelBasedOnCellAddDelete([2, 0, [cell]],
878
				cellsDiffInfo, 6, 7, applyEdits, createModifiedCellDiffInfo);
879

880
			assert.deepStrictEqual(appliedEdits, [
881
				{
882
					editType: CellEditType.Replace,
883
					index: 4,
884
					cells: [{
885
						cellKind: CellKind.Code,
886
						language: 'python',
887
						outputs: [],
888
						mime: undefined,
889
						metadata: {},
890
						internalMetadata: {},
891
						source: cell.getValue(),
892
					}], count: 0
893
				}
894
			]);
895

896
			assert.deepStrictEqual(result, [
897
				{
898
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
899
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
900
				},
901
				{
902
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('1'), originalCellIndex: 1,
903
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
904
				},
905
				{
906
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('2'), originalCellIndex: 2,
907
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
908
				},
909
				{
910
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('3'), originalCellIndex: 3,
911
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
912
				},
913
				{
914
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
915
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('New1'),
916
				},
917
				{
918
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('InsertedOriginal:4'), originalCellIndex: 4,
919
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('InsertedModified:2'),
920
				},
921
				{
922
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('4'), originalCellIndex: 5,
923
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('4'),
924
				},
925
				{
926
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('5'), originalCellIndex: 6,
927
					modifiedCellIndex: 4, modifiedModel: createModifiedModel('5'),
928
				},
929
				{
930
					diff, keep, undo, type: 'modified', originalModel: createOriginalModel('6'), originalCellIndex: 7,
931
					modifiedCellIndex: 5, modifiedModel: createModifiedModel('6'),
932
				},
933
			]);
934
		});
935
		test('Insert 2 new cells into an notebook with 3 cells deleted', async function () {
936
			const cellsDiffInfo: ICellDiffInfo[] = [
937
				{
938
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
939
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
940
				},
941
				{
942
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('2'), originalCellIndex: 1,
943
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
944
				},
945
				{
946
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('3'), originalCellIndex: 2,
947
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
948
				},
949
				{
950
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('4'), originalCellIndex: 3,
951
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
952
				},
953
				{
954
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
955
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('New1'),
956
				},
957
				{
958
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('5'), originalCellIndex: 4,
959
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('5'),
960
				},
961
				{
962
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 5,
963
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('1'),
964
				},
965
			];
966
			const cell1 = createICell(CellKind.Code, 'print("Hello World")');
967
			const cell2 = createICell(CellKind.Code, 'print("Foo Bar")');
968
			const result = adjustCellDiffAndOriginalModelBasedOnCellAddDelete([2, 0, [cell1, cell2]],
969
				cellsDiffInfo, 4, 6, applyEdits, createModifiedCellDiffInfo);
970

971
			assert.deepStrictEqual(appliedEdits, [
972
				{
973
					editType: CellEditType.Replace,
974
					index: 4,
975
					cells: [{
976
						cellKind: CellKind.Code,
977
						language: 'python',
978
						outputs: [],
979
						mime: undefined,
980
						metadata: {},
981
						internalMetadata: {},
982
						source: cell1.getValue(),
983
					}, {
984
						cellKind: CellKind.Code,
985
						language: 'python',
986
						outputs: [],
987
						mime: undefined,
988
						metadata: {},
989
						internalMetadata: {},
990
						source: cell2.getValue(),
991
					}], count: 0
992
				}
993
			]);
994

995
			assert.deepStrictEqual(result, [
996
				{
997
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
998
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
999
				},
1000
				{
1001
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('2'), originalCellIndex: 1,
1002
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1003
				},
1004
				{
1005
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('3'), originalCellIndex: 2,
1006
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1007
				},
1008
				{
1009
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('4'), originalCellIndex: 3,
1010
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1011
				},
1012
				{
1013
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1014
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('New1'),
1015
				},
1016
				{
1017
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel(`InsertedOriginal:4`), originalCellIndex: 4,
1018
					modifiedCellIndex: 2, modifiedModel: createModifiedModel(`InsertedModified:2`),
1019
				},
1020
				{
1021
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel(`InsertedOriginal:5`), originalCellIndex: 5,
1022
					modifiedCellIndex: 3, modifiedModel: createModifiedModel(`InsertedModified:3`),
1023
				},
1024
				{
1025
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('5'), originalCellIndex: 6,
1026
					modifiedCellIndex: 4, modifiedModel: createModifiedModel('5'),
1027
				},
1028
				{
1029
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 7,
1030
					modifiedCellIndex: 5, modifiedModel: createModifiedModel('1'),
1031
				},
1032
			]);
1033
		});
1034
		test('Delete a cell from an unchanged notebook', async function () {
1035
			const cellsDiffInfo: ICellDiffInfo[] = [
1036
				{
1037
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1038
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1039
				},
1040
				{
1041
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 1,
1042
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('1'),
1043
				},
1044
			];
1045

1046
			const result = adjustCellDiffAndOriginalModelBasedOnCellAddDelete([0, 1, []],
1047
				cellsDiffInfo, 2, 2, applyEdits, createModifiedCellDiffInfo);
1048

1049
			assert.deepStrictEqual(appliedEdits, [
1050
				{
1051
					editType: CellEditType.Replace,
1052
					index: 0,
1053
					cells: [], count: 1
1054
				}
1055
			]);
1056

1057
			assert.deepStrictEqual(result, [
1058
				{
1059
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 0,
1060
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('1'),
1061
				},
1062
			]);
1063
		});
1064
		test('Delete last cell from an unchanged notebook', async function () {
1065
			const cellsDiffInfo: ICellDiffInfo[] = [
1066
				{
1067
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1068
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1069
				},
1070
				{
1071
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 1,
1072
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('1'),
1073
				},
1074
			];
1075

1076
			const result = adjustCellDiffAndOriginalModelBasedOnCellAddDelete([1, 1, []],
1077
				cellsDiffInfo, 2, 2, applyEdits, createModifiedCellDiffInfo);
1078
			assert.deepStrictEqual(appliedEdits, [
1079
				{
1080
					editType: CellEditType.Replace,
1081
					index: 1,
1082
					cells: [], count: 1
1083
				}
1084
			]);
1085

1086
			assert.deepStrictEqual(result, [
1087
				{
1088
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1089
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1090
				},
1091
			]);
1092
		});
1093
		test('Delete the first cell, then insert a new cell at the top', async function () {
1094
			const cellsDiffInfo: ICellDiffInfo[] = [
1095
				{
1096
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1097
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1098
				},
1099
				{
1100
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 1,
1101
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('1'),
1102
				},
1103
			];
1104

1105
			const cell1 = createICell(CellKind.Code, 'print("Hello World")');
1106
			const result = adjustCellDiffAndOriginalModelBasedOnCellAddDelete([0, 0, [cell1]],
1107
				cellsDiffInfo, 2, 2, applyEdits, createModifiedCellDiffInfo);
1108

1109
			assert.deepStrictEqual(appliedEdits, [
1110
				{
1111
					editType: CellEditType.Replace,
1112
					index: 1,
1113
					cells: [{
1114
						cellKind: CellKind.Code,
1115
						language: 'python',
1116
						outputs: [],
1117
						mime: undefined,
1118
						metadata: {},
1119
						internalMetadata: {},
1120
						source: cell1.getValue(),
1121
					}], count: 0
1122
				}
1123
			]);
1124

1125
			assert.deepStrictEqual(result, [
1126
				{
1127
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1128
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1129
				},
1130
				{
1131
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('InsertedOriginal:1'), originalCellIndex: 1,
1132
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('InsertedModified:0'),
1133
				},
1134
				{
1135
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 2,
1136
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('1'),
1137
				},
1138
			]);
1139
		});
1140
		test('Delete a new cell from a notebook with 3 cells deleted', async function () {
1141
			const cellsDiffInfo: ICellDiffInfo[] = [
1142
				{
1143
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1144
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1145
				},
1146
				{
1147
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('2'), originalCellIndex: 1,
1148
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1149
				},
1150
				{
1151
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('3'), originalCellIndex: 2,
1152
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1153
				},
1154
				{
1155
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('4'), originalCellIndex: 3,
1156
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1157
				},
1158
				{
1159
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1160
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('New1'),
1161
				},
1162
				{
1163
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('5'), originalCellIndex: 4,
1164
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('5'),
1165
				},
1166
				{
1167
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 5,
1168
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('1'),
1169
				},
1170
			];
1171

1172
			const result = adjustCellDiffAndOriginalModelBasedOnCellAddDelete([1, 1, [
1173
				// createICell(CellKind.Code, 'print("Hello World")')
1174
			]],
1175
				cellsDiffInfo, 4, 6, applyEdits, createModifiedCellDiffInfo);
1176

1177
			assert.deepStrictEqual(appliedEdits, [
1178
			]);
1179

1180
			assert.deepStrictEqual(result, [
1181
				{
1182
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1183
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1184
				},
1185
				{
1186
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('2'), originalCellIndex: 1,
1187
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1188
				},
1189
				{
1190
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('3'), originalCellIndex: 2,
1191
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1192
				},
1193
				{
1194
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('4'), originalCellIndex: 3,
1195
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1196
				},
1197
				{
1198
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('5'), originalCellIndex: 4,
1199
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('5'),
1200
				},
1201
				{
1202
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 5,
1203
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('1'),
1204
				},
1205
			]);
1206
		});
1207
		test('Delete 2 cells from a notebook with 3 cells deleted', async function () {
1208
			const cellsDiffInfo: ICellDiffInfo[] = [
1209
				{
1210
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1211
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1212
				},
1213
				{
1214
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('2'), originalCellIndex: 1,
1215
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1216
				},
1217
				{
1218
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('3'), originalCellIndex: 2,
1219
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1220
				},
1221
				{
1222
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('4'), originalCellIndex: 3,
1223
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1224
				},
1225
				{
1226
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1227
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('New1'),
1228
				},
1229
				{
1230
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('5'), originalCellIndex: 4,
1231
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('5'),
1232
				},
1233
				{
1234
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 5,
1235
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('1'),
1236
				},
1237
			];
1238

1239
			const result = adjustCellDiffAndOriginalModelBasedOnCellAddDelete([1, 2, [
1240
			]],
1241
				cellsDiffInfo, 4, 6, applyEdits, createModifiedCellDiffInfo);
1242

1243
			assert.deepStrictEqual(appliedEdits, [
1244
				{
1245
					editType: CellEditType.Replace,
1246
					index: 4,
1247
					cells: [], count: 1
1248
				}
1249
			]);
1250

1251
			assert.deepStrictEqual(result, [
1252
				{
1253
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1254
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1255
				},
1256
				{
1257
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('2'), originalCellIndex: 1,
1258
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1259
				},
1260
				{
1261
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('3'), originalCellIndex: 2,
1262
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1263
				},
1264
				{
1265
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('4'), originalCellIndex: 3,
1266
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1267
				},
1268
				{
1269
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 4,
1270
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('1'),
1271
				},
1272
			]);
1273
		});
1274
		test('Delete 3 cells from a notebook with 3 cells deleted', async function () {
1275
			const cellsDiffInfo: ICellDiffInfo[] = [
1276
				{
1277
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1278
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1279
				},
1280
				{
1281
					diff, keep, undo, type: 'modified', originalModel: createOriginalModel('1'), originalCellIndex: 1,
1282
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('1'),
1283
				},
1284
				{
1285
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('2'), originalCellIndex: 2,
1286
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1287
				},
1288
				{
1289
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('3'), originalCellIndex: 3,
1290
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1291
				},
1292
				{
1293
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('4'), originalCellIndex: 4,
1294
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1295
				},
1296
				{
1297
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1298
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('New1'),
1299
				},
1300
				{
1301
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('5'), originalCellIndex: 5,
1302
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('5'),
1303
				},
1304
				{
1305
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('6'), originalCellIndex: 6,
1306
					modifiedCellIndex: 4, modifiedModel: createModifiedModel('6'),
1307
				},
1308
			];
1309

1310
			const result = adjustCellDiffAndOriginalModelBasedOnCellAddDelete([1, 3, [
1311
			]],
1312
				cellsDiffInfo, 5, 7, applyEdits, createModifiedCellDiffInfo);
1313

1314
			assert.deepStrictEqual(appliedEdits, [
1315
				{
1316
					editType: CellEditType.Replace,
1317
					index: 1,
1318
					cells: [], count: 1
1319
				},
1320
				{
1321
					editType: CellEditType.Replace,
1322
					index: 5,
1323
					cells: [], count: 1
1324
				}
1325
			]);
1326

1327
			assert.deepStrictEqual(result, [
1328
				{
1329
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1330
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1331
				},
1332
				{
1333
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('2'), originalCellIndex: 1,
1334
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1335
				},
1336
				{
1337
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('3'), originalCellIndex: 2,
1338
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1339
				},
1340
				{
1341
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('4'), originalCellIndex: 3,
1342
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1343
				},
1344
				{
1345
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('6'), originalCellIndex: 4,
1346
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('6'),
1347
				},
1348
			]);
1349
		});
1350

1351
		test('Insert 1 cell at the bottom via chat, then user creats a new cell just below that', async function () {
1352
			const cellsDiffInfo: ICellDiffInfo[] = [
1353
				{
1354
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1355
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1356
				},
1357
				{
1358
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1359
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('New1'),
1360
				},
1361
			];
1362
			const cell1 = createICell(CellKind.Code, 'print("Hello World")');
1363
			const result = adjustCellDiffAndOriginalModelBasedOnCellAddDelete([2, 0, [cell1]],
1364
				cellsDiffInfo, 3, 1, applyEdits, createModifiedCellDiffInfo);
1365

1366
			assert.deepStrictEqual(appliedEdits, [
1367
				{
1368
					editType: CellEditType.Replace,
1369
					index: 1,
1370
					cells: [{
1371
						cellKind: CellKind.Code,
1372
						language: 'python',
1373
						outputs: [],
1374
						mime: undefined,
1375
						metadata: {},
1376
						internalMetadata: {},
1377
						source: cell1.getValue(),
1378
					}], count: 0
1379
				}
1380
			]);
1381

1382
			assert.deepStrictEqual(result, [
1383
				{
1384
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1385
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1386
				},
1387
				{
1388
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1389
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('New1'),
1390
				},
1391
				{
1392
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('InsertedOriginal:1'), originalCellIndex: 1,
1393
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('InsertedModified:2'),
1394
				},
1395
			]);
1396
		});
1397
		test('Insert 1 cell at the bottom via chat, then user creats anew cells above the previous new cell', async function () {
1398
			const cellsDiffInfo: ICellDiffInfo[] = [
1399
				{
1400
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1401
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1402
				},
1403
				{
1404
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 1,
1405
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('1'),
1406
				},
1407
				{
1408
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1409
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('New1'),
1410
				},
1411
			];
1412
			const cell1 = createICell(CellKind.Code, 'print("Hello World")');
1413
			const result = adjustCellDiffAndOriginalModelBasedOnCellAddDelete([2, 0, [cell1]],
1414
				cellsDiffInfo, 3, 2, applyEdits, createModifiedCellDiffInfo);
1415

1416
			assert.deepStrictEqual(appliedEdits, [
1417
				{
1418
					editType: CellEditType.Replace,
1419
					index: 2,
1420
					cells: [{
1421
						cellKind: CellKind.Code,
1422
						language: 'python',
1423
						outputs: [],
1424
						mime: undefined,
1425
						metadata: {},
1426
						internalMetadata: {},
1427
						source: cell1.getValue(),
1428
					}], count: 0
1429
				}
1430
			]);
1431

1432
			assert.deepStrictEqual(result, [
1433
				{
1434
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1435
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1436
				},
1437
				{
1438
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 1,
1439
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('1'),
1440
				},
1441
				{
1442
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('InsertedOriginal:2'), originalCellIndex: 2,
1443
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('InsertedModified:2'),
1444
				},
1445
				{
1446
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1447
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('New1'),
1448
				},
1449
			]);
1450
		});
1451
		test('Insert 1 cell at the bottom via chat, then user inserts a new cells below the  previous new cell', async function () {
1452
			const cellsDiffInfo: ICellDiffInfo[] = [
1453
				{
1454
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1455
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1456
				},
1457
				{
1458
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 1,
1459
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('1'),
1460
				},
1461
				{
1462
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1463
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('New1'),
1464
				},
1465
			];
1466
			const cell1 = createICell(CellKind.Code, 'print("Hello World")');
1467
			const result = adjustCellDiffAndOriginalModelBasedOnCellAddDelete([3, 0, [cell1]],
1468
				cellsDiffInfo, 3, 2, applyEdits, createModifiedCellDiffInfo);
1469

1470
			assert.deepStrictEqual(appliedEdits, [
1471
				{
1472
					editType: CellEditType.Replace,
1473
					index: 2,
1474
					cells: [{
1475
						cellKind: CellKind.Code,
1476
						language: 'python',
1477
						outputs: [],
1478
						mime: undefined,
1479
						metadata: {},
1480
						internalMetadata: {},
1481
						source: cell1.getValue(),
1482
					}], count: 0
1483
				}
1484
			]);
1485

1486
			assert.deepStrictEqual(result, [
1487
				{
1488
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1489
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1490
				},
1491
				{
1492
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 1,
1493
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('1'),
1494
				},
1495
				{
1496
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1497
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('New1'),
1498
				},
1499
				{
1500
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('InsertedOriginal:2'), originalCellIndex: 2,
1501
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('InsertedModified:3'),
1502
				},
1503
			]);
1504
		});
1505
	});
1506

1507
	suite('Cell Movements', function () {
1508

1509
		const keep = () => Promise.resolve(true);
1510
		const undo = () => Promise.resolve(true);
1511
		const diff = observableValue('cell1', nullDocumentDiff);
1512

1513
		ensureNoDisposablesAreLeakedInTestSuite();
1514
		function createModifiedModel(id: string): ObservablePromise<ITextModel> {
1515
			return `Modified:${id}` as any;
1516

1517
		}
1518
		function createOriginalModel(id: string): ObservablePromise<ITextModel> {
1519
			return `Original:${id}` as any;
1520

1521
		}
1522
		test('Swap first two inserted cells in a previously empty notebook', async function () {
1523
			const cellsDiffInfo: ICellDiffInfo[] = [
1524
				{
1525
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1526
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1527
				},
1528
				{
1529
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1530
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('1'),
1531
				}
1532
			];
1533
			const result = adjustCellDiffAndOriginalModelBasedOnCellMovements({
1534
				cells: [], kind: NotebookCellsChangeType.Move,
1535
				index: 0, length: 1, newIdx: 1
1536
			}, cellsDiffInfo);
1537

1538
			assert.ok(result);
1539
			assert.strictEqual(result[1].length, 0);
1540
			assert.deepStrictEqual(result[0], [
1541
				{
1542
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1543
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('1'),
1544
				},
1545
				{
1546
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1547
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
1548
				},
1549
			]);
1550
		});
1551
		test('Swap first two inserted cells in a notebook that had 2 cells', async function () {
1552
			const cellsDiffInfo: ICellDiffInfo[] = [
1553
				{
1554
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1555
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1556
				},
1557
				{
1558
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1559
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('1'),
1560
				},
1561
				{
1562
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1563
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('2'),
1564
				},
1565
				{
1566
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 1,
1567
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('3'),
1568
				}
1569
			];
1570
			const result = adjustCellDiffAndOriginalModelBasedOnCellMovements({
1571
				cells: [], kind: NotebookCellsChangeType.Move,
1572
				index: 0, length: 1, newIdx: 1
1573
			}, cellsDiffInfo);
1574

1575
			assert.ok(result);
1576
			assert.strictEqual(result[1].length, 0);
1577
			assert.deepStrictEqual(result[0], [
1578
				{
1579
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1580
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('1'),
1581
				},
1582
				{
1583
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1584
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
1585
				},
1586
				{
1587
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1588
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('2'),
1589
				},
1590
				{
1591
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 1,
1592
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('3'),
1593
				}
1594
			]);
1595
		});
1596
		test('Move first inserted cell to the very bottom of notebook that had 2 cells', async function () {
1597
			const cellsDiffInfo: ICellDiffInfo[] = [
1598
				{
1599
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1600
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1601
				},
1602
				{
1603
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1604
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('1'),
1605
				},
1606
				{
1607
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1608
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('2'),
1609
				},
1610
				{
1611
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 1,
1612
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('3'),
1613
				}
1614
			];
1615
			const result = adjustCellDiffAndOriginalModelBasedOnCellMovements({
1616
				cells: [], kind: NotebookCellsChangeType.Move,
1617
				index: 0, length: 1, newIdx: 3
1618
			}, cellsDiffInfo);
1619

1620
			assert.ok(result);
1621
			assert.strictEqual(result[1].length, 0);
1622
			assert.deepStrictEqual(result[0], [
1623
				{
1624
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1625
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('1'),
1626
				},
1627
				{
1628
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1629
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('2'),
1630
				},
1631
				{
1632
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 1,
1633
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('3'),
1634
				},
1635
				{
1636
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1637
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('0'),
1638
				},
1639
			]);
1640
		});
1641
		test('Move last cell to top of notebook after 2 cells were inserted', async function () {
1642
			const cellsDiffInfo: ICellDiffInfo[] = [
1643
				{
1644
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1645
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1646
				},
1647
				{
1648
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1649
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('1'),
1650
				},
1651
				{
1652
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1653
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('2'),
1654
				},
1655
				{
1656
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 1,
1657
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('3'),
1658
				}
1659
			];
1660
			const result = adjustCellDiffAndOriginalModelBasedOnCellMovements({
1661
				cells: [], kind: NotebookCellsChangeType.Move,
1662
				index: 3, length: 1, newIdx: 0
1663
			}, cellsDiffInfo);
1664

1665
			assert.ok(result);
1666
			assert.deepStrictEqual(result[1], [
1667
				{
1668
					editType: CellEditType.Move,
1669
					index: 1,
1670
					length: 1,
1671
					newIdx: 0
1672
				}
1673
			]);
1674
			assert.deepStrictEqual(result[0], [
1675
				{
1676
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 0,
1677
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('3'),
1678
				},
1679
				{
1680
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1681
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('0'),
1682
				},
1683
				{
1684
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1685
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('1'),
1686
				},
1687
				{
1688
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 1,
1689
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('2'),
1690
				},
1691
			]);
1692
		});
1693

1694
		test('Move second inserted cell to the very bottom of notebook that had 2 cells', async function () {
1695
			const cellsDiffInfo: ICellDiffInfo[] = [
1696
				{
1697
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1698
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1699
				},
1700
				{
1701
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1702
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('1'),
1703
				},
1704
				{
1705
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1706
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('2'),
1707
				},
1708
				{
1709
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 1,
1710
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('3'),
1711
				}
1712
			];
1713
			const result = adjustCellDiffAndOriginalModelBasedOnCellMovements({
1714
				cells: [], kind: NotebookCellsChangeType.Move,
1715
				index: 1, length: 1, newIdx: 3
1716
			}, cellsDiffInfo);
1717

1718
			assert.ok(result);
1719
			assert.strictEqual(result[1].length, 0);
1720
			assert.deepStrictEqual(result[0], [
1721
				{
1722
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1723
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1724
				},
1725
				{
1726
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1727
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('2'),
1728
				},
1729
				{
1730
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 1,
1731
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('3'),
1732
				},
1733
				{
1734
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1735
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('1'),
1736
				},
1737
			]);
1738
		});
1739
		test('Move second inserted cell to the second last position of notebook that had 2 cells', async function () {
1740
			const cellsDiffInfo: ICellDiffInfo[] = [
1741
				{
1742
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1743
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1744
				},
1745
				{
1746
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1747
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('1'),
1748
				},
1749
				{
1750
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1751
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('2'),
1752
				},
1753
				{
1754
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 1,
1755
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('3'),
1756
				}
1757
			];
1758
			const result = adjustCellDiffAndOriginalModelBasedOnCellMovements({
1759
				cells: [], kind: NotebookCellsChangeType.Move,
1760
				index: 1, length: 1, newIdx: 2
1761
			}, cellsDiffInfo);
1762

1763
			assert.ok(result);
1764
			assert.strictEqual(result[1].length, 0);
1765
			assert.deepStrictEqual(result[0], [
1766
				{
1767
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1768
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1769
				},
1770
				{
1771
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1772
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('2'),
1773
				},
1774
				{
1775
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1776
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('1'),
1777
				},
1778
				{
1779
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 1,
1780
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('3'),
1781
				}
1782
			]);
1783
		});
1784
		test('Move first cell to the last position of notebook that had 3 cells deleted from the middle', async function () {
1785
			const cellsDiffInfo: ICellDiffInfo[] = [
1786
				{
1787
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1788
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1789
				},
1790
				{
1791
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 1,
1792
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('1'),
1793
				},
1794
				{
1795
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('2'), originalCellIndex: 2,
1796
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1797
				},
1798
				{
1799
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('3'), originalCellIndex: 3,
1800
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1801
				},
1802
				{
1803
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('4'), originalCellIndex: 4,
1804
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1805
				},
1806
				{
1807
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('5'), originalCellIndex: 5,
1808
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('2'),
1809
				},
1810
			];
1811
			const result = adjustCellDiffAndOriginalModelBasedOnCellMovements({
1812
				cells: [], kind: NotebookCellsChangeType.Move,
1813
				index: 0, length: 1, newIdx: 2
1814
			}, cellsDiffInfo);
1815

1816
			assert.ok(result);
1817
			assert.deepStrictEqual(result[1], [
1818
				{
1819
					editType: CellEditType.Move,
1820
					index: 0,
1821
					length: 1,
1822
					newIdx: 5
1823
				}
1824
			]);
1825
			assert.deepStrictEqual(result[0], [
1826
				{
1827
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 0,
1828
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('1'),
1829
				},
1830
				{
1831
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('2'), originalCellIndex: 1,
1832
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1833
				},
1834
				{
1835
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('3'), originalCellIndex: 2,
1836
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1837
				},
1838
				{
1839
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('4'), originalCellIndex: 3,
1840
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1841
				},
1842
				{
1843
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('5'), originalCellIndex: 4,
1844
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('2'),
1845
				},
1846
				{
1847
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 5,
1848
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('0'),
1849
				},
1850
			]);
1851
		});
1852
		test('Move second cell to the last position of notebook that had 3 cells deleted from the middle', async function () {
1853
			const cellsDiffInfo: ICellDiffInfo[] = [
1854
				{
1855
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1856
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1857
				},
1858
				{
1859
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 1,
1860
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('1'),
1861
				},
1862
				{
1863
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('2'), originalCellIndex: 2,
1864
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1865
				},
1866
				{
1867
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('3'), originalCellIndex: 3,
1868
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1869
				},
1870
				{
1871
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('4'), originalCellIndex: 4,
1872
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1873
				},
1874
				{
1875
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('5'), originalCellIndex: 5,
1876
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('2'),
1877
				},
1878
			];
1879
			const result = adjustCellDiffAndOriginalModelBasedOnCellMovements({
1880
				cells: [], kind: NotebookCellsChangeType.Move,
1881
				index: 1, length: 1, newIdx: 2
1882
			}, cellsDiffInfo);
1883

1884
			assert.ok(result);
1885
			assert.deepStrictEqual(result[1], [
1886
				{
1887
					editType: CellEditType.Move,
1888
					index: 1,
1889
					length: 1,
1890
					newIdx: 5
1891
				}
1892
			]);
1893
			assert.deepStrictEqual(result[0], [
1894
				{
1895
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1896
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1897
				},
1898
				{
1899
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('2'), originalCellIndex: 1,
1900
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1901
				},
1902
				{
1903
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('3'), originalCellIndex: 2,
1904
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1905
				},
1906
				{
1907
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('4'), originalCellIndex: 3,
1908
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1909
				},
1910
				{
1911
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('5'), originalCellIndex: 4,
1912
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('2'),
1913
				},
1914
				{
1915
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 5,
1916
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('1'),
1917
				},
1918
			]);
1919
		});
1920

1921
		test('Move second cell to the last position of notebook that had 3 cells deleted from middle and 1 inserted in the middle', async function () {
1922
			const cellsDiffInfo: ICellDiffInfo[] = [
1923
				{
1924
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1925
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1926
				},
1927
				{
1928
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 1,
1929
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('1'),
1930
				},
1931
				{
1932
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('2'), originalCellIndex: 2,
1933
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1934
				},
1935
				{
1936
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('3'), originalCellIndex: 3,
1937
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1938
				},
1939
				{
1940
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('4'), originalCellIndex: 4,
1941
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1942
				},
1943
				{
1944
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1945
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('New1'),
1946
				},
1947
				{
1948
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('5'), originalCellIndex: 5,
1949
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('5'),
1950
				},
1951
			];
1952
			const result = adjustCellDiffAndOriginalModelBasedOnCellMovements({
1953
				cells: [], kind: NotebookCellsChangeType.Move,
1954
				index: 1, length: 1, newIdx: 3
1955
			}, cellsDiffInfo);
1956

1957
			assert.ok(result);
1958
			assert.deepStrictEqual(result[1], [
1959
				{
1960
					editType: CellEditType.Move,
1961
					index: 1,
1962
					length: 1,
1963
					newIdx: 5
1964
				}
1965
			]);
1966
			assert.deepStrictEqual(result[0], [
1967
				{
1968
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
1969
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
1970
				},
1971
				{
1972
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('2'), originalCellIndex: 1,
1973
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1974
				},
1975
				{
1976
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('3'), originalCellIndex: 2,
1977
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1978
				},
1979
				{
1980
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('4'), originalCellIndex: 3,
1981
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
1982
				},
1983
				{
1984
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
1985
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('New1'),
1986
				},
1987
				{
1988
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('5'), originalCellIndex: 4,
1989
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('5'),
1990
				},
1991
				{
1992
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 5,
1993
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('1'),
1994
				},
1995
			]);
1996
		});
1997
		test('Move last cell to the second position of notebook that had 3 cells deleted from middle and 1 inserted in the middle', async function () {
1998
			const cellsDiffInfo: ICellDiffInfo[] = [
1999
				{
2000
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
2001
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
2002
				},
2003
				{
2004
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 1,
2005
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('1'),
2006
				},
2007
				{
2008
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('2'), originalCellIndex: 2,
2009
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
2010
				},
2011
				{
2012
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('3'), originalCellIndex: 3,
2013
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
2014
				},
2015
				{
2016
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('4'), originalCellIndex: 4,
2017
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
2018
				},
2019
				{
2020
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
2021
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('New1'),
2022
				},
2023
				{
2024
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('5'), originalCellIndex: 5,
2025
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('5'),
2026
				},
2027
			];
2028
			const result = adjustCellDiffAndOriginalModelBasedOnCellMovements({
2029
				cells: [], kind: NotebookCellsChangeType.Move,
2030
				index: 3, length: 1, newIdx: 1
2031
			}, cellsDiffInfo);
2032

2033
			assert.ok(result);
2034
			assert.deepStrictEqual(result[1], [
2035
				{
2036
					editType: CellEditType.Move,
2037
					index: 5,
2038
					length: 1,
2039
					newIdx: 1
2040
				}
2041
			]);
2042
			assert.deepStrictEqual(result[0], [
2043
				{
2044
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('0'), originalCellIndex: 0,
2045
					modifiedCellIndex: 0, modifiedModel: createModifiedModel('0'),
2046
				},
2047
				{
2048
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('5'), originalCellIndex: 1,
2049
					modifiedCellIndex: 1, modifiedModel: createModifiedModel('5'),
2050
				},
2051
				{
2052
					diff, keep, undo, type: 'unchanged', originalModel: createOriginalModel('1'), originalCellIndex: 2,
2053
					modifiedCellIndex: 2, modifiedModel: createModifiedModel('1'),
2054
				},
2055
				{
2056
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('2'), originalCellIndex: 3,
2057
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
2058
				},
2059
				{
2060
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('3'), originalCellIndex: 4,
2061
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
2062
				},
2063
				{
2064
					diff, keep, undo, type: 'delete', originalModel: createOriginalModel('4'), originalCellIndex: 5,
2065
					modifiedCellIndex: undefined, modifiedModel: createModifiedModel('null'),
2066
				},
2067
				{
2068
					diff, keep, undo, type: 'insert', originalModel: createOriginalModel('null'), originalCellIndex: undefined,
2069
					modifiedCellIndex: 3, modifiedModel: createModifiedModel('New1'),
2070
				},
2071
			]);
2072
		});
2073
	});
2074

2075
});
2076

2077
Product

Resources

Company
