Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
arangodb/js/server/tests/aql/aql-functions-string.js

2267 lines
125 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* jshint globalstrict:false, strict:false, maxlen:5000 */
/* global assertEqual, assertNotEqual, assertTrue */
// //////////////////////////////////////////////////////////////////////////////
// / @brief tests for query language, functions
// /
// / @file
// /
// / DISCLAIMER
// /
// / Copyright 2010-2012 triagens GmbH, Cologne, Germany
// /
// / Licensed under the Apache License, Version 2.0 (the "License");
// / you may not use this file except in compliance with the License.
// / You may obtain a copy of the License at
// /
// / http://www.apache.org/licenses/LICENSE-2.0
// /
// / Unless required by applicable law or agreed to in writing, software
// / distributed under the License is distributed on an "AS IS" BASIS,
// / WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// / See the License for the specific language governing permissions and
// / limitations under the License.
// /
// / Copyright holder is triAGENS GmbH, Cologne, Germany
// /
// / @author Jan Steemann
// / @author Copyright 2012, triAGENS GmbH, Cologne, Germany
// //////////////////////////////////////////////////////////////////////////////
var internal = require('internal');
var errors = internal.errors;
var jsunity = require('jsunity');
var helper = require('@arangodb/aql-helper');
var getQueryResults = helper.getQueryResults;
var assertQueryError = helper.assertQueryError;
var assertQueryWarningAndNull = helper.assertQueryWarningAndNull;
// //////////////////////////////////////////////////////////////////////////////
// / @brief test suite
// //////////////////////////////////////////////////////////////////////////////
function ahuacatlStringFunctionsTestSuite () {
return {
// //////////////////////////////////////////////////////////////////////////////
// / @brief set up
// //////////////////////////////////////////////////////////////////////////////
setUp: function () {
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief tear down
// //////////////////////////////////////////////////////////////////////////////
tearDown: function () {
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test JSON_STRINGIFY
// //////////////////////////////////////////////////////////////////////////////
testJsonStringify: function () {
var buildQuery = function (nr, input) {
switch (nr) {
case 0:
return `RETURN JSON_STRINGIFY(${input})`;
case 1:
return `RETURN NOOPT(JSON_STRINGIFY(${input}))`;
default:
assertTrue(false, 'Undefined state');
}
};
for (var i = 0; i < 2; ++i) {
assertEqual([ 'null' ], getQueryResults(buildQuery(i, 'null')));
assertEqual([ 'false' ], getQueryResults(buildQuery(i, 'false')));
assertEqual([ 'true' ], getQueryResults(buildQuery(i, 'true')));
assertEqual([ '-19.3' ], getQueryResults(buildQuery(i, '-19.3')));
assertEqual([ '0' ], getQueryResults(buildQuery(i, '0')));
assertEqual([ '0' ], getQueryResults(buildQuery(i, '0.0')));
assertEqual([ '0.1' ], getQueryResults(buildQuery(i, '0.1')));
assertEqual([ '100' ], getQueryResults(buildQuery(i, '100')));
assertEqual([ '10001434.2' ], getQueryResults(buildQuery(i, '10001434.2')));
assertEqual([ '"foo bar"' ], getQueryResults(buildQuery(i, '"foo bar"')));
assertEqual([ '"foo \\" bar"' ], getQueryResults(buildQuery(i, '"foo \\" bar"')));
assertEqual([ '[]' ], getQueryResults(buildQuery(i, '[]')));
assertEqual([ '[1,2,3,4]' ], getQueryResults(buildQuery(i, '[ 1, 2, 3, 4 ]')));
assertEqual([ '[[1,2,3,4]]' ], getQueryResults(buildQuery(i, '[ [ 1, 2, 3, 4 ] ]')));
assertEqual([ '{}' ], getQueryResults(buildQuery(i, '{ }')));
assertEqual([ '{"a":1,"b":2}' ], getQueryResults(buildQuery(i, '{ a: 1, b : 2 }')));
assertEqual([ '{"A":2,"a":1}' ], getQueryResults(buildQuery(i, '{ A: 2, a: 1 }')));
assertEqual([ '{"a":1,"b":"foo","c":null}' ], getQueryResults(buildQuery(i, '{ "a": 1, "b": "foo", c: null }')));
}
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test JSON_PARSE
// //////////////////////////////////////////////////////////////////////////////
testJsonParse: function () {
var buildQuery = function (nr, input) {
switch (nr) {
case 0:
return `RETURN JSON_PARSE(${input})`;
case 1:
return `RETURN NOOPT(JSON_PARSE(${input}))`;
default:
assertTrue(false, 'Undefined state');
}
};
for (var i = 0; i < 2; ++i) {
// invalid JSON
assertEqual([ null ], getQueryResults(buildQuery(i, 'null')));
assertEqual([ null ], getQueryResults(buildQuery(i, 'false')));
assertEqual([ null ], getQueryResults(buildQuery(i, 'true')));
assertEqual([ null ], getQueryResults(buildQuery(i, '1234')));
assertEqual([ null ], getQueryResults(buildQuery(i, '""')));
assertEqual([ null ], getQueryResults(buildQuery(i, '" "')));
assertEqual([ null ], getQueryResults(buildQuery(i, '"abcd"')));
assertEqual([ null ], getQueryResults(buildQuery(i, '[]')));
assertEqual([ null ], getQueryResults(buildQuery(i, '{}')));
assertEqual([ null ], getQueryResults(buildQuery(i, '"["')));
assertEqual([ null ], getQueryResults(buildQuery(i, '"[]]"')));
assertEqual([ null ], getQueryResults(buildQuery(i, '"{"')));
assertEqual([ null ], getQueryResults(buildQuery(i, '"{}}"')));
assertEqual([ null ], getQueryResults(buildQuery(i, '"{a}"')));
assertEqual([ null ], getQueryResults(buildQuery(i, '"{\\"a\\"}"')));
assertEqual([ null ], getQueryResults(buildQuery(i, '"{a:1}"')));
// valid JSON
assertEqual([ null ], getQueryResults(buildQuery(i, '"null"')));
assertEqual([ false ], getQueryResults(buildQuery(i, '"false"')));
assertEqual([ true ], getQueryResults(buildQuery(i, '"true"')));
assertEqual([ -19.3 ], getQueryResults(buildQuery(i, '"-19.3"')));
assertEqual([ 0 ], getQueryResults(buildQuery(i, '"0"')));
assertEqual([ 0 ], getQueryResults(buildQuery(i, '"0.0"')));
assertEqual([ 0.1 ], getQueryResults(buildQuery(i, '"0.1"')));
assertEqual([ 100 ], getQueryResults(buildQuery(i, '"100"')));
assertEqual([ 10001434.2 ], getQueryResults(buildQuery(i, '"10001434.2"')));
assertEqual([ 'foo bar' ], getQueryResults(buildQuery(i, '"\\"foo bar\\""')));
assertEqual([ [] ], getQueryResults(buildQuery(i, '"[]"')));
assertEqual([ [1, 2, 3, 4] ], getQueryResults(buildQuery(i, '"[ 1, 2, 3, 4 ]"')));
assertEqual([ [[1, 2, 3, 4]] ], getQueryResults(buildQuery(i, '"[ [ 1, 2, 3, 4 ] ]"')));
assertEqual([ {} ], getQueryResults(buildQuery(i, '"{ }"')));
assertEqual([ { a: 1, b: 2 } ], getQueryResults(buildQuery(i, '"{ \\"a\\": 1, \\"b\\" : 2 }"')));
assertEqual([ { A: 2, a: 1 } ], getQueryResults(buildQuery(i, '"{ \\"A\\": 2, \\"a\\": 1 }"')));
assertEqual([ { a: 1, b: 'foo', c: null } ], getQueryResults(buildQuery(i, '"{ \\"a\\": 1, \\"b\\": \\"foo\\", \\"c\\": null }"')));
}
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test regex function, invalid arguments
// //////////////////////////////////////////////////////////////////////////////
testRegexInvalid: function () {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN REGEX_TEST()');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN REGEX_TEST("test")');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN REGEX_TEST("test", "meow", "foo", "bar")');
assertQueryWarningAndNull(errors.ERROR_QUERY_INVALID_REGEX.code, 'RETURN REGEX_TEST("test", "[")');
assertQueryWarningAndNull(errors.ERROR_QUERY_INVALID_REGEX.code, 'RETURN REGEX_TEST("test", "[^")');
assertQueryWarningAndNull(errors.ERROR_QUERY_INVALID_REGEX.code, 'RETURN REGEX_TEST("test", "a.(")');
assertQueryWarningAndNull(errors.ERROR_QUERY_INVALID_REGEX.code, 'RETURN REGEX_TEST("test", "(a")');
assertQueryWarningAndNull(errors.ERROR_QUERY_INVALID_REGEX.code, 'RETURN REGEX_TEST("test", "(a]")');
assertQueryWarningAndNull(errors.ERROR_QUERY_INVALID_REGEX.code, 'RETURN REGEX_TEST("test", "**")');
assertQueryWarningAndNull(errors.ERROR_QUERY_INVALID_REGEX.code, 'RETURN REGEX_TEST("test", "?")');
assertQueryWarningAndNull(errors.ERROR_QUERY_INVALID_REGEX.code, 'RETURN REGEX_TEST("test", "*")');
},
testRegex: function () {
var values = [
// empty values
['', '', true],
['', '^', true],
['', '$', true],
['', '^$', true],
['', '^.*$', true],
['', '^.+$', false],
['', '.', false],
['', '.?', true],
[' ', '.?', true],
[' ', '.+', true],
[' ', '.$', true],
[' ', '^.', true],
[' ', '.$', true],
[' ', '^.$', true],
[' ', '^.{1,}$', true],
[' ', '^.{2,}$', false],
// whole words
['the quick brown fox', 'the', true],
['the quick brown fox', 'quick', true],
['the quick brown fox', 'quicK', false],
['the quick brown fox', 'quIcK', false],
['the quick brown fox', 'brown', true],
['the quick brown fox', 'fox', true],
['the quick brown fox', 'The', false],
['the quick brown fox', 'THE', false],
['the quick brown fox', 'foxx', false],
['the quick brown fox', 'hasi', false],
['the quick brown fox', 'number', false],
// anchored
['the quick brown fox', '^the', true],
['the quick brown fox', '^the$', false],
['the quick brown fox', '^the quick', true],
['the quick brown fox', '^the quick brown', true],
['the quick brown fox', '^the quick brown fo', true],
['the quick brown fox', '^th', true],
['the quick brown fox', '^t', true],
['the quick brown fox', '^the quick$', false],
['the quick brown fox', '^quick', false],
['the quick brown fox', 'quick$', false],
['the quick brown fox', '^quick$', false],
['the quick brown fox', '^brown', false],
['the quick brown fox', 'brown$', false],
['the quick brown fox', '^brown$', false],
['the quick brown fox', 'fox', true],
['the quick brown fox', 'fox$', true],
['the quick brown fox', '^fox$', false],
['the quick brown fox', 'The', false],
['the quick brown fox', '^The', false],
['the quick brown fox', 'THE', false],
['the quick brown fox', '^THE', false],
['the quick brown fox', 'foxx', false],
['the quick brown fox', 'foxx$', false],
['the quick brown fox', 'the quick brown fox$', true],
['the quick brown fox', 'brown fox$', true],
['the quick brown fox', 'quick brown fox$', true],
['the quick brown fox', 'he quick brown fox$', true],
['the quick brown fox', 'e quick brown fox$', true],
['the quick brown fox', 'quick brown fox$', true],
['the quick brown fox', 'x$', true],
['the quick brown fox', '^', true],
['the quick brown fox', '$', true],
['the quick brown fox', '^.*$', true],
['the quick brown fox', '.*', true],
['the quick brown fox', '^.*', true],
['the quick brown fox', '^.*$', true],
// partials
['the quick brown fox', ' quick', true],
['the quick brown fox', ' Quick', false],
['the quick brown fox', 'the quick', true],
['the quick brown fox', 'the slow', false],
['the quick brown fox', 'the quick brown', true],
['the quick brown fox', 'the quick browne', false],
['the quick brown fox', 'the quick brownfox', false],
['the quick brown fox', 'the quick brown fox', true],
['the quick brown fox', 'the quick brown foxx', false],
['the quick brown fox', 'quick brown fox', true],
['the quick brown fox', 'a quick brown fox', false],
['the quick brown fox', 'brown fox', true],
['the quick brown fox', 'rown fox', true],
['the quick brown fox', 'rown f', true],
['the quick brown fox', 'e q', true],
['the quick brown fox', 'f z', false],
['the quick brown fox', 'red fo', false],
['the quick brown fox', 'köter', false],
['the quick brown fox', 'ö', false],
['the quick brown fox', 'z', false],
['the quick brown fox', 'z', false],
['the quick brown fox', ' ', true],
['the quick brown fox', ' ', false],
['the quick brown fox', '', true],
['the quick brown fox', 'number one', false],
['the quick brown fox', '123', false],
// wildcards
['the quick brown fox', 'the.*fox', true],
['the quick brown fox', '^the.*fox$', true],
['the quick brown fox', '^the.*dog$', false],
['the quick brown fox', 'the (quick|slow) (red|green|brown) (dog|cat|fox)', true],
['the quick brown fox', 'the .*(red|green|brown) (dog|cat|fox)', true],
['the quick brown fox', '^the .*(red|green|brown) (dog|cat|fox)', true],
['the quick brown fox', 'the (quick|slow) (red|green|brown) (dog|cat)', false],
['the quick brown fox', '^the (quick|slow) (red|green|brown) (dog|cat)', false],
['the quick brown fox', '^the .*(red|green|brown) (dog|cat)', false],
['the quick brown fox', 'the .*(red|green|brown) (dog|cat)', false],
['the quick brown fox', 'the (slow|lazy) brown (fox|wolf)', false],
['the quick brown fox', 'the.*brown (fox|wolf)', true],
['the quick brown fox', '^t.*(fox|wolf)', true],
['the quick brown fox', '^t.*(fox|wolf)$', true],
['the quick brown fox', '^t.*(fo|wolf)x$', true],
['the quick brown fox', '^t.*(fo|wolf)xx', false],
// line breaks
['the quick\nbrown\nfox', 'the.*fox', false],
['the quick\nbrown\nfox', 'the(.|\n)*fox', true],
['the quick\nbrown\nfox', '^the.*fox$', false],
['the quick\nbrown\nfox', '^the(.|\n)*fox$', true],
['the quick\nbrown\nfox', 'the.*fox$', false],
['the quick\nbrown\nfox', 'the(.|\n)*fox$', true],
['the quick\nbrown\nfox', '^the.*fox$', false],
['the quick\nbrown\nfox', '^the(.|\n)*fox$', true],
['the quick\nbrown\nfox', '^the.*dog$', false],
['the quick\nbrown\nfox', '^the(.|\n)*dog$', false],
['the quick\nbrown\nfox', 'brown fox', false],
['the quick\nbrown\nfox', 'brown.fox', false],
['the quick\nbrown\nfox', 'brown(.|\n)fox', true],
['the quick\nbrown\nfox', 'brown\\nfox', true],
['the quick\nbrown\nfox', 'quick.brown', false],
['the quick\nbrown\nfox', 'quick(.|\n)brown', true],
['the quick\r\nbrown\nfox', 'quick.brown', false],
['the quick\r\nbrown\nfox', 'quick(.|\r\n)brown', true],
['the quick\r\nbrown\nfox', 'quick\\r\\nbrown', true],
['the quick\r\nbrown\nfox', 'quick\\r\\red', false]
];
values.forEach(function (v) {
var query = 'RETURN REGEX_TEST(@what, @re)';
assertEqual(v[2], getQueryResults(query, { what: v[0], re: v[1] })[0], v);
query = 'RETURN NOOPT(REGEX_TEST(@what, @re))';
assertEqual(v[2], getQueryResults(query, { what: v[0], re: v[1] })[0], v);
query = 'RETURN @what =~ @re';
assertEqual(v[2], getQueryResults(query, { what: v[0], re: v[1] })[0], v);
query = 'RETURN @what !~ @re';
assertEqual(!v[2], getQueryResults(query, { what: v[0], re: v[1] })[0], v);
});
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test regex function, cache
// //////////////////////////////////////////////////////////////////////////////
testRegexCache: function () {
var actual = getQueryResults(`FOR i IN 1..100 RETURN REGEX_TEST(CONCAT('test', i), 'test')`);
assertEqual(100, actual.length);
for (var i = 0; i < actual.length; ++i) {
assertTrue(actual[i]);
}
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test REGEX_REPLACE, invalid arguments
// //////////////////////////////////////////////////////////////////////////////
testRegexReplaceInvalid: function () {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN REGEX_REPLACE()');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN REGEX_REPLACE("test")');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN REGEX_TEST("test", "meow", "woof", "foo", "bar")');
assertQueryWarningAndNull(errors.ERROR_QUERY_INVALID_REGEX.code, 'RETURN REGEX_REPLACE("test", "?", "hello")');
assertQueryWarningAndNull(errors.ERROR_QUERY_INVALID_REGEX.code, 'RETURN REGEX_REPLACE("test", "*", "hello")');
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test REGEX_REPLACE
// //////////////////////////////////////////////////////////////////////////////
testRegexReplace: function () {
var values = [
// whole words
[['the quick brown fox', 'the', 'A'], 'A quick brown fox'],
[['the quick brown fox', 'quick', 'slow'], 'the slow brown fox'],
[['the quick brown fox', 'quicK', 'slow'], 'the quick brown fox'],
[['the quick brown fox', 'brown ', 'white'], 'the quick whitefox'],
[['the quick brown fox', 'fox', 'dog'], 'the quick brown dog'],
[['the quick brown fox', 'hasi', 'fasi'], 'the quick brown fox'],
// anchored
[['the quick brown fox', '^the', 'A'], 'A quick brown fox'],
[['the quick brown fox', '^the$', 'A'], 'the quick brown fox'],
[['the quick brown fox', '^the quick brown fo', 'fa'], 'fax'],
// // partials
[['the quick brown fox', 'ö', 'i'], 'the quick brown fox'],
[['the quick brown fox', 'o', 'i'], 'the quick briwn fix'],
[['the quick brown fox', ' ', '-'], 'the-quick-brown-fox'],
[['the quick brown fox', ' ', '-'], 'the quick brown fox'],
[['the quick brown fox', ' ', ''], 'thequickbrownfox'],
[['the quick brown fox', '', 'x'], 'xtxhxex xqxuxixcxkx xbxrxoxwxnx xfxoxxx'],
// // wildcards
[['the quick brown fox', 'the.*fox', 'jumped over'], 'jumped over'],
[['the quick brown fox', '^the.*fox$', 'jumped over'], 'jumped over'],
[['the quick brown fox', '^the.*dog$', 'jumped over'], 'the quick brown fox'],
[['the quick brown fox', 'the (quick|slow) (red|green|brown) (dog|cat|fox)', 'jumped over'], 'jumped over'],
[['the quick brown fox', 'the .*(red|green|brown) (dog|cat|fox)', 'jumped over'], 'jumped over'],
[['the quick brown fox', 'the (slow|lazy) brown (fox|wolf)', 'jumped over'], 'the quick brown fox'],
[['the quick brown fox', 'the (slow|quick) brown (fox|wolf)', 'jumped over'], 'jumped over'],
// // line breaks
[['the quick\nbrown\nfox', 'the(.|\n)*fox', 'jumped over'], 'jumped over'],
[['the quick\nbrown\nfox', '^the.*fox$', 'jumped over'], 'the quick\nbrown\nfox']
];
values.forEach(function (v) {
var query;
query = 'RETURN REGEX_REPLACE(@what, @re, @with)';
assertEqual(v[1], getQueryResults(query, { what: v[0][0], re: v[0][1], with: v[0][2] })[0], v);
query = 'RETURN NOOPT(REGEX_REPLACE(@what, @re, @with))';
assertEqual(v[1], getQueryResults(query, { what: v[0][0], re: v[0][1], with: v[0][2] })[0], v);
});
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test like function, invalid arguments
// //////////////////////////////////////////////////////////////////////////////
testLikeInvalid: function () {
assertQueryError(errors.ERROR_QUERY_PARSE.code, 'RETURN LIKE');
assertQueryError(errors.ERROR_QUERY_PARSE.code, 'RETURN "test" LIKE');
assertQueryError(errors.ERROR_QUERY_PARSE.code, 'RETURN LIKE "test"');
assertQueryError(errors.ERROR_QUERY_PARSE.code, 'RETURN "test" LIKE "meow", "foo", "bar")');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN LIKE()');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN LIKE("test")');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN LIKE("test", "meow", "foo", "bar")');
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test like function
// //////////////////////////////////////////////////////////////////////////////
testLike: function () {
// containment
assertEqual([ false ], getQueryResults('RETURN "this is a test string" LIKE "test"'));
assertEqual([ false ], getQueryResults('RETURN "this is a test string" LIKE "%test"'));
assertEqual([ false ], getQueryResults('RETURN "this is a test string" LIKE "test%"'));
assertEqual([ true ], getQueryResults('RETURN "this is a test string" LIKE "%test%"'));
assertEqual([ true ], getQueryResults('RETURN "this is a test string" LIKE "this%test%"'));
assertEqual([ true ], getQueryResults('RETURN "this is a test string" LIKE "this%is%test%"'));
assertEqual([ true ], getQueryResults('RETURN "this is a test string" LIKE "this%g"'));
assertEqual([ false ], getQueryResults('RETURN "this is a test string" LIKE "this%n"'));
assertEqual([ false ], getQueryResults('RETURN "this is a test string" LIKE "This%n"'));
assertEqual([ false ], getQueryResults('RETURN "this is a test string" LIKE "his%"'));
assertEqual([ true ], getQueryResults('RETURN "this is a test string" LIKE "%g"'));
assertEqual([ false ], getQueryResults('RETURN "this is a test string" LIKE "%G"'));
assertEqual([ false ], getQueryResults('RETURN "this is a test string" LIKE "this%test%is%"'));
assertEqual([ false ], getQueryResults('RETURN LIKE("this is a test string", "test")'));
assertEqual([ false ], getQueryResults('RETURN LIKE("this is a test string", "%test")'));
assertEqual([ false ], getQueryResults('RETURN LIKE("this is a test string", "test%")'));
assertEqual([ true ], getQueryResults('RETURN LIKE("this is a test string", "%test%")'));
assertEqual([ true ], getQueryResults('RETURN LIKE("this is a test string", "this%test%")'));
assertEqual([ true ], getQueryResults('RETURN LIKE("this is a test string", "this%is%test%")'));
assertEqual([ true ], getQueryResults('RETURN LIKE("this is a test string", "this%g")'));
assertEqual([ false ], getQueryResults('RETURN LIKE("this is a test string", "this%n")'));
assertEqual([ false ], getQueryResults('RETURN LIKE("this is a test string", "This%n")'));
assertEqual([ false ], getQueryResults('RETURN LIKE("this is a test string", "his%")'));
assertEqual([ true ], getQueryResults('RETURN LIKE("this is a test string", "%g")'));
assertEqual([ false ], getQueryResults('RETURN LIKE("this is a test string", "%G")'));
assertEqual([ false ], getQueryResults('RETURN LIKE("this is a test string", "this%test%is%")'));
// special characters
assertEqual([ true ], getQueryResults('RETURN "%" LIKE "\\%"'));
assertEqual([ true ], getQueryResults('RETURN "a%c" LIKE "a%c"'));
assertEqual([ false ], getQueryResults('RETURN "a%c" LIKE "ac"'));
assertEqual([ false ], getQueryResults('RETURN "a%c" LIKE "a\\\\%"'));
assertEqual([ false ], getQueryResults('RETURN "a%c" LIKE "\\\\%a%"'));
assertEqual([ false ], getQueryResults('RETURN "a%c" LIKE "\\\\%\\\\%"'));
assertEqual([ true ], getQueryResults('RETURN "%%" LIKE "\\\\%\\\\%"'));
assertEqual([ true ], getQueryResults('RETURN "_" LIKE "\\\\_"'));
assertEqual([ true ], getQueryResults('RETURN "_" LIKE "\\\\_%"'));
assertEqual([ true ], getQueryResults('RETURN "abcd" LIKE "_bcd"'));
assertEqual([ true ], getQueryResults('RETURN "abcde" LIKE "_bcd%"'));
assertEqual([ false ], getQueryResults('RETURN "abcde" LIKE "\\\\_bcd%"'));
assertEqual([ true ], getQueryResults('RETURN "\\\\abc" LIKE "\\\\\\\\%"'));
assertEqual([ true ], getQueryResults('RETURN "\\abc" LIKE "\\a%"'));
assertEqual([ true ], getQueryResults('RETURN "[ ] ( ) % * . + -" LIKE "[%"'));
assertEqual([ true ], getQueryResults('RETURN "[ ] ( ) % * . + -" LIKE "[ ] ( ) \\% * . + -"'));
assertEqual([ true ], getQueryResults('RETURN "[ ] ( ) % * . + -" LIKE "%. +%"'));
assertEqual([ true ], getQueryResults('RETURN "abc^def$g" LIKE "abc^def$g"'));
assertEqual([ true ], getQueryResults('RETURN "abc^def$g" LIKE "%^%$g"'));
assertEqual([ true ], getQueryResults('RETURN "der\*hund" LIKE "%*%"'));
assertEqual([ true ], getQueryResults('RETURN "der*hund" LIKE "%*%"'));
assertEqual([ false ], getQueryResults('RETURN "der*hund" LIKE "*"'));
assertEqual([ true ], getQueryResults('RETURN LIKE("%", "\\%")'));
assertEqual([ true ], getQueryResults('RETURN LIKE("a%c", "a%c")'));
assertEqual([ false ], getQueryResults('RETURN LIKE("a%c", "ac")'));
assertEqual([ false ], getQueryResults('RETURN LIKE("a%c", "a\\\\%")'));
assertEqual([ false ], getQueryResults('RETURN LIKE("a%c", "\\\\%a%")'));
assertEqual([ false ], getQueryResults('RETURN LIKE("a%c", "\\\\%\\\\%")'));
assertEqual([ true ], getQueryResults('RETURN LIKE("%%", "\\\\%\\\\%")'));
assertEqual([ true ], getQueryResults('RETURN LIKE("_", "\\\\_")'));
assertEqual([ true ], getQueryResults('RETURN LIKE("_", "\\\\_%")'));
assertEqual([ true ], getQueryResults('RETURN LIKE("abcd", "_bcd")'));
assertEqual([ true ], getQueryResults('RETURN LIKE("abcde", "_bcd%")'));
assertEqual([ false ], getQueryResults('RETURN LIKE("abcde", "\\\\_bcd%")'));
assertEqual([ true ], getQueryResults('RETURN LIKE("\\\\abc", "\\\\\\\\%")'));
assertEqual([ true ], getQueryResults('RETURN LIKE("\\abc", "\\a%")'));
assertEqual([ true ], getQueryResults('RETURN LIKE("[ ] ( ) % * . + -", "[%")'));
assertEqual([ true ], getQueryResults('RETURN LIKE("[ ] ( ) % * . + -", "[ ] ( ) \\% * . + -")'));
assertEqual([ true ], getQueryResults('RETURN LIKE("[ ] ( ) % * . + -", "%. +%")'));
assertEqual([ true ], getQueryResults('RETURN LIKE("abc^def$g", "abc^def$g")'));
assertEqual([ true ], getQueryResults('RETURN LIKE("abc^def$g", "%^%$g")'));
// case-sensivity
assertEqual([ false ], getQueryResults('RETURN "ABCD" LIKE "abcd"'));
assertEqual([ false ], getQueryResults('RETURN "abcd" LIKE "ABCD"'));
assertEqual([ false ], getQueryResults('RETURN "MÖterTräNenMÜtterSöhne" LIKE "MÖTERTRÄNENMÜTTERSÖHNE"'));
assertEqual([ false ], getQueryResults('RETURN LIKE("ABCD", "abcd", false)'));
assertEqual([ true ], getQueryResults('RETURN LIKE("ABCD", "abcd", true)'));
assertEqual([ false ], getQueryResults('RETURN LIKE("abcd", "ABCD", false)'));
assertEqual([ true ], getQueryResults('RETURN LIKE("abcd", "ABCD", true)'));
assertEqual([ true ], getQueryResults('RETURN LIKE("MÖterTräNenMÜtterSöhne", "MöterTräNenMütterSöhne", true)'));
assertEqual([ true ], getQueryResults('RETURN LIKE("MÖterTräNenMÜtterSöhne", "mötertränenmüttersöhne", true)'));
assertEqual([ true ], getQueryResults('RETURN LIKE("MÖterTräNenMÜtterSöhne", "MÖTERTRÄNENMÜTTERSÖHNE", true)'));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test like with special characters
// //////////////////////////////////////////////////////////////////////////////
testLikeSpecialChars: function () {
var data = [
'the quick\nbrown fox jumped over\r\nthe lazy dog',
`'the "\\quick\\\n "brown\\\rfox' jumped`,
`'the fox'' jumped \\over the \newline \roof'`
];
data.forEach(function (value) {
var actual = getQueryResults('RETURN LIKE(' + JSON.stringify(value) + `, 'foobar')`);
assertEqual([ false ], actual);
actual = getQueryResults('RETURN LIKE(' + JSON.stringify(value) + ', ' + JSON.stringify(value) + ')');
assertEqual([ true ], actual);
actual = getQueryResults('RETURN ' + JSON.stringify(value) + ' LIKE ' + JSON.stringify(value));
assertEqual([ true ], actual);
});
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test like function, cache
// //////////////////////////////////////////////////////////////////////////////
testLikeCache: function () {
var actual = getQueryResults(`FOR i IN 1..100 RETURN LIKE(CONCAT('test', i), 'test%')`);
assertEqual(100, actual.length);
for (var i = 0; i < actual.length; ++i) {
assertTrue(actual[i]);
}
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test like function, invalid arguments
// //////////////////////////////////////////////////////////////////////////////
testLikeInvalidCxx: function () {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN NOOPT(LIKE())');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN NOOPT(LIKE("test"))');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN NOOPT(LIKE("test", "meow", "foo", "bar"))');
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test like function
// //////////////////////////////////////////////////////////////////////////////
testLikeCxx: function () {
assertEqual([ false ], getQueryResults('RETURN NOOPT(LIKE("this is a test string", "test"))'));
assertEqual([ false ], getQueryResults('RETURN NOOPT(LIKE("this is a test string", "%test"))'));
assertEqual([ false ], getQueryResults('RETURN NOOPT(LIKE("this is a test string", "test%"))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("this is a test string", "%test%"))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("this is a test string", "this%test%"))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("this is a test string", "this%is%test%"))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("this is a test string", "this%g"))'));
assertEqual([ false ], getQueryResults('RETURN NOOPT(LIKE("this is a test string", "this%n"))'));
assertEqual([ false ], getQueryResults('RETURN NOOPT(LIKE("this is a test string", "This%n"))'));
assertEqual([ false ], getQueryResults('RETURN NOOPT(LIKE("this is a test string", "his%"))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("this is a test string", "%g"))'));
assertEqual([ false ], getQueryResults('RETURN NOOPT(LIKE("this is a test string", "%G"))'));
assertEqual([ false ], getQueryResults('RETURN NOOPT(LIKE("this is a test string", "this%test%is%"))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("%", "\\%"))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("a%c", "a%c"))'));
assertEqual([ false ], getQueryResults('RETURN NOOPT(LIKE("a%c", "ac"))'));
assertEqual([ false ], getQueryResults('RETURN NOOPT(LIKE("a%c", "a\\\\%"))'));
assertEqual([ false ], getQueryResults('RETURN NOOPT(LIKE("a%c", "\\\\%a%"))'));
assertEqual([ false ], getQueryResults('RETURN NOOPT(LIKE("a%c", "\\\\%\\\\%"))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("%%", "\\\\%\\\\%"))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("_", "\\\\_"))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("_", "\\\\_%"))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("abcd", "_bcd"))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("abcde", "_bcd%"))'));
assertEqual([ false ], getQueryResults('RETURN NOOPT(LIKE("abcde", "\\\\_bcd%"))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("\\\\abc", "\\\\\\\\%"))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("\\abc", "\\a%"))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("[ ] ( ) % * . + -", "[%"))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("[ ] ( ) % * . + -", "[ ] ( ) \\% * . + -"))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("[ ] ( ) % * . + -", "%. +%"))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("abc^def$g", "abc^def$g"))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("abc^def$g", "%^%$g"))'));
assertEqual([ false ], getQueryResults('RETURN NOOPT(LIKE("ABCD", "abcd", false))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("ABCD", "abcd", true))'));
assertEqual([ false ], getQueryResults('RETURN NOOPT(LIKE("abcd", "ABCD", false))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("abcd", "ABCD", true))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("MÖterTräNenMÜtterSöhne", "MöterTräNenMütterSöhne", true))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("MÖterTräNenMÜtterSöhne", "mötertränenmüttersöhne", true))'));
assertEqual([ true ], getQueryResults('RETURN NOOPT(LIKE("MÖterTräNenMÜtterSöhne", "MÖTERTRÄNENMÜTTERSÖHNE", true))'));
assertEqual([ [ true, false, true, false ] ], getQueryResults('RETURN [ NOOPT(LIKE("Möter", "m_ter", true)), NOOPT(LIKE("Möter", "m_ter", false)), NOOPT(LIKE("Möter", "m_ter", true)), NOOPT(LIKE("Möter", "m_ter", false)) ]'));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test like with special characters
// //////////////////////////////////////////////////////////////////////////////
testLikeSpecialCharsCxx: function () {
var data = [
'the quick\nbrown fox jumped over\r\nthe lazy dog',
`'the "\\quick\\\n "brown\\\rfox' jumped`,
`'the fox'' jumped \\over the \newline \roof'`
];
data.forEach(function (value) {
var actual = getQueryResults('RETURN NOOPT(LIKE(' + JSON.stringify(value) + `, 'foobar'))`);
assertEqual([ false ], actual);
actual = getQueryResults('RETURN NOOPT(LIKE(' + JSON.stringify(value) + ', ' + JSON.stringify(value) + '))');
assertEqual([ true ], actual);
});
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test first require function / expected datatype & arg. mismatch
// //////////////////////////////////////////////////////////////////////////////
testContainsFirst: function () {
var buildQuery = function (nr, input) {
switch (nr) {
case 0:
return `RETURN CONTAINS(${input})`;
case 1:
return `RETURN NOOPT(CONTAINS(${input}))`;
default:
assertTrue(false, 'Undefined state');
}
};
for (var i = 0; i < 2; ++i) {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, buildQuery(i, '"test"'));
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, buildQuery(i, '"test", "test", "test", "test"'));
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, buildQuery(i, ''));
assertEqual([ -1 ], getQueryResults(buildQuery(i, '"test", "test2", "test3"')));
assertEqual([ false ], getQueryResults(buildQuery(i, 'null, null')));
assertEqual([ true ], getQueryResults(buildQuery(i, '4, 4')));
assertEqual([ true ], getQueryResults(buildQuery(i, '{}, {}')));
assertEqual([ true ], getQueryResults(buildQuery(i, '{a:1,b:2}, {a:1,b:2}')));
assertEqual([ true ], getQueryResults(buildQuery(i, '[], []')));
assertEqual([ true ], getQueryResults(buildQuery(i, '[1,2,3], [1,2,3]')));
assertEqual([ true ], getQueryResults(buildQuery(i, '[1,2], [1,2]')));
assertEqual([ true ], getQueryResults(buildQuery(i, '[1,2,3], 2')));
assertEqual([ false ], getQueryResults(buildQuery(i, 'null, "yes"')));
assertEqual([ false ], getQueryResults(buildQuery(i, '3, null')));
}
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test contains true1
// //////////////////////////////////////////////////////////////////////////////
testContainsTrue1: function () {
var expected = [true];
var actual = getQueryResults('RETURN CONTAINS("test2", "test")');
assertEqual(expected, actual);
actual = getQueryResults('RETURN NOOPT(CONTAINS("test2", "test"))');
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test contains true2
// //////////////////////////////////////////////////////////////////////////////
testContainsTrue2: function () {
var expected = [true];
var actual = getQueryResults('RETURN CONTAINS("xxasdxx", "asd")');
assertEqual(expected, actual);
actual = getQueryResults('RETURN NOOPT(CONTAINS("xxasdxx", "asd"))');
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test contains false1
// //////////////////////////////////////////////////////////////////////////////
testContainsFalse1: function () {
var expected = [false];
var actual = getQueryResults('RETURN CONTAINS("test", "test2")');
assertEqual(expected, actual);
actual = getQueryResults('RETURN NOOPT(CONTAINS("test", "test2"))');
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test contains false2
// //////////////////////////////////////////////////////////////////////////////
testContainsFalse2: function () {
var expected = [false];
var actual = getQueryResults('RETURN CONTAINS("test123", "")');
assertEqual(expected, actual);
actual = getQueryResults('RETURN NOOPT(CONTAINS("test123", ""))');
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test contanis false3
// //////////////////////////////////////////////////////////////////////////////
testContainsFalse3: function () {
var expected = [false];
var actual = getQueryResults('RETURN CONTAINS("", "test123")');
assertEqual(expected, actual);
actual = getQueryResults('RETURN NOOPT(CONTAINS("", "test123"))');
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test contains indexed
// //////////////////////////////////////////////////////////////////////////////
testContainsIndexed: function () {
var buildQuery = function (nr, input) {
switch (nr) {
case 0:
return `RETURN CONTAINS(${input})`;
case 1:
return `RETURN NOOPT(CONTAINS(${input}))`;
default:
assertTrue(false, 'Undefined state');
}
};
for (var i = 0; i < 2; ++i) {
assertEqual([ 0 ], getQueryResults(buildQuery(i, '"test2", "test", true')));
assertEqual([ true ], getQueryResults(buildQuery(i, '"test2", "test", false')));
assertEqual([ 1 ], getQueryResults(buildQuery(i, '"test2", "est", true')));
assertEqual([ true ], getQueryResults(buildQuery(i, '"test2", "est", false')));
assertEqual([ -1 ], getQueryResults(buildQuery(i, '"this is a long test", "this is a test", true')));
assertEqual([ false ], getQueryResults(buildQuery(i, '"this is a long test", "this is a test", false')));
assertEqual([ 18 ], getQueryResults(buildQuery(i, '"this is a test of this test", "this test", true')));
assertEqual([ true ], getQueryResults(buildQuery(i, '"this is a test of this test", "this test", false')));
assertEqual([ -1 ], getQueryResults(buildQuery(i, '"this is a test of this test", "This", true')));
assertEqual([ false ], getQueryResults(buildQuery(i, '"this is a test of this test", "This", false')));
}
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test contains with special characters
// //////////////////////////////////////////////////////////////////////////////
testContainsSpecialChars: function () {
var data = [
'the quick\nbrown fox jumped over\r\nthe lazy dog',
`'the "\\quick\\\n "brown\\\rfox' jumped`,
`'the fox'' jumped \\over the \newline \roof'`
];
data.forEach(function (value) {
var actual = getQueryResults(`RETURN CONTAINS(` + JSON.stringify(value) + `, 'foobar', false)`);
assertEqual([ false ], actual);
actual = getQueryResults(`RETURN CONTAINS(` + JSON.stringify(value) + ', ' + JSON.stringify(value) + ', false)');
assertEqual([ true ], actual);
actual = getQueryResults(`RETURN NOOPT(CONTAINS(` + JSON.stringify(value) + `, 'foobar', false))`);
assertEqual([ false ], actual);
actual = getQueryResults(`RETURN NOOPT(CONTAINS(` + JSON.stringify(value) + ', ' + JSON.stringify(value) + ', false))');
assertEqual([ true ], actual);
});
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test left function
// //////////////////////////////////////////////////////////////////////////////
testLeft: function () {
assertEqual(['cp', 'f', '', 'foo', 'foo', '', '', '', 'mö', 'mötö', '😰2🤓'],
getQueryResults(`FOR t IN [ [ 'cpp', 2 ], [ 'foo', 1 ], [ 'foo', 0 ], [ 'foo', 4 ], [ 'foo', 999999999 ], [ '', 0 ], [ '', 1 ], [ '', 2 ], [ 'mötör', 2 ], [ 'mötör', 4 ], ['😰2🤓4🤡6😎8', 3] ] RETURN NOOPT(LEFT(t[0], t[1]))`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test left function
// //////////////////////////////////////////////////////////////////////////////
testLeftInvalid: function () {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN NOOPT(LEFT())');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, `RETURN NOOPT(LEFT('foo'))`);
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, `RETURN NOOPT(LEFT('foo', 2, 3))`);
assertEqual([ '' ], getQueryResults(`RETURN NOOPT(LEFT(null, 1))`));
assertEqual([ '' ], getQueryResults(`RETURN NOOPT(LEFT(null, 2))`));
assertEqual([ 'tr' ], getQueryResults(`RETURN NOOPT(LEFT(true, 2))`));
assertEqual([ '4' ], getQueryResults(`RETURN NOOPT(LEFT(4, 2))`));
assertEqual([ '[]' ], getQueryResults(`RETURN NOOPT(LEFT([ ], 2))`));
assertEqual([ '[' ], getQueryResults(`RETURN NOOPT(LEFT([ ], 1))`));
assertEqual([ '{}' ], getQueryResults(`RETURN NOOPT(LEFT({ }, 2))`));
assertEqual([ '{' ], getQueryResults(`RETURN NOOPT(LEFT({ }, 1))`));
assertEqual([ '' ], getQueryResults(`RETURN NOOPT(LEFT('foo', null))`));
assertEqual([ 'f' ], getQueryResults(`RETURN NOOPT(LEFT('foo', true))`));
assertEqual([ '' ], getQueryResults(`RETURN NOOPT(LEFT('foo', 'bar'))`));
assertEqual([ '' ], getQueryResults(`RETURN NOOPT(LEFT('foo', [ ]))`));
assertEqual([ '' ], getQueryResults(`RETURN NOOPT(LEFT('foo', { }))`));
assertEqual([ '' ], getQueryResults(`RETURN NOOPT(LEFT('foo', -1))`));
assertEqual([ '' ], getQueryResults(`RETURN NOOPT(LEFT('foo', -1.5))`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test right function
// //////////////////////////////////////////////////////////////////////////////
testRight: function () {
assertEqual(['pc', 'o', '', 'foo', 'foo', '', '', '', 'ör', 'ötör', '6😎8'],
getQueryResults(`FOR t IN [ [ 'ppc', 2 ], [ 'foo', 1 ], [ 'foo', 0 ], [ 'foo', 4 ], [ 'foo', 999999999 ], [ '', 0 ], [ '', 1 ], [ '', 2 ], [ 'mötör', 2 ], [ 'mötör', 4 ], ['😰2🤓4🤡6😎8', 3] ] RETURN NOOPT(RIGHT(t[0], t[1]))`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test left function
// //////////////////////////////////////////////////////////////////////////////
testRightInvalid: function () {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN NOOPT(RIGHT())');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, `RETURN NOOPT(RIGHT('foo'))`);
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, `RETURN NOOPT(RIGHT('foo', 2, 3))`);
assertEqual([ '' ], getQueryResults(`RETURN NOOPT(RIGHT(null, 1))`));
assertEqual([ '' ], getQueryResults(`RETURN NOOPT(RIGHT(null, 2))`));
assertEqual([ 'ue' ], getQueryResults(`RETURN NOOPT(RIGHT(true, 2))`));
assertEqual([ '4' ], getQueryResults(`RETURN NOOPT(RIGHT(4, 2))`));
assertEqual([ '[]' ], getQueryResults(`RETURN NOOPT(RIGHT([ ], 2))`));
assertEqual([ ']' ], getQueryResults(`RETURN NOOPT(RIGHT([ ], 1))`));
assertEqual([ '{}' ], getQueryResults(`RETURN NOOPT(RIGHT({ }, 2))`));
assertEqual([ '}' ], getQueryResults(`RETURN NOOPT(RIGHT({ }, 1))`));
assertEqual([ '' ], getQueryResults(`RETURN NOOPT(RIGHT('foo', null))`));
assertEqual([ 'o' ], getQueryResults(`RETURN NOOPT(RIGHT('foo', true))`));
assertEqual([ '' ], getQueryResults(`RETURN NOOPT(RIGHT('foo', 'bar'))`));
assertEqual([ '' ], getQueryResults(`RETURN NOOPT(RIGHT('foo', [ ]))`));
assertEqual([ '' ], getQueryResults(`RETURN NOOPT(RIGHT('foo', { }))`));
assertEqual([ '' ], getQueryResults(`RETURN NOOPT(RIGHT('foo', -1))`));
assertEqual([ '' ], getQueryResults(`RETURN NOOPT(RIGHT('foo', -1.5))`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test substitute function
// //////////////////////////////////////////////////////////////////////////////
testSubstitute: function () {
var values = [
[ 'the quick brown dog jumped over the lazy foxx', 'the quick brown foxx jumped over the lazy dog', [ 'foxx', 'dog' ], [ 'dog', 'foxx' ] ],
[ 'the quick brown foxx jumped over the lazy foxx', 'the quick brown foxx jumped over the lazy dog', [ 'foxx', 'dog' ], [ 'foxx', 'foxx' ] ],
[ 'the quick brown dog jumped over the lazy foxx', 'the quick brown foxx jumped over the lazy dog', { 'foxx': 'dog', 'dog': 'foxx' } ],
[ 'the quick brown foxx jumped over the lazy foxx', 'the quick brown foxx jumped over the lazy dog', { 'foxx': 'foxx', 'dog': 'foxx' } ],
[ 'the unspecified unspecified foxx jumped over the unspecified dog', 'the quick brown foxx jumped over the lazy dog', [ 'quick', 'brown', 'lazy' ], 'unspecified' ],
[ 'the slow yellow foxx jumped over the eager dog', 'the quick brown foxx jumped over the lazy dog', [ 'quick', 'brown', 'lazy' ], [ 'slow', 'yellow', 'eager' ] ],
[ 'the empty foxx jumped over the dog', 'the quick brown foxx jumped over the lazy dog', [ 'quick', 'brown', 'lazy' ], [ 'empty' ] ],
[ 'the empty empty foxx jumped over the empty dog', 'the quick brown foxx jumped over the lazy dog', [ 'quick', 'brown', 'lazy' ], 'empty' ],
[ 'the quick brown foxx jumped over the empty. dog', 'the quick brown foxx jumped over the lazy dog', [ 'dog', 'lazy' ], 'empty.', 1 ],
[ 'the.quick.brown.foxx.jumped.over.the.lazy\tdog', 'the\r\nquick\r\nbrown\r\nfoxx\r\njumped\r\nover\r\nthe\r\nlazy\tdog', '\r\n', '.' ],
[ 'the.quick.brown.foxx.jumped\r\nover\r\nthe\r\nlazy dog', 'the\r\nquick\r\nbrown\r\nfoxx\r\njumped\r\nover\r\nthe\r\nlazy dog', '\r\n', '.', 4 ],
[ 'A capital foxx escaped!', 'the quick brown foxx jumped over the lazy dog', [ 'the quick brown', 'jumped over the lazy dog' ], [ 'A capital', 'escaped!' ] ],
[ 'a quick brown foxx jumped over a lazy dog', 'the quick brown foxx jumped over the lazy dog', 'the', 'a' ],
[ 'a quick brown foxx jumped over the lazy dog', 'the quick brown foxx jumped over the lazy dog', 'the', 'a', 1 ],
[ 'the quick brown foxx jumped over the lazy dog', 'the quick brown foxx jumped over the lazy dog', 'the', 'a', 0 ],
[ 'a quick brown foxx jumped over a lazy dog', 'the quick brown foxx jumped over the lazy dog', [ 'the' ], [ 'a' ] ],
[ 'a quick brown foxx jumped over the lazy dog', 'the quick brown foxx jumped over the lazy dog', [ 'the' ], [ 'a' ], 1 ],
[ 'the quick brown foxx jumped over the lazy dog', 'the quick brown foxx jumped over the lazy dog', 'thisIsNotThere', 'a'],
[ 'the quick brown foxx jumped over the lazy dog', 'the quick brown foxx jumped over the lazy dog', {'thisIsNotThere': 'a'}],
[ 'the quick brown foxx jumped over the lazy dog', 'the quick brown foxx jumped over the lazy dog', ['thisIsNotThere', 'thisIsAlsoNotThere'], ['a', 'b'], 0 ],
[ 'mötör quick brown mötör jumped over the lazy dog', 'the quick brown foxx jumped over the lazy dog', [ 'over', 'the', 'foxx' ], 'mötör', 2 ],
[ 'apfela', 'rabarbara', ['barbara', 'rabarbar'], ['petra', 'apfel']],
[ 'rapetra', 'rabarbara', ['barbara', 'bar'], ['petra', 'foo']],
[ 'AbCdEF', 'aBcDef', { a: 'A', B: 'b', c: 'C', D: 'd', e: 'E', f: 'F' } ],
[ 'AbcDef', 'aBcDef', { a: 'A', B: 'b', c: 'C', D: 'd', e: 'E', f: 'F' }, 2 ],
[ 'aBcDef', 'aBcDef', { a: 'A', B: 'b', c: 'C', D: 'd', e: 'E', f: 'F' }, 0 ],
[ 'xxxxyyyyzzz', 'aaaabbbbccc', [ 'a', 'b', 'c' ], [ 'x', 'y', 'z' ] ],
[ 'xxaabbbbccc', 'aaaabbbbccc', [ 'a', 'b', 'c' ], [ 'x', 'y', 'z' ], 2 ],
[ 'xxxxyybbccc', 'aaaabbbbccc', [ 'a', 'b', 'c' ], [ 'x', 'y', 'z' ], 6 ],
[ 'aaaayyybccc', 'aaaabbbbccc', [ 'A', 'b', 'c' ], [ 'x', 'y', 'z' ], 3 ],
[ 'the quick foxx', 'the quick brown foxx', 'brown' ],
[ 'the quick brown foxx', 'the quick brown foxx', [ ] ],
[ 'the quick foxx', 'the quick brown foxx', [ 'brown' ], [ ] ]
];
values.forEach(function (value) {
var expected = value[0];
var args = [ ];
var i;
var n = value.length;
for (i = 1; i < n; ++i) {
args.push(JSON.stringify(value[i]));
}
var nuResults = getQueryResults('RETURN SUBSTITUTE(' + args.join(', ') + ')');
assertEqual([ expected ], nuResults, value);
});
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test substitute function
// //////////////////////////////////////////////////////////////////////////////
testSubstituteInvalid: function () {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN SUBSTITUTE()');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, `RETURN SUBSTITUTE('foo', 'bar', 'baz', 2, 2)`);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test split function
// //////////////////////////////////////////////////////////////////////////////
testSplit: function () {
var values = [
[ [ '' ], '', '\n' ],
[ [ '' ], '', 'foobar' ],
[ [ ], '', '' ],
[ [ ], '', [ '' ] ],
[ [ '' ], '', [ 'a', 'b', 'c' ] ],
[ [ 'this\nis\na\nt', 'st' ], 'this\nis\na\ntest', 'e' ],
[ [ 'th', 's\n', 's\na\nt', 'st' ], 'this\nis\na\ntest', [ 'e', 'i' ] ],
[ [ 'th', '\n', '\na\ntest' ], 'this\nis\na\ntest', 'is' ],
[ [ 'this', 'is', 'a', 'test' ], 'this\nis\na\ntest', '\n' ],
[ [ 'this', 'is', 'a', 'test' ], 'this\nis\na\ntest', [ '\n' ] ],
[ [ 'this', 'is', 'a', 'test' ], 'this\nis\na\ntest', [ '\n', '\r' ] ],
[ [ 'this', 'is', 'a', 'test' ], 'this\ris\ra\rtest', [ '\n', '\r' ] ],
[ [ 'this', 'is', 'a', 'test' ], 'this\tis\ta\ttest', [ '\t' ] ],
[ [ 'this', 'is', 'a', 'test' ], 'this\tis\ta\ttest', '\t' ],
[ [ 'this', 'is', 'a', 'test' ], 'this\nis\ra\ttest', [ '\n', '\r', '\t' ] ],
[ [ 'this', 'is', 'a', 'test' ], 'this is a test', [ ' ' ] ],
[ [ 'this', 'is', 'a', 'test' ], 'this is a test', ' ' ],
[ [ 'this', 'is', 'a', 'test' ], 'this/SEP/is/SEP/a/SEP/test', '/SEP/' ],
[ [ 'this', 'is', 'a', 'test' ], 'this/SEP/is/SEP/a/SEP/test', [ '/SEP/' ] ],
[ [ 'this', 'is', 'a', 'test' ], 'this/SEP1/is/SEP2/a/SEP3/test', [ '/SEP1/', '/SEP2/', '/SEP3/' ] ],
[ [ 'the', 'quick', 'brown', 'foxx' ], 'the quick brown foxx', ' ' ],
[ [ 'the quick ', ' foxx' ], 'the quick brown foxx', 'brown' ],
[ [ 't', 'h', 'e', ' ', 'q', 'u', 'i', 'c', 'k', ' ', 'b', 'r', 'o', 'w', 'n', ' ', 'f', 'o', 'x', 'x' ], 'the quick brown foxx', '' ],
[ [ 't', 'h', 'e', ' ', 'q', 'u', 'i', 'c', 'k', ' ', 'b', 'r', 'o', 'w', 'n', ' ', 'f', 'o', 'x', 'x' ], 'the quick brown foxx', ['', 'ab'] ],
[ [ 'the quick', 'brown foxx' ], 'the quick()brown foxx', '()' ],
[ [ 'the quick brown foxx' ], 'the quick brown foxx', ' {2}' ],
[ [ 'the quick brown foxx' ], 'the quick brown foxx', '?' ],
[ [ 'the quick brown foxx' ], 'the quick brown foxx', '+' ],
[ [ 'the quick brown foxx' ], 'the quick brown foxx', '*' ],
[ [ 'the quick brown foxx' ], 'the quick brown foxx', '^' ],
[ [ 'the quick brown foxx' ], 'the quick brown foxx', '$' ],
[ [ 'the quick brown foxx' ], 'the quick brown foxx', '.' ],
[ [ 'the quick7brown foxx' ], 'the quick7brown foxx', '\\d' ],
[ [ 'the quick brown foxx' ], "the quick brown foxx", ["[a-f]"] ],
[ [ 'the quick brown foxx' ], 'the quick brown foxx', 'u|f' ]
];
values.forEach(function (value) {
var expected = value[0], text = value[1], separator = value[2];
var res = getQueryResults('RETURN SPLIT(' + JSON.stringify(text) + ', ' + JSON.stringify(separator) + ')');
assertEqual([ expected ], res, JSON.stringify(value));
});
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test split function
// //////////////////////////////////////////////////////////////////////////////
testSplitMaxLength: function () {
var values = [
[ null, 'foobar', '', -1 ],
[ null, 'foobar', '', -10 ],
[ [ ], 'foobar', '', 0 ],
[ [ 'f' ], 'foobar', '', 1 ],
[ [ ], 'this\nis\na\ntest', '\n', 0 ],
[ [ 'this' ], 'this\nis\na\ntest', '\n', 1 ],
[ [ 'this', 'is', 'a' ], 'this\nis\na\ntest', '\n', 3 ],
[ [ 'this', 'is', 'a', 'test' ], 'this\nis\na\ntest', '\n', 5 ],
[ [ 'this', 'is', 'a', 'test' ], 'this\nis\na\ntest', '\n', 500 ],
[ [ 't', 'h', 'i', 's', ' ' ], 'this is a test', '', 5 ]
];
values.forEach(function (value) {
var expected = value[0], text = value[1], separator = value[2], limit = value[3];
var res = getQueryResults('RETURN SPLIT(' + JSON.stringify(text) + ', ' + JSON.stringify(separator) + ', ' + JSON.stringify(limit) + ')');
assertEqual([ expected ], res, JSON.stringify(value));
});
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test split function
// //////////////////////////////////////////////////////////////////////////////
testSplitEmpty: function () {
assertEqual([ [ 'the foxx' ] ], getQueryResults(`RETURN SPLIT('the foxx')`));
assertEqual([ [ '' ] ], getQueryResults(`RETURN SPLIT('')`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test split function
// //////////////////////////////////////////////////////////////////////////////
testSplitInvalid: function () {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN SPLIT()');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, `RETURN SPLIT('foo', '', 10, '')`);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test trim function
// //////////////////////////////////////////////////////////////////////////////
testTrim: function () {
assertEqual([ 'foo',
'foo ',
' foo',
'',
'',
'',
'abc',
'abc\n\r\t',
'\t\r\nabc',
'a\rb\nc',
'a\rb\nc ',
'\ta\rb\nc' ],
getQueryResults(`FOR t IN [
[ ' foo ', 0 ],
[ ' foo ', 1 ],
[ ' foo ', 2 ],
[ '', 0 ],
[ '', 1 ],
[ '', 2 ],
[ '\t\r\nabc\n\r\t', 0 ],
[ '\t\r\nabc\n\r\t', 1 ],
[ '\t\r\nabc\t\r\n', 2 ],
[ '\ta\rb\nc ', 0 ],
[ '\ta\rb\nc ', 1 ],
[ '\ta\rb\nc ', 2 ]
] RETURN NOOPT((TRIM(t[0], t[1]) ))`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test trim function
// //////////////////////////////////////////////////////////////////////////////
testTrimSpecial: function () {
assertEqual([ 'foo',
' foo ',
'',
'abc',
'\t\r\nabc\n\r\t',
'\r\nabc\t\r',
'a\rb\n',
'\rb\n',
'\ta\rb'
],
getQueryResults(`FOR t IN [
[ ' foo ', '\r\n\t ' ],
[ ' foo ', '\r\n\t' ],
[ '', '\r\n\t' ],
[ '\t\r\nabc\n\r\t', '\r\n\t ' ],
[ '\t\r\nabc\n\r\t', '\r\n ' ],
[ '\t\r\nabc\t\r\n', '\t\n' ],
[ '\ta\rb\nc', '\tc' ],
[ '\ta\rb\nc', '\tac' ],
[ '\ta\rb\nc', '\nc' ]
] RETURN NOOPT((TRIM(t[0], t[1]) ))`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test trim function
// //////////////////////////////////////////////////////////////////////////////
testTrimInvalid: function () {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, `RETURN NOOPT(TRIM())`);
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, `RETURN NOOPT(TRIM('foo', 2, 2))`);
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, `RETURN NOOPT(LTRIM('foo', 2, 2))`);
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, `RETURN NOOPT(LTRIM())`);
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, `RETURN NOOPT(RTRIM('foo', 2, 2))`);
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, `RETURN NOOPT(RTRIM())`);
let all = ['TRIM', 'LTRIM', 'RTRIM'];
for (let i = 0; i < 3; i++) {
let WHICH = all[i];
assertEqual([ '' ], getQueryResults(`RETURN NOOPT(${WHICH}(null))`));
assertEqual([ 'true' ], getQueryResults(`RETURN NOOPT(${WHICH}(true))`));
assertEqual([ '4' ], getQueryResults(`RETURN NOOPT(${WHICH}(4))`));
assertEqual([ '[]' ], getQueryResults(`RETURN NOOPT(${WHICH}([ ]))`));
assertEqual([ '{}' ], getQueryResults(`RETURN NOOPT(${WHICH}({ }))`));
assertEqual([ 'foo' ], getQueryResults(`RETURN NOOPT(${WHICH}('foo', null))`));
assertEqual([ 'foo' ], getQueryResults(`RETURN NOOPT(${WHICH}('foo', true))`));
assertEqual([ 'foo' ], getQueryResults(`RETURN NOOPT(${WHICH}('foo', 'bar'))`));
assertEqual([ 'foo' ], getQueryResults(`RETURN NOOPT(${WHICH}('foo', [ ]))`));
assertEqual([ 'foo' ], getQueryResults(`RETURN NOOPT(${WHICH}('foo', { }))`));
assertEqual([ 'foo' ], getQueryResults(`RETURN NOOPT(${WHICH}('foo', -1))`));
assertEqual([ 'foo' ], getQueryResults(`RETURN NOOPT(${WHICH}('foo', -1.5))`));
assertEqual([ 'foo' ], getQueryResults(`RETURN NOOPT(${WHICH}('foo', 3))`));
}
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test ltrim function
// //////////////////////////////////////////////////////////////////////////////
testLtrim: function () {
var expected = [ 'foo ',
'abc\n\r\t',
'a\rb\nc ',
'This\nis\r\na\ttest\r\n' ];
var actual = getQueryResults(`FOR t IN [
' foo ',
'\t\r\nabc\n\r\t',
'\ta\rb\nc ',
'\r\nThis\nis\r\na\ttest\r\n'
] RETURN NOOPT((LTRIM(t) ))`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test ltrim function
// //////////////////////////////////////////////////////////////////////////////
testLtrimSpecial1: function () {
var expected = [ 'foo ',
'\t\r\nabc\n\r\t',
'\ta\rb\nc ',
'This\nis\r\na\ttest\r\n'
];
var actual = getQueryResults(`FOR t IN [
' foo ',
'\t\r\nabc\n\r\t',
'\ta\rb\nc ',
'\r\nThis\nis\r\na\ttest\r\n'
] RETURN NOOPT((LTRIM(t, '\r \n') ))`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test ltrim function
// //////////////////////////////////////////////////////////////////////////////
testLtrimSpecial2: function () {
var expected = [ ' foo ',
'a,b,c,d,,e,f,,',
'foo,bar,baz\r\n'
];
var actual = getQueryResults(`FOR t IN [
' foo ',
',,,a,b,c,d,,e,f,,',
'foo,bar,baz\r\n'
] RETURN NOOPT((LTRIM(t, ',\n') ))`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test rtrim function
// //////////////////////////////////////////////////////////////////////////////
testRtrim: function () {
var expected = [ ' foo',
'\t\r\nabc',
'\ta\rb\nc',
'\r\nThis\nis\r\na\ttest'
];
var actual = getQueryResults(`FOR t IN [
' foo ',
'\t\r\nabc\n\r\t',
'\ta\rb\nc ',
'\r\nThis\nis\r\na\ttest\r\n'
] RETURN NOOPT((RTRIM(t) ))`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test ltrim function
// //////////////////////////////////////////////////////////////////////////////
testRtrimSpecial1: function () {
var expected = [ ' foo',
'\t\r\nabc\n\r\t',
'\ta\rb\nc',
'\r\nThis\nis\r\na\ttest' ];
var actual = getQueryResults(`FOR t IN [
' foo ',
'\t\r\nabc\n\r\t',
'\ta\rb\nc ',
'\r\nThis\nis\r\na\ttest\r\n'
] RETURN NOOPT((RTRIM(t, '\r \n') ))`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test ltrim function
// //////////////////////////////////////////////////////////////////////////////
testRtrimSpecial2: function () {
var expected = [ ' foo ',
',,,a,b,c,d,,e,f',
'foo,bar,baz\r'
];
var actual = getQueryResults(`FOR t IN [
' foo ',
',,,a,b,c,d,,e,f,,',
'foo,bar,baz\r\n'
] RETURN NOOPT((RTRIM(t, ',\n') ))`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test find_first function
// //////////////////////////////////////////////////////////////////////////////
testFindFirstEmpty1: function () {
[ 'foo', 'bar', 'baz', 'FOO', 'BAR', 'true', ' ' ].forEach(function (v) {
var actual = getQueryResults(`RETURN NOOPT((FIND_FIRST('', ` + JSON.stringify(v) + ')) )');
assertEqual([ -1 ], actual);
});
var actual = getQueryResults(`RETURN NOOPT((FIND_FIRST('', '')) )`);
assertEqual([ 0 ], actual);
actual = getQueryResults(`RETURN NOOPT((FIND_FIRST(' ', '', 4)) )`);
assertEqual([ 4 ], actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test find_first function
// //////////////////////////////////////////////////////////////////////////////
testFindFirstEmpty2: function () {
[ 'foo', 'bar', 'baz', 'FOO', 'BAR', 'true', ' ', '' ].forEach(function (v) {
var actual = getQueryResults(`RETURN NOOPT((FIND_FIRST(` + JSON.stringify(v) + `, '')) )`);
assertEqual([ 0 ], actual);
});
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test find_first function
// //////////////////////////////////////////////////////////////////////////////
testFindFirst: function () {
[
[ -1, 'foo', 'bar' ],
[ 3, 'foobar', 'bar' ],
[ 3, 'Foobar', 'bar' ],
[ -1, 'foobar', 'Bar' ],
[ 16, 'the quick brown bar jumped over the lazy dog', 'bar' ],
[ 16, 'the quick brown bar jumped over the lazy dog bar', 'bar' ],
[ 3, 'FOOBAR', 'BAR' ],
[ -1, 'FOOBAR', 'bar' ],
[ -1, 'the quick brown foxx', 'the foxx' ],
[ 0, 'the quick brown foxx', 'the quick' ],
[ -1, 'the quick brown foxx', 'the quick brown foxx j' ],
[ 4, 'the quick brown foxx', 'quick brown' ],
[ 35, 'the quick brown foxx jumped over a\nnewline', 'newline' ],
[ 14, 'some linebreak\r\ngoes here', '\r\n' ],
[ 12, 'foo BAR foo bar', 'bar' ],
[ 4, 'foo bar foo bar', 'bar' ],
[ 17, 'Heavy metal from MÖtleyCrÜe or MÖtleyCrÜe doing heavy metal?', 'MÖtleyCrÜe'],
[ 3, '或或或MÖtleyCrÜe或MÖtleyCrÜe从重金属中提取重金属？', 'MÖtleyCrÜe'],
[ 10, 'MÖtleyCrÜe或MÖtleyCrÜe从重金属中提取重金属？', '或']
].forEach(function (v) {
var actual = getQueryResults(`RETURN NOOPT((FIND_FIRST(` + JSON.stringify(v[1]) + ', ' + JSON.stringify(v[2]) + ')) )');
assertEqual([ v[0] ], actual);
});
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test find_first function
// //////////////////////////////////////////////////////////////////////////////
testFindFirstStartEnd: function () {
[
[ 3, 'foobar', 'bar', 2 ],
[ 3, 'foobar', 'bar', 3 ],
[ -1, 'foobar', 'bar', 4 ],
[ 3, 'foobar', 'bar', 1, 5 ],
[ -1, 'foobar', 'bar', 4, 5 ],
[ -1, 'foobar', 'bar', 1, 4 ],
[ 3, 'foobar', 'bar', 3 ],
[ -1, 'foobar', 'bar', 0, 4 ],
[ 3, 'foobar', 'bar', 0, 5 ],
[ 3, 'foobar', 'bar', 0, 999 ],
[ 0, 'the quick brown bar jumped over the lazy dog', 'the', 0 ],
[ 32, 'the quick brown bar jumped over the lazy dog', 'the', 1 ],
[ 4, 'the quick brown bar jumped over the lazy dog', 'q', 1 ],
[ 4, 'the quick brown bar jumped over the lazy dog', 'q', 3 ],
[ 4, 'the quick brown bar jumped over the lazy dog', 'q', 4 ],
[ -1, 'the quick brown bar jumped over the lazy dog', 'q', 5 ]
].forEach(function (v) {
var actual = getQueryResults(`RETURN NOOPT((FIND_FIRST(` + JSON.stringify(v[1]) + ', ' + JSON.stringify(v[2]) + ', ' + v[3] + ', ' + (v[4] === undefined ? null : v[4]) + ')) )');
assertEqual([ v[0] ], actual);
});
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test find first function
// //////////////////////////////////////////////////////////////////////////////
testFindFirstInvalid: function () {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, `RETURN NOOPT((FIND_FIRST() ))`);
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, `RETURN NOOPT((FIND_FIRST('foo') ))`);
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, `RETURN NOOPT((FIND_FIRST('foo', 'bar', 2, 2, 2) ))`);
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_FIRST(null, 'foo') ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_FIRST(true, 'foo') ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_FIRST(4, 'foo') ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_FIRST([], 'foo') ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_FIRST([ ], 'foo') ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_FIRST({}, 'foo') ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_FIRST({ }, 'foo') ))`));
assertEqual([ +0 ], getQueryResults(`RETURN NOOPT((FIND_FIRST('foo', null) ))`));
assertEqual([ +0 ], getQueryResults(`RETURN NOOPT((FIND_FIRST('foo', '') ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_FIRST('foo', true) ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_FIRST('foo', []) ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_FIRST('foo', [1,2]) ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_FIRST('foo', { }) ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_FIRST('foo', -1) ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_FIRST('foo', -1.5) ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_FIRST('foo', 3) ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_FIRST('foo', 'bar', 'baz') ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_FIRST('foo', 'bar', 1, 'bar') ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_FIRST('foo', 'bar', -1) ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_FIRST('foo', 'bar', 1, -1) ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_FIRST('foo', 'bar', 1, 0) ))`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test find_last function
// //////////////////////////////////////////////////////////////////////////////
testFindLastEmpty1: function () {
[ 'foo', 'bar', 'baz', 'FOO', 'BAR', 'true', ' ' ].forEach(function (v) {
var actual = getQueryResults(`RETURN NOOPT((FIND_LAST('', ` + JSON.stringify(v) + ') ))');
assertEqual([ -1 ], actual);
});
var actual = getQueryResults(`RETURN NOOPT((FIND_LAST('', '') ))`);
assertEqual([ 0 ], actual);
actual = getQueryResults(`RETURN NOOPT((FIND_LAST('012345', '', 1) ))`);
assertEqual([ 6 ], actual);
actual = getQueryResults(`RETURN NOOPT((FIND_LAST('0123456', '', 1, 4) ))`);
assertEqual([ 5 ], actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test find_last function
// //////////////////////////////////////////////////////////////////////////////
testFindLastEmpty2: function () {
[ 'foo', 'bar', 'baz', 'FOO', 'BAR', 'true', ' ', '' ].forEach(function (v) {
var actual = getQueryResults(`RETURN NOOPT((FIND_LAST(` + JSON.stringify(v) + `, '') ))`);
assertEqual([ v.length ], actual);
});
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test find_last function
// //////////////////////////////////////////////////////////////////////////////
testFindLast: function () {
[
[ -1, 'foo', 'bar' ],
[ 3, 'foobar', 'bar' ],
[ 3, 'Foobar', 'bar' ],
[ -1, 'foobar', 'Bar' ],
[ 16, 'the quick brown bar jumped over the lazy dog', 'bar' ],
[ 3, 'FOOBAR', 'BAR' ],
[ -1, 'FOOBAR', 'bar' ],
[ -1, 'the quick brown foxx', 'the foxx' ],
[ 0, 'the quick brown foxx', 'the quick' ],
[ -1, 'the quick brown foxx', 'the quick brown foxx j' ],
[ 4, 'the quick brown foxx', 'quick brown' ],
[ 35, 'the quick brown foxx jumped over a\nnewline', 'newline' ],
[ 14, 'some linebreak\r\ngoes here', '\r\n' ],
[ 31, 'Heavy metal from MÖtleyCrÜe or MÖtleyCrÜe doing heavy metal?', 'MÖtleyCrÜe'],
[ 11, 'MÖtleyCrÜe或MÖtleyCrÜe从重金属中提取重金属？', 'MÖtleyCrÜe'],
[ 10, 'MÖtleyCrÜe或MÖtleyCrÜe从重金属中提取重金属？', '或']
].forEach(function (v) {
var actual = getQueryResults(`RETURN NOOPT((FIND_LAST(` + JSON.stringify(v[1]) + ', ' + JSON.stringify(v[2]) + ') ))');
assertEqual([ v[0] ], actual);
});
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test find_last function
// //////////////////////////////////////////////////////////////////////////////
testFindLastStartEnd: function () {
[
[ 3, 'foobar', 'bar', 0 ],
[ 3, 'foobar', 'bar', 1 ],
[ 3, 'foobar', 'bar', 2 ],
[ 3, 'foobar', 'bar', 3 ],
[ -1, 'foobar', 'bar', 4 ],
[ 3, 'foobar', 'bar', 1, 5 ],
[ 3, 'foobar', 'bar', 2, 5 ],
[ 3, 'foobar', 'bar', 3, 5 ],
[ -1, 'foobar', 'bar', 4, 6 ],
[ -1, 'foobar', 'bar', 4, 5 ],
[ -1, 'foobar', 'bar', 1, 4 ],
[ -1, 'foobar', 'bar', 0, 4 ],
[ 3, 'foobar', 'bar', 0, 5 ],
[ 3, 'foobar', 'bar', 0, 999 ],
[ 32, 'the quick brown bar jumped over the lazy dog', 'the', 0 ],
[ 32, 'the quick brown bar jumped over the lazy dog', 'the', 10 ],
[ 32, 'the quick brown bar jumped over the lazy dog', 'the', 1 ]
].forEach(function (v) {
var actual = getQueryResults(`RETURN NOOPT((FIND_LAST(` + JSON.stringify(v[1]) + ', ' + JSON.stringify(v[2]) + ', ' + v[3] + ', ' + (v[4] === undefined ? null : v[4]) + ') ))');
assertEqual([ v[0] ], actual);
});
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test find_last function
// //////////////////////////////////////////////////////////////////////////////
testFindLastInvalid: function () {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, `RETURN NOOPT((FIND_LAST() ))`);
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, `RETURN NOOPT((FIND_LAST('foo') ))`);
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, `RETURN NOOPT((FIND_LAST('foo', 'bar', 2, 2, 2) ))`);
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_LAST(null, 'foo') ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_LAST(true, 'foo') ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_LAST(4, 'foo') ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_LAST([ ], 'foo') ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_LAST({ }, 'foo') ))`));
assertEqual([ +3 ], getQueryResults(`RETURN NOOPT((FIND_LAST('foo', null) ))`));
assertEqual([ +3 ], getQueryResults(`RETURN NOOPT((FIND_LAST('foo', '') ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_LAST('foo', true) ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_LAST('foo', [ ]) ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_LAST('foo', { }) ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_LAST('foo', -1) ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_LAST('foo', -1.5) ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_LAST('foo', 3) ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_LAST('foo', 'bar', 'baz') ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_LAST('foo', 'bar', 1, 'bar') ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_LAST('foo', 'bar', -1) ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_LAST('foo', 'bar', 1, -1) ))`));
assertEqual([ -1 ], getQueryResults(`RETURN NOOPT((FIND_LAST('foo', 'bar', 1, 0) ))`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat function
// //////////////////////////////////////////////////////////////////////////////
testConcat1: function () {
var expected = [ 'theQuickBrownFoxJumps' ];
var actual = getQueryResults(`FOR r IN [ 1 ] return CONCAT('the', 'Quick', '', null, 'Brown', null, 'Fox', 'Jumps')`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat function
// //////////////////////////////////////////////////////////////////////////////
testConcat2: function () {
var expected = [ 'theQuickBrownアボカドJumps名称について' ];
var actual = getQueryResults(`FOR r IN [ 1 ] return CONCAT('the', 'Quick', '', null, 'Brown', null, 'アボカド', 'Jumps', '名称について')`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat function
// //////////////////////////////////////////////////////////////////////////////
testConcatList1: function () {
var expected = [ 'theQuickBrownアボカドJumps名称について' ];
var actual = getQueryResults(`FOR r IN [ 1 ] return CONCAT([ 'the', 'Quick', '', null, 'Brown', null, 'アボカド', 'Jumps', '名称について' ])`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat function
// //////////////////////////////////////////////////////////////////////////////
testConcatList2: function () {
var expected = [ '["the","Quick","",null,"Brown",null,"アボカド","Jumps","名称について"]' ];
var actual = getQueryResults(`FOR r IN [ 1 ] return CONCAT([ 'the', 'Quick', '', null, 'Brown', null, 'アボカド', 'Jumps', '名称について' ], null)`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat function
// //////////////////////////////////////////////////////////////////////////////
testConcatInvalid: function () {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN CONCAT()');
assertEqual([ 'yestrue' ], getQueryResults('RETURN CONCAT("yes", true)'));
assertEqual([ 'yes4' ], getQueryResults('RETURN CONCAT("yes", 4)'));
assertEqual([ 'yes[]' ], getQueryResults('RETURN CONCAT("yes", [ ])'));
assertEqual([ 'yes{}' ], getQueryResults('RETURN CONCAT("yes", { })'));
assertEqual([ 'trueyes' ], getQueryResults('RETURN CONCAT(true, "yes")'));
assertEqual([ '4yes' ], getQueryResults('RETURN CONCAT(4, "yes")'));
assertEqual([ '[]yes' ], getQueryResults('RETURN CONCAT([ ], "yes")'));
assertEqual([ '{}yes' ], getQueryResults('RETURN CONCAT({ }, "yes")'));
assertEqual([ '{"a":"foo","b":2}yes' ], getQueryResults('RETURN CONCAT({ a: "foo", b: 2 }, "yes")'));
assertEqual([ '[1,"Quick"]["Brown"]falseFox' ], getQueryResults(`RETURN CONCAT([ 1, 'Quick' ], '', null, [ 'Brown' ], false, 'Fox')`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat function
// //////////////////////////////////////////////////////////////////////////////
testConcatCxx1: function () {
var expected = [ 'theQuickBrownFoxJumps' ];
var actual = getQueryResults(`FOR r IN [ 1 ] return NOOPT(CONCAT('the', 'Quick', '', null, 'Brown', null, 'Fox', 'Jumps'))`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat function
// //////////////////////////////////////////////////////////////////////////////
testConcatCxx2: function () {
var expected = [ 'theQuickBrownアボカドJumps名称について' ];
var actual = getQueryResults(`FOR r IN [ 1 ] return NOOPT(CONCAT('the', 'Quick', '', null, 'Brown', null, 'アボカド', 'Jumps', '名称について'))`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat function
// //////////////////////////////////////////////////////////////////////////////
testConcatCxxList1: function () {
var expected = [ 'theQuickBrownアボカドJumps名称について' ];
var actual = getQueryResults(`FOR r IN [ 1 ] return NOOPT(CONCAT([ 'the', 'Quick', '', null, 'Brown', null, 'アボカド', 'Jumps', '名称について' ]))`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat function
// //////////////////////////////////////////////////////////////////////////////
testConcatCxxList2: function () {
var expected = [ '["the","Quick","",null,"Brown",null,"アボカド","Jumps","名称について"]false' ];
var actual = getQueryResults(`FOR r IN [ 1 ] return NOOPT(CONCAT([ 'the', 'Quick', '', null, 'Brown', null, 'アボカド', 'Jumps', '名称について' ], null, false))`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat function
// //////////////////////////////////////////////////////////////////////////////
testConcatCxxInvalid: function () {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN NOOPT(CONCAT())');
assertEqual([ 'yestrue' ], getQueryResults('RETURN NOOPT(CONCAT("yes", true))'));
assertEqual([ 'yes4' ], getQueryResults('RETURN NOOPT(CONCAT("yes", 4))'));
assertEqual([ 'yes[]' ], getQueryResults('RETURN NOOPT(CONCAT("yes", [ ]))'));
assertEqual([ 'yes{}' ], getQueryResults('RETURN NOOPT(CONCAT("yes", { }))'));
assertEqual([ 'trueyes' ], getQueryResults('RETURN NOOPT(CONCAT(true, "yes"))'));
assertEqual([ '4yes' ], getQueryResults('RETURN NOOPT(CONCAT(4, "yes"))'));
assertEqual([ '[]yes' ], getQueryResults('RETURN NOOPT(CONCAT([ ], "yes"))'));
assertEqual([ '[1,2,3]yes' ], getQueryResults('RETURN NOOPT(CONCAT([ 1,2,3], "yes"))'));
assertEqual([ '[1,2,3]yes' ], getQueryResults('RETURN NOOPT(CONCAT([ 1 , 2, 3 ], "yes"))'));
assertEqual([ '{}yes' ], getQueryResults('RETURN NOOPT(CONCAT({ }, "yes"))'));
assertEqual([ '{"a":"foo","b":2}yes' ], getQueryResults('RETURN NOOPT(CONCAT({ a: "foo", b: 2 }, "yes"))'));
assertEqual([ '[1,"Quick"]["Brown"]falseFox' ], getQueryResults(`RETURN NOOPT(CONCAT([ 1, 'Quick' ], '', null, [ 'Brown' ], false, 'Fox'))`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat_separator function
// //////////////////////////////////////////////////////////////////////////////
testConcatSeparator1: function () {
var expected = [ 'the,Quick,Brown,Fox,Jumps' ];
var actual = getQueryResults(`FOR r IN [ 1 ] return CONCAT_SEPARATOR(',', 'the', 'Quick', null, 'Brown', null, 'Fox', 'Jumps')`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat_separator function
// //////////////////////////////////////////////////////////////////////////////
testConcatSeparator2: function () {
var expected = [ 'the*/*/Quick*/*/Brown*/*/*/*/Fox*/*/Jumps' ];
var actual = getQueryResults(`FOR r IN [ 1 ] return CONCAT_SEPARATOR('*/*/', 'the', 'Quick', null, 'Brown', '', 'Fox', 'Jumps')`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat_separator function
// //////////////////////////////////////////////////////////////////////////////
testConcatSeparatorList1: function () {
var expected = [ '["the","Quick",null,"Brown",null,"Fox","Jumps"],higher,["than","you"]' ];
var actual = getQueryResults(`FOR r IN [ 1 ] return CONCAT_SEPARATOR(',', [ 'the', 'Quick', null, 'Brown', null, 'Fox', 'Jumps' ], 'higher', [ 'than', 'you' ])`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat_separator function
// //////////////////////////////////////////////////////////////////////////////
testConcatSeparatorList2: function () {
var expected = [ '["the","Quick",null,"Brown","","Fox","Jumps"]*/*/[]*/*/higher*/*/["than","you"]' ];
var actual = getQueryResults(`FOR r IN [ 1 ] return CONCAT_SEPARATOR('*/*/', [ 'the', 'Quick', null, 'Brown', '', 'Fox', 'Jumps' ], [ ], 'higher', [ 'than', 'you' ])`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat_separator function
// //////////////////////////////////////////////////////////////////////////////
testConcatSeparatorList3: function () {
var expected = [ 'the*/*/Quick*/*/Brown*/*/*/*/Fox*/*/Jumps*/*/[]*/*/higher*/*/["than","you"]' ];
var actual = getQueryResults(`FOR r IN [ 1 ] return CONCAT_SEPARATOR('*/*/', 'the', 'Quick', null, 'Brown', '', 'Fox', 'Jumps', [ ], 'higher', [ 'than', 'you' ])`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat_separator function
// //////////////////////////////////////////////////////////////////////////////
testConcatSeparatorList4: function () {
var expected = [ 'the*/*/Quick*/*/Brown*/*/*/*/Fox*/*/Jumps' ];
var actual = getQueryResults(`FOR r IN [ 1 ] return CONCAT_SEPARATOR('*/*/', [ 'the', 'Quick', null, 'Brown', '', 'Fox', 'Jumps' ])`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat_separator function
// //////////////////////////////////////////////////////////////////////////////
testConcatSeparatorList5: function () {
var expected = [ 'the*/*/Quick*/*/Brown*/*/*/*/Fox*/*/Jumps*/*/[]*/*/higher*/*/["than","you"]' ];
var actual = getQueryResults(`FOR r IN [ 1 ] return CONCAT_SEPARATOR('*/*/', [ 'the', 'Quick', null, 'Brown', '', 'Fox', 'Jumps', [ ], 'higher', [ 'than', 'you' ] ])`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat_separator function
// //////////////////////////////////////////////////////////////////////////////
testConcatSeparatorInvalid: function () {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN CONCAT_SEPARATOR()');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN CONCAT_SEPARATOR("yes")');
assertEqual([ 'yesyes' ], getQueryResults('RETURN CONCAT_SEPARATOR(null, "yes", "yes")'));
assertEqual([ 'yestrueyes' ], getQueryResults('RETURN CONCAT_SEPARATOR(true, "yes", "yes")'));
assertEqual([ 'yes4yes' ], getQueryResults('RETURN CONCAT_SEPARATOR(4, "yes", "yes")'));
assertEqual([ 'yes[]yes' ], getQueryResults('RETURN CONCAT_SEPARATOR([ ], "yes", "yes")'));
assertEqual([ 'yes{}yes' ], getQueryResults('RETURN CONCAT_SEPARATOR({ }, "yes", "yes")'));
assertEqual([ 'trueyesyes' ], getQueryResults('RETURN CONCAT_SEPARATOR("yes", true, "yes")'));
assertEqual([ '4yesyes' ], getQueryResults('RETURN CONCAT_SEPARATOR("yes", 4, "yes")'));
assertEqual([ '[]yesyes' ], getQueryResults('RETURN CONCAT_SEPARATOR("yes", [ ], "yes")'));
assertEqual([ '{}yesyes' ], getQueryResults('RETURN CONCAT_SEPARATOR("yes", { }, "yes")'));
assertEqual([ 'yesyestrue' ], getQueryResults('RETURN CONCAT_SEPARATOR("yes", "yes", true)'));
assertEqual([ 'yesyes4' ], getQueryResults('RETURN CONCAT_SEPARATOR("yes", "yes", 4)'));
assertEqual([ 'yesyes[]' ], getQueryResults('RETURN CONCAT_SEPARATOR("yes", "yes", [ ])'));
assertEqual([ 'yesyes[1,2,3]' ], getQueryResults('RETURN CONCAT_SEPARATOR("yes", "yes", [ 1,2,3 ])'));
assertEqual([ 'yesyes{}' ], getQueryResults('RETURN CONCAT_SEPARATOR("yes", "yes", { })'));
assertEqual([ 'yesyes{}' ], getQueryResults('RETURN CONCAT_SEPARATOR("yes", [ "yes", { } ])'));
assertEqual([ '["yes",{}]yestrue' ], getQueryResults('RETURN CONCAT_SEPARATOR("yes", [ "yes", { } ], null, true)'));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat_separator function
// //////////////////////////////////////////////////////////////////////////////
testConcatSeparatorCxx1: function () {
var expected = [ 'the,Quick,Brown,Fox,Jumps' ];
var actual = getQueryResults(`FOR r IN [ 1 ] RETURN NOOPT(CONCAT_SEPARATOR(',', 'the', 'Quick', null, 'Brown', null, 'Fox', 'Jumps'))`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat_separator function
// //////////////////////////////////////////////////////////////////////////////
testConcatSeparatorCxx2: function () {
var expected = [ 'the*/*/Quick*/*/Brown*/*/*/*/Fox*/*/Jumps' ];
var actual = getQueryResults(`FOR r IN [ 1 ] RETURN NOOPT(CONCAT_SEPARATOR('*/*/', 'the', 'Quick', null, 'Brown', '', 'Fox', 'Jumps'))`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat_separator function
// //////////////////////////////////////////////////////////////////////////////
testConcatSeparatorListCxx1: function () {
var expected = [ '["the","Quick",null,"Brown",null,"Fox","Jumps"],higher,["than","you"]' ];
var actual = getQueryResults(`FOR r IN [ 1 ] RETURN NOOPT(CONCAT_SEPARATOR(',', [ 'the', 'Quick', null, 'Brown', null, 'Fox', 'Jumps' ], 'higher', [ 'than', 'you' ]))`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat_separator function
// //////////////////////////////////////////////////////////////////////////////
testConcatSeparatorListCxx2: function () {
var expected = [ '["the","Quick",null,"Brown","","Fox","Jumps"]*/*/[]*/*/higher*/*/["than","you"]' ];
var actual = getQueryResults(`FOR r IN [ 1 ] RETURN NOOPT(CONCAT_SEPARATOR('*/*/', [ 'the', 'Quick', null, 'Brown', '', 'Fox', 'Jumps' ], [ ], 'higher', [ 'than', 'you' ]))`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat_separator function
// //////////////////////////////////////////////////////////////////////////////
testConcatSeparatorListCxx3: function () {
var expected = [ 'the*/*/Quick*/*/Brown*/*/*/*/Fox*/*/Jumps*/*/[]*/*/higher*/*/["than","you"]' ];
var actual = getQueryResults(`FOR r IN [ 1 ] RETURN NOOPT(CONCAT_SEPARATOR('*/*/', 'the', 'Quick', null, 'Brown', '', 'Fox', 'Jumps', [ ], 'higher', [ 'than', 'you' ]))`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat_separator function
// //////////////////////////////////////////////////////////////////////////////
testConcatSeparatorListCxx4: function () {
var expected = [ 'the*/*/Quick*/*/Brown*/*/*/*/Fox*/*/Jumps' ];
var actual = getQueryResults(`FOR r IN [ 1 ] RETURN NOOPT(CONCAT_SEPARATOR('*/*/', [ 'the', 'Quick', null, 'Brown', '', 'Fox', 'Jumps' ]))`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat_separator function
// //////////////////////////////////////////////////////////////////////////////
testConcatSeparatorListCxx5: function () {
var expected = [ 'the*/*/Quick*/*/Brown*/*/*/*/Fox*/*/Jumps*/*/[]*/*/higher*/*/["than","you"]' ];
var actual = getQueryResults(`FOR r IN [ 1 ] RETURN NOOPT(CONCAT_SEPARATOR('*/*/', [ 'the', 'Quick', null, 'Brown', '', 'Fox', 'Jumps', [ ], 'higher', [ 'than', 'you' ] ]))`);
assertEqual(expected, actual);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test concat_separator function
// //////////////////////////////////////////////////////////////////////////////
testConcatSeparatorCxxInvalid: function () {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN NOOPT(CONCAT_SEPARATOR())');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN NOOPT(CONCAT_SEPARATOR("yes"))');
assertEqual([ 'yesyes' ], getQueryResults('RETURN NOOPT(CONCAT_SEPARATOR(null, "yes", "yes"))'));
assertEqual([ 'yestrueyes' ], getQueryResults('RETURN NOOPT(CONCAT_SEPARATOR(true, "yes", "yes"))'));
assertEqual([ 'yes4yes' ], getQueryResults('RETURN NOOPT(CONCAT_SEPARATOR(4, "yes", "yes"))'));
assertEqual([ 'yes[]yes' ], getQueryResults('RETURN NOOPT(CONCAT_SEPARATOR([ ], "yes", "yes"))'));
assertEqual([ 'yes{}yes' ], getQueryResults('RETURN NOOPT(CONCAT_SEPARATOR({ }, "yes", "yes"))'));
assertEqual([ 'trueyesyes' ], getQueryResults('RETURN NOOPT(CONCAT_SEPARATOR("yes", true, "yes"))'));
assertEqual([ '4yesyes' ], getQueryResults('RETURN NOOPT(CONCAT_SEPARATOR("yes", 4, "yes"))'));
assertEqual([ '[]yesyes' ], getQueryResults('RETURN NOOPT(CONCAT_SEPARATOR("yes", [ ], "yes"))'));
assertEqual([ '{}yesyes' ], getQueryResults('RETURN NOOPT(CONCAT_SEPARATOR("yes", { }, "yes"))'));
assertEqual([ 'yesyestrue' ], getQueryResults('RETURN NOOPT(CONCAT_SEPARATOR("yes", "yes", true))'));
assertEqual([ 'yesyes4' ], getQueryResults('RETURN NOOPT(CONCAT_SEPARATOR("yes", "yes", 4))'));
assertEqual([ 'yesyes[]' ], getQueryResults('RETURN NOOPT(CONCAT_SEPARATOR("yes", "yes", [ ]))'));
assertEqual([ 'yesyes[1,2,3]' ], getQueryResults('RETURN NOOPT(CONCAT_SEPARATOR("yes", "yes", [ 1,2,3 ]))'));
assertEqual([ 'yesyes{}' ], getQueryResults('RETURN NOOPT(CONCAT_SEPARATOR("yes", "yes", { }))'));
assertEqual([ 'yesyes{}' ], getQueryResults('RETURN NOOPT(CONCAT_SEPARATOR("yes", [ "yes", { } ]))'));
assertEqual([ '["yes",{}]yestrue' ], getQueryResults('RETURN NOOPT(CONCAT_SEPARATOR("yes", [ "yes", { } ], null, true))'));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test charlength function
// //////////////////////////////////////////////////////////////////////////////
testCharLength1: () => {
assertEqual([ 7 ], getQueryResults(`RETURN NOOPT(CHAR_LENGTH('äöüÄÖÜß'))`));
assertEqual([ 10 ], getQueryResults(`RETURN NOOPT(CHAR_LENGTH('アボカド名称について'))`));
assertEqual([ 13 ], getQueryResults(`RETURN NOOPT(CHAR_LENGTH('the quick fox'))`));
assertEqual([ 0 ], getQueryResults(`RETURN NOOPT(CHAR_LENGTH(null))`));
assertEqual([ 4 ], getQueryResults(`RETURN NOOPT(CHAR_LENGTH(true))`));
assertEqual([ 5 ], getQueryResults(`RETURN NOOPT(CHAR_LENGTH(false))`));
assertEqual([ 1 ], getQueryResults(`RETURN NOOPT(CHAR_LENGTH(3))`));
assertEqual([ 3 ], getQueryResults(`RETURN NOOPT(CHAR_LENGTH(3.3))`));
assertEqual([ 4 ], getQueryResults(`RETURN NOOPT(CHAR_LENGTH('🥑😄👻👽'))`));
assertEqual([ 2 ], getQueryResults(`RETURN NOOPT(CHAR_LENGTH([ ]))`));
assertEqual([ 7 ], getQueryResults(`RETURN NOOPT(CHAR_LENGTH([ 1, 2, 3 ]))`));
assertEqual([ 2 ], getQueryResults(`RETURN NOOPT(CHAR_LENGTH({ }))`));
assertEqual([ 7 ], getQueryResults(`RETURN NOOPT(CHAR_LENGTH({ a:1 }))`));
assertEqual([ 11 ], getQueryResults(`RETURN NOOPT(CHAR_LENGTH({ a: "foo" }))`));
assertEqual([ 13 ], getQueryResults(`RETURN NOOPT(CHAR_LENGTH({ a:1, b: 2 }))`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test charlength function
// //////////////////////////////////////////////////////////////////////////////
testCharLengthInvalid: () => {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN NOOPT(CHAR_LENGTH())');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, `RETURN NOOPT(CHAR_LENGTH('yes', 'yes'))`);
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test lower function
// //////////////////////////////////////////////////////////////////////////////
testLower1: () => {
assertEqual([ 'the quick brown fox jumped' ], getQueryResults(`RETURN NOOPT(LOWER('THE quick Brown foX JuMpED'))`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test lower function
// //////////////////////////////////////////////////////////////////////////////
testLower2: () => {
assertEqual([ 'äöüäöüß アボカド名称について' ], getQueryResults(`return NOOPT(LOWER('äöüÄÖÜß アボカド名称について'))`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test lower function
// //////////////////////////////////////////////////////////////////////////////
testLower3: () => {
assertEqual([ `0123456789<>|,;.:-_#'+*@!"$&/(){[]}?\\` ], getQueryResults(`return NOOPT(LOWER('0123456789<>|,;.:-_#\\'+*@!\\"$&/(){[]}?\\\\'))`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test lower function
// //////////////////////////////////////////////////////////////////////////////
testLowerInvalid: () => {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN NOOPT(LOWER())');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, `RETURN LOWER(NOOPT('yes', 'yes'))`);
assertEqual([ '' ], getQueryResults('RETURN NOOPT(LOWER(null))'));
assertEqual([ 'true' ], getQueryResults('RETURN NOOPT(LOWER(true))'));
assertEqual([ '3' ], getQueryResults('RETURN NOOPT(LOWER(3))'));
assertEqual([ '[]' ], getQueryResults('RETURN NOOPT(LOWER([]))'));
assertEqual([ '[1,2,3]' ], getQueryResults('RETURN NOOPT(LOWER([1,2,3]))'));
assertEqual([ '{}' ], getQueryResults('RETURN NOOPT(LOWER({}))'));
assertEqual([ '{"a":1,"b":2}' ], getQueryResults('RETURN NOOPT(LOWER({A:1,b:2}))'));
assertEqual([ '{"a":1,"a":2,"b":3}' ], getQueryResults('RETURN NOOPT(LOWER({A:1,a:2,b:3}))'));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test upper function
// //////////////////////////////////////////////////////////////////////////////
testUpper1: () => {
assertEqual([ 'THE QUICK BROWN FOX JUMPED' ], getQueryResults(`return NOOPT(UPPER('THE quick Brown foX JuMpED'))`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test upper function
// //////////////////////////////////////////////////////////////////////////////
testUpper2: () => {
assertEqual([ 'ÄÖÜÄÖÜSS アボカド名称について' ], getQueryResults(`return NOOPT(UPPER('äöüÄÖÜß アボカド名称について'))`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test upper function
// //////////////////////////////////////////////////////////////////////////////
testUpperInvalid: () => {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN NOOPT(UPPER())');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, `RETURN NOOPT(UPPER('yes', 'yes'))`);
assertEqual([ '' ], getQueryResults('RETURN NOOPT(UPPER(null))'));
assertEqual([ 'TRUE' ], getQueryResults('RETURN NOOPT(UPPER(true))'));
assertEqual([ '3' ], getQueryResults('RETURN NOOPT(UPPER(3))'));
assertEqual([ '[]' ], getQueryResults('RETURN NOOPT(UPPER([]))'));
assertEqual([ '[1,2,3]' ], getQueryResults('RETURN NOOPT(UPPER([1,2,3]))'));
assertEqual([ '{}' ], getQueryResults('RETURN NOOPT(UPPER({}))'));
assertEqual([ '{"A":1,"B":2}' ], getQueryResults('RETURN NOOPT(UPPER({a:1, b:2}))'));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test substring function
// //////////////////////////////////////////////////////////////////////////////
testSubstring1: function () {
var expected = [ 'the' ];
assertEqual(expected, getQueryResults(`FOR r IN [ 1 ] return SUBSTRING('the quick brown fox', 0, 3)`));
assertEqual(expected, getQueryResults(`FOR r IN [ 1 ] return NOOPT(SUBSTRING('the quick brown fox', 0, 3))`));
assertEqual(['🤡cp'], getQueryResults(`FOR r IN [ 1 ] return NOOPT(SUBSTRING('🤡cpp quick brown fox', 0, 3))`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test substring function
// //////////////////////////////////////////////////////////////////////////////
testSubstring2: function () {
var expected = [ 'quick' ];
assertEqual(expected, getQueryResults(`FOR r IN [ 1 ] return SUBSTRING('the quick brown fox', 4, 5)`));
assertEqual(expected, getQueryResults(`FOR r IN [ 1 ] return NOOPT(SUBSTRING('the quick brown fox', 4, 5))`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test substring function
// //////////////////////////////////////////////////////////////////////////////
testSubstring3: function () {
const expected = [ 'fox' ];
assertEqual(expected, getQueryResults(`return SUBSTRING('the quick brown fox', -3)`));
assertEqual(expected, getQueryResults(`return NOOPT(SUBSTRING('the quick brown fox', -3))`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test substring function
// //////////////////////////////////////////////////////////////////////////////
testSubstringInvalid: function () {
var buildQuery = function (nr, input) {
switch (nr) {
case 0:
return `RETURN SUBSTRING(${input})`;
case 1:
return `RETURN NOOPT(SUBSTRING(${input}))`;
default:
assertTrue(false, 'Undefined state');
}
};
for (var i = 0; i < 2; ++i) {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, buildQuery(i, ''));
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, buildQuery(i, '"yes"'));
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, buildQuery(i, '"yes", 0, 2, "yes"'));
assertEqual([ '' ], getQueryResults(buildQuery(i, 'null, 0')));
assertEqual([ '' ], getQueryResults(buildQuery(i, 'null, 1')));
assertEqual([ 'true' ], getQueryResults(buildQuery(i, 'true, 0')));
assertEqual([ '3' ], getQueryResults(buildQuery(i, '3, 0')));
assertEqual([ '[]' ], getQueryResults(buildQuery(i, '[ ], 0')));
assertEqual([ '[1,2,3]' ], getQueryResults(buildQuery(i, '[ 1, 2, 3 ], 0')));
assertEqual([ '2,3]' ], getQueryResults(buildQuery(i, '[ 1, 2, 3 ], 3')));
assertEqual([ '{}' ], getQueryResults(buildQuery(i, '{ }, 0')));
assertEqual([ '' ], getQueryResults(buildQuery(i, `'yes', null, 0`)));
assertEqual([ '' ], getQueryResults(buildQuery(i, `'yes', true, 0`)));
assertEqual([ '' ], getQueryResults(buildQuery(i, `'yes', 'yes', 0`)));
assertEqual([ '' ], getQueryResults(buildQuery(i, `'yes', [ ], 0`)));
assertEqual([ '' ], getQueryResults(buildQuery(i, `'yes', { }, 0`)));
assertEqual([ '' ], getQueryResults(buildQuery(i, `'yes', 'yes', null`)));
assertEqual([ 'y' ], getQueryResults(buildQuery(i, `'yes', 'yes', true`)));
assertEqual([ '' ], getQueryResults(buildQuery(i, `'yes', 'yes', [ ]`)));
assertEqual([ '' ], getQueryResults(buildQuery(i, `'yes', 'yes', { }`)));
}
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test hash function
// //////////////////////////////////////////////////////////////////////////////
testHash: function () {
var buildQuery = function (nr, input) {
switch (nr) {
case 0:
return `RETURN HASH(${input})`;
case 1:
return `RETURN NOOPT(HASH(${input}))`;
default:
assertTrue(false, 'Undefined state');
}
};
var i;
for (i = 0; i < 2; ++i) {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, buildQuery(i, ''));
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, buildQuery(i, '1, 2'));
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, buildQuery(i, '1, 2, 3'));
assertEqual([ 675717317264138 ], getQueryResults(buildQuery(i, `null`)));
assertEqual([ 1217335385489389 ], getQueryResults(buildQuery(i, `false`)));
assertEqual([ 57801618404459 ], getQueryResults(buildQuery(i, `true`)));
assertEqual([ 675717317264138 ], getQueryResults(buildQuery(i, `1 / 0`)));
assertEqual([ 2964198978643 ], getQueryResults(buildQuery(i, `0`)));
assertEqual([ 2964198978643 ], getQueryResults(buildQuery(i, `0.0`)));
assertEqual([ 464020872367562 ], getQueryResults(buildQuery(i, `0.00001`)));
assertEqual([ 652971229830707 ], getQueryResults(buildQuery(i, `1`)));
assertEqual([ 510129580600084 ], getQueryResults(buildQuery(i, `-1`)));
assertEqual([ 24372339383975 ], getQueryResults(buildQuery(i, `-10.5`)));
assertEqual([ 1041198105137773 ], getQueryResults(buildQuery(i, `123452532322453`)));
assertEqual([ 876255539722551 ], getQueryResults(buildQuery(i, `123452532322454`)));
assertEqual([ 1277486662998285 ], getQueryResults(buildQuery(i, `123452532322454.434`)));
assertEqual([ 210539478145939 ], getQueryResults(buildQuery(i, `-123452532322454`)));
assertEqual([ 261745517313272 ], getQueryResults(buildQuery(i, `-9999999999999.999`)));
assertEqual([ 441814588996558 ], getQueryResults(buildQuery(i, `''`)));
assertEqual([ 1112732548475941 ], getQueryResults(buildQuery(i, `' '`)));
assertEqual([ 246233608921999 ], getQueryResults(buildQuery(i, `' '`)));
assertEqual([ 1542381651001813 ], getQueryResults(buildQuery(i, `'a'`)));
assertEqual([ 843602980995939 ], getQueryResults(buildQuery(i, `'A'`)));
assertEqual([ 1618092585478118 ], getQueryResults(buildQuery(i, `' a'`)));
assertEqual([ 725364078947946 ], getQueryResults(buildQuery(i, `' A'`)));
assertEqual([ 736233736371291 ], getQueryResults(buildQuery(i, `' foobar'`)));
assertEqual([ 360657200843601 ], getQueryResults(buildQuery(i, `'this is a string test. please ignore.'`)));
assertEqual([ 828085160327326 ], getQueryResults(buildQuery(i, `'this is a string test. please Ignore.'`)));
assertEqual([ 2072438876063292 ], getQueryResults(buildQuery(i, `'a string is a string is a string of course. even longer strings can be hashed. isn\\'t this fantastic? let\\'s see if we can cross the short-string bounds with it...'`)));
assertEqual([ 181227890622943 ], getQueryResults(buildQuery(i, `[]`)));
assertEqual([ 346113245898278 ], getQueryResults(buildQuery(i, `[0]`)));
assertEqual([ 785599515440277 ], getQueryResults(buildQuery(i, `[1]`)));
assertEqual([ 1295855700045140 ], getQueryResults(buildQuery(i, `[1,2]`)));
assertEqual([ 1295855700045140 ], getQueryResults(buildQuery(i, `1..2`)));
assertEqual([ 1255602544875390 ], getQueryResults(buildQuery(i, `[2,1]`)));
assertEqual([ 1255602544875390 ], getQueryResults(buildQuery(i, `2..1`)));
assertEqual([ 1625466870434085 ], getQueryResults(buildQuery(i, `[1,2,3]`)));
assertEqual([ 1625466870434085 ], getQueryResults(buildQuery(i, `1..3`)));
assertEqual([ 1657598895986170 ], getQueryResults(buildQuery(i, `[1,2,3,4]`)));
assertEqual([ 1657598895986170 ], getQueryResults(buildQuery(i, `1..4`)));
assertEqual([ 1580543009747638 ], getQueryResults(buildQuery(i, `[1,2,4,3]`)));
assertEqual([ 157821093310761 ], getQueryResults(buildQuery(i, `[1,2,3,2]`)));
assertEqual([ 1032992608692014 ], getQueryResults(buildQuery(i, `[1,2,3,2,1]`)));
assertEqual([ 2051766968908771 ], getQueryResults(buildQuery(i, `1..1000`)));
assertEqual([ 1954991255293719 ], getQueryResults(buildQuery(i, `{}`)));
assertEqual([ 1294634865089389 ], getQueryResults(buildQuery(i, `{a:1}`)));
assertEqual([ 1451630758438458 ], getQueryResults(buildQuery(i, `{a:2}`)));
assertEqual([ 402003666669761 ], getQueryResults(buildQuery(i, `{a:1,b:1}`)));
assertEqual([ 529935412783457 ], getQueryResults(buildQuery(i, `{a:1,b:2}`)));
assertEqual([ 402003666669761 ], getQueryResults(buildQuery(i, `{b:1,a:1}`)));
assertEqual([ 529935412783457 ], getQueryResults(buildQuery(i, `{b:2,a:1}`)));
assertEqual([ 1363279506864914 ], getQueryResults(buildQuery(i, `{b:1,a:2}`)));
assertEqual([ 1363279506864914 ], getQueryResults(buildQuery(i, `{a:2,b:1}`)));
assertEqual([ 1685918180496814 ], getQueryResults(buildQuery(i, `{a:2,b:'1'}`)));
assertEqual([ 874128984798182 ], getQueryResults(buildQuery(i, `{a:2,b:null}`)));
assertEqual([ 991653416476703 ], getQueryResults(buildQuery(i, `{A:1,B:2}`)));
assertEqual([ 502569457877206 ], getQueryResults(buildQuery(i, `{a:'A',b:'B'}`)));
assertEqual([ 1154380811055928 ], getQueryResults(buildQuery(i, `{a:'a',b:'b'}`)));
assertEqual([ 416732334603048 ], getQueryResults(buildQuery(i, `{a:['a'],b:['b']}`)));
assertEqual([ 176300349653218 ], getQueryResults(buildQuery(i, `{a:1,b:-1}`)));
assertEqual([ 1460607510107728 ], getQueryResults(buildQuery(i, `{_id:'foo',_key:'bar',_rev:'baz'}`)));
assertEqual([ 1271501175803754 ], getQueryResults(buildQuery(i, `{_id:'foo',_key:'bar',_rev:'baz',bar:'bark'}`)));
}
for (i = 0; i < 2; ++i) {
// order does not matter
assertEqual(getQueryResults(buildQuery(i, '{a:1,b:2}')), getQueryResults(buildQuery(i, '{b:2,a:1}')));
assertNotEqual(getQueryResults(buildQuery(i, '{a:1,b:2}')), getQueryResults(buildQuery(i, '{a:2,b:1}')));
// order matters
assertNotEqual(getQueryResults(buildQuery(i, '[1,2,3]')), getQueryResults(buildQuery(i, '[3,2,1]')));
// arrays and ranges
assertEqual(getQueryResults(buildQuery(i, '[1,2,3]')), getQueryResults(buildQuery(i, '1..3')));
// arrays and subqueries
assertEqual(getQueryResults(buildQuery(i, '[1,2,3]')), getQueryResults(buildQuery(i, 'FOR i IN [1,2,3] RETURN i')));
}
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test md5 function
// //////////////////////////////////////////////////////////////////////////////
testMd5: function () {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN MD5()');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN MD5("foo", 2)');
assertEqual([ 'd41d8cd98f00b204e9800998ecf8427e' ], getQueryResults(`RETURN MD5('')`));
assertEqual([ '7215ee9c7d9dc229d2921a40e899ec5f' ], getQueryResults(`RETURN MD5(' ')`));
assertEqual([ 'cfcd208495d565ef66e7dff9f98764da' ], getQueryResults(`RETURN MD5('0')`));
assertEqual([ 'c4ca4238a0b923820dcc509a6f75849b' ], getQueryResults(`RETURN MD5('1')`));
assertEqual([ '6bb61e3b7bce0931da574d19d1d82c88' ], getQueryResults(`RETURN MD5('-1')`));
assertEqual([ '0bad51c0b9b2ba77c19bf6bfbbf88dc3' ], getQueryResults(`RETURN MD5(' 0')`));
assertEqual([ '2e5751b7cfd7f053cd29e946fb2649a4' ], getQueryResults(`RETURN MD5('0 ')`));
assertEqual([ 'acbd18db4cc2f85cedef654fccc4a4d8' ], getQueryResults(`RETURN MD5('foo')`));
assertEqual([ '901890a8e9c8cf6d5a1a542b229febff' ], getQueryResults(`RETURN MD5('FOO')`));
assertEqual([ '1356c67d7ad1638d816bfb822dd2c25d' ], getQueryResults(`RETURN MD5('Foo')`));
assertEqual([ 'f32a26e2a3a8aa338cd77b6e1263c535' ], getQueryResults(`RETURN MD5('FooBar')`));
assertEqual([ 'c639efc1e98762233743a75e7798dd9c' ], getQueryResults(`RETURN MD5('This is a test string')`));
assertEqual([ 'f9a70133b9fe5fa12acd30056bf4aa26' ], getQueryResults(`RETURN MD5('With\r\nLinebreaks\n')`));
assertEqual([ '1441a7909c087dbbe7ce59881b9df8b9' ], getQueryResults(`RETURN MD5('[object Object]')`));
assertEqual([ 'cfcd208495d565ef66e7dff9f98764da' ], getQueryResults(`RETURN MD5(0)`));
assertEqual([ 'c4ca4238a0b923820dcc509a6f75849b' ], getQueryResults(`RETURN MD5(1)`));
assertEqual([ '6bb61e3b7bce0931da574d19d1d82c88' ], getQueryResults(`RETURN MD5(-1)`));
assertEqual([ 'd41d8cd98f00b204e9800998ecf8427e' ], getQueryResults(`RETURN MD5(null)`));
assertEqual([ 'd751713988987e9331980363e24189ce' ], getQueryResults(`RETURN MD5([])`));
assertEqual([ '8d5162ca104fa7e79fe80fd92bb657fb' ], getQueryResults(`RETURN MD5([0])`));
assertEqual([ '35dba5d75538a9bbe0b4da4422759a0e' ], getQueryResults(`RETURN MD5('[1]')`));
assertEqual([ 'f79408e5ca998cd53faf44af31e6eb45' ], getQueryResults(`RETURN MD5([1,2])`));
assertEqual([ '99914b932bd37a50b983c5e7c90ae93b' ], getQueryResults(`RETURN MD5({ })`));
assertEqual([ '99914b932bd37a50b983c5e7c90ae93b' ], getQueryResults(`RETURN MD5({})`));
assertEqual([ '608de49a4600dbb5b173492759792e4a' ], getQueryResults(`RETURN MD5({a:1,b:2})`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test sha1 function
// //////////////////////////////////////////////////////////////////////////////
testSha1: function () {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN SHA1()');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN SHA1("foo", 2)');
assertEqual([ 'da39a3ee5e6b4b0d3255bfef95601890afd80709' ], getQueryResults(`RETURN SHA1('')`));
assertEqual([ 'b858cb282617fb0956d960215c8e84d1ccf909c6' ], getQueryResults(`RETURN SHA1(' ')`));
assertEqual([ 'b6589fc6ab0dc82cf12099d1c2d40ab994e8410c' ], getQueryResults(`RETURN SHA1('0')`));
assertEqual([ '356a192b7913b04c54574d18c28d46e6395428ab' ], getQueryResults(`RETURN SHA1('1')`));
assertEqual([ '7984b0a0e139cabadb5afc7756d473fb34d23819' ], getQueryResults(`RETURN SHA1('-1')`));
assertEqual([ '7ae5a5c19b16f9ee3b00ca36fc729536fb5e7307' ], getQueryResults(`RETURN SHA1(' 0')`));
assertEqual([ '1ee9183b1f737da4d348ea42281bd1dd682c5d52' ], getQueryResults(`RETURN SHA1('0 ')`));
assertEqual([ '0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33' ], getQueryResults(`RETURN SHA1('foo')`));
assertEqual([ 'feab40e1fca77c7360ccca1481bb8ba5f919ce3a' ], getQueryResults(`RETURN SHA1('FOO')`));
assertEqual([ '201a6b3053cc1422d2c3670b62616221d2290929' ], getQueryResults(`RETURN SHA1('Foo')`));
assertEqual([ 'eb8fc41f9d9ae5855c4d801355075e4ccfb22808' ], getQueryResults(`RETURN SHA1('FooBar')`));
assertEqual([ 'e2f67c772368acdeee6a2242c535c6cc28d8e0ed' ], getQueryResults(`RETURN SHA1('This is a test string')`));
assertEqual([ 'a90b947dd16a53e717451d3c536d445ece647c52' ], getQueryResults(`RETURN SHA1('With\r\nLinebreaks\n')`));
assertEqual([ '2be88ca4242c76e8253ac62474851065032d6833' ], getQueryResults(`RETURN SHA1('null')`));
assertEqual([ 'f629ae44b7b3dcfed444d363e626edf411ec69a8' ], getQueryResults(`RETURN SHA1('[1]')`));
assertEqual([ 'c1d44ff03aff1372856c281854f454e2e1d15b7c' ], getQueryResults(`RETURN SHA1('[object Object]')`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test sha512 function
// //////////////////////////////////////////////////////////////////////////////
testSha512: function () {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN SHA512()');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN SHA512("foo", 2)');
assertEqual([ 'cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e' ], getQueryResults(`RETURN SHA512('')`));
assertEqual([ 'f90ddd77e400dfe6a3fcf479b00b1ee29e7015c5bb8cd70f5f15b4886cc339275ff553fc8a053f8ddc7324f45168cffaf81f8c3ac93996f6536eef38e5e40768' ], getQueryResults(`RETURN SHA512(' ')`));
assertEqual([ '31bca02094eb78126a517b206a88c73cfa9ec6f704c7030d18212cace820f025f00bf0ea68dbf3f3a5436ca63b53bf7bf80ad8d5de7d8359d0b7fed9dbc3ab99' ], getQueryResults(`RETURN SHA512('0')`));
assertEqual([ '4dff4ea340f0a823f15d3f4f01ab62eae0e5da579ccb851f8db9dfe84c58b2b37b89903a740e1ee172da793a6e79d560e5f7f9bd058a12a280433ed6fa46510a' ], getQueryResults(`RETURN SHA512('1')`));
assertEqual([ '4fcdd8c15addb15f1e994008677c740848168cd8d32e92d44301ea12b37a93fbd9f0a0468d04789e1f387b395509bd3b998e8aad5e02dd2625f0aac661fb1100' ], getQueryResults(`RETURN SHA512('-1')`));
assertEqual([ '5364d359dbe42bfb870d304e46cfefa1d438779ed425e30a3de0948a3e99594e58dfcca0e0da47e561f0718ffaabfe68f50515d2dca1f715acd7fca6808f87e8' ], getQueryResults(`RETURN SHA512(' 0')`));
assertEqual([ '3595817cf0e1f1852bc3d279f38df6f899ca963dedd143af810d3c50844a7ca3e0c25be6d3761e9a7010641756110c344ab57e6e5fe3e89a4cb6532705a8c47d' ], getQueryResults(`RETURN SHA512('0 ')`));
assertEqual([ 'f7fbba6e0636f890e56fbbf3283e524c6fa3204ae298382d624741d0dc6638326e282c41be5e4254d8820772c5518a2c5a8c0c7f7eda19594a7eb539453e1ed7' ], getQueryResults(`RETURN SHA512('foo')`));
assertEqual([ '9840f9826bba3ddfc3c4872884f51dcbe915a2d42c6a4d0d59ce564e7fe541f15b9a4271554065379709932bc99a71d85f05aacd62457fce5fd131f847de99ec' ], getQueryResults(`RETURN SHA512('FOO')`));
assertEqual([ '4abcd2639957cb23e33f63d70659b602a5923fafcfd2768ef79b0badea637e5c837161aa101a557a1d4deacbd912189e2bb11bf3c0c0c70ef7797217da7e8207' ], getQueryResults(`RETURN SHA512('Foo')`));
assertEqual([ '0d6fc00052fee1d3ae1880d5dc59b74dd50449ffdea399449223d2c5b792395ce64153b150fc0fc01bfeed30c7347411cfb8a3b17b51fd8aa6c03acfbcd09e7b' ], getQueryResults(`RETURN SHA512('FooBar')`));
assertEqual([ 'b8ee69b29956b0b56e26d0a25c6a80713c858cf2902a12962aad08d682345646b2d5f193bbe03997543a9285e5932f34baf2c85c89459f25ba1cf43c4410793c' ], getQueryResults(`RETURN SHA512('This is a test string')`));
assertEqual([ '80e0e9a3b8b4019546bb30538b4c8934c1afcb98c70a67001ca3a5eb1c243ec217f5e022edfa6aa0afb25a62ac5eef1a87108a3912e015da7bf519d08b4ea704' ], getQueryResults(`RETURN SHA512('With\r\nLinebreaks\n')`));
assertEqual([ '04f8ff2682604862e405bf88de102ed7710ac45c1205957625e4ee3e5f5a2241e453614acc451345b91bafc88f38804019c7492444595674e94e8cf4be53817f' ], getQueryResults(`RETURN SHA512('null')`));
assertEqual([ 'cb0b42c73bc373fa2c695ffb4d4c801571f23397aead7c5b793269801e740ed666f83149b1eed6eaab5f07876236f166da5ae3deb8ab52e85dfd9bdd7c3c9432' ], getQueryResults(`RETURN SHA512('[1]')`));
assertEqual([ '1dccad3fad058a29ccef8e003fa71bbabf587431ac5a55fb36268bf7958c5f3cb31116ac9e855ec61bb9b72ecbd484f704bee032707fb0ead24ad2bee97b9a39' ], getQueryResults(`RETURN SHA512('[object Object]')`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test md5 function
// //////////////////////////////////////////////////////////////////////////////
testMd5Cxx: function () {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN NOOPT(MD5())');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN NOOPT(MD5("foo", 2))');
assertEqual([ 'd41d8cd98f00b204e9800998ecf8427e' ], getQueryResults(`RETURN NOOPT(MD5(''))`));
assertEqual([ '7215ee9c7d9dc229d2921a40e899ec5f' ], getQueryResults(`RETURN NOOPT(MD5(' '))`));
assertEqual([ 'cfcd208495d565ef66e7dff9f98764da' ], getQueryResults(`RETURN NOOPT(MD5('0'))`));
assertEqual([ 'c4ca4238a0b923820dcc509a6f75849b' ], getQueryResults(`RETURN NOOPT(MD5('1'))`));
assertEqual([ '6bb61e3b7bce0931da574d19d1d82c88' ], getQueryResults(`RETURN NOOPT(MD5('-1'))`));
assertEqual([ '0bad51c0b9b2ba77c19bf6bfbbf88dc3' ], getQueryResults(`RETURN NOOPT(MD5(' 0'))`));
assertEqual([ '2e5751b7cfd7f053cd29e946fb2649a4' ], getQueryResults(`RETURN NOOPT(MD5('0 '))`));
assertEqual([ 'acbd18db4cc2f85cedef654fccc4a4d8' ], getQueryResults(`RETURN NOOPT(MD5('foo'))`));
assertEqual([ '901890a8e9c8cf6d5a1a542b229febff' ], getQueryResults(`RETURN NOOPT(MD5('FOO'))`));
assertEqual([ '1356c67d7ad1638d816bfb822dd2c25d' ], getQueryResults(`RETURN NOOPT(MD5('Foo'))`));
assertEqual([ 'f32a26e2a3a8aa338cd77b6e1263c535' ], getQueryResults(`RETURN NOOPT(MD5('FooBar'))`));
assertEqual([ 'c639efc1e98762233743a75e7798dd9c' ], getQueryResults(`RETURN NOOPT(MD5('This is a test string'))`));
assertEqual([ 'f9a70133b9fe5fa12acd30056bf4aa26' ], getQueryResults(`RETURN NOOPT(MD5('With\r\nLinebreaks\n'))`));
assertEqual([ '1441a7909c087dbbe7ce59881b9df8b9' ], getQueryResults(`RETURN NOOPT(MD5('[object Object]'))`));
assertEqual([ 'cfcd208495d565ef66e7dff9f98764da' ], getQueryResults(`RETURN NOOPT(MD5(0))`));
assertEqual([ 'c4ca4238a0b923820dcc509a6f75849b' ], getQueryResults(`RETURN NOOPT(MD5(1))`));
assertEqual([ '6bb61e3b7bce0931da574d19d1d82c88' ], getQueryResults(`RETURN NOOPT(MD5(-1))`));
assertEqual([ 'd41d8cd98f00b204e9800998ecf8427e' ], getQueryResults(`RETURN NOOPT(MD5(null))`));
assertEqual([ '35dba5d75538a9bbe0b4da4422759a0e' ], getQueryResults(`RETURN NOOPT(MD5('[1]'))`));
assertEqual([ '99914b932bd37a50b983c5e7c90ae93b' ], getQueryResults(`RETURN NOOPT(MD5({}))`));
assertEqual([ 'c7cb8c1df686c0219d540849efe3bce3' ], getQueryResults(`RETURN NOOPT(MD5('[1,2,4,7,11,16,22,29,37,46,56,67,79,92,106,121,137,154,172,191,211,232,254,277,301,326,352,379,407,436,466,497,529,562,596,631,667,704,742,781,821,862,904,947,991,1036,1082,1129,1177,1226,1276,1327,1379,1432,1486,1541,1597,1654,1712,1771,1831,1892,1954,2017,2081,2146,2212,2279,2347,2416,2486,2557,2629,2702,2776,2851,2927,3004,3082,3161,3241,3322,3404,3487,3571,3656,3742,3829,3917,4006,4096,4187,4279,4372,4466,4561,4657,4754,4852,4951]'))`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test sha1 function
// //////////////////////////////////////////////////////////////////////////////
testSha1Cxx: function () {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN NOOPT(SHA1())');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN NOOPT(SHA1("foo", 2))');
assertEqual([ 'da39a3ee5e6b4b0d3255bfef95601890afd80709' ], getQueryResults(`RETURN NOOPT(SHA1(''))`));
assertEqual([ 'b858cb282617fb0956d960215c8e84d1ccf909c6' ], getQueryResults(`RETURN NOOPT(SHA1(' '))`));
assertEqual([ 'b6589fc6ab0dc82cf12099d1c2d40ab994e8410c' ], getQueryResults(`RETURN NOOPT(SHA1('0'))`));
assertEqual([ '356a192b7913b04c54574d18c28d46e6395428ab' ], getQueryResults(`RETURN NOOPT(SHA1('1'))`));
assertEqual([ '7984b0a0e139cabadb5afc7756d473fb34d23819' ], getQueryResults(`RETURN NOOPT(SHA1('-1'))`));
assertEqual([ '7ae5a5c19b16f9ee3b00ca36fc729536fb5e7307' ], getQueryResults(`RETURN NOOPT(SHA1(' 0'))`));
assertEqual([ '1ee9183b1f737da4d348ea42281bd1dd682c5d52' ], getQueryResults(`RETURN NOOPT(SHA1('0 '))`));
assertEqual([ '0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33' ], getQueryResults(`RETURN NOOPT(SHA1('foo'))`));
assertEqual([ 'feab40e1fca77c7360ccca1481bb8ba5f919ce3a' ], getQueryResults(`RETURN NOOPT(SHA1('FOO'))`));
assertEqual([ '201a6b3053cc1422d2c3670b62616221d2290929' ], getQueryResults(`RETURN NOOPT(SHA1('Foo'))`));
assertEqual([ 'eb8fc41f9d9ae5855c4d801355075e4ccfb22808' ], getQueryResults(`RETURN NOOPT(SHA1('FooBar'))`));
assertEqual([ 'e2f67c772368acdeee6a2242c535c6cc28d8e0ed' ], getQueryResults(`RETURN NOOPT(SHA1('This is a test string'))`));
assertEqual([ 'a90b947dd16a53e717451d3c536d445ece647c52' ], getQueryResults(`RETURN NOOPT(SHA1('With\r\nLinebreaks\n'))`));
assertEqual([ '2be88ca4242c76e8253ac62474851065032d6833' ], getQueryResults(`RETURN NOOPT(SHA1('null'))`));
assertEqual([ 'f629ae44b7b3dcfed444d363e626edf411ec69a8' ], getQueryResults(`RETURN NOOPT(SHA1('[1]'))`));
assertEqual([ 'c1d44ff03aff1372856c281854f454e2e1d15b7c' ], getQueryResults(`RETURN NOOPT(SHA1('[object Object]'))`));
assertEqual([ '888227c44807b86059eb36f9fe0fc602a9b16fab' ], getQueryResults(`RETURN NOOPT(SHA1('[1,2,4,7,11,16,22,29,37,46,56,67,79,92,106,121,137,154,172,191,211,232,254,277,301,326,352,379,407,436,466,497,529,562,596,631,667,704,742,781,821,862,904,947,991,1036,1082,1129,1177,1226,1276,1327,1379,1432,1486,1541,1597,1654,1712,1771,1831,1892,1954,2017,2081,2146,2212,2279,2347,2416,2486,2557,2629,2702,2776,2851,2927,3004,3082,3161,3241,3322,3404,3487,3571,3656,3742,3829,3917,4006,4096,4187,4279,4372,4466,4561,4657,4754,4852,4951]'))`));
},
// //////////////////////////////////////////////////////////////////////////////
// / @brief test random_token function
// //////////////////////////////////////////////////////////////////////////////
testRandomToken: function () {
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN RANDOM_TOKEN()');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, 'RETURN RANDOM_TOKEN(1, 2)');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH.code, 'RETURN RANDOM_TOKEN(-1)');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH.code, 'RETURN RANDOM_TOKEN(-10)');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH.code, 'RETURN RANDOM_TOKEN(0)');
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH.code, 'RETURN RANDOM_TOKEN(65537)');
var actual = getQueryResults('FOR i IN [ 1, 10, 100, 1000 ] RETURN RANDOM_TOKEN(i)');
assertEqual(4, actual.length);
assertEqual(1, actual[0].length);
assertEqual(10, actual[1].length);
assertEqual(100, actual[2].length);
assertEqual(1000, actual[3].length);
}
};
}
// //////////////////////////////////////////////////////////////////////////////
// / @brief executes the test suite
// //////////////////////////////////////////////////////////////////////////////
jsunity.run(ahuacatlStringFunctionsTestSuite);
return jsunity.done();
Reference in New Issue View Git Blame Copy Permalink