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

Merge from vscode 10492ba146318412cbee8b76a8c630f226914734

Browse Source
This commit is contained in:
ADS Merger
2020-04-08 06:33:38 +00:00
parent fca2344c2e
commit 1868a7d370
339 changed files with 3795 additions and 3146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
src/vs/base/test/browser/ui/tree/compressedObjectTreeModel.test.ts
View File

@@ -5,7 +5,7 @@
import * as assert from 'assert';
import { compress, ICompressedTreeElement, ICompressedTreeNode, decompress, CompressedObjectTreeModel } from 'vs/base/browser/ui/tree/compressedObjectTreeModel';
import { Iterator } from 'vs/base/common/iterator';
import { Iterable } from 'vs/base/common/iterator';
import { ITreeNode } from 'vs/base/browser/ui/tree/tree';
import { ISpliceable } from 'vs/base/common/sequence';
@@ -16,7 +16,7 @@ interface IResolvedCompressedTreeElement<T> extends ICompressedTreeElement<T> {
function resolve<T>(treeElement: ICompressedTreeElement<T>): IResolvedCompressedTreeElement<T> {
const result: any = { element: treeElement.element };
const children = Iterator.collect(Iterator.map(Iterator.from(treeElement.children), resolve));
const children = [...Iterable.map(Iterable.from(treeElement.children), resolve)];
if (treeElement.incompressible) {
result.incompressible = true;
@@ -315,25 +315,25 @@ suite('CompressedObjectTree', function () {
const list: ITreeNode<ICompressedTreeNode<number>>[] = [];
const model = new CompressedObjectTreeModel<number>('test', toSpliceable(list));
model.setChildren(null, Iterator.fromArray([
model.setChildren(null, [
{ element: 0 },
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(toArray(list), [[0], [1], [2]]);
assert.equal(model.size, 3);
model.setChildren(null, Iterator.fromArray([
model.setChildren(null, [
{ element: 3 },
{ element: 4 },
{ element: 5 },
]));
]);
assert.deepEqual(toArray(list), [[3], [4], [5]]);
assert.equal(model.size, 3);
model.setChildren(null, Iterator.empty());
model.setChildren(null);
assert.deepEqual(toArray(list), []);
assert.equal(model.size, 0);
});
@@ -342,34 +342,34 @@ suite('CompressedObjectTree', function () {
const list: ITreeNode<ICompressedTreeNode<number>>[] = [];
const model = new CompressedObjectTreeModel<number>('test', toSpliceable(list));
model.setChildren(null, Iterator.fromArray([
model.setChildren(null, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(toArray(list), [[0], [10], [11], [12], [1], [2]]);
assert.equal(model.size, 6);
model.setChildren(12, Iterator.fromArray([
model.setChildren(12, [
{ element: 120 },
{ element: 121 }
]));
]);
assert.deepEqual(toArray(list), [[0], [10], [11], [12], [120], [121], [1], [2]]);
assert.equal(model.size, 8);
model.setChildren(0, Iterator.empty());
model.setChildren(0);
assert.deepEqual(toArray(list), [[0], [1], [2]]);
assert.equal(model.size, 3);
model.setChildren(null, Iterator.empty());
model.setChildren(null);
assert.deepEqual(toArray(list), []);
assert.equal(model.size, 0);
});
@@ -378,50 +378,50 @@ suite('CompressedObjectTree', function () {
const list: ITreeNode<ICompressedTreeNode<number>>[] = [];
const model = new CompressedObjectTreeModel<number>('test', toSpliceable(list));
model.setChildren(null, Iterator.fromArray([
model.setChildren(null, [
{
element: 1, children: Iterator.fromArray([{
element: 11, children: Iterator.fromArray([{
element: 111, children: Iterator.fromArray([
element: 1, children: [{
element: 11, children: [{
element: 111, children: [
{ element: 1111 },
{ element: 1112 },
{ element: 1113 },
])
}])
}])
]
}]
}]
}
]));
]);
assert.deepEqual(toArray(list), [[1, 11, 111], [1111], [1112], [1113]]);
assert.equal(model.size, 6);
model.setChildren(11, Iterator.fromArray([
model.setChildren(11, [
{ element: 111 },
{ element: 112 },
{ element: 113 },
]));
]);
assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113]]);
assert.equal(model.size, 5);
model.setChildren(113, Iterator.fromArray([
model.setChildren(113, [
{ element: 1131 }
]));
]);
assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113, 1131]]);
assert.equal(model.size, 6);
model.setChildren(1131, Iterator.fromArray([
model.setChildren(1131, [
{ element: 1132 }
]));
]);
assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113, 1131, 1132]]);
assert.equal(model.size, 7);
model.setChildren(1131, Iterator.fromArray([
model.setChildren(1131, [
{ element: 1132 },
{ element: 1133 },
]));
]);
assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113, 1131], [1132], [1133]]);
assert.equal(model.size, 8);

121
src/vs/base/test/browser/ui/tree/indexTreeModel.test.ts
View File

@@ -6,7 +6,6 @@
import * as assert from 'assert';
import { ITreeNode, ITreeFilter, TreeVisibility } from 'vs/base/browser/ui/tree/tree';
import { ISpliceable } from 'vs/base/common/sequence';
import { Iterator } from 'vs/base/common/iterator';
import { IndexTreeModel, IIndexTreeNode } from 'vs/base/browser/ui/tree/indexTreeModel';
function toSpliceable<T>(arr: T[]): ISpliceable<T> {
@@ -34,11 +33,11 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{ element: 0 },
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(list.length, 3);
assert.deepEqual(list[0].element, 0);
@@ -56,17 +55,17 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(list.length, 6);
assert.deepEqual(list[0].element, 0);
@@ -93,17 +92,17 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, collapsed: true, children: Iterator.fromArray([
element: 0, collapsed: true, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(list.length, 3);
assert.deepEqual(list[0].element, 0);
@@ -121,11 +120,11 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{ element: 0 },
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(list.length, 3);
@@ -146,17 +145,17 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(list.length, 6);
@@ -180,17 +179,17 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(list.length, 6);
@@ -208,17 +207,17 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, collapsed: true, children: Iterator.fromArray([
element: 0, collapsed: true, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(list.length, 3);
@@ -233,17 +232,17 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(list.length, 6);
@@ -264,17 +263,17 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, collapsed: true, children: Iterator.fromArray([
element: 0, collapsed: true, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(list.length, 3);
@@ -304,7 +303,7 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 1, children: [
{
@@ -319,7 +318,7 @@ suite('IndexTreeModel', function () {
{ element: 21 }
]
}
]));
]);
assert.deepEqual(list.length, 5);
assert.deepEqual(toArray(list), [1, 11, 111, 2, 21]);
@@ -337,13 +336,13 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 }
])
]
}
]));
]);
assert.deepEqual(list.length, 2);
@@ -406,7 +405,7 @@ suite('IndexTreeModel', function () {
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1, { filter });
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, children: [
{ element: 1 },
@@ -418,7 +417,7 @@ suite('IndexTreeModel', function () {
{ element: 7 }
]
}
]));
]);
assert.deepEqual(list.length, 4);
assert.deepEqual(toArray(list), [0, 2, 4, 6]);
@@ -440,14 +439,14 @@ suite('IndexTreeModel', function () {
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1, { filter });
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, children: [
{ element: 1 },
{ element: 2 }
]
}
]));
]);
assert.deepEqual(toArray(list), []);
});
@@ -463,7 +462,7 @@ suite('IndexTreeModel', function () {
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1, { filter });
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, children: [
{ element: 1 },
@@ -475,7 +474,7 @@ suite('IndexTreeModel', function () {
{ element: 7 }
]
},
]));
]);
assert.deepEqual(toArray(list), [0, 1, 2, 3, 4, 5, 6, 7]);
@@ -502,7 +501,7 @@ suite('IndexTreeModel', function () {
const model = new IndexTreeModel<string>('test', toSpliceable(list), 'root', { filter });
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 'vscode', children: [
{ element: '.build' },
@@ -522,7 +521,7 @@ suite('IndexTreeModel', function () {
}
]
},
]));
]);
assert.deepEqual(list.length, 10);
@@ -548,7 +547,7 @@ suite('IndexTreeModel', function () {
const model = new IndexTreeModel<string>('test', toSpliceable(list), 'root', { filter });
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 'vscode', children: [
{ element: '.build' },
@@ -568,7 +567,7 @@ suite('IndexTreeModel', function () {
}
]
},
]));
]);
assert.deepEqual(list.length, 10);
@@ -594,7 +593,7 @@ suite('IndexTreeModel', function () {
const model = new IndexTreeModel<string>('test', toSpliceable(list), 'root', { filter });
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 'vscode', collapsed: true, children: [
{ element: '.build' },
@@ -614,7 +613,7 @@ suite('IndexTreeModel', function () {
}
]
},
]));
]);
assert.deepEqual(toArray(list), ['vscode']);
@@ -642,17 +641,17 @@ suite('IndexTreeModel', function () {
const list: IIndexTreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(model.getNodeLocation(list[0]), [0]);
assert.deepEqual(model.getNodeLocation(list[1]), [0, 0]);
@@ -672,7 +671,7 @@ suite('IndexTreeModel', function () {
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1, { filter });
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, children: [
{ element: 1 },
@@ -684,7 +683,7 @@ suite('IndexTreeModel', function () {
{ element: 7 }
]
}
]));
]);
assert.deepEqual(model.getNodeLocation(list[0]), [0]);
assert.deepEqual(model.getNodeLocation(list[1]), [0, 1]);
@@ -704,11 +703,11 @@ suite('IndexTreeModel', function () {
const model = new IndexTreeModel<string>('test', toSpliceable(list), 'root', { filter });
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{ element: 'silver' },
{ element: 'gold' },
{ element: 'platinum' }
]));
]);
assert.deepEqual(toArray(list), ['silver', 'gold', 'platinum']);
@@ -716,11 +715,11 @@ suite('IndexTreeModel', function () {
model.refilter();
assert.deepEqual(toArray(list), ['platinum']);
model.splice([0], Number.POSITIVE_INFINITY, Iterator.fromArray([
model.splice([0], Number.POSITIVE_INFINITY, [
{ element: 'silver' },
{ element: 'gold' },
{ element: 'platinum' }
]));
]);
assert.deepEqual(toArray(list), ['platinum']);
model.refilter();

81
src/vs/base/test/browser/ui/tree/objectTree.test.ts
View File

@@ -7,7 +7,6 @@ import * as assert from 'assert';
import { ITreeNode, ITreeRenderer } from 'vs/base/browser/ui/tree/tree';
import { IListVirtualDelegate, IIdentityProvider } from 'vs/base/browser/ui/list/list';
import { ObjectTree, CompressibleObjectTree, ICompressibleTreeRenderer } from 'vs/base/browser/ui/tree/objectTree';
import { Iterator } from 'vs/base/common/iterator';
import { ICompressedTreeNode } from 'vs/base/browser/ui/tree/compressedObjectTreeModel';
suite('ObjectTree', function () {
@@ -46,17 +45,17 @@ suite('ObjectTree', function () {
});
test('should be able to navigate', () => {
tree.setChildren(null, Iterator.fromArray([
tree.setChildren(null, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
const navigator = tree.navigate();
@@ -87,17 +86,17 @@ suite('ObjectTree', function () {
});
test('should skip collapsed nodes', () => {
tree.setChildren(null, Iterator.fromArray([
tree.setChildren(null, [
{
element: 0, collapsed: true, children: Iterator.fromArray([
element: 0, collapsed: true, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
const navigator = tree.navigate();
@@ -118,17 +117,17 @@ suite('ObjectTree', function () {
test('should skip filtered elements', () => {
filter = el => el % 2 === 0;
tree.setChildren(null, Iterator.fromArray([
tree.setChildren(null, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
const navigator = tree.navigate();
@@ -150,17 +149,17 @@ suite('ObjectTree', function () {
});
test('should be able to start from node', () => {
tree.setChildren(null, Iterator.fromArray([
tree.setChildren(null, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
const navigator = tree.navigate(1);
@@ -291,50 +290,50 @@ suite('CompressibleObjectTree', function () {
const tree = new CompressibleObjectTree<number>('test', container, new Delegate(), [new Renderer()]);
tree.layout(200);
tree.setChildren(null, Iterator.fromArray([
tree.setChildren(null, [
{
element: 1, children: Iterator.fromArray([{
element: 11, children: Iterator.fromArray([{
element: 111, children: Iterator.fromArray([
element: 1, children: [{
element: 11, children: [{
element: 111, children: [
{ element: 1111 },
{ element: 1112 },
{ element: 1113 },
])
}])
}])
]
}]
}]
}
]));
]);
let rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
assert.deepEqual(rows, ['1/11/111', '1111', '1112', '1113']);
tree.setChildren(11, Iterator.fromArray([
tree.setChildren(11, [
{ element: 111 },
{ element: 112 },
{ element: 113 },
]));
]);
rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
assert.deepEqual(rows, ['1/11', '111', '112', '113']);
tree.setChildren(113, Iterator.fromArray([
tree.setChildren(113, [
{ element: 1131 }
]));
]);
rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
assert.deepEqual(rows, ['1/11', '111', '112', '113/1131']);
tree.setChildren(1131, Iterator.fromArray([
tree.setChildren(1131, [
{ element: 1132 }
]));
]);
rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
assert.deepEqual(rows, ['1/11', '111', '112', '113/1131/1132']);
tree.setChildren(1131, Iterator.fromArray([
tree.setChildren(1131, [
{ element: 1132 },
{ element: 1133 },
]));
]);
rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
assert.deepEqual(rows, ['1/11', '111', '112', '113/1131', '1132', '1133']);
@@ -348,19 +347,19 @@ suite('CompressibleObjectTree', function () {
const tree = new CompressibleObjectTree<number>('test', container, new Delegate(), [new Renderer()]);
tree.layout(200);
tree.setChildren(null, Iterator.fromArray([
tree.setChildren(null, [
{
element: 1, children: Iterator.fromArray([{
element: 11, children: Iterator.fromArray([{
element: 111, children: Iterator.fromArray([
element: 1, children: [{
element: 11, children: [{
element: 111, children: [
{ element: 1111 },
{ element: 1112 },
{ element: 1113 },
])
}])
}])
]
}]
}]
}
]));
]);
let rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
assert.deepEqual(rows, ['1/11/111', '1111', '1112', '1113']);

35
src/vs/base/test/browser/ui/tree/objectTreeModel.test.ts
View File

@@ -7,7 +7,6 @@ import * as assert from 'assert';
import { ITreeNode } from 'vs/base/browser/ui/tree/tree';
import { ISpliceable } from 'vs/base/common/sequence';
import { ObjectTreeModel } from 'vs/base/browser/ui/tree/objectTreeModel';
import { Iterator } from 'vs/base/common/iterator';
function toSpliceable<T>(arr: T[]): ISpliceable<T> {
return {
@@ -35,25 +34,25 @@ suite('ObjectTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new ObjectTreeModel<number>('test', toSpliceable(list));
model.setChildren(null, Iterator.fromArray([
model.setChildren(null, [
{ element: 0 },
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(toArray(list), [0, 1, 2]);
assert.equal(model.size, 3);
model.setChildren(null, Iterator.fromArray([
model.setChildren(null, [
{ element: 3 },
{ element: 4 },
{ element: 5 },
]));
]);
assert.deepEqual(toArray(list), [3, 4, 5]);
assert.equal(model.size, 3);
model.setChildren(null, Iterator.empty());
model.setChildren(null);
assert.deepEqual(toArray(list), []);
assert.equal(model.size, 0);
});
@@ -62,34 +61,34 @@ suite('ObjectTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new ObjectTreeModel<number>('test', toSpliceable(list));
model.setChildren(null, Iterator.fromArray([
model.setChildren(null, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(toArray(list), [0, 10, 11, 12, 1, 2]);
assert.equal(model.size, 6);
model.setChildren(12, Iterator.fromArray([
model.setChildren(12, [
{ element: 120 },
{ element: 121 }
]));
]);
assert.deepEqual(toArray(list), [0, 10, 11, 12, 120, 121, 1, 2]);
assert.equal(model.size, 8);
model.setChildren(0, Iterator.empty());
model.setChildren(0);
assert.deepEqual(toArray(list), [0, 1, 2]);
assert.equal(model.size, 3);
model.setChildren(null, Iterator.empty());
model.setChildren(null);
assert.deepEqual(toArray(list), []);
assert.equal(model.size, 0);
});
@@ -98,16 +97,16 @@ suite('ObjectTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new ObjectTreeModel<number>('test', toSpliceable(list));
model.setChildren(null, Iterator.fromArray([
model.setChildren(null, [
{ element: 0, collapsed: true }
]));
]);
assert.deepEqual(toArray(list), [0]);
model.setChildren(0, Iterator.fromArray([
model.setChildren(0, [
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(toArray(list), [0]);

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

@@ -343,6 +343,36 @@ suite('Filters', () => {
);
});
test('Freeze when fjfj -> jfjf, https://github.com/microsoft/vscode/issues/91807', function () {
assertMatches(
'jfjfj',
'fjfjfjfjfjfjfjfjfjfjfj',
undefined, fuzzyScore
);
assertMatches(
'jfjfjfjfjfjfjfjfjfj',
'fjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfj',
undefined, fuzzyScore
);
assertMatches(
'jfjfjfjfjfjfjfjfjfjjfjfjfjfjfjfjfjfjfjjfjfjfjfjfjfjfjfjfjjfjfjfjfjfjfjfjfjfjjfjfjfjfjfjfjfjfjfjjfjfjfjfjfjfjfjfjfj',
'fjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfj',
undefined, fuzzyScore
);
assertMatches(
'jfjfjfjfjfjfjfjfjfj',
'fJfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfj',
'f^J^f^j^f^j^f^j^f^j^f^j^f^j^f^j^f^j^f^jfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfj', // strong match
fuzzyScore
);
assertMatches(
'jfjfjfjfjfjfjfjfjfj',
'fjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfj',
'f^j^f^j^f^j^f^j^f^j^f^j^f^j^f^j^f^j^f^jfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfjfj', // any match
fuzzyScore, { firstMatchCanBeWeak: true }
);
});
test('fuzzyScore, issue #26423', function () {
assertMatches('baba', 'abababab', undefined, fuzzyScore);

14
src/vs/base/test/common/iterator.test.ts
View File

@@ -4,19 +4,7 @@
*--------------------------------------------------------------------------------------------*/
import * as assert from 'assert';
import { Iterator, Iterable } from 'vs/base/common/iterator';
suite('Iterator', () => {
test('concat', () => {
const first = Iterator.fromArray([1, 2, 3]);
const second = Iterator.fromArray([4, 5, 6]);
const third = Iterator.fromArray([7, 8, 9]);
const actualIterator = Iterator.concat(first, second, third);
const actual = Iterator.collect(actualIterator);
assert.deepEqual(actual, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
});
});
import { Iterable } from 'vs/base/common/iterator';
suite('Iterable', function () {

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

@@ -3,7 +3,7 @@
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { ResourceMap, TernarySearchTree, PathIterator, StringIterator, LinkedMap, Touch, LRUCache } from 'vs/base/common/map';
import { ResourceMap, TernarySearchTree, PathIterator, StringIterator, LinkedMap, Touch, LRUCache, UriIterator } from 'vs/base/common/map';
import * as assert from 'assert';
import { URI } from 'vs/base/common/uri';
@@ -312,7 +312,64 @@ suite('Map', () => {
assert.equal(iter.hasNext(), false);
});
function assertTernarySearchTree<E>(trie: TernarySearchTree<E>, ...elements: [string, E][]) {
test('URIIterator', function () {
const iter = new UriIterator();
iter.reset(URI.parse('file:///usr/bin/file.txt'));
assert.equal(iter.value(), 'file');
assert.equal(iter.cmp('FILE'), 0);
assert.equal(iter.hasNext(), true);
iter.next();
assert.equal(iter.value(), 'usr');
assert.equal(iter.hasNext(), true);
iter.next();
assert.equal(iter.value(), 'bin');
assert.equal(iter.hasNext(), true);
iter.next();
assert.equal(iter.value(), 'file.txt');
assert.equal(iter.hasNext(), false);
iter.reset(URI.parse('file://share/usr/bin/file.txt?foo'));
// scheme
assert.equal(iter.value(), 'file');
assert.equal(iter.cmp('FILE'), 0);
assert.equal(iter.hasNext(), true);
iter.next();
// authority
assert.equal(iter.value(), 'share');
assert.equal(iter.cmp('SHARe'), 0);
assert.equal(iter.hasNext(), true);
iter.next();
// path
assert.equal(iter.value(), 'usr');
assert.equal(iter.hasNext(), true);
iter.next();
// path
assert.equal(iter.value(), 'bin');
assert.equal(iter.hasNext(), true);
iter.next();
// path
assert.equal(iter.value(), 'file.txt');
assert.equal(iter.hasNext(), true);
iter.next();
// query
assert.equal(iter.value(), 'foo');
assert.equal(iter.cmp('z') > 0, true);
assert.equal(iter.cmp('a') < 0, true);
assert.equal(iter.hasNext(), false);
});
function assertTernarySearchTree<E>(trie: TernarySearchTree<string, E>, ...elements: [string, E][]) {
const map = new Map<string, E>();
for (const [key, value] of elements) {
map.set(key, value);
@@ -378,7 +435,7 @@ suite('Map', () => {
});
test('TernarySearchTree - basics', function () {
let trie = new TernarySearchTree<number>(new StringIterator());
let trie = new TernarySearchTree<string, number>(new StringIterator());
trie.set('foo', 1);
trie.set('bar', 2);
@@ -408,7 +465,7 @@ suite('Map', () => {
});
test('TernarySearchTree - delete & cleanup', function () {
let trie = new TernarySearchTree<number>(new StringIterator());
let trie = new TernarySearchTree<string, number>(new StringIterator());
trie.set('foo', 1);
trie.set('foobar', 2);
trie.set('bar', 3);
@@ -418,7 +475,7 @@ suite('Map', () => {
});
test('TernarySearchTree (PathSegments) - basics', function () {
let trie = new TernarySearchTree<number>(new PathIterator());
let trie = new TernarySearchTree<string, number>(new PathIterator());
trie.set('/user/foo/bar', 1);
trie.set('/user/foo', 2);
@@ -442,7 +499,7 @@ suite('Map', () => {
test('TernarySearchTree (PathSegments) - lookup', function () {
const map = new TernarySearchTree<number>(new PathIterator());
const map = new TernarySearchTree<string, number>(new PathIterator());
map.set('/user/foo/bar', 1);
map.set('/user/foo', 2);
map.set('/user/foo/flip/flop', 3);
@@ -456,7 +513,7 @@ suite('Map', () => {
test('TernarySearchTree (PathSegments) - superstr', function () {
const map = new TernarySearchTree<number>(new PathIterator());
const map = new TernarySearchTree<string, number>(new PathIterator());
map.set('/user/foo/bar', 1);
map.set('/user/foo', 2);
map.set('/user/foo/flip/flop', 3);
@@ -493,6 +550,100 @@ suite('Map', () => {
assert.equal(map.findSuperstr('/userr'), undefined);
});
test('TernarySearchTree (URI) - basics', function () {
let trie = new TernarySearchTree<URI, number>(new UriIterator());
trie.set(URI.file('/user/foo/bar'), 1);
trie.set(URI.file('/user/foo'), 2);
trie.set(URI.file('/user/foo/flip/flop'), 3);
assert.equal(trie.get(URI.file('/user/foo/bar')), 1);
assert.equal(trie.get(URI.file('/user/foo')), 2);
assert.equal(trie.get(URI.file('/user/foo/flip/flop')), 3);
assert.equal(trie.findSubstr(URI.file('/user/bar')), undefined);
assert.equal(trie.findSubstr(URI.file('/user/foo')), 2);
assert.equal(trie.findSubstr(URI.file('/user/foo/ba')), 2);
assert.equal(trie.findSubstr(URI.file('/user/foo/far/boo')), 2);
assert.equal(trie.findSubstr(URI.file('/user/foo/bar')), 1);
assert.equal(trie.findSubstr(URI.file('/user/foo/bar/far/boo')), 1);
});
test('TernarySearchTree (URI) - lookup', function () {
const map = new TernarySearchTree<URI, number>(new UriIterator());
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);
map.set(URI.parse('http://foo.bar/user/foo/flip/flop'), 3);
assert.equal(map.get(URI.parse('http://foo.bar/foo')), undefined);
assert.equal(map.get(URI.parse('http://foo.bar/user')), undefined);
assert.equal(map.get(URI.parse('http://foo.bar/user/foo/bar')), 1);
assert.equal(map.get(URI.parse('http://foo.bar/user/foo?query')), 2);
assert.equal(map.get(URI.parse('http://foo.bar/user/foo?Query')), undefined);
assert.equal(map.get(URI.parse('http://foo.bar/user/foo?QUERY')), 3);
assert.equal(map.get(URI.parse('http://foo.bar/user/foo/bar/boo')), undefined);
});
test('TernarySearchTree (PathSegments) - superstr', function () {
const map = new TernarySearchTree<URI, number>(new UriIterator());
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 iter = map.findSuperstr(URI.file('/user'))!;
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);
iter = map.findSuperstr(URI.file('/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);
iter = map.findSuperstr(URI.file('/'))!;
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, 4);
assert.equal(item.done, false);
item = iter.next();
assert.equal(item.value, undefined);
assert.equal(item.done, true);
assert.equal(map.findSuperstr(URI.file('/not')), undefined);
assert.equal(map.findSuperstr(URI.file('/us')), undefined);
assert.equal(map.findSuperstr(URI.file('/usrr')), undefined);
assert.equal(map.findSuperstr(URI.file('/userr')), undefined);
});
test('ResourceMap - basics', function () {
const map = new ResourceMap<any>();

21
src/vs/base/test/common/strings.test.ts
View File

@@ -81,6 +81,27 @@ suite('Strings', () => {
assertCompareIgnoreCase('O', '/');
});
test('compareIgnoreCase (substring)', () => {
function assertCompareIgnoreCase(a: string, b: string, aStart: number, aEnd: number, bStart: number, bEnd: number, recurse = true): void {
let actual = strings.compareIgnoreCase(a, b, aStart, aEnd, bStart, bEnd);
actual = actual > 0 ? 1 : actual < 0 ? -1 : actual;
let expected = strings.compare(a.toLowerCase().substring(aStart, aEnd), b.toLowerCase().substring(bStart, bEnd));
expected = expected > 0 ? 1 : expected < 0 ? -1 : expected;
assert.equal(actual, expected, `${a} <> ${b}`);
if (recurse) {
assertCompareIgnoreCase(b, a, bStart, bEnd, aStart, aEnd, false);
}
}
assertCompareIgnoreCase('', '', 0, 0, 0, 0);
assertCompareIgnoreCase('abc', 'ABC', 0, 1, 0, 1);
assertCompareIgnoreCase('abc', 'Aabc', 0, 3, 1, 4);
assertCompareIgnoreCase('abcABc', 'ABcd', 3, 6, 0, 4);
});
test('format', () => {
assert.strictEqual(strings.format('Foo Bar'), 'Foo Bar');
assert.strictEqual(strings.format('Foo {0} Bar'), 'Foo {0} Bar');

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

@@ -538,7 +538,7 @@ suite('URI', () => {
assert.throws(() => assertJoined(('foo:'), 'bazz', ''));
assert.throws(() => new URL('bazz', 'foo:'));
assert.throws(() => assertJoined(('foo://bar'), 'bazz', ''));
// assert.throws(() => new URL('bazz', 'foo://bar')); Edge,Chrome => throw, Safari => foo://bar/bazz, Firefox ??
// assert.throws(() => new URL('bazz', 'foo://bar')); Edge, Chrome => THROW, Firefox, Safari => foo://bar/bazz
});
test('URI#joinPath (posix)', function () {
@@ -549,8 +549,8 @@ suite('URI', () => {
assertJoined(('file://server/share/c:/'), '../../bazz', 'file://server/bazz', false);
assertJoined(('file://server/share/c:'), '../../bazz', 'file://server/bazz', false);
assertJoined(('file://ser/foo/'), '../../bazz', 'file://ser/bazz');
assertJoined(('file://ser/foo'), '../../bazz', 'file://ser/bazz');
assertJoined(('file://ser/foo/'), '../../bazz', 'file://ser/bazz', false); // Firefox -> Different, Edge, Chrome, Safar -> OK
assertJoined(('file://ser/foo'), '../../bazz', 'file://ser/bazz', false); // Firefox -> Different, Edge, Chrome, Safar -> OK
});
test('URI#joinPath (windows)', function () {