public static colorizeModelLine(model: IModel, lineNumber: number, tabSize: number = 4): string {
		let content = model.getLineContent(lineNumber);
		let tokens = model.getLineTokens(lineNumber, false);
		let inflatedTokens = tokens.inflate();
		return this.colorizeLine(content, inflatedTokens, tabSize);
	}

suite('Search - Model', () => {
	let instantiation: IInstantiationService;
	let oneModel: IModel;

	setup(() => {
		let emitter = new Emitter<any>();

		oneModel = new model.Model('line1\nline2\nline3', null, URI.parse('file:///folder/file.txt'));
		instantiation = createInstantiationService({
			modelService: {
				getModel: () => oneModel,
				onModelAdded: emitter.event
			},
			requestService: {
				getRequestUrl: () => 'file:///folder/file.txt'
			},
			contextService: new TestContextService()
		});
	});

	teardown(() => {
		oneModel.dispose();
	});

	test('Line Match', function() {
		let fileMatch = new FileMatch(null, toUri('folder\\file.txt'));
		let lineMatch = new Match(fileMatch, 'foo bar', 1, 0, 3);
		assert.equal(lineMatch.text(), 'foo bar');
		assert.equal(lineMatch.range().startLineNumber, 2);
		assert.equal(lineMatch.range().endLineNumber, 2);
		assert.equal(lineMatch.range().startColumn, 1);
		assert.equal(lineMatch.range().endColumn, 4);
	});

	test('Line Match - Remove', function() {

		let fileMatch = new FileMatch(null, toUri('folder\\file.txt'));
		let lineMatch = new Match(fileMatch, 'foo bar', 1, 0, 3);
		fileMatch.add(lineMatch);
		assert.equal(fileMatch.matches().length, 1);
		fileMatch.remove(lineMatch);
		assert.equal(fileMatch.matches().length, 0);
	});

	test('File Match', function() {

		let fileMatch = new FileMatch(null, toUri('folder\\file.txt'));
		assert.equal(fileMatch.matches(), 0);
		assert.equal(fileMatch.resource().toString(), 'file:///c%3A/folder/file.txt');
		assert.equal(fileMatch.name(), 'file.txt');

		fileMatch = new FileMatch(null, toUri('file.txt'));
		assert.equal(fileMatch.matches(), 0);
		assert.equal(fileMatch.resource().toString(), 'file:///c%3A/file.txt');
		assert.equal(fileMatch.name(), 'file.txt');
	});

	test('Search Result', function() {

		let searchResult = instantiation.createInstance(SearchResult, null);
		assert.equal(searchResult.isEmpty(), true);

		let raw: IFileMatch[] = [];
		for (let i = 0; i < 10; i++) {
			raw.push({
				resource: URI.parse('file://c:/' + i),
				lineMatches: [{
					preview: String(i),
					lineNumber: 1,
					offsetAndLengths: [[0, 1]]
				}]
			});
		}
		searchResult.append(raw);

		assert.equal(searchResult.isEmpty(), false);
		assert.equal(searchResult.matches().length, 10);
	});

	test('Alle Drei Zusammen', function() {

		let searchResult = instantiation.createInstance(SearchResult, null);
		let fileMatch = new FileMatch(searchResult, toUri('far\\boo'));
		let lineMatch = new Match(fileMatch, 'foo bar', 1, 0, 3);

		assert(lineMatch.parent() === fileMatch);
		assert(fileMatch.parent() === searchResult);
	});

	//// ----- utils
	//function lineHasDecorations(model: editor.IModel, lineNumber: number, decorations: { start: number; end: number; }[]): void {
	//    let lineDecorations:typeof decorations = [];
	//    let decs = model.getLineDecorations(lineNumber);
	//    for (let i = 0, len = decs.length; i < len; i++) {
	//        lineDecorations.push({
	//            start: decs[i].range.startColumn,
	//            end: decs[i].range.endColumn
	//        });
	//    }
	//    assert.deepEqual(lineDecorations, decorations);
//.........这里部分代码省略.........

export function suggest(model: IModel, position: IPosition, triggerCharacter: string, groups?: ISuggestSupport[][]): TPromise<ISuggestResult2[][]> {

	if (!groups) {
		groups = SuggestRegistry.orderedGroups(model);
	}

	const resource = model.getAssociatedResource();
	const suggestions: ISuggestResult[][] = [];

	const factory = groups.map((supports, index) => {
		return () => {

			// stop as soon as a group produced a result
			if (suggestions.length > 0) {
				return;
			}

			// for each support in the group ask for suggestions
			const promises = supports.map(support => {
				return support.suggest(resource, position, triggerCharacter).then(values => {

					const result: ISuggestResult2[] = [];
					for (let suggestResult of values) {

						if (!suggestResult
							|| !Array.isArray(suggestResult.suggestions)
							|| suggestResult.suggestions.length === 0) {
							continue;
						}

						result.push({
							support,
							currentWord: suggestResult.currentWord,
							incomplete: suggestResult.incomplete,
							suggestions: suggestResult.suggestions
						});
					}

					return result;

				}, onUnexpectedError);
			});

			return TPromise.join(promises).then(values => {
				for (let value of values) {
					if (Array.isArray(value) && value.length > 0) {
						suggestions.push(value);
					}
				}
			});
		};
	});

	return sequence(factory).then(() => {
		// add snippets to the first group
		const snippets = getSnippets(model, position);
		if (suggestions.length === 0) {
			suggestions.push([snippets]);
		} else {
			suggestions[0].push(snippets);
		}
		return suggestions;
	});
}

	teardown(() => {
		oneModel.dispose();
	});