cubetiq/code-server
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Update to VS Code 1.52.1

Browse Source
This commit is contained in:
Asher
2021-02-09 16:08:37 +00:00
parent 7f629c3675 e4a830e9b7
commit 859de79d97
1351 changed files with 56560 additions and 38990 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
lib/vscode/src/vs/base/test/browser/comparers.test.ts
View File

@@ -197,7 +197,7 @@ suite('Comparers', () => {
// name-only comparisons
assert(compareFileNamesDefault('a', 'A') === compareLocale('a', 'A'), 'the same letter sorts by locale');
assert(compareFileNamesDefault('â', 'Â') === compareLocale('â', 'Â'), 'the same accented letter sorts by locale');
assert.deepEqual(['artichoke', 'Artichoke', 'art', 'Art'].sort(compareFileNamesDefault), ['artichoke', 'Artichoke', 'art', 'Art'].sort(compareLocale), 'words with the same root and different cases sort in locale order');
// assert.deepEqual(['artichoke', 'Artichoke', 'art', 'Art'].sort(compareFileNamesDefault), ['artichoke', 'Artichoke', 'art', 'Art'].sort(compareLocale), 'words with the same root and different cases sort in locale order');
assert.deepEqual(['email', 'Email', 'émail', 'Émail'].sort(compareFileNamesDefault), ['email', 'Email', 'émail', 'Émail'].sort(compareLocale), 'the same base characters with different case or accents sort in locale order');
// numeric comparisons
@@ -259,7 +259,7 @@ suite('Comparers', () => {
// name-only comparisons
assert(compareFileExtensionsDefault('a', 'A') === compareLocale('a', 'A'), 'the same letter of different case sorts by locale');
assert(compareFileExtensionsDefault('â', 'Â') === compareLocale('â', 'Â'), 'the same accented letter of different case sorts by locale');
assert.deepEqual(['artichoke', 'Artichoke', 'art', 'Art'].sort(compareFileExtensionsDefault), ['artichoke', 'Artichoke', 'art', 'Art'].sort(compareLocale), 'words with the same root and different cases sort in locale order');
// assert.deepEqual(['artichoke', 'Artichoke', 'art', 'Art'].sort(compareFileExtensionsDefault), ['artichoke', 'Artichoke', 'art', 'Art'].sort(compareLocale), 'words with the same root and different cases sort in locale order');
assert.deepEqual(['email', 'Email', 'émail', 'Émail'].sort(compareFileExtensionsDefault), ['email', 'Email', 'émail', 'Émail'].sort((a, b) => a.localeCompare(b)), 'the same base characters with different case or accents sort in locale order');
// name plus extension comparisons

24
lib/vscode/src/vs/base/test/common/hash.test.ts → lib/vscode/src/vs/base/test/browser/hash.test.ts
View File

@@ -2,8 +2,10 @@
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as assert from 'assert';
import { hash, StringSHA1 } from 'vs/base/common/hash';
import { sha1Hex } from 'vs/base/browser/hash';
suite('Hash', () => {
test('string', () => {
@@ -71,28 +73,32 @@ suite('Hash', () => {
});
function checkSHA1(strings: string[], expected: string) {
async function checkSHA1(str: string, expected: string) {
// Test with StringSHA1
const hash = new StringSHA1();
for (const str of strings) {
hash.update(str);
}
const actual = hash.digest();
hash.update(str);
let actual = hash.digest();
assert.equal(actual, expected);
// Test with crypto.subtle
actual = await sha1Hex(str);
assert.equal(actual, expected);
}
test('sha1-1', () => {
checkSHA1(['\udd56'], '9bdb77276c1852e1fb067820472812fcf6084024');
return checkSHA1('\udd56', '9bdb77276c1852e1fb067820472812fcf6084024');
});
test('sha1-2', () => {
checkSHA1(['\udb52'], '9bdb77276c1852e1fb067820472812fcf6084024');
return checkSHA1('\udb52', '9bdb77276c1852e1fb067820472812fcf6084024');
});
test('sha1-3', () => {
checkSHA1(['\uda02ꑍ'], '9b483a471f22fe7e09d83f221871a987244bbd3f');
return checkSHA1('\uda02ꑍ', '9b483a471f22fe7e09d83f221871a987244bbd3f');
});
test('sha1-4', () => {
checkSHA1(['hello'], 'aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d');
return checkSHA1('hello', 'aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d');
});
});

22
lib/vscode/src/vs/base/test/browser/markdownRenderer.test.ts
View File

@@ -5,7 +5,7 @@
import * as assert from 'assert';
import * as marked from 'vs/base/common/marked/marked';
import { renderMarkdown } from 'vs/base/browser/markdownRenderer';
import { renderMarkdown, renderMarkdownAsPlaintext } from 'vs/base/browser/markdownRenderer';
import { MarkdownString, IMarkdownString } from 'vs/base/common/htmlContent';
import { URI } from 'vs/base/common/uri';
import { parse } from 'vs/base/common/marshalling';
@@ -57,7 +57,7 @@ suite('MarkdownRenderer', () => {
mds.appendText('$(zap) $(not a theme icon) $(add)');
let result: HTMLElement = renderMarkdown(mds);
assert.strictEqual(result.innerHTML, `<p>$(zap) $(not a theme icon) $(add)</p>`);
assert.strictEqual(result.innerHTML, `<p>$(zap)&nbsp;$(not&nbsp;a&nbsp;theme&nbsp;icon)&nbsp;$(add)</p>`);
});
test('render appendMarkdown', () => {
@@ -85,7 +85,7 @@ suite('MarkdownRenderer', () => {
mds.appendText('$(zap) $(not a theme icon) $(add)');
let result: HTMLElement = renderMarkdown(mds);
assert.strictEqual(result.innerHTML, `<p>$(zap) $(not a theme icon) $(add)</p>`);
assert.strictEqual(result.innerHTML, `<p>$(zap)&nbsp;$(not&nbsp;a&nbsp;theme&nbsp;icon)&nbsp;$(add)</p>`);
});
test('render appendMarkdown with escaped icon', () => {
@@ -115,4 +115,20 @@ suite('MarkdownRenderer', () => {
assert.ok(data.documentUri.toString().startsWith('file:///c%3A/'));
});
suite('PlaintextMarkdownRender', () => {
test('test code, blockquote, heading, list, listitem, paragraph, table, tablerow, tablecell, strong, em, br, del, text are rendered plaintext', () => {
const markdown = { value: '`code`\n>quote\n# heading\n- list\n\n\ntable | table2\n--- | --- \none | two\n\n\nbo**ld**\n_italic_\n~~del~~\nsome text' };
const expected = 'code\nquote\nheading\nlist\ntable table2 one two \nbold\nitalic\ndel\nsome text\n';
const result: string = renderMarkdownAsPlaintext(markdown);
assert.strictEqual(result, expected);
});
test('test html, hr, image, link are rendered plaintext', () => {
const markdown = { value: '<div>html</div>\n\n---\n![image](imageLink)\n[text](textLink)' };
const expected = '\ntext\n';
const result: string = renderMarkdownAsPlaintext(markdown);
assert.strictEqual(result, expected);
});
});
});

10
lib/vscode/src/vs/base/test/browser/ui/scrollbar/scrollbarState.test.ts
View File

@@ -18,8 +18,11 @@ suite('ScrollbarState', () => {
assert.equal(actual.getSliderSize(), 20);
assert.equal(actual.getSliderPosition(), 249);
assert.equal(actual.getDesiredScrollPositionFromOffset(259), 32849);
// 259 is greater than 230 so page down, 32787 + 339 = 33126
assert.equal(actual.getDesiredScrollPositionFromOffsetPaged(259), 33126);
actual.setScrollPosition(32849);
assert.equal(actual.getArrowSize(), 0);
assert.equal(actual.getScrollPosition(), 32849);
@@ -41,8 +44,11 @@ suite('ScrollbarState', () => {
assert.equal(actual.getSliderSize(), 20);
assert.equal(actual.getSliderPosition(), 230);
assert.equal(actual.getDesiredScrollPositionFromOffset(240 + 12), 32811);
// 240 + 12 = 252; greater than 230 so page down, 32787 + 339 = 33126
assert.equal(actual.getDesiredScrollPositionFromOffsetPaged(240 + 12), 33126);
actual.setScrollPosition(32811);
assert.equal(actual.getArrowSize(), 12);
assert.equal(actual.getScrollPosition(), 32811);

8
lib/vscode/src/vs/base/test/browser/ui/splitview/splitview.test.ts
View File

@@ -91,7 +91,7 @@ suite('Splitview', () => {
splitview.addView(view2, 20);
splitview.addView(view3, 20);
let viewQuery = container.querySelectorAll('.monaco-split-view2 > .split-view-container > .split-view-view');
let viewQuery = container.querySelectorAll('.monaco-split-view2 > .monaco-scrollable-element > .split-view-container > .split-view-view');
assert.equal(viewQuery.length, 3, 'split view should have 3 views');
let sashQuery = container.querySelectorAll('.monaco-split-view2 > .sash-container > .monaco-sash');
@@ -99,7 +99,7 @@ suite('Splitview', () => {
splitview.removeView(2);
viewQuery = container.querySelectorAll('.monaco-split-view2 > .split-view-container > .split-view-view');
viewQuery = container.querySelectorAll('.monaco-split-view2 > .monaco-scrollable-element > .split-view-container > .split-view-view');
assert.equal(viewQuery.length, 2, 'split view should have 2 views');
sashQuery = container.querySelectorAll('.monaco-split-view2 > .sash-container > .monaco-sash');
@@ -107,7 +107,7 @@ suite('Splitview', () => {
splitview.removeView(0);
viewQuery = container.querySelectorAll('.monaco-split-view2 > .split-view-container > .split-view-view');
viewQuery = container.querySelectorAll('.monaco-split-view2 > .monaco-scrollable-element > .split-view-container > .split-view-view');
assert.equal(viewQuery.length, 1, 'split view should have 1 view');
sashQuery = container.querySelectorAll('.monaco-split-view2 > .sash-container > .monaco-sash');
@@ -115,7 +115,7 @@ suite('Splitview', () => {
splitview.removeView(0);
viewQuery = container.querySelectorAll('.monaco-split-view2 > .split-view-container > .split-view-view');
viewQuery = container.querySelectorAll('.monaco-split-view2 > .monaco-scrollable-element > .split-view-container > .split-view-view');
assert.equal(viewQuery.length, 0, 'split view should have no views');
sashQuery = container.querySelectorAll('.monaco-split-view2 > .sash-container > .monaco-sash');

79
lib/vscode/src/vs/base/test/common/async.test.ts
View File

@@ -7,7 +7,7 @@ import * as assert from 'assert';
import * as async from 'vs/base/common/async';
import { isPromiseCanceledError } from 'vs/base/common/errors';
import { URI } from 'vs/base/common/uri';
import { CancellationTokenSource } from 'vs/base/common/cancellation';
import { CancellationToken, CancellationTokenSource } from 'vs/base/common/cancellation';
suite('Async', () => {
@@ -651,41 +651,39 @@ suite('Async', () => {
test('raceCancellation', async () => {
const cts = new CancellationTokenSource();
const now = Date.now();
const p = async.raceCancellation(async.timeout(100), cts.token);
let triggered = false;
const p = async.raceCancellation(async.timeout(100).then(() => triggered = true), cts.token);
cts.cancel();
await p;
assert.ok(Date.now() - now < 100);
assert.ok(!triggered);
});
test('raceTimeout', async () => {
const cts = new CancellationTokenSource();
// timeout wins
let now = Date.now();
let timedout = false;
let triggered = false;
const p1 = async.raceTimeout(async.timeout(100), 1, () => timedout = true);
const p1 = async.raceTimeout(async.timeout(100).then(() => triggered = true), 1, () => timedout = true);
cts.cancel();
await p1;
assert.ok(Date.now() - now < 100);
assert.ok(!triggered);
assert.equal(timedout, true);
// promise wins
now = Date.now();
timedout = false;
const p2 = async.raceTimeout(async.timeout(1), 100, () => timedout = true);
const p2 = async.raceTimeout(async.timeout(1).then(() => triggered = true), 100, () => timedout = true);
cts.cancel();
await p2;
assert.ok(Date.now() - now < 100);
assert.ok(triggered);
assert.equal(timedout, false);
});
@@ -719,4 +717,63 @@ suite('Async', () => {
assert.equal(counter.increment(), 2);
assert.equal(counter.increment(), 3);
});
test('firstParallel - simple', async () => {
const a = await async.firstParallel([
Promise.resolve(1),
Promise.resolve(2),
Promise.resolve(3),
], v => v === 2);
assert.equal(a, 2);
});
test('firstParallel - uses null default', async () => {
assert.equal(await async.firstParallel([Promise.resolve(1)], v => v === 2), null);
});
test('firstParallel - uses value default', async () => {
assert.equal(await async.firstParallel([Promise.resolve(1)], v => v === 2, 4), 4);
});
test('firstParallel - empty', async () => {
assert.equal(await async.firstParallel([], v => v === 2, 4), 4);
});
test('firstParallel - cancels', async () => {
let ct1: CancellationToken;
const p1 = async.createCancelablePromise(async (ct) => {
ct1 = ct;
await async.timeout(200, ct);
return 1;
});
let ct2: CancellationToken;
const p2 = async.createCancelablePromise(async (ct) => {
ct2 = ct;
await async.timeout(2, ct);
return 2;
});
assert.equal(await async.firstParallel([p1, p2], v => v === 2, 4), 2);
assert.equal(ct1!.isCancellationRequested, true, 'should cancel a');
assert.equal(ct2!.isCancellationRequested, true, 'should cancel b');
});
test('firstParallel - rejection handling', async () => {
let ct1: CancellationToken;
const p1 = async.createCancelablePromise(async (ct) => {
ct1 = ct;
await async.timeout(200, ct);
return 1;
});
let ct2: CancellationToken;
const p2 = async.createCancelablePromise(async (ct) => {
ct2 = ct;
await async.timeout(2, ct);
throw new Error('oh no');
});
assert.equal(await async.firstParallel([p1, p2], v => v === 2, 4).catch(() => 'ok'), 'ok');
assert.equal(ct1!.isCancellationRequested, true, 'should cancel a');
assert.equal(ct2!.isCancellationRequested, true, 'should cancel b');
});
});

2
lib/vscode/src/vs/base/test/common/linkedList.test.ts
View File

@@ -14,7 +14,7 @@ suite('LinkedList', function () {
assert.equal(list.size, elements.length);
// assert toArray
assert.deepEqual(list.toArray(), elements);
assert.deepEqual(Array.from(list), elements);
// assert Symbol.iterator (1)
assert.deepEqual([...list], elements);

153
lib/vscode/src/vs/base/test/common/map.test.ts
View File

@@ -3,7 +3,7 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { ResourceMap, TernarySearchTree, PathIterator, StringIterator, LinkedMap, Touch, LRUCache, UriIterator } from 'vs/base/common/map';
import { ResourceMap, TernarySearchTree, PathIterator, StringIterator, LinkedMap, Touch, LRUCache, UriIterator, ConfigKeysIterator } from 'vs/base/common/map';
import * as assert from 'assert';
import { URI } from 'vs/base/common/uri';
import { extUriIgnorePathCase } from 'vs/base/common/resources';
@@ -368,7 +368,7 @@ suite('Map', () => {
});
test('URIIterator', function () {
const iter = new UriIterator(false);
const iter = new UriIterator(() => false);
iter.reset(URI.parse('file:///usr/bin/file.txt'));
assert.equal(iter.value(), 'file');
@@ -549,13 +549,15 @@ suite('Map', () => {
trie.set('foo', 1);
trie.set('foobar', 2);
trie.set('bar', 3);
trie.set('foobarbaz', 4);
trie.deleteSuperstr('foo');
assertTernarySearchTree(trie, ['bar', 3]);
assertTernarySearchTree(trie, ['foo', 1], ['bar', 3]);
trie = new TernarySearchTree<string, number>(new StringIterator());
trie.set('foo', 1);
trie.set('foobar', 2);
trie.set('bar', 3);
trie.set('foobarbaz', 4);
trie.deleteSuperstr('fo');
assertTernarySearchTree(trie, ['bar', 3]);
@@ -612,17 +614,17 @@ suite('Map', () => {
map.set('/user/foo/flip/flop', 3);
map.set('/usr/foo', 4);
let item: IteratorResult<number>;
let item: IteratorResult<[string, number]>;
let iter = map.findSuperstr('/user');
item = iter!.next();
assert.equal(item.value, 2);
assert.equal(item.value[1], 2);
assert.equal(item.done, false);
item = iter!.next();
assert.equal(item.value, 1);
assert.equal(item.value[1], 1);
assert.equal(item.done, false);
item = iter!.next();
assert.equal(item.value, 3);
assert.equal(item.value[1], 3);
assert.equal(item.done, false);
item = iter!.next();
assert.equal(item.value, undefined);
@@ -630,7 +632,7 @@ suite('Map', () => {
iter = map.findSuperstr('/usr');
item = iter!.next();
assert.equal(item.value, 4);
assert.equal(item.value[1], 4);
assert.equal(item.done, false);
item = iter!.next();
@@ -675,12 +677,12 @@ suite('Map', () => {
map.set('/usr/foo', 4);
map.deleteSuperstr('/user/foo');
assertTernarySearchTree(map,
['/usr/foo', 4],
['/user/foo', 2], ['/usr/foo', 4],
);
});
test('TernarySearchTree (URI) - basics', function () {
let trie = new TernarySearchTree<URI, number>(new UriIterator(false));
let trie = new TernarySearchTree<URI, number>(new UriIterator(() => false));
trie.set(URI.file('/user/foo/bar'), 1);
trie.set(URI.file('/user/foo'), 2);
@@ -700,7 +702,7 @@ suite('Map', () => {
test('TernarySearchTree (URI) - lookup', function () {
const map = new TernarySearchTree<URI, number>(new UriIterator(false));
const map = new TernarySearchTree<URI, number>(new UriIterator(() => false));
map.set(URI.parse('http://foo.bar/user/foo/bar'), 1);
map.set(URI.parse('http://foo.bar/user/foo?query'), 2);
map.set(URI.parse('http://foo.bar/user/foo?QUERY'), 3);
@@ -715,25 +717,35 @@ suite('Map', () => {
assert.equal(map.get(URI.parse('http://foo.bar/user/foo/bar/boo')), undefined);
});
test('TernarySearchTree (PathSegments) - superstr', function () {
test('TernarySearchTree (URI) - lookup, casing', function () {
const map = new TernarySearchTree<URI, number>(new UriIterator(false));
const map = new TernarySearchTree<URI, number>(new UriIterator(uri => /^https?$/.test(uri.scheme)));
map.set(URI.parse('http://foo.bar/user/foo/bar'), 1);
assert.equal(map.get(URI.parse('http://foo.bar/USER/foo/bar')), 1);
map.set(URI.parse('foo://foo.bar/user/foo/bar'), 1);
assert.equal(map.get(URI.parse('foo://foo.bar/USER/foo/bar')), undefined);
});
test('TernarySearchTree (URI) - superstr', function () {
const map = new TernarySearchTree<URI, number>(new UriIterator(() => false));
map.set(URI.file('/user/foo/bar'), 1);
map.set(URI.file('/user/foo'), 2);
map.set(URI.file('/user/foo/flip/flop'), 3);
map.set(URI.file('/usr/foo'), 4);
let item: IteratorResult<number>;
let item: IteratorResult<[URI, number]>;
let iter = map.findSuperstr(URI.file('/user'))!;
item = iter.next();
assert.equal(item.value, 2);
assert.equal(item.value[1], 2);
assert.equal(item.done, false);
item = iter.next();
assert.equal(item.value, 1);
assert.equal(item.value[1], 1);
assert.equal(item.done, false);
item = iter.next();
assert.equal(item.value, 3);
assert.equal(item.value[1], 3);
assert.equal(item.done, false);
item = iter.next();
assert.equal(item.value, undefined);
@@ -741,7 +753,7 @@ suite('Map', () => {
iter = map.findSuperstr(URI.file('/usr'))!;
item = iter.next();
assert.equal(item.value, 4);
assert.equal(item.value[1], 4);
assert.equal(item.done, false);
item = iter.next();
@@ -750,16 +762,16 @@ suite('Map', () => {
iter = map.findSuperstr(URI.file('/'))!;
item = iter.next();
assert.equal(item.value, 2);
assert.equal(item.value[1], 2);
assert.equal(item.done, false);
item = iter.next();
assert.equal(item.value, 1);
assert.equal(item.value[1], 1);
assert.equal(item.done, false);
item = iter.next();
assert.equal(item.value, 3);
assert.equal(item.value[1], 3);
assert.equal(item.done, false);
item = iter.next();
assert.equal(item.value, 4);
assert.equal(item.value[1], 4);
assert.equal(item.done, false);
item = iter.next();
assert.equal(item.value, undefined);
@@ -771,6 +783,103 @@ suite('Map', () => {
assert.equal(map.findSuperstr(URI.file('/userr')), undefined);
});
test('TernarySearchTree (ConfigKeySegments) - basics', function () {
let trie = new TernarySearchTree<string, number>(new ConfigKeysIterator());
trie.set('config.foo.bar', 1);
trie.set('config.foo', 2);
trie.set('config.foo.flip.flop', 3);
assert.equal(trie.get('config.foo.bar'), 1);
assert.equal(trie.get('config.foo'), 2);
assert.equal(trie.get('config.foo.flip.flop'), 3);
assert.equal(trie.findSubstr('config.bar'), undefined);
assert.equal(trie.findSubstr('config.foo'), 2);
assert.equal(trie.findSubstr('config.foo.ba'), 2);
assert.equal(trie.findSubstr('config.foo.far.boo'), 2);
assert.equal(trie.findSubstr('config.foo.bar'), 1);
assert.equal(trie.findSubstr('config.foo.bar.far.boo'), 1);
});
test('TernarySearchTree (ConfigKeySegments) - lookup', function () {
const map = new TernarySearchTree<string, number>(new ConfigKeysIterator());
map.set('config.foo.bar', 1);
map.set('config.foo', 2);
map.set('config.foo.flip.flop', 3);
assert.equal(map.get('foo'), undefined);
assert.equal(map.get('config'), undefined);
assert.equal(map.get('config.foo'), 2);
assert.equal(map.get('config.foo.bar'), 1);
assert.equal(map.get('config.foo.bar.boo'), undefined);
});
test('TernarySearchTree (ConfigKeySegments) - superstr', function () {
const map = new TernarySearchTree<string, number>(new ConfigKeysIterator());
map.set('config.foo.bar', 1);
map.set('config.foo', 2);
map.set('config.foo.flip.flop', 3);
map.set('boo', 4);
let item: IteratorResult<[string, number]>;
let iter = map.findSuperstr('config');
item = iter!.next();
assert.equal(item.value[1], 2);
assert.equal(item.done, false);
item = iter!.next();
assert.equal(item.value[1], 1);
assert.equal(item.done, false);
item = iter!.next();
assert.equal(item.value[1], 3);
assert.equal(item.done, false);
item = iter!.next();
assert.equal(item.value, undefined);
assert.equal(item.done, true);
assert.equal(map.findSuperstr('foo'), undefined);
assert.equal(map.findSuperstr('config.foo.no'), undefined);
assert.equal(map.findSuperstr('config.foop'), undefined);
});
test('TernarySearchTree (ConfigKeySegments) - delete_superstr', function () {
const map = new TernarySearchTree<string, number>(new ConfigKeysIterator());
map.set('config.foo.bar', 1);
map.set('config.foo', 2);
map.set('config.foo.flip.flop', 3);
map.set('boo', 4);
assertTernarySearchTree(map,
['config.foo.bar', 1],
['config.foo', 2],
['config.foo.flip.flop', 3],
['boo', 4],
);
// not a segment
map.deleteSuperstr('config.fo');
assertTernarySearchTree(map,
['config.foo.bar', 1],
['config.foo', 2],
['config.foo.flip.flop', 3],
['boo', 4],
);
// delete a segment
map.set('config.foo.bar', 1);
map.set('config.foo', 2);
map.set('config.foo.flip.flop', 3);
map.set('config.boo', 4);
map.deleteSuperstr('config.foo');
assertTernarySearchTree(map,
['config.foo', 2], ['boo', 4],
);
});
test('ResourceMap - basics', function () {
const map = new ResourceMap<any>();

18
lib/vscode/src/vs/base/test/common/markdownString.test.ts
View File

@@ -8,12 +8,24 @@ import { MarkdownString } from 'vs/base/common/htmlContent';
suite('MarkdownString', () => {
test('Escape leading whitespace', function () {
const mds = new MarkdownString();
mds.appendText('Hello\n Not a code block');
assert.equal(mds.value, 'Hello\n\n&nbsp;&nbsp;&nbsp;&nbsp;Not&nbsp;a&nbsp;code&nbsp;block');
});
test('MarkdownString.appendText doesn\'t escape quote #109040', function () {
const mds = new MarkdownString();
mds.appendText('> Text\n>More');
assert.equal(mds.value, '\\>&nbsp;Text\n\n\\>More');
});
test('appendText', () => {
const mds = new MarkdownString();
mds.appendText('# foo\n*bar*');
assert.equal(mds.value, '\\# foo\n\n\\*bar\\*');
assert.equal(mds.value, '\\#&nbsp;foo\n\n\\*bar\\*');
});
suite('ThemeIcons', () => {
@@ -24,7 +36,7 @@ suite('MarkdownString', () => {
const mds = new MarkdownString(undefined, { supportThemeIcons: true });
mds.appendText('$(zap) $(not a theme icon) $(add)');
assert.equal(mds.value, '\\\\$\\(zap\\) $\\(not a theme icon\\) \\\\$\\(add\\)');
assert.equal(mds.value, '\\\\$\\(zap\\)&nbsp;$\\(not&nbsp;a&nbsp;theme&nbsp;icon\\)&nbsp;\\\\$\\(add\\)');
});
test('appendMarkdown', () => {
@@ -49,7 +61,7 @@ suite('MarkdownString', () => {
const mds = new MarkdownString(undefined, { supportThemeIcons: false });
mds.appendText('$(zap) $(not a theme icon) $(add)');
assert.equal(mds.value, '$\\(zap\\) $\\(not a theme icon\\) $\\(add\\)');
assert.equal(mds.value, '$\\(zap\\)&nbsp;$\\(not&nbsp;a&nbsp;theme&nbsp;icon\\)&nbsp;$\\(add\\)');
});
test('appendMarkdown', () => {

70
lib/vscode/src/vs/base/test/common/network.test.ts Normal file
View File

@@ -0,0 +1,70 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as assert from 'assert';
import { URI } from 'vs/base/common/uri';
import { FileAccess, Schemas } from 'vs/base/common/network';
import { isEqual } from 'vs/base/common/resources';
import { isElectronSandboxed } from 'vs/base/common/platform';
suite('network', () => {
const enableTest = isElectronSandboxed;
(!enableTest ? test.skip : test)('FileAccess: URI (native)', () => {
// asCodeUri() & asFileUri(): simple, without authority
let originalFileUri = URI.file('network.test.ts');
let browserUri = FileAccess.asBrowserUri(originalFileUri);
assert.ok(browserUri.authority.length > 0);
let fileUri = FileAccess.asFileUri(browserUri);
assert.equal(fileUri.authority.length, 0);
assert(isEqual(originalFileUri, fileUri));
// asCodeUri() & asFileUri(): with authority
originalFileUri = URI.file('network.test.ts').with({ authority: 'test-authority' });
browserUri = FileAccess.asBrowserUri(originalFileUri);
assert.equal(browserUri.authority, originalFileUri.authority);
fileUri = FileAccess.asFileUri(browserUri);
assert(isEqual(originalFileUri, fileUri));
});
(!enableTest ? test.skip : test)('FileAccess: moduleId (native)', () => {
const browserUri = FileAccess.asBrowserUri('vs/base/test/node/network.test', require);
assert.equal(browserUri.scheme, Schemas.vscodeFileResource);
const fileUri = FileAccess.asFileUri('vs/base/test/node/network.test', require);
assert.equal(fileUri.scheme, Schemas.file);
});
(!enableTest ? test.skip : test)('FileAccess: query and fragment is dropped (native)', () => {
let originalFileUri = URI.file('network.test.ts').with({ query: 'foo=bar', fragment: 'something' });
let browserUri = FileAccess.asBrowserUri(originalFileUri);
assert.equal(browserUri.query, '');
assert.equal(browserUri.fragment, '');
});
(!enableTest ? test.skip : test)('FileAccess: query and fragment is kept if URI is already of same scheme (native)', () => {
let originalFileUri = URI.file('network.test.ts').with({ query: 'foo=bar', fragment: 'something' });
let browserUri = FileAccess.asBrowserUri(originalFileUri.with({ scheme: Schemas.vscodeFileResource }));
assert.equal(browserUri.query, 'foo=bar');
assert.equal(browserUri.fragment, 'something');
let fileUri = FileAccess.asFileUri(originalFileUri);
assert.equal(fileUri.query, 'foo=bar');
assert.equal(fileUri.fragment, 'something');
});
(!enableTest ? test.skip : test)('FileAccess: web', () => {
const originalHttpsUri = URI.file('network.test.ts').with({ scheme: 'https' });
const browserUri = FileAccess.asBrowserUri(originalHttpsUri);
assert.equal(originalHttpsUri.toString(), browserUri.toString());
});
test('FileAccess: remote URIs', () => {
const originalRemoteUri = URI.file('network.test.ts').with({ scheme: Schemas.vscodeRemote });
const browserUri = FileAccess.asBrowserUri(originalRemoteUri);
assert.notEqual(originalRemoteUri.scheme, browserUri.scheme);
});
});

1
lib/vscode/src/vs/base/test/common/processes.test.ts
View File

@@ -19,7 +19,6 @@ suite('Processes', () => {
VSCODE_CLI: 'x',
VSCODE_DEV: 'x',
VSCODE_IPC_HOOK: 'x',
VSCODE_LOGS: 'x',
VSCODE_NLS_CONFIG: 'x',
VSCODE_PORTABLE: 'x',
VSCODE_PID: 'x',

5
lib/vscode/src/vs/base/test/common/strings.test.ts
View File

@@ -417,4 +417,9 @@ suite('Strings', () => {
test('getGraphemeBreakType', () => {
assert.equal(strings.getGraphemeBreakType(0xBC1), strings.GraphemeBreakType.SpacingMark);
});
test('truncate', () => {
assert.equal('hello world', strings.truncate('hello world', 100));
assert.equal('hello…', strings.truncate('hello world', 5));
});
});