microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-02-04 21:53:42 -06:00
Code Issues Packages Projects Releases 212 Wiki Activity

Enable clorizer unit tests

Browse Source
This commit is contained in:
Mohamed Hegazy 2014-08-07 22:21:12 -07:00
parent e515ca9697
commit 3fcd33ec32
4 changed files with 110 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/harness/harnessLanguageService.ts
View File

@ -271,6 +271,11 @@ module Harness.LanguageService {
return this.ls;
}
/** Return a new instance of the classifier service shim */
public getClassifier(): ts.ClassifierShim {
return new TypeScript.Services.TypeScriptServicesFactory().createClassifierShim(this);
}
/** Parse file given its source text */
public parseSourceText(fileName: string, sourceText: TypeScript.IScriptSnapshot): TypeScript.SourceUnitSyntax {
return TypeScript.Parser.parse(fileName, TypeScript.SimpleText.fromScriptSnapshot(sourceText), ts.ScriptTarget.ES5, TypeScript.isDTSFile(fileName)).sourceUnit();

3
src/harness/runner.ts
View File

@ -99,6 +99,9 @@ if (runners.length === 0) {
//// language services
runners.push(new FourslashRunner());
//runners.push(new GeneratedFourslashRunner());
// unittests
runners.push(new UnitTestRunner(UnittestTestType.Services));
}
sys.newLine = '\r\n';

10
src/harness/unittestrunner.ts
View File

@ -8,7 +8,7 @@ enum UnittestTestType {
}
class UnitTestRunner extends RunnerBase {
constructor(public testType?: UnittestTestType) {
constructor(public testType: UnittestTestType) {
super();
}
@ -20,6 +20,9 @@ class UnitTestRunner extends RunnerBase {
case UnittestTestType.LanguageService:
this.tests = this.enumerateFiles('tests/cases/unittests/ls');
break;
case UnittestTestType.Services:
this.tests = this.enumerateFiles('tests/cases/unittests/services', /colorization.ts/);
break;
default:
if (this.tests.length === 0) {
throw new Error('Unsupported test cases: ' + this.testType);
@ -38,7 +41,7 @@ class UnitTestRunner extends RunnerBase {
});
harnessCompiler.addInputFiles(toBeAdded);
harnessCompiler.setCompilerOptions({ noResolve: true });
var stdout = new Harness.Compiler.EmitterIOHost();
var emitDiagnostics = harnessCompiler.emitAll(stdout);
var results = stdout.toArray();
@ -59,7 +62,8 @@ class UnitTestRunner extends RunnerBase {
before: before,
after: after,
Harness: Harness,
IO: Harness.IO
IO: Harness.IO,
ts:ts
// FourSlash: FourSlash
};
}

194
tests/cases/unittests/services/colorization.ts
View File

@ -1,198 +1,194 @@
///<reference path='_project.ts'/>
interface Classification {
interface Classification {
length: number;
class2: TypeScript.TokenClass;
class: ts.TokenClass;
}
interface ClassiferResult {
tuples: Classification[];
finalLexState: TypeScript.LexState;
finalEndOfLineState: ts.EndOfLineState;
}
var TokenClassNames = {};
TokenClassNames[TypeScript.TokenClass.Punctuation] = "Punctuation";
TokenClassNames[TypeScript.TokenClass.Keyword] = "Keyword";
TokenClassNames[TypeScript.TokenClass.Operator] = "Operator";
TokenClassNames[TypeScript.TokenClass.Comment] = "Comment";
TokenClassNames[TypeScript.TokenClass.Whitespace] = "Whitespace";
TokenClassNames[TypeScript.TokenClass.Identifier] = "Identifier";
TokenClassNames[TypeScript.TokenClass.NumberLiteral] = "NumberLiteral";
TokenClassNames[TypeScript.TokenClass.StringLiteral] = "StringLiteral";
TokenClassNames[TypeScript.TokenClass.RegExpLiteral] = "RegExpLiteral";
TokenClassNames[ts.TokenClass.Punctuation] = "Punctuation";
TokenClassNames[ts.TokenClass.Keyword] = "Keyword";
TokenClassNames[ts.TokenClass.Operator] = "Operator";
TokenClassNames[ts.TokenClass.Comment] = "Comment";
TokenClassNames[ts.TokenClass.Whitespace] = "Whitespace";
TokenClassNames[ts.TokenClass.Identifier] = "Identifier";
TokenClassNames[ts.TokenClass.NumberLiteral] = "NumberLiteral";
TokenClassNames[ts.TokenClass.StringLiteral] = "StringLiteral";
TokenClassNames[ts.TokenClass.RegExpLiteral] = "RegExpLiteral";
describe('Colorization', function() {
var mytypescriptLS = new Harness.TypeScriptLS();
var myls = mytypescriptLS.getLanguageService();
var myclassifier = new Services.ClassifierShim(myls.host);
function getClassifications(code: string, initialLexState?: TypeScript.LexState = TypeScript.LexState.Start): ClassiferResult {
var classResult = myclassifier.getClassificationsForLine(code, initialLexState).split('\n');
describe('Colorization', function () {
var mytypescriptLS = new Harness.LanguageService.TypeScriptLS();
var myclassifier = mytypescriptLS.getClassifier();
function getClassifications(code: string, initialEndOfLineState: ts.EndOfLineState = ts.EndOfLineState.Start): ClassiferResult {
var classResult = myclassifier.getClassificationsForLine(code, initialEndOfLineState).split('\n');
var tuples: Classification[] = [];
var i = 0;
for (; i < classResult.length - 1; i += 2) {
tuples[i / 2] = {
length: parseInt(classResult[i]),
class2: parseInt(classResult[i + 1])
class: parseInt(classResult[i + 1])
};
}
var finalLexState = classResult[classResult.length - 1];
var finalEndOfLineState = classResult[classResult.length - 1];
return {
tuples: tuples,
finalLexState: parseInt(finalLexState)
finalEndOfLineState: parseInt(finalEndOfLineState)
};
}
function verifyClassification(classification: Classification, expectedLength: number, expectedClass: number) {
assert.notNull(classification);
assert.is(classification.length === expectedLength, "Classification length does not match expected. Expected: " + expectedLength + ", Actual: " + classification.length);
assert.is(classification.class2 === expectedClass, "Classification class does not match expected. Expected: " + TokenClassNames[expectedClass] + ", Actual: " + TokenClassNames[classification.class2]);
assert.isNotNull(classification);
assert.equal(classification.length, expectedLength, "Classification length does not match expected. Expected: " + expectedLength + ", Actual: " + classification.length);
assert.equal(classification.class, expectedClass, "Classification class does not match expected. Expected: " + TokenClassNames[expectedClass] + ", Actual: " + TokenClassNames[classification.class]);
}
describe("test cases for colorization", function() {
describe("test cases for colorization", function () {
var results = getClassifications('var x:string = "foo"; //Hello');
it("checks for a keyword", function() {
verifyClassification(results.tuples[0], 3, TypeScript.TokenClass.Keyword);
it("checks for a keyword", function () {
verifyClassification(results.tuples[0], 3, ts.TokenClass.Keyword);
});
it("checks for a whitespace", function() {
verifyClassification(results.tuples[1], 4, TypeScript.TokenClass.Whitespace);
it("checks for a whitespace", function () {
verifyClassification(results.tuples[1], 1, ts.TokenClass.Whitespace);
});
it("checks for a identifier", function() {
verifyClassification(results.tuples[2], 5, TypeScript.TokenClass.Identifier);
it("checks for a identifier", function () {
verifyClassification(results.tuples[2], 1, ts.TokenClass.Identifier);
});
it("checks for an punctuation", function() {
verifyClassification(results.tuples[3], 6, TypeScript.TokenClass.Punctuation);
});
it("checks for a operator", function() {
verifyClassification(results.tuples[6], 14, TypeScript.TokenClass.Operator);
it("checks for an punctuation", function () {
verifyClassification(results.tuples[3], 1, ts.TokenClass.Punctuation);
});
it("checks for a string literal", function() {
verifyClassification(results.tuples[8], 20, TypeScript.TokenClass.StringLiteral);
it("checks for a operator", function () {
verifyClassification(results.tuples[6], 1, ts.TokenClass.Operator);
});
it("checks for a comment", function() {
verifyClassification(results.tuples[11], 29, TypeScript.TokenClass.Comment);
it("checks for a string literal", function () {
verifyClassification(results.tuples[8], 5, ts.TokenClass.StringLiteral);
});
it("checks for a comment", function () {
verifyClassification(results.tuples[11], 7, ts.TokenClass.Comment);
});
});
describe("test comment colorization after a divide operator", function() {
describe("test comment colorization after a divide operator", function () {
var results = getClassifications('1 / 1 // comment');
it("checks for a number literal", function() {
verifyClassification(results.tuples[0], 1, TypeScript.TokenClass.NumberLiteral);
it("checks for a number literal", function () {
verifyClassification(results.tuples[0], 1, ts.TokenClass.NumberLiteral);
});
it("checks for a whitespace", function() {
verifyClassification(results.tuples[1], 2, TypeScript.TokenClass.Whitespace);
it("checks for a whitespace", function () {
verifyClassification(results.tuples[1], 1, ts.TokenClass.Whitespace);
});
it("checks for a operator", function() {
verifyClassification(results.tuples[2], 3, TypeScript.TokenClass.Operator);
it("checks for a operator", function () {
verifyClassification(results.tuples[2], 1, ts.TokenClass.Operator);
});
it("checks for a whitespace", function() {
verifyClassification(results.tuples[3], 4, TypeScript.TokenClass.Whitespace);
it("checks for a whitespace", function () {
verifyClassification(results.tuples[3], 1, ts.TokenClass.Whitespace);
});
it("checks for a number literal", function() {
verifyClassification(results.tuples[4], 5, TypeScript.TokenClass.NumberLiteral);
it("checks for a number literal", function () {
verifyClassification(results.tuples[4], 1, ts.TokenClass.NumberLiteral);
});
it("checks for a whitespace", function() {
verifyClassification(results.tuples[5], 6, TypeScript.TokenClass.Whitespace);
it("checks for a whitespace", function () {
verifyClassification(results.tuples[5], 1, ts.TokenClass.Whitespace);
});
it("checks for a comment", function() {
verifyClassification(results.tuples[6], 16, TypeScript.TokenClass.Comment);
it("checks for a comment", function () {
verifyClassification(results.tuples[6], 10, ts.TokenClass.Comment);
});
});
describe("test literal colorization after a divide operator", function() {
describe("test literal colorization after a divide operator", function () {
var results = getClassifications('1 / 2, 1 / 2');
it("checks for a number literal", function() {
verifyClassification(results.tuples[0], 1, TypeScript.TokenClass.NumberLiteral);
it("checks for a number literal", function () {
verifyClassification(results.tuples[0], 1, ts.TokenClass.NumberLiteral);
});
it("checks for a whitespace", function() {
verifyClassification(results.tuples[1], 2, TypeScript.TokenClass.Whitespace);
it("checks for a whitespace", function () {
verifyClassification(results.tuples[1], 1, ts.TokenClass.Whitespace);
});
it("checks for a operator", function() {
verifyClassification(results.tuples[2], 3, TypeScript.TokenClass.Operator);
it("checks for a operator", function () {
verifyClassification(results.tuples[2], 1, ts.TokenClass.Operator);
});
it("checks for a whitespace", function() {
verifyClassification(results.tuples[3], 4, TypeScript.TokenClass.Whitespace);
it("checks for a whitespace", function () {
verifyClassification(results.tuples[3], 1, ts.TokenClass.Whitespace);
});
it("checks for a number literal", function() {
verifyClassification(results.tuples[4], 5, TypeScript.TokenClass.NumberLiteral);
it("checks for a number literal", function () {
verifyClassification(results.tuples[4], 1, ts.TokenClass.NumberLiteral);
});
it("checks for a operator", function() {
verifyClassification(results.tuples[5], 6, TypeScript.TokenClass.Operator);
it("checks for a operator", function () {
verifyClassification(results.tuples[5], 1, ts.TokenClass.Operator);
});
it("checks for a whitespace", function() {
verifyClassification(results.tuples[6], 7, TypeScript.TokenClass.Whitespace);
it("checks for a whitespace", function () {
verifyClassification(results.tuples[6], 1, ts.TokenClass.Whitespace);
});
it("checks for a number literal", function() {
verifyClassification(results.tuples[7], 8, TypeScript.TokenClass.NumberLiteral);
it("checks for a number literal", function () {
verifyClassification(results.tuples[7], 1, ts.TokenClass.NumberLiteral);
});
it("checks for a whitespace", function() {
verifyClassification(results.tuples[8], 9, TypeScript.TokenClass.Whitespace);
it("checks for a whitespace", function () {
verifyClassification(results.tuples[8], 1, ts.TokenClass.Whitespace);
});
it("checks for a operator", function() {
verifyClassification(results.tuples[9], 10, TypeScript.TokenClass.Operator);
it("checks for a operator", function () {
verifyClassification(results.tuples[9], 1, ts.TokenClass.Operator);
});
it("checks for a whitespace", function() {
verifyClassification(results.tuples[10], 11, TypeScript.TokenClass.Whitespace);
it("checks for a whitespace", function () {
verifyClassification(results.tuples[10], 1, ts.TokenClass.Whitespace);
});
it("checks for a number literal", function() {
verifyClassification(results.tuples[11], 12, TypeScript.TokenClass.NumberLiteral);
it("checks for a number literal", function () {
verifyClassification(results.tuples[11], 1, ts.TokenClass.NumberLiteral);
});
});
describe("test cases for colorizing multi-line string", function() {
it("classifies first line correctelly", function() {
var results = getClassifications("'line1\\\n", TypeScript.LexState.Start);
describe("test cases for colorizing multi-line string", function () {
it("classifies first line correctelly", function () {
var results = getClassifications("'line1\\", ts.EndOfLineState.Start);
assert.equal(results.tuples.length, 1);
verifyClassification(results.tuples[0], 8, TypeScript.TokenClass.StringLiteral);
assert.equal(results.finalLexState, TypeScript.LexState.InMultilineSingleQuoteString);
verifyClassification(results.tuples[0], 7, ts.TokenClass.StringLiteral);
assert.equal(results.finalEndOfLineState, ts.EndOfLineState.InSingleQuoteStringLiteral);
});
it("classifies second line correctelly", function() {
var results = getClassifications("\\\n", TypeScript.LexState.InMultilineSingleQuoteString);
it("classifies second line correctelly", function () {
var results = getClassifications("\\", ts.EndOfLineState.InDoubleQuoteStringLiteral);
assert.equal(results.tuples.length, 1);
verifyClassification(results.tuples[0], 2, TypeScript.TokenClass.StringLiteral);
assert.equal(results.finalLexState, TypeScript.LexState.InMultilineSingleQuoteString);
verifyClassification(results.tuples[0], 1, ts.TokenClass.StringLiteral);
assert.equal(results.finalEndOfLineState, ts.EndOfLineState.InDoubleQuoteStringLiteral);
});
it("classifies third line correctelly", function() {
var results = getClassifications("'", TypeScript.LexState.InMultilineSingleQuoteString);
it("classifies third line correctelly", function () {
var results = getClassifications("'", ts.EndOfLineState.InSingleQuoteStringLiteral);
assert.equal(results.tuples.length, 1);
verifyClassification(results.tuples[0], 1, TypeScript.TokenClass.StringLiteral);
assert.equal(results.finalLexState, TypeScript.LexState.Start);
verifyClassification(results.tuples[0], 1, ts.TokenClass.StringLiteral);
assert.equal(results.finalEndOfLineState, ts.EndOfLineState.Start);
});
});
});