mirror of https://gitee.com/bigwinds/arangodb
1923 lines
112 KiB
JavaScript
1923 lines
112 KiB
JavaScript
/*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 assertQueryWarningAndFalse = helper.assertQueryWarningAndFalse;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function ahuacatlStringFunctionsTestSuite () {
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown : function () {
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @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\")");
|
|
|
|
assertQueryWarningAndFalse(errors.ERROR_QUERY_INVALID_REGEX.code, "RETURN REGEX_TEST(\"test\", \"[\")");
|
|
assertQueryWarningAndFalse(errors.ERROR_QUERY_INVALID_REGEX.code, "RETURN REGEX_TEST(\"test\", \"[^\")");
|
|
assertQueryWarningAndFalse(errors.ERROR_QUERY_INVALID_REGEX.code, "RETURN REGEX_TEST(\"test\", \"a.(\")");
|
|
assertQueryWarningAndFalse(errors.ERROR_QUERY_INVALID_REGEX.code, "RETURN REGEX_TEST(\"test\", \"(a\")");
|
|
assertQueryWarningAndFalse(errors.ERROR_QUERY_INVALID_REGEX.code, "RETURN REGEX_TEST(\"test\", \"(a]\")");
|
|
assertQueryWarningAndFalse(errors.ERROR_QUERY_INVALID_REGEX.code, "RETURN REGEX_TEST(\"test\", \"**\")");
|
|
assertQueryWarningAndFalse(errors.ERROR_QUERY_INVALID_REGEX.code, "RETURN REGEX_TEST(\"test\", \"?\")");
|
|
assertQueryWarningAndFalse(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 NOOPT(V8(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 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 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, 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}))`;
|
|
case 2:
|
|
return `RETURN NOOPT(V8(CONTAINS(${input})))`;
|
|
default:
|
|
assertTrue(false, "Undefined state");
|
|
}
|
|
};
|
|
for (var i = 0; i < 3; ++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 tear 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);
|
|
|
|
actual = getQueryResults("RETURN NOOPT(V8(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);
|
|
|
|
actual = getQueryResults("RETURN NOOPT(V8(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);
|
|
|
|
actual = getQueryResults("RETURN NOOPT(V8(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);
|
|
|
|
actual = getQueryResults("RETURN NOOPT(V8(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);
|
|
|
|
actual = getQueryResults("RETURN NOOPT(V8(CONTAINS(\"\", \"test123\")))");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear contains indexed
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testContainsIndexed : function () {
|
|
var buildQuery = function(nr, input) {
|
|
switch (nr) {
|
|
case 0:
|
|
return `RETURN CONTAINS(${input})`;
|
|
case 1:
|
|
return `RETURN NOOPT(CONTAINS(${input}))`;
|
|
case 2:
|
|
return `RETURN NOOPT(V8(CONTAINS(${input})))`;
|
|
default:
|
|
assertTrue(false, "Undefined state");
|
|
}
|
|
};
|
|
for (var i = 0; i < 3; ++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);
|
|
|
|
actual = getQueryResults("RETURN NOOPT(V8(CONTAINS(" + JSON.stringify(value) + ", 'foobar', false)))");
|
|
assertEqual([ false ], actual);
|
|
|
|
actual = getQueryResults("RETURN NOOPT(V8(CONTAINS(" + JSON.stringify(value) + ", " + JSON.stringify(value) + ", false)))");
|
|
assertEqual([ true ], actual);
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test left function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testLeft : function () {
|
|
var expected = [ 'fo', 'f', '', 'foo', 'foo', '', '', '', 'mö', 'mötö' ];
|
|
var actual = getQueryResults("FOR t IN [ [ 'foo', 2 ], [ 'foo', 1 ], [ 'foo', 0 ], [ 'foo', 4 ], [ 'foo', 999999999 ], [ '', 0 ], [ '', 1 ], [ '', 2 ], [ 'mötör', 2 ], [ 'mötör', 4 ] ] RETURN LEFT(t[0], t[1])");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test left function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testLeftInvalid : function () {
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN LEFT()");
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN LEFT('foo')");
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN LEFT('foo', 2, 3)");
|
|
assertEqual([ "" ], getQueryResults("RETURN LEFT(null, 1)"));
|
|
assertEqual([ "" ], getQueryResults("RETURN LEFT(null, 2)"));
|
|
assertEqual([ "tr" ], getQueryResults("RETURN LEFT(true, 2)"));
|
|
assertEqual([ "4" ], getQueryResults("RETURN LEFT(4, 2)"));
|
|
assertEqual([ "[]" ], getQueryResults("RETURN LEFT([ ], 2)"));
|
|
assertEqual([ "[" ], getQueryResults("RETURN LEFT([ ], 1)"));
|
|
assertEqual([ "{}" ], getQueryResults("RETURN LEFT({ }, 2)"));
|
|
assertEqual([ "{" ], getQueryResults("RETURN LEFT({ }, 1)"));
|
|
assertEqual([ "" ], getQueryResults("RETURN LEFT('foo', null)"));
|
|
assertEqual([ "f" ], getQueryResults("RETURN LEFT('foo', true)"));
|
|
assertEqual([ "" ], getQueryResults("RETURN LEFT('foo', 'bar')"));
|
|
assertEqual([ "" ], getQueryResults("RETURN LEFT('foo', [ ])"));
|
|
assertEqual([ "" ], getQueryResults("RETURN LEFT('foo', { })"));
|
|
assertEqual([ "" ], getQueryResults("RETURN LEFT('foo', -1)"));
|
|
assertEqual([ "" ], getQueryResults("RETURN LEFT('foo', -1.5)"));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test right function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRight : function () {
|
|
var expected = [ 'oo', 'o', '', 'foo', 'foo', '', '', '', 'ör', 'ötör' ];
|
|
var actual = getQueryResults("FOR t IN [ [ 'foo', 2 ], [ 'foo', 1 ], [ 'foo', 0 ], [ 'foo', 4 ], [ 'foo', 999999999 ], [ '', 0 ], [ '', 1 ], [ '', 2 ], [ 'mötör', 2 ], [ 'mötör', 4 ] ] RETURN RIGHT(t[0], t[1])");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test left function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRightInvalid : function () {
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN RIGHT()");
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN RIGHT('foo')");
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN RIGHT('foo', 2, 3)");
|
|
assertEqual([ "" ], getQueryResults("RETURN RIGHT(null, 1)"));
|
|
assertEqual([ "" ], getQueryResults("RETURN RIGHT(null, 2)"));
|
|
assertEqual([ "ue" ], getQueryResults("RETURN RIGHT(true, 2)"));
|
|
assertEqual([ "4" ], getQueryResults("RETURN RIGHT(4, 2)"));
|
|
assertEqual([ "[]" ], getQueryResults("RETURN RIGHT([ ], 2)"));
|
|
assertEqual([ "]" ], getQueryResults("RETURN RIGHT([ ], 1)"));
|
|
assertEqual([ "{}" ], getQueryResults("RETURN RIGHT({ }, 2)"));
|
|
assertEqual([ "}" ], getQueryResults("RETURN RIGHT({ }, 1)"));
|
|
assertEqual([ "" ], getQueryResults("RETURN RIGHT('foo', null)"));
|
|
assertEqual([ "o" ], getQueryResults("RETURN RIGHT('foo', true)"));
|
|
assertEqual([ "" ], getQueryResults("RETURN RIGHT('foo', 'bar')"));
|
|
assertEqual([ "" ], getQueryResults("RETURN RIGHT('foo', [ ])"));
|
|
assertEqual([ "" ], getQueryResults("RETURN RIGHT('foo', { })"));
|
|
assertEqual([ "" ], getQueryResults("RETURN RIGHT('foo', -1)"));
|
|
assertEqual([ "" ], getQueryResults("RETURN 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 ],
|
|
[ "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 ],
|
|
[ "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], args = [ ],i, n = value.length;
|
|
for (i = 1; i < n; ++i) {
|
|
args.push(JSON.stringify(value[i]));
|
|
}
|
|
assertEqual([ expected ], getQueryResults("RETURN SUBSTITUTE(" + args.join(", ") + ")"), 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", "" ]
|
|
];
|
|
|
|
values.forEach(function(value) {
|
|
var expected = value[0], text = value[1], separator = value[2];
|
|
assertEqual([ expected ], getQueryResults("RETURN SPLIT(" + JSON.stringify(text) + ", " + JSON.stringify(separator) + ")"), 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];
|
|
assertEqual([ expected ], getQueryResults("RETURN SPLIT(" + JSON.stringify(text) + ", " + JSON.stringify(separator) + ", " + JSON.stringify(limit) + ")"));
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @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 () {
|
|
var expected = [ 'foo', 'foo ', ' foo', '', '', '', 'abc', 'abc\n\r\t', '\t\r\nabc', 'a\rb\nc', 'a\rb\nc ', '\ta\rb\nc' ];
|
|
var actual = 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 TRIM(t[0], t[1])");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test trim function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testTrimSpecial : function () {
|
|
var expected = [ 'foo', ' foo ', '', 'abc', '\t\r\nabc\n\r\t', '\r\nabc\t\r', 'a\rb\n', '\rb\n', '\ta\rb' ];
|
|
var actual = 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 TRIM(t[0], t[1])");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test trim function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testTrimInvalid : function () {
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN TRIM()");
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN TRIM('foo', 2, 2)");
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN LTRIM('foo', 2, 2)");
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN LTRIM()");
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN RTRIM('foo', 2, 2)");
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN RTRIM()");
|
|
|
|
assertEqual([ "" ], getQueryResults("RETURN TRIM(null)"));
|
|
assertEqual([ "true" ], getQueryResults("RETURN TRIM(true)"));
|
|
assertEqual([ "4" ], getQueryResults("RETURN TRIM(4)"));
|
|
assertEqual([ "[]" ], getQueryResults("RETURN TRIM([ ])"));
|
|
assertEqual([ "{}" ], getQueryResults("RETURN TRIM({ })"));
|
|
assertEqual([ "foo" ], getQueryResults("RETURN TRIM('foo', null)"));
|
|
assertEqual([ "foo" ], getQueryResults("RETURN TRIM('foo', true)"));
|
|
assertEqual([ "foo" ], getQueryResults("RETURN TRIM('foo', 'bar')"));
|
|
assertEqual([ "foo" ], getQueryResults("RETURN TRIM('foo', [ ])"));
|
|
assertEqual([ "foo" ], getQueryResults("RETURN TRIM('foo', { })"));
|
|
assertEqual([ "foo" ], getQueryResults("RETURN TRIM('foo', -1)"));
|
|
assertEqual([ "foo" ], getQueryResults("RETURN TRIM('foo', -1.5)"));
|
|
assertEqual([ "foo" ], getQueryResults("RETURN TRIM('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 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 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 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 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 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 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 FIND_FIRST('', " + JSON.stringify(v) + ")");
|
|
assertEqual([ -1 ], actual);
|
|
});
|
|
|
|
var actual = getQueryResults("RETURN FIND_FIRST('', '')");
|
|
assertEqual([ 0 ], actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test find_first function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFindFirstEmpty2 : function () {
|
|
[ 'foo', 'bar', 'baz', 'FOO', 'BAR', 'true', ' ', '' ].forEach(function(v) {
|
|
var actual = getQueryResults("RETURN 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' ]
|
|
].forEach(function(v) {
|
|
var actual = getQueryResults("RETURN 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 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 FIND_FIRST()");
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN FIND_FIRST('foo')");
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN FIND_FIRST('foo', 'bar', 2, 2, 2)");
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_FIRST(null, 'foo')"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_FIRST(true, 'foo')"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_FIRST(4, 'foo')"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_FIRST([], 'foo')"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_FIRST([ ], 'foo')"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_FIRST({}, 'foo')"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_FIRST({ }, 'foo')"));
|
|
assertEqual([ 0 ], getQueryResults("RETURN FIND_FIRST('foo', null)"));
|
|
assertEqual([ 0 ], getQueryResults("RETURN FIND_FIRST('foo', '')"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_FIRST('foo', true)"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_FIRST('foo', [])"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_FIRST('foo', [1,2])"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_FIRST('foo', { })"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_FIRST('foo', -1)"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_FIRST('foo', -1.5)"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_FIRST('foo', 3)"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_FIRST('foo', 'bar', 'baz')"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_FIRST('foo', 'bar', 1, 'bar')"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_FIRST('foo', 'bar', -1)"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_FIRST('foo', 'bar', 1, -1)"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN 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 FIND_LAST('', " + JSON.stringify(v) + ")");
|
|
assertEqual([ -1 ], actual);
|
|
});
|
|
|
|
var actual = getQueryResults("RETURN FIND_LAST('', '')");
|
|
assertEqual([ 0 ], actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test find_last function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFindLastEmpty2 : function () {
|
|
[ 'foo', 'bar', 'baz', 'FOO', 'BAR', 'true', ' ', '' ].forEach(function(v) {
|
|
var actual = getQueryResults("RETURN 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' ]
|
|
].forEach(function(v) {
|
|
var actual = getQueryResults("RETURN 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 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 FIND_LAST()");
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN FIND_LAST('foo')");
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN FIND_LAST('foo', 'bar', 2, 2, 2)");
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_LAST(null, 'foo')"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_LAST(true, 'foo')"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_LAST(4, 'foo')"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_LAST([ ], 'foo')"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_LAST({ }, 'foo')"));
|
|
assertEqual([ 3 ], getQueryResults("RETURN FIND_LAST('foo', null)"));
|
|
assertEqual([ 3 ], getQueryResults("RETURN FIND_LAST('foo', '')"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_LAST('foo', true)"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_LAST('foo', [ ])"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_LAST('foo', { })"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_LAST('foo', -1)"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_LAST('foo', -1.5)"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_LAST('foo', 3)"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_LAST('foo', 'bar', 'baz')"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_LAST('foo', 'bar', 1, 'bar')"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_LAST('foo', 'bar', -1)"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN FIND_LAST('foo', 'bar', 1, -1)"));
|
|
assertEqual([ -1 ], getQueryResults("RETURN 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 : function () {
|
|
var expected = [ 13 ];
|
|
var actual = getQueryResults("FOR r IN [ 1 ] return CHAR_LENGTH('the quick fox')");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test charlength function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCharLength2 : function () {
|
|
var expected = [ 7 ];
|
|
var actual = getQueryResults("FOR r IN [ 1 ] return CHAR_LENGTH('äöüÄÖÜß')");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test charlength function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCharLength3 : function () {
|
|
var expected = [ 10 ];
|
|
var actual = getQueryResults("FOR r IN [ 1 ] return CHAR_LENGTH('アボカド名称について')");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test charlength function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCharLengthInvalid : function () {
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN CHAR_LENGTH()");
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN CHAR_LENGTH(\"yes\", \"yes\")");
|
|
assertEqual([ 0 ], getQueryResults("RETURN CHAR_LENGTH(null)"));
|
|
assertEqual([ 4 ], getQueryResults("RETURN CHAR_LENGTH(true)"));
|
|
assertEqual([ 1 ], getQueryResults("RETURN CHAR_LENGTH(3)"));
|
|
assertEqual([ 2 ], getQueryResults("RETURN CHAR_LENGTH([ ])"));
|
|
assertEqual([ 7 ], getQueryResults("RETURN CHAR_LENGTH([ 1, 2, 3 ])"));
|
|
assertEqual([ 2 ], getQueryResults("RETURN CHAR_LENGTH({ })"));
|
|
assertEqual([ 7 ], getQueryResults("RETURN CHAR_LENGTH({ a:1 })"));
|
|
assertEqual([ 11 ], getQueryResults("RETURN CHAR_LENGTH({ a: \"foo\" })"));
|
|
assertEqual([ 13 ], getQueryResults("RETURN CHAR_LENGTH({ a:1, b: 2 })"));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test lower function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testLower1 : function () {
|
|
var expected = [ "the quick brown fox jumped" ];
|
|
var actual = getQueryResults("FOR r IN [ 1 ] return LOWER('THE quick Brown foX JuMpED')");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test lower function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testLower2 : function () {
|
|
var expected = [ "äöüäöüß アボカド名称について" ];
|
|
var actual = getQueryResults("FOR r IN [ 1 ] return LOWER('äöüÄÖÜß アボカド名称について')");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test lower function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testLower3 : function () {
|
|
var expected = [ "0123456789<>|,;.:-_#'+*@!\"$&/(){[]}?\\" ];
|
|
var actual = getQueryResults("FOR r IN [ 1 ] return LOWER('0123456789<>|,;.:-_#\\'+*@!\\\"$&/(){[]}?\\\\')");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test lower function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testLowerInvalid : function () {
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN LOWER()");
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN LOWER(\"yes\", \"yes\")");
|
|
assertEqual([ "" ], getQueryResults("RETURN LOWER(null)"));
|
|
assertEqual([ "true" ], getQueryResults("RETURN LOWER(true)"));
|
|
assertEqual([ "3" ], getQueryResults("RETURN LOWER(3)"));
|
|
assertEqual([ "[]" ], getQueryResults("RETURN LOWER([])"));
|
|
assertEqual([ "[1,2,3]" ], getQueryResults("RETURN LOWER([1,2,3])"));
|
|
assertEqual([ "{}" ], getQueryResults("RETURN LOWER({})"));
|
|
assertEqual([ "{\"a\":1,\"b\":2}" ], getQueryResults("RETURN LOWER({A:1,b:2})"));
|
|
assertEqual([ "{\"a\":1,\"a\":2,\"b\":3}" ], getQueryResults("RETURN LOWER({A:1,a:2,b:3})"));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test upper function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUpper1 : function () {
|
|
var expected = [ "THE QUICK BROWN FOX JUMPED" ];
|
|
var actual = getQueryResults("FOR r IN [ 1 ] return UPPER('THE quick Brown foX JuMpED')");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test upper function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUpper2 : function () {
|
|
var expected = [ "ÄÖÜÄÖÜSS アボカド名称について" ];
|
|
var actual = getQueryResults("FOR r IN [ 1 ] return UPPER('äöüÄÖÜß アボカド名称について')");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test upper function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUpperInvalid : function () {
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN UPPER()");
|
|
assertQueryError(errors.ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH.code, "RETURN UPPER(\"yes\", \"yes\")");
|
|
assertEqual([ "" ], getQueryResults("RETURN UPPER(null)"));
|
|
assertEqual([ "TRUE" ], getQueryResults("RETURN UPPER(true)"));
|
|
assertEqual([ "3" ], getQueryResults("RETURN UPPER(3)"));
|
|
assertEqual([ "[]" ], getQueryResults("RETURN UPPER([])"));
|
|
assertEqual([ "[1,2,3]" ], getQueryResults("RETURN UPPER([1,2,3])"));
|
|
assertEqual([ "{}" ], getQueryResults("RETURN UPPER({})"));
|
|
assertEqual([ "{\"A\":1,\"B\":2}" ], getQueryResults("RETURN UPPER({a:1, b:2})"));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test substring function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testSubstring1 : function () {
|
|
var expected = [ "the" ];
|
|
var actual = getQueryResults("FOR r IN [ 1 ] return SUBSTRING('the quick brown fox', 0, 3)");
|
|
assertEqual(expected, actual);
|
|
|
|
actual = getQueryResults("FOR r IN [ 1 ] return NOOPT(SUBSTRING('the quick brown fox', 0, 3))");
|
|
assertEqual(expected, actual);
|
|
|
|
actual = getQueryResults("FOR r IN [ 1 ] return NOOPT(V8(SUBSTRING('the quick brown fox', 0, 3)))");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test substring function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testSubstring2 : function () {
|
|
var expected = [ "quick" ];
|
|
var actual = getQueryResults("FOR r IN [ 1 ] return SUBSTRING('the quick brown fox', 4, 5)");
|
|
assertEqual(expected, actual);
|
|
|
|
actual = getQueryResults("FOR r IN [ 1 ] return NOOPT(SUBSTRING('the quick brown fox', 4, 5))");
|
|
assertEqual(expected, actual);
|
|
|
|
actual = getQueryResults("FOR r IN [ 1 ] return NOOPT(V8(SUBSTRING('the quick brown fox', 4, 5)))");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test substring function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testSubstring3 : function () {
|
|
var expected = [ "fox" ];
|
|
var actual = getQueryResults("FOR r IN [ 1 ] return SUBSTRING('the quick brown fox', -3)");
|
|
assertEqual(expected, actual);
|
|
|
|
actual = getQueryResults("FOR r IN [ 1 ] return NOOPT(SUBSTRING('the quick brown fox', -3))");
|
|
assertEqual(expected, actual);
|
|
|
|
actual = getQueryResults("FOR r IN [ 1 ] return NOOPT(V8(SUBSTRING('the quick brown fox', -3)))");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @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}))`;
|
|
case 2:
|
|
return `RETURN NOOPT(V8(SUBSTRING(${input})))`;
|
|
default:
|
|
assertTrue(false, "Undefined state");
|
|
}
|
|
};
|
|
for (var i = 0; i < 3; ++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}))`;
|
|
case 2:
|
|
return `RETURN NOOPT(V8(HASH(${input})))`;
|
|
default:
|
|
assertTrue(false, "Undefined state");
|
|
}
|
|
};
|
|
var i;
|
|
for (i = 0; i < 3; ++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 < 3; ++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 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();
|
|
|