ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-02-08 17:24:01 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge VS Code 1.26.1 (#2394)

Browse Source 
* Squash merge commits for 1.26 (#1) (#2323)

* Polish tag search as per feedback (#55269)

* Polish tag search as per feedback

* Updated regex

* Allow users to opt-out of features that send online requests in the background (#55097)

* settings sweep #54690

* Minor css tweaks to enable eoverflow elipsis in more places (#55277)

* fix an issue with titlebarheight when not scaling with zoom

* Settings descriptions update #54690

* fixes #55209

* Settings editor - many padding fixes

* More space above level 2 label

* Fixing Cannot debug npm script using Yarn #55103

* Settings editor - show ellipsis when description overflows

* Settings editor - ... fix measuring around links, relayout

* Setting descriptions

* Settings editor - fix ... for some short lines, fix select container width

* Settings editor - overlay trees so scrollable shadow is full width

* Fix #54133 - missing extension settings after reload

* Settings color token description tweak

* Settings editor - disable overflow indicator temporarily, needs to be faster

* Added command to Run the selected npm script

* fixes #54452

* fixes #54929

* fixes #55248

* prefix command with extension name

* Contribute run selected to the context menu

* node-debug@1.26.6

* Allow terminal rendererType to be swapped out at runtime

Part of #53274
Fixes #55344

* Settings editor - fix not focusing search when restoring editor
setInput must be actually async. Will be fixed naturally when we aren't using winJS promises...

* Settings editor - TOC should only expand the section with a selected item

* Bump node-debug2

* Settings editor - Tree focus outlines

* Settings editor - don't blink the scrollbar when toc selection changes
And hide TOC correctly when the editor is narrow

* Settings editor - header rows should not be selectable

* fixes #54877

* change debug assignee to isi

* Settings sweep (#54690)

* workaround for #55051

* Settings sweep (#54690)

* settings sweep

#54690

* Don't try closing tags when you type > after another >

* Describe what implementation code lens does

Fixes #55370

* fix javadoc formatter setting description

* fixes #55325

* update to officical TS version

* Settings editor - Even more padding, use semibold instead of bold

* Fix #55357 - fix TOC twistie

* fixes #55288

* explorer: refresh on di change file system provider registration

fixes #53256

* Disable push to Linux repo to test standalone publisher

* New env var to notify log level to extensions #54001

* Disable snippets in extension search (when not in suggest dropdown) (#55281)

* Disable snippits in extension search (when not in suggest dropdown)

* Add monaco input contributions

* Fix bug preventing snippetSuggestions from taking effect in sub-editors

* Latest emmet helper to fix #52366

* Fix comment updates for threads within same file

* Allow extensions to log telemetry to log files #54001

* Pull latest css grammar

* files.exclude control - use same style for "add" vs "edit"

* files.exclude control - focus/keyboard behavior

* don't show menubar too early

* files.exclude - better styling

* Place cursor at end of extensions search box on autofill (#55254)

* Place cursor at end of extensions search box on autofill

* Use position instead of selection

* fix linux build issue (empty if block)

* Settings editor - fix extension category prefixes

* Settings editor - add simple ellipsis for first line that overflows, doesn't cover case when first line does not overflow but there is more text, TODO

* File/Text search provider docs

* Fixes #52655

* Include epoch (#55008)

* Fixes #53385

* Fixes #49480

*  VS Code Insiders (Users) not opening Fixes #55353

* Better handling of the case when the extension host fails to start

* Fixes #53966

*  Remove confusing Start from wordPartLeft commands ID

* vscode-xterm@3.6.0-beta12

Fixes #55488

* Initial size is set to infinity!! Fixes #55461

* Polish embeddedEditorBackground

* configuration service misses event

* Fix #55224 - fix duplicate results in multiroot workspace from splitting the diskseach query

* Select all not working in issue reporter on mac, fixes #55424

* Disable fuzzy matching for extensions autosuggest (#55498)

* Fix clipping of extensions search border in some third party themes (#55504)

* fixes #55538

* Fix bug causing an aria alert to not be shown the third time
 (and odd numbers thereafter)

* Settings editor - work around rendering glitch with webkit-line-clamp

* Settings editor - revert earlier '...' changes

* Settings editor - move enumDescription to its own div, because it disturbs -webkit-line-clamp for some reason

* Settings editor - better overflow indicator

* Don't show existing filters in autocomplete (#55495)

* Dont show existing filters in autocomplete

* Simplify

* Settings Editor: Add aria labels for input elements Fixes: #54836 (#55543)

* fixes #55223

* Update vscode-css-languageservice to 3.0.10-next.1

* Fix #55509 - settings navigation

* Fix #55519

* Fix #55520

* FIx #55524

* Fix #55556 - include wordSeparators in all search queries, so findTextInFiles can respect isWordMatch correctly

* oss updates for endgame

* Fix unit tests

* fixes #55522

* Avoid missing manifest error from bubbling up #54757

* Settings format crawl

* Search provider - Fix FileSearchProvider to return array, not progress

* Fix #55598

* Settings editor - fix NPE rendering settings with no description

* dont render inden guides in search box (#55600)

* fixes #55454

* More settings crawl

* Another change for #55598 - maxResults applies to FileSearch and TextSearch but not FileIndex

* Fix FileSearchProvider unit tests for progress change

* fixes #55561

* Settings description update for #54690

* Update setting descriptions for online services

* Minor edits

* fixes #55513

* fixes #55451

* Fix #55612 - fix findTextInFiles cancellation

* fixes #55539

* More setting description tweaks

* Setting to disable online experiments #54354

* fixes #55507

* fixes #55515

* Show online services action only in Insiders for now

* Settings editor - change toc behavior default to 'filter'

* Settings editor - nicer filter count style during search

* Fix #55617 - search viewlet icons

* Settings editor - better styling for element count indicator

* SearchProvider - fix NPE when searching extraFileResources

* Allow extends to work without json suffix

Fixes #16905

* Remove accessability options logic entirely

Follow up on #55451

* use latest version of DAP

* fixes #55490

* fixes #55122

* fixes #52332

* Avoid assumptions about git: URIs (fixes #36236)

* relative path for descriptions

* resourece: get rid of isFile context key

fixes #48275

* Register previous ids for compatibility (#53497)

* more tuning for #48275

* no need to always re-read "files explorer"

fixes #52003

* read out active composites properly

fixes #51967

* Update link colors for hc theme to meet color contrast ratio, fixes #55651

Also updated link color for `textLinkActiveForeground` to be the same as `textLinkForeground` as it wasn't properly updated

* detect 'winpty-agent.exe'; fixes #55672

* node-debug@1.26.7

* reset counter on new label

* Settings editor - fix multiple setting links in one description

* Settings editor - color code blocks in setting descriptions, fix #55532

* Settings editor - hover color in TOC

* Settings editor - fix navigation NPE

* Settings editor - fix text control width

* Settings editor - maybe fix #55684

* Fix bug causing cursor to not move on paste

* fixes #53582

* Use ctrlCmd instead of ctrl for go down from search box

* fixes #55264

* fixes #55456

* filter for spcaes before triggering search (#55611)

* Fix #55698 - don't lose filtered TOC counts when refreshing TOC

* fixes #55421

* fixes #28979

* fixes #55576

* only add check for updates to windows/linux help

* readonly files: append decoration to label

fixes #53022

* debug: do not show toolbar while initialising

fixes #55026

* Opening launch.json should not activate debug extensions

fixes #55029

* fixes #55435

* fixes #55434

* fixes #55439

* trigger menu only on altkey up

* Fix #50555 - fix settings editor memory leak

* Fix #55712 - no need to focus 'a' anymore when restoring control focus after tree render

* fixes #55335

* proper fix for readonly model

fixes #53022

* improve FoldingRangeKind spec (for #55686)

* Use class with static fields (fixes #55494)

* Fixes #53671

* fixes #54630

* [html] should disable ionic suggestions by default. Currently forces deprecated Ionic v1 suggestions in .html files while typing. Fixes #53324

* cleanup deps

* debug issues back to andre

* update electron for smoketest

* Fix #55757 - prevent settings tabs from overflowing

* Fix #53897 - revert setting menu defaults to old editor

* Add enum descriptions to `typescript.preferences.importModuleSpecifier`

* Fix #55767 - leaking style elements from settings editor

* Fix #55521 - prevent flashing when clicking in exclude control

* Update Git modified color for contrast ratio, fixes #53140

* Revert "Merge branch 'master' of github.com:Microsoft/vscode"

This reverts commit bf46b6bfbae0cab99c2863e1244a916181fa9fbc, reversing
changes made to e275a424483dfb4ed33b428c97d5e2c441d6b917.

* Revert "Revert "Merge branch 'master' of github.com:Microsoft/vscode""

This reverts commit 53949d963f39e40757557c6526332354a31d9154.

* don't ask to install an incomplete menu

* Fix NPE in terminal AccessibilityManager

Fixes #55744

* don't display fallback menu unless we've closed the last window

* fixes #55547

* Fix smoke tests for extension search box

* Update OSSREADME.json for Electron 2.0.5

* Update distro

Includes Chromium license changes

* fix #55455

* fix #55865

* fixes #55893

* Fix bug causing workspace recommendations to go away upon ignoring a recommendation (#55805)

* Fix bug causing workspace recommendations to go away upon ignoring a recommendation

* ONly show on @recommended or @recommended:workspace

* Make more consistant

* Fix #55911

* Understand json activity (#55926)

* Understand json file activity

* Refactoring

* adding composer.json

* Distro update for experiments

* use terminal.processId for auto-attach; fixes #55918

* Reject invalid URI with vscode.openFolder (for #55891)

* improve win32 setup system vs user detection

fixes #55840

fixes #55840

delay winreg import

related to #55840

show notification earlier

related to #55840

fix #55840

update inno setup message

related to #55840

* Fix #55593 - this code only operates on local paths, so use fsPath and Uri.file instead

* Bring back the old menu due to electron 2.0 issues (#55913)

* add the old menu back for native menus

* make menu labels match

* `vscode.openFolder`: treat missing URI schema gracefully (for #55891)

* delay EH reattach; fixes #55955

* Mark all json files under appSettingsHome as settings

* Use localized strings for telemetry opt-out

* Exception when saving file editor opened from remote file provider (fixes #55051)

* Remove terminal menu from stable

Fixes 56003

* VSCode Insiders crashes on open with TypeError: Cannot read property 'lastIndexOf' of undefined. Fixes #54933

* improve fix for #55891

* fix #55916

* Improve #55891

* increase EH debugging restart delay; fixes #55955

* Revert "Don't include non-resource entries in history quick pick"

This reverts commit 37209a838e9f7e9abe6dc53ed73cdf1e03b72060.

* Diff editor: horizontal scrollbar height is smaller (fixes #56062)

* improve openFolder uri fix (correctly treat backslashes)

* fixes #56116
repair ipc for native menubar keybindings

* Fix #56240 - Open the JSON settings editor instead of the UI editor

* Fix #55536

* uriDisplay: if no formatter is registered fall back to getPathlabel

fixes #56104

* VSCode hangs when opening python file. Fixes #56377

* VS Code Hangs When Opening Specific PowerShell File. Fixes #56430

* Fix #56433 - search extraFileResources even when no folders open

* Workaround #55649

* Fix in master #56371

* Fix tests #56371

* Fix in master #56317

* increase version to 1.26.1

* Fixes #56387: Handle SIGPIPE in extension host

* fixes #56185

* Fix merge issues (part 1)

* Fix build breaks (part 1)

* Build breaks (part 2)

* Build breaks (part 3)

* More build breaks (part 4)

* Fix build breaks (part 5)

* WIP

* Fix menus

* Render query result and message panels (#2363)

* Put back query editor hot exit changes

* Fix grid changes that broke profiler (#2365)

* Update APIs for saving query editor state

* Fix restore view state for profiler and edit data

* Updating custom default themes to support 4.5:1 contrast ratio

* Test updates

* Fix Extension Manager and Windows Setup

* Update license headers

* Add appveyor and travis files back

* Fix hidden modal dropdown issue
This commit is contained in:
Karl Burtram
2018-09-04 14:55:00 -07:00
committed by GitHub
parent 3763278366
commit 81329fa7fa
2638 changed files with 118456 additions and 64012 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/vs/base/test/browser/builder.test.ts
View File

@@ -54,6 +54,7 @@ function select(builder: Builder, selector: string, offdom?: boolean): MultiBuil
return new MultiBuilder(builders);
}
// {{SQL CARBON EDIT}} disable broken tests
suite('Builder', () => {
test('Binding', function () {
});

1
src/vs/base/test/browser/dom.test.ts
View File

@@ -8,6 +8,7 @@ import * as assert from 'assert';
import * as dom from 'vs/base/browser/dom';
const $ = dom.$;
// {{SQL CARBON EDIT}} disable broken tests
suite('dom', () => {
test('hasClass', () => {
});

16
src/vs/base/test/browser/highlightedLabel.test.ts
View File

@@ -52,4 +52,18 @@ suite('HighlightedLabel', () => {
label.set('foobarfoo', [{ start: 3, end: 6 }]);
assert.equal(label.element.innerHTML, '<span>foo</span><span class="highlight">bar</span><span>foo</span>');
});
});
test('escapeNewLines', function () {
let highlights = [{ start: 0, end: 5 }, { start: 7, end: 9 }, { start: 11, end: 12 }];// before,after,after
let escaped = HighlightedLabel.escapeNewLines('ACTION\r\n_TYPE2', highlights);
assert.equal(escaped, 'ACTION\u23CE_TYPE2');
assert.deepEqual(highlights, [{ start: 0, end: 5 }, { start: 6, end: 8 }, { start: 10, end: 11 }]);
highlights = [{ start: 5, end: 9 }, { start: 11, end: 12 }];//overlap,after
escaped = HighlightedLabel.escapeNewLines('ACTION\r\n_TYPE2', highlights);
assert.equal(escaped, 'ACTION\u23CE_TYPE2');
assert.deepEqual(highlights, [{ start: 5, end: 8 }, { start: 10, end: 11 }]);
});
});

3
src/vs/base/test/browser/progressBar.test.ts
View File

@@ -24,7 +24,8 @@ suite('ProgressBar', () => {
assert(bar.infinite());
assert(bar.total(100));
assert(bar.worked(50));
assert(bar.worked(50));
assert(bar.setWorked(70));
assert(bar.worked(30));
assert(bar.done());
bar.dispose();

28
src/vs/base/test/browser/ui/contextview/contextview.test.ts Normal file
View File

@@ -0,0 +1,28 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as assert from 'assert';
import { layout, LayoutAnchorPosition } from 'vs/base/browser/ui/contextview/contextview';
suite('Contextview', function () {
test('layout', function () {
assert.equal(layout(200, 20, { offset: 0, size: 0, position: LayoutAnchorPosition.Before }), 0);
assert.equal(layout(200, 20, { offset: 50, size: 0, position: LayoutAnchorPosition.Before }), 50);
assert.equal(layout(200, 20, { offset: 200, size: 0, position: LayoutAnchorPosition.Before }), 180);
assert.equal(layout(200, 20, { offset: 0, size: 0, position: LayoutAnchorPosition.After }), 0);
assert.equal(layout(200, 20, { offset: 50, size: 0, position: LayoutAnchorPosition.After }), 30);
assert.equal(layout(200, 20, { offset: 200, size: 0, position: LayoutAnchorPosition.After }), 180);
assert.equal(layout(200, 20, { offset: 0, size: 50, position: LayoutAnchorPosition.Before }), 50);
assert.equal(layout(200, 20, { offset: 50, size: 50, position: LayoutAnchorPosition.Before }), 100);
assert.equal(layout(200, 20, { offset: 150, size: 50, position: LayoutAnchorPosition.Before }), 130);
assert.equal(layout(200, 20, { offset: 0, size: 50, position: LayoutAnchorPosition.After }), 50);
assert.equal(layout(200, 20, { offset: 50, size: 50, position: LayoutAnchorPosition.After }), 30);
assert.equal(layout(200, 20, { offset: 150, size: 50, position: LayoutAnchorPosition.After }), 130);
});
});

12
src/vs/base/test/browser/ui/grid/grid.test.ts Normal file
View File

@@ -0,0 +1,12 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as assert from 'assert';
suite('Grid', function () {
test('getRelativeLocation', function () {
assert.equal(0, 0);
});
});

230
src/vs/base/test/browser/ui/grid/gridview.test.ts Normal file
View File

@@ -0,0 +1,230 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as assert from 'assert';
import { $ } from 'vs/base/browser/dom';
import { GridView, IView, Sizing } from 'vs/base/browser/ui/grid/gridview';
import { nodesToArrays, TestView } from './util';
suite('Gridview', function () {
let gridview: GridView;
setup(function () {
gridview = new GridView();
const container = $('.container');
container.style.position = 'absolute';
container.style.width = `${200}px`;
container.style.height = `${200}px`;
container.appendChild(gridview.element);
});
teardown(function () {
gridview = null;
});
test('empty gridview is empty', function () {
assert.deepEqual(nodesToArrays(gridview.getViews()), []);
gridview.dispose();
});
test('gridview addView', function () {
const view = new TestView(20, 20, 20, 20);
assert.throws(() => gridview.addView(view, 200, []), 'empty location');
assert.throws(() => gridview.addView(view, 200, [1]), 'index overflow');
assert.throws(() => gridview.addView(view, 200, [0, 0]), 'hierarchy overflow');
const views = [
new TestView(20, 20, 20, 20),
new TestView(20, 20, 20, 20),
new TestView(20, 20, 20, 20)
];
gridview.addView(views[0], 200, [0]);
gridview.addView(views[1], 200, [1]);
gridview.addView(views[2], 200, [2]);
assert.deepEqual(nodesToArrays(gridview.getViews()), views);
gridview.dispose();
});
test('gridview addView nested', function () {
const views = [
new TestView(20, 20, 20, 20),
[
new TestView(20, 20, 20, 20),
new TestView(20, 20, 20, 20)
]
];
gridview.addView(views[0] as IView, 200, [0]);
gridview.addView(views[1][0] as IView, 200, [1]);
gridview.addView(views[1][1] as IView, 200, [1, 1]);
assert.deepEqual(nodesToArrays(gridview.getViews()), views);
gridview.dispose();
});
test('gridview addView deep nested', function () {
const view1 = new TestView(20, 20, 20, 20);
gridview.addView(view1 as IView, 200, [0]);
assert.deepEqual(nodesToArrays(gridview.getViews()), [view1]);
const view2 = new TestView(20, 20, 20, 20);
gridview.addView(view2 as IView, 200, [1]);
assert.deepEqual(nodesToArrays(gridview.getViews()), [view1, view2]);
const view3 = new TestView(20, 20, 20, 20);
gridview.addView(view3 as IView, 200, [1, 0]);
assert.deepEqual(nodesToArrays(gridview.getViews()), [view1, [view3, view2]]);
const view4 = new TestView(20, 20, 20, 20);
gridview.addView(view4 as IView, 200, [1, 0, 0]);
assert.deepEqual(nodesToArrays(gridview.getViews()), [view1, [[view4, view3], view2]]);
const view5 = new TestView(20, 20, 20, 20);
gridview.addView(view5 as IView, 200, [1, 0]);
assert.deepEqual(nodesToArrays(gridview.getViews()), [view1, [view5, [view4, view3], view2]]);
const view6 = new TestView(20, 20, 20, 20);
gridview.addView(view6 as IView, 200, [2]);
assert.deepEqual(nodesToArrays(gridview.getViews()), [view1, [view5, [view4, view3], view2], view6]);
const view7 = new TestView(20, 20, 20, 20);
gridview.addView(view7 as IView, 200, [1, 1]);
assert.deepEqual(nodesToArrays(gridview.getViews()), [view1, [view5, view7, [view4, view3], view2], view6]);
const view8 = new TestView(20, 20, 20, 20);
gridview.addView(view8 as IView, 200, [1, 1, 0]);
assert.deepEqual(nodesToArrays(gridview.getViews()), [view1, [view5, [view8, view7], [view4, view3], view2], view6]);
gridview.dispose();
});
test('simple layout', function () {
gridview.layout(800, 600);
const view1 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
gridview.addView(view1, 200, [0]);
assert.deepEqual(view1.size, [800, 600]);
assert.deepEqual(gridview.getViewSize([0]), { width: 800, height: 600 });
const view2 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
gridview.addView(view2, 200, [0]);
assert.deepEqual(view1.size, [800, 400]);
assert.deepEqual(gridview.getViewSize([1]), { width: 800, height: 400 });
assert.deepEqual(view2.size, [800, 200]);
assert.deepEqual(gridview.getViewSize([0]), { width: 800, height: 200 });
const view3 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
gridview.addView(view3, 200, [1, 1]);
assert.deepEqual(view1.size, [600, 400]);
assert.deepEqual(gridview.getViewSize([1, 0]), { width: 600, height: 400 });
assert.deepEqual(view2.size, [800, 200]);
assert.deepEqual(gridview.getViewSize([0]), { width: 800, height: 200 });
assert.deepEqual(view3.size, [200, 400]);
assert.deepEqual(gridview.getViewSize([1, 1]), { width: 200, height: 400 });
const view4 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
gridview.addView(view4, 200, [0, 0]);
assert.deepEqual(view1.size, [600, 400]);
assert.deepEqual(gridview.getViewSize([1, 0]), { width: 600, height: 400 });
assert.deepEqual(view2.size, [600, 200]);
assert.deepEqual(gridview.getViewSize([0, 1]), { width: 600, height: 200 });
assert.deepEqual(view3.size, [200, 400]);
assert.deepEqual(gridview.getViewSize([1, 1]), { width: 200, height: 400 });
assert.deepEqual(view4.size, [200, 200]);
assert.deepEqual(gridview.getViewSize([0, 0]), { width: 200, height: 200 });
const view5 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
gridview.addView(view5, 100, [1, 0, 1]);
assert.deepEqual(view1.size, [600, 300]);
assert.deepEqual(gridview.getViewSize([1, 0, 0]), { width: 600, height: 300 });
assert.deepEqual(view2.size, [600, 200]);
assert.deepEqual(gridview.getViewSize([0, 1]), { width: 600, height: 200 });
assert.deepEqual(view3.size, [200, 400]);
assert.deepEqual(gridview.getViewSize([1, 1]), { width: 200, height: 400 });
assert.deepEqual(view4.size, [200, 200]);
assert.deepEqual(gridview.getViewSize([0, 0]), { width: 200, height: 200 });
assert.deepEqual(view5.size, [600, 100]);
assert.deepEqual(gridview.getViewSize([1, 0, 1]), { width: 600, height: 100 });
});
test('simple layout with automatic size distribution', function () {
gridview.layout(800, 600);
const view1 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
gridview.addView(view1, Sizing.Distribute, [0]);
assert.deepEqual(view1.size, [800, 600]);
assert.deepEqual(gridview.getViewSize([0]), { width: 800, height: 600 });
const view2 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
gridview.addView(view2, Sizing.Distribute, [0]);
assert.deepEqual(view1.size, [800, 300]);
assert.deepEqual(view2.size, [800, 300]);
const view3 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
gridview.addView(view3, Sizing.Distribute, [1, 1]);
assert.deepEqual(view1.size, [400, 300]);
assert.deepEqual(view2.size, [800, 300]);
assert.deepEqual(view3.size, [400, 300]);
const view4 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
gridview.addView(view4, Sizing.Distribute, [0, 0]);
assert.deepEqual(view1.size, [400, 300]);
assert.deepEqual(view2.size, [400, 300]);
assert.deepEqual(view3.size, [400, 300]);
assert.deepEqual(view4.size, [400, 300]);
const view5 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
gridview.addView(view5, Sizing.Distribute, [1, 0, 1]);
assert.deepEqual(view1.size, [400, 150]);
assert.deepEqual(view2.size, [400, 300]);
assert.deepEqual(view3.size, [400, 300]);
assert.deepEqual(view4.size, [400, 300]);
assert.deepEqual(view5.size, [400, 150]);
});
test('addviews before layout call 1', function () {
const view1 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
gridview.addView(view1, 200, [0]);
const view2 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
gridview.addView(view2, 200, [0]);
const view3 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
gridview.addView(view3, 200, [1, 1]);
gridview.layout(800, 600);
assert.deepEqual(view1.size, [400, 300]);
assert.deepEqual(view2.size, [800, 300]);
assert.deepEqual(view3.size, [400, 300]);
});
test('addviews before layout call 2', function () {
const view1 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
gridview.addView(view1, 200, [0]);
const view2 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
gridview.addView(view2, 200, [0]);
const view3 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
gridview.addView(view3, 200, [0, 0]);
gridview.layout(800, 600);
assert.deepEqual(view1.size, [800, 300]);
assert.deepEqual(view2.size, [400, 300]);
assert.deepEqual(view3.size, [400, 300]);
});
});

81
src/vs/base/test/browser/ui/grid/util.ts Normal file
View File

@@ -0,0 +1,81 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as assert from 'assert';
import { Emitter, Event } from 'vs/base/common/event';
import { IView, GridNode, isGridBranchNode, } from 'vs/base/browser/ui/grid/gridview';
export class TestView implements IView {
private _onDidChange = new Emitter<{ width: number; height: number; }>();
readonly onDidChange = this._onDidChange.event;
get minimumWidth(): number { return this._minimumWidth; }
set minimumWidth(size: number) { this._minimumWidth = size; this._onDidChange.fire(); }
get maximumWidth(): number { return this._maximumWidth; }
set maximumWidth(size: number) { this._maximumWidth = size; this._onDidChange.fire(); }
get minimumHeight(): number { return this._minimumHeight; }
set minimumHeight(size: number) { this._minimumHeight = size; this._onDidChange.fire(); }
get maximumHeight(): number { return this._maximumHeight; }
set maximumHeight(size: number) { this._maximumHeight = size; this._onDidChange.fire(); }
private _element: HTMLElement = document.createElement('div');
get element(): HTMLElement { this._onDidGetElement.fire(); return this._element; }
private _onDidGetElement = new Emitter<void>();
readonly onDidGetElement = this._onDidGetElement.event;
private _width = 0;
get width(): number { return this._width; }
private _height = 0;
get height(): number { return this._height; }
get size(): [number, number] { return [this.width, this.height]; }
private _onDidLayout = new Emitter<{ width: number; height: number; }>();
readonly onDidLayout: Event<{ width: number; height: number; }> = this._onDidLayout.event;
private _onDidFocus = new Emitter<void>();
readonly onDidFocus: Event<void> = this._onDidFocus.event;
constructor(
private _minimumWidth: number,
private _maximumWidth: number,
private _minimumHeight: number,
private _maximumHeight: number
) {
assert(_minimumWidth <= _maximumWidth, 'gridview view minimum width must be <= maximum width');
assert(_minimumHeight <= _maximumHeight, 'gridview view minimum height must be <= maximum height');
}
layout(width: number, height: number): void {
this._width = width;
this._height = height;
this._onDidLayout.fire({ width, height });
}
focus(): void {
this._onDidFocus.fire();
}
dispose(): void {
this._onDidChange.dispose();
this._onDidGetElement.dispose();
this._onDidLayout.dispose();
this._onDidFocus.dispose();
}
}
export function nodesToArrays(node: GridNode): any {
if (isGridBranchNode(node)) {
return node.children.map(nodesToArrays);
} else {
return node.view;
}
}

41
src/vs/base/test/browser/ui/list/listView.test.ts Normal file
View File

@@ -0,0 +1,41 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as assert from 'assert';
import { ListView } from 'vs/base/browser/ui/list/listView';
import { IVirtualDelegate, IRenderer } from 'vs/base/browser/ui/list/list';
import { range } from 'vs/base/common/arrays';
suite('ListView', function () {
test('all rows get disposed', function () {
const element = document.createElement('div');
element.style.height = '200px';
element.style.width = '200px';
const delegate: IVirtualDelegate<number> = {
getHeight() { return 20; },
getTemplateId() { return 'template'; }
};
let templatesCount = 0;
const renderer: IRenderer<number, void> = {
templateId: 'template',
renderTemplate() { templatesCount++; },
renderElement() { },
disposeElement() { },
disposeTemplate() { templatesCount--; }
};
const listView = new ListView<number>(element, delegate, [renderer]);
listView.layout(200);
assert.equal(templatesCount, 0, 'no templates have been allocated');
listView.splice(0, 0, range(100));
assert.equal(templatesCount, 10, 'some templates have been allocated');
listView.dispose();
assert.equal(templatesCount, 0, 'all templates have been disposed');
});
});

18
src/vs/base/test/browser/ui/splitview/splitview.test.ts
View File

@@ -5,8 +5,8 @@
import * as assert from 'assert';
import { Emitter } from 'vs/base/common/event';
import { SplitView, IView, Orientation } from 'vs/base/browser/ui/splitview/splitview';
import { Sash } from 'vs/base/browser/ui/sash/sash';
import { SplitView, IView, Orientation, Sizing } from 'vs/base/browser/ui/splitview/splitview';
import { Sash, SashState } from 'vs/base/browser/ui/sash/sash';
class TestView implements IView {
@@ -19,8 +19,11 @@ class TestView implements IView {
get maximumSize(): number { return this._maximumSize; }
set maximumSize(size: number) { this._maximumSize = size; this._onDidChange.fire(); }
private _onDidRender = new Emitter<{ container: HTMLElement; orientation: Orientation }>();
readonly onDidRender = this._onDidRender.event;
private _element: HTMLElement = document.createElement('div');
get element(): HTMLElement { this._onDidGetElement.fire(); return this._element; }
private _onDidGetElement = new Emitter<void>();
readonly onDidGetElement = this._onDidGetElement.event;
private _size = 0;
get size(): number { return this._size; }
@@ -37,10 +40,6 @@ class TestView implements IView {
assert(_minimumSize <= _maximumSize, 'splitview view minimum size must be <= maximum size');
}
render(container: HTMLElement, orientation: Orientation): void {
this._onDidRender.fire({ container, orientation });
}
layout(size: number, orientation: Orientation): void {
this._size = size;
this._onDidLayout.fire({ size, orientation });
@@ -52,7 +51,7 @@ class TestView implements IView {
dispose(): void {
this._onDidChange.dispose();
this._onDidRender.dispose();
this._onDidGetElement.dispose();
this._onDidLayout.dispose();
this._onDidFocus.dispose();
}
@@ -62,6 +61,7 @@ function getSashes(splitview: SplitView): Sash[] {
return (splitview as any).sashItems.map(i => i.sash) as Sash[];
}
// {{SQL CARBON EDIT}} disable broken tests
suite('Splitview', () => {
test('empty splitview has empty DOM', () => {
});

334
src/vs/base/test/browser/ui/tree/treeModel.test.ts Normal file
View File

@@ -0,0 +1,334 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as assert from 'assert';
import { TreeModel, ITreeNode } from 'vs/base/browser/ui/tree/treeModel';
import { ISpliceable } from 'vs/base/common/sequence';
import { Iterator } from 'vs/base/common/iterator';
function toSpliceable<T>(arr: T[]): ISpliceable<T> {
return {
splice(start: number, deleteCount: number, elements: T[]): void {
arr.splice(start, deleteCount, ...elements);
}
};
}
function toArray<T>(list: ITreeNode<T>[]): T[] {
return list.map(i => i.element);
}
suite('TreeModel2', function () {
test('ctor', function () {
const list = [] as ITreeNode<number>[];
const model = new TreeModel<number>(toSpliceable(list));
assert(model);
assert.equal(list.length, 0);
});
test('insert', function () {
const list = [] as ITreeNode<number>[];
const model = new TreeModel<number>(toSpliceable(list));
model.splice([0], 0, Iterator.iterate([
{ element: 0 },
{ element: 1 },
{ element: 2 }
]));
assert.deepEqual(list.length, 3);
assert.deepEqual(list[0].element, 0);
assert.deepEqual(list[0].collapsed, false);
assert.deepEqual(list[0].depth, 1);
assert.deepEqual(list[1].element, 1);
assert.deepEqual(list[1].collapsed, false);
assert.deepEqual(list[1].depth, 1);
assert.deepEqual(list[2].element, 2);
assert.deepEqual(list[2].collapsed, false);
assert.deepEqual(list[2].depth, 1);
});
test('deep insert', function () {
const list = [] as ITreeNode<number>[];
const model = new TreeModel<number>(toSpliceable(list));
model.splice([0], 0, Iterator.iterate([
{
element: 0, children: Iterator.iterate([
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
},
{ element: 1 },
{ element: 2 }
]));
assert.deepEqual(list.length, 6);
assert.deepEqual(list[0].element, 0);
assert.deepEqual(list[0].collapsed, false);
assert.deepEqual(list[0].depth, 1);
assert.deepEqual(list[1].element, 10);
assert.deepEqual(list[1].collapsed, false);
assert.deepEqual(list[1].depth, 2);
assert.deepEqual(list[2].element, 11);
assert.deepEqual(list[2].collapsed, false);
assert.deepEqual(list[2].depth, 2);
assert.deepEqual(list[3].element, 12);
assert.deepEqual(list[3].collapsed, false);
assert.deepEqual(list[3].depth, 2);
assert.deepEqual(list[4].element, 1);
assert.deepEqual(list[4].collapsed, false);
assert.deepEqual(list[4].depth, 1);
assert.deepEqual(list[5].element, 2);
assert.deepEqual(list[5].collapsed, false);
assert.deepEqual(list[5].depth, 1);
});
test('deep insert collapsed', function () {
const list = [] as ITreeNode<number>[];
const model = new TreeModel<number>(toSpliceable(list));
model.splice([0], 0, Iterator.iterate([
{
element: 0, collapsed: true, children: Iterator.iterate([
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
},
{ element: 1 },
{ element: 2 }
]));
assert.deepEqual(list.length, 3);
assert.deepEqual(list[0].element, 0);
assert.deepEqual(list[0].collapsed, true);
assert.deepEqual(list[0].depth, 1);
assert.deepEqual(list[1].element, 1);
assert.deepEqual(list[1].collapsed, false);
assert.deepEqual(list[1].depth, 1);
assert.deepEqual(list[2].element, 2);
assert.deepEqual(list[2].collapsed, false);
assert.deepEqual(list[2].depth, 1);
});
test('delete', function () {
const list = [] as ITreeNode<number>[];
const model = new TreeModel<number>(toSpliceable(list));
model.splice([0], 0, Iterator.iterate([
{ element: 0 },
{ element: 1 },
{ element: 2 }
]));
assert.deepEqual(list.length, 3);
model.splice([1], 1);
assert.deepEqual(list.length, 2);
assert.deepEqual(list[0].element, 0);
assert.deepEqual(list[0].collapsed, false);
assert.deepEqual(list[0].depth, 1);
assert.deepEqual(list[1].element, 2);
assert.deepEqual(list[1].collapsed, false);
assert.deepEqual(list[1].depth, 1);
model.splice([0], 2);
assert.deepEqual(list.length, 0);
});
test('nested delete', function () {
const list = [] as ITreeNode<number>[];
const model = new TreeModel<number>(toSpliceable(list));
model.splice([0], 0, Iterator.iterate([
{
element: 0, children: Iterator.iterate([
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
},
{ element: 1 },
{ element: 2 }
]));
assert.deepEqual(list.length, 6);
model.splice([1], 2);
assert.deepEqual(list.length, 4);
assert.deepEqual(list[0].element, 0);
assert.deepEqual(list[0].collapsed, false);
assert.deepEqual(list[0].depth, 1);
assert.deepEqual(list[1].element, 10);
assert.deepEqual(list[1].collapsed, false);
assert.deepEqual(list[1].depth, 2);
assert.deepEqual(list[2].element, 11);
assert.deepEqual(list[2].collapsed, false);
assert.deepEqual(list[2].depth, 2);
assert.deepEqual(list[3].element, 12);
assert.deepEqual(list[3].collapsed, false);
assert.deepEqual(list[3].depth, 2);
});
test('deep delete', function () {
const list = [] as ITreeNode<number>[];
const model = new TreeModel<number>(toSpliceable(list));
model.splice([0], 0, Iterator.iterate([
{
element: 0, children: Iterator.iterate([
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
},
{ element: 1 },
{ element: 2 }
]));
assert.deepEqual(list.length, 6);
model.splice([0], 1);
assert.deepEqual(list.length, 2);
assert.deepEqual(list[0].element, 1);
assert.deepEqual(list[0].collapsed, false);
assert.deepEqual(list[0].depth, 1);
assert.deepEqual(list[1].element, 2);
assert.deepEqual(list[1].collapsed, false);
assert.deepEqual(list[1].depth, 1);
});
test('hidden delete', function () {
const list = [] as ITreeNode<number>[];
const model = new TreeModel<number>(toSpliceable(list));
model.splice([0], 0, Iterator.iterate([
{
element: 0, collapsed: true, children: Iterator.iterate([
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
},
{ element: 1 },
{ element: 2 }
]));
assert.deepEqual(list.length, 3);
model.splice([0, 1], 1);
assert.deepEqual(list.length, 3);
model.splice([0, 0], 2);
assert.deepEqual(list.length, 3);
});
test('collapse', function () {
const list = [] as ITreeNode<number>[];
const model = new TreeModel<number>(toSpliceable(list));
model.splice([0], 0, Iterator.iterate([
{
element: 0, children: Iterator.iterate([
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
},
{ element: 1 },
{ element: 2 }
]));
assert.deepEqual(list.length, 6);
model.setCollapsed([0], true);
assert.deepEqual(list.length, 3);
assert.deepEqual(list[0].element, 0);
assert.deepEqual(list[0].collapsed, true);
assert.deepEqual(list[0].depth, 1);
assert.deepEqual(list[1].element, 1);
assert.deepEqual(list[1].collapsed, false);
assert.deepEqual(list[1].depth, 1);
assert.deepEqual(list[2].element, 2);
assert.deepEqual(list[2].collapsed, false);
assert.deepEqual(list[2].depth, 1);
});
test('expand', function () {
const list = [] as ITreeNode<number>[];
const model = new TreeModel<number>(toSpliceable(list));
model.splice([0], 0, Iterator.iterate([
{
element: 0, collapsed: true, children: Iterator.iterate([
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
},
{ element: 1 },
{ element: 2 }
]));
assert.deepEqual(list.length, 3);
model.setCollapsed([0], false);
assert.deepEqual(list.length, 6);
assert.deepEqual(list[0].element, 0);
assert.deepEqual(list[0].collapsed, false);
assert.deepEqual(list[0].depth, 1);
assert.deepEqual(list[1].element, 10);
assert.deepEqual(list[1].collapsed, false);
assert.deepEqual(list[1].depth, 2);
assert.deepEqual(list[2].element, 11);
assert.deepEqual(list[2].collapsed, false);
assert.deepEqual(list[2].depth, 2);
assert.deepEqual(list[3].element, 12);
assert.deepEqual(list[3].collapsed, false);
assert.deepEqual(list[3].depth, 2);
assert.deepEqual(list[4].element, 1);
assert.deepEqual(list[4].collapsed, false);
assert.deepEqual(list[4].depth, 1);
assert.deepEqual(list[5].element, 2);
assert.deepEqual(list[5].collapsed, false);
assert.deepEqual(list[5].depth, 1);
});
test('collapse should recursively adjust visible count', function () {
const list = [] as ITreeNode<number>[];
const model = new TreeModel<number>(toSpliceable(list));
model.splice([0], 0, Iterator.iterate([
{
element: 1, children: [
{
element: 11, children: [
{ element: 111 }
]
}
]
},
{
element: 2, children: [
{ element: 21 }
]
}
]));
assert.deepEqual(list.length, 5);
assert.deepEqual(toArray(list), [1, 11, 111, 2, 21]);
model.setCollapsed([0, 0], true);
assert.deepEqual(list.length, 4);
assert.deepEqual(toArray(list), [1, 11, 2, 21]);
model.setCollapsed([1], true);
assert.deepEqual(list.length, 3);
assert.deepEqual(toArray(list), [1, 11, 2]);
});
});

43
src/vs/base/test/common/arrays.test.ts
View File

@@ -52,6 +52,11 @@ suite('Arrays', () => {
assert.deepEqual(data, [1, 2, 3, 4, 5, 6, 7, 8]);
});
test('mergeSort, sorted array', function () {
let data = arrays.mergeSort([1, 2, 3, 4, 5, 6], (a, b) => a - b);
assert.deepEqual(data, [1, 2, 3, 4, 5, 6]);
});
test('mergeSort, is stable', function () {
let numbers = arrays.mergeSort([33, 22, 11, 4, 99, 1], (a, b) => 0);
@@ -304,5 +309,43 @@ suite('Arrays', () => {
sparse = arrays.coalesce(sparse);
assert.equal(sparse.length, 5);
});
test('coalesce - inplace', function () {
let a = [null, 1, null, 2, 3];
arrays.coalesce(a, true);
assert.equal(a.length, 3);
assert.equal(a[0], 1);
assert.equal(a[1], 2);
assert.equal(a[2], 3);
a = [null, 1, null, void 0, undefined, 2, 3];
arrays.coalesce(a, true);
assert.equal(a.length, 3);
assert.equal(a[0], 1);
assert.equal(a[1], 2);
assert.equal(a[2], 3);
let b = [];
b[10] = 1;
b[20] = 2;
b[30] = 3;
arrays.coalesce(b, true);
assert.equal(b.length, 3);
assert.equal(b[0], 1);
assert.equal(b[1], 2);
assert.equal(b[2], 3);
let sparse = [];
sparse[0] = 1;
sparse[1] = 1;
sparse[17] = 1;
sparse[1000] = 1;
sparse[1001] = 1;
assert.equal(sparse.length, 1002);
arrays.coalesce(sparse, true);
assert.equal(sparse.length, 5);
});
});

288
src/vs/base/test/common/async.test.ts
View File

@@ -5,20 +5,159 @@
'use strict';
import * as assert from 'assert';
import { Promise, TPromise } from 'vs/base/common/winjs.base';
import * as Async from 'vs/base/common/async';
import { TPromise } from 'vs/base/common/winjs.base';
import * as async from 'vs/base/common/async';
import URI from 'vs/base/common/uri';
import { isPromiseCanceledError } from 'vs/base/common/errors';
suite('Async', () => {
test('cancelablePromise - set token, don\'t wait for inner promise', function () {
let canceled = 0;
let promise = async.createCancelablePromise(token => {
token.onCancellationRequested(_ => { canceled += 1; });
return new Promise(resolve => { /*never*/ });
});
let result = promise.then(_ => assert.ok(false), err => {
assert.equal(canceled, 1);
assert.ok(isPromiseCanceledError(err));
});
promise.cancel();
promise.cancel(); // cancel only once
return result;
});
test('cancelablePromise - cancel despite inner promise being resolved', function () {
let canceled = 0;
let promise = async.createCancelablePromise(token => {
token.onCancellationRequested(_ => { canceled += 1; });
return Promise.resolve(1234);
});
let result = promise.then(_ => assert.ok(false), err => {
assert.equal(canceled, 1);
assert.ok(isPromiseCanceledError(err));
});
promise.cancel();
return result;
});
// Cancelling a sync cancelable promise will fire the cancelled token.
// Also, every `then` callback runs in another execution frame.
test('CancelablePromise execution order (sync)', function () {
const order = [];
const cancellablePromise = async.createCancelablePromise(token => {
order.push('in callback');
token.onCancellationRequested(_ => order.push('cancelled'));
return Promise.resolve(1234);
});
order.push('afterCreate');
const promise = cancellablePromise
.then(null, err => null)
.then(() => order.push('finally'));
cancellablePromise.cancel();
order.push('afterCancel');
return promise.then(() => assert.deepEqual(order, ['in callback', 'afterCreate', 'cancelled', 'afterCancel', 'finally']));
});
// Cancelling an async cancelable promise is just the same as a sync cancellable promise.
test('CancelablePromise execution order (async)', function () {
const order = [];
const cancellablePromise = async.createCancelablePromise(token => {
order.push('in callback');
token.onCancellationRequested(_ => order.push('cancelled'));
return new Promise(c => setTimeout(c(1234), 0));
});
order.push('afterCreate');
const promise = cancellablePromise
.then(null, err => null)
.then(() => order.push('finally'));
cancellablePromise.cancel();
order.push('afterCancel');
return promise.then(() => assert.deepEqual(order, ['in callback', 'afterCreate', 'cancelled', 'afterCancel', 'finally']));
});
// Cancelling a sync tpromise will NOT cancel the promise, since it has resolved already.
// Every `then` callback runs sync in the same execution frame, thus `finally` executes
// before `afterCancel`.
test('TPromise execution order (sync)', function () {
const order = [];
let promise = new TPromise(resolve => {
order.push('in executor');
resolve(1234);
}, () => order.push('cancelled'));
order.push('afterCreate');
promise = promise
.then(null, err => null)
.then(() => order.push('finally'));
promise.cancel();
order.push('afterCancel');
return promise.then(() => assert.deepEqual(order, ['in executor', 'afterCreate', 'finally', 'afterCancel']));
});
// Cancelling an async tpromise will cancel the promise.
// Every `then` callback runs sync on the same execution frame as the `cancel` call,
// so finally still executes before `afterCancel`.
test('TPromise execution order (async)', function () {
const order = [];
let promise = new TPromise(resolve => {
order.push('in executor');
setTimeout(() => resolve(1234));
}, () => order.push('cancelled'));
order.push('afterCreate');
promise = promise
.then(null, err => null)
.then(() => order.push('finally'));
promise.cancel();
order.push('afterCancel');
return promise.then(() => assert.deepEqual(order, ['in executor', 'afterCreate', 'cancelled', 'finally', 'afterCancel']));
});
test('cancelablePromise - get inner result', async function () {
let promise = async.createCancelablePromise(token => {
return async.timeout(12).then(_ => 1234);
});
let result = await promise;
assert.equal(result, 1234);
});
test('asDisposablePromise', async function () {
let value = await async.asDisposablePromise(TPromise.as(1)).promise;
assert.equal(value, 1);
let disposablePromise = async.asDisposablePromise(TPromise.timeout(1000).then(_ => 1), 2);
disposablePromise.dispose();
value = await disposablePromise.promise;
assert.equal(value, 2);
});
test('Throttler - non async', function () {
let count = 0;
let factory = () => {
return TPromise.as(++count);
};
let throttler = new Async.Throttler();
let throttler = new async.Throttler();
return Promise.join([
return TPromise.join([
throttler.queue(factory).then((result) => { assert.equal(result, 1); }),
throttler.queue(factory).then((result) => { assert.equal(result, 2); }),
throttler.queue(factory).then((result) => { assert.equal(result, 3); }),
@@ -35,16 +174,16 @@ suite('Async', () => {
});
};
let throttler = new Async.Throttler();
let throttler = new async.Throttler();
return Promise.join([
return TPromise.join([
throttler.queue(factory).then((result) => { assert.equal(result, 1); }),
throttler.queue(factory).then((result) => { assert.equal(result, 2); }),
throttler.queue(factory).then((result) => { assert.equal(result, 2); }),
throttler.queue(factory).then((result) => { assert.equal(result, 2); }),
throttler.queue(factory).then((result) => { assert.equal(result, 2); })
]).then(() => {
Promise.join([
TPromise.join([
throttler.queue(factory).then((result) => { assert.equal(result, 3); }),
throttler.queue(factory).then((result) => { assert.equal(result, 4); }),
throttler.queue(factory).then((result) => { assert.equal(result, 4); }),
@@ -62,10 +201,10 @@ suite('Async', () => {
});
};
let throttler = new Async.Throttler();
let p1: Promise;
let throttler = new async.Throttler();
let p1: TPromise;
const p = Promise.join([
const p = TPromise.join([
p1 = throttler.queue(factory).then((result) => { assert(false, 'should not be here, 1'); }, () => { assert(true, 'yes, it was cancelled'); }),
throttler.queue(factory).then((result) => { assert.equal(result, 1); }, () => { assert(false, 'should not be here, 2'); }),
throttler.queue(factory).then((result) => { assert.equal(result, 1); }, () => { assert(false, 'should not be here, 3'); }),
@@ -85,10 +224,10 @@ suite('Async', () => {
});
};
let throttler = new Async.Throttler();
let p2: Promise;
let throttler = new async.Throttler();
let p2: TPromise;
const p = Promise.join([
const p = TPromise.join([
throttler.queue(factory).then((result) => { assert.equal(result, 1); }, () => { assert(false, 'should not be here, 1'); }),
p2 = throttler.queue(factory).then((result) => { assert(false, 'should not be here, 2'); }, () => { assert(true, 'yes, it was cancelled'); }),
throttler.queue(factory).then((result) => { assert.equal(result, 2); }, () => { assert(false, 'should not be here, 3'); }),
@@ -108,10 +247,10 @@ suite('Async', () => {
});
};
let throttler = new Async.Throttler();
let p3: Promise;
let throttler = new async.Throttler();
let p3: TPromise;
const p = Promise.join([
const p = TPromise.join([
throttler.queue(factory).then((result) => { assert.equal(result, 1); }, () => { assert(false, 'should not be here, 1'); }),
throttler.queue(factory).then((result) => { assert.equal(result, 2); }, () => { assert(false, 'should not be here, 2'); }),
p3 = throttler.queue(factory).then((result) => { assert(false, 'should not be here, 3'); }, () => { assert(true, 'yes, it was cancelled'); }),
@@ -128,15 +267,15 @@ suite('Async', () => {
return TPromise.timeout(0).then(() => n);
};
let throttler = new Async.Throttler();
let throttler = new async.Throttler();
let promises: Promise[] = [];
let promises: TPromise[] = [];
promises.push(throttler.queue(factoryFactory(1)).then((n) => { assert.equal(n, 1); }));
promises.push(throttler.queue(factoryFactory(2)).then((n) => { assert.equal(n, 3); }));
promises.push(throttler.queue(factoryFactory(3)).then((n) => { assert.equal(n, 3); }));
return Promise.join(promises);
return TPromise.join(promises);
});
test('Throttler - progress should work', function () {
@@ -148,15 +287,15 @@ suite('Async', () => {
});
});
let throttler = new Async.Throttler();
let promises: Promise[] = [];
let throttler = new async.Throttler();
let promises: TPromise[] = [];
let progresses: any[][] = [[], [], []];
promises.push(throttler.queue(factory).then(null, null, (p) => progresses[0].push(p)));
promises.push(throttler.queue(factory).then(null, null, (p) => progresses[1].push(p)));
promises.push(throttler.queue(factory).then(null, null, (p) => progresses[2].push(p)));
return Promise.join(promises).then(() => {
return TPromise.join(promises).then(() => {
assert.deepEqual(progresses[0], [0]);
assert.deepEqual(progresses[1], [0]);
assert.deepEqual(progresses[2], [0]);
@@ -169,8 +308,8 @@ suite('Async', () => {
return TPromise.as(++count);
};
let delayer = new Async.Delayer(0);
let promises: Promise[] = [];
let delayer = new async.Delayer(0);
let promises: TPromise[] = [];
assert(!delayer.isTriggered());
@@ -183,7 +322,7 @@ suite('Async', () => {
promises.push(delayer.trigger(factory).then((result) => { assert.equal(result, 1); assert(!delayer.isTriggered()); }));
assert(delayer.isTriggered());
return Promise.join(promises).then(() => {
return TPromise.join(promises).then(() => {
assert(!delayer.isTriggered());
});
});
@@ -194,7 +333,7 @@ suite('Async', () => {
return TPromise.as(++count);
};
let delayer = new Async.Delayer(0);
let delayer = new async.Delayer(0);
assert(!delayer.isTriggered());
@@ -217,8 +356,8 @@ suite('Async', () => {
return TPromise.as(++count);
};
let delayer = new Async.Delayer(0);
let promises: Promise[] = [];
let delayer = new async.Delayer(0);
let promises: TPromise[] = [];
assert(!delayer.isTriggered());
@@ -233,7 +372,7 @@ suite('Async', () => {
delayer.cancel();
return Promise.join(promises).then(() => {
return TPromise.join(promises).then(() => {
assert(!delayer.isTriggered());
});
});
@@ -244,8 +383,8 @@ suite('Async', () => {
return TPromise.as(++count);
};
let delayer = new Async.Delayer(0);
let promises: Promise[] = [];
let delayer = new async.Delayer(0);
let promises: TPromise[] = [];
assert(!delayer.isTriggered());
@@ -261,7 +400,7 @@ suite('Async', () => {
delayer.cancel();
const p = Promise.join(promises).then(() => {
const p = TPromise.join(promises).then(() => {
promises = [];
assert(!delayer.isTriggered());
@@ -272,7 +411,7 @@ suite('Async', () => {
promises.push(delayer.trigger(factory).then(() => { assert.equal(result, 1); assert(!delayer.isTriggered()); }));
assert(delayer.isTriggered());
const p = Promise.join(promises).then(() => {
const p = TPromise.join(promises).then(() => {
assert(!delayer.isTriggered());
});
@@ -296,8 +435,8 @@ suite('Async', () => {
return TPromise.as(n);
};
let delayer = new Async.Delayer(0);
let promises: Promise[] = [];
let delayer = new async.Delayer(0);
let promises: TPromise[] = [];
assert(!delayer.isTriggered());
@@ -305,7 +444,7 @@ suite('Async', () => {
promises.push(delayer.trigger(factoryFactory(2)).then((n) => { assert.equal(n, 3); }));
promises.push(delayer.trigger(factoryFactory(3)).then((n) => { assert.equal(n, 3); }));
const p = Promise.join(promises).then(() => {
const p = TPromise.join(promises).then(() => {
assert(!delayer.isTriggered());
});
@@ -323,15 +462,15 @@ suite('Async', () => {
});
});
let delayer = new Async.Delayer(0);
let promises: Promise[] = [];
let delayer = new async.Delayer(0);
let promises: TPromise[] = [];
let progresses: any[][] = [[], [], []];
promises.push(delayer.trigger(factory).then(null, null, (p) => progresses[0].push(p)));
promises.push(delayer.trigger(factory).then(null, null, (p) => progresses[1].push(p)));
promises.push(delayer.trigger(factory).then(null, null, (p) => progresses[2].push(p)));
return Promise.join(promises).then(() => {
return TPromise.join(promises).then(() => {
assert.deepEqual(progresses[0], [0]);
assert.deepEqual(progresses[1], [0]);
assert.deepEqual(progresses[2], [0]);
@@ -347,15 +486,15 @@ suite('Async', () => {
});
});
let delayer = new Async.ThrottledDelayer(0);
let promises: Promise[] = [];
let delayer = new async.ThrottledDelayer(0);
let promises: TPromise[] = [];
let progresses: any[][] = [[], [], []];
promises.push(delayer.trigger(factory).then(null, null, (p) => progresses[0].push(p)));
promises.push(delayer.trigger(factory).then(null, null, (p) => progresses[1].push(p)));
promises.push(delayer.trigger(factory).then(null, null, (p) => progresses[2].push(p)));
return Promise.join(promises).then(() => {
return TPromise.join(promises).then(() => {
assert.deepEqual(progresses[0], [0]);
assert.deepEqual(progresses[1], [0]);
assert.deepEqual(progresses[2], [0]);
@@ -367,7 +506,7 @@ suite('Async', () => {
return TPromise.as(n);
};
return Async.sequence([
return async.sequence([
factoryFactory(1),
factoryFactory(2),
factoryFactory(3),
@@ -388,20 +527,20 @@ suite('Async', () => {
return TPromise.as(n);
};
let limiter = new Async.Limiter(1);
let limiter = new async.Limiter(1);
let promises: Promise[] = [];
let promises: TPromise[] = [];
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].forEach(n => promises.push(limiter.queue(factoryFactory(n))));
return Promise.join(promises).then((res) => {
return TPromise.join(promises).then((res) => {
assert.equal(10, res.length);
limiter = new Async.Limiter(100);
limiter = new async.Limiter(100);
promises = [];
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].forEach(n => promises.push(limiter.queue(factoryFactory(n))));
return Promise.join(promises).then((res) => {
return TPromise.join(promises).then((res) => {
assert.equal(10, res.length);
});
});
@@ -412,19 +551,19 @@ suite('Async', () => {
return TPromise.timeout(0).then(() => n);
};
let limiter = new Async.Limiter(1);
let promises: Promise[] = [];
let limiter = new async.Limiter(1);
let promises: TPromise[] = [];
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].forEach(n => promises.push(limiter.queue(factoryFactory(n))));
return Promise.join(promises).then((res) => {
return TPromise.join(promises).then((res) => {
assert.equal(10, res.length);
limiter = new Async.Limiter(100);
limiter = new async.Limiter(100);
promises = [];
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].forEach(n => promises.push(limiter.queue(factoryFactory(n))));
return Promise.join(promises).then((res) => {
return TPromise.join(promises).then((res) => {
assert.equal(10, res.length);
});
});
@@ -438,19 +577,19 @@ suite('Async', () => {
return TPromise.timeout(0).then(() => { activePromises--; return n; });
};
let limiter = new Async.Limiter(5);
let limiter = new async.Limiter(5);
let promises: Promise[] = [];
let promises: TPromise[] = [];
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].forEach(n => promises.push(limiter.queue(factoryFactory(n))));
return Promise.join(promises).then((res) => {
return TPromise.join(promises).then((res) => {
assert.equal(10, res.length);
assert.deepEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], res);
});
});
test('Queue - simple', function () {
let queue = new Async.Queue();
let queue = new async.Queue();
let syncPromise = false;
let f1 = () => TPromise.as(true).then(() => syncPromise = true);
@@ -473,7 +612,7 @@ suite('Async', () => {
});
test('Queue - order is kept', function () {
let queue = new Async.Queue();
let queue = new async.Queue();
let res: number[] = [];
@@ -497,7 +636,7 @@ suite('Async', () => {
});
test('Queue - errors bubble individually but not cause stop', function () {
let queue = new Async.Queue();
let queue = new async.Queue();
let res: number[] = [];
let error = false;
@@ -522,7 +661,7 @@ suite('Async', () => {
});
test('Queue - order is kept (chained)', function () {
let queue = new Async.Queue();
let queue = new async.Queue();
let res: number[] = [];
@@ -550,7 +689,7 @@ suite('Async', () => {
});
test('Queue - events', function (done) {
let queue = new Async.Queue();
let queue = new async.Queue();
let finished = false;
queue.onFinished(() => {
@@ -576,7 +715,7 @@ suite('Async', () => {
});
test('ResourceQueue - simple', function () {
let queue = new Async.ResourceQueue();
let queue = new async.ResourceQueue();
const r1Queue = queue.queueFor(URI.file('/some/path'));
const r2Queue = queue.queueFor(URI.file('/some/other/path'));
@@ -592,29 +731,4 @@ suite('Async', () => {
const r1Queue2 = queue.queueFor(URI.file('/some/path'));
assert.notEqual(r1Queue, r1Queue2); // previous one got disposed after finishing
});
test('ThrottledEmitter', function () {
const emitter = new Async.ThrottledEmitter();
const fnThatEmitsEvent = () => {
emitter.fire();
};
const promiseFn = TPromise.timeout(0).then(() => {
fnThatEmitsEvent();
fnThatEmitsEvent();
fnThatEmitsEvent();
});
let count = 0;
emitter.event(() => {
count++;
});
emitter.throttle(promiseFn);
promiseFn.then(() => {
assert.equal(count, 1);
});
});
});

9
src/vs/base/test/common/diff/diff.test.ts
View File

@@ -6,20 +6,19 @@
import * as assert from 'assert';
import { LcsDiff, IDiffChange } from 'vs/base/common/diff/diff';
import { LcsDiff, IDiffChange, ISequence } from 'vs/base/common/diff/diff';
class StringDiffSequence {
class StringDiffSequence implements ISequence {
constructor(private source: string) {
}
getLength() {
return this.source.length;
}
getElementHash(i: number) {
return this.source.charAt(i);
getElementAtIndex(i: number) {
return this.source.charCodeAt(i);
}
}

100
src/vs/base/test/common/event.test.ts
View File

@@ -5,10 +5,11 @@
'use strict';
import * as assert from 'assert';
import { Event, Emitter, debounceEvent, EventBufferer, once, fromPromise, stopwatch, buffer, echo, EventMultiplexer, latch } from 'vs/base/common/event';
import { Event, Emitter, debounceEvent, EventBufferer, once, fromPromise, stopwatch, buffer, echo, EventMultiplexer, latch, AsyncEmitter, IWaitUntil } from 'vs/base/common/event';
import { IDisposable } from 'vs/base/common/lifecycle';
import * as Errors from 'vs/base/common/errors';
import { TPromise } from 'vs/base/common/winjs.base';
import { timeout } from 'vs/base/common/async';
namespace Samples {
@@ -238,6 +239,103 @@ suite('Event', function () {
});
});
suite('AsyncEmitter', function () {
test('event has waitUntil-function', async function () {
interface E extends IWaitUntil {
foo: boolean;
bar: number;
}
let emitter = new AsyncEmitter<E>();
emitter.event(e => {
assert.equal(e.foo, true);
assert.equal(e.bar, 1);
assert.equal(typeof e.waitUntil, 'function');
});
emitter.fireAsync(thenables => ({
foo: true,
bar: 1,
waitUntil(t: Thenable<void>) { thenables.push(t); }
}));
emitter.dispose();
});
test('sequential delivery', async function () {
interface E extends IWaitUntil {
foo: boolean;
}
let globalState = 0;
let emitter = new AsyncEmitter<E>();
emitter.event(e => {
e.waitUntil(timeout(10).then(_ => {
assert.equal(globalState, 0);
globalState += 1;
}));
});
emitter.event(e => {
e.waitUntil(timeout(1).then(_ => {
assert.equal(globalState, 1);
globalState += 1;
}));
});
await emitter.fireAsync(thenables => ({
foo: true,
waitUntil(t) {
thenables.push(t);
}
}));
assert.equal(globalState, 2);
});
test('sequential, in-order delivery', async function () {
interface E extends IWaitUntil {
foo: number;
}
let events: number[] = [];
let done = false;
let emitter = new AsyncEmitter<E>();
// e1
emitter.event(e => {
e.waitUntil(timeout(10).then(async _ => {
if (e.foo === 1) {
await emitter.fireAsync(thenables => ({
foo: 2,
waitUntil(t) {
thenables.push(t);
}
}));
assert.deepEqual(events, [1, 2]);
done = true;
}
}));
});
// e2
emitter.event(e => {
events.push(e.foo);
e.waitUntil(timeout(7));
});
await emitter.fireAsync(thenables => ({
foo: 1,
waitUntil(t) {
thenables.push(t);
}
}));
assert.ok(done);
});
});
suite('Event utils', () => {
suite('EventBufferer', () => {

10
src/vs/base/test/common/filters.test.ts
View File

@@ -298,7 +298,7 @@ suite('Filters', () => {
assertMatches('ob', 'foobar', undefined, fuzzyScore);
assertMatches('sl', 'SVisualLoggerLogsList', '^SVisual^LoggerLogsList', fuzzyScore);
assertMatches('sllll', 'SVisualLoggerLogsList', '^SVisua^l^Logger^Logs^List', fuzzyScore);
assertMatches('Three', 'HTMLHRElement', 'H^TML^H^R^El^ement', fuzzyScore);
assertMatches('Three', 'HTMLHRElement', undefined, fuzzyScore);
assertMatches('Three', 'Three', '^T^h^r^e^e', fuzzyScore);
assertMatches('fo', 'barfoo', undefined, fuzzyScore);
assertMatches('fo', 'bar_foo', 'bar_^f^oo', fuzzyScore);
@@ -309,6 +309,14 @@ suite('Filters', () => {
assertMatches('fo', 'bar\\foo', 'bar\\^f^oo', fuzzyScore);
});
test('fuzzyScore (first match can be weak)', function () {
let fuzzyScoreWeak = (pattern, word) => fuzzyScore(pattern, word, undefined, true);
assertMatches('Three', 'HTMLHRElement', 'H^TML^H^R^El^ement', fuzzyScoreWeak);
assertMatches('tor', 'constructor', 'construc^t^o^r', fuzzyScoreWeak);
assertMatches('ur', 'constructor', 'constr^ucto^r', fuzzyScoreWeak);
assertTopScore(fuzzyScoreWeak, 'tor', 2, 'constructor', 'Thor', 'cTor');
});
test('fuzzyScore, many matches', function () {
assertMatches(

49
src/vs/base/test/common/history.test.ts
View File

@@ -16,19 +16,18 @@ suite('History Navigator', () => {
});
test('create sets the position to last', () => {
const testObject = new HistoryNavigator(['1', '2', '3', '4'], 3);
const testObject = new HistoryNavigator(['1', '2', '3', '4'], 100);
assert.equal('4', testObject.current());
assert.equal(null, testObject.next());
assert.equal('3', testObject.previous());
assert.equal(testObject.current(), null);
assert.equal(testObject.next(), null);
assert.equal(testObject.previous(), '4');
});
test('last returns last element', () => {
const testObject = new HistoryNavigator(['1', '2', '3', '4'], 3);
const testObject = new HistoryNavigator(['1', '2', '3', '4'], 100);
testObject.first();
assert.equal('4', testObject.last());
assert.equal(testObject.first(), '1');
assert.equal(testObject.last(), '4', );
});
test('first returns first element', () => {
@@ -42,17 +41,18 @@ suite('History Navigator', () => {
testObject.first();
assert.equal('3', testObject.next());
assert.equal('4', testObject.next());
assert.equal(null, testObject.next());
assert.equal(testObject.next(), '3');
assert.equal(testObject.next(), '4');
assert.equal(testObject.next(), null);
});
test('previous returns previous element', () => {
const testObject = new HistoryNavigator(['1', '2', '3', '4'], 3);
assert.equal('3', testObject.previous());
assert.equal('2', testObject.previous());
assert.equal(null, testObject.previous());
assert.equal(testObject.previous(), '4');
assert.equal(testObject.previous(), '3');
assert.equal(testObject.previous(), '2');
assert.equal(testObject.previous(), null);
});
test('next on last element returs null and remains on last', () => {
@@ -61,8 +61,8 @@ suite('History Navigator', () => {
testObject.first();
testObject.last();
assert.equal('4', testObject.current());
assert.equal(null, testObject.next());
assert.equal(testObject.current(), '4');
assert.equal(testObject.next(), null);
});
test('previous on first element returs null and remains on first', () => {
@@ -70,8 +70,8 @@ suite('History Navigator', () => {
testObject.first();
assert.equal('2', testObject.current());
assert.equal(null, testObject.previous());
assert.equal(testObject.current(), '2');
assert.equal(testObject.previous(), null);
});
test('add reduces the input to limit', () => {
@@ -79,7 +79,7 @@ suite('History Navigator', () => {
testObject.add('5');
assert.deepEqual(['4', '5'], toArray(testObject));
assert.deepEqual(toArray(testObject), ['4', '5']);
});
test('adding existing element changes the position', () => {
@@ -87,7 +87,7 @@ suite('History Navigator', () => {
testObject.add('2');
assert.deepEqual(['1', '3', '4', '2'], toArray(testObject));
assert.deepEqual(toArray(testObject), ['1', '3', '4', '2']);
});
test('add resets the navigator to last', () => {
@@ -96,8 +96,8 @@ suite('History Navigator', () => {
testObject.first();
testObject.add('5');
assert.equal('5', testObject.current());
assert.equal(null, testObject.next());
assert.equal(testObject.previous(), '5');
assert.equal(testObject.next(), null);
});
test('adding an existing item changes the order', () => {
@@ -110,9 +110,9 @@ suite('History Navigator', () => {
test('clear', () => {
const testObject = new HistoryNavigator(['a', 'b', 'c']);
assert.equal('c', testObject.current());
assert.equal(testObject.previous(), 'c');
testObject.clear();
assert.equal(undefined, testObject.current());
assert.equal(testObject.current(), undefined);
});
function toArray(historyNavigator: HistoryNavigator<string>): string[] {
@@ -126,4 +126,3 @@ suite('History Navigator', () => {
return result;
}
});

22
src/vs/base/test/common/json.test.ts
View File

@@ -43,9 +43,9 @@ function assertInvalidParse(input: string, expected: any, options?: ParseOptions
assert.deepEqual(actual, expected);
}
function assertTree(input: string, expected: any, expectedErrors: number[] = []): void {
function assertTree(input: string, expected: any, expectedErrors: number[] = [], options?: ParseOptions): void {
var errors: ParseError[] = [];
var actual = parseTree(input, errors);
var actual = parseTree(input, errors, options);
assert.deepEqual(errors.map(e => e.error, expected), expectedErrors);
let checkParent = (node: Node) => {
@@ -203,7 +203,7 @@ suite('JSON', () => {
test('parse: objects with errors', () => {
assertInvalidParse('{,}', {});
assertInvalidParse('{ "foo": true, }', { foo: true });
assertInvalidParse('{ "foo": true, }', { foo: true }, { disallowTrailingComma: true });
assertInvalidParse('{ "bar": 8 "xoo": "foo" }', { bar: 8, xoo: 'foo' });
assertInvalidParse('{ ,"bar": 8 }', { bar: 8 });
assertInvalidParse('{ ,"bar": 8, "foo" }', { bar: 8 });
@@ -213,10 +213,10 @@ suite('JSON', () => {
test('parse: array with errors', () => {
assertInvalidParse('[,]', []);
assertInvalidParse('[ 1, 2, ]', [1, 2]);
assertInvalidParse('[ 1, 2, ]', [1, 2], { disallowTrailingComma: true });
assertInvalidParse('[ 1 2, 3 ]', [1, 2, 3]);
assertInvalidParse('[ ,1, 2, 3 ]', [1, 2, 3]);
assertInvalidParse('[ ,1, 2, 3, ]', [1, 2, 3]);
assertInvalidParse('[ ,1, 2, 3, ]', [1, 2, 3], { disallowTrailingComma: true });
});
test('parse: disallow commments', () => {
@@ -229,15 +229,19 @@ suite('JSON', () => {
});
test('parse: trailing comma', () => {
let options = { allowTrailingComma: true };
// default is allow
assertValidParse('{ "hello": [], }', { hello: [] });
let options = { disallowTrailingComma: false };
assertValidParse('{ "hello": [], }', { hello: [] }, options);
assertValidParse('{ "hello": [] }', { hello: [] }, options);
assertValidParse('{ "hello": [], "world": {}, }', { hello: [], world: {} }, options);
assertValidParse('{ "hello": [], "world": {} }', { hello: [], world: {} }, options);
assertValidParse('{ "hello": [1,] }', { hello: [1] }, options);
assertInvalidParse('{ "hello": [], }', { hello: [] });
assertInvalidParse('{ "hello": [], "world": {}, }', { hello: [], world: {} });
options = { disallowTrailingComma: true };
assertInvalidParse('{ "hello": [], }', { hello: [] }, options);
assertInvalidParse('{ "hello": [], "world": {}, }', { hello: [], world: {} }, options);
});
test('tree: literals', () => {
@@ -320,6 +324,6 @@ suite('JSON', () => {
}
]
}
, [ParseErrorCode.PropertyNameExpected, ParseErrorCode.ValueExpected]);
, [ParseErrorCode.PropertyNameExpected, ParseErrorCode.ValueExpected], { disallowTrailingComma: true });
});
});

32
src/vs/base/test/common/map.test.ts
View File

@@ -8,6 +8,7 @@
import { ResourceMap, TernarySearchTree, PathIterator, StringIterator, LinkedMap, Touch, LRUCache } from 'vs/base/common/map';
import * as assert from 'assert';
import URI from 'vs/base/common/uri';
import { IteratorResult } from 'vs/base/common/iterator';
suite('Map', () => {
@@ -418,17 +419,30 @@ suite('Map', () => {
map.set('/user/foo/flip/flop', 3);
map.set('/usr/foo', 4);
const elements = map.findSuperstr('/user');
let item: IteratorResult<number>;
let iter = map.findSuperstr('/user');
assertTernarySearchTree(elements, ['foo/bar', 1], ['foo', 2], ['foo/flip/flop', 3]);
// assert.equal(elements.length, 3);
assert.equal(elements.get('foo/bar'), 1);
assert.equal(elements.get('foo'), 2);
assert.equal(elements.get('foo/flip/flop'), 3);
item = iter.next();
assert.equal(item.value, 2);
assert.equal(item.done, false);
item = iter.next();
assert.equal(item.value, 1);
assert.equal(item.done, false);
item = iter.next();
assert.equal(item.value, 3);
assert.equal(item.done, false);
item = iter.next();
assert.equal(item.value, undefined);
assert.equal(item.done, true);
assertTernarySearchTree(map.findSuperstr('/usr'), ['foo', 4]);
assert.equal(map.findSuperstr('/usr/foo'), undefined);
assert.equal(map.get('/usr/foo'), 4);
iter = map.findSuperstr('/usr');
item = iter.next();
assert.equal(item.value, 4);
assert.equal(item.done, false);
item = iter.next();
assert.equal(item.value, undefined);
assert.equal(item.done, true);
assert.equal(map.findSuperstr('/not'), undefined);
assert.equal(map.findSuperstr('/us'), undefined);

6
src/vs/base/test/common/network.test.ts
View File

@@ -36,7 +36,7 @@ suite('Network', () => {
);
assertUrl('http://www.test.com:8000#hash',
'http', 'www.test.com', '8000', '', '', 'hash'
'http', 'www.test.com', '8000', '/', '', 'hash'
);
assertUrl('http://www.test.com/#hash',
@@ -44,7 +44,7 @@ suite('Network', () => {
);
assertUrl('http://www.test.com#hash',
'http', 'www.test.com', '', '', '', 'hash'
'http', 'www.test.com', '', '/', '', 'hash'
);
assertUrl('http://www.test.com:8000/this/that/theother.html',
@@ -56,7 +56,7 @@ suite('Network', () => {
);
assertUrl('http://www.test.com:8000',
'http', 'www.test.com', '8000', '', '', ''
'http', 'www.test.com', '8000', '/', '', ''
);
assertUrl('http://www.test.com/',

69
src/vs/base/test/common/resources.test.ts
View File

@@ -5,9 +5,10 @@
'use strict';
import * as assert from 'assert';
import URI from 'vs/base/common/uri';
import { distinctParents, dirname } from 'vs/base/common/resources';
import { normalize } from 'vs/base/common/paths';
import { dirname, distinctParents, joinPath, isEqual, isEqualOrParent, hasToIgnoreCase } from 'vs/base/common/resources';
import URI from 'vs/base/common/uri';
import { isWindows } from 'vs/base/common/platform';
suite('Resources', () => {
@@ -50,4 +51,68 @@ suite('Resources', () => {
// does not explode (https://github.com/Microsoft/vscode/issues/41987)
dirname(URI.from({ scheme: 'file', authority: '/users/someone/portal.h' }));
});
test('joinPath', () => {
assert.equal(
joinPath(URI.file('/foo/bar'), '/file.js').toString(),
'file:///foo/bar/file.js');
assert.equal(
joinPath(URI.file('/foo/bar/'), '/file.js').toString(),
'file:///foo/bar/file.js');
assert.equal(
joinPath(URI.file('/'), '/file.js').toString(),
'file:///file.js');
assert.equal(
joinPath(URI.from({ scheme: 'myScheme', authority: 'authority', path: '/path', query: 'query', fragment: 'fragment' }), '/file.js').toString(),
'myScheme://authority/path/file.js?query#fragment');
});
test('isEqual', () => {
let fileURI = URI.file('/foo/bar');
let fileURI2 = URI.file('/foo/Bar');
assert.equal(isEqual(fileURI, fileURI, true), true);
assert.equal(isEqual(fileURI, fileURI, false), true);
assert.equal(isEqual(fileURI, fileURI, hasToIgnoreCase(fileURI)), true);
assert.equal(isEqual(fileURI, fileURI2, true), true);
assert.equal(isEqual(fileURI, fileURI2, false), false);
let fileURI3 = URI.parse('foo://server:453/foo/bar');
let fileURI4 = URI.parse('foo://server:453/foo/Bar');
assert.equal(isEqual(fileURI3, fileURI3, true), true);
assert.equal(isEqual(fileURI3, fileURI3, false), true);
assert.equal(isEqual(fileURI3, fileURI3, hasToIgnoreCase(fileURI3)), true);
assert.equal(isEqual(fileURI3, fileURI4, true), true);
assert.equal(isEqual(fileURI3, fileURI4, false), false);
assert.equal(isEqual(fileURI, fileURI3, true), false);
});
test('isEqualOrParent', () => {
let fileURI = isWindows ? URI.file('c:\\foo\\bar') : URI.file('/foo/bar');
let fileURI2 = isWindows ? URI.file('c:\\foo') : URI.file('/foo');
let fileURI2b = isWindows ? URI.file('C:\\Foo\\') : URI.file('/Foo/');
assert.equal(isEqualOrParent(fileURI, fileURI, true), true, '1');
assert.equal(isEqualOrParent(fileURI, fileURI, false), true, '2');
assert.equal(isEqualOrParent(fileURI, fileURI2, true), true, '3');
assert.equal(isEqualOrParent(fileURI, fileURI2, false), true, '4');
assert.equal(isEqualOrParent(fileURI, fileURI2b, true), true, '5');
assert.equal(isEqualOrParent(fileURI, fileURI2b, false), false, '6');
assert.equal(isEqualOrParent(fileURI2, fileURI, false), false, '7');
assert.equal(isEqualOrParent(fileURI2b, fileURI2, true), true, '8');
let fileURI3 = URI.parse('foo://server:453/foo/bar/goo');
let fileURI4 = URI.parse('foo://server:453/foo/');
let fileURI5 = URI.parse('foo://server:453/foo');
assert.equal(isEqualOrParent(fileURI3, fileURI3, true), true, '11');
assert.equal(isEqualOrParent(fileURI3, fileURI3, false), true, '12');
assert.equal(isEqualOrParent(fileURI3, fileURI4, true), true, '13');
assert.equal(isEqualOrParent(fileURI3, fileURI4, false), true, '14');
assert.equal(isEqualOrParent(fileURI3, fileURI, true), false, '15');
assert.equal(isEqualOrParent(fileURI5, fileURI5, true), true, '16');
});
});

43
src/vs/base/test/common/uri.test.ts
View File

@@ -51,15 +51,19 @@ suite('URI', () => {
test('URI#fsPath - no `fsPath` when no `path`', () => {
const value = URI.parse('file://%2Fhome%2Fticino%2Fdesktop%2Fcpluscplus%2Ftest.cpp');
assert.equal(value.authority, '/home/ticino/desktop/cpluscplus/test.cpp');
assert.equal(value.path, '');
assert.equal(value.fsPath, '');
assert.equal(value.path, '/');
if (isWindows) {
assert.equal(value.fsPath, '\\');
} else {
assert.equal(value.fsPath, '/');
}
});
test('http#toString', () => {
assert.equal(URI.from({ scheme: 'http', authority: 'www.msft.com', path: '/my/path' }).toString(), 'http://www.msft.com/my/path');
assert.equal(URI.from({ scheme: 'http', authority: 'www.msft.com', path: '/my/path' }).toString(), 'http://www.msft.com/my/path');
assert.equal(URI.from({ scheme: 'http', authority: 'www.MSFT.com', path: '/my/path' }).toString(), 'http://www.msft.com/my/path');
assert.equal(URI.from({ scheme: 'http', authority: '', path: 'my/path' }).toString(), 'http:my/path');
assert.equal(URI.from({ scheme: 'http', authority: '', path: 'my/path' }).toString(), 'http:/my/path');
assert.equal(URI.from({ scheme: 'http', authority: '', path: '/my/path' }).toString(), 'http:/my/path');
assert.equal(URI.from({ scheme: '', authority: '', path: 'my/path' }).toString(), 'my/path');
assert.equal(URI.from({ scheme: '', authority: '', path: '/my/path' }).toString(), '/my/path');
@@ -213,7 +217,7 @@ suite('URI', () => {
value = URI.parse('file:?q');
assert.equal(value.scheme, 'file');
assert.equal(value.authority, '');
assert.equal(value.path, '');
assert.equal(value.path, '/');
assert.equal(value.query, 'q');
assert.equal(value.fragment, '');
@@ -227,7 +231,7 @@ suite('URI', () => {
value = URI.parse('file:#d');
assert.equal(value.scheme, 'file');
assert.equal(value.authority, '');
assert.equal(value.path, '');
assert.equal(value.path, '/');
assert.equal(value.query, '');
assert.equal(value.fragment, 'd');
@@ -428,6 +432,35 @@ suite('URI', () => {
});
test('class URI cannot represent relative file paths #34449', function () {
let path = '/foo/bar';
assert.equal(URI.file(path).path, path);
path = 'foo/bar';
assert.equal(URI.file(path).path, '/foo/bar');
path = './foo/bar';
assert.equal(URI.file(path).path, '/./foo/bar'); // todo@joh missing normalization
const fileUri1 = URI.parse(`file:foo/bar`);
assert.equal(fileUri1.path, '/foo/bar');
assert.equal(fileUri1.authority, '');
const uri = fileUri1.toString();
assert.equal(uri, 'file:///foo/bar');
const fileUri2 = URI.parse(uri);
assert.equal(fileUri2.path, '/foo/bar');
assert.equal(fileUri2.authority, '');
});
test('Ctrl click to follow hash query param url gets urlencoded #49628', function () {
let input = 'http://localhost:3000/#/foo?bar=baz';
let uri = URI.parse(input);
assert.equal(uri.toString(true), input);
input = 'http://localhost:3000/foo?bar=baz';
uri = URI.parse(input);
assert.equal(uri.toString(true), input);
});
test('URI - (de)serialize', function () {
var values = [

66
src/vs/base/test/common/utils.ts
View File

@@ -5,10 +5,9 @@
'use strict';
import { TPromise, PPromise, TValueCallback, TProgressCallback, ProgressCallback } from 'vs/base/common/winjs.base';
import * as errors from 'vs/base/common/errors';
import * as paths from 'vs/base/common/paths';
import URI from 'vs/base/common/uri';
import { TPromise, TValueCallback } from 'vs/base/common/winjs.base';
export class DeferredTPromise<T> extends TPromise<T> {
@@ -16,17 +15,15 @@ export class DeferredTPromise<T> extends TPromise<T> {
private completeCallback: TValueCallback<T>;
private errorCallback: (err: any) => void;
private progressCallback: ProgressCallback;
constructor() {
constructor(oncancel?: any) {
let captured: any;
super((c, e, p) => {
captured = { c, e, p };
}, () => this.oncancel());
super((c, e) => {
captured = { c, e };
}, oncancel ? oncancel : () => this.oncancel);
this.canceled = false;
this.completeCallback = captured.c;
this.errorCallback = captured.e;
this.progressCallback = captured.p;
}
public complete(value: T) {
@@ -37,48 +34,27 @@ export class DeferredTPromise<T> extends TPromise<T> {
this.errorCallback(err);
}
public progress(p: any) {
this.progressCallback(p);
}
private oncancel(): void {
this.canceled = true;
}
}
export class DeferredPPromise<C, P> extends PPromise<C, P> {
private completeCallback: TValueCallback<C>;
private errorCallback: (err: any) => void;
private progressCallback: TProgressCallback<P>;
constructor(init: (complete: TValueCallback<C>, error: (err: any) => void, progress: TProgressCallback<P>) => void = (c, e, p) => { }, oncancel?: any) {
let captured: any;
super((c, e, p) => {
captured = { c, e, p };
}, oncancel ? oncancel : () => this.oncancel);
this.completeCallback = captured.c;
this.errorCallback = captured.e;
this.progressCallback = captured.p;
}
private oncancel(): void {
this.errorCallback(errors.canceled());
}
public complete(c: C) {
this.completeCallback(c);
}
public progress(p: P) {
this.progressCallback(p);
}
public error(e: any) {
this.errorCallback(e);
}
}
export function toResource(this: any, path: string) {
return URI.file(paths.join('C:\\', Buffer.from(this.test.fullTitle()).toString('base64'), path));
}
export function suiteRepeat(n: number, description: string, callback: (this: any) => void): void {
for (let i = 0; i < n; i++) {
suite(`${description} (iteration ${i})`, callback);
}
}
export function testRepeat(n: number, description: string, callback: (this: any, done: MochaDone) => any): void {
for (let i = 0; i < n; i++) {
test(`${description} (iteration ${i})`, callback);
}
}
export function testRepeatOnly(n: number, description: string, callback: (this: any, done: MochaDone) => any): void {
suite.only('repeat', () => testRepeat(n, description, callback));
}

70
src/vs/base/test/common/winjs.promise.test.ts Normal file
View File

@@ -0,0 +1,70 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as assert from 'assert';
import * as winjs from 'vs/base/common/winjs.base';
suite('WinJS and ES6 Promises', function () {
test('Promise.resolve', function () {
let resolveTPromise;
const tPromise = new winjs.Promise((c, e) => {
resolveTPromise = c;
});
const es6Promise = Promise.resolve(tPromise);
const done = es6Promise.then(function (result) {
assert.equal(result, 'passed');
});
resolveTPromise('passed');
return done;
});
test('new Promise', function () {
let resolveTPromise;
const tPromise = new winjs.Promise((c, e) => {
resolveTPromise = c;
});
const es6Promise = new Promise(function (c, e) {
c(tPromise);
});
const done = es6Promise.then(function (result) {
assert.equal(result, 'passed');
});
resolveTPromise('passed');
return done;
});
test('1. Uncaught TypeError: this._state.then is not a function', () => {
let p1 = winjs.Promise.wrap<number>(new Promise<number>(function (c, e) { c(1); }));
Promise.all([p1]);
});
test('2. Uncaught TypeError: this._state.then is not a function', () => {
let p1 = winjs.Promise.wrap<number>(new Promise<number>(function (c, e) { c(1); }));
let thenFunc = p1.then.bind(p1);
setTimeout(() => {
thenFunc(() => { });
}, 0);
});
test('3. Uncaught TypeError: this._state.then is not a function', () => {
let c;
let p1 = new winjs.Promise(function (_c, e) { c = _c; });
let thenFunc = p1.then.bind(p1);
setTimeout(() => {
c(1);
thenFunc(() => { });
}, 0);
});
});

90
src/vs/base/test/node/config.test.ts
View File

@@ -77,70 +77,70 @@ suite('Config', () => {
});
});
test('watching', function (done) {
this.timeout(10000); // watching is timing intense
// test('watching', function (done) {
// this.timeout(10000); // watching is timing intense
testFile('config', 'config.json').then(res => {
fs.writeFileSync(res.testFile, '// my comment\n{ "foo": "bar" }');
// testFile('config', 'config.json').then(res => {
// fs.writeFileSync(res.testFile, '// my comment\n{ "foo": "bar" }');
let watcher = new ConfigWatcher<{ foo: string; }>(res.testFile);
watcher.getConfig(); // ensure we are in sync
// let watcher = new ConfigWatcher<{ foo: string; }>(res.testFile);
// watcher.getConfig(); // ensure we are in sync
fs.writeFileSync(res.testFile, '// my comment\n{ "foo": "changed" }');
// fs.writeFileSync(res.testFile, '// my comment\n{ "foo": "changed" }');
watcher.onDidUpdateConfiguration(event => {
assert.ok(event);
assert.equal(event.config.foo, 'changed');
assert.equal(watcher.getValue('foo'), 'changed');
// watcher.onDidUpdateConfiguration(event => {
// assert.ok(event);
// assert.equal(event.config.foo, 'changed');
// assert.equal(watcher.getValue('foo'), 'changed');
watcher.dispose();
// watcher.dispose();
res.cleanUp().then(done, done);
});
}, done);
});
// res.cleanUp().then(done, done);
// });
// }, done);
// });
test('watching also works when file created later', function (done) {
this.timeout(10000); // watching is timing intense
// test('watching also works when file created later', function (done) {
// this.timeout(10000); // watching is timing intense
testFile('config', 'config.json').then(res => {
let watcher = new ConfigWatcher<{ foo: string; }>(res.testFile);
watcher.getConfig(); // ensure we are in sync
// testFile('config', 'config.json').then(res => {
// let watcher = new ConfigWatcher<{ foo: string; }>(res.testFile);
// watcher.getConfig(); // ensure we are in sync
fs.writeFileSync(res.testFile, '// my comment\n{ "foo": "changed" }');
// fs.writeFileSync(res.testFile, '// my comment\n{ "foo": "changed" }');
watcher.onDidUpdateConfiguration(event => {
assert.ok(event);
assert.equal(event.config.foo, 'changed');
assert.equal(watcher.getValue('foo'), 'changed');
// watcher.onDidUpdateConfiguration(event => {
// assert.ok(event);
// assert.equal(event.config.foo, 'changed');
// assert.equal(watcher.getValue('foo'), 'changed');
watcher.dispose();
// watcher.dispose();
res.cleanUp().then(done, done);
});
}, done);
});
// res.cleanUp().then(done, done);
// });
// }, done);
// });
test('watching detects the config file getting deleted', function (done) {
this.timeout(10000); // watching is timing intense
// test('watching detects the config file getting deleted', function (done) {
// this.timeout(10000); // watching is timing intense
testFile('config', 'config.json').then(res => {
fs.writeFileSync(res.testFile, '// my comment\n{ "foo": "bar" }');
// testFile('config', 'config.json').then(res => {
// fs.writeFileSync(res.testFile, '// my comment\n{ "foo": "bar" }');
let watcher = new ConfigWatcher<{ foo: string; }>(res.testFile);
watcher.getConfig(); // ensure we are in sync
// let watcher = new ConfigWatcher<{ foo: string; }>(res.testFile);
// watcher.getConfig(); // ensure we are in sync
watcher.onDidUpdateConfiguration(event => {
assert.ok(event);
// watcher.onDidUpdateConfiguration(event => {
// assert.ok(event);
watcher.dispose();
// watcher.dispose();
res.cleanUp().then(done, done);
});
// res.cleanUp().then(done, done);
// });
fs.unlinkSync(res.testFile);
}, done);
});
// fs.unlinkSync(res.testFile);
// }, done);
// });
test('reload', function (done) {
testFile('config', 'config.json').then(res => {

16
src/vs/base/test/node/extfs/extfs.test.ts
View File

@@ -6,16 +6,16 @@
'use strict';
import * as assert from 'assert';
import * as os from 'os';
import * as path from 'path';
import * as fs from 'fs';
import * as uuid from 'vs/base/common/uuid';
import * as strings from 'vs/base/common/strings';
import * as extfs from 'vs/base/node/extfs';
import * as os from 'os';
import * as path from 'path';
import { Readable } from 'stream';
import { canNormalize } from 'vs/base/common/normalization';
import { isLinux, isWindows } from 'vs/base/common/platform';
import * as uuid from 'vs/base/common/uuid';
import * as extfs from 'vs/base/node/extfs';
const ignore = () => { };
@@ -224,7 +224,7 @@ suite('Extfs', () => {
});
test('readdir', function (done) {
if (strings.canNormalize && typeof process.versions['electron'] !== 'undefined' /* needs electron */) {
if (canNormalize && typeof process.versions['electron'] !== 'undefined' /* needs electron */) {
const id = uuid.generateUuid();
const parentDir = path.join(os.tmpdir(), 'vsctests', id);
const newDir = path.join(parentDir, 'extfs', id, 'öäü');

799
src/vs/base/test/node/glob.test.ts
View File

File diff suppressed because it is too large Load Diff

9
src/vs/base/test/node/id.test.ts
View File

@@ -5,6 +5,7 @@
'use strict';
import * as assert from 'assert';
import * as getmac from 'getmac';
import { getMachineId } from 'vs/base/node/id';
suite('ID', () => {
@@ -14,4 +15,12 @@ suite('ID', () => {
assert.ok(id);
});
});
test('getMac', function () {
return new Promise<string>((resolve, reject) => {
getmac.getMac((err, macAddress) => err ? reject(err) : resolve(macAddress));
}).then(macAddress => {
assert.ok(/^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/.test(macAddress), `Expected a MAC address, got: ${macAddress}`);
});
});
});

3061
src/vs/base/test/node/uri.test.data.txt Normal file
View File

File diff suppressed because it is too large Load Diff

61
src/vs/base/test/node/uri.test.perf.ts Normal file
View File

@@ -0,0 +1,61 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as assert from 'assert';
import URI from 'vs/base/common/uri';
import { readFileSync } from 'fs';
suite('URI - perf', function () {
let manyFileUris: URI[];
setup(function () {
manyFileUris = [];
let data = readFileSync(URI.parse(require.toUrl('./uri.test.data.txt')).fsPath).toString();
let lines = data.split('\n');
for (let line of lines) {
manyFileUris.push(URI.file(line));
}
});
function perfTest(name: string, callback: Function) {
test(name, _done => {
let t1 = Date.now();
callback();
let d = Date.now() - t1;
console.log(`${name} took ${d}ms (${(d / manyFileUris.length).toPrecision(3)} ms/uri)`);
_done();
});
}
perfTest('toString', function () {
for (const uri of manyFileUris) {
let data = uri.toString();
assert.ok(data);
}
});
perfTest('toString(skipEncoding)', function () {
for (const uri of manyFileUris) {
let data = uri.toString(true);
assert.ok(data);
}
});
perfTest('fsPath', function () {
for (const uri of manyFileUris) {
let data = uri.fsPath;
assert.ok(data);
}
});
perfTest('toJSON', function () {
for (const uri of manyFileUris) {
let data = uri.toJSON();
assert.ok(data);
}
});
});

2
src/vs/base/test/node/zip/zip.test.ts
View File

@@ -12,7 +12,7 @@ import URI from 'vs/base/common/uri';
import { extract } from 'vs/base/node/zip';
import { generateUuid } from 'vs/base/common/uuid';
import { rimraf, exists } from 'vs/base/node/pfs';
import { NullLogService } from '../../../../platform/log/common/log';
import { NullLogService } from 'vs/platform/log/common/log';
const fixtures = URI.parse(require.toUrl('./fixtures')).fsPath;