Less mode tests should not depend on Typescript mode

src/vs/languages/html/test/common/html.test.ts

@@ -14,10 +14,7 @@ import {getRawEnterActionAtPosition} from 'vs/editor/common/modes/supports/onEnt
 import {TextModelWithTokens} from 'vs/editor/common/model/textModelWithTokens';
 import {TextModel} from 'vs/editor/common/model/textModel';
 import {Range} from 'vs/editor/common/core/range';
-import {createMockModeService} from 'vs/editor/test/common/servicesTestUtils';
-import {IModeService} from 'vs/editor/common/services/modeService';
 import {MockModeService} from 'vs/editor/test/common/mocks/mockModeService';
-import {MockExtensionService} from 'vs/editor/test/common/mocks/mockExtensionService';
 import {NULL_THREAD_SERVICE} from 'vs/platform/test/common/nullThreadService';
 import {createInstantiationService} from 'vs/platform/instantiation/common/instantiationService';
 import {HTMLMode} from 'vs/languages/html/common/html';

src/vs/languages/less/test/common/colorizer.test.ts

@@ -4,25 +4,98 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import 'vs/languages/css/common/css.contribution';
-import 'vs/languages/typescript/common/typescript.contribution';
-import 'vs/languages/less/common/less';
-import 'vs/languages/less/common/less.contribution';
 import Modes = require('vs/editor/common/modes');
 import modesUtil = require('vs/editor/test/common/modesUtil');
 import * as lessTokenTypes from 'vs/languages/less/common/lessTokenTypes';
+import {MockModeService} from 'vs/editor/test/common/mocks/mockModeService';
+import {NULL_THREAD_SERVICE} from 'vs/platform/test/common/nullThreadService';
+import {createInstantiationService} from 'vs/platform/instantiation/common/instantiationService';
+import {LESSMode} from 'vs/languages/less/common/less';
+import {MockMode} from 'vs/editor/test/common/mocks/mockMode';
+import {TokenizationSupport} from 'vs/editor/common/modes/supports/tokenizationSupport';
+import {AbstractState} from 'vs/editor/common/modes/abstractState';
+
+export class MockJSState extends AbstractState {
+
+	constructor(mode:Modes.IMode, stateCount:number) {
+		super(mode);
+	}
+
+	public makeClone():MockJSState {
+		return this;
+	}
+
+	public equals(other:Modes.IState):boolean {
+		return true;
+	}
+
+	public tokenize(stream:Modes.IStream):Modes.ITokenizationResult {
+		stream.advanceToEOS();
+		return { type: 'mock-js' };
+	}
+}
+
+export class MockJSMode extends MockMode {
+
+	public tokenizationSupport: Modes.ITokenizationSupport;
+
+	constructor() {
+		super();
+
+		this.tokenizationSupport = new TokenizationSupport(this, {
+			getInitialState: () => new MockJSState(this, 0)
+		}, false, false);
+	}
+}
+
+class LESSMockModeService extends MockModeService {
+	isRegisteredMode(mimetypeOrModeId: string): boolean {
+		if (mimetypeOrModeId === 'javascript') {
+			return true;
+		}
+		throw new Error('Not implemented');
+	}
+
+	getMode(commaSeparatedMimetypesOrCommaSeparatedIds: string): Modes.IMode {
+		if (commaSeparatedMimetypesOrCommaSeparatedIds === 'javascript') {
+			return new MockJSMode();
+		}
+		throw new Error('Not implemented');
+	}
+
+	getModeIdForLanguageName(alias:string): string {
+		if (alias === 'text/javascript') {
+			return 'javascript';
+		}
+		throw new Error('Not implemented');
+	}
+}
 
 suite('LESS-tokenization', () => {
 
-	var tokenizationSupport: Modes.ITokenizationSupport;
-	var assertOnEnter: modesUtil.IOnEnterAsserter;
+	let tokenizationSupport: Modes.ITokenizationSupport;
+	let assertOnEnter: modesUtil.IOnEnterAsserter;
 
-	setup((done) => {
-		modesUtil.load('less', ['javascript']).then(mode => {
-			tokenizationSupport = mode.tokenizationSupport;
-			assertOnEnter = modesUtil.createOnEnterAsserter(mode.getId(), mode.richEditSupport);
-			done();
+	setup(() => {
+		let threadService = NULL_THREAD_SERVICE;
+		let modeService = new LESSMockModeService();
+		let inst = createInstantiationService({
+			threadService: threadService,
+			modeService: modeService
 		});
+		threadService.setInstantiationService(inst);
+
+		let mode = new LESSMode(
+			{ id: 'less' },
+			inst,
+			threadService,
+			modeService,
+			null,
+			null
+		);
+
+		tokenizationSupport = mode.tokenizationSupport;
+		assertOnEnter = modesUtil.createOnEnterAsserter(mode.getId(), mode.richEditSupport);
 	});
 
 	test('', () => {
@@ -621,10 +694,7 @@ suite('LESS-tokenization', () => {
 				{ startIndex:5, type: 'punctuation.less' },
 				{ startIndex:6, type: '' },
 				{ startIndex:7, type: 'punctuation.backtick.less' },
-				{ startIndex:8, type: 'keyword.js' },
-				{ startIndex:16, type: '' },
-				{ startIndex:17, type: 'identifier.js' },
-				{ startIndex:24, type: 'delimiter.parenthesis.js' },
+				{ startIndex:8, type: 'mock-js' },
 				{ startIndex:26, type: 'punctuation.backtick.less' },
 				{ startIndex:27, type: '' },
 				{ startIndex:28, type: 'comment.less' }