Merge from vscode ada4bddb8edc69eea6ebaaa0e88c5f903cbd43d8 (#5529)

src/vs/workbench/test/browser/parts/editor/baseEditor.test.ts

@@ -86,7 +86,7 @@ class MyResourceInput extends ResourceEditorInput { }
 
 suite('Workbench base editor', () => {
 
-	test('BaseEditor API', function () {
+	test('BaseEditor API', async () => {
 		let e = new MyEditor(NullTelemetryService);
 		let input = new MyOtherInput();
 		let options = new EditorOptions();
@@ -94,25 +94,24 @@ suite('Workbench base editor', () => {
 		assert(!e.isVisible());
 		assert(!e.input);
 		assert(!e.options);
-		return e.setInput(input, options, CancellationToken.None).then(() => {
-			assert.strictEqual(input, e.input);
-			assert.strictEqual(options, e.options);
 
-			const group = new TestEditorGroup(1);
-			e.setVisible(true, group);
-			assert(e.isVisible());
-			assert.equal(e.group, group);
-			input.onDispose(() => {
-				assert(false);
-			});
-			e.dispose();
-			e.clearInput();
-			e.setVisible(false, group);
-			assert(!e.isVisible());
-			assert(!e.input);
-			assert(!e.options);
-			assert(!e.getControl());
+		await e.setInput(input, options, CancellationToken.None);
+		assert.strictEqual(input, e.input);
+		assert.strictEqual(options, e.options);
+		const group = new TestEditorGroup(1);
+		e.setVisible(true, group);
+		assert(e.isVisible());
+		assert.equal(e.group, group);
+		input.onDispose(() => {
+			assert(false);
 		});
+		e.dispose();
+		e.clearInput();
+		e.setVisible(false, group);
+		assert(!e.isVisible());
+		assert(!e.input);
+		assert(!e.options);
+		assert(!e.getControl());
 	});
 
 	test('EditorDescriptor', () => {
@@ -154,10 +153,10 @@ suite('Workbench base editor', () => {
 
 		let inst = new TestInstantiationService();
 
-		const editor = EditorRegistry.getEditor(inst.createInstance(MyResourceInput, 'fake', '', URI.file('/fake')))!.instantiate(inst);
+		const editor = EditorRegistry.getEditor(inst.createInstance(MyResourceInput, 'fake', '', URI.file('/fake'), undefined))!.instantiate(inst);
 		assert.strictEqual(editor.getId(), 'myEditor');
 
-		const otherEditor = EditorRegistry.getEditor(inst.createInstance(ResourceEditorInput, 'fake', '', URI.file('/fake')))!.instantiate(inst);
+		const otherEditor = EditorRegistry.getEditor(inst.createInstance(ResourceEditorInput, 'fake', '', URI.file('/fake'), undefined))!.instantiate(inst);
 		assert.strictEqual(otherEditor.getId(), 'myOtherEditor');
 
 		(<any>EditorRegistry).setEditors(oldEditors);
@@ -173,7 +172,7 @@ suite('Workbench base editor', () => {
 
 		let inst = new TestInstantiationService();
 
-		const editor = EditorRegistry.getEditor(inst.createInstance(MyResourceInput, 'fake', '', URI.file('/fake')))!.instantiate(inst);
+		const editor = EditorRegistry.getEditor(inst.createInstance(MyResourceInput, 'fake', '', URI.file('/fake'), undefined))!.instantiate(inst);
 		assert.strictEqual('myOtherEditor', editor.getId());
 
 		(<any>EditorRegistry).setEditors(oldEditors);

src/vs/workbench/test/common/editor/editorDiffModel.test.ts

@@ -35,7 +35,7 @@ suite('Workbench editor model', () => {
 		accessor = instantiationService.createInstance(ServiceAccessor);
 	});
 
-	test('TextDiffEditorModel', () => {
+	test('TextDiffEditorModel', async () => {
 		const dispose = accessor.textModelResolverService.registerTextModelContentProvider('test', {
 			provideTextContent: function (resource: URI): Promise<ITextModel> {
 				if (resource.scheme === 'test') {
@@ -48,27 +48,26 @@ suite('Workbench editor model', () => {
 			}
 		});
 
-		let input = instantiationService.createInstance(ResourceEditorInput, 'name', 'description', URI.from({ scheme: 'test', authority: null!, path: 'thePath' }));
-		let otherInput = instantiationService.createInstance(ResourceEditorInput, 'name2', 'description', URI.from({ scheme: 'test', authority: null!, path: 'thePath' }));
+		let input = instantiationService.createInstance(ResourceEditorInput, 'name', 'description', URI.from({ scheme: 'test', authority: null!, path: 'thePath' }), undefined);
+		let otherInput = instantiationService.createInstance(ResourceEditorInput, 'name2', 'description', URI.from({ scheme: 'test', authority: null!, path: 'thePath' }), undefined);
 		let diffInput = new DiffEditorInput('name', 'description', input, otherInput);
 
-		return diffInput.resolve().then((model: any) => {
-			assert(model);
-			assert(model instanceof TextDiffEditorModel);
+		let model = await diffInput.resolve() as TextDiffEditorModel;
 
-			let diffEditorModel = model.textDiffEditorModel;
-			assert(diffEditorModel.original);
-			assert(diffEditorModel.modified);
+		assert(model);
+		assert(model instanceof TextDiffEditorModel);
 
-			return diffInput.resolve().then((model: any) => {
-				assert(model.isResolved());
+		let diffEditorModel = model.textDiffEditorModel!;
+		assert(diffEditorModel.original);
+		assert(diffEditorModel.modified);
 
-				assert(diffEditorModel !== model.textDiffEditorModel);
-				diffInput.dispose();
-				assert(!model.textDiffEditorModel);
+		model = await diffInput.resolve() as TextDiffEditorModel;
+		assert(model.isResolved());
 
-				dispose.dispose();
-			});
-		});
+		assert(diffEditorModel !== model.textDiffEditorModel);
+		diffInput.dispose();
+		assert(!model.textDiffEditorModel);
+
+		dispose.dispose();
 	});
 });

src/vs/workbench/test/common/editor/editorGroups.test.ts

@@ -111,27 +111,17 @@ class TestFileEditorInput extends EditorInput implements IFileEditorInput {
 	}
 	getTypeId() { return 'testFileEditorInputForGroups'; }
 	resolve(): Promise<IEditorModel> { return Promise.resolve(null!); }
+	setEncoding(encoding: string) { }
+	getEncoding(): string { return null!; }
+	setPreferredEncoding(encoding: string) { }
+	getResource(): URI { return this.resource; }
+	setForceOpenAsBinary(): void { }
+	setMode(mode: string) { }
+	setPreferredMode(mode: string) { }
 
 	matches(other: TestFileEditorInput): boolean {
 		return other && this.id === other.id && other instanceof TestFileEditorInput;
 	}
-
-	setEncoding(encoding: string) {
-	}
-
-	getEncoding(): string {
-		return null!;
-	}
-
-	setPreferredEncoding(encoding: string) {
-	}
-
-	getResource(): URI {
-		return this.resource;
-	}
-
-	setForceOpenAsBinary(): void {
-	}
 }
 
 function input(id = String(index++), nonSerializable?: boolean, resource?: URI): EditorInput {

src/vs/workbench/test/common/editor/editorModel.test.ts

@@ -21,8 +21,8 @@ import { TestTextResourcePropertiesService } from 'vs/workbench/test/workbenchTe
 
 class MyEditorModel extends EditorModel { }
 class MyTextEditorModel extends BaseTextEditorModel {
-	public createTextEditorModel(value: ITextBufferFactory, resource?: URI, modeId?: string) {
-		return super.createTextEditorModel(value, resource, modeId);
+	public createTextEditorModel(value: ITextBufferFactory, resource?: URI, preferredMode?: string) {
+		return super.createTextEditorModel(value, resource, preferredMode);
 	}
 
 	isReadonly(): boolean {
@@ -40,7 +40,7 @@ suite('Workbench editor model', () => {
 		modeService = instantiationService.stub(IModeService, ModeServiceImpl);
 	});
 
-	test('EditorModel', () => {
+	test('EditorModel', async () => {
 		let counter = 0;
 
 		let m = new MyEditorModel();
@@ -50,25 +50,23 @@ suite('Workbench editor model', () => {
 			counter++;
 		});
 
-		return m.load().then(model => {
-			assert(model === m);
-			assert.strictEqual(m.isResolved(), true);
-			m.dispose();
-			assert.equal(counter, 1);
-		});
+		const model = await m.load();
+		assert(model === m);
+		assert.strictEqual(m.isResolved(), true);
+		m.dispose();
+		assert.equal(counter, 1);
 	});
 
-	test('BaseTextEditorModel', () => {
+	test('BaseTextEditorModel', async () => {
 		let modelService = stubModelService(instantiationService);
 
 		let m = new MyTextEditorModel(modelService, modeService);
-		return m.load().then((model: MyTextEditorModel) => {
-			assert(model === m);
-			model.createTextEditorModel(createTextBufferFactory('foo'), null!, 'text/plain');
-			assert.strictEqual(m.isResolved(), true);
-		}).then(() => {
-			m.dispose();
-		});
+		const model = await m.load() as MyTextEditorModel;
+
+		assert(model === m);
+		model.createTextEditorModel(createTextBufferFactory('foo'), null!, 'text/plain');
+		assert.strictEqual(m.isResolved(), true);
+		m.dispose();
 	});
 
 	function stubModelService(instantiationService: TestInstantiationService): IModelService {

src/vs/workbench/test/common/editor/resourceEditorInput.test.ts

@@ -12,17 +12,16 @@ import { workbenchInstantiationService } from 'vs/workbench/test/workbenchTestSe
 import { IModelService } from 'vs/editor/common/services/modelService';
 import { IModeService } from 'vs/editor/common/services/modeService';
 import { snapshotToString } from 'vs/workbench/services/textfile/common/textfiles';
+import { ModesRegistry, PLAINTEXT_MODE_ID } from 'vs/editor/common/modes/modesRegistry';
 
 class ServiceAccessor {
 	constructor(
 		@IModelService public modelService: IModelService,
 		@IModeService public modeService: IModeService
-	) {
-	}
+	) { }
 }
 
 suite('Workbench resource editor input', () => {
-
 	let instantiationService: IInstantiationService;
 	let accessor: ServiceAccessor;
 
@@ -31,14 +30,33 @@ suite('Workbench resource editor input', () => {
 		accessor = instantiationService.createInstance(ServiceAccessor);
 	});
 
-	test('simple', () => {
-		let resource = URI.from({ scheme: 'inmemory', authority: null!, path: 'thePath' });
+	test('basics', async () => {
+		const resource = URI.from({ scheme: 'inmemory', authority: null!, path: 'thePath' });
 		accessor.modelService.createModel('function test() {}', accessor.modeService.create('text'), resource);
-		let input: ResourceEditorInput = instantiationService.createInstance(ResourceEditorInput, 'The Name', 'The Description', resource);
 
-		return input.resolve().then(model => {
-			assert.ok(model);
-			assert.equal(snapshotToString((model as ResourceEditorModel).createSnapshot()!), 'function test() {}');
+		const input: ResourceEditorInput = instantiationService.createInstance(ResourceEditorInput, 'The Name', 'The Description', resource, undefined);
+
+		const model = await input.resolve();
+
+		assert.ok(model);
+		assert.equal(snapshotToString(((model as ResourceEditorModel).createSnapshot()!)), 'function test() {}');
+	});
+
+	test('custom mode', async () => {
+		ModesRegistry.registerLanguage({
+			id: 'resource-input-test',
 		});
+
+		const resource = URI.from({ scheme: 'inmemory', authority: null!, path: 'thePath' });
+		accessor.modelService.createModel('function test() {}', accessor.modeService.create('text'), resource);
+
+		const input: ResourceEditorInput = instantiationService.createInstance(ResourceEditorInput, 'The Name', 'The Description', resource, 'resource-input-test');
+
+		const model = await input.resolve();
+		assert.ok(model);
+		assert.equal(model.textEditorModel.getModeId(), 'resource-input-test');
+
+		input.setMode('text');
+		assert.equal(model.textEditorModel.getModeId(), PLAINTEXT_MODE_ID);
 	});
 });

src/vs/workbench/test/common/editor/untitledEditor.test.ts

@@ -16,6 +16,7 @@ import { ModeServiceImpl } from 'vs/editor/common/services/modeServiceImpl';
 import { UntitledEditorInput } from 'vs/workbench/common/editor/untitledEditorInput';
 import { timeout } from 'vs/base/common/async';
 import { snapshotToString } from 'vs/workbench/services/textfile/common/textfiles';
+import { ModesRegistry, PLAINTEXT_MODE_ID } from 'vs/editor/common/modes/modesRegistry';
 
 export class TestUntitledEditorService extends UntitledEditorService {
 	get(resource: URI) { return super.get(resource); }
@@ -45,7 +46,7 @@ suite('Workbench untitled editors', () => {
 		accessor.untitledEditorService.dispose();
 	});
 
-	test('Untitled Editor Service', function (done) {
+	test('Untitled Editor Service', async (done) => {
 		const service = accessor.untitledEditorService;
 		assert.equal(service.getAll().length, 0);
 
@@ -68,36 +69,35 @@ suite('Workbench untitled editors', () => {
 		assert.equal(service.getAll().length, 1);
 
 		// dirty
-		input2.resolve().then(model => {
-			assert.ok(!service.isDirty(input2.getResource()));
+		const model = await input2.resolve();
 
-			const listener = service.onDidChangeDirty(resource => {
-				listener.dispose();
+		assert.ok(!service.isDirty(input2.getResource()));
 
-				assert.equal(resource.toString(), input2.getResource().toString());
+		const listener = service.onDidChangeDirty(resource => {
+			listener.dispose();
 
-				assert.ok(service.isDirty(input2.getResource()));
-				assert.equal(service.getDirty()[0].toString(), input2.getResource().toString());
-				assert.equal(service.getDirty([input2.getResource()])[0].toString(), input2.getResource().toString());
-				assert.equal(service.getDirty([input1.getResource()]).length, 0);
+			assert.equal(resource.toString(), input2.getResource().toString());
 
-				service.revertAll();
-				assert.equal(service.getAll().length, 0);
-				assert.ok(!input2.isDirty());
-				assert.ok(!model.isDirty());
+			assert.ok(service.isDirty(input2.getResource()));
+			assert.equal(service.getDirty()[0].toString(), input2.getResource().toString());
+			assert.equal(service.getDirty([input2.getResource()])[0].toString(), input2.getResource().toString());
+			assert.equal(service.getDirty([input1.getResource()]).length, 0);
 
-				input2.dispose();
+			service.revertAll();
+			assert.equal(service.getAll().length, 0);
+			assert.ok(!input2.isDirty());
+			assert.ok(!model.isDirty());
 
-				assert.ok(!service.exists(input2.getResource()));
+			input2.dispose();
 
-				done();
-			});
+			assert.ok(!service.exists(input2.getResource()));
+			done();
+		});
 
-			model.textEditorModel.setValue('foo bar');
-		}, err => done(err));
+		model.textEditorModel.setValue('foo bar');
 	});
 
-	test('Untitled with associated resource', function () {
+	test('Untitled with associated resource', () => {
 		const service = accessor.untitledEditorService;
 		const file = URI.file(join('C:\\', '/foo/file.txt'));
 		const untitled = service.createOrGet(file);
@@ -107,53 +107,49 @@ suite('Workbench untitled editors', () => {
 		untitled.dispose();
 	});
 
-	test('Untitled no longer dirty when content gets empty', function () {
+	test('Untitled no longer dirty when content gets empty', async () => {
 		const service = accessor.untitledEditorService;
 		const input = service.createOrGet();
 
 		// dirty
-		return input.resolve().then(model => {
-			model.textEditorModel.setValue('foo bar');
-			assert.ok(model.isDirty());
-
-			model.textEditorModel.setValue('');
-			assert.ok(!model.isDirty());
-
-			input.dispose();
-		});
+		const model = await input.resolve();
+		model.textEditorModel.setValue('foo bar');
+		assert.ok(model.isDirty());
+		model.textEditorModel.setValue('');
+		assert.ok(!model.isDirty());
+		input.dispose();
 	});
 
-	test('Untitled via loadOrCreate', function () {
+	test('Untitled via loadOrCreate', async () => {
 		const service = accessor.untitledEditorService;
-		service.loadOrCreate().then(model1 => {
-			model1.textEditorModel!.setValue('foo bar');
-			assert.ok(model1.isDirty());
 
-			model1.textEditorModel!.setValue('');
-			assert.ok(!model1.isDirty());
+		const model1 = await service.loadOrCreate();
 
-			return service.loadOrCreate({ initialValue: 'Hello World' }).then(model2 => {
-				assert.equal(snapshotToString(model2.createSnapshot()!), 'Hello World');
+		model1.textEditorModel!.setValue('foo bar');
+		assert.ok(model1.isDirty());
 
-				const input = service.createOrGet();
+		model1.textEditorModel!.setValue('');
+		assert.ok(!model1.isDirty());
 
-				return service.loadOrCreate({ resource: input.getResource() }).then(model3 => {
-					assert.equal(model3.getResource().toString(), input.getResource().toString());
+		const model2 = await service.loadOrCreate({ initialValue: 'Hello World' });
+		assert.equal(snapshotToString(model2.createSnapshot()!), 'Hello World');
 
-					const file = URI.file(join('C:\\', '/foo/file44.txt'));
-					return service.loadOrCreate({ resource: file }).then(model4 => {
-						assert.ok(service.hasAssociatedFilePath(model4.getResource()));
-						assert.ok(model4.isDirty());
+		const input = service.createOrGet();
 
-						model1.dispose();
-						model2.dispose();
-						model3.dispose();
-						model4.dispose();
-						input.dispose();
-					});
-				});
-			});
-		});
+		const model3 = await service.loadOrCreate({ resource: input.getResource() });
+
+		assert.equal(model3.getResource().toString(), input.getResource().toString());
+
+		const file = URI.file(join('C:\\', '/foo/file44.txt'));
+		const model4 = await service.loadOrCreate({ resource: file });
+		assert.ok(service.hasAssociatedFilePath(model4.getResource()));
+		assert.ok(model4.isDirty());
+
+		model1.dispose();
+		model2.dispose();
+		model3.dispose();
+		model4.dispose();
+		input.dispose();
 	});
 
 	test('Untitled suggest name', function () {
@@ -163,24 +159,31 @@ suite('Workbench untitled editors', () => {
 		assert.ok(service.suggestFileName(input.getResource()));
 	});
 
-	test('Untitled with associated path remains dirty when content gets empty', function () {
+	test('Untitled with associated path remains dirty when content gets empty', async () => {
 		const service = accessor.untitledEditorService;
 		const file = URI.file(join('C:\\', '/foo/file.txt'));
 		const input = service.createOrGet(file);
 
 		// dirty
-		return input.resolve().then(model => {
-			model.textEditorModel.setValue('foo bar');
-			assert.ok(model.isDirty());
-
-			model.textEditorModel.setValue('');
-			assert.ok(model.isDirty());
-
-			input.dispose();
-		});
+		const model = await input.resolve();
+		model.textEditorModel.setValue('foo bar');
+		assert.ok(model.isDirty());
+		model.textEditorModel.setValue('');
+		assert.ok(model.isDirty());
+		input.dispose();
 	});
 
-	test('Untitled created with files.defaultLanguage setting', function () {
+	test('Untitled with initial content is dirty', async () => {
+		const service = accessor.untitledEditorService;
+		const input = service.createOrGet(undefined, undefined, 'Hello World');
+
+		// dirty
+		const model = await input.resolve();
+		assert.ok(model.isDirty());
+		input.dispose();
+	});
+
+	test('Untitled created with files.defaultLanguage setting', () => {
 		const defaultLanguage = 'javascript';
 		const config = accessor.testConfigurationService;
 		config.setUserConfiguration('files', { 'defaultLanguage': defaultLanguage });
@@ -188,30 +191,52 @@ suite('Workbench untitled editors', () => {
 		const service = accessor.untitledEditorService;
 		const input = service.createOrGet();
 
-		assert.equal(input.getModeId(), defaultLanguage);
+		assert.equal(input.getMode(), defaultLanguage);
 
 		config.setUserConfiguration('files', { 'defaultLanguage': undefined });
 
 		input.dispose();
 	});
 
-	test('Untitled created with modeId overrides files.defaultLanguage setting', function () {
-		const modeId = 'typescript';
+	test('Untitled created with mode overrides files.defaultLanguage setting', () => {
+		const mode = 'typescript';
 		const defaultLanguage = 'javascript';
 		const config = accessor.testConfigurationService;
 		config.setUserConfiguration('files', { 'defaultLanguage': defaultLanguage });
 
 		const service = accessor.untitledEditorService;
-		const input = service.createOrGet(null!, modeId);
+		const input = service.createOrGet(null!, mode);
 
-		assert.equal(input.getModeId(), modeId);
+		assert.equal(input.getMode(), mode);
 
 		config.setUserConfiguration('files', { 'defaultLanguage': undefined });
 
 		input.dispose();
 	});
 
-	test('encoding change event', function () {
+	test('Untitled can change mode afterwards', async () => {
+		const mode = 'untitled-input-test';
+
+		ModesRegistry.registerLanguage({
+			id: mode,
+		});
+
+		const service = accessor.untitledEditorService;
+		const input = service.createOrGet(null!, mode);
+
+		assert.equal(input.getMode(), mode);
+
+		const model = await input.resolve();
+		assert.equal(model.getMode(), mode);
+
+		input.setMode('text');
+
+		assert.equal(input.getMode(), PLAINTEXT_MODE_ID);
+
+		input.dispose();
+	});
+
+	test('encoding change event', async () => {
 		const service = accessor.untitledEditorService;
 		const input = service.createOrGet();
 
@@ -223,16 +248,13 @@ suite('Workbench untitled editors', () => {
 		});
 
 		// dirty
-		return input.resolve().then(model => {
-			model.setEncoding('utf16');
-
-			assert.equal(counter, 1);
-
-			input.dispose();
-		});
+		const model = await input.resolve();
+		model.setEncoding('utf16');
+		assert.equal(counter, 1);
+		input.dispose();
 	});
 
-	test('onDidChangeContent event', () => {
+	test('onDidChangeContent event', async () => {
 		const service = accessor.untitledEditorService;
 		const input = service.createOrGet();
 
@@ -245,39 +267,32 @@ suite('Workbench untitled editors', () => {
 			assert.equal(r.toString(), input.getResource().toString());
 		});
 
-		return input.resolve().then(model => {
-			model.textEditorModel.setValue('foo');
-			assert.equal(counter, 0, 'Dirty model should not trigger event immediately');
+		const model = await input.resolve();
+		model.textEditorModel.setValue('foo');
+		assert.equal(counter, 0, 'Dirty model should not trigger event immediately');
 
-			return timeout(3).then(() => {
-				assert.equal(counter, 1, 'Dirty model should trigger event');
+		await timeout(3);
+		assert.equal(counter, 1, 'Dirty model should trigger event');
+		model.textEditorModel.setValue('bar');
 
-				model.textEditorModel.setValue('bar');
-				return timeout(3).then(() => {
-					assert.equal(counter, 2, 'Content change when dirty should trigger event');
+		await timeout(3);
+		assert.equal(counter, 2, 'Content change when dirty should trigger event');
+		model.textEditorModel.setValue('');
 
-					model.textEditorModel.setValue('');
-					return timeout(3).then(() => {
-						assert.equal(counter, 3, 'Manual revert should trigger event');
+		await timeout(3);
+		assert.equal(counter, 3, 'Manual revert should trigger event');
+		model.textEditorModel.setValue('foo');
 
-						model.textEditorModel.setValue('foo');
-						return timeout(3).then(() => {
-							assert.equal(counter, 4, 'Dirty model should trigger event');
+		await timeout(3);
+		assert.equal(counter, 4, 'Dirty model should trigger event');
+		model.revert();
 
-							model.revert();
-							return timeout(3).then(() => {
-								assert.equal(counter, 5, 'Revert should trigger event');
-
-								input.dispose();
-							});
-						});
-					});
-				});
-			});
-		});
+		await timeout(3);
+		assert.equal(counter, 5, 'Revert should trigger event');
+		input.dispose();
 	});
 
-	test('onDidDisposeModel event', () => {
+	test('onDidDisposeModel event', async () => {
 		const service = accessor.untitledEditorService;
 		const input = service.createOrGet();
 
@@ -288,10 +303,9 @@ suite('Workbench untitled editors', () => {
 			assert.equal(r.toString(), input.getResource().toString());
 		});
 
-		return input.resolve().then(model => {
-			assert.equal(counter, 0);
-			input.dispose();
-			assert.equal(counter, 1);
-		});
+		await input.resolve();
+		assert.equal(counter, 0);
+		input.dispose();
+		assert.equal(counter, 1);
 	});
 });

src/vs/workbench/test/electron-browser/api/mainThreadSaveParticipant.test.ts

@@ -37,7 +37,7 @@ suite('MainThreadSaveParticipant', function () {
 	});
 
 	test('insert final new line', async function () {
-		const model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/final_new_line.txt'), 'utf8') as IResolvedTextFileEditorModel;
+		const model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/final_new_line.txt'), 'utf8', undefined) as IResolvedTextFileEditorModel;
 
 		await model.load();
 		const configService = new TestConfigurationService();
@@ -70,7 +70,7 @@ suite('MainThreadSaveParticipant', function () {
 	});
 
 	test('trim final new lines', async function () {
-		const model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/trim_final_new_line.txt'), 'utf8') as IResolvedTextFileEditorModel;
+		const model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/trim_final_new_line.txt'), 'utf8', undefined) as IResolvedTextFileEditorModel;
 
 		await model.load();
 		const configService = new TestConfigurationService();
@@ -105,7 +105,7 @@ suite('MainThreadSaveParticipant', function () {
 	});
 
 	test('trim final new lines bug#39750', async function () {
-		const model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/trim_final_new_line.txt'), 'utf8') as IResolvedTextFileEditorModel;
+		const model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/trim_final_new_line.txt'), 'utf8', undefined) as IResolvedTextFileEditorModel;
 
 		await model.load();
 		const configService = new TestConfigurationService();
@@ -132,7 +132,7 @@ suite('MainThreadSaveParticipant', function () {
 	});
 
 	test('trim final new lines bug#46075', async function () {
-		const model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/trim_final_new_line.txt'), 'utf8') as IResolvedTextFileEditorModel;
+		const model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/trim_final_new_line.txt'), 'utf8', undefined) as IResolvedTextFileEditorModel;
 
 		await model.load();
 		const configService = new TestConfigurationService();

src/vs/workbench/test/workbenchTestServices.ts

@@ -15,7 +15,7 @@ import { ConfirmResult, IEditorInputWithOptions, CloseDirection, IEditorIdentifi
 import { IEditorOpeningEvent, EditorServiceImpl, IEditorGroupView } from 'vs/workbench/browser/parts/editor/editor';
 import { Event, Emitter } from 'vs/base/common/event';
 import Severity from 'vs/base/common/severity';
-import { IBackupFileService } from 'vs/workbench/services/backup/common/backup';
+import { IBackupFileService, IResolvedBackup } from 'vs/workbench/services/backup/common/backup';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { IWorkbenchLayoutService, Parts, Position as PartPosition } from 'vs/workbench/services/layout/browser/layoutService';
 import { TextModelResolverService } from 'vs/workbench/services/textmodelResolver/common/textModelResolverService';
@@ -85,7 +85,7 @@ import { VSBuffer, VSBufferReadable } from 'vs/base/common/buffer';
 import { BrowserTextFileService } from 'vs/workbench/services/textfile/browser/textFileService';
 
 export function createFileInput(instantiationService: IInstantiationService, resource: URI): FileEditorInput {
-	return instantiationService.createInstance(FileEditorInput, resource, undefined);
+	return instantiationService.createInstance(FileEditorInput, resource, undefined, undefined);
 }
 
 export const TestEnvironmentService = new WorkbenchEnvironmentService(parseArgs(process.argv) as IWindowConfiguration, process.execPath);
@@ -1093,7 +1093,7 @@ export class TestBackupFileService implements IBackupFileService {
 		throw new Error('not implemented');
 	}
 
-	public backupResource(_resource: URI, _content: ITextSnapshot): Promise<void> {
+	public backupResource<T extends object>(_resource: URI, _content: ITextSnapshot, versionId?: number, meta?: T): Promise<void> {
 		return Promise.resolve();
 	}
 
@@ -1108,7 +1108,7 @@ export class TestBackupFileService implements IBackupFileService {
 		return textBuffer.getValueInRange(range, EndOfLinePreference.TextDefined);
 	}
 
-	public resolveBackupContent(_backup: URI): Promise<ITextBufferFactory> {
+	public resolveBackupContent<T extends object>(_backup: URI): Promise<IResolvedBackup<T>> {
 		throw new Error('not implemented');
 	}