mirror of
https://github.com/microsoft/vscode.git
synced 2026-05-02 22:41:31 +01:00
[css] move to extension
This commit is contained in:
Martin Aeschlimann
64
extensions/css/server/src/test/codeActions.test.ts
Normal file
64
extensions/css/server/src/test/codeActions.test.ts
Normal file
@@ -0,0 +1,64 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
'use strict';
|
||||
|
||||
import * as assert from 'assert';
|
||||
import {Parser} from '../parser/cssParser';
|
||||
import {CSSCompletion} from '../services/cssCompletion';
|
||||
import {CSSCodeActions} from '../services/cssCodeActions';
|
||||
import {CSSValidation} from '../services/cssValidation';
|
||||
|
||||
import {CompletionList, TextDocument, TextEdit, Position, Range, Command} from 'vscode-languageserver';
|
||||
import {applyEdits} from './textEditSupport';
|
||||
|
||||
suite('CSS - Code Actions', () => {
|
||||
let testCodeActions = function (value: string, tokenBefore: string): Thenable<{ commands: Command[]; document: TextDocument; }> {
|
||||
let document = TextDocument.create('test://test/test.css', 'css', 0, value);
|
||||
let styleSheet = new Parser().parseStylesheet(document);
|
||||
let offset = value.indexOf(tokenBefore);
|
||||
let startPosition = document.positionAt(offset);
|
||||
let endPosition = document.positionAt(offset + tokenBefore.length);
|
||||
let range = Range.create(startPosition, endPosition);
|
||||
let validation = new CSSValidation();
|
||||
validation.configure({ validate: true });
|
||||
|
||||
return validation.doValidation(document, styleSheet).then(diagnostics => {
|
||||
return new CSSCodeActions().doCodeActions(document, range, { diagnostics }, styleSheet).then(commands => {
|
||||
return { commands, document };
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
let assertCodeAction = function (commands: Command[], document: TextDocument, expected: { title: string; content: string; }[]) {
|
||||
let labels = commands.map(command => command.title);
|
||||
|
||||
for (let exp of expected) {
|
||||
let index = labels.indexOf(exp.title);
|
||||
assert.ok(index !== -1, 'Quick fix not found: ' + exp.title + ' , found:' + labels.join(','));
|
||||
let command = commands[index];
|
||||
assert.equal(applyEdits(document, <TextEdit[]>command.arguments[2]), exp.content);
|
||||
assert.equal(command.arguments[0], document.uri);
|
||||
assert.equal(command.arguments[1], document.version);
|
||||
}
|
||||
};
|
||||
|
||||
test('Unknown Properties', function (testDone): any {
|
||||
Promise.all([
|
||||
testCodeActions('body { /*here*/displai: inline }', '/*here*/').then((result) => {
|
||||
assertCodeAction(result.commands, result.document, [
|
||||
{ title: 'Rename to \'display\'', content: 'body { /*here*/display: inline }' }
|
||||
])
|
||||
}),
|
||||
|
||||
testCodeActions('body { /*here*/background-colar: red }', '/*here*/').then((result) => {
|
||||
assertCodeAction(result.commands, result.document, [
|
||||
{ title: 'Rename to \'background-color\'', content: 'body { /*here*/background-color: red }' },
|
||||
{ title: 'Rename to \'background-clip\'', content: 'body { /*here*/background-clip: red }' },
|
||||
{ title: 'Rename to \'background-image\'', content: 'body { /*here*/background-image: red }' }
|
||||
])
|
||||
})
|
||||
]).then(() => testDone(), (error) => testDone(error));
|
||||
});
|
||||
})
|
||||
230
extensions/css/server/src/test/completion.test.ts
Normal file
230
extensions/css/server/src/test/completion.test.ts
Normal file
@@ -0,0 +1,230 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
'use strict';
|
||||
|
||||
import * as assert from 'assert';
|
||||
import {Parser} from '../parser/cssParser';
|
||||
import {CSSCompletion} from '../services/cssCompletion';
|
||||
|
||||
import {CompletionList, TextDocument, TextEdit, Position, CompletionItemKind} from 'vscode-languageserver';
|
||||
import {applyEdits} from './textEditSupport';
|
||||
|
||||
suite('CSS - Completion', () => {
|
||||
|
||||
interface ItemDescription {
|
||||
label: string;
|
||||
documentation?: string;
|
||||
kind?: CompletionItemKind;
|
||||
resultText?: string;
|
||||
}
|
||||
|
||||
let assertCompletion = function (completions: CompletionList, expected: ItemDescription, document?: TextDocument) {
|
||||
let matches = completions.items.filter(completion => {
|
||||
return completion.label === expected.label;
|
||||
});
|
||||
assert.equal(matches.length, 1, expected.label + " should only existing once: Actual: " + completions.items.map(c => c.label).join(', '));
|
||||
if (expected.documentation) {
|
||||
assert.equal(matches[0].documentation, expected.documentation);
|
||||
}
|
||||
if (expected.kind) {
|
||||
assert.equal(matches[0].kind, expected.kind);
|
||||
}
|
||||
if (document && expected.resultText) {
|
||||
assert.equal(applyEdits(document, [matches[0].textEdit]), expected.resultText);
|
||||
}
|
||||
};
|
||||
|
||||
let testCompletionFor = function (value: string, stringBefore: string, expected: { count?: number, items?: ItemDescription[] }): Thenable<CompletionList> {
|
||||
let idx = stringBefore ? value.indexOf(stringBefore) + stringBefore.length : 0;
|
||||
|
||||
let completionProvider = new CSSCompletion();
|
||||
|
||||
let document = TextDocument.create('test://test/test.css', 'css', 0, value);
|
||||
let position = Position.create(0, idx);
|
||||
let jsonDoc = new Parser().parseStylesheet(document);
|
||||
let list = completionProvider.doComplete(document, position, jsonDoc);
|
||||
if (expected.count) {
|
||||
assert.equal(list.items, expected.count);
|
||||
}
|
||||
if (expected.items) {
|
||||
for (let item of expected.items) {
|
||||
assertCompletion(list, item, document);
|
||||
}
|
||||
}
|
||||
return Promise.resolve(null);
|
||||
};
|
||||
|
||||
test('sylesheet', function (testDone): any {
|
||||
Promise.all([
|
||||
testCompletionFor(' ', null, {
|
||||
items: [
|
||||
{ label: '@import' },
|
||||
{ label: '@keyframes' },
|
||||
{ label: 'div' }
|
||||
]
|
||||
}),
|
||||
testCompletionFor(' body {', null, {
|
||||
items: [
|
||||
{ label: '@import' },
|
||||
{ label: '@keyframes' },
|
||||
{ label: 'html' }
|
||||
]
|
||||
}),
|
||||
testCompletionFor('@import url("something.css");', '@', {
|
||||
count: 0
|
||||
})
|
||||
]).then(() => testDone(), (error) => testDone(error));
|
||||
});
|
||||
test('properties', function (testDone): any {
|
||||
Promise.all([
|
||||
testCompletionFor('body {', '{', {
|
||||
items: [
|
||||
{ label: 'display' },
|
||||
{ label: 'background' }
|
||||
]
|
||||
}),
|
||||
testCompletionFor('body { ver', 'ver', {
|
||||
items: [
|
||||
{ label: 'vertical-align' }
|
||||
]
|
||||
}),
|
||||
testCompletionFor('body { vertical-align', 'vertical-ali', {
|
||||
items: [
|
||||
{ label: 'vertical-align' }
|
||||
]
|
||||
}),
|
||||
testCompletionFor('body { vertical-align', 'vertical-align', {
|
||||
items: [
|
||||
{ label: 'vertical-align' }
|
||||
]
|
||||
}),
|
||||
testCompletionFor('body { vertical-align: bottom;}', 'vertical-align', {
|
||||
items: [
|
||||
{ label: 'vertical-align' }
|
||||
]
|
||||
}),
|
||||
testCompletionFor('body { trans ', 'trans', {
|
||||
items: [
|
||||
{ label: 'transition' }
|
||||
]
|
||||
})
|
||||
]).then(() => testDone(), (error) => testDone(error));
|
||||
});
|
||||
test('values', function (testDone): any {
|
||||
Promise.all([
|
||||
testCompletionFor('body { vertical-align: bottom;}', 'vertical-align:', {
|
||||
items: [
|
||||
{ label: 'bottom' },
|
||||
{ label: '0cm' }
|
||||
]
|
||||
}),
|
||||
testCompletionFor('body { vertical-align: bottom;}', 'vertical-align: ', {
|
||||
items: [
|
||||
{ label: 'bottom' },
|
||||
{ label: '0cm' }
|
||||
]
|
||||
}),
|
||||
testCompletionFor('body { vertical-align: bott', 'bott', {
|
||||
items: [
|
||||
{ label: 'bottom' }
|
||||
]
|
||||
}),
|
||||
testCompletionFor('body { vertical-align: bottom }', 'bott', {
|
||||
items: [
|
||||
{ label: 'bottom' }
|
||||
]
|
||||
}),
|
||||
testCompletionFor('body { vertical-align: bottom }', 'bottom', {
|
||||
items: [
|
||||
{ label: 'bottom' }
|
||||
]
|
||||
}),
|
||||
testCompletionFor('body { vertical-align: bottom; }', 'bottom', {
|
||||
items: [
|
||||
{ label: 'bottom' }
|
||||
]
|
||||
}),
|
||||
testCompletionFor('body { vertical-align: bottom; }', 'bottom;', {
|
||||
count: 0
|
||||
}),
|
||||
testCompletionFor('body { vertical-align: bottom; }', 'bottom; ', {
|
||||
items: [
|
||||
{ label: 'display' }
|
||||
]
|
||||
})
|
||||
]).then(() => testDone(), (error) => testDone(error));
|
||||
});
|
||||
test('units', function (testDone): any {
|
||||
Promise.all([
|
||||
testCompletionFor('body { vertical-align: 9 }', '9', {
|
||||
items: [
|
||||
{ label: '9cm' }
|
||||
]
|
||||
}),
|
||||
testCompletionFor('body { vertical-align: 1.2 }', '1.2', {
|
||||
items: [
|
||||
{ label: '1.2em' }
|
||||
]
|
||||
}),
|
||||
testCompletionFor('body { vertical-align: 10 }', '1', {
|
||||
items: [
|
||||
{ label: '1cm' }
|
||||
]
|
||||
}),
|
||||
testCompletionFor('body { vertical-align: 10c }', '10c', {
|
||||
items: [
|
||||
{ label: '10cm' }
|
||||
]
|
||||
})
|
||||
]).then(() => testDone(), (error) => testDone(error));
|
||||
});
|
||||
test('unknown', function (testDone): any {
|
||||
Promise.all([
|
||||
testCompletionFor('body { notexisting: ;}', 'notexisting: ', {
|
||||
count: 0
|
||||
}),
|
||||
testCompletionFor('.foo { unknown: foo; } .bar { unknown: }', '.bar { unknown:', {
|
||||
items: [
|
||||
{ label: 'foo', kind: CompletionItemKind.Value }
|
||||
]
|
||||
})
|
||||
]).then(() => testDone(), (error) => testDone(error));
|
||||
});
|
||||
test('colors', function (testDone): any {
|
||||
Promise.all([
|
||||
testCompletionFor('body { border-right: ', 'right: ', {
|
||||
items: [
|
||||
{ label: 'cyan' },
|
||||
{ label: 'dotted' },
|
||||
{ label: '0em' }
|
||||
]
|
||||
}),
|
||||
testCompletionFor('body { border-right: cyan dotted 2em ', 'cyan', {
|
||||
items: [
|
||||
{ label: 'cyan' },
|
||||
{ label: 'darkcyan' }
|
||||
]
|
||||
}),
|
||||
testCompletionFor('body { border-right: dotted 2em ', '2em ', {
|
||||
items: [
|
||||
{ label: 'cyan' }
|
||||
]
|
||||
}),
|
||||
testCompletionFor('.foo { background-color: #123456; } .bar { background-color: }', '.bar { background-color:', {
|
||||
items: [
|
||||
{ label: '#123456', kind: CompletionItemKind.Color }
|
||||
]
|
||||
}),
|
||||
testCompletionFor('.foo { background-color: r', 'background-color: r', {
|
||||
items: [
|
||||
{ label: 'rgb', kind: CompletionItemKind.Function },
|
||||
{ label: 'rgba', kind: CompletionItemKind.Function },
|
||||
{ label: 'red', kind: CompletionItemKind.Color }
|
||||
]
|
||||
})
|
||||
]).then(() => testDone(), (error) => testDone(error));
|
||||
});
|
||||
});
|
||||
|
||||
60
extensions/css/server/src/test/languageFacts.test.ts
Normal file
60
extensions/css/server/src/test/languageFacts.test.ts
Normal file
@@ -0,0 +1,60 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
'use strict';
|
||||
|
||||
import * as assert from 'assert';
|
||||
import * as languageFacts from '../services/languageFacts';
|
||||
import {Parser} from '../parser/cssParser';
|
||||
import * as nodes from '../parser/cssNodes';
|
||||
import {TextDocument} from 'vscode-languageserver';
|
||||
|
||||
export function assertColor(parser: Parser, text: string, selection: string, isColor: boolean): void {
|
||||
let document = TextDocument.create('test://test/test.css', 'css', 0, text);
|
||||
let stylesheet = parser.parseStylesheet(document);
|
||||
assert.equal(0, nodes.ParseErrorCollector.entries(stylesheet).length, 'compile errors');
|
||||
|
||||
let node = nodes.getNodeAtOffset(stylesheet, text.indexOf(selection));
|
||||
|
||||
assert.equal(isColor, languageFacts.isColorValue(node));
|
||||
}
|
||||
|
||||
suite('CSS - Language Facts', () => {
|
||||
|
||||
test('properties', function () {
|
||||
let properties = languageFacts.getProperties();
|
||||
let alignLast = properties['text-align-last'];
|
||||
|
||||
assert.ok(alignLast !== null);
|
||||
assert.equal(alignLast.name, 'text-align-last');
|
||||
let b = alignLast.browsers;
|
||||
assert.equal(b['FF'], '12');
|
||||
assert.equal(b['IE'], '5');
|
||||
assert.equal(b['E'], '');
|
||||
assert.equal(b['C'], void 0);
|
||||
assert.equal(b['count'], 3);
|
||||
|
||||
assert.equal(languageFacts.getBrowserLabel(alignLast.browsers), 'Edge, Firefox 12, IE 5');
|
||||
|
||||
let r = alignLast.restrictions;
|
||||
|
||||
assert.equal(r.length, 1);
|
||||
assert.equal(r[0], 'enum');
|
||||
|
||||
let v = alignLast.values;
|
||||
assert.equal(v.length, 5);
|
||||
assert.equal(v[0].name, 'auto');
|
||||
assert.equal(v[0].browsers.all, true);
|
||||
assert.equal(v[0].browsers.count, Number.MAX_VALUE);
|
||||
});
|
||||
|
||||
test('is color', function () {
|
||||
let parser = new Parser();
|
||||
assertColor(parser, '#main { color: red }', 'red', true);
|
||||
assertColor(parser, '#main { color: #231 }', '#231', true);
|
||||
assertColor(parser, '#main { red: 1 }', 'red', false);
|
||||
assertColor(parser, '#red { foo: 1 }', 'red', false);
|
||||
});
|
||||
});
|
||||
|
||||
129
extensions/css/server/src/test/lint.test.ts
Normal file
129
extensions/css/server/src/test/lint.test.ts
Normal file
@@ -0,0 +1,129 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
'use strict';
|
||||
|
||||
import * as assert from 'assert';
|
||||
import * as nodes from '../parser/cssNodes';
|
||||
import {Parser} from '../parser/cssParser';
|
||||
import {LintVisitor} from '../services/lint';
|
||||
import {Rule, Rules} from '../services/lintRules';
|
||||
import {TextDocument} from 'vscode-languageserver';
|
||||
|
||||
export function assertEntries(node: nodes.Node, rules: nodes.IRule[]): void {
|
||||
|
||||
let visitor = new LintVisitor();
|
||||
node.accept(visitor);
|
||||
|
||||
let entries = visitor.getEntries(nodes.Level.Error | nodes.Level.Warning | nodes.Level.Ignore);
|
||||
assert.equal(entries.length, rules.length);
|
||||
|
||||
for (let entry of entries) {
|
||||
let idx = rules.indexOf(entry.getRule());
|
||||
rules.splice(idx, 1);
|
||||
}
|
||||
assert.equal(rules.length, 0);
|
||||
}
|
||||
|
||||
function assertStyleSheet(input: string, ...rules: Rule[]): void {
|
||||
let p = new Parser();
|
||||
let document = TextDocument.create('test://test/test.css', 'css', 0, input);
|
||||
let node = p.parseStylesheet(document);
|
||||
|
||||
assertEntries(node, rules);
|
||||
}
|
||||
|
||||
function assertRuleSet(input: string, ...rules: Rule[]): void {
|
||||
let p = new Parser();
|
||||
let node = p.internalParse(input, p._parseRuleset);
|
||||
assertEntries(node, rules);
|
||||
}
|
||||
|
||||
|
||||
function assertFontFace(input: string, ...rules: Rule[]): void {
|
||||
let p = new Parser();
|
||||
let node = p.internalParse(input, p._parseFontFace);
|
||||
assertEntries(node, rules);
|
||||
}
|
||||
|
||||
suite('CSS - Lint', () => {
|
||||
|
||||
test('universal selector, empty rule', function () {
|
||||
assertRuleSet('* { color: perty }', Rules.UniversalSelector);
|
||||
assertRuleSet('*, div { color: perty }', Rules.UniversalSelector);
|
||||
assertRuleSet('div, * { color: perty }', Rules.UniversalSelector);
|
||||
assertRuleSet('div > * { color: perty }', Rules.UniversalSelector);
|
||||
assertRuleSet('div + * { color: perty }', Rules.UniversalSelector);
|
||||
});
|
||||
|
||||
test('empty ruleset', function () {
|
||||
assertRuleSet('selector {}', Rules.EmptyRuleSet);
|
||||
});
|
||||
|
||||
test('properies ignored due to inline ', function () {
|
||||
assertRuleSet('selector { display: inline; height: 100px; }', Rules.PropertyIgnoredDueToDisplay);
|
||||
assertRuleSet('selector { display: inline; width: 100px; }', Rules.PropertyIgnoredDueToDisplay);
|
||||
assertRuleSet('selector { display: inline; margin-top: 1em; }', Rules.PropertyIgnoredDueToDisplay);
|
||||
assertRuleSet('selector { display: inline; margin-bottom: 1em; }', Rules.PropertyIgnoredDueToDisplay);
|
||||
assertRuleSet('selector { display: inline; float: right; }', Rules.PropertyIgnoredDueToDisplay, Rules.AvoidFloat);
|
||||
assertRuleSet('selector { display: inline-block; float: right; }', Rules.PropertyIgnoredDueToDisplay, Rules.AvoidFloat);
|
||||
assertRuleSet('selector { display: block; vertical-align: center; }', Rules.PropertyIgnoredDueToDisplay);
|
||||
});
|
||||
|
||||
test('avoid !important', function () {
|
||||
assertRuleSet('selector { display: inline !important; }', Rules.AvoidImportant);
|
||||
});
|
||||
|
||||
test('avoid float', function () {
|
||||
assertRuleSet('selector { float: right; }', Rules.AvoidFloat);
|
||||
});
|
||||
|
||||
test('avoid id selectors', function () {
|
||||
assertRuleSet('#selector { display: inline; }', Rules.AvoidIdSelector);
|
||||
});
|
||||
|
||||
test('zero with unit', function () {
|
||||
// assertRuleSet('selector { width: 0px }', lint.Rules.ZeroWithUnit);
|
||||
assertRuleSet('selector { width: 0% }');
|
||||
});
|
||||
|
||||
test('duplicate declarations', function () {
|
||||
assertRuleSet('selector { color: perty; color: perty }', Rules.DuplicateDeclarations, Rules.DuplicateDeclarations);
|
||||
assertRuleSet('selector { color: -o-perty; color: perty }');
|
||||
});
|
||||
|
||||
test('unknown properties', function () {
|
||||
assertRuleSet('selector { -ms-property: "rest is missing" }', Rules.UnknownVendorSpecificProperty);
|
||||
assertRuleSet('selector { -moz-box-shadow: "rest is missing" }', Rules.UnknownVendorSpecificProperty, Rules.IncludeStandardPropertyWhenUsingVendorPrefix);
|
||||
assertRuleSet('selector { box-shadow: none }'); // no error
|
||||
assertRuleSet('selector { box-property: "rest is missing" }', Rules.UnknownProperty);
|
||||
|
||||
});
|
||||
|
||||
test('IE hacks', function () {
|
||||
assertRuleSet('selector { display: inline-block; *display: inline; }', Rules.IEStarHack);
|
||||
assertRuleSet('selector { background: #00f; /* all browsers including Mac IE */ *background: #f00; /* IE 7 and below */ _background: #f60; /* IE 6 and below */ }', Rules.IEStarHack, Rules.IEStarHack);
|
||||
});
|
||||
|
||||
test('vendor specific prefixes', function () {
|
||||
assertRuleSet('selector { -moz-animation: none }', Rules.AllVendorPrefixes, Rules.IncludeStandardPropertyWhenUsingVendorPrefix);
|
||||
assertRuleSet('selector { -moz-transform: none; transform: none }', Rules.AllVendorPrefixes);
|
||||
assertRuleSet('selector { transform: none; }');
|
||||
assertRuleSet('selector { -moz-transform: none; transform: none; -o-transform: none; -webkit-transform: none; -ms-transform: none; }');
|
||||
assertRuleSet('selector { --transform: none; }');
|
||||
});
|
||||
|
||||
test('font-face required properties', function () {
|
||||
assertFontFace('@font-face { }', Rules.RequiredPropertiesForFontFace);
|
||||
assertFontFace('@font-face { src: url(test.tff) }', Rules.RequiredPropertiesForFontFace);
|
||||
assertFontFace('@font-face { font-family: \'name\' }', Rules.RequiredPropertiesForFontFace);
|
||||
assertFontFace('@font-face { src: url(test.tff); font-family: \'name\' }'); // no error
|
||||
});
|
||||
|
||||
test('keyframes', function () {
|
||||
assertStyleSheet('@keyframes foo { }');
|
||||
assertStyleSheet('@keyframes foo { } @-moz-keyframes foo { }', Rules.AllVendorPrefixes);
|
||||
assertStyleSheet('@-moz-keyframes foo { }', Rules.AllVendorPrefixes, Rules.IncludeStandardPropertyWhenUsingVendorPrefix);
|
||||
});
|
||||
});
|
||||
227
extensions/css/server/src/test/navigation.test.ts
Normal file
227
extensions/css/server/src/test/navigation.test.ts
Normal file
@@ -0,0 +1,227 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
'use strict';
|
||||
|
||||
import * as assert from 'assert';
|
||||
import {Scope, GlobalScope, ScopeBuilder} from '../parser/cssSymbolScope';
|
||||
import * as nodes from '../parser/cssNodes';
|
||||
import {Parser} from '../parser/cssParser';
|
||||
import {CSSNavigation} from '../services/cssNavigation';
|
||||
|
||||
import {TextDocument, DocumentHighlightKind} from 'vscode-languageserver';
|
||||
|
||||
export function assertScopesAndSymbols(p: Parser, input: string, expected: string): void {
|
||||
let global = createScope(p, input);
|
||||
assert.equal(scopeToString(global), expected);
|
||||
}
|
||||
|
||||
export function assertHighlights(p: Parser, input: string, marker: string, expectedMatches: number, expectedWrites: number): void {
|
||||
let document = TextDocument.create('test://test/test.css', 'css', 0, input);
|
||||
|
||||
let stylesheet = p.parseStylesheet(document);
|
||||
assertNoErrors(stylesheet);
|
||||
|
||||
let index = input.indexOf(marker) + marker.length;
|
||||
let position = document.positionAt(index);
|
||||
|
||||
let highlights = new CSSNavigation().findDocumentHighlights(document, position, stylesheet);
|
||||
assert.equal(highlights.length, expectedMatches);
|
||||
|
||||
let nWrites = 0;
|
||||
for (let highlight of highlights) {
|
||||
if (highlight.kind === DocumentHighlightKind.Write) {
|
||||
nWrites++;
|
||||
}
|
||||
let range = highlight.range;
|
||||
let start = document.offsetAt(range.start), end = document.offsetAt(range.end);
|
||||
assert.equal(document.getText().substring(start, end), marker);
|
||||
}
|
||||
assert.equal(nWrites, expectedWrites);
|
||||
}
|
||||
|
||||
|
||||
export function assertSymbolsInScope(p: Parser, input: string, offset: number, ...selections: { name: string; type: nodes.ReferenceType }[]): void {
|
||||
|
||||
let global = createScope(p, input);
|
||||
|
||||
let scope = global.findScope(offset);
|
||||
|
||||
let getErrorMessage = function (name: string) {
|
||||
let all = 'symbol ' + name + ' not found. In scope: ';
|
||||
scope.getSymbols().forEach((sym) => { all += (sym.name + ' '); });
|
||||
return all;
|
||||
};
|
||||
|
||||
for (let i = 0; i < selections.length; i++) {
|
||||
let selection = selections[i];
|
||||
let sym = scope.getSymbol(selection.name, selection.type) || global.getSymbol(selection.name, selection.type);
|
||||
assert.ok(!!sym, getErrorMessage(selection.name));
|
||||
}
|
||||
}
|
||||
|
||||
export function assertScopeBuilding(p: Parser, input: string, ...scopes: { offset: number; length: number; }[]): void {
|
||||
|
||||
let global = createScope(p, input);
|
||||
|
||||
function assertChildren(scope: Scope): void {
|
||||
|
||||
scope.children.forEach((scope) => {
|
||||
|
||||
// check bounds
|
||||
let expected = scopes.shift();
|
||||
assert.equal(scope.offset, expected.offset);
|
||||
assert.equal(scope.length, expected.length);
|
||||
|
||||
// recursive descent
|
||||
assertChildren(scope);
|
||||
});
|
||||
}
|
||||
|
||||
assertChildren(global);
|
||||
|
||||
assert.equal(scopes.length, 0, 'remainig scopes: ' + scopes.join());
|
||||
}
|
||||
|
||||
function scopeToString(scope: Scope): string {
|
||||
let str = '';
|
||||
let symbols = scope.getSymbols();
|
||||
for (let index = 0; index < symbols.length; index++) {
|
||||
if (str.length > 0) {
|
||||
str += ',';
|
||||
}
|
||||
str += symbols[index].name;
|
||||
}
|
||||
let scopes = scope.children;
|
||||
for (let index = 0; index < scopes.length; index++) {
|
||||
if (str.length > 0) {
|
||||
str += ',';
|
||||
}
|
||||
str += ('[' + scopeToString(scopes[index]) + ']');
|
||||
}
|
||||
return str;
|
||||
}
|
||||
|
||||
function assertNoErrors(node: nodes.Node): void {
|
||||
let markers = nodes.ParseErrorCollector.entries(node);
|
||||
if (markers.length > 0) {
|
||||
assert.ok(false, 'node has errors: ' + markers[0].getMessage() + ', offset: ' + markers[0].getNode().offset);
|
||||
}
|
||||
}
|
||||
|
||||
function createScope(p: Parser, input: string): Scope {
|
||||
let document = TextDocument.create('test://test/test.css', 'css', 0, input);
|
||||
|
||||
let styleSheet = p.parseStylesheet(document),
|
||||
global = new GlobalScope(),
|
||||
builder = new ScopeBuilder(global);
|
||||
|
||||
assertNoErrors(styleSheet);
|
||||
styleSheet.accept(builder);
|
||||
return global;
|
||||
}
|
||||
|
||||
suite('CSS - Symbols', () => {
|
||||
|
||||
test('scope creation', function () {
|
||||
|
||||
let global = new GlobalScope(),
|
||||
child1 = new Scope(10, 5),
|
||||
child2 = new Scope(15, 5);
|
||||
|
||||
global.addChild(child1);
|
||||
global.addChild(child2);
|
||||
|
||||
assert.equal(global.children.length, 2);
|
||||
assert.ok(child1.parent === global);
|
||||
assert.ok(child2.parent === global);
|
||||
|
||||
// find children
|
||||
assert.ok(global.findScope(-1) === null);
|
||||
assert.ok(global.findScope(0) === global);
|
||||
assert.ok(global.findScope(10) === child1);
|
||||
assert.ok(global.findScope(14) === child1);
|
||||
assert.ok(global.findScope(15) === child2);
|
||||
assert.ok(global.findScope(19) === child2);
|
||||
assert.ok(global.findScope(19).parent === global);
|
||||
});
|
||||
|
||||
test('scope building', function () {
|
||||
let p = new Parser();
|
||||
assertScopeBuilding(p, '.class {}', { offset: 7, length: 2 });
|
||||
assertScopeBuilding(p, '.class {} .class {}', { offset: 7, length: 2 }, { offset: 17, length: 2 });
|
||||
});
|
||||
|
||||
test('symbols in scopes', function () {
|
||||
let p = new Parser();
|
||||
assertSymbolsInScope(p, '@keyframes animation {};', 0, { name: 'animation', type: nodes.ReferenceType.Keyframe });
|
||||
assertSymbolsInScope(p, ' .class1 {} .class2 {}', 0, { name: '.class1', type: nodes.ReferenceType.Rule }, { name: '.class2', type: nodes.ReferenceType.Rule });
|
||||
});
|
||||
|
||||
test('scopes and symbols', function () {
|
||||
let p = new Parser();
|
||||
assertScopesAndSymbols(p, '.class {}', '.class,[]');
|
||||
assertScopesAndSymbols(p, '@keyframes animation {}; .class {}', 'animation,.class,[],[]');
|
||||
assertScopesAndSymbols(p, '@page :pseudo-class { margin:2in; }', '[]');
|
||||
assertScopesAndSymbols(p, '@media print { body { font-size: 10pt } }', '[body,[]]');
|
||||
assertScopesAndSymbols(p, '@-moz-keyframes identifier { 0% { top: 0; } 50% { top: 30px; left: 20px; }}', 'identifier,[[],[]]');
|
||||
assertScopesAndSymbols(p, '@font-face { font-family: "Bitstream Vera Serif Bold"; }', '[]');
|
||||
});
|
||||
|
||||
test('mark occurrences', function () {
|
||||
let p = new Parser();
|
||||
assertHighlights(p, '@keyframes id {}; #main { animation: id 4s linear 0s infinite alternate; }', 'id', 2, 1);
|
||||
assertHighlights(p, '@keyframes id {}; #main { animation-name: id; foo: id;}', 'id', 2, 1);
|
||||
});
|
||||
|
||||
test('test variables in root scope', function () {
|
||||
let p = new Parser();
|
||||
assertSymbolsInScope(p, ':root{ --var1: abc; --var2: def; }', 0, { name: '--var1', type: nodes.ReferenceType.Variable }, { name: '--var2', type: nodes.ReferenceType.Variable });
|
||||
});
|
||||
|
||||
test('test variables in local scope', function () {
|
||||
let p = new Parser();
|
||||
assertSymbolsInScope(p, '.a{ --var1: abc; --var2: def; }', 2, { name: '--var1', type: nodes.ReferenceType.Variable }, { name: '--var2', type: nodes.ReferenceType.Variable });
|
||||
});
|
||||
|
||||
test('test variables in local scope get root variables too', function () {
|
||||
let p = new Parser();
|
||||
assertSymbolsInScope(p, '.a{ --var1: abc; } :root{ --var2: abc;}', 2, { name: '--var1', type: nodes.ReferenceType.Variable }, { name: '--var2', type: nodes.ReferenceType.Variable });
|
||||
});
|
||||
|
||||
test('test variables in local scope get root variables and other local variables too', function () {
|
||||
let p = new Parser();
|
||||
assertSymbolsInScope(p, '.a{ --var1: abc; } .b{ --var2: abc; } :root{ --var3: abc;}', 2, { name: '--var1', type: nodes.ReferenceType.Variable }, { name: '--var2', type: nodes.ReferenceType.Variable }, { name: '--var3', type: nodes.ReferenceType.Variable });
|
||||
});
|
||||
|
||||
test('mark occurrences for variable defined in root and used in a rule', function () {
|
||||
let p = new Parser();
|
||||
assertHighlights(p, '.a{ background: let(--var1); } :root{ --var1: abc;}', '--var1', 2, 1);
|
||||
});
|
||||
|
||||
test('mark occurrences for variable defined in a rule and used in a different rule', function () {
|
||||
let p = new Parser();
|
||||
assertHighlights(p, '.a{ background: let(--var1); } :b{ --var1: abc;}', '--var1', 2, 1);
|
||||
});
|
||||
|
||||
test('mark occurrences for property', function () {
|
||||
let p = new Parser();
|
||||
assertHighlights(p, 'body { display: inline } #foo { display: inline }', 'display', 2, 0);
|
||||
});
|
||||
|
||||
test('mark occurrences for value', function () {
|
||||
let p = new Parser();
|
||||
assertHighlights(p, 'body { display: inline } #foo { display: inline }', 'inline', 2, 0);
|
||||
});
|
||||
|
||||
test('mark occurrences for selector', function () {
|
||||
let p = new Parser();
|
||||
assertHighlights(p, 'body { display: inline } #foo { display: inline }', 'body', 1, 1);
|
||||
});
|
||||
|
||||
test('mark occurrences for comment', function () {
|
||||
let p = new Parser();
|
||||
assertHighlights(p, '/* comment */body { display: inline } ', 'comment', 0, 0);
|
||||
});
|
||||
});
|
||||
118
extensions/css/server/src/test/nodes.test.ts
Normal file
118
extensions/css/server/src/test/nodes.test.ts
Normal file
@@ -0,0 +1,118 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
'use strict';
|
||||
|
||||
import * as assert from 'assert';
|
||||
import * as nodes from '../parser/cssNodes';
|
||||
import {Parser} from '../parser/cssParser';
|
||||
|
||||
export class PrintingVisitor implements nodes.IVisitor {
|
||||
|
||||
public tree: string[] = [];
|
||||
|
||||
public visitNode(node: nodes.Node): boolean {
|
||||
this.tree.push(nodes.NodeType[node.type].toLowerCase());
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
export function assertNodes(fn: (input: string) => nodes.Node, input: string, expected: string): void {
|
||||
let node = fn(input);
|
||||
let visitor = new PrintingVisitor();
|
||||
|
||||
node.accept(visitor);
|
||||
|
||||
let actual = visitor.tree.join(',') + ',';
|
||||
let segments = expected.split(',');
|
||||
let oldIndex: number = undefined;
|
||||
let index = -1;
|
||||
|
||||
while (segments.length > 0) {
|
||||
let segment = segments.shift();
|
||||
if (segment === '...') {
|
||||
continue;
|
||||
}
|
||||
index = actual.indexOf(segment + ',', oldIndex);
|
||||
if (index <= oldIndex) {
|
||||
assert.ok(false, segment + ' NOT found in ' + actual);
|
||||
}
|
||||
oldIndex = index + segment.length;
|
||||
}
|
||||
|
||||
assert.ok(true);
|
||||
}
|
||||
|
||||
suite('CSS - Nodes', () => {
|
||||
|
||||
test('Test Node', function () {
|
||||
|
||||
let node = new nodes.Node();
|
||||
assert.equal(node.offset, -1);
|
||||
assert.equal(node.length, -1);
|
||||
assert.equal(node.parent, null);
|
||||
assert.equal(node.getChildren().length, 0);
|
||||
|
||||
let c = 0;
|
||||
node.accept((n: nodes.Node) => {
|
||||
assert.ok(n === node);
|
||||
c += 1;
|
||||
return true;
|
||||
});
|
||||
assert.equal(c, 1);
|
||||
|
||||
let child = new nodes.Node();
|
||||
node.adoptChild(child);
|
||||
|
||||
c = 0;
|
||||
let expects = [node, child];
|
||||
node.accept((n: nodes.Node) => {
|
||||
assert.ok(n === expects[c]);
|
||||
c += 1;
|
||||
return true;
|
||||
});
|
||||
assert.equal(c, 2);
|
||||
});
|
||||
|
||||
test('Test Adopting', function () {
|
||||
|
||||
let child = new nodes.Node();
|
||||
let p1 = new nodes.Node();
|
||||
let p2 = new nodes.Node();
|
||||
|
||||
assert.ok(child.parent === null);
|
||||
assert.equal(p1.getChildren().length, 0);
|
||||
assert.equal(p2.getChildren().length, 0);
|
||||
|
||||
p1.adoptChild(child);
|
||||
assert.ok(child.parent === p1);
|
||||
assert.equal(p1.getChildren().length, 1);
|
||||
assert.equal(p2.getChildren().length, 0);
|
||||
|
||||
p2.adoptChild(child);
|
||||
assert.ok(child.parent === p2);
|
||||
assert.equal(p1.getChildren().length, 0);
|
||||
assert.equal(p2.getChildren().length, 1);
|
||||
});
|
||||
|
||||
function ruleset(input: string): nodes.RuleSet {
|
||||
let parser = new Parser();
|
||||
let node = parser.internalParse(input, parser._parseRuleset);
|
||||
return node;
|
||||
}
|
||||
|
||||
test('RuleSet', function () {
|
||||
assertNodes(ruleset, 'selector { prop: value }', 'ruleset,...,selector,...,declaration,...,property,...,expression');
|
||||
assertNodes(ruleset, 'selector { prop; }', 'ruleset,...,selector,...,selector');
|
||||
});
|
||||
|
||||
test('Keyframe', function () {
|
||||
function fn(input: string): nodes.Node {
|
||||
let parser = new Parser();
|
||||
let node = parser.internalParse(input, parser._parseKeyframe);
|
||||
return node;
|
||||
};
|
||||
assertNodes(fn, '@keyframes name { from { top: 0px} to { top: 100px } }', 'keyframe,identifier,keyframeselector,declaration,keyframeselector,declaration');
|
||||
});
|
||||
});
|
||||
404
extensions/css/server/src/test/parser.test.ts
Normal file
404
extensions/css/server/src/test/parser.test.ts
Normal file
@@ -0,0 +1,404 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
'use strict';
|
||||
|
||||
import * as assert from 'assert';
|
||||
import {Parser} from '../parser/cssParser';
|
||||
import {TokenType} from '../parser/cssScanner';
|
||||
import * as nodes from '../parser/cssNodes';
|
||||
import {ParseError} from '../parser/cssErrors';
|
||||
|
||||
export function assertNode(text: string, parser: Parser, f: () => nodes.Node): nodes.Node {
|
||||
let node = parser.internalParse(text, f);
|
||||
assert.ok(node !== null, 'no node returned');
|
||||
let markers = nodes.ParseErrorCollector.entries(node);
|
||||
if (markers.length > 0) {
|
||||
assert.ok(false, 'node has errors: ' + markers[0].getMessage() + ', offset: ' + markers[0].getNode().offset);
|
||||
}
|
||||
assert.ok(parser.accept(TokenType.EOF), 'Expect scanner at EOF');
|
||||
return node;
|
||||
}
|
||||
|
||||
export function assertFunction(text: string, parser: Parser, f: () => nodes.Node): void {
|
||||
assertNode(text, parser, f);
|
||||
}
|
||||
|
||||
export function assertNoNode(text: string, parser: Parser, f: () => nodes.Node): void {
|
||||
let node = parser.internalParse(text, f);
|
||||
assert.ok(node === null);
|
||||
}
|
||||
|
||||
export function assertError(text: string, parser: Parser, f: () => nodes.Node, error: nodes.IRule): void {
|
||||
let node = parser.internalParse(text, f);
|
||||
assert.ok(node !== null, 'no node returned');
|
||||
let markers = nodes.ParseErrorCollector.entries(node);
|
||||
if (markers.length === 0) {
|
||||
assert.ok(false, 'no errors but error expected: ' + error.message);
|
||||
} else {
|
||||
markers = markers.sort((a, b) => { return a.getOffset() - b.getOffset(); });
|
||||
assert.equal(markers[0].getRule().id, error.id);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
suite('CSS - Parser', () => {
|
||||
|
||||
test('Test stylesheet', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('@charset "demo" ;', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('body { margin: 0px; padding: 3em, 6em; }', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('--> <!--', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('<!-- --> @import "string"; <!-- -->', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('@media asdsa { } <!-- --> <!-- -->', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('@media screen, projection { }', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('@media screen and (max-width: 400px) { @-ms-viewport { width: 320px; }}', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('@-ms-viewport { width: 320px; height: 768px; }', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('#boo, far {} \n.far boo {}', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('@-moz-keyframes darkWordHighlight { from { background-color: inherit; } to { background-color: rgba(83, 83, 83, 0.7); } }', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('@import "foo";', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('@import url(/css/screen.css) screen, projection;', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('@page { margin: 2.5cm; }', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('@font-face { font-family: "Example Font"; }', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('@namespace "http://www.w3.org/1999/xhtml";', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('@namespace pref url(http://test);', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('@-moz-document url(http://test), url-prefix(http://www.w3.org/Style/) { body { color: purple; background: yellow; } }', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('E E[foo] E[foo="bar"] E[foo~="bar"] E[foo^="bar"] E[foo$="bar"] E[foo*="bar"] E[foo|="en"] {}', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('input[type=\"submit\"] {}', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('E:root E:nth-child(n) E:nth-last-child(n) E:nth-of-type(n) E:nth-last-of-type(n) E:first-child E:last-child {}', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('E:first-of-type E:last-of-type E:only-child E:only-of-type E:empty E:link E:visited E:active E:hover E:focus E:target E:lang(fr) E:enabled E:disabled E:checked {}', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('E::first-line E::first-letter E::before E::after {}', parser, parser._parseStylesheet.bind(parser));
|
||||
assertNode('E.warning E#myid E:not(s) {}', parser, parser._parseStylesheet.bind(parser));
|
||||
assertError('@namespace;', parser, parser._parseStylesheet.bind(parser), ParseError.URIExpected);
|
||||
assertError('@namespace url(http://test)', parser, parser._parseStylesheet.bind(parser), ParseError.SemiColonExpected);
|
||||
assertError('@mskeyframes darkWordHighlight { from { background-color: inherit; } to { background-color: rgba(83, 83, 83, 0.7); } }', parser, parser._parseStylesheet.bind(parser), ParseError.UnknownAtRule);
|
||||
assertError('@charset;', parser, parser._parseStylesheet.bind(parser), ParseError.IdentifierExpected);
|
||||
assertError('@charset \'utf8\'', parser, parser._parseStylesheet.bind(parser), ParseError.SemiColonExpected);
|
||||
});
|
||||
|
||||
test('Stylesheet /Panic/', function () {
|
||||
let parser = new Parser();
|
||||
assertError('#boo, far } \n.far boo {}', parser, parser._parseStylesheet.bind(parser), ParseError.LeftCurlyExpected);
|
||||
assertError('#boo, far { far: 43px; \n.far boo {}', parser, parser._parseStylesheet.bind(parser), ParseError.RightCurlyExpected);
|
||||
});
|
||||
|
||||
test('@font-face', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('@font-face {}', parser, parser._parseFontFace.bind(parser));
|
||||
assertNode('@font-face { src: url(http://test) }', parser, parser._parseFontFace.bind(parser));
|
||||
assertNode('@font-face { font-style: normal; font-stretch: normal; }', parser, parser._parseFontFace.bind(parser));
|
||||
assertError('@font-face { font-style: normal font-stretch: normal; }', parser, parser._parseFontFace.bind(parser), ParseError.SemiColonExpected);
|
||||
});
|
||||
|
||||
test('@keyframe selector', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('from {}', parser, parser._parseKeyframeSelector.bind(parser));
|
||||
assertNode('to {}', parser, parser._parseKeyframeSelector.bind(parser));
|
||||
assertNode('0% {}', parser, parser._parseKeyframeSelector.bind(parser));
|
||||
assertNode('10% {}', parser, parser._parseKeyframeSelector.bind(parser));
|
||||
assertNode('100000% {}', parser, parser._parseKeyframeSelector.bind(parser));
|
||||
assertNode('from { width: 100% }', parser, parser._parseKeyframeSelector.bind(parser));
|
||||
assertNode('from { width: 100%; to: 10px; }', parser, parser._parseKeyframeSelector.bind(parser));
|
||||
});
|
||||
|
||||
test('@keyframe', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('@keyframes name {}', parser, parser._parseKeyframe.bind(parser));
|
||||
assertNode('@-webkit-keyframes name {}', parser, parser._parseKeyframe.bind(parser));
|
||||
assertNode('@-o-keyframes name {}', parser, parser._parseKeyframe.bind(parser));
|
||||
assertNode('@-moz-keyframes name {}', parser, parser._parseKeyframe.bind(parser));
|
||||
assertNode('@keyframes name { from {} to {}}', parser, parser._parseKeyframe.bind(parser));
|
||||
assertNode('@keyframes name { from {} 80% {} 100% {}}', parser, parser._parseKeyframe.bind(parser));
|
||||
assertNode('@keyframes name { from { top: 0px; } 80% { top: 100px; } 100% { top: 50px; }}', parser, parser._parseKeyframe.bind(parser));
|
||||
assertNode('@keyframes name { from { top: 0px; } 70%, 80% { top: 100px; } 100% { top: 50px; }}', parser, parser._parseKeyframe.bind(parser));
|
||||
assertNode('@keyframes name { from { top: 0px; left: 1px; right: 2px }}', parser, parser._parseKeyframe.bind(parser));
|
||||
assertError('@keyframes name { from { top: 0px; left: 1px, right: 2px }}', parser, parser._parseKeyframe.bind(parser), ParseError.SemiColonExpected);
|
||||
assertError('@keyframes )', parser, parser._parseKeyframe.bind(parser), ParseError.IdentifierExpected);
|
||||
assertError('@keyframes name { { top: 0px; } }', parser, parser._parseKeyframe.bind(parser), ParseError.RightCurlyExpected);
|
||||
assertError('@keyframes name { from, #123', parser, parser._parseKeyframe.bind(parser), ParseError.PercentageExpected);
|
||||
});
|
||||
|
||||
test('Test import', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('@import "asdasdsa"', parser, parser._parseImport.bind(parser));
|
||||
assertNode('@ImPort "asdsadsa"', parser, parser._parseImport.bind(parser));
|
||||
assertNode('@import "asdasd" dsfsdf', parser, parser._parseImport.bind(parser));
|
||||
assertError('@import', parser, parser._parseImport.bind(parser), ParseError.URIOrStringExpected);
|
||||
});
|
||||
|
||||
test('Test media', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('@media asdsa { }', parser, parser._parseMedia.bind(parser));
|
||||
assertNode('@meDia sadd{} ', parser, parser._parseMedia.bind(parser));
|
||||
assertNode('@media somename, othername2 { }', parser, parser._parseMedia.bind(parser));
|
||||
assertNode('@media only screen and (max-width:850px) { }', parser, parser._parseMedia.bind(parser));
|
||||
assertNode('@media only screen and (max-width:850px) { }', parser, parser._parseMedia.bind(parser));
|
||||
assertNode('@media all and (min-width:500px) { }', parser, parser._parseMedia.bind(parser));
|
||||
assertNode('@media screen and (color), projection and (color) { }', parser, parser._parseMedia.bind(parser));
|
||||
assertNode('@media not screen and (device-aspect-ratio: 16/9) { }', parser, parser._parseMedia.bind(parser));
|
||||
assertNode('@media print and (min-resolution: 300dpi) { }', parser, parser._parseMedia.bind(parser));
|
||||
assertNode('@media print and (min-resolution: 118dpcm) { }', parser, parser._parseMedia.bind(parser));
|
||||
assertNode('@media print { @page { margin: 10% } blockquote, pre { page-break-inside: avoid } }', parser, parser._parseMedia.bind(parser));
|
||||
assertNode('@media print { body:before { } }', parser, parser._parseMedia.bind(parser));
|
||||
assertError('@media somename othername2 { }', parser, parser._parseMedia.bind(parser), ParseError.LeftCurlyExpected);
|
||||
assertError('@media not, screen { }', parser, parser._parseMedia.bind(parser), ParseError.IdentifierExpected);
|
||||
assertError('@media not screen and foo { }', parser, parser._parseMedia.bind(parser), ParseError.LeftParenthesisExpected);
|
||||
assertError('@media not screen and () { }', parser, parser._parseMedia.bind(parser), ParseError.IdentifierExpected);
|
||||
assertError('@media not screen and (color:) { }', parser, parser._parseMedia.bind(parser), ParseError.TermExpected);
|
||||
assertError('@media not screen and (color:#234567 { }', parser, parser._parseMedia.bind(parser), ParseError.RightParenthesisExpected);
|
||||
});
|
||||
|
||||
test('Test media_list', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('somename', parser, parser._parseMediaList.bind(parser));
|
||||
assertNode('somename, othername', parser, parser._parseMediaList.bind(parser));
|
||||
});
|
||||
|
||||
test('medium', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('somename', parser, parser._parseMedium.bind(parser));
|
||||
assertNode('-asdas', parser, parser._parseMedium.bind(parser));
|
||||
assertNode('-asda34s', parser, parser._parseMedium.bind(parser));
|
||||
});
|
||||
|
||||
test('page', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('@page : name{ }', parser, parser._parsePage.bind(parser));
|
||||
assertNode('@page :left, :right { }', parser, parser._parsePage.bind(parser));
|
||||
assertNode('@page : name{ some : "asdas" }', parser, parser._parsePage.bind(parser));
|
||||
assertNode('@page : name{ some : "asdas" !important }', parser, parser._parsePage.bind(parser));
|
||||
assertNode('@page : name{ some : "asdas" !important; some : "asdas" !important }', parser, parser._parsePage.bind(parser));
|
||||
assertNode('@page rotated { size : landscape }', parser, parser._parsePage.bind(parser));
|
||||
assertNode('@page :left { margin-left: 4cm; margin-right: 3cm; }', parser, parser._parsePage.bind(parser));
|
||||
assertNode('@page { @top-right-corner { content: url(foo.png); border: solid green; } }', parser, parser._parsePage.bind(parser));
|
||||
assertNode('@page { @top-left-corner { content: " "; border: solid green; } @bottom-right-corner { content: counter(page); border: solid green; } }', parser, parser._parsePage.bind(parser));
|
||||
assertError('@page { @top-left-corner foo { content: " "; border: solid green; } }', parser, parser._parsePage.bind(parser), ParseError.LeftCurlyExpected);
|
||||
assertError('@page { @XY foo { content: " "; border: solid green; } }', parser, parser._parsePage.bind(parser), ParseError.UnknownAtRule);
|
||||
assertError('@page :left { margin-left: 4cm margin-right: 3cm; }', parser, parser._parsePage.bind(parser), ParseError.SemiColonExpected);
|
||||
assertError('@page : { }', parser, parser._parsePage.bind(parser), ParseError.IdentifierExpected);
|
||||
assertError('@page :left, { }', parser, parser._parsePage.bind(parser), ParseError.IdentifierExpected);
|
||||
});
|
||||
|
||||
test('pseudo page', function () {
|
||||
let parser = new Parser();
|
||||
assertNode(': some ', parser, parser._parsePageSelector.bind(parser));
|
||||
});
|
||||
|
||||
test('operator', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('/', parser, parser._parseOperator.bind(parser));
|
||||
assertNode('*', parser, parser._parseOperator.bind(parser));
|
||||
assertNode('+', parser, parser._parseOperator.bind(parser));
|
||||
assertNode('-', parser, parser._parseOperator.bind(parser));
|
||||
});
|
||||
|
||||
test('combinator', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('+', parser, parser._parseCombinator.bind(parser));
|
||||
assertNode('+ ', parser, parser._parseCombinator.bind(parser));
|
||||
assertNode('> ', parser, parser._parseCombinator.bind(parser));
|
||||
assertNode('>', parser, parser._parseCombinator.bind(parser));
|
||||
});
|
||||
|
||||
test('unary_operator', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('-', parser, parser._parseUnaryOperator.bind(parser));
|
||||
assertNode('+', parser, parser._parseUnaryOperator.bind(parser));
|
||||
});
|
||||
|
||||
test('Property', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('asdsa', parser, parser._parseProperty.bind(parser));
|
||||
assertNode('asdsa334', parser, parser._parseProperty.bind(parser));
|
||||
|
||||
assertNode('--color', parser, parser._parseProperty.bind(parser));
|
||||
assertNode('--primary-font', parser, parser._parseProperty.bind(parser));
|
||||
assertNode('-color', parser, parser._parseProperty.bind(parser));
|
||||
assertNode('somevar', parser, parser._parseProperty.bind(parser));
|
||||
assertNode('some--let', parser, parser._parseProperty.bind(parser));
|
||||
assertNode('somevar--', parser, parser._parseProperty.bind(parser));
|
||||
});
|
||||
|
||||
test('Ruleset', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('name{ }', parser, parser._parseRuleset.bind(parser));
|
||||
assertNode(' name\n{ some : "asdas" }', parser, parser._parseRuleset.bind(parser));
|
||||
assertNode(' name{ some : "asdas" !important }', parser, parser._parseRuleset.bind(parser));
|
||||
assertNode('name{ \n some : "asdas" !important; some : "asdas" }', parser, parser._parseRuleset.bind(parser));
|
||||
assertNode('* {}', parser, parser._parseRuleset.bind(parser));
|
||||
assertNode('.far{}', parser, parser._parseRuleset.bind(parser));
|
||||
assertNode('boo {}', parser, parser._parseRuleset.bind(parser));
|
||||
assertNode('.far #boo {}', parser, parser._parseRuleset.bind(parser));
|
||||
assertNode('boo { prop: value }', parser, parser._parseRuleset.bind(parser));
|
||||
assertNode('boo { prop: value; }', parser, parser._parseRuleset.bind(parser));
|
||||
assertNode('boo { prop: value; prop: value }', parser, parser._parseRuleset.bind(parser));
|
||||
assertNode('boo { prop: value; prop: value; }', parser, parser._parseRuleset.bind(parser));
|
||||
});
|
||||
|
||||
test('Ruleset /Panic/', function () {
|
||||
let parser = new Parser();
|
||||
// assertNode('boo { : value }', parser, parser._parseRuleset.bind(parser));
|
||||
assertError('boo { prop: ; }', parser, parser._parseRuleset.bind(parser), ParseError.PropertyValueExpected);
|
||||
assertError('boo { prop }', parser, parser._parseRuleset.bind(parser), ParseError.ColonExpected);
|
||||
assertError('boo { prop: ; far: 12em; }', parser, parser._parseRuleset.bind(parser), ParseError.PropertyValueExpected);
|
||||
// assertNode('boo { prop: ; 1ar: 12em; }', parser, parser._parseRuleset.bind(parser));
|
||||
});
|
||||
|
||||
test('selector', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('asdsa', parser, parser._parseSelector.bind(parser));
|
||||
assertNode('asdsa + asdas', parser, parser._parseSelector.bind(parser));
|
||||
assertNode('asdsa + asdas + name', parser, parser._parseSelector.bind(parser));
|
||||
assertNode('asdsa + asdas + name', parser, parser._parseSelector.bind(parser));
|
||||
assertNode('name #id#anotherid', parser, parser._parseSelector.bind(parser));
|
||||
assertNode('name.far .boo', parser, parser._parseSelector.bind(parser));
|
||||
assertNode('name .name .zweitername', parser, parser._parseSelector.bind(parser));
|
||||
assertNode('*', parser, parser._parseSelector.bind(parser));
|
||||
assertNode('#id', parser, parser._parseSelector.bind(parser));
|
||||
assertNode('far.boo', parser, parser._parseSelector.bind(parser));
|
||||
});
|
||||
|
||||
test('simple selector', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('name', parser, parser._parseSimpleSelector.bind(parser));
|
||||
assertNode('#id#anotherid', parser, parser._parseSimpleSelector.bind(parser));
|
||||
assertNode('name.far', parser, parser._parseSimpleSelector.bind(parser));
|
||||
assertNode('name.erstername.zweitername', parser, parser._parseSimpleSelector.bind(parser));
|
||||
});
|
||||
|
||||
test('element name', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('name', parser, parser._parseElementName.bind(parser));
|
||||
assertNode('*', parser, parser._parseElementName.bind(parser));
|
||||
});
|
||||
|
||||
test('attrib', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('[name]', parser, parser._parseAttrib.bind(parser));
|
||||
assertNode('[name = name2]', parser, parser._parseAttrib.bind(parser));
|
||||
assertNode('[name ~= name3]', parser, parser._parseAttrib.bind(parser));
|
||||
assertNode('[name~=name3]', parser, parser._parseAttrib.bind(parser));
|
||||
assertNode('[name |= name3]', parser, parser._parseAttrib.bind(parser));
|
||||
assertNode('[name |= "this is a striiiing"]', parser, parser._parseAttrib.bind(parser));
|
||||
});
|
||||
|
||||
test('pseudo', function () {
|
||||
let parser = new Parser();
|
||||
assertNode(':some', parser, parser._parsePseudo.bind(parser));
|
||||
assertNode(':some(thing)', parser, parser._parsePseudo.bind(parser));
|
||||
assertNode(':nth-child(12)', parser, parser._parsePseudo.bind(parser));
|
||||
assertNode(':lang(it)', parser, parser._parsePseudo.bind(parser));
|
||||
assertNode(':not(.class)', parser, parser._parsePseudo.bind(parser));
|
||||
assertNode(':not(:disabled)', parser, parser._parsePseudo.bind(parser));
|
||||
assertNode(':not(#foo)', parser, parser._parsePseudo.bind(parser));
|
||||
});
|
||||
|
||||
test('declaration', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('name : "this is a string" !important', parser, parser._parseDeclaration.bind(parser));
|
||||
assertNode('name : "this is a string"', parser, parser._parseDeclaration.bind(parser));
|
||||
assertNode('property:12', parser, parser._parseDeclaration.bind(parser));
|
||||
assertNode('-vendor-property: 12', parser, parser._parseDeclaration.bind(parser));
|
||||
assertNode('font-size: 12px', parser, parser._parseDeclaration.bind(parser));
|
||||
assertNode('color : #888 /4', parser, parser._parseDeclaration.bind(parser));
|
||||
assertNode('filter : progid:DXImageTransform.Microsoft.Shadow(color=#000000,direction=45)', parser, parser._parseDeclaration.bind(parser));
|
||||
assertNode('filter : progid: DXImageTransform.\nMicrosoft.\nDropShadow(\noffx=2, offy=1, color=#000000)', parser, parser._parseDeclaration.bind(parser));
|
||||
assertNode('font-size: 12px', parser, parser._parseDeclaration.bind(parser));
|
||||
assertNode('*background: #f00 /* IE 7 and below */', parser, parser._parseDeclaration.bind(parser));
|
||||
assertNode('_background: #f60 /* IE 6 and below */', parser, parser._parseDeclaration.bind(parser));
|
||||
assertNode('background-image: linear-gradient(to right, silver, white 50px, white calc(100% - 50px), silver)', parser, parser._parseDeclaration.bind(parser));
|
||||
|
||||
assertNode('--color: #F5F5F5', parser, parser._parseDeclaration.bind(parser));
|
||||
assertNode('--color: 0', parser, parser._parseDeclaration.bind(parser));
|
||||
assertNode('--color: 255', parser, parser._parseDeclaration.bind(parser));
|
||||
assertNode('--color: 25.5', parser, parser._parseDeclaration.bind(parser));
|
||||
assertNode('--color: 25px', parser, parser._parseDeclaration.bind(parser));
|
||||
assertNode('--color: 25.5px', parser, parser._parseDeclaration.bind(parser));
|
||||
assertNode('--primary-font: "wf_SegoeUI","Segoe UI","Segoe","Segoe WP"', parser, parser._parseDeclaration.bind(parser));
|
||||
assertError('--color : ', parser, parser._parseDeclaration.bind(parser), ParseError.PropertyValueExpected);
|
||||
assertError('--color value', parser, parser._parseDeclaration.bind(parser), ParseError.ColonExpected);
|
||||
});
|
||||
|
||||
|
||||
test('term', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('"asdasd"', parser, parser._parseTerm.bind(parser));
|
||||
assertNode('name', parser, parser._parseTerm.bind(parser));
|
||||
assertNode('#FFFFFF', parser, parser._parseTerm.bind(parser));
|
||||
assertNode('url("this is a url")', parser, parser._parseTerm.bind(parser));
|
||||
assertNode('+324', parser, parser._parseTerm.bind(parser));
|
||||
assertNode('-45', parser, parser._parseTerm.bind(parser));
|
||||
assertNode('+45', parser, parser._parseTerm.bind(parser));
|
||||
assertNode('-45%', parser, parser._parseTerm.bind(parser));
|
||||
assertNode('-45mm', parser, parser._parseTerm.bind(parser));
|
||||
assertNode('-45em', parser, parser._parseTerm.bind(parser));
|
||||
assertNode('"asdsa"', parser, parser._parseTerm.bind(parser));
|
||||
assertNode('faa', parser, parser._parseTerm.bind(parser));
|
||||
assertNode('url("this is a striiiiing")', parser, parser._parseTerm.bind(parser));
|
||||
assertNode('#FFFFFF', parser, parser._parseTerm.bind(parser));
|
||||
assertNode('name(asd)', parser, parser._parseTerm.bind(parser));
|
||||
assertNode('calc(50% + 20px)', parser, parser._parseTerm.bind(parser));
|
||||
assertNode('calc(50% + (100%/3 - 2*1em - 2*1px))', parser, parser._parseTerm.bind(parser));
|
||||
assertNoNode('%(\'repetitions: %S file: %S\', 1 + 2, "directory/file.less")', parser, parser._parseTerm.bind(parser)); // less syntax
|
||||
assertNoNode('~"ms:alwaysHasItsOwnSyntax.For.Stuff()"', parser, parser._parseTerm.bind(parser)); // less syntax
|
||||
});
|
||||
|
||||
test('function', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('name( "bla" )', parser, parser._parseFunction.bind(parser));
|
||||
assertNode('name( name )', parser, parser._parseFunction.bind(parser));
|
||||
assertNode('name( -500mm )', parser, parser._parseFunction.bind(parser));
|
||||
assertNode('\u060frf()', parser, parser._parseFunction.bind(parser));
|
||||
assertNode('über()', parser, parser._parseFunction.bind(parser));
|
||||
|
||||
assertNoNode('über ()', parser, parser._parseFunction.bind(parser));
|
||||
assertNoNode('%()', parser, parser._parseFunction.bind(parser));
|
||||
assertNoNode('% ()', parser, parser._parseFunction.bind(parser));
|
||||
|
||||
assertFunction('let(--color)', parser, parser._parseFunction.bind(parser));
|
||||
assertFunction('let(--color, somevalue)', parser, parser._parseFunction.bind(parser));
|
||||
assertFunction('let(--variable1, --variable2)', parser, parser._parseFunction.bind(parser));
|
||||
assertFunction('let(--variable1, let(--variable2))', parser, parser._parseFunction.bind(parser));
|
||||
assertFunction('fun(value1, value2)', parser, parser._parseFunction.bind(parser));
|
||||
});
|
||||
|
||||
test('Test Token prio', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('!important', parser, parser._parsePrio.bind(parser));
|
||||
assertNode('!/*demo*/important', parser, parser._parsePrio.bind(parser));
|
||||
assertNode('! /*demo*/ important', parser, parser._parsePrio.bind(parser));
|
||||
assertNode('! /*dem o*/ important', parser, parser._parsePrio.bind(parser));
|
||||
});
|
||||
|
||||
test('hexcolor', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('#FFF', parser, parser._parseHexColor.bind(parser));
|
||||
assertNode('#FFFFFF', parser, parser._parseHexColor.bind(parser));
|
||||
});
|
||||
|
||||
test('Test class', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('.faa', parser, parser._parseClass.bind(parser));
|
||||
assertNode('faa', parser, parser._parseElementName.bind(parser));
|
||||
assertNode('*', parser, parser._parseElementName.bind(parser));
|
||||
assertNode('.faa42', parser, parser._parseClass.bind(parser));
|
||||
});
|
||||
|
||||
|
||||
test('Prio', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('!important', parser, parser._parsePrio.bind(parser));
|
||||
});
|
||||
|
||||
test('Expr', function () {
|
||||
let parser = new Parser();
|
||||
assertNode('45,5px', parser, parser._parseExpr.bind(parser));
|
||||
assertNode(' 45 , 5px ', parser, parser._parseExpr.bind(parser));
|
||||
assertNode('5/6', parser, parser._parseExpr.bind(parser));
|
||||
assertNode('36mm, -webkit-calc(100%-10px)', parser, parser._parseExpr.bind(parser));
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
228
extensions/css/server/src/test/scanner.test.ts
Normal file
228
extensions/css/server/src/test/scanner.test.ts
Normal file
@@ -0,0 +1,228 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
'use strict';
|
||||
|
||||
import * as assert from 'assert';
|
||||
import {Scanner, TokenType} from '../parser/cssScanner';
|
||||
|
||||
suite('CSS - Scanner', () => {
|
||||
|
||||
function assertSingleToken(scan: Scanner, source: string, len: number, offset: number, text: string, type: TokenType): void {
|
||||
scan.setSource(source);
|
||||
let token = scan.scan();
|
||||
assert.equal(token.len, len);
|
||||
assert.equal(token.offset, offset);
|
||||
assert.equal(token.text, text);
|
||||
assert.equal(token.type, type);
|
||||
}
|
||||
|
||||
test('Whitespace', function () {
|
||||
let scanner = new Scanner();
|
||||
assertSingleToken(scanner, ' @', 1, 1, '@', TokenType.Delim);
|
||||
assertSingleToken(scanner, ' /* comment*/ \n/*comment*/@', 1, 26, '@', TokenType.Delim);
|
||||
|
||||
scanner = new Scanner();
|
||||
scanner.ignoreWhitespace = false;
|
||||
assertSingleToken(scanner, ' @', 1, 0, ' ', TokenType.Whitespace);
|
||||
assertSingleToken(scanner, '/*comment*/ @', 1, 11, ' ', TokenType.Whitespace);
|
||||
|
||||
scanner = new Scanner();
|
||||
scanner.ignoreComment = false;
|
||||
assertSingleToken(scanner, ' /*comment*/@', 11, 1, '/*comment*/', TokenType.Comment);
|
||||
assertSingleToken(scanner, '/*comment*/ @', 11, 0, '/*comment*/', TokenType.Comment);
|
||||
});
|
||||
|
||||
test('Token Ident', function () {
|
||||
let scanner = new Scanner();
|
||||
assertSingleToken(scanner, '\u060frf', 3, 0, '\u060frf', TokenType.Ident);
|
||||
assertSingleToken(scanner, 'über', 4, 0, 'über', TokenType.Ident);
|
||||
assertSingleToken(scanner, '-bo', 3, 0, '-bo', TokenType.Ident);
|
||||
assertSingleToken(scanner, '_bo', 3, 0, '_bo', TokenType.Ident);
|
||||
assertSingleToken(scanner, 'boo', 3, 0, 'boo', TokenType.Ident);
|
||||
assertSingleToken(scanner, 'Boo', 3, 0, 'Boo', TokenType.Ident);
|
||||
assertSingleToken(scanner, 'red--', 5, 0, 'red--', TokenType.Ident);
|
||||
assertSingleToken(scanner, 'red-->', 5, 0, 'red--', TokenType.Ident);
|
||||
assertSingleToken(scanner, '--red', 5, 0, '--red', TokenType.Ident);
|
||||
assertSingleToken(scanner, 'a\\.b', 4, 0, 'a\.b', TokenType.Ident);
|
||||
assertSingleToken(scanner, '\\E9motion', 9, 0, 'émotion', TokenType.Ident);
|
||||
assertSingleToken(scanner, '\\E9 dition', 10, 0, 'édition', TokenType.Ident);
|
||||
assertSingleToken(scanner, '\\0000E9dition', 13, 0, 'édition', TokenType.Ident);
|
||||
assertSingleToken(scanner, 'S\\0000e9f', 9, 0, 'Séf', TokenType.Ident);
|
||||
});
|
||||
|
||||
test('Token Url', function () {
|
||||
let scanner = new Scanner();
|
||||
assertSingleToken(scanner, 'url(\'http://msft.com\')', 22, 0, 'url(\'http://msft.com\')', TokenType.URI);
|
||||
assertSingleToken(scanner, 'url("http://msft.com")', 22, 0, 'url("http://msft.com")', TokenType.URI);
|
||||
assertSingleToken(scanner, 'url( "http://msft.com")', 23, 0, 'url( "http://msft.com")', TokenType.URI);
|
||||
assertSingleToken(scanner, 'url(\t"http://msft.com")', 23, 0, 'url(\t"http://msft.com")', TokenType.URI);
|
||||
assertSingleToken(scanner, 'url(\n"http://msft.com")', 23, 0, 'url(\n"http://msft.com")', TokenType.URI);
|
||||
assertSingleToken(scanner, 'url("http://msft.com"\n)', 23, 0, 'url("http://msft.com"\n)', TokenType.URI);
|
||||
assertSingleToken(scanner, 'url("")', 7, 0, 'url("")', TokenType.URI);
|
||||
assertSingleToken(scanner, 'uRL("")', 7, 0, 'uRL("")', TokenType.URI);
|
||||
assertSingleToken(scanner, 'URL("")', 7, 0, 'URL("")', TokenType.URI);
|
||||
assertSingleToken(scanner, 'url(http://msft.com)', 20, 0, 'url(http://msft.com)', TokenType.URI);
|
||||
assertSingleToken(scanner, 'url()', 5, 0, 'url()', TokenType.URI);
|
||||
assertSingleToken(scanner, 'url(\'http://msft.com\n)', 22, 0, 'url(\'http://msft.com\n)', TokenType.BadUri);
|
||||
assertSingleToken(scanner, 'url("http://msft.com"', 21, 0, 'url("http://msft.com"', TokenType.BadUri);
|
||||
assertSingleToken(scanner, 'url(http://msft.com\')', 21, 0, 'url(http://msft.com\')', TokenType.URI);
|
||||
});
|
||||
|
||||
test('Token AtKeyword', function () {
|
||||
let scanner = new Scanner();
|
||||
assertSingleToken(scanner, '@import', 7, 0, '@import', TokenType.AtKeyword);
|
||||
assertSingleToken(scanner, '@importttt', 10, 0, '@importttt', TokenType.AtKeyword);
|
||||
assertSingleToken(scanner, '@imp', 4, 0, '@imp', TokenType.AtKeyword);
|
||||
assertSingleToken(scanner, '@5', 2, 0, '@5', TokenType.AtKeyword);
|
||||
assertSingleToken(scanner, '@media', 6, 0, '@media', TokenType.AtKeyword);
|
||||
assertSingleToken(scanner, '@page', 5, 0, '@page', TokenType.AtKeyword);
|
||||
assertSingleToken(scanner, '@charset', 8, 0, '@charset', TokenType.Charset);
|
||||
assertSingleToken(scanner, '@-mport', 7, 0, '@-mport', TokenType.AtKeyword);
|
||||
assertSingleToken(scanner, '@\u00f0mport', 7, 0, '@\u00f0mport', TokenType.AtKeyword);
|
||||
assertSingleToken(scanner, '@', 1, 0, '@', TokenType.Delim);
|
||||
});
|
||||
|
||||
test('Token Number', function () {
|
||||
let scanner = new Scanner();
|
||||
assertSingleToken(scanner, '1234', 4, 0, '1234', TokenType.Num);
|
||||
assertSingleToken(scanner, '1.34', 4, 0, '1.34', TokenType.Num);
|
||||
assertSingleToken(scanner, '.234', 4, 0, '.234', TokenType.Num);
|
||||
assertSingleToken(scanner, '.234.', 4, 0, '.234', TokenType.Num);
|
||||
assertSingleToken(scanner, '..234', 1, 0, '.', TokenType.Delim);
|
||||
});
|
||||
|
||||
test('Token Delim', function () {
|
||||
let scanner = new Scanner();
|
||||
assertSingleToken(scanner, '@', 1, 0, '@', TokenType.Delim);
|
||||
assertSingleToken(scanner, '+', 1, 0, '+', TokenType.Delim);
|
||||
assertSingleToken(scanner, '>', 1, 0, '>', TokenType.Delim);
|
||||
assertSingleToken(scanner, '#', 1, 0, '#', TokenType.Delim);
|
||||
assertSingleToken(scanner, '\'', 1, 0, '\'', TokenType.BadString);
|
||||
assertSingleToken(scanner, '"', 1, 0, '"', TokenType.BadString);
|
||||
});
|
||||
|
||||
test('Token Hash', function () {
|
||||
let scanner = new Scanner();
|
||||
assertSingleToken(scanner, '#import', 7, 0, '#import', TokenType.Hash);
|
||||
assertSingleToken(scanner, '#-mport', 7, 0, '#-mport', TokenType.Hash);
|
||||
assertSingleToken(scanner, '#123', 4, 0, '#123', TokenType.Hash);
|
||||
});
|
||||
|
||||
test('Token Dimension/Percentage', function () {
|
||||
let scanner = new Scanner();
|
||||
assertSingleToken(scanner, '3em', 3, 0, '3em', TokenType.EMS);
|
||||
assertSingleToken(scanner, '4.423ex', 7, 0, '4.423ex', TokenType.EXS);
|
||||
assertSingleToken(scanner, '3423px', 6, 0, '3423px', TokenType.Length);
|
||||
assertSingleToken(scanner, '4.423cm', 7, 0, '4.423cm', TokenType.Length);
|
||||
assertSingleToken(scanner, '4.423mm', 7, 0, '4.423mm', TokenType.Length);
|
||||
assertSingleToken(scanner, '4.423in', 7, 0, '4.423in', TokenType.Length);
|
||||
assertSingleToken(scanner, '4.423pt', 7, 0, '4.423pt', TokenType.Length);
|
||||
assertSingleToken(scanner, '4.423pc', 7, 0, '4.423pc', TokenType.Length);
|
||||
assertSingleToken(scanner, '4.423deg', 8, 0, '4.423deg', TokenType.Angle);
|
||||
assertSingleToken(scanner, '4.423rad', 8, 0, '4.423rad', TokenType.Angle);
|
||||
assertSingleToken(scanner, '4.423grad', 9, 0, '4.423grad', TokenType.Angle);
|
||||
assertSingleToken(scanner, '4.423ms', 7, 0, '4.423ms', TokenType.Time);
|
||||
assertSingleToken(scanner, '4.423s', 6, 0, '4.423s', TokenType.Time);
|
||||
assertSingleToken(scanner, '4.423hz', 7, 0, '4.423hz', TokenType.Freq);
|
||||
assertSingleToken(scanner, '.423khz', 7, 0, '.423khz', TokenType.Freq);
|
||||
assertSingleToken(scanner, '3.423%', 6, 0, '3.423%', TokenType.Percentage);
|
||||
assertSingleToken(scanner, '.423%', 5, 0, '.423%', TokenType.Percentage);
|
||||
assertSingleToken(scanner, '.423ft', 6, 0, '.423ft', TokenType.Dimension);
|
||||
assertSingleToken(scanner, '200dpi', 6, 0, '200dpi', TokenType.Resolution);
|
||||
assertSingleToken(scanner, '123dpcm', 7, 0, '123dpcm', TokenType.Resolution);
|
||||
});
|
||||
|
||||
test('Token String', function () {
|
||||
let scanner = new Scanner();
|
||||
assertSingleToken(scanner, '\'farboo\'', 8, 0, '\'farboo\'', TokenType.String);
|
||||
assertSingleToken(scanner, '"farboo"', 8, 0, '"farboo"', TokenType.String);
|
||||
assertSingleToken(scanner, '"farbo\u00f0"', 8, 0, '"farbo\u00f0"', TokenType.String);
|
||||
assertSingleToken(scanner, '"far\\\"oo"', 9, 0, '"far\"oo"', TokenType.String);
|
||||
assertSingleToken(scanner, '"fa\\\noo"', 8, 0, '"fa\noo"', TokenType.String);
|
||||
assertSingleToken(scanner, '"fa\\\roo"', 8, 0, '"fa\roo"', TokenType.String);
|
||||
assertSingleToken(scanner, '"fa\\\foo"', 8, 0, '"fa\foo"', TokenType.String);
|
||||
assertSingleToken(scanner, '\'farboo"', 8, 0, '\'farboo"', TokenType.BadString);
|
||||
assertSingleToken(scanner, '\'farboo', 7, 0, '\'farboo', TokenType.BadString);
|
||||
assertSingleToken(scanner, '\'', 1, 0, '\'', TokenType.BadString);
|
||||
assertSingleToken(scanner, '"', 1, 0, '"', TokenType.BadString);
|
||||
});
|
||||
|
||||
test('Token CDO', function () {
|
||||
let scanner = new Scanner();
|
||||
assertSingleToken(scanner, '<!--', 4, 0, '<!--', TokenType.CDO);
|
||||
assertSingleToken(scanner, '<!-\n-', 1, 0, '<', TokenType.Delim);
|
||||
});
|
||||
|
||||
test('Token CDC', function () {
|
||||
let scanner = new Scanner();
|
||||
assertSingleToken(scanner, '-->', 3, 0, '-->', TokenType.CDC);
|
||||
assertSingleToken(scanner, '--y>', 3, 0, '--y', TokenType.Ident);
|
||||
assertSingleToken(scanner, '--<', 1, 0, '-', TokenType.Delim);
|
||||
});
|
||||
|
||||
test('Token singletokens ;:{}[]()', function () {
|
||||
let scanner = new Scanner();
|
||||
assertSingleToken(scanner, ': ', 1, 0, ':', TokenType.Colon);
|
||||
assertSingleToken(scanner, '; ', 1, 0, ';', TokenType.SemiColon);
|
||||
assertSingleToken(scanner, '{ ', 1, 0, '{', TokenType.CurlyL);
|
||||
assertSingleToken(scanner, '} ', 1, 0, '}', TokenType.CurlyR);
|
||||
assertSingleToken(scanner, '[ ', 1, 0, '[', TokenType.BracketL);
|
||||
assertSingleToken(scanner, '] ', 1, 0, ']', TokenType.BracketR);
|
||||
assertSingleToken(scanner, '( ', 1, 0, '(', TokenType.ParenthesisL);
|
||||
assertSingleToken(scanner, ') ', 1, 0, ')', TokenType.ParenthesisR);
|
||||
});
|
||||
|
||||
test('Token dashmatch & includes', function () {
|
||||
let scanner = new Scanner();
|
||||
assertSingleToken(scanner, '~=', 2, 0, '~=', TokenType.Includes);
|
||||
assertSingleToken(scanner, '~', 1, 0, '~', TokenType.Delim);
|
||||
assertSingleToken(scanner, '|=', 2, 0, '|=', TokenType.Dashmatch);
|
||||
assertSingleToken(scanner, '|', 1, 0, '|', TokenType.Delim);
|
||||
assertSingleToken(scanner, '^=', 2, 0, '^=', TokenType.PrefixOperator);
|
||||
assertSingleToken(scanner, '$=', 2, 0, '$=', TokenType.SuffixOperator);
|
||||
assertSingleToken(scanner, '*=', 2, 0, '*=', TokenType.SubstringOperator);
|
||||
});
|
||||
|
||||
test('Comments', function () {
|
||||
let scanner = new Scanner();
|
||||
assertSingleToken(scanner, '/* */', 0, 10, '', TokenType.EOF);
|
||||
assertSingleToken(scanner, '/* abcd*/', 0, 14, '', TokenType.EOF);
|
||||
assertSingleToken(scanner, '/*abcd */', 0, 10, '', TokenType.EOF);
|
||||
assertSingleToken(scanner, '/* ab- .-cd */', 0, 15, '', TokenType.EOF);
|
||||
});
|
||||
|
||||
test('Whitespaces', function () {
|
||||
let scanner = new Scanner();
|
||||
assertSingleToken(scanner, ' ', 0, 1, '', TokenType.EOF);
|
||||
assertSingleToken(scanner, ' ', 0, 6, '', TokenType.EOF);
|
||||
});
|
||||
});
|
||||
|
||||
suite('CSS - Token Sequences', () => {
|
||||
|
||||
function assertTokenSequence(scan: Scanner, source: string, ...tokens: TokenType[]): void {
|
||||
scan.setSource(source);
|
||||
let token = scan.scan();
|
||||
let i = 0;
|
||||
while (tokens.length > i) {
|
||||
assert.equal(token.type, tokens[i]);
|
||||
token = scan.scan();
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
// tests with skipping comments
|
||||
test('Token Sequence', function () {
|
||||
let scanner = new Scanner();
|
||||
assertTokenSequence(scanner, '5 5 5 5', TokenType.Num, TokenType.Num, TokenType.Num, TokenType.Num);
|
||||
assertTokenSequence(scanner, '/* 5 4 */-->', TokenType.CDC);
|
||||
assertTokenSequence(scanner, '/* 5 4 */ -->', TokenType.CDC);
|
||||
assertTokenSequence(scanner, '/* "adaasd" */ -->', TokenType.CDC);
|
||||
assertTokenSequence(scanner, '/* <!-- */ -->', TokenType.CDC);
|
||||
assertTokenSequence(scanner, 'red-->', TokenType.Ident, TokenType.Delim);
|
||||
assertTokenSequence(scanner, '@ import', TokenType.Delim, TokenType.Ident);
|
||||
});
|
||||
|
||||
});
|
||||
106
extensions/css/server/src/test/selectorPrinting.test.ts
Normal file
106
extensions/css/server/src/test/selectorPrinting.test.ts
Normal file
@@ -0,0 +1,106 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
'use strict';
|
||||
|
||||
import * as assert from 'assert';
|
||||
import {Parser} from '../parser/cssParser';
|
||||
import * as nodes from '../parser/cssNodes';
|
||||
import * as selectorPrinter from '../services/selectorPrinting';
|
||||
import {TextDocument} from 'vscode-languageserver';
|
||||
|
||||
function elementToString(element: selectorPrinter.Element): string {
|
||||
let label = element.name || '';
|
||||
if (element.attributes) {
|
||||
label = label + '[';
|
||||
let needsSeparator = false;
|
||||
for (let key in element.attributes) {
|
||||
if (needsSeparator) {
|
||||
label = label + '|';
|
||||
}
|
||||
needsSeparator = true;
|
||||
label = label + key + '=' + element.attributes[key];
|
||||
}
|
||||
label = label + ']';
|
||||
}
|
||||
|
||||
|
||||
if (element.children) {
|
||||
label = label + '{';
|
||||
for (let index = 0; index < element.children.length; index++) {
|
||||
if (index > 0) {
|
||||
label = label + '|';
|
||||
}
|
||||
label = label + elementToString(element.children[index]);
|
||||
}
|
||||
label = label + '}';
|
||||
}
|
||||
return label;
|
||||
}
|
||||
|
||||
export function parseSelector(p: Parser, input: string, selectorName: string, expected: string): void {
|
||||
let document = TextDocument.create('test://test/test.css', 'css', 0, input);
|
||||
let styleSheet = p.parseStylesheet(document);
|
||||
|
||||
let node = nodes.getNodeAtOffset(styleSheet, input.indexOf(selectorName));
|
||||
let selector = node.findParent(nodes.NodeType.Selector);
|
||||
|
||||
let element = selectorPrinter.selectorToElement(selector);
|
||||
assert.equal(elementToString(element), expected);
|
||||
}
|
||||
|
||||
export interface ExpectedElement {
|
||||
name?: string;
|
||||
attributes?: { [name: string]: string; };
|
||||
}
|
||||
|
||||
export function assertElement(p: Parser, input: string, element: ExpectedElement): void {
|
||||
let node = p.internalParse(input, p._parseSimpleSelector);
|
||||
|
||||
let actual = selectorPrinter.toElement(node);
|
||||
|
||||
assert.equal(actual.name, element.name);
|
||||
assert.deepEqual(actual.attributes, element.attributes);
|
||||
}
|
||||
|
||||
|
||||
suite('CSS - Selector Printing', () => {
|
||||
|
||||
test('class/hash/elementname/attr', function () {
|
||||
let p = new Parser();
|
||||
assertElement(p, 'element', { name: 'element' });
|
||||
assertElement(p, '.div', { attributes: { class: 'div' } });
|
||||
assertElement(p, '#first', { attributes: { id: 'first' } });
|
||||
assertElement(p, 'element.on', { name: 'element', attributes: { class: 'on' } });
|
||||
assertElement(p, 'element.on#first', { name: 'element', attributes: { class: 'on', id: 'first' } });
|
||||
assertElement(p, '.on#first', { attributes: { class: 'on', id: 'first' } });
|
||||
|
||||
assertElement(p, '[lang=\'de\']', { attributes: { lang: 'de' } });
|
||||
assertElement(p, '[enabled]', { attributes: { enabled: undefined } });
|
||||
|
||||
});
|
||||
|
||||
test('simple selector', function () {
|
||||
let p = new Parser();
|
||||
parseSelector(p, 'element { }', 'element', '{element}');
|
||||
parseSelector(p, 'element.div { }', 'element', '{element[class=div]}');
|
||||
parseSelector(p, 'element.on#first { }', 'element', '{element[class=on|id=first]}');
|
||||
parseSelector(p, 'element:hover { }', 'element', '{element[:hover=]}');
|
||||
parseSelector(p, 'element[lang=\'de\'] { }', 'element', '{element[lang=de]}');
|
||||
parseSelector(p, 'element[enabled] { }', 'element', '{element[enabled=undefined]}');
|
||||
parseSelector(p, 'element[foo~="warning"] { }', 'element', '{element[foo= … warning … ]}');
|
||||
parseSelector(p, 'element[lang|="en"] { }', 'element', '{element[lang=en-…]}');
|
||||
parseSelector(p, '* { }', '*', '{element}');
|
||||
});
|
||||
|
||||
test('selector', function () {
|
||||
let p = new Parser();
|
||||
parseSelector(p, 'e1 e2 { }', 'e1', '{e1{…{e2}}}');
|
||||
parseSelector(p, 'e1 .div { }', 'e1', '{e1{…{[class=div]}}}');
|
||||
parseSelector(p, 'e1 > e2 { }', 'e2', '{e1{e2}}');
|
||||
parseSelector(p, 'e1, e2 { }', 'e1', '{e1}');
|
||||
parseSelector(p, 'e1 + e2 { }', 'e2', '{e1|e2}');
|
||||
parseSelector(p, 'e1 ~ e2 { }', 'e2', '{e1|e2|⋮|e2}');
|
||||
});
|
||||
});
|
||||
23
extensions/css/server/src/test/textEditSupport.ts
Normal file
23
extensions/css/server/src/test/textEditSupport.ts
Normal file
@@ -0,0 +1,23 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
'use strict';
|
||||
|
||||
import {TextDocument, TextEdit} from 'vscode-languageserver';
|
||||
import * as assert from 'assert';
|
||||
|
||||
export function applyEdits(document: TextDocument, edits: TextEdit[]): string {
|
||||
let text = document.getText();
|
||||
let sortedEdits = edits.sort((a, b) => document.offsetAt(b.range.start) - document.offsetAt(a.range.start));
|
||||
let lastOffset = text.length;
|
||||
sortedEdits.forEach(e => {
|
||||
let startOffset = document.offsetAt(e.range.start);
|
||||
let endOffset = document.offsetAt(e.range.end);
|
||||
assert.ok(startOffset <= endOffset);
|
||||
assert.ok(endOffset <= lastOffset);
|
||||
text = text.substring(0, startOffset) + e.newText + text.substring(endOffset, text.length);
|
||||
lastOffset = startOffset;
|
||||
});
|
||||
return text;
|
||||
}
|
||||
Reference in New Issue
Block a user