Skip to content

Commit 3fcd33e

Browse files
mhegazymhegazy
committed
Enable clorizer unit tests
1 parent e515ca9 commit 3fcd33e

4 files changed

Lines changed: 111 additions & 103 deletions

File tree

‎src/harness/harnessLanguageService.ts‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -271,6 +271,11 @@ module Harness.LanguageService {
271271
return this.ls;
272272
}
273273

274+
/** Return a new instance of the classifier service shim */
275+
public getClassifier(): ts.ClassifierShim {
276+
return new TypeScript.Services.TypeScriptServicesFactory().createClassifierShim(this);
277+
}
278+
274279
/** Parse file given its source text */
275280
public parseSourceText(fileName: string, sourceText: TypeScript.IScriptSnapshot): TypeScript.SourceUnitSyntax {
276281
return TypeScript.Parser.parse(fileName, TypeScript.SimpleText.fromScriptSnapshot(sourceText), ts.ScriptTarget.ES5, TypeScript.isDTSFile(fileName)).sourceUnit();

‎src/harness/runner.ts‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -99,6 +99,9 @@ if (runners.length === 0) {
9999
//// language services
100100
runners.push(new FourslashRunner());
101101
//runners.push(new GeneratedFourslashRunner());
102+
103+
// unittests
104+
runners.push(new UnitTestRunner(UnittestTestType.Services));
102105
}
103106

104107
sys.newLine = '\r\n';

‎src/harness/unittestrunner.ts‎

Lines changed: 7 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ enum UnittestTestType {
88
}
99

1010
class UnitTestRunner extends RunnerBase {
11-
constructor(public testType?: UnittestTestType) {
11+
constructor(public testType: UnittestTestType) {
1212
super();
1313
}
1414

@@ -20,6 +20,9 @@ class UnitTestRunner extends RunnerBase {
2020
case UnittestTestType.LanguageService:
2121
this.tests = this.enumerateFiles('tests/cases/unittests/ls');
2222
break;
23+
case UnittestTestType.Services:
24+
this.tests = this.enumerateFiles('tests/cases/unittests/services', /colorization.ts/);
25+
break;
2326
default:
2427
if (this.tests.length === 0) {
2528
throw new Error('Unsupported test cases: ' + this.testType);
@@ -38,7 +41,7 @@ class UnitTestRunner extends RunnerBase {
3841
});
3942
harnessCompiler.addInputFiles(toBeAdded);
4043
harnessCompiler.setCompilerOptions({ noResolve: true });
41-
44+
4245
var stdout = new Harness.Compiler.EmitterIOHost();
4346
var emitDiagnostics = harnessCompiler.emitAll(stdout);
4447
var results = stdout.toArray();
@@ -59,7 +62,8 @@ class UnitTestRunner extends RunnerBase {
5962
before: before,
6063
after: after,
6164
Harness: Harness,
62-
IO: Harness.IO
65+
IO: Harness.IO,
66+
ts:ts
6367
// FourSlash: FourSlash
6468
};
6569
}

‎tests/cases/unittests/services/colorization.ts‎

Lines changed: 96 additions & 100 deletions
Original file line numberDiff line numberDiff line change
@@ -1,198 +1,194 @@
1-
///<reference path='_project.ts'/>
2-
3-
interface Classification {
1+
interface Classification {
42
length: number;
5-
class2: TypeScript.TokenClass;
3+
class: ts.TokenClass;
64
}
75

86
interface ClassiferResult {
97
tuples: Classification[];
10-
finalLexState: TypeScript.LexState;
8+
finalEndOfLineState: ts.EndOfLineState;
119
}
1210

1311
var TokenClassNames = {};
14-
TokenClassNames[TypeScript.TokenClass.Punctuation] = "Punctuation";
15-
TokenClassNames[TypeScript.TokenClass.Keyword] = "Keyword";
16-
TokenClassNames[TypeScript.TokenClass.Operator] = "Operator";
17-
TokenClassNames[TypeScript.TokenClass.Comment] = "Comment";
18-
TokenClassNames[TypeScript.TokenClass.Whitespace] = "Whitespace";
19-
TokenClassNames[TypeScript.TokenClass.Identifier] = "Identifier";
20-
TokenClassNames[TypeScript.TokenClass.NumberLiteral] = "NumberLiteral";
21-
TokenClassNames[TypeScript.TokenClass.StringLiteral] = "StringLiteral";
22-
TokenClassNames[TypeScript.TokenClass.RegExpLiteral] = "RegExpLiteral";
23-
24-
25-
describe('Colorization', function() {
26-
var mytypescriptLS = new Harness.TypeScriptLS();
27-
var myls = mytypescriptLS.getLanguageService();
28-
29-
var myclassifier = new Services.ClassifierShim(myls.host);
30-
31-
function getClassifications(code: string, initialLexState?: TypeScript.LexState = TypeScript.LexState.Start): ClassiferResult {
32-
var classResult = myclassifier.getClassificationsForLine(code, initialLexState).split('\n');
12+
TokenClassNames[ts.TokenClass.Punctuation] = "Punctuation";
13+
TokenClassNames[ts.TokenClass.Keyword] = "Keyword";
14+
TokenClassNames[ts.TokenClass.Operator] = "Operator";
15+
TokenClassNames[ts.TokenClass.Comment] = "Comment";
16+
TokenClassNames[ts.TokenClass.Whitespace] = "Whitespace";
17+
TokenClassNames[ts.TokenClass.Identifier] = "Identifier";
18+
TokenClassNames[ts.TokenClass.NumberLiteral] = "NumberLiteral";
19+
TokenClassNames[ts.TokenClass.StringLiteral] = "StringLiteral";
20+
TokenClassNames[ts.TokenClass.RegExpLiteral] = "RegExpLiteral";
21+
22+
23+
describe('Colorization', function () {
24+
var mytypescriptLS = new Harness.LanguageService.TypeScriptLS();
25+
var myclassifier = mytypescriptLS.getClassifier();
26+
27+
function getClassifications(code: string, initialEndOfLineState: ts.EndOfLineState = ts.EndOfLineState.Start): ClassiferResult {
28+
var classResult = myclassifier.getClassificationsForLine(code, initialEndOfLineState).split('\n');
3329
var tuples: Classification[] = [];
3430
var i = 0;
3531

3632
for (; i < classResult.length - 1; i += 2) {
3733
tuples[i / 2] = {
3834
length: parseInt(classResult[i]),
39-
class2: parseInt(classResult[i + 1])
35+
class: parseInt(classResult[i + 1])
4036
};
4137
}
42-
var finalLexState = classResult[classResult.length - 1];
38+
var finalEndOfLineState = classResult[classResult.length - 1];
4339

4440
return {
4541
tuples: tuples,
46-
finalLexState: parseInt(finalLexState)
42+
finalEndOfLineState: parseInt(finalEndOfLineState)
4743
};
4844
}
4945

5046
function verifyClassification(classification: Classification, expectedLength: number, expectedClass: number) {
51-
assert.notNull(classification);
52-
assert.is(classification.length === expectedLength, "Classification length does not match expected. Expected: " + expectedLength + ", Actual: " + classification.length);
53-
assert.is(classification.class2 === expectedClass, "Classification class does not match expected. Expected: " + TokenClassNames[expectedClass] + ", Actual: " + TokenClassNames[classification.class2]);
47+
assert.isNotNull(classification);
48+
assert.equal(classification.length, expectedLength, "Classification length does not match expected. Expected: " + expectedLength + ", Actual: " + classification.length);
49+
assert.equal(classification.class, expectedClass, "Classification class does not match expected. Expected: " + TokenClassNames[expectedClass] + ", Actual: " + TokenClassNames[classification.class]);
5450
}
55-
56-
describe("test cases for colorization", function() {
51+
52+
describe("test cases for colorization", function () {
5753
var results = getClassifications('var x:string = "foo"; //Hello');
5854

59-
it("checks for a keyword", function() {
60-
verifyClassification(results.tuples[0], 3, TypeScript.TokenClass.Keyword);
55+
it("checks for a keyword", function () {
56+
verifyClassification(results.tuples[0], 3, ts.TokenClass.Keyword);
6157
});
6258

63-
it("checks for a whitespace", function() {
64-
verifyClassification(results.tuples[1], 4, TypeScript.TokenClass.Whitespace);
59+
it("checks for a whitespace", function () {
60+
verifyClassification(results.tuples[1], 1, ts.TokenClass.Whitespace);
6561
});
6662

67-
it("checks for a identifier", function() {
68-
verifyClassification(results.tuples[2], 5, TypeScript.TokenClass.Identifier);
63+
it("checks for a identifier", function () {
64+
verifyClassification(results.tuples[2], 1, ts.TokenClass.Identifier);
6965
});
7066

71-
it("checks for an punctuation", function() {
72-
verifyClassification(results.tuples[3], 6, TypeScript.TokenClass.Punctuation);
67+
it("checks for an punctuation", function () {
68+
verifyClassification(results.tuples[3], 1, ts.TokenClass.Punctuation);
7369
});
74-
75-
it("checks for a operator", function() {
76-
verifyClassification(results.tuples[6], 14, TypeScript.TokenClass.Operator);
70+
71+
it("checks for a operator", function () {
72+
verifyClassification(results.tuples[6], 1, ts.TokenClass.Operator);
7773
});
7874

79-
it("checks for a string literal", function() {
80-
verifyClassification(results.tuples[8], 20, TypeScript.TokenClass.StringLiteral);
75+
it("checks for a string literal", function () {
76+
verifyClassification(results.tuples[8], 5, ts.TokenClass.StringLiteral);
8177
});
8278

83-
it("checks for a comment", function() {
84-
verifyClassification(results.tuples[11], 29, TypeScript.TokenClass.Comment);
79+
it("checks for a comment", function () {
80+
verifyClassification(results.tuples[11], 7, ts.TokenClass.Comment);
8581
});
8682
});
8783

88-
describe("test comment colorization after a divide operator", function() {
84+
describe("test comment colorization after a divide operator", function () {
8985
var results = getClassifications('1 / 1 // comment');
9086

91-
it("checks for a number literal", function() {
92-
verifyClassification(results.tuples[0], 1, TypeScript.TokenClass.NumberLiteral);
87+
it("checks for a number literal", function () {
88+
verifyClassification(results.tuples[0], 1, ts.TokenClass.NumberLiteral);
9389
});
9490

95-
it("checks for a whitespace", function() {
96-
verifyClassification(results.tuples[1], 2, TypeScript.TokenClass.Whitespace);
91+
it("checks for a whitespace", function () {
92+
verifyClassification(results.tuples[1], 1, ts.TokenClass.Whitespace);
9793
});
9894

99-
it("checks for a operator", function() {
100-
verifyClassification(results.tuples[2], 3, TypeScript.TokenClass.Operator);
95+
it("checks for a operator", function () {
96+
verifyClassification(results.tuples[2], 1, ts.TokenClass.Operator);
10197
});
10298

103-
it("checks for a whitespace", function() {
104-
verifyClassification(results.tuples[3], 4, TypeScript.TokenClass.Whitespace);
99+
it("checks for a whitespace", function () {
100+
verifyClassification(results.tuples[3], 1, ts.TokenClass.Whitespace);
105101
});
106102

107-
it("checks for a number literal", function() {
108-
verifyClassification(results.tuples[4], 5, TypeScript.TokenClass.NumberLiteral);
103+
it("checks for a number literal", function () {
104+
verifyClassification(results.tuples[4], 1, ts.TokenClass.NumberLiteral);
109105
});
110106

111-
it("checks for a whitespace", function() {
112-
verifyClassification(results.tuples[5], 6, TypeScript.TokenClass.Whitespace);
107+
it("checks for a whitespace", function () {
108+
verifyClassification(results.tuples[5], 1, ts.TokenClass.Whitespace);
113109
});
114110

115-
it("checks for a comment", function() {
116-
verifyClassification(results.tuples[6], 16, TypeScript.TokenClass.Comment);
111+
it("checks for a comment", function () {
112+
verifyClassification(results.tuples[6], 10, ts.TokenClass.Comment);
117113
});
118114
});
119115

120-
describe("test literal colorization after a divide operator", function() {
116+
describe("test literal colorization after a divide operator", function () {
121117
var results = getClassifications('1 / 2, 1 / 2');
122118

123-
it("checks for a number literal", function() {
124-
verifyClassification(results.tuples[0], 1, TypeScript.TokenClass.NumberLiteral);
119+
it("checks for a number literal", function () {
120+
verifyClassification(results.tuples[0], 1, ts.TokenClass.NumberLiteral);
125121
});
126122

127-
it("checks for a whitespace", function() {
128-
verifyClassification(results.tuples[1], 2, TypeScript.TokenClass.Whitespace);
123+
it("checks for a whitespace", function () {
124+
verifyClassification(results.tuples[1], 1, ts.TokenClass.Whitespace);
129125
});
130126

131-
it("checks for a operator", function() {
132-
verifyClassification(results.tuples[2], 3, TypeScript.TokenClass.Operator);
127+
it("checks for a operator", function () {
128+
verifyClassification(results.tuples[2], 1, ts.TokenClass.Operator);
133129
});
134130

135-
it("checks for a whitespace", function() {
136-
verifyClassification(results.tuples[3], 4, TypeScript.TokenClass.Whitespace);
131+
it("checks for a whitespace", function () {
132+
verifyClassification(results.tuples[3], 1, ts.TokenClass.Whitespace);
137133
});
138134

139-
it("checks for a number literal", function() {
140-
verifyClassification(results.tuples[4], 5, TypeScript.TokenClass.NumberLiteral);
135+
it("checks for a number literal", function () {
136+
verifyClassification(results.tuples[4], 1, ts.TokenClass.NumberLiteral);
141137
});
142138

143-
it("checks for a operator", function() {
144-
verifyClassification(results.tuples[5], 6, TypeScript.TokenClass.Operator);
139+
it("checks for a operator", function () {
140+
verifyClassification(results.tuples[5], 1, ts.TokenClass.Operator);
145141
});
146142

147-
it("checks for a whitespace", function() {
148-
verifyClassification(results.tuples[6], 7, TypeScript.TokenClass.Whitespace);
143+
it("checks for a whitespace", function () {
144+
verifyClassification(results.tuples[6], 1, ts.TokenClass.Whitespace);
149145
});
150146

151-
it("checks for a number literal", function() {
152-
verifyClassification(results.tuples[7], 8, TypeScript.TokenClass.NumberLiteral);
147+
it("checks for a number literal", function () {
148+
verifyClassification(results.tuples[7], 1, ts.TokenClass.NumberLiteral);
153149
});
154150

155-
it("checks for a whitespace", function() {
156-
verifyClassification(results.tuples[8], 9, TypeScript.TokenClass.Whitespace);
151+
it("checks for a whitespace", function () {
152+
verifyClassification(results.tuples[8], 1, ts.TokenClass.Whitespace);
157153
});
158154

159-
it("checks for a operator", function() {
160-
verifyClassification(results.tuples[9], 10, TypeScript.TokenClass.Operator);
155+
it("checks for a operator", function () {
156+
verifyClassification(results.tuples[9], 1, ts.TokenClass.Operator);
161157
});
162158

163-
it("checks for a whitespace", function() {
164-
verifyClassification(results.tuples[10], 11, TypeScript.TokenClass.Whitespace);
159+
it("checks for a whitespace", function () {
160+
verifyClassification(results.tuples[10], 1, ts.TokenClass.Whitespace);
165161
});
166162

167-
it("checks for a number literal", function() {
168-
verifyClassification(results.tuples[11], 12, TypeScript.TokenClass.NumberLiteral);
163+
it("checks for a number literal", function () {
164+
verifyClassification(results.tuples[11], 1, ts.TokenClass.NumberLiteral);
169165
});
170166

171167
});
172168

173-
describe("test cases for colorizing multi-line string", function() {
174-
it("classifies first line correctelly", function() {
175-
var results = getClassifications("'line1\\\n", TypeScript.LexState.Start);
169+
describe("test cases for colorizing multi-line string", function () {
170+
it("classifies first line correctelly", function () {
171+
var results = getClassifications("'line1\\", ts.EndOfLineState.Start);
176172

177173
assert.equal(results.tuples.length, 1);
178-
verifyClassification(results.tuples[0], 8, TypeScript.TokenClass.StringLiteral);
179-
assert.equal(results.finalLexState, TypeScript.LexState.InMultilineSingleQuoteString);
174+
verifyClassification(results.tuples[0], 7, ts.TokenClass.StringLiteral);
175+
assert.equal(results.finalEndOfLineState, ts.EndOfLineState.InSingleQuoteStringLiteral);
180176
});
181177

182-
it("classifies second line correctelly", function() {
183-
var results = getClassifications("\\\n", TypeScript.LexState.InMultilineSingleQuoteString);
178+
it("classifies second line correctelly", function () {
179+
var results = getClassifications("\\", ts.EndOfLineState.InDoubleQuoteStringLiteral);
184180

185181
assert.equal(results.tuples.length, 1);
186-
verifyClassification(results.tuples[0], 2, TypeScript.TokenClass.StringLiteral);
187-
assert.equal(results.finalLexState, TypeScript.LexState.InMultilineSingleQuoteString);
182+
verifyClassification(results.tuples[0], 1, ts.TokenClass.StringLiteral);
183+
assert.equal(results.finalEndOfLineState, ts.EndOfLineState.InDoubleQuoteStringLiteral);
188184
});
189185

190-
it("classifies third line correctelly", function() {
191-
var results = getClassifications("'", TypeScript.LexState.InMultilineSingleQuoteString);
186+
it("classifies third line correctelly", function () {
187+
var results = getClassifications("'", ts.EndOfLineState.InSingleQuoteStringLiteral);
192188

193189
assert.equal(results.tuples.length, 1);
194-
verifyClassification(results.tuples[0], 1, TypeScript.TokenClass.StringLiteral);
195-
assert.equal(results.finalLexState, TypeScript.LexState.Start);
190+
verifyClassification(results.tuples[0], 1, ts.TokenClass.StringLiteral);
191+
assert.equal(results.finalEndOfLineState, ts.EndOfLineState.Start);
196192
});
197193
});
198194
});

0 commit comments

Comments
 (0)