386 lines
14 KiB
HTML
386 lines
14 KiB
HTML
<!doctype html>
|
|
<html>
|
|
<head>
|
|
<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
|
|
<script>
|
|
function test()
|
|
{
|
|
let suite = InspectorTest.createSyncSuite("ResourceQueryController");
|
|
|
|
suite.addTestCase({
|
|
name: "FindSpecialCharacterIndices",
|
|
description: "Should correctly find special filename characters.",
|
|
test() {
|
|
let matcher = new WI.ResourceQueryController;
|
|
let tests = [
|
|
{
|
|
filename: "Abcd",
|
|
expected: "^"
|
|
},
|
|
{
|
|
filename: "ABCDE",
|
|
expected: "^"
|
|
},
|
|
{
|
|
filename: "abcdef",
|
|
expected: "^",
|
|
},
|
|
{
|
|
filename: "abc-def",
|
|
expected: "^ ^^",
|
|
},
|
|
{
|
|
filename: "abc---def",
|
|
expected: "^ ^^^^",
|
|
},
|
|
{
|
|
filename: "a-bc_de.f",
|
|
expected: "^^^ ^^ ^^",
|
|
},
|
|
{
|
|
filename: "AxBxCxDxExFx",
|
|
expected: "^ ^ ^ ^ ^ ^",
|
|
},
|
|
{
|
|
filename: "ab-c_d.ef",
|
|
expected: "^ ^^^^^^",
|
|
},
|
|
{
|
|
filename: "AxBxCxdxexDxyxEF",
|
|
expected: "^ ^ ^ ^ ^",
|
|
},
|
|
];
|
|
|
|
function createSpecialMask(filename, specialIndices) {
|
|
let mask = " ".repeat(filename.length);
|
|
specialIndices.forEach((index) => {
|
|
mask = mask.substr(0, index) + "^" + mask.substr(index + 1);
|
|
});
|
|
return mask.trim();
|
|
}
|
|
|
|
for (let {filename, expected} of tests) {
|
|
let actual = createSpecialMask(filename, matcher._findSpecialCharacterIndices(filename));
|
|
InspectorTest.expectEqual(actual, expected, "Result should match expected special indices.");
|
|
}
|
|
}
|
|
});
|
|
|
|
suite.addTestCase({
|
|
name: "ExecuteQueryAgainstNoResources",
|
|
description: "Should return no results if no resources were added to the controller.",
|
|
test() {
|
|
let matcher = new WI.ResourceQueryController;
|
|
let results = matcher.executeQuery("abcde");
|
|
InspectorTest.expectThat(!results.length, "Should return no results.")
|
|
}
|
|
});
|
|
|
|
suite.addTestCase({
|
|
name: "ExecuteWhitespaceQueryOrEmptyQuery",
|
|
description: "Empty queries and queries containing only whitespace should return no results.",
|
|
test() {
|
|
const whitespaceCharacters = " \t\r\n";
|
|
let matcher = new WI.ResourceQueryController;
|
|
matcher.addResource(new WI.Resource("abcde"));
|
|
|
|
for (let query of whitespaceCharacters) {
|
|
let results = matcher.executeQuery(query);
|
|
InspectorTest.expectThat(!results.length, "Whitespace query should return no results.");
|
|
}
|
|
|
|
let results = matcher.executeQuery("");
|
|
InspectorTest.expectThat(!results.length, "Empty query should return no results.");
|
|
}
|
|
});
|
|
|
|
suite.addTestCase({
|
|
name: "ExecuteQueryContainingWhitespace",
|
|
description: "Whitespace within a query should be ignored.",
|
|
test() {
|
|
let matcher = new WI.ResourceQueryController;
|
|
matcher.addResource(new WI.Resource("abcde"));
|
|
|
|
for (let query of [" abcde", "abcde ", " abcde ", "a b c d e", "a b c d e"]) {
|
|
let results = matcher.executeQuery(query);
|
|
InspectorTest.expectEqual(results.length, 1, "Should match one result.");
|
|
}
|
|
}
|
|
});
|
|
|
|
suite.addTestCase({
|
|
name: "ExecuteQueryMatchNone",
|
|
description: "Should not find a match.",
|
|
test() {
|
|
let matcher = new WI.ResourceQueryController;
|
|
let tests = [
|
|
{query: "abcde", filename: "abcd"},
|
|
{query: "abcd-", filename: "abcde"},
|
|
{query: "abcde", filename: "abced"},
|
|
];
|
|
|
|
for (let {query, filename} of tests) {
|
|
matcher.reset();
|
|
matcher.addResource(new WI.Resource(filename));
|
|
let results = matcher.executeQuery(query);
|
|
InspectorTest.expectThat(!results.length, `Query "${query}" shouldn't match "${filename}".`);
|
|
}
|
|
}
|
|
});
|
|
|
|
suite.addTestCase({
|
|
name: "ExecuteQueryMatchesExpectedCharacters",
|
|
description: "Should match the expected query characters.",
|
|
test() {
|
|
let matcher = new WI.ResourceQueryController;
|
|
let tests = [
|
|
{
|
|
query: "abcd",
|
|
filename: "abcde",
|
|
expected: "abcd"
|
|
},
|
|
{
|
|
query: " abcd",
|
|
filename: "abcde",
|
|
expected: "abcd"
|
|
},
|
|
{
|
|
query: "abcd ",
|
|
filename: "abcde",
|
|
expected: "abcd"
|
|
},
|
|
{
|
|
query: "a b c d",
|
|
filename: "abcde",
|
|
expected: "abcd"
|
|
},
|
|
{
|
|
query: "a-bcde",
|
|
filename: "abcde-abcde",
|
|
expected: "a - bcde"
|
|
},
|
|
{
|
|
query: "abcde",
|
|
filename: "AaBbCcDdEe",
|
|
expected: "A B C D E"
|
|
},
|
|
{
|
|
query: "abcde",
|
|
filename: "AbcdBcdCdDe",
|
|
expected: "A B C De"
|
|
},
|
|
{
|
|
query: "abcdex",
|
|
filename: "AxBxCxdxexDxyxEF",
|
|
expected: "A B C d ex"
|
|
},
|
|
{
|
|
query: "bc",
|
|
filename: "abCd",
|
|
expected: " bC"
|
|
},
|
|
{
|
|
query: "bb",
|
|
filename: "abBc",
|
|
expected: " bB"
|
|
}
|
|
];
|
|
|
|
for (let {query, filename, expected} of tests) {
|
|
matcher.reset();
|
|
matcher.addResource(new WI.Resource(filename));
|
|
|
|
let results = matcher.executeQuery(query);
|
|
InspectorTest.assert(results.length === 1, "Should return exactly one match.");
|
|
let actual = results.length ? results[0].__test_createMatchesMask() : null;
|
|
InspectorTest.expectEqual(actual, expected, `Query "${query}" should match "${expected}" in "${filename}".`);
|
|
}
|
|
}
|
|
});
|
|
|
|
// Generator for creating a sequence of case permutations for a string.
|
|
// Example: "xx" => ["xx", "Xx", "xX", "XX"]
|
|
function *casePermutations(string) {
|
|
let permutationCount = Math.pow(2, string.length);
|
|
InspectorTest.assert(permutationCount !== Infinity, "String length exceeds permutations limit.");
|
|
if (permutationCount === Infinity)
|
|
return;
|
|
|
|
let index = 0;
|
|
while (index < permutationCount) {
|
|
let result = "";
|
|
for (let i = 0; i < string.length; ++i)
|
|
result += (index & (1 << i)) ? string[i].toUpperCase() : string[i].toLowerCase();
|
|
|
|
index++;
|
|
yield result;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
suite.addTestCase({
|
|
name: "ExecuteQueryShouldIgnoreCase",
|
|
description: "Queries that differ only in case should return identical results.",
|
|
test() {
|
|
let matcher = new WI.ResourceQueryController;
|
|
let tests = [
|
|
{
|
|
query: "abcd",
|
|
filename: "abcde",
|
|
expected: "abcd"
|
|
},
|
|
{
|
|
query: "abcde",
|
|
filename: "AaBbCcDdEe",
|
|
expected: "A B C D E"
|
|
},
|
|
{
|
|
query: "abcde",
|
|
filename: "AbcdBcdCdDe",
|
|
expected: "A B C De"
|
|
},
|
|
{
|
|
query: "abcdex",
|
|
filename: "AxBxCxdxexDxyxEF",
|
|
expected: "A B C d ex"
|
|
},
|
|
{
|
|
query: "bc",
|
|
filename: "abCd",
|
|
expected: " bC"
|
|
},
|
|
];
|
|
|
|
for (let {query, filename, expected} of tests) {
|
|
InspectorTest.log(`All case permutations of query "${query}" should match "${expected}" in "${filename}".`);
|
|
|
|
matcher.reset();
|
|
matcher.addResource(new WI.Resource(filename));
|
|
|
|
for (let queryPermutation of casePermutations(query)) {
|
|
let results = matcher.executeQuery(queryPermutation);
|
|
let actual = results.length === 1 ? results[0].__test_createMatchesMask() : "";
|
|
InspectorTest.expectEqual(expected, actual, `Permutation "${queryPermutation}".`);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
suite.addTestCase({
|
|
name: "ExecuteQueryGeneralRankings",
|
|
description: "Check that query results are ranked by descending relevance.",
|
|
test() {
|
|
let filenames = ["AbCdE", "AbcDe", "abcde", "AxbcDe", "AxBxCxDxEx", "AxbxcDe", "xabcde"]; // Filenames in order of descending rank.
|
|
let matcher = new WI.ResourceQueryController;
|
|
filenames.forEach((filename) => matcher.addResource(new WI.Resource(filename)));
|
|
|
|
let query = "abcde";
|
|
let results = matcher.executeQuery(query);
|
|
let resultFilenames = results.map((filename) => filename.resource.displayName);
|
|
InspectorTest.expectShallowEqual(resultFilenames, filenames, "Results should be ranked by descending relevancy.");
|
|
}
|
|
});
|
|
|
|
suite.addTestCase({
|
|
name: "ExecuteQueryPositionRankings",
|
|
description: "Check that matches close to the beginning of the filename rank higher.",
|
|
test() {
|
|
let filenames = ["bcd", "BxCxDx", "AxBxCxDx", "abcd", "xxxAxxxBxxxCxxxD"]; // Filenames in order of descending rank.
|
|
let matcher = new WI.ResourceQueryController;
|
|
filenames.forEach((filename) => matcher.addResource(new WI.Resource(filename)));
|
|
|
|
let query = "bcd";
|
|
let results = matcher.executeQuery(query);
|
|
let resultFilenames = results.map((result) => result.resource.displayName);
|
|
InspectorTest.expectShallowEqual(resultFilenames, filenames, "Results should be ranked by descending relevancy.");
|
|
}
|
|
});
|
|
|
|
suite.addTestCase({
|
|
name: "ExecuteQueryConsecutiveRankings",
|
|
description: "Check that consecutive matches rank higher.",
|
|
test() {
|
|
let matcher = new WI.ResourceQueryController;
|
|
let tests = [
|
|
{
|
|
filenames: ["Color.js", "HighlightColor.js", "CxxOxxLxxOxxR.js"],
|
|
query: "color",
|
|
},
|
|
{
|
|
filenames: ["ContentView.js", "CxxVxxIxxExxW.js"],
|
|
query: "cview",
|
|
},
|
|
{
|
|
filenames: ["HeapSnapshot.js", "HxxSxxHxxOxxT.js"],
|
|
query: "hshot",
|
|
},
|
|
];
|
|
|
|
let passed = true;
|
|
for (let {filenames, query} of tests) {
|
|
matcher.reset();
|
|
filenames.forEach((filename) => matcher.addResource(new WI.Resource(filename)));
|
|
|
|
let results = matcher.executeQuery(query);
|
|
let resultFilenames = results.map((result) => result.resource.displayName);
|
|
|
|
passed = passed && Object.shallowEqual(resultFilenames, filenames);
|
|
}
|
|
|
|
InspectorTest.expectThat(passed, "Results should be ranked by descending relevancy.");
|
|
}
|
|
});
|
|
|
|
suite.addTestCase({
|
|
name: "GetMatchingTextRanges",
|
|
description: "Check that query result TextRanges are correct.",
|
|
test() {
|
|
function textRange(start, end) {
|
|
return new WI.TextRange(0, start, 0, end);
|
|
}
|
|
|
|
let matcher = new WI.ResourceQueryController;
|
|
let tests = [
|
|
{filename: "a", ranges: []},
|
|
{filename: "abcde", ranges: [textRange(0, 5)]},
|
|
{filename: "AxBxCxDe", ranges: [textRange(0, 1), textRange(2, 3), textRange(4, 5), textRange(6, 8)]},
|
|
];
|
|
|
|
for (let {filename, ranges} of tests) {
|
|
matcher.reset();
|
|
matcher.addResource(new WI.Resource(filename));
|
|
|
|
let results = matcher.executeQuery("abcde");
|
|
let resultTextRanges = results.length ? results[0].matchingTextRanges : [];
|
|
InspectorTest.expectEqual(JSON.stringify(resultTextRanges), JSON.stringify(ranges), "Result TextRanges should match the expected ranges.");
|
|
}
|
|
}
|
|
});
|
|
|
|
suite.addTestCase({
|
|
name: "QueryMatchesExtension",
|
|
description: "Test case for when a character from the query is found in the extension of the resource.",
|
|
test() {
|
|
const query = "TestCase";
|
|
const filenames = ["TestCase.123", "TestCase.a", "TestCase.b"];
|
|
|
|
let matcher = new WI.ResourceQueryController;
|
|
for (let filename of filenames)
|
|
matcher.addResource(new WI.Resource(filename));
|
|
|
|
let results = matcher.executeQuery(query);
|
|
let resultFilenames = results.map((result) => result.resource.displayName);
|
|
InspectorTest.expectShallowEqual(resultFilenames, filenames, "All resources should be matched.");
|
|
}
|
|
});
|
|
|
|
suite.runTestCasesAndFinish();
|
|
}
|
|
</script>
|
|
</head>
|
|
<body onload="runTest()">
|
|
<p>Testing WI.ResourceQueryController.</p>
|
|
</body>
|
|
</html>
|