SQL Operations Studio Public Preview 1 (0.23) release source code

src/vs/editor/contrib/suggest/test/browser/completionModel.test.ts

@@ -0,0 +1,231 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import * as assert from 'assert';
+import { ISuggestion, ISuggestResult, ISuggestSupport, SuggestionType } from 'vs/editor/common/modes';
+import { ISuggestionItem, getSuggestionComparator } from 'vs/editor/contrib/suggest/browser/suggest';
+import { CompletionModel } from 'vs/editor/contrib/suggest/browser/completionModel';
+import { IPosition } from 'vs/editor/common/core/position';
+import { TPromise } from 'vs/base/common/winjs.base';
+
+suite('CompletionModel', function () {
+
+	function createSuggestItem(label: string, overwriteBefore: number, type: SuggestionType = 'property', incomplete: boolean = false, position: IPosition = { lineNumber: 1, column: 1 }): ISuggestionItem {
+
+		return new class implements ISuggestionItem {
+
+			position = position;
+
+			suggestion: ISuggestion = {
+				label,
+				overwriteBefore,
+				insertText: label,
+				type
+			};
+
+			container: ISuggestResult = {
+				incomplete,
+				suggestions: [this.suggestion]
+			};
+
+			support: ISuggestSupport = {
+				provideCompletionItems(): any {
+					return;
+				}
+			};
+
+			resolve(): TPromise<void> {
+				return null;
+			}
+		};
+	}
+
+	let model: CompletionModel;
+
+	setup(function () {
+
+		model = new CompletionModel([
+			createSuggestItem('foo', 3),
+			createSuggestItem('Foo', 3),
+			createSuggestItem('foo', 2),
+		], 1, {
+				leadingLineContent: 'foo',
+				characterCountDelta: 0
+			});
+	});
+
+	test('filtering - cached', function () {
+
+		const itemsNow = model.items;
+		let itemsThen = model.items;
+		assert.ok(itemsNow === itemsThen);
+
+		// still the same context
+		model.lineContext = { leadingLineContent: 'foo', characterCountDelta: 0 };
+		itemsThen = model.items;
+		assert.ok(itemsNow === itemsThen);
+
+		// different context, refilter
+		model.lineContext = { leadingLineContent: 'foo1', characterCountDelta: 1 };
+		itemsThen = model.items;
+		assert.ok(itemsNow !== itemsThen);
+	});
+
+
+	test('complete/incomplete', function () {
+
+		assert.equal(model.incomplete, false);
+
+		let incompleteModel = new CompletionModel([
+			createSuggestItem('foo', 3, undefined, true),
+			createSuggestItem('foo', 2),
+		], 1, {
+				leadingLineContent: 'foo',
+				characterCountDelta: 0
+			});
+		assert.equal(incompleteModel.incomplete, true);
+	});
+
+	test('replaceIncomplete', function () {
+
+		const completeItem = createSuggestItem('foobar', 1, undefined, false, { lineNumber: 1, column: 2 });
+		const incompleteItem = createSuggestItem('foofoo', 1, undefined, true, { lineNumber: 1, column: 2 });
+
+		const model = new CompletionModel([completeItem, incompleteItem], 2, { leadingLineContent: 'f', characterCountDelta: 0 });
+		assert.equal(model.incomplete, true);
+		assert.equal(model.items.length, 2);
+
+		const { complete, incomplete } = model.resolveIncompleteInfo();
+
+		assert.equal(incomplete.length, 1);
+		assert.ok(incomplete[0] === incompleteItem.support);
+		assert.equal(complete.length, 1);
+		assert.ok(complete[0] === completeItem);
+	});
+
+	test('proper current word when length=0, #16380', function () {
+
+		model = new CompletionModel([
+			createSuggestItem('    </div', 4),
+			createSuggestItem('a', 0),
+			createSuggestItem('p', 0),
+			createSuggestItem('    </tag', 4),
+			createSuggestItem('    XYZ', 4),
+		], 1, {
+				leadingLineContent: '   <',
+				characterCountDelta: 0
+			});
+
+		assert.equal(model.items.length, 4);
+
+		const [a, b, c, d] = model.items;
+		assert.equal(a.suggestion.label, '    </div');
+		assert.equal(b.suggestion.label, '    </tag');
+		assert.equal(c.suggestion.label, 'a');
+		assert.equal(d.suggestion.label, 'p');
+	});
+
+	test('keep snippet sorting with prefix: top, #25495', function () {
+
+		model = new CompletionModel([
+			createSuggestItem('Snippet1', 1, 'snippet'),
+			createSuggestItem('tnippet2', 1, 'snippet'),
+			createSuggestItem('semver', 1, 'property'),
+		], 1, {
+				leadingLineContent: 's',
+				characterCountDelta: 0
+			}, 'top');
+
+		assert.equal(model.items.length, 2);
+		const [a, b] = model.items;
+		assert.equal(a.suggestion.label, 'Snippet1');
+		assert.equal(b.suggestion.label, 'semver');
+		assert.ok(a.score < b.score); // snippet really promoted
+
+	});
+
+	test('keep snippet sorting with prefix: bottom, #25495', function () {
+
+		model = new CompletionModel([
+			createSuggestItem('snippet1', 1, 'snippet'),
+			createSuggestItem('tnippet2', 1, 'snippet'),
+			createSuggestItem('Semver', 1, 'property'),
+		], 1, {
+				leadingLineContent: 's',
+				characterCountDelta: 0
+			}, 'bottom');
+
+		assert.equal(model.items.length, 2);
+		const [a, b] = model.items;
+		assert.equal(a.suggestion.label, 'Semver');
+		assert.equal(b.suggestion.label, 'snippet1');
+		assert.ok(a.score < b.score); // snippet really demoted
+	});
+
+	test('keep snippet sorting with prefix: inline, #25495', function () {
+
+		model = new CompletionModel([
+			createSuggestItem('snippet1', 1, 'snippet'),
+			createSuggestItem('tnippet2', 1, 'snippet'),
+			createSuggestItem('Semver', 1, 'property'),
+		], 1, {
+				leadingLineContent: 's',
+				characterCountDelta: 0
+			}, 'inline');
+
+		assert.equal(model.items.length, 2);
+		const [a, b] = model.items;
+		assert.equal(a.suggestion.label, 'snippet1');
+		assert.equal(b.suggestion.label, 'Semver');
+		assert.ok(a.score > b.score); // snippet really demoted
+	});
+
+	test('filterText seems ignored in autocompletion, #26874', function () {
+
+		const item1 = createSuggestItem('Map - java.util', 1, 'property');
+		item1.suggestion.filterText = 'Map';
+		const item2 = createSuggestItem('Map - java.util', 1, 'property');
+
+		model = new CompletionModel([item1, item2], 1, {
+			leadingLineContent: 'M',
+			characterCountDelta: 0
+		});
+
+		assert.equal(model.items.length, 2);
+
+		model.lineContext = {
+			leadingLineContent: 'Map ',
+			characterCountDelta: 3
+		};
+		assert.equal(model.items.length, 1);
+	});
+
+	test('Vscode 1.12 no longer obeys \'sortText\' in completion items (from language server), #26096', function () {
+
+		const item1 = createSuggestItem('<- groups', 2, 'property', false, { lineNumber: 1, column: 3 });
+		item1.suggestion.filterText = '  groups';
+		item1.suggestion.sortText = '00002';
+
+		const item2 = createSuggestItem('source', 0, 'property', false, { lineNumber: 1, column: 3 });
+		item2.suggestion.filterText = 'source';
+		item2.suggestion.sortText = '00001';
+
+		const items = [item1, item2].sort(getSuggestionComparator('inline'));
+
+		model = new CompletionModel(items, 3, {
+			leadingLineContent: '  ',
+			characterCountDelta: 0
+		});
+
+		assert.equal(model.items.length, 2);
+
+		const [first, second] = model.items;
+		assert.equal(first.suggestion.label, 'source');
+		assert.equal(second.suggestion.label, '<- groups');
+
+	});
+
+});

src/vs/editor/contrib/suggest/test/browser/suggest.test.ts

@@ -0,0 +1,110 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import * as assert from 'assert';
+import URI from 'vs/base/common/uri';
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { SuggestRegistry } from 'vs/editor/common/modes';
+import { provideSuggestionItems } from 'vs/editor/contrib/suggest/browser/suggest';
+import { Position } from 'vs/editor/common/core/position';
+import { Model } from 'vs/editor/common/model/model';
+
+
+suite('Suggest', function () {
+
+	let model: Model;
+	let registration: IDisposable;
+
+	setup(function () {
+
+		model = Model.createFromString('FOO\nbar\BAR\nfoo', undefined, undefined, URI.parse('foo:bar/path'));
+		registration = SuggestRegistry.register({ pattern: 'bar/path', scheme: 'foo' }, {
+			provideCompletionItems() {
+				return {
+					incomplete: false,
+					suggestions: [{
+						label: 'aaa',
+						type: 'snippet',
+						insertText: 'aaa'
+					}, {
+						label: 'zzz',
+						type: 'snippet',
+						insertText: 'zzz'
+					}, {
+						label: 'fff',
+						type: 'property',
+						insertText: 'fff'
+					}]
+				};
+			}
+		});
+	});
+
+	teardown(() => {
+		registration.dispose();
+		model.dispose();
+	});
+
+	test('sort - snippet inline', function () {
+		return provideSuggestionItems(model, new Position(1, 1), 'inline').then(items => {
+			assert.equal(items.length, 3);
+			assert.equal(items[0].suggestion.label, 'aaa');
+			assert.equal(items[1].suggestion.label, 'fff');
+			assert.equal(items[2].suggestion.label, 'zzz');
+		});
+	});
+
+	test('sort - snippet top', function () {
+		return provideSuggestionItems(model, new Position(1, 1), 'top').then(items => {
+			assert.equal(items.length, 3);
+			assert.equal(items[0].suggestion.label, 'aaa');
+			assert.equal(items[1].suggestion.label, 'zzz');
+			assert.equal(items[2].suggestion.label, 'fff');
+		});
+	});
+
+	test('sort - snippet bottom', function () {
+		return provideSuggestionItems(model, new Position(1, 1), 'bottom').then(items => {
+			assert.equal(items.length, 3);
+			assert.equal(items[0].suggestion.label, 'fff');
+			assert.equal(items[1].suggestion.label, 'aaa');
+			assert.equal(items[2].suggestion.label, 'zzz');
+		});
+	});
+
+	test('sort - snippet none', function () {
+		return provideSuggestionItems(model, new Position(1, 1), 'none').then(items => {
+			assert.equal(items.length, 1);
+			assert.equal(items[0].suggestion.label, 'fff');
+		});
+	});
+
+	test('only from', function () {
+
+		const foo: any = {
+			triggerCharacters: [],
+			provideCompletionItems() {
+				return {
+					currentWord: '',
+					incomplete: false,
+					suggestions: [{
+						label: 'jjj',
+						type: 'property',
+						insertText: 'jjj'
+					}]
+				};
+			}
+		};
+		const registration = SuggestRegistry.register({ pattern: 'bar/path', scheme: 'foo' }, foo);
+
+		provideSuggestionItems(model, new Position(1, 1), undefined, [foo]).then(items => {
+			registration.dispose();
+
+			assert.equal(items.length, 1);
+			assert.ok(items[0].support === foo);
+		});
+	});
+});

src/vs/editor/contrib/suggest/test/browser/suggestModel.test.ts

@@ -0,0 +1,460 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import * as assert from 'assert';
+import Event from 'vs/base/common/event';
+import URI from 'vs/base/common/uri';
+import { IDisposable, dispose } from 'vs/base/common/lifecycle';
+import { TPromise } from 'vs/base/common/winjs.base';
+import { Model } from 'vs/editor/common/model/model';
+import { ICommonCodeEditor, Handler } from 'vs/editor/common/editorCommon';
+import { ISuggestSupport, ISuggestResult, SuggestRegistry } from 'vs/editor/common/modes';
+import { SuggestModel, LineContext } from 'vs/editor/contrib/suggest/browser/suggestModel';
+import { MockCodeEditor, MockScopeLocation } from 'vs/editor/test/common/mocks/mockCodeEditor';
+import { ServiceCollection } from 'vs/platform/instantiation/common/serviceCollection';
+import { InstantiationService } from 'vs/platform/instantiation/common/instantiationService';
+import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
+import { MockContextKeyService } from 'vs/platform/keybinding/test/common/mockKeybindingService';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { NullTelemetryService } from 'vs/platform/telemetry/common/telemetryUtils';
+
+function createMockEditor(model: Model): MockCodeEditor {
+	const contextKeyService = new MockContextKeyService();
+	const telemetryService = NullTelemetryService;
+	const instantiationService = new InstantiationService(new ServiceCollection(
+		[IContextKeyService, contextKeyService],
+		[ITelemetryService, telemetryService]
+	));
+
+	const editor = new MockCodeEditor(new MockScopeLocation(), {}, instantiationService, contextKeyService);
+	editor.setModel(model);
+	return editor;
+}
+
+suite('SuggestModel - Context', function () {
+
+	let model: Model;
+
+	setup(function () {
+		model = Model.createFromString('Das Pferd frisst keinen Gurkensalat - Philipp Reis 1861.\nWer hat\'s erfunden?');
+	});
+
+	teardown(function () {
+		model.dispose();
+	});
+
+	test('Context - shouldAutoTrigger', function () {
+
+		function assertAutoTrigger(offset: number, expected: boolean): void {
+			const pos = model.getPositionAt(offset);
+			const editor = createMockEditor(model);
+			editor.setPosition(pos);
+			assert.equal(LineContext.shouldAutoTrigger(editor), expected);
+			editor.dispose();
+		}
+
+		assertAutoTrigger(3, true); // end of word, Das|
+		assertAutoTrigger(4, false); // no word Das |
+		assertAutoTrigger(1, false); // middle of word D|as
+		assertAutoTrigger(55, false); // number, 1861|
+	});
+
+});
+
+suite('SuggestModel - TriggerAndCancelOracle', function () {
+
+
+	const alwaysEmptySupport: ISuggestSupport = {
+		provideCompletionItems(doc, pos) {
+			return <ISuggestResult>{
+				incomplete: false,
+				suggestions: []
+			};
+		}
+	};
+
+	const alwaysSomethingSupport: ISuggestSupport = {
+		provideCompletionItems(doc, pos) {
+			return <ISuggestResult>{
+				incomplete: false,
+				suggestions: [{
+					label: doc.getWordUntilPosition(pos).word,
+					type: 'property',
+					insertText: 'foofoo'
+				}]
+			};
+		}
+	};
+
+	let disposables: IDisposable[] = [];
+	let model: Model;
+
+	setup(function () {
+		disposables = dispose(disposables);
+		model = Model.createFromString('abc def', undefined, undefined, URI.parse('test:somefile.ttt'));
+		disposables.push(model);
+	});
+
+	function withOracle(callback: (model: SuggestModel, editor: ICommonCodeEditor) => any): TPromise<any> {
+
+		return new TPromise((resolve, reject) => {
+			const editor = createMockEditor(model);
+			const oracle = new SuggestModel(editor);
+			disposables.push(oracle, editor);
+
+			try {
+				resolve(callback(oracle, editor));
+			} catch (err) {
+				reject(err);
+			}
+		});
+	}
+
+	function assertEvent<E>(event: Event<E>, action: () => any, assert: (e: E) => any) {
+		return new TPromise((resolve, reject) => {
+			const sub = event(e => {
+				sub.dispose();
+				try {
+					resolve(assert(e));
+				} catch (err) {
+					reject(err);
+				}
+			});
+			try {
+				action();
+			} catch (err) {
+				reject(err);
+			}
+		});
+	}
+
+	test('events - cancel/trigger', function () {
+		return withOracle(model => {
+
+			return TPromise.join([
+				assertEvent(model.onDidCancel, function () {
+					model.cancel();
+				}, function (event) {
+					assert.equal(event.retrigger, false);
+				}),
+
+				assertEvent(model.onDidCancel, function () {
+					model.cancel(true);
+				}, function (event) {
+					assert.equal(event.retrigger, true);
+				}),
+
+				// cancel on trigger
+				assertEvent(model.onDidCancel, function () {
+					model.trigger(false);
+				}, function (event) {
+					assert.equal(event.retrigger, false);
+				}),
+
+				assertEvent(model.onDidCancel, function () {
+					model.trigger(false, true);
+				}, function (event) {
+					assert.equal(event.retrigger, true);
+				}),
+
+				assertEvent(model.onDidTrigger, function () {
+					model.trigger(true);
+				}, function (event) {
+					assert.equal(event.auto, true);
+				}),
+
+				assertEvent(model.onDidTrigger, function () {
+					model.trigger(false);
+				}, function (event) {
+					assert.equal(event.auto, false);
+				})
+			]);
+		});
+	});
+
+
+	test('events - suggest/empty', function () {
+
+		disposables.push(SuggestRegistry.register({ scheme: 'test' }, alwaysEmptySupport));
+
+		return withOracle(model => {
+			return TPromise.join([
+				assertEvent(model.onDidCancel, function () {
+					model.trigger(true);
+				}, function (event) {
+					assert.equal(event.retrigger, false);
+				}),
+				assertEvent(model.onDidSuggest, function () {
+					model.trigger(false);
+				}, function (event) {
+					assert.equal(event.auto, false);
+					assert.equal(event.isFrozen, false);
+					assert.equal(event.completionModel.items.length, 0);
+				})
+			]);
+		});
+	});
+
+	test('trigger - on type', function () {
+
+		disposables.push(SuggestRegistry.register({ scheme: 'test' }, alwaysSomethingSupport));
+
+		return withOracle((model, editor) => {
+			return assertEvent(model.onDidSuggest, () => {
+				editor.setPosition({ lineNumber: 1, column: 4 });
+				editor.trigger('keyboard', Handler.Type, { text: 'd' });
+
+			}, event => {
+				assert.equal(event.auto, true);
+				assert.equal(event.completionModel.items.length, 1);
+				const [first] = event.completionModel.items;
+
+				assert.equal(first.support, alwaysSomethingSupport);
+			});
+		});
+	});
+
+	test('#17400: Keep filtering suggestModel.ts after space', function () {
+
+		disposables.push(SuggestRegistry.register({ scheme: 'test' }, {
+			provideCompletionItems(doc, pos) {
+				return <ISuggestResult>{
+					currentWord: '',
+					incomplete: false,
+					suggestions: [{
+						label: 'My Table',
+						type: 'property',
+						insertText: 'My Table'
+					}]
+				};
+			}
+		}));
+
+		model.setValue('');
+
+		return withOracle((model, editor) => {
+
+			return assertEvent(model.onDidSuggest, () => {
+				// make sure completionModel starts here!
+				model.trigger(true);
+			}, event => {
+
+				return assertEvent(model.onDidSuggest, () => {
+					editor.setPosition({ lineNumber: 1, column: 1 });
+					editor.trigger('keyboard', Handler.Type, { text: 'My' });
+
+				}, event => {
+					assert.equal(event.auto, true);
+					assert.equal(event.completionModel.items.length, 1);
+					const [first] = event.completionModel.items;
+					assert.equal(first.suggestion.label, 'My Table');
+
+					return assertEvent(model.onDidSuggest, () => {
+						editor.setPosition({ lineNumber: 1, column: 3 });
+						editor.trigger('keyboard', Handler.Type, { text: ' ' });
+
+					}, event => {
+						assert.equal(event.auto, true);
+						assert.equal(event.completionModel.items.length, 1);
+						const [first] = event.completionModel.items;
+						assert.equal(first.suggestion.label, 'My Table');
+					});
+				});
+			});
+		});
+	});
+
+	test('#21484: Trigger character always force a new completion session', function () {
+
+		disposables.push(SuggestRegistry.register({ scheme: 'test' }, {
+			provideCompletionItems(doc, pos) {
+				return <ISuggestResult>{
+					currentWord: '',
+					incomplete: false,
+					suggestions: [{
+						label: 'foo.bar',
+						type: 'property',
+						insertText: 'foo.bar',
+						overwriteBefore: pos.column - 1
+					}]
+				};
+			}
+		}));
+
+		disposables.push(SuggestRegistry.register({ scheme: 'test' }, {
+			triggerCharacters: ['.'],
+			provideCompletionItems(doc, pos) {
+				return <ISuggestResult>{
+					currentWord: '',
+					incomplete: false,
+					suggestions: [{
+						label: 'boom',
+						type: 'property',
+						insertText: 'boom',
+						overwriteBefore: doc.getLineContent(pos.lineNumber)[pos.column - 2] === '.' ? 0 : pos.column - 1
+					}]
+				};
+			}
+		}));
+
+		model.setValue('');
+
+		return withOracle((model, editor) => {
+
+			return assertEvent(model.onDidSuggest, () => {
+				editor.setPosition({ lineNumber: 1, column: 1 });
+				editor.trigger('keyboard', Handler.Type, { text: 'foo' });
+
+			}, event => {
+				assert.equal(event.auto, true);
+				assert.equal(event.completionModel.items.length, 1);
+				const [first] = event.completionModel.items;
+				assert.equal(first.suggestion.label, 'foo.bar');
+
+				return assertEvent(model.onDidSuggest, () => {
+					editor.trigger('keyboard', Handler.Type, { text: '.' });
+
+				}, event => {
+					assert.equal(event.auto, true);
+					assert.equal(event.completionModel.items.length, 2);
+					const [first, second] = event.completionModel.items;
+					assert.equal(first.suggestion.label, 'foo.bar');
+					assert.equal(second.suggestion.label, 'boom');
+				});
+			});
+		});
+	});
+
+	test('Intellisense Completion doesn\'t respect space after equal sign (.html file), #29353 [1/2]', function () {
+
+		disposables.push(SuggestRegistry.register({ scheme: 'test' }, alwaysSomethingSupport));
+
+		return withOracle((model, editor) => {
+
+			editor.getModel().setValue('fo');
+			editor.setPosition({ lineNumber: 1, column: 3 });
+
+			return assertEvent(model.onDidSuggest, () => {
+				model.trigger(false);
+			}, event => {
+				assert.equal(event.auto, false);
+				assert.equal(event.isFrozen, false);
+				assert.equal(event.completionModel.items.length, 1);
+
+				return assertEvent(model.onDidCancel, () => {
+					editor.trigger('keyboard', Handler.Type, { text: '+' });
+				}, event => {
+					assert.equal(event.retrigger, false);
+				});
+			});
+		});
+	});
+
+	test('Intellisense Completion doesn\'t respect space after equal sign (.html file), #29353 [2/2]', function () {
+
+		disposables.push(SuggestRegistry.register({ scheme: 'test' }, alwaysSomethingSupport));
+
+		return withOracle((model, editor) => {
+
+			editor.getModel().setValue('fo');
+			editor.setPosition({ lineNumber: 1, column: 3 });
+
+			return assertEvent(model.onDidSuggest, () => {
+				model.trigger(false);
+			}, event => {
+				assert.equal(event.auto, false);
+				assert.equal(event.isFrozen, false);
+				assert.equal(event.completionModel.items.length, 1);
+
+				return assertEvent(model.onDidCancel, () => {
+					editor.trigger('keyboard', Handler.Type, { text: ' ' });
+				}, event => {
+					assert.equal(event.retrigger, false);
+				});
+			});
+		});
+	});
+
+	test('Incomplete suggestion results cause re-triggering when typing w/o further context, #28400 (1/2)', function () {
+
+		disposables.push(SuggestRegistry.register({ scheme: 'test' }, {
+			provideCompletionItems(doc, pos) {
+				return <ISuggestResult>{
+					incomplete: true,
+					suggestions: [{
+						label: 'foo',
+						type: 'property',
+						insertText: 'foo',
+						overwriteBefore: pos.column - 1
+					}]
+				};
+			}
+		}));
+
+		return withOracle((model, editor) => {
+
+			editor.getModel().setValue('foo');
+			editor.setPosition({ lineNumber: 1, column: 4 });
+
+			return assertEvent(model.onDidSuggest, () => {
+				model.trigger(false);
+			}, event => {
+				assert.equal(event.auto, false);
+				assert.equal(event.completionModel.incomplete, true);
+				assert.equal(event.completionModel.items.length, 1);
+
+				return assertEvent(model.onDidCancel, () => {
+					editor.trigger('keyboard', Handler.Type, { text: ';' });
+				}, event => {
+					assert.equal(event.retrigger, false);
+				});
+			});
+		});
+	});
+
+	test('Incomplete suggestion results cause re-triggering when typing w/o further context, #28400 (2/2)', function () {
+
+		disposables.push(SuggestRegistry.register({ scheme: 'test' }, {
+			provideCompletionItems(doc, pos) {
+				return <ISuggestResult>{
+					incomplete: true,
+					suggestions: [{
+						label: 'foo;',
+						type: 'property',
+						insertText: 'foo',
+						overwriteBefore: pos.column - 1
+					}]
+				};
+			}
+		}));
+
+		return withOracle((model, editor) => {
+
+			editor.getModel().setValue('foo');
+			editor.setPosition({ lineNumber: 1, column: 4 });
+
+			return assertEvent(model.onDidSuggest, () => {
+				model.trigger(false);
+			}, event => {
+				assert.equal(event.auto, false);
+				assert.equal(event.completionModel.incomplete, true);
+				assert.equal(event.completionModel.items.length, 1);
+
+				return assertEvent(model.onDidSuggest, () => {
+					// while we cancel incrementally enriching the set of
+					// completions we still filter against those that we have
+					// until now
+					editor.trigger('keyboard', Handler.Type, { text: ';' });
+				}, event => {
+					assert.equal(event.auto, false);
+					assert.equal(event.completionModel.incomplete, true);
+					assert.equal(event.completionModel.items.length, 1);
+
+				});
+			});
+		});
+	});
+});