diff --git a/js/server/aql-operators.js b/js/server/aql-operators.js new file mode 100644 index 0000000000..e4dc7cce43 --- /dev/null +++ b/js/server/aql-operators.js @@ -0,0 +1,758 @@ +//////////////////////////////////////////////////////////////////////////////// +/// @brief AQL query language operators (internal use only) +/// +/// @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 AQL_TYPEWEIGHT_UNDEFINED = 0; +var AQL_TYPEWEIGHT_NULL = 1; +var AQL_TYPEWEIGHT_BOOL = 2; +var AQL_TYPEWEIGHT_NUMBER = 3; +var AQL_TYPEWEIGHT_STRING = 4; +var AQL_TYPEWEIGHT_ARRAY = 5; +var AQL_TYPEWEIGHT_OBJECT = 6; + +//////////////////////////////////////////////////////////////////////////////// +/// @brief get the sort type of an operand +//////////////////////////////////////////////////////////////////////////////// + +function AQL_TYPEWEIGHT (lhs) { + if (lhs === undefined) { + return AQL_TYPEWEIGHT_UNDEFINED; + } + + if (lhs === null) { + return AQL_TYPEWEIGHT_NULL; + } + + if (lhs instanceof Array) { + return AQL_TYPEWEIGHT_ARRAY; + } + + switch (typeof(lhs)) { + case 'boolean': + return AQL_TYPEWEIGHT_BOOL; + case 'number': + if (isNaN(lhs) || !isFinite(lhs)) { + // not a number => undefined + return AQL_TYPEWEIGHT_UNDEFINED; + } + return AQL_TYPEWEIGHT_NUMBER; + case 'string': + return AQL_TYPEWEIGHT_STRING; + case 'object': + return AQL_TYPEWEIGHT_OBJECT; + default: + return AQL_TYPEWEIGHT_UNDEFINED; + } +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief get the keys of an array or object in a comparable way +//////////////////////////////////////////////////////////////////////////////// + +function AQL_KEYS (lhs) { + var keys = []; + + if (lhs instanceof Array) { + var i = 0; + for (var k in lhs) { + if (lhs.hasOwnProperty(k)) { + keys.push(i++); + } + } + } + else { + for (var k in lhs) { + if (lhs.hasOwnProperty(k)) { + keys.push(k); + } + } + + // object keys need to be sorted by names + keys.sort(); + } + + return keys; +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief perform logical and +//////////////////////////////////////////////////////////////////////////////// + +function AQL_LOGICAL_AND (lhs, rhs) { + // lhs && rhs: both operands must be bools, returns a bool or undefined + if (AQL_TYPEWEIGHT(lhs) !== AQL_TYPEWEIGHT_BOOL || + AQL_TYPEWEIGHT(rhs) !== AQL_TYPEWEIGHT_BOOL) { + return undefined; + } + + return (lhs && rhs); +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief perform logical or +//////////////////////////////////////////////////////////////////////////////// + +function AQL_LOGICAL_OR (lhs, rhs) { + // lhs || rhs: both operands must be bools, returns a bool or undefined + if (AQL_TYPEWEIGHT(lhs) !== AQL_TYPEWEIGHT_BOOL || + AQL_TYPEWEIGHT(rhs) !== AQL_TYPEWEIGHT_BOOL) { + return undefined; + } + + return (lhs || rhs); +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief perform logical negation +//////////////////////////////////////////////////////////////////////////////// + +function AQL_LOGICAL_NOT (lhs) { + // !lhs: operand must be bool, returns a bool or undefined + if (AQL_TYPEWEIGHT(lhs) !== AQL_TYPEWEIGHT_BOOL) { + return undefined; + } + + return !lhs; +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief perform equality check +//////////////////////////////////////////////////////////////////////////////// + +function AQL_RELATIONAL_EQUAL (lhs, rhs) { + // determines if two values are the same, returns a bool or undefined + var leftWeight = AQL_TYPEWEIGHT(lhs); + var rightWeight = AQL_TYPEWEIGHT(rhs); + + if (leftWeight === AQL_TYPEWEIGHT_UNDEFINED || + rightWeight === AQL_TYPEWEIGHT_UNDEFINED) { + return undefined; + } + + if (leftWeight != rightWeight) { + return false; + } + + // lhs and rhs have the same type + + if (leftWeight >= AQL_TYPEWEIGHT_ARRAY) { + // arrays and objects + var l = AQL_KEYS(lhs); + var r = AQL_KEYS(rhs); + var numLeft = l.length; + var numRight = r.length; + + if (numLeft !== numRight) { + return false; + } + + for (var i = 0; i < numLeft; ++i) { + var key = l[i]; + if (key !== r[i]) { + // keys must be identical + return false; + } + + var result = AQL_RELATIONAL_EQUAL(lhs[key], rhs[key]); + if (result === undefined || result === false) { + return result; + } + } + return true; + } + + // primitive type + return (lhs === rhs); +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief perform unequality check +//////////////////////////////////////////////////////////////////////////////// + +function AQL_RELATIONAL_UNEQUAL (lhs, rhs) { + // determines if two values are not the same, returns a bool or undefined + var leftWeight = AQL_TYPEWEIGHT(lhs); + var rightWeight = AQL_TYPEWEIGHT(rhs); + + if (leftWeight === AQL_TYPEWEIGHT_UNDEFINED || + rightWeight === AQL_TYPEWEIGHT_UNDEFINED) { + return undefined; + } + + if (leftWeight != rightWeight) { + return true; + } + + // lhs and rhs have the same type + + if (leftWeight >= AQL_TYPEWEIGHT_ARRAY) { + // arrays and objects + var l = AQL_KEYS(lhs); + var r = AQL_KEYS(rhs); + var numLeft = l.length; + var numRight = r.length; + + if (numLeft !== numRight) { + return true; + } + + for (var i = 0; i < numLeft; ++i) { + var key = l[i]; + if (key !== r[i]) { + // keys differ => unequality + return true; + } + + var result = AQL_RELATIONAL_UNEQUAL(lhs[key], rhs[key]); + if (result === undefined || result === true) { + return result; + } + } + return false; + } + + // primitive type + return (lhs !== rhs); +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief perform greater than check (inner function) +//////////////////////////////////////////////////////////////////////////////// + +function AQL_RELATIONAL_GREATER_REC (lhs, rhs) { + // determines if lhs is greater than rhs, returns a bool or undefined + var leftWeight = AQL_TYPEWEIGHT(lhs); + var rightWeight = AQL_TYPEWEIGHT(rhs); + + if (leftWeight === AQL_TYPEWEIGHT_UNDEFINED || + rightWeight === AQL_TYPEWEIGHT_UNDEFINED) { + return undefined; + } + + if (leftWeight > rightWeight) { + return true; + } + if (leftWeight < rightWeight) { + return false; + } + + // lhs and rhs have the same type + + if (leftWeight >= AQL_TYPEWEIGHT_ARRAY) { + // arrays and objects + var l = AQL_KEYS(lhs); + var r = AQL_KEYS(rhs); + var numLeft = l.length; + var numRight = r.length; + + for (var i = 0; i < numLeft; ++i) { + if (i >= numRight) { + // right operand does not have any more keys + return true; + } + var key = l[i]; + if (key < r[i]) { + // left key is less than right key + return false; + } + else if (key > r[i]) { + // left key is bigger than right key + return true; + } + + var result = AQL_RELATIONAL_GREATER_REC(lhs[i], rhs[i]); + if (result !== null) { + return result; + } + } + return null; + } + + // primitive type + if (lhs === rhs) { + return null; + } + return (lhs > rhs); +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief perform greater than check +//////////////////////////////////////////////////////////////////////////////// + +function AQL_RELATIONAL_GREATER (lhs, rhs) { + var result = AQL_RELATIONAL_GREATER_REC(lhs, rhs); + + if (result === null) { + result = false; + } + + return result; +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief perform greater equal check +//////////////////////////////////////////////////////////////////////////////// + +function AQL_RELATIONAL_GREATEREQUAL (lhs, rhs) { + // determines if lhs is greater or equal to rhs, returns a bool or undefined + var leftWeight = AQL_TYPEWEIGHT(lhs); + var rightWeight = AQL_TYPEWEIGHT(rhs); + + if (leftWeight === AQL_TYPEWEIGHT_UNDEFINED || + rightWeight === AQL_TYPEWEIGHT_UNDEFINED) { + return undefined; + } + + if (leftWeight > rightWeight) { + return true; + } + if (leftWeight < rightWeight) { + return false; + } + + // lhs and rhs have the same type + + if (leftWeight >= AQL_TYPEWEIGHT_ARRAY) { + // arrays and objects + var l = AQL_KEYS(lhs); + var r = AQL_KEYS(rhs); + var numLeft = l.length; + var numRight = r.length; + + for (var i = 0; i < numLeft; ++i) { + if (i >= numRight) { + return true; + } + var result = AQL_RELATIONAL_GREATEREQUAL(lhs[i], rhs[i]); + if (result === undefined || result === false) { + return result; + } + } + return true; + } + + // primitive type + return (lhs >= rhs); +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief perform less than check (inner function) +//////////////////////////////////////////////////////////////////////////////// + +function AQL_RELATIONAL_LESS_REC (lhs, rhs) { + // determines if lhs is less than rhs, returns a bool or undefined + var leftWeight = AQL_TYPEWEIGHT(lhs); + var rightWeight = AQL_TYPEWEIGHT(rhs); + + if (leftWeight === AQL_TYPEWEIGHT_UNDEFINED || + rightWeight === AQL_TYPEWEIGHT_UNDEFINED) { + return undefined; + } + + if (leftWeight < rightWeight) { + return true; + } + if (leftWeight > rightWeight) { + return false; + } + + // lhs and rhs have the same type + + if (leftWeight >= AQL_TYPEWEIGHT_ARRAY) { + // arrays and objects + var l = AQL_KEYS(lhs); + var r = AQL_KEYS(rhs); + var numLeft = l.length; + var numRight = r.length; + + for (var i = 0; i < numRight; ++i) { + if (i >= numLeft) { + // left operand does not have any more keys + return true; + } + var key = l[i]; + if (key < r[i]) { + // left key is less than right key + return true; + } + else if (key > r[i]) { + // left key is bigger than right key + return false; + } + var result = AQL_RELATIONAL_LESS_REC(lhs[key], rhs[key]); + if (result !== null) { + return result; + } + } + return null; + } + + // primitive type + if (lhs === rhs) { + return null; + } + return (lhs < rhs); +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief perform less than check +//////////////////////////////////////////////////////////////////////////////// + +function AQL_RELATIONAL_LESS (lhs, rhs) { + var result = AQL_RELATIONAL_LESS_REC(lhs, rhs); + + if (result === null) { + result = false; + } + + return result; +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief perform less equal check +//////////////////////////////////////////////////////////////////////////////// + +function AQL_RELATIONAL_LESSEQUAL (lhs, rhs) { + // determines if lhs is less or equal to rhs, returns a bool or undefined + var leftWeight = AQL_TYPEWEIGHT(lhs); + var rightWeight = AQL_TYPEWEIGHT(rhs); + + if (leftWeight === AQL_TYPEWEIGHT_UNDEFINED || + rightWeight === AQL_TYPEWEIGHT_UNDEFINED) { + return undefined; + } + + if (leftWeight < rightWeight) { + return true; + } + if (leftWeight > rightWeight) { + return false; + } + + // lhs and rhs have the same type + + if (leftWeight >= AQL_TYPEWEIGHT_ARRAY) { + // arrays and objects + var l = AQL_KEYS(lhs); + var r = AQL_KEYS(rhs); + var numLeft = l.length; + var numRight = r.length; + + for (var i = 0; i < numRight; ++i) { + if (i >= numLeft) { + return true; + } + var result = AQL_RELATIONAL_LESSEQUAL(lhs[i], rhs[i]); + if (result === undefined || result === false) { + return result; + } + } + return true; + } + + // primitive type + return (lhs <= rhs); +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief perform in list check +//////////////////////////////////////////////////////////////////////////////// + +function AQL_RELATIONAL_IN (lhs, rhs) { + // lhs IN rhs: both operands must have the same type, returns a bool or undefined + var leftWeight = AQL_TYPEWEIGHT(lhs); + var rightWeight = AQL_TYPEWEIGHT(rhs); + + if (leftWeight === AQL_TYPEWEIGHT_UNDEFINED || + rightWeight !== AQL_TYPEWEIGHT_ARRAY) { + return undefined; + } + + var r = AQL_KEYS(rhs); + var numRight = r.length; + + for (var i = 0; i < numRight; ++i) { + if (AQL_RELATIONAL_EQUAL(lhs, r[i])) { + return true; + } + } + + return false; +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief perform unary plus operation +//////////////////////////////////////////////////////////////////////////////// + +function AQL_UNARY_PLUS (lhs) { + // +lhs: operand must be numeric, returns a number or undefined + if (AQL_TYPEWEIGHT(lhs) !== AQL_TYPEWEIGHT_NUMBER) { + return undefined; + } + + return lhs; +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief perform unary minus operation +//////////////////////////////////////////////////////////////////////////////// + +function AQL_UNARY_MINUS (lhs) { + // -lhs: operand must be numeric, returns a number or undefined + if (AQL_TYPEWEIGHT(lhs) !== AQL_TYPEWEIGHT_NUMBER) { + return undefined; + } + + return -lhs; +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief perform artithmetic plus +//////////////////////////////////////////////////////////////////////////////// + +function AQL_ARITHMETIC_PLUS (lhs, rhs) { + // lhs + rhs: operands must be numeric, returns a number or undefined + if (AQL_TYPEWEIGHT(lhs) !== AQL_TYPEWEIGHT_NUMBER || + AQL_TYPEWEIGHT(rhs) !== AQL_TYPEWEIGHT_NUMBER) { + return undefined; + } + + return (lhs + rhs); +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief perform artithmetic minus +//////////////////////////////////////////////////////////////////////////////// + +function AQL_ARITHMETIC_MINUS (lhs, rhs) { + // lhs - rhs: operands must be numeric, returns a number or undefined + if (AQL_TYPEWEIGHT(lhs) !== AQL_TYPEWEIGHT_NUMBER || + AQL_TYPEWEIGHT(rhs) !== AQL_TYPEWEIGHT_NUMBER) { + return undefined; + } + + return (lhs - rhs); +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief perform artithmetic multiplication +//////////////////////////////////////////////////////////////////////////////// + +function AQL_ARITHMETIC_TIMES (lhs, rhs) { + // lhs * rhs: operands must be numeric, returns a number or undefined + if (AQL_TYPEWEIGHT(lhs) !== AQL_TYPEWEIGHT_NUMBER || + AQL_TYPEWEIGHT(rhs) !== AQL_TYPEWEIGHT_NUMBER) { + return undefined; + } + + return (lhs * rhs); +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief perform artithmetic division +//////////////////////////////////////////////////////////////////////////////// + +function AQL_ARITHMETIC_DIVIDE (lhs, rhs) { + // lhs / rhs: operands must be numeric, returns a number or undefined + if (AQL_TYPEWEIGHT(lhs) !== AQL_TYPEWEIGHT_NUMBER || + AQL_TYPEWEIGHT(rhs) !== AQL_TYPEWEIGHT_NUMBER || + rhs == 0) { + return undefined; + } + + return (lhs / rhs); +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief perform artithmetic modulus +//////////////////////////////////////////////////////////////////////////////// + +function AQL_ARITHMETIC_MODULUS (lhs, rhs) { + // lhs % rhs: operands must be numeric, returns a number or undefined + if (AQL_TYPEWEIGHT(lhs) !== AQL_TYPEWEIGHT_NUMBER || + AQL_TYPEWEIGHT(rhs) !== AQL_TYPEWEIGHT_NUMBER || + rhs == 0) { + return undefined; + } + + return (lhs % rhs); +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief perform string concatenation +//////////////////////////////////////////////////////////////////////////////// + +function AQL_STRING_CONCAT (lhs, rhs) { + // string concatenation of lhs and rhs: operands must be strings, returns a string or undefined + if (AQL_TYPEWEIGHT(lhs) !== AQL_TYPEWEIGHT_STRING || + AQL_TYPEWEIGHT(rhs) !== AQL_TYPEWEIGHT_STRING) { + return undefined; + } + + return (lhs + rhs); +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief cast to a number +//////////////////////////////////////////////////////////////////////////////// + +function AQL_CAST_NUMBER (lhs) { + // (number) lhs: operand can have any type, returns a number + switch (AQL_TYPEWEIGHT(lhs)) { + case AQL_TYPEWEIGHT_UNDEFINED: + case AQL_TYPEWEIGHT_NULL: + case AQL_TYPEWEIGHT_ARRAY: + case AQL_TYPEWEIGHT_OBJECT: + return 0.0; + case AQL_TYPEWEIGHT_BOOL: + return (lhs ? 1 : 0); + case AQL_TYPEWEIGHT_NUMBER: + return lhs; + case AQL_TYPEWEIGHT_STRING: + var result = parseFloat(lhs); + return ((AQL_TYPEWEIGHT(result) === AQL_TYPEWEIGHT_NUMBER) ? result : 0); + } +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief cast to a string +//////////////////////////////////////////////////////////////////////////////// + +function AQL_CAST_STRING (lhs) { + // (string) lhs: operand can have any type, returns a string + switch (AQL_TYPEWEIGHT(lhs)) { + case AQL_TYPEWEIGHT_STRING: + return lhs; + case AQL_TYPEWEIGHT_UNDEFINED: + return 'undefined'; + case AQL_TYPEWEIGHT_NULL: + return 'null'; + case AQL_TYPEWEIGHT_BOOL: + return (lhs ? 'true' : 'false'); + case AQL_TYPEWEIGHT_NUMBER: + case AQL_TYPEWEIGHT_ARRAY: + case AQL_TYPEWEIGHT_OBJECT: + return lhs.toString(); + } +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief cast to a bool +//////////////////////////////////////////////////////////////////////////////// + +function AQL_CAST_BOOL (lhs) { + // (bool) lhs: operand can have any type, returns a bool + switch (AQL_TYPEWEIGHT(lhs)) { + case AQL_TYPEWEIGHT_UNDEFINED: + case AQL_TYPEWEIGHT_NULL: + return false; + case AQL_TYPEWEIGHT_BOOL: + return lhs; + case AQL_TYPEWEIGHT_NUMBER: + return (lhs != 0); + case AQL_TYPEWEIGHT_STRING: + return (lhs != ''); + case AQL_TYPEWEIGHT_ARRAY: + return (lhs.length > 0); + case AQL_TYPEWEIGHT_OBJECT: + return (AQL_KEYS(lhs).length > 0); + } +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief cast to null +//////////////////////////////////////////////////////////////////////////////// + +function AQL_CAST_NULL (lhs) { + // (null) lhs: operand can have any type, always returns null + return null; +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief cast to undefined +//////////////////////////////////////////////////////////////////////////////// + +function AQL_CAST_UNDEFINED (lhs) { + // (null) lhs: operand can have any type, always returns undefined + return undefined; +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test if value is of type string +//////////////////////////////////////////////////////////////////////////////// + +function AQL_IS_STRING (lhs) { + return (AQL_TYPEWEIGHT(lhs) === AQL_TYPEWEIGHT_STRING); +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test if value is of type number +//////////////////////////////////////////////////////////////////////////////// + +function AQL_IS_NUMBER (lhs) { + return (AQL_TYPEWEIGHT(lhs) === AQL_TYPEWEIGHT_NUMBER); +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test if value is of type bool +//////////////////////////////////////////////////////////////////////////////// + +function AQL_IS_BOOL (lhs) { + return (AQL_TYPEWEIGHT(lhs) === AQL_TYPEWEIGHT_BOOL); +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test if value is of type null +//////////////////////////////////////////////////////////////////////////////// + +function AQL_IS_NULL (lhs) { + return (AQL_TYPEWEIGHT(lhs) === AQL_TYPEWEIGHT_NULL); +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test if value is of type undefined +//////////////////////////////////////////////////////////////////////////////// + +function AQL_IS_UNDEFINED (lhs) { + return (AQL_TYPEWEIGHT(lhs) === AQL_TYPEWEIGHT_UNDEFINED); +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test if value is of type array +//////////////////////////////////////////////////////////////////////////////// + +function AQL_IS_ARRAY (lhs) { + return (AQL_TYPEWEIGHT(lhs) === AQL_TYPEWEIGHT_ARRAY); +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test if value is of type object +//////////////////////////////////////////////////////////////////////////////// + +function AQL_IS_OBJECT (lhs) { + return (AQL_TYPEWEIGHT(lhs) === AQL_TYPEWEIGHT_OBJECT); +} + diff --git a/js/server/tests/aql-operators.js b/js/server/tests/aql-operators.js new file mode 100644 index 0000000000..b6f7ca0a6d --- /dev/null +++ b/js/server/tests/aql-operators.js @@ -0,0 +1,2122 @@ +//////////////////////////////////////////////////////////////////////////////// +/// @brief tests for AQL operators +/// +/// @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 +//////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test suite +//////////////////////////////////////////////////////////////////////////////// + +function aqlOperatorsTestSuite () { + +//////////////////////////////////////////////////////////////////////////////// +/// @brief set up +//////////////////////////////////////////////////////////////////////////////// + + function setUp () { + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief tear down +//////////////////////////////////////////////////////////////////////////////// + + function tearDown () { + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_KEYS function +//////////////////////////////////////////////////////////////////////////////// + + function testKeys () { + assertEqual([ ], AQL_KEYS([ ])); + assertEqual([ 0, 1, 2 ], AQL_KEYS([ 0, 1, 2 ])); + assertEqual([ 0, 1, 2 ], AQL_KEYS([ 1, 2, 3 ])); + assertEqual([ 0, 1, 2 ], AQL_KEYS([ 5, 6, 9 ])); + assertEqual([ 0, 1, 2 ], AQL_KEYS([ false, false, false ])); + assertEqual([ 0, 1, 2 ], AQL_KEYS([ -1, -1, 'zang' ])); + assertEqual([ 0, 1, 2, 3 ], AQL_KEYS([ 99, 99, 99, 99 ])); + assertEqual([ 0 ], AQL_KEYS([ [ ] ])); + assertEqual([ 0 ], AQL_KEYS([ [ 1 ] ])); + assertEqual([ 0, 1 ], AQL_KEYS([ [ 1 ], 1 ])); + assertEqual([ 0, 1 ], AQL_KEYS([ [ 1 ], [ 1 ] ])); + assertEqual([ 0 ], AQL_KEYS([ [ 1 , 2 ] ])); + assertEqual([ 0, 1, 2 ], AQL_KEYS([ [ 1 , 2 ], [ ], 3 ])); + assertEqual([ 0, 1, 2 ], AQL_KEYS([ { }, { }, { } ])); + assertEqual([ 0, 1, 2 ], AQL_KEYS([ { 'a' : true, 'b' : false }, { }, { } ])); + assertEqual([ ], AQL_KEYS({ })); + assertEqual([ '0' ], AQL_KEYS({ '0' : false })); + assertEqual([ '0' ], AQL_KEYS({ '0' : undefined })); + assertEqual([ 'a', 'b', 'c' ], AQL_KEYS({ 'a' : true, 'b' : true, 'c' : true })); + assertEqual([ 'a', 'b', 'c' ], AQL_KEYS({ 'a' : true, 'c' : true, 'b' : true })); + assertEqual([ 'a', 'b', 'c' ], AQL_KEYS({ 'b' : true, 'a' : true, 'c' : true })); + assertEqual([ 'a', 'b', 'c' ], AQL_KEYS({ 'b' : true, 'c' : true, 'a' : true })); + assertEqual([ 'a', 'b', 'c' ], AQL_KEYS({ 'c' : true, 'a' : true, 'b' : true })); + assertEqual([ 'a', 'b', 'c' ], AQL_KEYS({ 'c' : true, 'b' : true, 'a' : true })); + assertEqual([ '0', '1', '2' ], AQL_KEYS({ '0' : true, '1' : true, '2' : true })); + assertEqual([ '0', '1', '2' ], AQL_KEYS({ '1' : true, '2' : true, '0' : true })); + assertEqual([ 'a1', 'a2', 'a3' ], AQL_KEYS({ 'a1' : true, 'a2' : true, 'a3' : true })); + assertEqual([ 'a1', 'a10', 'a20', 'a200', 'a21' ], AQL_KEYS({ 'a200' : true, 'a21' : true, 'a20' : true, 'a10' : false, 'a1' : null })); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_IS_UNDEFINED function +//////////////////////////////////////////////////////////////////////////////// + + function testIsUndefinedTrue () { + assertTrue(AQL_IS_UNDEFINED(undefined)); + assertTrue(AQL_IS_UNDEFINED(NaN)); + assertTrue(AQL_IS_UNDEFINED(1.3e308 * 1.3e308)); + assertTrue(AQL_IS_UNDEFINED(AQL_ARITHMETIC_DIVIDE(1, 0))); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_IS_UNDEFINED function +//////////////////////////////////////////////////////////////////////////////// + + function testIsUndefinedFalse () { + assertFalse(AQL_IS_UNDEFINED(0)); + assertFalse(AQL_IS_UNDEFINED(1)); + assertFalse(AQL_IS_UNDEFINED(-1)); + assertFalse(AQL_IS_UNDEFINED(0.1)); + assertFalse(AQL_IS_UNDEFINED(-0.1)); + assertFalse(AQL_IS_UNDEFINED(false)); + assertFalse(AQL_IS_UNDEFINED(true)); + assertFalse(AQL_IS_UNDEFINED(null)); + assertFalse(AQL_IS_UNDEFINED('abc')); + assertFalse(AQL_IS_UNDEFINED('null')); + assertFalse(AQL_IS_UNDEFINED('false')); + assertFalse(AQL_IS_UNDEFINED('undefined')); + assertFalse(AQL_IS_UNDEFINED('')); + assertFalse(AQL_IS_UNDEFINED(' ')); + assertFalse(AQL_IS_UNDEFINED([ ])); + assertFalse(AQL_IS_UNDEFINED([ 0 ])); + assertFalse(AQL_IS_UNDEFINED([ 0, 1 ])); + assertFalse(AQL_IS_UNDEFINED([ 1, 2 ])); + assertFalse(AQL_IS_UNDEFINED({ })); + assertFalse(AQL_IS_UNDEFINED({ 'a' : 0 })); + assertFalse(AQL_IS_UNDEFINED({ 'a' : 1 })); + assertFalse(AQL_IS_UNDEFINED({ 'a' : 0, 'b' : 1 })); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_IS_NULL function +//////////////////////////////////////////////////////////////////////////////// + + function testIsNullTrue () { + assertTrue(AQL_IS_NULL(null)); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_IS_NULL function +//////////////////////////////////////////////////////////////////////////////// + + function testIsNullFalse () { + assertFalse(AQL_IS_NULL(0)); + assertFalse(AQL_IS_NULL(1)); + assertFalse(AQL_IS_NULL(-1)); + assertFalse(AQL_IS_NULL(0.1)); + assertFalse(AQL_IS_NULL(-0.1)); + assertFalse(AQL_IS_NULL(NaN)); + assertFalse(AQL_IS_NULL(1.3e308 * 1.3e308)); + assertFalse(AQL_IS_NULL(false)); + assertFalse(AQL_IS_NULL(true)); + assertFalse(AQL_IS_NULL(undefined)); + assertFalse(AQL_IS_NULL('abc')); + assertFalse(AQL_IS_NULL('null')); + assertFalse(AQL_IS_NULL('false')); + assertFalse(AQL_IS_NULL('undefined')); + assertFalse(AQL_IS_NULL('')); + assertFalse(AQL_IS_NULL(' ')); + assertFalse(AQL_IS_NULL([ ])); + assertFalse(AQL_IS_NULL([ 0 ])); + assertFalse(AQL_IS_NULL([ 0, 1 ])); + assertFalse(AQL_IS_NULL([ 1, 2 ])); + assertFalse(AQL_IS_NULL({ })); + assertFalse(AQL_IS_NULL({ 'a' : 0 })); + assertFalse(AQL_IS_NULL({ 'a' : 1 })); + assertFalse(AQL_IS_NULL({ 'a' : 0, 'b' : 1 })); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_IS_BOOL function +//////////////////////////////////////////////////////////////////////////////// + + function testIsBoolTrue () { + assertTrue(AQL_IS_BOOL(false)); + assertTrue(AQL_IS_BOOL(true)); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_IS_BOOL function +//////////////////////////////////////////////////////////////////////////////// + + function testIsBoolFalse () { + assertFalse(AQL_IS_BOOL(undefined)); + assertFalse(AQL_IS_BOOL(NaN)); + assertFalse(AQL_IS_BOOL(1.3e308 * 1.3e308)); + assertFalse(AQL_IS_BOOL(0)); + assertFalse(AQL_IS_BOOL(1)); + assertFalse(AQL_IS_BOOL(-1)); + assertFalse(AQL_IS_BOOL(0.1)); + assertFalse(AQL_IS_BOOL(-0.1)); + assertFalse(AQL_IS_BOOL(null)); + assertFalse(AQL_IS_BOOL('abc')); + assertFalse(AQL_IS_BOOL('null')); + assertFalse(AQL_IS_BOOL('false')); + assertFalse(AQL_IS_BOOL('undefined')); + assertFalse(AQL_IS_BOOL('')); + assertFalse(AQL_IS_BOOL(' ')); + assertFalse(AQL_IS_BOOL([ ])); + assertFalse(AQL_IS_BOOL([ 0 ])); + assertFalse(AQL_IS_BOOL([ 0, 1 ])); + assertFalse(AQL_IS_BOOL([ 1, 2 ])); + assertFalse(AQL_IS_BOOL([ '' ])); + assertFalse(AQL_IS_BOOL([ '0' ])); + assertFalse(AQL_IS_BOOL([ '1' ])); + assertFalse(AQL_IS_BOOL([ true ])); + assertFalse(AQL_IS_BOOL([ false ])); + assertFalse(AQL_IS_BOOL({ })); + assertFalse(AQL_IS_BOOL({ 'a' : 0 })); + assertFalse(AQL_IS_BOOL({ 'a' : 1 })); + assertFalse(AQL_IS_BOOL({ 'a' : 0, 'b' : 1 })); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_IS_NUMBER function +//////////////////////////////////////////////////////////////////////////////// + + function testIsNumberTrue () { + assertTrue(AQL_IS_NUMBER(0)); + assertTrue(AQL_IS_NUMBER(1)); + assertTrue(AQL_IS_NUMBER(-1)); + assertTrue(AQL_IS_NUMBER(0.1)); + assertTrue(AQL_IS_NUMBER(-0.1)); + assertTrue(AQL_IS_NUMBER(12.5356)); + assertTrue(AQL_IS_NUMBER(-235.26436)); + assertTrue(AQL_IS_NUMBER(-23.3e17)); + assertTrue(AQL_IS_NUMBER(563.44576e19)); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_IS_NUMBER function +//////////////////////////////////////////////////////////////////////////////// + + function testIsNumberFalse () { + assertFalse(AQL_IS_NUMBER(false)); + assertFalse(AQL_IS_NUMBER(true)); + assertFalse(AQL_IS_NUMBER(undefined)); + assertFalse(AQL_IS_NUMBER(NaN)); + assertFalse(AQL_IS_NUMBER(1.3e308 * 1.3e308)); + assertFalse(AQL_IS_NUMBER(null)); + assertFalse(AQL_IS_NUMBER('abc')); + assertFalse(AQL_IS_NUMBER('null')); + assertFalse(AQL_IS_NUMBER('false')); + assertFalse(AQL_IS_NUMBER('undefined')); + assertFalse(AQL_IS_NUMBER('')); + assertFalse(AQL_IS_NUMBER(' ')); + assertFalse(AQL_IS_NUMBER([ ])); + assertFalse(AQL_IS_NUMBER([ 0 ])); + assertFalse(AQL_IS_NUMBER([ 0, 1 ])); + assertFalse(AQL_IS_NUMBER([ 1, 2 ])); + assertFalse(AQL_IS_NUMBER([ '' ])); + assertFalse(AQL_IS_NUMBER([ '0' ])); + assertFalse(AQL_IS_NUMBER([ '1' ])); + assertFalse(AQL_IS_NUMBER([ true ])); + assertFalse(AQL_IS_NUMBER([ false ])); + assertFalse(AQL_IS_NUMBER({ })); + assertFalse(AQL_IS_NUMBER({ 'a' : 0 })); + assertFalse(AQL_IS_NUMBER({ 'a' : 1 })); + assertFalse(AQL_IS_NUMBER({ 'a' : 0, 'b' : 1 })); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_IS_STRING function +//////////////////////////////////////////////////////////////////////////////// + + function testIsStringTrue () { + assertTrue(AQL_IS_STRING('abc')); + assertTrue(AQL_IS_STRING('null')); + assertTrue(AQL_IS_STRING('false')); + assertTrue(AQL_IS_STRING('undefined')); + assertTrue(AQL_IS_STRING('')); + assertTrue(AQL_IS_STRING(' ')); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_IS_STRING function +//////////////////////////////////////////////////////////////////////////////// + + function testIsStringFalse () { + assertFalse(AQL_IS_STRING(false)); + assertFalse(AQL_IS_STRING(true)); + assertFalse(AQL_IS_STRING(undefined)); + assertFalse(AQL_IS_STRING(NaN)); + assertFalse(AQL_IS_STRING(1.3e308 * 1.3e308)); + assertFalse(AQL_IS_STRING(0)); + assertFalse(AQL_IS_STRING(1)); + assertFalse(AQL_IS_STRING(-1)); + assertFalse(AQL_IS_STRING(0.1)); + assertFalse(AQL_IS_STRING(-0.1)); + assertFalse(AQL_IS_STRING(null)); + assertFalse(AQL_IS_STRING([ ])); + assertFalse(AQL_IS_STRING([ 0 ])); + assertFalse(AQL_IS_STRING([ 0, 1 ])); + assertFalse(AQL_IS_STRING([ 1, 2 ])); + assertFalse(AQL_IS_STRING([ '' ])); + assertFalse(AQL_IS_STRING([ '0' ])); + assertFalse(AQL_IS_STRING([ '1' ])); + assertFalse(AQL_IS_STRING([ true ])); + assertFalse(AQL_IS_STRING([ false ])); + assertFalse(AQL_IS_STRING({ })); + assertFalse(AQL_IS_STRING({ 'a' : 0 })); + assertFalse(AQL_IS_STRING({ 'a' : 1 })); + assertFalse(AQL_IS_STRING({ 'a' : 0, 'b' : 1 })); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_IS_ARRAY function +//////////////////////////////////////////////////////////////////////////////// + + function testIsArrayTrue () { + assertTrue(AQL_IS_ARRAY([ ])); + assertTrue(AQL_IS_ARRAY([ 0 ])); + assertTrue(AQL_IS_ARRAY([ 0, 1 ])); + assertTrue(AQL_IS_ARRAY([ 1, 2 ])); + assertTrue(AQL_IS_ARRAY([ '' ])); + assertTrue(AQL_IS_ARRAY([ '0' ])); + assertTrue(AQL_IS_ARRAY([ '1' ])); + assertTrue(AQL_IS_ARRAY([ true ])); + assertTrue(AQL_IS_ARRAY([ false ])); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_IS_ARRAY function +//////////////////////////////////////////////////////////////////////////////// + + function testIsArrayFalse () { + assertFalse(AQL_IS_ARRAY('abc')); + assertFalse(AQL_IS_ARRAY('null')); + assertFalse(AQL_IS_ARRAY('false')); + assertFalse(AQL_IS_ARRAY('undefined')); + assertFalse(AQL_IS_ARRAY('')); + assertFalse(AQL_IS_ARRAY(' ')); + assertFalse(AQL_IS_ARRAY(false)); + assertFalse(AQL_IS_ARRAY(true)); + assertFalse(AQL_IS_ARRAY(undefined)); + assertFalse(AQL_IS_ARRAY(NaN)); + assertFalse(AQL_IS_ARRAY(1.3e308 * 1.3e308)); + assertFalse(AQL_IS_ARRAY(0)); + assertFalse(AQL_IS_ARRAY(1)); + assertFalse(AQL_IS_ARRAY(-1)); + assertFalse(AQL_IS_ARRAY(0.1)); + assertFalse(AQL_IS_ARRAY(-0.1)); + assertFalse(AQL_IS_ARRAY(null)); + assertFalse(AQL_IS_ARRAY({ })); + assertFalse(AQL_IS_ARRAY({ 'a' : 0 })); + assertFalse(AQL_IS_ARRAY({ 'a' : 1 })); + assertFalse(AQL_IS_ARRAY({ 'a' : 0, 'b' : 1 })); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_IS_OBJECT function +//////////////////////////////////////////////////////////////////////////////// + + function testIsObjectTrue () { + assertTrue(AQL_IS_OBJECT({ })); + assertTrue(AQL_IS_OBJECT({ 'a' : 0 })); + assertTrue(AQL_IS_OBJECT({ 'a' : 1 })); + assertTrue(AQL_IS_OBJECT({ 'a' : 0, 'b' : 1 })); + assertTrue(AQL_IS_OBJECT({ '1' : false, 'b' : false })); + assertTrue(AQL_IS_OBJECT({ '0' : false })); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_IS_OBJECT function +//////////////////////////////////////////////////////////////////////////////// + + function testIsObjectFalse () { + assertFalse(AQL_IS_OBJECT('abc')); + assertFalse(AQL_IS_OBJECT('null')); + assertFalse(AQL_IS_OBJECT('false')); + assertFalse(AQL_IS_OBJECT('undefined')); + assertFalse(AQL_IS_OBJECT('')); + assertFalse(AQL_IS_OBJECT(' ')); + assertFalse(AQL_IS_OBJECT(false)); + assertFalse(AQL_IS_OBJECT(true)); + assertFalse(AQL_IS_OBJECT(undefined)); + assertFalse(AQL_IS_OBJECT(NaN)); + assertFalse(AQL_IS_OBJECT(1.3e308 * 1.3e308)); + assertFalse(AQL_IS_OBJECT(0)); + assertFalse(AQL_IS_OBJECT(1)); + assertFalse(AQL_IS_OBJECT(-1)); + assertFalse(AQL_IS_OBJECT(0.1)); + assertFalse(AQL_IS_OBJECT(-0.1)); + assertFalse(AQL_IS_OBJECT(null)); + assertFalse(AQL_IS_OBJECT([ ])); + assertFalse(AQL_IS_OBJECT([ 0 ])); + assertFalse(AQL_IS_OBJECT([ 0, 1 ])); + assertFalse(AQL_IS_OBJECT([ 1, 2 ])); + assertFalse(AQL_IS_OBJECT([ '' ])); + assertFalse(AQL_IS_OBJECT([ '0' ])); + assertFalse(AQL_IS_OBJECT([ '1' ])); + assertFalse(AQL_IS_OBJECT([ true ])); + assertFalse(AQL_IS_OBJECT([ false ])); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_CAST_NULL function +//////////////////////////////////////////////////////////////////////////////// + + function testCastNull () { + assertEqual(null, AQL_CAST_NULL(undefined)); + assertEqual(null, AQL_CAST_NULL(null)); + assertEqual(null, AQL_CAST_NULL(1)); + assertEqual(null, AQL_CAST_NULL(2)); + assertEqual(null, AQL_CAST_NULL(-1)); + assertEqual(null, AQL_CAST_NULL(0)); + assertEqual(null, AQL_CAST_NULL(NaN)); + assertEqual(null, AQL_CAST_NULL(true)); + assertEqual(null, AQL_CAST_NULL(false)); + assertEqual(null, AQL_CAST_NULL('')); + assertEqual(null, AQL_CAST_NULL(' ')); + assertEqual(null, AQL_CAST_NULL(' ')); + assertEqual(null, AQL_CAST_NULL('1')); + assertEqual(null, AQL_CAST_NULL('0')); + assertEqual(null, AQL_CAST_NULL('-1')); + assertEqual(null, AQL_CAST_NULL([ ])); + assertEqual(null, AQL_CAST_NULL([ 0 ] )); + assertEqual(null, AQL_CAST_NULL([ 0, 1 ] )); + assertEqual(null, AQL_CAST_NULL([ 1, 2 ] )); + assertEqual(null, AQL_CAST_NULL({ } )); + assertEqual(null, AQL_CAST_NULL({ 'a' : true })); + assertEqual(null, AQL_CAST_NULL({ 'a' : true, 'b' : 0 })); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_CAST_UNDEFINED function +//////////////////////////////////////////////////////////////////////////////// + + function testCastUndefined () { + assertEqual(undefined, AQL_CAST_UNDEFINED(undefined)); + assertEqual(undefined, AQL_CAST_UNDEFINED(null)); + assertEqual(undefined, AQL_CAST_UNDEFINED(1)); + assertEqual(undefined, AQL_CAST_UNDEFINED(2)); + assertEqual(undefined, AQL_CAST_UNDEFINED(-1)); + assertEqual(undefined, AQL_CAST_UNDEFINED(0)); + assertEqual(undefined, AQL_CAST_UNDEFINED(NaN)); + assertEqual(undefined, AQL_CAST_UNDEFINED(true)); + assertEqual(undefined, AQL_CAST_UNDEFINED(false)); + assertEqual(undefined, AQL_CAST_UNDEFINED('')); + assertEqual(undefined, AQL_CAST_UNDEFINED(' ')); + assertEqual(undefined, AQL_CAST_UNDEFINED(' ')); + assertEqual(undefined, AQL_CAST_UNDEFINED('1')); + assertEqual(undefined, AQL_CAST_UNDEFINED('1 ')); + assertEqual(undefined, AQL_CAST_UNDEFINED('0')); + assertEqual(undefined, AQL_CAST_UNDEFINED('-1')); + assertEqual(undefined, AQL_CAST_UNDEFINED([ ])); + assertEqual(undefined, AQL_CAST_UNDEFINED([ 0 ] )); + assertEqual(undefined, AQL_CAST_UNDEFINED([ 0, 1 ] )); + assertEqual(undefined, AQL_CAST_UNDEFINED([ 1, 2 ] )); + assertEqual(undefined, AQL_CAST_UNDEFINED([ '' ])); + assertEqual(undefined, AQL_CAST_UNDEFINED([ false ])); + assertEqual(undefined, AQL_CAST_UNDEFINED([ true ])); + assertEqual(undefined, AQL_CAST_UNDEFINED({ } )); + assertEqual(undefined, AQL_CAST_UNDEFINED({ 'a' : true })); + assertEqual(undefined, AQL_CAST_UNDEFINED({ 'a' : true, 'b' : 0 })); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_CAST_BOOL function +//////////////////////////////////////////////////////////////////////////////// + + function testCastBoolTrue () { + assertEqual(true, AQL_CAST_BOOL(true)); + assertEqual(true, AQL_CAST_BOOL(1)); + assertEqual(true, AQL_CAST_BOOL(2)); + assertEqual(true, AQL_CAST_BOOL(-1)); + assertEqual(true, AQL_CAST_BOOL(100)); + assertEqual(true, AQL_CAST_BOOL(100.01)); + assertEqual(true, AQL_CAST_BOOL(0.001)); + assertEqual(true, AQL_CAST_BOOL(-0.001)); + assertEqual(true, AQL_CAST_BOOL(' ')); + assertEqual(true, AQL_CAST_BOOL(' ')); + assertEqual(true, AQL_CAST_BOOL('1')); + assertEqual(true, AQL_CAST_BOOL('1 ')); + assertEqual(true, AQL_CAST_BOOL('0')); + assertEqual(true, AQL_CAST_BOOL('-1')); + assertEqual(true, AQL_CAST_BOOL([ 0 ])); + assertEqual(true, AQL_CAST_BOOL([ 0, 1 ])); + assertEqual(true, AQL_CAST_BOOL([ 1, 2 ])); + assertEqual(true, AQL_CAST_BOOL([ -1, 0 ])); + assertEqual(true, AQL_CAST_BOOL([ '' ])); + assertEqual(true, AQL_CAST_BOOL([ false ])); + assertEqual(true, AQL_CAST_BOOL([ true ])); + assertEqual(true, AQL_CAST_BOOL({ 'a' : true })); + assertEqual(true, AQL_CAST_BOOL({ 'a' : false })); + assertEqual(true, AQL_CAST_BOOL({ 'a' : false, 'b' : 0 })); + assertEqual(true, AQL_CAST_BOOL({ '0' : false })); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_CAST_BOOL function +//////////////////////////////////////////////////////////////////////////////// + + function testCastBoolFalse () { + assertEqual(false, AQL_CAST_BOOL(0)); + assertEqual(false, AQL_CAST_BOOL(NaN)); + assertEqual(false, AQL_CAST_BOOL('')); + assertEqual(false, AQL_CAST_BOOL(undefined)); + assertEqual(false, AQL_CAST_BOOL(null)); + assertEqual(false, AQL_CAST_BOOL(false)); + assertEqual(false, AQL_CAST_BOOL([ ])); + assertEqual(false, AQL_CAST_BOOL({ })); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_CAST_NUMBER function +//////////////////////////////////////////////////////////////////////////////// + + function testCastNumber () { + assertEqual(0, AQL_CAST_NUMBER(undefined)); + assertEqual(0, AQL_CAST_NUMBER(null)); + assertEqual(0, AQL_CAST_NUMBER(false)); + assertEqual(1, AQL_CAST_NUMBER(true)); + assertEqual(1, AQL_CAST_NUMBER(1)); + assertEqual(2, AQL_CAST_NUMBER(2)); + assertEqual(-1, AQL_CAST_NUMBER(-1)); + assertEqual(0, AQL_CAST_NUMBER(0)); + assertEqual(0, AQL_CAST_NUMBER(NaN)); + assertEqual(0, AQL_CAST_NUMBER('')); + assertEqual(0, AQL_CAST_NUMBER(' ')); + assertEqual(0, AQL_CAST_NUMBER(' ')); + assertEqual(1, AQL_CAST_NUMBER('1')); + assertEqual(1, AQL_CAST_NUMBER('1 ')); + assertEqual(0, AQL_CAST_NUMBER('0')); + assertEqual(-1, AQL_CAST_NUMBER('-1')); + assertEqual(-1, AQL_CAST_NUMBER('-1 ')); + assertEqual(-1, AQL_CAST_NUMBER(' -1 ')); + assertEqual(-1, AQL_CAST_NUMBER(' -1a')); + assertEqual(0, AQL_CAST_NUMBER('a1bc')); + assertEqual(0, AQL_CAST_NUMBER('aaaa1')); + assertEqual(0, AQL_CAST_NUMBER('-a1')); + assertEqual(-1.255, AQL_CAST_NUMBER('-1.255')); + assertEqual(-1.23456, AQL_CAST_NUMBER('-1.23456')); + assertEqual(-1.23456, AQL_CAST_NUMBER('-1.23456 ')); + assertEqual(1.23456, AQL_CAST_NUMBER(' 1.23456 ')); + assertEqual(1.23456, AQL_CAST_NUMBER(' 1.23456a')); + assertEqual(0, AQL_CAST_NUMBER('--1')); + assertEqual(1, AQL_CAST_NUMBER('+1')); + assertEqual(12.42e32, AQL_CAST_NUMBER('12.42e32')); + assertEqual(0, AQL_CAST_NUMBER([ ])); + assertEqual(0, AQL_CAST_NUMBER([ 0 ])); + assertEqual(0, AQL_CAST_NUMBER([ 0, 1 ])); + assertEqual(0, AQL_CAST_NUMBER([ 1, 2 ])); + assertEqual(0, AQL_CAST_NUMBER([ -1, 0 ])); + assertEqual(0, AQL_CAST_NUMBER([ 0, 1, [ 1, 2 ], [ [ 9, 4 ] ] ])); + assertEqual(0, AQL_CAST_NUMBER([ { } ])); + assertEqual(0, AQL_CAST_NUMBER([ 0, 1, { } ])); + assertEqual(0, AQL_CAST_NUMBER([ { }, { } ])); + assertEqual(0, AQL_CAST_NUMBER([ '' ])); + assertEqual(0, AQL_CAST_NUMBER([ false ])); + assertEqual(0, AQL_CAST_NUMBER([ true ])); + assertEqual(0, AQL_CAST_NUMBER({ })); + assertEqual(0, AQL_CAST_NUMBER({ 'a' : true })); + assertEqual(0, AQL_CAST_NUMBER({ 'a' : true, 'b' : 0 })); + assertEqual(0, AQL_CAST_NUMBER({ 'a' : { }, 'b' : { } })); + assertEqual(0, AQL_CAST_NUMBER({ 'a' : [ ], 'b' : [ ] })); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_CAST_STRING function +//////////////////////////////////////////////////////////////////////////////// + + function testCastString () { + assertEqual('undefined', AQL_CAST_STRING(undefined)); + assertEqual('null', AQL_CAST_STRING(null)); + assertEqual('false', AQL_CAST_STRING(false)); + assertEqual('true', AQL_CAST_STRING(true)); + assertEqual('1', AQL_CAST_STRING(1)); + assertEqual('2', AQL_CAST_STRING(2)); + assertEqual('-1', AQL_CAST_STRING(-1)); + assertEqual('0', AQL_CAST_STRING(0)); + assertEqual('undefined', AQL_CAST_STRING(NaN)); + assertEqual('', AQL_CAST_STRING('')); + assertEqual(' ', AQL_CAST_STRING(' ')); + assertEqual(' ', AQL_CAST_STRING(' ')); + assertEqual('1', AQL_CAST_STRING('1')); + assertEqual('1 ', AQL_CAST_STRING('1 ')); + assertEqual('0', AQL_CAST_STRING('0')); + assertEqual('-1', AQL_CAST_STRING('-1')); + assertEqual('', AQL_CAST_STRING([ ])); + assertEqual('0', AQL_CAST_STRING([ 0 ])); + assertEqual('0,1', AQL_CAST_STRING([ 0, 1 ])); + assertEqual('1,2', AQL_CAST_STRING([ 1, 2 ])); + assertEqual('-1,0', AQL_CAST_STRING([ -1, 0 ])); + assertEqual('0,1,1,2,9,4', AQL_CAST_STRING([ 0, 1, [ 1, 2 ], [ [ 9, 4 ] ] ])); + assertEqual('[object Object]', AQL_CAST_STRING([ { } ])); + assertEqual('0,1,[object Object]', AQL_CAST_STRING([ 0, 1, { } ])); + assertEqual('[object Object],[object Object]', AQL_CAST_STRING([ { }, { } ])); + assertEqual('', AQL_CAST_STRING([ '' ])); + assertEqual('false', AQL_CAST_STRING([ false ])); + assertEqual('true', AQL_CAST_STRING([ true ])); + assertEqual('[object Object]', AQL_CAST_STRING({ })); + assertEqual('[object Object]', AQL_CAST_STRING({ 'a' : true })); + assertEqual('[object Object]', AQL_CAST_STRING({ 'a' : true, 'b' : 0 })); + assertEqual('[object Object]', AQL_CAST_STRING({ 'a' : { }, 'b' : { } })); + assertEqual('[object Object]', AQL_CAST_STRING({ 'a' : [ ], 'b' : [ ] })); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_LOGICAL_AND function +//////////////////////////////////////////////////////////////////////////////// + + function testLogicalAndUndefined () { + assertEqual(undefined, AQL_LOGICAL_AND(undefined, undefined)); + assertEqual(undefined, AQL_LOGICAL_AND(undefined, null)); + assertEqual(undefined, AQL_LOGICAL_AND(undefined, true)); + assertEqual(undefined, AQL_LOGICAL_AND(undefined, false)); + assertEqual(undefined, AQL_LOGICAL_AND(undefined, 0.0)); + assertEqual(undefined, AQL_LOGICAL_AND(undefined, 1.0)); + assertEqual(undefined, AQL_LOGICAL_AND(undefined, -1.0)); + assertEqual(undefined, AQL_LOGICAL_AND(undefined, '')); + assertEqual(undefined, AQL_LOGICAL_AND(undefined, '0')); + assertEqual(undefined, AQL_LOGICAL_AND(undefined, '1')); + assertEqual(undefined, AQL_LOGICAL_AND(undefined, [ ])); + assertEqual(undefined, AQL_LOGICAL_AND(undefined, [ 0 ])); + assertEqual(undefined, AQL_LOGICAL_AND(undefined, [ 0, 1 ])); + assertEqual(undefined, AQL_LOGICAL_AND(undefined, [ 1, 2 ])); + assertEqual(undefined, AQL_LOGICAL_AND(undefined, { })); + assertEqual(undefined, AQL_LOGICAL_AND(undefined, { 'a' : 0 })); + assertEqual(undefined, AQL_LOGICAL_AND(undefined, { 'a' : 1 })); + assertEqual(undefined, AQL_LOGICAL_AND(undefined, { '0' : false })); + assertEqual(undefined, AQL_LOGICAL_AND(null, undefined)); + assertEqual(undefined, AQL_LOGICAL_AND(true, undefined)); + assertEqual(undefined, AQL_LOGICAL_AND(false, undefined)); + assertEqual(undefined, AQL_LOGICAL_AND(0.0, undefined)); + assertEqual(undefined, AQL_LOGICAL_AND(1.0, undefined)); + assertEqual(undefined, AQL_LOGICAL_AND(-1.0, undefined)); + assertEqual(undefined, AQL_LOGICAL_AND('', undefined)); + assertEqual(undefined, AQL_LOGICAL_AND('0', undefined)); + assertEqual(undefined, AQL_LOGICAL_AND('1', undefined)); + assertEqual(undefined, AQL_LOGICAL_AND([ ], undefined)); + assertEqual(undefined, AQL_LOGICAL_AND([ 0 ], undefined)); + assertEqual(undefined, AQL_LOGICAL_AND([ 0, 1 ], undefined)); + assertEqual(undefined, AQL_LOGICAL_AND([ 1, 2 ], undefined)); + assertEqual(undefined, AQL_LOGICAL_AND({ }, undefined)); + assertEqual(undefined, AQL_LOGICAL_AND({ 'a' : 0 }, undefined)); + assertEqual(undefined, AQL_LOGICAL_AND({ 'a' : 1 }, undefined)); + assertEqual(undefined, AQL_LOGICAL_AND({ '0' : false }, undefined)); + + assertEqual(undefined, AQL_LOGICAL_AND(true, null)); + assertEqual(undefined, AQL_LOGICAL_AND(null, true)); + assertEqual(undefined, AQL_LOGICAL_AND(true, '')); + assertEqual(undefined, AQL_LOGICAL_AND('', true)); + assertEqual(undefined, AQL_LOGICAL_AND(true, ' ')); + assertEqual(undefined, AQL_LOGICAL_AND(' ', true)); + assertEqual(undefined, AQL_LOGICAL_AND(true, '0')); + assertEqual(undefined, AQL_LOGICAL_AND('0', true)); + assertEqual(undefined, AQL_LOGICAL_AND(true, '1')); + assertEqual(undefined, AQL_LOGICAL_AND('1', true)); + assertEqual(undefined, AQL_LOGICAL_AND(true, 'true')); + assertEqual(undefined, AQL_LOGICAL_AND('true', true)); + assertEqual(undefined, AQL_LOGICAL_AND(true, 'false')); + assertEqual(undefined, AQL_LOGICAL_AND('false', true)); + assertEqual(undefined, AQL_LOGICAL_AND(true, 0)); + assertEqual(undefined, AQL_LOGICAL_AND(0, true)); + assertEqual(undefined, AQL_LOGICAL_AND(true, 1)); + assertEqual(undefined, AQL_LOGICAL_AND(1, true)); + assertEqual(undefined, AQL_LOGICAL_AND(true, -1)); + assertEqual(undefined, AQL_LOGICAL_AND(-1, true)); + assertEqual(undefined, AQL_LOGICAL_AND(true, 1.1)); + assertEqual(undefined, AQL_LOGICAL_AND(1.1, true)); + assertEqual(undefined, AQL_LOGICAL_AND(true, [ ])); + assertEqual(undefined, AQL_LOGICAL_AND([ ], true)); + assertEqual(undefined, AQL_LOGICAL_AND(true, [ 0 ])); + assertEqual(undefined, AQL_LOGICAL_AND([ 0 ], true)); + assertEqual(undefined, AQL_LOGICAL_AND(true, [ 0, 1 ])); + assertEqual(undefined, AQL_LOGICAL_AND([ 0, 1 ], true)); + assertEqual(undefined, AQL_LOGICAL_AND(true, [ true ])); + assertEqual(undefined, AQL_LOGICAL_AND([ true ], true)); + assertEqual(undefined, AQL_LOGICAL_AND(true, [ false ])); + assertEqual(undefined, AQL_LOGICAL_AND([ false ], true)); + assertEqual(undefined, AQL_LOGICAL_AND(true, { })); + assertEqual(undefined, AQL_LOGICAL_AND({ }, true)); + assertEqual(undefined, AQL_LOGICAL_AND(true, { 'a' : true })); + assertEqual(undefined, AQL_LOGICAL_AND({ 'a' : true }, true)); + assertEqual(undefined, AQL_LOGICAL_AND(true, { 'a' : true, 'b' : false })); + assertEqual(undefined, AQL_LOGICAL_AND({ 'a' : true, 'b' : false }, true)); + + assertEqual(undefined, AQL_LOGICAL_AND(false, null)); + assertEqual(undefined, AQL_LOGICAL_AND(null, false)); + assertEqual(undefined, AQL_LOGICAL_AND(false, '')); + assertEqual(undefined, AQL_LOGICAL_AND('', false)); + assertEqual(undefined, AQL_LOGICAL_AND(false, ' ')); + assertEqual(undefined, AQL_LOGICAL_AND(' ', false)); + assertEqual(undefined, AQL_LOGICAL_AND(false, '0')); + assertEqual(undefined, AQL_LOGICAL_AND('0', false)); + assertEqual(undefined, AQL_LOGICAL_AND(false, '1')); + assertEqual(undefined, AQL_LOGICAL_AND('1', false)); + assertEqual(undefined, AQL_LOGICAL_AND(false, 'true')); + assertEqual(undefined, AQL_LOGICAL_AND('true', false)); + assertEqual(undefined, AQL_LOGICAL_AND(false, 'false')); + assertEqual(undefined, AQL_LOGICAL_AND('false', false)); + assertEqual(undefined, AQL_LOGICAL_AND(false, 0)); + assertEqual(undefined, AQL_LOGICAL_AND(0, false)); + assertEqual(undefined, AQL_LOGICAL_AND(false, 1)); + assertEqual(undefined, AQL_LOGICAL_AND(1, false)); + assertEqual(undefined, AQL_LOGICAL_AND(false, -1)); + assertEqual(undefined, AQL_LOGICAL_AND(-1, false)); + assertEqual(undefined, AQL_LOGICAL_AND(false, 1.1)); + assertEqual(undefined, AQL_LOGICAL_AND(1.1, false)); + assertEqual(undefined, AQL_LOGICAL_AND(false, [ ])); + assertEqual(undefined, AQL_LOGICAL_AND([ ], false)); + assertEqual(undefined, AQL_LOGICAL_AND(false, [ 0 ])); + assertEqual(undefined, AQL_LOGICAL_AND([ 0 ], false)); + assertEqual(undefined, AQL_LOGICAL_AND(false, [ 0, 1 ])); + assertEqual(undefined, AQL_LOGICAL_AND([ 0, 1 ], false)); + assertEqual(undefined, AQL_LOGICAL_AND(false, [ true ])); + assertEqual(undefined, AQL_LOGICAL_AND([ false ], true)); + assertEqual(undefined, AQL_LOGICAL_AND(false, [ false ])); + assertEqual(undefined, AQL_LOGICAL_AND([ false ], false)); + assertEqual(undefined, AQL_LOGICAL_AND(false, { })); + assertEqual(undefined, AQL_LOGICAL_AND({ }, false)); + assertEqual(undefined, AQL_LOGICAL_AND(false, { 'a' : true })); + assertEqual(undefined, AQL_LOGICAL_AND({ 'a' : false }, true)); + assertEqual(undefined, AQL_LOGICAL_AND(false, { 'a' : true, 'b' : false })); + assertEqual(undefined, AQL_LOGICAL_AND({ 'a' : false, 'b' : false }, true)); + assertEqual(undefined, AQL_LOGICAL_AND(NaN, NaN)); + assertEqual(undefined, AQL_LOGICAL_AND(NaN, 0)); + assertEqual(undefined, AQL_LOGICAL_AND(NaN, true)); + assertEqual(undefined, AQL_LOGICAL_AND(NaN, false)); + assertEqual(undefined, AQL_LOGICAL_AND(NaN, null)); + assertEqual(undefined, AQL_LOGICAL_AND(NaN, undefined)); + assertEqual(undefined, AQL_LOGICAL_AND(NaN, '')); + assertEqual(undefined, AQL_LOGICAL_AND(NaN, '0')); + assertEqual(undefined, AQL_LOGICAL_AND(0, NaN)); + assertEqual(undefined, AQL_LOGICAL_AND(true, NaN)); + assertEqual(undefined, AQL_LOGICAL_AND(false, NaN)); + assertEqual(undefined, AQL_LOGICAL_AND(null, NaN)); + assertEqual(undefined, AQL_LOGICAL_AND(undefined, NaN)); + assertEqual(undefined, AQL_LOGICAL_AND('', NaN)); + assertEqual(undefined, AQL_LOGICAL_AND('0', NaN)); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_LOGICAL_AND function +//////////////////////////////////////////////////////////////////////////////// + + function testLogicalAndBool () { + assertTrue(AQL_LOGICAL_AND(true, true)); + assertFalse(AQL_LOGICAL_AND(true, false)); + assertFalse(AQL_LOGICAL_AND(false, true)); + assertFalse(AQL_LOGICAL_AND(false, false)); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_LOGICAL_OR function +//////////////////////////////////////////////////////////////////////////////// + + function testLogicalOrUndefined () { + assertEqual(undefined, AQL_LOGICAL_OR(undefined, undefined)); + assertEqual(undefined, AQL_LOGICAL_OR(undefined, null)); + assertEqual(undefined, AQL_LOGICAL_OR(undefined, true)); + assertEqual(undefined, AQL_LOGICAL_OR(undefined, false)); + assertEqual(undefined, AQL_LOGICAL_OR(undefined, 0.0)); + assertEqual(undefined, AQL_LOGICAL_OR(undefined, 1.0)); + assertEqual(undefined, AQL_LOGICAL_OR(undefined, -1.0)); + assertEqual(undefined, AQL_LOGICAL_OR(undefined, '')); + assertEqual(undefined, AQL_LOGICAL_OR(undefined, '0')); + assertEqual(undefined, AQL_LOGICAL_OR(undefined, '1')); + assertEqual(undefined, AQL_LOGICAL_OR(undefined, [ ])); + assertEqual(undefined, AQL_LOGICAL_OR(undefined, [ 0 ])); + assertEqual(undefined, AQL_LOGICAL_OR(undefined, [ 0, 1 ])); + assertEqual(undefined, AQL_LOGICAL_OR(undefined, [ 1, 2 ])); + assertEqual(undefined, AQL_LOGICAL_OR(undefined, { })); + assertEqual(undefined, AQL_LOGICAL_OR(undefined, { 'a' : 0 })); + assertEqual(undefined, AQL_LOGICAL_OR(undefined, { 'a' : 1 })); + assertEqual(undefined, AQL_LOGICAL_OR(undefined, { '0' : false })); + assertEqual(undefined, AQL_LOGICAL_OR(null, undefined)); + assertEqual(undefined, AQL_LOGICAL_OR(true, undefined)); + assertEqual(undefined, AQL_LOGICAL_OR(false, undefined)); + assertEqual(undefined, AQL_LOGICAL_OR(0.0, undefined)); + assertEqual(undefined, AQL_LOGICAL_OR(1.0, undefined)); + assertEqual(undefined, AQL_LOGICAL_OR(-1.0, undefined)); + assertEqual(undefined, AQL_LOGICAL_OR('', undefined)); + assertEqual(undefined, AQL_LOGICAL_OR('0', undefined)); + assertEqual(undefined, AQL_LOGICAL_OR('1', undefined)); + assertEqual(undefined, AQL_LOGICAL_OR([ ], undefined)); + assertEqual(undefined, AQL_LOGICAL_OR([ 0 ], undefined)); + assertEqual(undefined, AQL_LOGICAL_OR([ 0, 1 ], undefined)); + assertEqual(undefined, AQL_LOGICAL_OR([ 1, 2 ], undefined)); + assertEqual(undefined, AQL_LOGICAL_OR({ }, undefined)); + assertEqual(undefined, AQL_LOGICAL_OR({ 'a' : 0 }, undefined)); + assertEqual(undefined, AQL_LOGICAL_OR({ 'a' : 1 }, undefined)); + assertEqual(undefined, AQL_LOGICAL_OR({ '0' : false }, undefined)); + + assertEqual(undefined, AQL_LOGICAL_OR(true, null)); + assertEqual(undefined, AQL_LOGICAL_OR(null, true)); + assertEqual(undefined, AQL_LOGICAL_OR(true, '')); + assertEqual(undefined, AQL_LOGICAL_OR('', true)); + assertEqual(undefined, AQL_LOGICAL_OR(true, ' ')); + assertEqual(undefined, AQL_LOGICAL_OR(' ', true)); + assertEqual(undefined, AQL_LOGICAL_OR(true, '0')); + assertEqual(undefined, AQL_LOGICAL_OR('0', true)); + assertEqual(undefined, AQL_LOGICAL_OR(true, '1')); + assertEqual(undefined, AQL_LOGICAL_OR('1', true)); + assertEqual(undefined, AQL_LOGICAL_OR(true, 'true')); + assertEqual(undefined, AQL_LOGICAL_OR('true', true)); + assertEqual(undefined, AQL_LOGICAL_OR(true, 'false')); + assertEqual(undefined, AQL_LOGICAL_OR('false', true)); + assertEqual(undefined, AQL_LOGICAL_OR(true, 0)); + assertEqual(undefined, AQL_LOGICAL_OR(0, true)); + assertEqual(undefined, AQL_LOGICAL_OR(true, 1)); + assertEqual(undefined, AQL_LOGICAL_OR(1, true)); + assertEqual(undefined, AQL_LOGICAL_OR(true, -1)); + assertEqual(undefined, AQL_LOGICAL_OR(-1, true)); + assertEqual(undefined, AQL_LOGICAL_OR(true, 1.1)); + assertEqual(undefined, AQL_LOGICAL_OR(1.1, true)); + assertEqual(undefined, AQL_LOGICAL_OR(true, [ ])); + assertEqual(undefined, AQL_LOGICAL_OR([ ], true)); + assertEqual(undefined, AQL_LOGICAL_OR(true, [ 0 ])); + assertEqual(undefined, AQL_LOGICAL_OR([ 0 ], true)); + assertEqual(undefined, AQL_LOGICAL_OR(true, [ 0, 1 ])); + assertEqual(undefined, AQL_LOGICAL_OR([ 0, 1 ], true)); + assertEqual(undefined, AQL_LOGICAL_OR(true, [ true ])); + assertEqual(undefined, AQL_LOGICAL_OR([ true ], true)); + assertEqual(undefined, AQL_LOGICAL_OR(true, [ false ])); + assertEqual(undefined, AQL_LOGICAL_OR([ false ], true)); + assertEqual(undefined, AQL_LOGICAL_OR(true, { })); + assertEqual(undefined, AQL_LOGICAL_OR({ }, true)); + assertEqual(undefined, AQL_LOGICAL_OR(true, { 'a' : true })); + assertEqual(undefined, AQL_LOGICAL_OR({ 'a' : true }, true)); + assertEqual(undefined, AQL_LOGICAL_OR(true, { 'a' : true, 'b' : false })); + assertEqual(undefined, AQL_LOGICAL_OR({ 'a' : true, 'b' : false }, true)); + + assertEqual(undefined, AQL_LOGICAL_OR(false, null)); + assertEqual(undefined, AQL_LOGICAL_OR(null, false)); + assertEqual(undefined, AQL_LOGICAL_OR(false, '')); + assertEqual(undefined, AQL_LOGICAL_OR('', false)); + assertEqual(undefined, AQL_LOGICAL_OR(false, ' ')); + assertEqual(undefined, AQL_LOGICAL_OR(' ', false)); + assertEqual(undefined, AQL_LOGICAL_OR(false, '0')); + assertEqual(undefined, AQL_LOGICAL_OR('0', false)); + assertEqual(undefined, AQL_LOGICAL_OR(false, '1')); + assertEqual(undefined, AQL_LOGICAL_OR('1', false)); + assertEqual(undefined, AQL_LOGICAL_OR(false, 'true')); + assertEqual(undefined, AQL_LOGICAL_OR('true', false)); + assertEqual(undefined, AQL_LOGICAL_OR(false, 'false')); + assertEqual(undefined, AQL_LOGICAL_OR('false', false)); + assertEqual(undefined, AQL_LOGICAL_OR(false, 0)); + assertEqual(undefined, AQL_LOGICAL_OR(0, false)); + assertEqual(undefined, AQL_LOGICAL_OR(false, 1)); + assertEqual(undefined, AQL_LOGICAL_OR(1, false)); + assertEqual(undefined, AQL_LOGICAL_OR(false, -1)); + assertEqual(undefined, AQL_LOGICAL_OR(-1, false)); + assertEqual(undefined, AQL_LOGICAL_OR(false, 1.1)); + assertEqual(undefined, AQL_LOGICAL_OR(1.1, false)); + assertEqual(undefined, AQL_LOGICAL_OR(false, [ ])); + assertEqual(undefined, AQL_LOGICAL_OR([ ], false)); + assertEqual(undefined, AQL_LOGICAL_OR(false, [ 0 ])); + assertEqual(undefined, AQL_LOGICAL_OR([ 0 ], false)); + assertEqual(undefined, AQL_LOGICAL_OR(false, [ 0, 1 ])); + assertEqual(undefined, AQL_LOGICAL_OR([ 0, 1 ], false)); + assertEqual(undefined, AQL_LOGICAL_OR(false, [ true ])); + assertEqual(undefined, AQL_LOGICAL_OR([ false ], true)); + assertEqual(undefined, AQL_LOGICAL_OR(false, [ false ])); + assertEqual(undefined, AQL_LOGICAL_OR([ false ], false)); + assertEqual(undefined, AQL_LOGICAL_OR(false, { })); + assertEqual(undefined, AQL_LOGICAL_OR({ }, false)); + assertEqual(undefined, AQL_LOGICAL_OR(false, { 'a' : true })); + assertEqual(undefined, AQL_LOGICAL_OR({ 'a' : false }, true)); + assertEqual(undefined, AQL_LOGICAL_OR(false, { 'a' : true, 'b' : false })); + assertEqual(undefined, AQL_LOGICAL_OR({ 'a' : false, 'b' : false }, true)); + assertEqual(undefined, AQL_LOGICAL_OR(NaN, NaN)); + assertEqual(undefined, AQL_LOGICAL_OR(NaN, 0)); + assertEqual(undefined, AQL_LOGICAL_OR(NaN, true)); + assertEqual(undefined, AQL_LOGICAL_OR(NaN, false)); + assertEqual(undefined, AQL_LOGICAL_OR(NaN, null)); + assertEqual(undefined, AQL_LOGICAL_OR(NaN, undefined)); + assertEqual(undefined, AQL_LOGICAL_OR(NaN, '')); + assertEqual(undefined, AQL_LOGICAL_OR(NaN, '0')); + assertEqual(undefined, AQL_LOGICAL_OR(0, NaN)); + assertEqual(undefined, AQL_LOGICAL_OR(true, NaN)); + assertEqual(undefined, AQL_LOGICAL_OR(false, NaN)); + assertEqual(undefined, AQL_LOGICAL_OR(null, NaN)); + assertEqual(undefined, AQL_LOGICAL_OR(undefined, NaN)); + assertEqual(undefined, AQL_LOGICAL_OR('', NaN)); + assertEqual(undefined, AQL_LOGICAL_OR('0', NaN)); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_LOGICAL_OR function +//////////////////////////////////////////////////////////////////////////////// + + function testLogicalOrBool () { + assertTrue(AQL_LOGICAL_OR(true, true)); + assertTrue(AQL_LOGICAL_OR(true, false)); + assertTrue(AQL_LOGICAL_OR(false, true)); + assertFalse(AQL_LOGICAL_OR(false, false)); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_LOGICAL_NOT function +//////////////////////////////////////////////////////////////////////////////// + + function testLogicalNotUndefined () { + assertEqual(undefined, AQL_LOGICAL_NOT(undefined)); + assertEqual(undefined, AQL_LOGICAL_NOT(null)); + assertEqual(undefined, AQL_LOGICAL_NOT(0.0)); + assertEqual(undefined, AQL_LOGICAL_NOT(1.0)); + assertEqual(undefined, AQL_LOGICAL_NOT(-1.0)); + assertEqual(undefined, AQL_LOGICAL_NOT('')); + assertEqual(undefined, AQL_LOGICAL_NOT('0')); + assertEqual(undefined, AQL_LOGICAL_NOT('1')); + assertEqual(undefined, AQL_LOGICAL_NOT([ ])); + assertEqual(undefined, AQL_LOGICAL_NOT([ 0 ])); + assertEqual(undefined, AQL_LOGICAL_NOT([ 0, 1 ])); + assertEqual(undefined, AQL_LOGICAL_NOT([ 1, 2 ])); + assertEqual(undefined, AQL_LOGICAL_NOT({ })); + assertEqual(undefined, AQL_LOGICAL_NOT({ 'a' : 0 })); + assertEqual(undefined, AQL_LOGICAL_NOT({ 'a' : 1 })); + assertEqual(undefined, AQL_LOGICAL_NOT({ '0' : false})); + assertEqual(undefined, AQL_LOGICAL_NOT(NaN)); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_LOGICAL_NOT function +//////////////////////////////////////////////////////////////////////////////// + + function testLogicalNotBool () { + assertTrue(AQL_LOGICAL_NOT(false)); + assertFalse(AQL_LOGICAL_NOT(true)); + + assertTrue(AQL_LOGICAL_NOT(AQL_LOGICAL_NOT(true))); + assertFalse(AQL_LOGICAL_NOT(AQL_LOGICAL_NOT(false))); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_RELATIONAL_EQUAL function +//////////////////////////////////////////////////////////////////////////////// + + function testRelationalEqualUndefined () { + assertEqual(undefined, AQL_RELATIONAL_EQUAL(undefined, undefined)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(undefined, null)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(undefined, true)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(undefined, false)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(undefined, 0.0)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(undefined, 1.0)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(undefined, -1.0)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(undefined, '')); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(undefined, '0')); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(undefined, '1')); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(undefined, [ ])); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(undefined, [ 0 ])); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(undefined, [ 0, 1 ])); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(undefined, [ 1, 2 ])); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(undefined, { })); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(undefined, { 'a' : 0 })); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(undefined, { 'a' : 1 })); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(undefined, { '0' : false })); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(null, undefined)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(true, undefined)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(false, undefined)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(0.0, undefined)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(1.0, undefined)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(-1.0, undefined)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL('', undefined)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL('0', undefined)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL('1', undefined)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL([ ], undefined)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL([ 0 ], undefined)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL([ 0, 1 ], undefined)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL([ 1, 2 ], undefined)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL({ }, undefined)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL({ 'a' : 0 }, undefined)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL({ 'a' : 1 }, undefined)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL({ '0' : false }, undefined)); + assertEqual(undefined, AQL_RELATIONAL_EQUAL(NaN, NaN)); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_RELATIONAL_EQUAL function +//////////////////////////////////////////////////////////////////////////////// + + function testRelationalEqualTrue () { + assertTrue(AQL_RELATIONAL_EQUAL(1, 1)); + assertTrue(AQL_RELATIONAL_EQUAL(0, 0)); + assertTrue(AQL_RELATIONAL_EQUAL(-1, -1)); + assertTrue(AQL_RELATIONAL_EQUAL(1.345, 1.345)); + assertTrue(AQL_RELATIONAL_EQUAL(1.0, 1.00)); + assertTrue(AQL_RELATIONAL_EQUAL(1.0, 1.000)); + assertTrue(AQL_RELATIONAL_EQUAL(1.1, 1.1)); + assertTrue(AQL_RELATIONAL_EQUAL(1.01, 1.01)); + assertTrue(AQL_RELATIONAL_EQUAL(1.001, 1.001)); + assertTrue(AQL_RELATIONAL_EQUAL(1.0001, 1.0001)); + assertTrue(AQL_RELATIONAL_EQUAL(1.00001, 1.00001)); + assertTrue(AQL_RELATIONAL_EQUAL(1.000001, 1.000001)); + assertTrue(AQL_RELATIONAL_EQUAL(1.245e307, 1.245e307)); + assertTrue(AQL_RELATIONAL_EQUAL(-99.43423, -99.43423)); + assertTrue(AQL_RELATIONAL_EQUAL(true, true)); + assertTrue(AQL_RELATIONAL_EQUAL(false, false)); + assertTrue(AQL_RELATIONAL_EQUAL('', '')); + assertTrue(AQL_RELATIONAL_EQUAL(' ', ' ')); + assertTrue(AQL_RELATIONAL_EQUAL(' 1', ' 1')); + assertTrue(AQL_RELATIONAL_EQUAL('0', '0')); + assertTrue(AQL_RELATIONAL_EQUAL('abc', 'abc')); + assertTrue(AQL_RELATIONAL_EQUAL('-1', '-1')); + assertTrue(AQL_RELATIONAL_EQUAL(null, null)); + assertTrue(AQL_RELATIONAL_EQUAL('true', 'true')); + assertTrue(AQL_RELATIONAL_EQUAL('false', 'false')); + assertTrue(AQL_RELATIONAL_EQUAL('undefined', 'undefined')); + assertTrue(AQL_RELATIONAL_EQUAL('null', 'null')); + assertTrue(AQL_RELATIONAL_EQUAL([ ], [ ])); + assertTrue(AQL_RELATIONAL_EQUAL([ 0 ], [ 0 ])); + assertTrue(AQL_RELATIONAL_EQUAL([ 0, 1 ], [ 0, 1 ])); + assertTrue(AQL_RELATIONAL_EQUAL([ 0, 1, 4 ], [ 0, 1, 4 ])); + assertTrue(AQL_RELATIONAL_EQUAL([ 3, 4, -99 ], [ 3, 4, -99 ])); + assertTrue(AQL_RELATIONAL_EQUAL([ 'a', 4, [ 1, 'a' ], false ], [ 'a', 4, [ 1, 'a' ], false ])); + assertTrue(AQL_RELATIONAL_EQUAL({ }, { })); + assertTrue(AQL_RELATIONAL_EQUAL({ 'a' : true }, { 'a' : true })); + assertTrue(AQL_RELATIONAL_EQUAL({ 'a' : true, 'b': true }, { 'a' : true, 'b': true })); + assertTrue(AQL_RELATIONAL_EQUAL({ 'a' : true, 'b': true }, { 'b' : true, 'a': true })); + assertTrue(AQL_RELATIONAL_EQUAL({ 'b' : true, 'a': true }, { 'b' : true, 'a': true })); + assertTrue(AQL_RELATIONAL_EQUAL({ 'b' : true, 'a': true }, { 'a' : true, 'b': true })); + assertTrue(AQL_RELATIONAL_EQUAL({ 'a' : [ 0, 1 ], 'b' : [ 1, 9 ] }, { 'a' : [ 0, 1 ], 'b' : [ 1, 9 ] })); + assertTrue(AQL_RELATIONAL_EQUAL({ 'a' : [ 0, 1 ], 'b' : [ 1, 9 ] }, { 'b' : [ 1, 9 ], 'a' : [ 0, 1 ] })); + assertTrue(AQL_RELATIONAL_EQUAL({ 'f' : { 'c' : { 'd' : [ 0, 1 ], 'a' : [ 1, 9 ] }, 'a' : false }, 'a' : true }, { 'a' : true, 'f' : { 'a' : false, 'c' : { 'a' : [ 1, 9 ], 'd' : [ 0, 1 ] } } })); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_RELATIONAL_EQUAL function +//////////////////////////////////////////////////////////////////////////////// + + function testRelationalEqualFalse () { + assertFalse(AQL_RELATIONAL_EQUAL(1, 0)); + assertFalse(AQL_RELATIONAL_EQUAL(0, 1)); + assertFalse(AQL_RELATIONAL_EQUAL(0, false)); + assertFalse(AQL_RELATIONAL_EQUAL(false, 0)); + assertFalse(AQL_RELATIONAL_EQUAL(false, 0)); + assertFalse(AQL_RELATIONAL_EQUAL(-1, 1)); + assertFalse(AQL_RELATIONAL_EQUAL(1, -1)); + assertFalse(AQL_RELATIONAL_EQUAL(-1, 0)); + assertFalse(AQL_RELATIONAL_EQUAL(0, -1)); + assertFalse(AQL_RELATIONAL_EQUAL(true, false)); + assertFalse(AQL_RELATIONAL_EQUAL(false, true)); + assertFalse(AQL_RELATIONAL_EQUAL(true, 1)); + assertFalse(AQL_RELATIONAL_EQUAL(1, true)); + assertFalse(AQL_RELATIONAL_EQUAL(0, true)); + assertFalse(AQL_RELATIONAL_EQUAL(true, 0)); + assertFalse(AQL_RELATIONAL_EQUAL(true, 'true')); + assertFalse(AQL_RELATIONAL_EQUAL(false, 'false')); + assertFalse(AQL_RELATIONAL_EQUAL('true', true)); + assertFalse(AQL_RELATIONAL_EQUAL('false', false)); + assertFalse(AQL_RELATIONAL_EQUAL(-1.345, 1.345)); + assertFalse(AQL_RELATIONAL_EQUAL(1.345, -1.345)); + assertFalse(AQL_RELATIONAL_EQUAL(1.345, 1.346)); + assertFalse(AQL_RELATIONAL_EQUAL(1.346, 1.345)); + assertFalse(AQL_RELATIONAL_EQUAL(1.344, 1.345)); + assertFalse(AQL_RELATIONAL_EQUAL(1.345, 1.344)); + assertFalse(AQL_RELATIONAL_EQUAL(1, 2)); + assertFalse(AQL_RELATIONAL_EQUAL(2, 1)); + assertFalse(AQL_RELATIONAL_EQUAL(1.246e307, 1.245e307)); + assertFalse(AQL_RELATIONAL_EQUAL(1.246e307, 1.247e307)); + assertFalse(AQL_RELATIONAL_EQUAL(1.246e307, 1.2467e307)); + assertFalse(AQL_RELATIONAL_EQUAL(-99.43423, -99.434233)); + assertFalse(AQL_RELATIONAL_EQUAL(1.00001, 1.000001)); + assertFalse(AQL_RELATIONAL_EQUAL(1.00001, 1.0001)); + assertFalse(AQL_RELATIONAL_EQUAL(null, 1)); + assertFalse(AQL_RELATIONAL_EQUAL(1, null)); + assertFalse(AQL_RELATIONAL_EQUAL(null, 0)); + assertFalse(AQL_RELATIONAL_EQUAL(0, null)); + assertFalse(AQL_RELATIONAL_EQUAL(null, '')); + assertFalse(AQL_RELATIONAL_EQUAL('', null)); + assertFalse(AQL_RELATIONAL_EQUAL(null, '0')); + assertFalse(AQL_RELATIONAL_EQUAL('0', null)); + assertFalse(AQL_RELATIONAL_EQUAL(null, false)); + assertFalse(AQL_RELATIONAL_EQUAL(false, null)); + assertFalse(AQL_RELATIONAL_EQUAL(null, true)); + assertFalse(AQL_RELATIONAL_EQUAL(true, null)); + assertFalse(AQL_RELATIONAL_EQUAL(null, 'null')); + assertFalse(AQL_RELATIONAL_EQUAL('null', null)); + assertFalse(AQL_RELATIONAL_EQUAL(0, '')); + assertFalse(AQL_RELATIONAL_EQUAL('', 0)); + assertFalse(AQL_RELATIONAL_EQUAL(1, '')); + assertFalse(AQL_RELATIONAL_EQUAL('', 1)); + assertFalse(AQL_RELATIONAL_EQUAL(' ', '')); + assertFalse(AQL_RELATIONAL_EQUAL('', ' ')); + assertFalse(AQL_RELATIONAL_EQUAL(' 1', '1')); + assertFalse(AQL_RELATIONAL_EQUAL('1', ' 1')); + assertFalse(AQL_RELATIONAL_EQUAL('1 ', '1')); + assertFalse(AQL_RELATIONAL_EQUAL('1', '1 ')); + assertFalse(AQL_RELATIONAL_EQUAL('1 ', ' 1')); + assertFalse(AQL_RELATIONAL_EQUAL(' 1', '1 ')); + assertFalse(AQL_RELATIONAL_EQUAL(' 1 ', '1')); + assertFalse(AQL_RELATIONAL_EQUAL('0', '')); + assertFalse(AQL_RELATIONAL_EQUAL('', ' ')); + assertFalse(AQL_RELATIONAL_EQUAL('abc', 'abcd')); + assertFalse(AQL_RELATIONAL_EQUAL('abcd', 'abc')); + assertFalse(AQL_RELATIONAL_EQUAL('dabc', 'abcd')); + assertFalse(AQL_RELATIONAL_EQUAL('1', 1)); + assertFalse(AQL_RELATIONAL_EQUAL(1, '1')); + assertFalse(AQL_RELATIONAL_EQUAL('0', 0)); + assertFalse(AQL_RELATIONAL_EQUAL('1.0', 1.0)); + assertFalse(AQL_RELATIONAL_EQUAL('1.0', 1)); + assertFalse(AQL_RELATIONAL_EQUAL('-1', -1)); + assertFalse(AQL_RELATIONAL_EQUAL('1.234', 1.234)); + assertFalse(AQL_RELATIONAL_EQUAL('NaN', NaN)); + + assertFalse(AQL_RELATIONAL_EQUAL([ 0 ], [ ])); + assertFalse(AQL_RELATIONAL_EQUAL([ ], [ 0 ])); + assertFalse(AQL_RELATIONAL_EQUAL([ ], [ 0, 1 ])); + assertFalse(AQL_RELATIONAL_EQUAL([ 0 ], [ 0, 1 ])); + assertFalse(AQL_RELATIONAL_EQUAL([ 1, 1, 0 ], [ 1, 0, 1 ])); + assertFalse(AQL_RELATIONAL_EQUAL([ 1, 0, 0 ], [ 1, 0, 1 ])); + assertFalse(AQL_RELATIONAL_EQUAL([ 1, 0, 0 ], [ 1, 0 ])); + assertFalse(AQL_RELATIONAL_EQUAL([ 1, 0 ], [ 1, 0, 0 ])); + assertFalse(AQL_RELATIONAL_EQUAL([ 1, 0 ], [ 0, 1 ])); + assertFalse(AQL_RELATIONAL_EQUAL([ 1, 0 ], [ 0 ])); + assertFalse(AQL_RELATIONAL_EQUAL([ 1, 0 ], [ 1 ])); + assertFalse(AQL_RELATIONAL_EQUAL([ 1, 2, 3 ], [ 3, 2, 1 ])); + assertFalse(AQL_RELATIONAL_EQUAL([ [ 1 ] ], [ [ 0 ] ])); + assertFalse(AQL_RELATIONAL_EQUAL([ 1, [ 1 , 0 ] ], [ 1, [ 0, 1 ] ])); + assertFalse(AQL_RELATIONAL_EQUAL([ 1, [ 1 , 0, [ ] ] ], [ 1, [ [ ], 1, 0 ] ])); + assertFalse(AQL_RELATIONAL_EQUAL([ '' ], false)); + assertFalse(AQL_RELATIONAL_EQUAL([ '' ], '')); + assertFalse(AQL_RELATIONAL_EQUAL([ '' ], [ ])); + assertFalse(AQL_RELATIONAL_EQUAL([ true ], [ ])); + assertFalse(AQL_RELATIONAL_EQUAL([ true ], [ false ])); + assertFalse(AQL_RELATIONAL_EQUAL([ false ], [ ])); + assertFalse(AQL_RELATIONAL_EQUAL([ null ], [ ])); + assertFalse(AQL_RELATIONAL_EQUAL([ null ], [ false ])); + assertFalse(AQL_RELATIONAL_EQUAL([ ], null)); + assertFalse(AQL_RELATIONAL_EQUAL([ ], '')); + assertFalse(AQL_RELATIONAL_EQUAL({ }, { 'a' : false })); + assertFalse(AQL_RELATIONAL_EQUAL({ 'a' : false }, { })); + assertFalse(AQL_RELATIONAL_EQUAL({ 'a' : true }, { 'a' : false })); + assertFalse(AQL_RELATIONAL_EQUAL({ 'a' : true }, { 'b' : true })); + assertFalse(AQL_RELATIONAL_EQUAL({ 'b' : true }, { 'a' : true })); + assertFalse(AQL_RELATIONAL_EQUAL({ 'a' : true, 'b' : [ 0, 1 ] }, { 'a' : true, 'b' : [ 1, 0 ] })); + assertFalse(AQL_RELATIONAL_EQUAL({ 'a' : true, 'b' : { 'a' : false, 'b' : true } }, { 'a' : true, 'b' : { 'a' : true, 'b': true } })); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_RELATIONAL_UNEQUAL function +//////////////////////////////////////////////////////////////////////////////// + + function testRelationalUnequalUndefined () { + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(undefined, undefined)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(undefined, null)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(undefined, true)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(undefined, false)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(undefined, 0.0)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(undefined, 1.0)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(undefined, -1.0)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(undefined, '')); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(undefined, '0')); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(undefined, '1')); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(undefined, [ ])); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(undefined, [ 0 ])); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(undefined, [ 0, 1 ])); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(undefined, [ 1, 2 ])); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(undefined, { })); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(undefined, { 'a' : 0 })); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(undefined, { 'a' : 1 })); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(undefined, { '0' : false })); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(null, undefined)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(true, undefined)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(false, undefined)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(0.0, undefined)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(1.0, undefined)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(-1.0, undefined)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL('', undefined)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL('0', undefined)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL('1', undefined)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL([ ], undefined)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL([ 0 ], undefined)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL([ 0, 1 ], undefined)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL([ 1, 2 ], undefined)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL({ }, undefined)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL({ 'a' : 0 }, undefined)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL({ 'a' : 1 }, undefined)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL({ '0' : false }, undefined)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(NaN, false)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(NaN, true)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(NaN, '')); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(NaN, 0)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(NaN, null)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(NaN, undefined)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(false, NaN)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(true, NaN)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL('', NaN)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(0, NaN)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(null, NaN)); + assertEqual(undefined, AQL_RELATIONAL_UNEQUAL(undefined, NaN)); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_RELATIONAL_UNEQUAL function +//////////////////////////////////////////////////////////////////////////////// + + function testRelationalUnequalTrue () { + assertTrue(AQL_RELATIONAL_UNEQUAL(1, 0)); + assertTrue(AQL_RELATIONAL_UNEQUAL(0, 1)); + assertTrue(AQL_RELATIONAL_UNEQUAL(0, false)); + assertTrue(AQL_RELATIONAL_UNEQUAL(false, 0)); + assertTrue(AQL_RELATIONAL_UNEQUAL(false, 0)); + assertTrue(AQL_RELATIONAL_UNEQUAL(-1, 1)); + assertTrue(AQL_RELATIONAL_UNEQUAL(1, -1)); + assertTrue(AQL_RELATIONAL_UNEQUAL(-1, 0)); + assertTrue(AQL_RELATIONAL_UNEQUAL(0, -1)); + assertTrue(AQL_RELATIONAL_UNEQUAL(true, false)); + assertTrue(AQL_RELATIONAL_UNEQUAL(false, true)); + assertTrue(AQL_RELATIONAL_UNEQUAL(true, 1)); + assertTrue(AQL_RELATIONAL_UNEQUAL(1, true)); + assertTrue(AQL_RELATIONAL_UNEQUAL(0, true)); + assertTrue(AQL_RELATIONAL_UNEQUAL(true, 0)); + assertTrue(AQL_RELATIONAL_UNEQUAL(true, 'true')); + assertTrue(AQL_RELATIONAL_UNEQUAL(false, 'false')); + assertTrue(AQL_RELATIONAL_UNEQUAL('true', true)); + assertTrue(AQL_RELATIONAL_UNEQUAL('false', false)); + assertTrue(AQL_RELATIONAL_UNEQUAL(-1.345, 1.345)); + assertTrue(AQL_RELATIONAL_UNEQUAL(1.345, -1.345)); + assertTrue(AQL_RELATIONAL_UNEQUAL(1.345, 1.346)); + assertTrue(AQL_RELATIONAL_UNEQUAL(1.346, 1.345)); + assertTrue(AQL_RELATIONAL_UNEQUAL(1.344, 1.345)); + assertTrue(AQL_RELATIONAL_UNEQUAL(1.345, 1.344)); + assertTrue(AQL_RELATIONAL_UNEQUAL(1, 2)); + assertTrue(AQL_RELATIONAL_UNEQUAL(2, 1)); + assertTrue(AQL_RELATIONAL_UNEQUAL(1.246e307, 1.245e307)); + assertTrue(AQL_RELATIONAL_UNEQUAL(1.246e307, 1.247e307)); + assertTrue(AQL_RELATIONAL_UNEQUAL(1.246e307, 1.2467e307)); + assertTrue(AQL_RELATIONAL_UNEQUAL(-99.43423, -99.434233)); + assertTrue(AQL_RELATIONAL_UNEQUAL(1.00001, 1.000001)); + assertTrue(AQL_RELATIONAL_UNEQUAL(1.00001, 1.0001)); + assertTrue(AQL_RELATIONAL_UNEQUAL(null, 1)); + assertTrue(AQL_RELATIONAL_UNEQUAL(1, null)); + assertTrue(AQL_RELATIONAL_UNEQUAL(null, 0)); + assertTrue(AQL_RELATIONAL_UNEQUAL(0, null)); + assertTrue(AQL_RELATIONAL_UNEQUAL(null, '')); + assertTrue(AQL_RELATIONAL_UNEQUAL('', null)); + assertTrue(AQL_RELATIONAL_UNEQUAL(null, '0')); + assertTrue(AQL_RELATIONAL_UNEQUAL('0', null)); + assertTrue(AQL_RELATIONAL_UNEQUAL(null, false)); + assertTrue(AQL_RELATIONAL_UNEQUAL(false, null)); + assertTrue(AQL_RELATIONAL_UNEQUAL(null, true)); + assertTrue(AQL_RELATIONAL_UNEQUAL(true, null)); + assertTrue(AQL_RELATIONAL_UNEQUAL(null, 'null')); + assertTrue(AQL_RELATIONAL_UNEQUAL('null', null)); + assertTrue(AQL_RELATIONAL_UNEQUAL(0, '')); + assertTrue(AQL_RELATIONAL_UNEQUAL('', 0)); + assertTrue(AQL_RELATIONAL_UNEQUAL(1, '')); + assertTrue(AQL_RELATIONAL_UNEQUAL('', 1)); + assertTrue(AQL_RELATIONAL_UNEQUAL(' ', '')); + assertTrue(AQL_RELATIONAL_UNEQUAL('', ' ')); + assertTrue(AQL_RELATIONAL_UNEQUAL(' 1', '1')); + assertTrue(AQL_RELATIONAL_UNEQUAL('1', ' 1')); + assertTrue(AQL_RELATIONAL_UNEQUAL('1 ', '1')); + assertTrue(AQL_RELATIONAL_UNEQUAL('1', '1 ')); + assertTrue(AQL_RELATIONAL_UNEQUAL('1 ', ' 1')); + assertTrue(AQL_RELATIONAL_UNEQUAL(' 1', '1 ')); + assertTrue(AQL_RELATIONAL_UNEQUAL(' 1 ', '1')); + assertTrue(AQL_RELATIONAL_UNEQUAL('0', '')); + assertTrue(AQL_RELATIONAL_UNEQUAL('', ' ')); + assertTrue(AQL_RELATIONAL_UNEQUAL('abc', 'abcd')); + assertTrue(AQL_RELATIONAL_UNEQUAL('abcd', 'abc')); + assertTrue(AQL_RELATIONAL_UNEQUAL('dabc', 'abcd')); + assertTrue(AQL_RELATIONAL_UNEQUAL('1', 1)); + assertTrue(AQL_RELATIONAL_UNEQUAL(1, '1')); + assertTrue(AQL_RELATIONAL_UNEQUAL('0', 0)); + assertTrue(AQL_RELATIONAL_UNEQUAL('1.0', 1.0)); + assertTrue(AQL_RELATIONAL_UNEQUAL('1.0', 1)); + assertTrue(AQL_RELATIONAL_UNEQUAL('-1', -1)); + assertTrue(AQL_RELATIONAL_UNEQUAL('1.234', 1.234)); + + assertTrue(AQL_RELATIONAL_UNEQUAL([ 0 ], [ ])); + assertTrue(AQL_RELATIONAL_UNEQUAL([ ], [ 0 ])); + assertTrue(AQL_RELATIONAL_UNEQUAL([ ], [ 0, 1 ])); + assertTrue(AQL_RELATIONAL_UNEQUAL([ 0 ], [ 0, 1 ])); + assertTrue(AQL_RELATIONAL_UNEQUAL([ 1, 1, 0 ], [ 1, 0, 1 ])); + assertTrue(AQL_RELATIONAL_UNEQUAL([ 1, 0, 0 ], [ 1, 0, 1 ])); + assertTrue(AQL_RELATIONAL_UNEQUAL([ 1, 0, 0 ], [ 1, 0 ])); + assertTrue(AQL_RELATIONAL_UNEQUAL([ 1, 0 ], [ 1, 0, 0 ])); + assertTrue(AQL_RELATIONAL_UNEQUAL([ 1, 0 ], [ 0, 1 ])); + assertTrue(AQL_RELATIONAL_UNEQUAL([ 1, 0 ], [ 0 ])); + assertTrue(AQL_RELATIONAL_UNEQUAL([ 1, 0 ], [ 1 ])); + assertTrue(AQL_RELATIONAL_UNEQUAL([ 1, 2, 3 ], [ 3, 2, 1 ])); + assertTrue(AQL_RELATIONAL_UNEQUAL([ [ 1 ] ], [ [ 0 ] ])); + assertTrue(AQL_RELATIONAL_UNEQUAL([ 1, [ 1 , 0 ] ], [ 1, [ 0, 1 ] ])); + assertTrue(AQL_RELATIONAL_UNEQUAL([ 1, [ 1 , 0, [ ] ] ], [ 1, [ [ ], 1, 0 ] ])); + assertTrue(AQL_RELATIONAL_UNEQUAL([ '' ], false)); + assertTrue(AQL_RELATIONAL_UNEQUAL([ '' ], '')); + assertTrue(AQL_RELATIONAL_UNEQUAL([ '' ], [ ])); + assertTrue(AQL_RELATIONAL_UNEQUAL([ true ], [ ])); + assertTrue(AQL_RELATIONAL_UNEQUAL([ true ], [ false ])); + assertTrue(AQL_RELATIONAL_UNEQUAL([ false ], [ ])); + assertTrue(AQL_RELATIONAL_UNEQUAL([ null ], [ ])); + assertTrue(AQL_RELATIONAL_UNEQUAL([ null ], [ false ])); + assertTrue(AQL_RELATIONAL_UNEQUAL([ ], null)); + assertTrue(AQL_RELATIONAL_UNEQUAL([ ], '')); + assertTrue(AQL_RELATIONAL_UNEQUAL({ }, { 'a' : false })); + assertTrue(AQL_RELATIONAL_UNEQUAL({ 'a' : false }, { })); + assertTrue(AQL_RELATIONAL_UNEQUAL({ 'a' : true }, { 'a' : false })); + assertTrue(AQL_RELATIONAL_UNEQUAL({ 'a' : true }, { 'b' : true })); + assertTrue(AQL_RELATIONAL_UNEQUAL({ 'b' : true }, { 'a' : true })); + assertTrue(AQL_RELATIONAL_UNEQUAL({ 'a' : true, 'b' : [ 0, 1 ] }, { 'a' : true, 'b' : [ 1, 0 ] })); + assertTrue(AQL_RELATIONAL_UNEQUAL({ 'a' : true, 'b' : { 'a' : false, 'b' : true } }, { 'a' : true, 'b' : { 'a' : true, 'b': true } })); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_RELATIONAL_UNEQUAL function +//////////////////////////////////////////////////////////////////////////////// + + function testRelationalUnequalFalse () { + assertFalse(AQL_RELATIONAL_UNEQUAL(1, 1)); + assertFalse(AQL_RELATIONAL_UNEQUAL(0, 0)); + assertFalse(AQL_RELATIONAL_UNEQUAL(-1, -1)); + assertFalse(AQL_RELATIONAL_UNEQUAL(1.345, 1.345)); + assertFalse(AQL_RELATIONAL_UNEQUAL(1.0, 1.00)); + assertFalse(AQL_RELATIONAL_UNEQUAL(1.0, 1.000)); + assertFalse(AQL_RELATIONAL_UNEQUAL(1.1, 1.1)); + assertFalse(AQL_RELATIONAL_UNEQUAL(1.01, 1.01)); + assertFalse(AQL_RELATIONAL_UNEQUAL(1.001, 1.001)); + assertFalse(AQL_RELATIONAL_UNEQUAL(1.0001, 1.0001)); + assertFalse(AQL_RELATIONAL_UNEQUAL(1.00001, 1.00001)); + assertFalse(AQL_RELATIONAL_UNEQUAL(1.000001, 1.000001)); + assertFalse(AQL_RELATIONAL_UNEQUAL(1.245e307, 1.245e307)); + assertFalse(AQL_RELATIONAL_UNEQUAL(-99.43423, -99.43423)); + assertFalse(AQL_RELATIONAL_UNEQUAL(true, true)); + assertFalse(AQL_RELATIONAL_UNEQUAL(false, false)); + assertFalse(AQL_RELATIONAL_UNEQUAL('', '')); + assertFalse(AQL_RELATIONAL_UNEQUAL(' ', ' ')); + assertFalse(AQL_RELATIONAL_UNEQUAL(' 1', ' 1')); + assertFalse(AQL_RELATIONAL_UNEQUAL('0', '0')); + assertFalse(AQL_RELATIONAL_UNEQUAL('abc', 'abc')); + assertFalse(AQL_RELATIONAL_UNEQUAL('-1', '-1')); + assertFalse(AQL_RELATIONAL_UNEQUAL(null, null)); + assertFalse(AQL_RELATIONAL_UNEQUAL('true', 'true')); + assertFalse(AQL_RELATIONAL_UNEQUAL('false', 'false')); + assertFalse(AQL_RELATIONAL_UNEQUAL('undefined', 'undefined')); + assertFalse(AQL_RELATIONAL_UNEQUAL('null', 'null')); + assertFalse(AQL_RELATIONAL_UNEQUAL([ ], [ ])); + assertFalse(AQL_RELATIONAL_UNEQUAL([ 0 ], [ 0 ])); + assertFalse(AQL_RELATIONAL_UNEQUAL([ 0, 1 ], [ 0, 1 ])); + assertFalse(AQL_RELATIONAL_UNEQUAL([ 0, 1, 4 ], [ 0, 1, 4 ])); + assertFalse(AQL_RELATIONAL_UNEQUAL([ 3, 4, -99 ], [ 3, 4, -99 ])); + assertFalse(AQL_RELATIONAL_UNEQUAL([ 'a', 4, [ 1, 'a' ], false ], [ 'a', 4, [ 1, 'a' ], false ])); + assertFalse(AQL_RELATIONAL_UNEQUAL({ }, { })); + assertFalse(AQL_RELATIONAL_UNEQUAL({ 'a' : true }, { 'a' : true })); + assertFalse(AQL_RELATIONAL_UNEQUAL({ 'a' : true, 'b': true }, { 'a' : true, 'b': true })); + assertFalse(AQL_RELATIONAL_UNEQUAL({ 'a' : true, 'b': true }, { 'b' : true, 'a': true })); + assertFalse(AQL_RELATIONAL_UNEQUAL({ 'b' : true, 'a': true }, { 'b' : true, 'a': true })); + assertFalse(AQL_RELATIONAL_UNEQUAL({ 'b' : true, 'a': true }, { 'a' : true, 'b': true })); + assertFalse(AQL_RELATIONAL_UNEQUAL({ 'a' : [ 0, 1 ], 'b' : [ 1, 9 ] }, { 'a' : [ 0, 1 ], 'b' : [ 1, 9 ] })); + assertFalse(AQL_RELATIONAL_UNEQUAL({ 'a' : [ 0, 1 ], 'b' : [ 1, 9 ] }, { 'b' : [ 1, 9 ], 'a' : [ 0, 1 ] })); + assertFalse(AQL_RELATIONAL_UNEQUAL({ 'f' : { 'c' : { 'd' : [ 0, 1 ], 'a' : [ 1, 9 ] }, 'a' : false }, 'a' : true }, { 'a' : true, 'f' : { 'a' : false, 'c' : { 'a' : [ 1, 9 ], 'd' : [ 0, 1 ] } } })); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_RELATIONAL_LESS function +//////////////////////////////////////////////////////////////////////////////// + + function testRelationalLessUndefined () { + assertEqual(undefined, AQL_RELATIONAL_LESS(undefined, undefined)); + assertEqual(undefined, AQL_RELATIONAL_LESS(undefined, null)); + assertEqual(undefined, AQL_RELATIONAL_LESS(undefined, true)); + assertEqual(undefined, AQL_RELATIONAL_LESS(undefined, false)); + assertEqual(undefined, AQL_RELATIONAL_LESS(undefined, 0.0)); + assertEqual(undefined, AQL_RELATIONAL_LESS(undefined, 1.0)); + assertEqual(undefined, AQL_RELATIONAL_LESS(undefined, -1.0)); + assertEqual(undefined, AQL_RELATIONAL_LESS(undefined, '')); + assertEqual(undefined, AQL_RELATIONAL_LESS(undefined, '0')); + assertEqual(undefined, AQL_RELATIONAL_LESS(undefined, '1')); + assertEqual(undefined, AQL_RELATIONAL_LESS(undefined, [ ])); + assertEqual(undefined, AQL_RELATIONAL_LESS(undefined, [ 0 ])); + assertEqual(undefined, AQL_RELATIONAL_LESS(undefined, [ 0, 1 ])); + assertEqual(undefined, AQL_RELATIONAL_LESS(undefined, [ 1, 2 ])); + assertEqual(undefined, AQL_RELATIONAL_LESS(undefined, { })); + assertEqual(undefined, AQL_RELATIONAL_LESS(undefined, { 'a' : 0 })); + assertEqual(undefined, AQL_RELATIONAL_LESS(undefined, { 'a' : 1 })); + assertEqual(undefined, AQL_RELATIONAL_LESS(undefined, { '0' : false })); + assertEqual(undefined, AQL_RELATIONAL_LESS(null, undefined)); + assertEqual(undefined, AQL_RELATIONAL_LESS(true, undefined)); + assertEqual(undefined, AQL_RELATIONAL_LESS(false, undefined)); + assertEqual(undefined, AQL_RELATIONAL_LESS(0.0, undefined)); + assertEqual(undefined, AQL_RELATIONAL_LESS(1.0, undefined)); + assertEqual(undefined, AQL_RELATIONAL_LESS(-1.0, undefined)); + assertEqual(undefined, AQL_RELATIONAL_LESS('', undefined)); + assertEqual(undefined, AQL_RELATIONAL_LESS('0', undefined)); + assertEqual(undefined, AQL_RELATIONAL_LESS('1', undefined)); + assertEqual(undefined, AQL_RELATIONAL_LESS([ ], undefined)); + assertEqual(undefined, AQL_RELATIONAL_LESS([ 0 ], undefined)); + assertEqual(undefined, AQL_RELATIONAL_LESS([ 0, 1 ], undefined)); + assertEqual(undefined, AQL_RELATIONAL_LESS([ 1, 2 ], undefined)); + assertEqual(undefined, AQL_RELATIONAL_LESS({ }, undefined)); + assertEqual(undefined, AQL_RELATIONAL_LESS({ 'a' : 0 }, undefined)); + assertEqual(undefined, AQL_RELATIONAL_LESS({ 'a' : 1 }, undefined)); + assertEqual(undefined, AQL_RELATIONAL_LESS({ '0' : false }, undefined)); + assertEqual(undefined, AQL_RELATIONAL_LESS(NaN, false)); + assertEqual(undefined, AQL_RELATIONAL_LESS(NaN, true)); + assertEqual(undefined, AQL_RELATIONAL_LESS(NaN, '')); + assertEqual(undefined, AQL_RELATIONAL_LESS(NaN, 0)); + assertEqual(undefined, AQL_RELATIONAL_LESS(NaN, null)); + assertEqual(undefined, AQL_RELATIONAL_LESS(NaN, undefined)); + assertEqual(undefined, AQL_RELATIONAL_LESS(false, NaN)); + assertEqual(undefined, AQL_RELATIONAL_LESS(true, NaN)); + assertEqual(undefined, AQL_RELATIONAL_LESS('', NaN)); + assertEqual(undefined, AQL_RELATIONAL_LESS(0, NaN)); + assertEqual(undefined, AQL_RELATIONAL_LESS(null, NaN)); + assertEqual(undefined, AQL_RELATIONAL_LESS(undefined, NaN)); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_RELATIONAL_LESS function +//////////////////////////////////////////////////////////////////////////////// + + function testRelationalLessTrue () { + assertTrue(AQL_RELATIONAL_LESS(null, false)); + assertTrue(AQL_RELATIONAL_LESS(null, true)); + assertTrue(AQL_RELATIONAL_LESS(null, 0)); + assertTrue(AQL_RELATIONAL_LESS(null, 1)); + assertTrue(AQL_RELATIONAL_LESS(null, -1)); + assertTrue(AQL_RELATIONAL_LESS(null, '')); + assertTrue(AQL_RELATIONAL_LESS(null, ' ')); + assertTrue(AQL_RELATIONAL_LESS(null, '1')); + assertTrue(AQL_RELATIONAL_LESS(null, '0')); + assertTrue(AQL_RELATIONAL_LESS(null, 'abcd')); + assertTrue(AQL_RELATIONAL_LESS(null, 'null')); + assertTrue(AQL_RELATIONAL_LESS(null, [ ])); + assertTrue(AQL_RELATIONAL_LESS(null, [ true ])); + assertTrue(AQL_RELATIONAL_LESS(null, [ false ])); + assertTrue(AQL_RELATIONAL_LESS(null, [ null ])); + assertTrue(AQL_RELATIONAL_LESS(null, [ 0 ])); + assertTrue(AQL_RELATIONAL_LESS(null, { })); + assertTrue(AQL_RELATIONAL_LESS(null, { 'a' : null })); + assertTrue(AQL_RELATIONAL_LESS(false, true)); + assertTrue(AQL_RELATIONAL_LESS(false, 0)); + assertTrue(AQL_RELATIONAL_LESS(false, 1)); + assertTrue(AQL_RELATIONAL_LESS(false, -1)); + assertTrue(AQL_RELATIONAL_LESS(false, '')); + assertTrue(AQL_RELATIONAL_LESS(false, ' ')); + assertTrue(AQL_RELATIONAL_LESS(false, '1')); + assertTrue(AQL_RELATIONAL_LESS(false, '0')); + assertTrue(AQL_RELATIONAL_LESS(false, 'abcd')); + assertTrue(AQL_RELATIONAL_LESS(false, 'true')); + assertTrue(AQL_RELATIONAL_LESS(false, [ ])); + assertTrue(AQL_RELATIONAL_LESS(false, [ true ])); + assertTrue(AQL_RELATIONAL_LESS(false, [ false ])); + assertTrue(AQL_RELATIONAL_LESS(false, [ null ])); + assertTrue(AQL_RELATIONAL_LESS(false, [ 0 ])); + assertTrue(AQL_RELATIONAL_LESS(false, { })); + assertTrue(AQL_RELATIONAL_LESS(false, { 'a' : null })); + assertTrue(AQL_RELATIONAL_LESS(true, 0)); + assertTrue(AQL_RELATIONAL_LESS(true, 1)); + assertTrue(AQL_RELATIONAL_LESS(true, -1)); + assertTrue(AQL_RELATIONAL_LESS(true, '')); + assertTrue(AQL_RELATIONAL_LESS(true, ' ')); + assertTrue(AQL_RELATIONAL_LESS(true, '1')); + assertTrue(AQL_RELATIONAL_LESS(true, '0')); + assertTrue(AQL_RELATIONAL_LESS(true, 'abcd')); + assertTrue(AQL_RELATIONAL_LESS(true, 'true')); + assertTrue(AQL_RELATIONAL_LESS(true, [ ])); + assertTrue(AQL_RELATIONAL_LESS(true, [ true ])); + assertTrue(AQL_RELATIONAL_LESS(true, [ false ])); + assertTrue(AQL_RELATIONAL_LESS(true, [ null ])); + assertTrue(AQL_RELATIONAL_LESS(true, [ 0 ])); + assertTrue(AQL_RELATIONAL_LESS(true, { })); + assertTrue(AQL_RELATIONAL_LESS(true, { 'a' : null })); + assertTrue(AQL_RELATIONAL_LESS(0, 1)); + assertTrue(AQL_RELATIONAL_LESS(1, 2)); + assertTrue(AQL_RELATIONAL_LESS(1, 100)); + assertTrue(AQL_RELATIONAL_LESS(20, 100)); + assertTrue(AQL_RELATIONAL_LESS(-100, 1)); + assertTrue(AQL_RELATIONAL_LESS(-100, -10)); + assertTrue(AQL_RELATIONAL_LESS(-11, -10)); + assertTrue(AQL_RELATIONAL_LESS(999, 1000)); + assertTrue(AQL_RELATIONAL_LESS(-1, 1)); + assertTrue(AQL_RELATIONAL_LESS(-1, 0)); + assertTrue(AQL_RELATIONAL_LESS(1.0, 1.01)); + assertTrue(AQL_RELATIONAL_LESS(1.111, 1.2)); + assertTrue(AQL_RELATIONAL_LESS(-1.111, -1.110)); + assertTrue(AQL_RELATIONAL_LESS(-1.111, -1.1109)); + assertTrue(AQL_RELATIONAL_LESS(0, '')); + assertTrue(AQL_RELATIONAL_LESS(0, ' ')); + assertTrue(AQL_RELATIONAL_LESS(0, '0')); + assertTrue(AQL_RELATIONAL_LESS(0, '1')); + assertTrue(AQL_RELATIONAL_LESS(0, '-1')); + assertTrue(AQL_RELATIONAL_LESS(0, 'true')); + assertTrue(AQL_RELATIONAL_LESS(0, 'false')); + assertTrue(AQL_RELATIONAL_LESS(0, 'null')); + assertTrue(AQL_RELATIONAL_LESS(1, '')); + assertTrue(AQL_RELATIONAL_LESS(1, ' ')); + assertTrue(AQL_RELATIONAL_LESS(1, '0')); + assertTrue(AQL_RELATIONAL_LESS(1, '1')); + assertTrue(AQL_RELATIONAL_LESS(1, '-1')); + assertTrue(AQL_RELATIONAL_LESS(1, 'true')); + assertTrue(AQL_RELATIONAL_LESS(1, 'false')); + assertTrue(AQL_RELATIONAL_LESS(1, 'null')); + assertTrue(AQL_RELATIONAL_LESS(0, '-1')); + assertTrue(AQL_RELATIONAL_LESS(0, '-100')); + assertTrue(AQL_RELATIONAL_LESS(0, '-1.1')); + assertTrue(AQL_RELATIONAL_LESS(0, '-0.0')); + assertTrue(AQL_RELATIONAL_LESS(1000, '-1')); + assertTrue(AQL_RELATIONAL_LESS(1000, '10')); + assertTrue(AQL_RELATIONAL_LESS(1000, '10000')); + assertTrue(AQL_RELATIONAL_LESS(0, [ ])); + assertTrue(AQL_RELATIONAL_LESS(0, [ 0 ])); + assertTrue(AQL_RELATIONAL_LESS(10, [ ])); + assertTrue(AQL_RELATIONAL_LESS(100, [ ])); + assertTrue(AQL_RELATIONAL_LESS(100, [ 0 ])); + assertTrue(AQL_RELATIONAL_LESS(100, [ 0, 1 ])); + assertTrue(AQL_RELATIONAL_LESS(100, [ 99 ])); + assertTrue(AQL_RELATIONAL_LESS(100, [ 100 ])); + assertTrue(AQL_RELATIONAL_LESS(100, [ 101 ])); + assertTrue(AQL_RELATIONAL_LESS(100, { })); + assertTrue(AQL_RELATIONAL_LESS(100, { 'a' : 0 })); + assertTrue(AQL_RELATIONAL_LESS(100, { 'a' : 1 })); + assertTrue(AQL_RELATIONAL_LESS(100, { 'a' : 99 })); + assertTrue(AQL_RELATIONAL_LESS(100, { 'a' : 100 })); + assertTrue(AQL_RELATIONAL_LESS(100, { 'a' : 101 })); + assertTrue(AQL_RELATIONAL_LESS(100, { 'a' : 1000 })); + assertTrue(AQL_RELATIONAL_LESS('', ' ')); + assertTrue(AQL_RELATIONAL_LESS('0', 'a')); + assertTrue(AQL_RELATIONAL_LESS('a', 'a ')); + assertTrue(AQL_RELATIONAL_LESS('a', 'b')); + assertTrue(AQL_RELATIONAL_LESS('A', 'a')); + assertTrue(AQL_RELATIONAL_LESS('AB', 'Ab')); + assertTrue(AQL_RELATIONAL_LESS('abcd', 'bbcd')); + assertTrue(AQL_RELATIONAL_LESS('abcd', 'abda')); + assertTrue(AQL_RELATIONAL_LESS('abcd', 'abdd')); + assertTrue(AQL_RELATIONAL_LESS('abcd', 'abcde')); + assertTrue(AQL_RELATIONAL_LESS('0abcd', 'abcde')); + assertTrue(AQL_RELATIONAL_LESS([ ], [ 0 ])); + assertTrue(AQL_RELATIONAL_LESS([ 0 ], [ 1 ])); + assertTrue(AQL_RELATIONAL_LESS([ 0, 1, 2 ], [ 0, 1, 2, 3 ])); + assertTrue(AQL_RELATIONAL_LESS([ 0, 1, 2 ], [ 0, 1, 3 ])); + assertTrue(AQL_RELATIONAL_LESS([ 0, 1, 4 ], [ 1, 0, 0 ])); + assertTrue(AQL_RELATIONAL_LESS([ 0, 1, 4 ], [ 1 ])); + assertTrue(AQL_RELATIONAL_LESS([ 15, 99 ], [ 110 ])); + assertTrue(AQL_RELATIONAL_LESS([ 15, 99 ], [ 15, 100 ])); + assertTrue(AQL_RELATIONAL_LESS([ ], [ undefined ])); + assertTrue(AQL_RELATIONAL_LESS([ ], [ null ])); + assertTrue(AQL_RELATIONAL_LESS([ ], [ false ])); + assertTrue(AQL_RELATIONAL_LESS([ ], [ true ])); + assertTrue(AQL_RELATIONAL_LESS([ ], [ 0 ])); + assertTrue(AQL_RELATIONAL_LESS([ ], [ -1 ])); + assertTrue(AQL_RELATIONAL_LESS([ ], [ '' ])); + assertTrue(AQL_RELATIONAL_LESS([ ], [ '0' ])); + assertTrue(AQL_RELATIONAL_LESS([ ], [ 'abcd' ])); + assertTrue(AQL_RELATIONAL_LESS([ ], [ [ ] ])); + assertTrue(AQL_RELATIONAL_LESS([ ], [ [ null ] ])); + assertTrue(AQL_RELATIONAL_LESS([ ], [ { } ])); + assertTrue(AQL_RELATIONAL_LESS([ null ], [ false ])); + assertTrue(AQL_RELATIONAL_LESS([ null ], [ true ])); + assertTrue(AQL_RELATIONAL_LESS([ null ], [ 0 ])); + assertTrue(AQL_RELATIONAL_LESS([ null ], [ [ ] ])); + assertTrue(AQL_RELATIONAL_LESS([ false ], [ true ])); + assertTrue(AQL_RELATIONAL_LESS([ false ], [ 0 ])); + assertTrue(AQL_RELATIONAL_LESS([ false ], [ -1 ])); + assertTrue(AQL_RELATIONAL_LESS([ false ], [ '' ])); + assertTrue(AQL_RELATIONAL_LESS([ false ], [ '0' ])); + assertTrue(AQL_RELATIONAL_LESS([ false ], [ 'abcd' ])); + assertTrue(AQL_RELATIONAL_LESS([ false ], [ [ ] ])); + assertTrue(AQL_RELATIONAL_LESS([ false ], [ [ false ] ])); + assertTrue(AQL_RELATIONAL_LESS([ true ], [ 0 ])); + assertTrue(AQL_RELATIONAL_LESS([ true ], [ -1 ])); + assertTrue(AQL_RELATIONAL_LESS([ true ], [ '' ])); + assertTrue(AQL_RELATIONAL_LESS([ true ], [ '0' ])); + assertTrue(AQL_RELATIONAL_LESS([ true ], [ 'abcd' ])); + assertTrue(AQL_RELATIONAL_LESS([ true ], [ [ ] ])); + assertTrue(AQL_RELATIONAL_LESS([ true ], [ [ false ] ])); + assertTrue(AQL_RELATIONAL_LESS([ false, false ], [ true ])); + assertTrue(AQL_RELATIONAL_LESS([ false, false ], [ false, true ])); + assertTrue(AQL_RELATIONAL_LESS([ false, false ], [ false, 0 ])); + assertTrue(AQL_RELATIONAL_LESS([ null, null ], [ null, false ])); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_RELATIONAL_LESS function +//////////////////////////////////////////////////////////////////////////////// + + function testRelationalLessFalse () { + assertFalse(AQL_RELATIONAL_LESS(false, null)); + assertFalse(AQL_RELATIONAL_LESS(true, null)); + assertFalse(AQL_RELATIONAL_LESS(0, null)); + assertFalse(AQL_RELATIONAL_LESS(1, null)); + assertFalse(AQL_RELATIONAL_LESS(-1, null)); + assertFalse(AQL_RELATIONAL_LESS('', null)); + assertFalse(AQL_RELATIONAL_LESS(' ', null)); + assertFalse(AQL_RELATIONAL_LESS('1', null)); + assertFalse(AQL_RELATIONAL_LESS('0', null)); + assertFalse(AQL_RELATIONAL_LESS('abcd', null)); + assertFalse(AQL_RELATIONAL_LESS('null', null)); + assertFalse(AQL_RELATIONAL_LESS([ ], null)); + assertFalse(AQL_RELATIONAL_LESS([ true ], null)); + assertFalse(AQL_RELATIONAL_LESS([ false ], null)); + assertFalse(AQL_RELATIONAL_LESS([ null ], null)); + assertFalse(AQL_RELATIONAL_LESS([ 0 ], null)); + assertFalse(AQL_RELATIONAL_LESS({ }, null)); + assertFalse(AQL_RELATIONAL_LESS({ 'a' : null }, null)); + assertFalse(AQL_RELATIONAL_LESS(true, false)); + assertFalse(AQL_RELATIONAL_LESS(0, false)); + assertFalse(AQL_RELATIONAL_LESS(1, false)); + assertFalse(AQL_RELATIONAL_LESS(-1, false)); + assertFalse(AQL_RELATIONAL_LESS('', false)); + assertFalse(AQL_RELATIONAL_LESS(' ', false)); + assertFalse(AQL_RELATIONAL_LESS('1', false)); + assertFalse(AQL_RELATIONAL_LESS('0', false)); + assertFalse(AQL_RELATIONAL_LESS('abcd', false)); + assertFalse(AQL_RELATIONAL_LESS('true', false)); + assertFalse(AQL_RELATIONAL_LESS([ ], false)); + assertFalse(AQL_RELATIONAL_LESS([ true ], false)); + assertFalse(AQL_RELATIONAL_LESS([ false ], false)); + assertFalse(AQL_RELATIONAL_LESS([ null ], false)); + assertFalse(AQL_RELATIONAL_LESS([ 0 ], false)); + assertFalse(AQL_RELATIONAL_LESS({ }, false)); + assertFalse(AQL_RELATIONAL_LESS({ 'a' : null }, false)); + assertFalse(AQL_RELATIONAL_LESS(0, true)); + assertFalse(AQL_RELATIONAL_LESS(1, true)); + assertFalse(AQL_RELATIONAL_LESS(-1, true)); + assertFalse(AQL_RELATIONAL_LESS('', true)); + assertFalse(AQL_RELATIONAL_LESS(' ', true)); + assertFalse(AQL_RELATIONAL_LESS('1', true)); + assertFalse(AQL_RELATIONAL_LESS('0', true)); + assertFalse(AQL_RELATIONAL_LESS('abcd', true)); + assertFalse(AQL_RELATIONAL_LESS('true', true)); + assertFalse(AQL_RELATIONAL_LESS([ ], true)); + assertFalse(AQL_RELATIONAL_LESS([ true ], true)); + assertFalse(AQL_RELATIONAL_LESS([ false ], true)); + assertFalse(AQL_RELATIONAL_LESS([ null ], true)); + assertFalse(AQL_RELATIONAL_LESS([ 0 ], true)); + assertFalse(AQL_RELATIONAL_LESS({ }, true)); + assertFalse(AQL_RELATIONAL_LESS({ 'a' : null }, true)); + assertFalse(AQL_RELATIONAL_LESS(1, 0)); + assertFalse(AQL_RELATIONAL_LESS(2, 1)); + assertFalse(AQL_RELATIONAL_LESS(100, 1)); + assertFalse(AQL_RELATIONAL_LESS(100, 20)); + assertFalse(AQL_RELATIONAL_LESS(1, -100)); + assertFalse(AQL_RELATIONAL_LESS(-10, -100)); + assertFalse(AQL_RELATIONAL_LESS(-10, -11)); + assertFalse(AQL_RELATIONAL_LESS(1000, 999)); + assertFalse(AQL_RELATIONAL_LESS(1, -1)); + assertFalse(AQL_RELATIONAL_LESS(0, -1)); + assertFalse(AQL_RELATIONAL_LESS(1.01, 1.0)); + assertFalse(AQL_RELATIONAL_LESS(1.2, 1.111)); + assertFalse(AQL_RELATIONAL_LESS(-1.110, -1.111)); + assertFalse(AQL_RELATIONAL_LESS(-1.1109, -1.111)); + assertFalse(AQL_RELATIONAL_LESS('', 0)); + assertFalse(AQL_RELATIONAL_LESS(' ', 0)); + assertFalse(AQL_RELATIONAL_LESS('0', 0)); + assertFalse(AQL_RELATIONAL_LESS('1', 0)); + assertFalse(AQL_RELATIONAL_LESS('-1', 0)); + assertFalse(AQL_RELATIONAL_LESS('true', 0)); + assertFalse(AQL_RELATIONAL_LESS('false', 0)); + assertFalse(AQL_RELATIONAL_LESS('null', 0)); + assertFalse(AQL_RELATIONAL_LESS('', 1)); + assertFalse(AQL_RELATIONAL_LESS(' ', 1)); + assertFalse(AQL_RELATIONAL_LESS('0', 1)); + assertFalse(AQL_RELATIONAL_LESS('1', 1)); + assertFalse(AQL_RELATIONAL_LESS('-1', 1)); + assertFalse(AQL_RELATIONAL_LESS('true', 1)); + assertFalse(AQL_RELATIONAL_LESS('false', 1)); + assertFalse(AQL_RELATIONAL_LESS('null', 1)); + assertFalse(AQL_RELATIONAL_LESS('-1', 0)); + assertFalse(AQL_RELATIONAL_LESS('-100', 0)); + assertFalse(AQL_RELATIONAL_LESS('-1.1', 0)); + assertFalse(AQL_RELATIONAL_LESS('-0.0', 0)); + assertFalse(AQL_RELATIONAL_LESS('-1', 1000)); + assertFalse(AQL_RELATIONAL_LESS('10', 1000)); + assertFalse(AQL_RELATIONAL_LESS('10000', 1000)); + assertFalse(AQL_RELATIONAL_LESS([ ], 0)); + assertFalse(AQL_RELATIONAL_LESS([ 0 ], 0)); + assertFalse(AQL_RELATIONAL_LESS([ ], 10)); + assertFalse(AQL_RELATIONAL_LESS([ ], 100)); + assertFalse(AQL_RELATIONAL_LESS([ 0 ], 100)); + assertFalse(AQL_RELATIONAL_LESS([ 0, 1 ], 100)); + assertFalse(AQL_RELATIONAL_LESS([ 99 ], 100)); + assertFalse(AQL_RELATIONAL_LESS([ 100 ], 100)); + assertFalse(AQL_RELATIONAL_LESS([ 101 ], 100)); + assertFalse(AQL_RELATIONAL_LESS({ }, 100)); + assertFalse(AQL_RELATIONAL_LESS({ 'a' : 0 }, 100)); + assertFalse(AQL_RELATIONAL_LESS({ 'a' : 1 }, 100)); + assertFalse(AQL_RELATIONAL_LESS({ 'a' : 99 }, 100)); + assertFalse(AQL_RELATIONAL_LESS({ 'a' : 100 }, 100)); + assertFalse(AQL_RELATIONAL_LESS({ 'a' : 101 }, 100)); + assertFalse(AQL_RELATIONAL_LESS({ 'a' : 1000 }, 100)); + assertFalse(AQL_RELATIONAL_LESS({ 'a' : false }, 'zz')); + assertFalse(AQL_RELATIONAL_LESS({ 'a' : 'a' }, 'zz')); + assertFalse(AQL_RELATIONAL_LESS(' ', '')); + assertFalse(AQL_RELATIONAL_LESS('a', '0')); + assertFalse(AQL_RELATIONAL_LESS('a ', 'a')); + assertFalse(AQL_RELATIONAL_LESS('b', 'a')); + assertFalse(AQL_RELATIONAL_LESS('a', 'A')); + assertFalse(AQL_RELATIONAL_LESS('Ab', 'AB')); + assertFalse(AQL_RELATIONAL_LESS('bbcd', 'abcd')); + assertFalse(AQL_RELATIONAL_LESS('abda', 'abcd')); + assertFalse(AQL_RELATIONAL_LESS('abdd', 'abcd')); + assertFalse(AQL_RELATIONAL_LESS('abcde', 'abcd')); + assertFalse(AQL_RELATIONAL_LESS('abcde', '0abcde')); + assertFalse(AQL_RELATIONAL_LESS([ 0 ], [ ])); + assertFalse(AQL_RELATIONAL_LESS([ 1 ], [ 0 ])); + assertFalse(AQL_RELATIONAL_LESS([ 0, 1, 2, 3 ], [ 0, 1, 2 ])); + assertFalse(AQL_RELATIONAL_LESS([ 0, 1, 3 ], [ 0, 1, 2 ])); + assertFalse(AQL_RELATIONAL_LESS([ 1, 0, 0 ], [ 0, 1, 4 ])); + assertFalse(AQL_RELATIONAL_LESS([ 1 ], [ 0, 1, 4 ])); + assertFalse(AQL_RELATIONAL_LESS([ 110 ], [ 15, 99 ])); + assertFalse(AQL_RELATIONAL_LESS([ 15, 100 ], [ 15, 99 ])); + assertFalse(AQL_RELATIONAL_LESS([ undefined ], [ ])); + assertFalse(AQL_RELATIONAL_LESS([ null ], [ ])); + assertFalse(AQL_RELATIONAL_LESS([ false ], [ ])); + assertFalse(AQL_RELATIONAL_LESS([ true ], [ ])); + assertFalse(AQL_RELATIONAL_LESS([ 0 ], [ ])); + assertFalse(AQL_RELATIONAL_LESS([ -1 ], [ ])); + assertFalse(AQL_RELATIONAL_LESS([ '' ], [ ])); + assertFalse(AQL_RELATIONAL_LESS([ '0' ], [ ])); + assertFalse(AQL_RELATIONAL_LESS([ 'abcd' ], [ ])); + assertFalse(AQL_RELATIONAL_LESS([ [ ] ], [ ])); + assertFalse(AQL_RELATIONAL_LESS([ [ null ] ], [ ])); + assertFalse(AQL_RELATIONAL_LESS([ { } ], [ ])); + assertFalse(AQL_RELATIONAL_LESS([ false ], [ null ])); + assertFalse(AQL_RELATIONAL_LESS([ true ], [ null ])); + assertFalse(AQL_RELATIONAL_LESS([ 0 ], [ null ])); + assertFalse(AQL_RELATIONAL_LESS([ [ ] ], [ null ])); + assertFalse(AQL_RELATIONAL_LESS([ true ], [ false ])); + assertFalse(AQL_RELATIONAL_LESS([ 0 ], [ false ])); + assertFalse(AQL_RELATIONAL_LESS([ -1 ], [ false ])); + assertFalse(AQL_RELATIONAL_LESS([ '' ], [ false ])); + assertFalse(AQL_RELATIONAL_LESS([ '0' ], [ false ])); + assertFalse(AQL_RELATIONAL_LESS([ 'abcd' ], [ false ])); + assertFalse(AQL_RELATIONAL_LESS([ [ ] ], [ false ])); + assertFalse(AQL_RELATIONAL_LESS([ [ false ] ], [ false ])); + assertFalse(AQL_RELATIONAL_LESS([ 0 ], [ true ])); + assertFalse(AQL_RELATIONAL_LESS([ -1 ], [ true ])); + assertFalse(AQL_RELATIONAL_LESS([ '' ], [ true ])); + assertFalse(AQL_RELATIONAL_LESS([ '0' ], [ true ])); + assertFalse(AQL_RELATIONAL_LESS([ 'abcd' ], [ true ])); + assertFalse(AQL_RELATIONAL_LESS([ [ ] ], [ true ])); + assertFalse(AQL_RELATIONAL_LESS([ [ false] ], [ true ])); + assertFalse(AQL_RELATIONAL_LESS([ true ], [ false, false ])); + assertFalse(AQL_RELATIONAL_LESS([ false, true ], [ false, false ])); + assertFalse(AQL_RELATIONAL_LESS([ false, 0 ], [ false, false ])); + assertFalse(AQL_RELATIONAL_LESS([ null, false ], [ null, null ])); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_RELATIONAL_GREATER function +//////////////////////////////////////////////////////////////////////////////// + + function testRelationalGreaterUndefined () { + assertEqual(undefined, AQL_RELATIONAL_GREATER(undefined, undefined)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(undefined, null)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(undefined, true)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(undefined, false)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(undefined, 0.0)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(undefined, 1.0)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(undefined, -1.0)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(undefined, '')); + assertEqual(undefined, AQL_RELATIONAL_GREATER(undefined, '0')); + assertEqual(undefined, AQL_RELATIONAL_GREATER(undefined, '1')); + assertEqual(undefined, AQL_RELATIONAL_GREATER(undefined, [ ])); + assertEqual(undefined, AQL_RELATIONAL_GREATER(undefined, [ 0 ])); + assertEqual(undefined, AQL_RELATIONAL_GREATER(undefined, [ 0, 1 ])); + assertEqual(undefined, AQL_RELATIONAL_GREATER(undefined, [ 1, 2 ])); + assertEqual(undefined, AQL_RELATIONAL_GREATER(undefined, { })); + assertEqual(undefined, AQL_RELATIONAL_GREATER(undefined, { 'a' : 0 })); + assertEqual(undefined, AQL_RELATIONAL_GREATER(undefined, { 'a' : 1 })); + assertEqual(undefined, AQL_RELATIONAL_GREATER(undefined, { '0' : false })); + assertEqual(undefined, AQL_RELATIONAL_GREATER(null, undefined)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(true, undefined)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(false, undefined)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(0.0, undefined)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(1.0, undefined)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(-1.0, undefined)); + assertEqual(undefined, AQL_RELATIONAL_GREATER('', undefined)); + assertEqual(undefined, AQL_RELATIONAL_GREATER('0', undefined)); + assertEqual(undefined, AQL_RELATIONAL_GREATER('1', undefined)); + assertEqual(undefined, AQL_RELATIONAL_GREATER([ ], undefined)); + assertEqual(undefined, AQL_RELATIONAL_GREATER([ 0 ], undefined)); + assertEqual(undefined, AQL_RELATIONAL_GREATER([ 0, 1 ], undefined)); + assertEqual(undefined, AQL_RELATIONAL_GREATER([ 1, 2 ], undefined)); + assertEqual(undefined, AQL_RELATIONAL_GREATER({ }, undefined)); + assertEqual(undefined, AQL_RELATIONAL_GREATER({ 'a' : 0 }, undefined)); + assertEqual(undefined, AQL_RELATIONAL_GREATER({ 'a' : 1 }, undefined)); + assertEqual(undefined, AQL_RELATIONAL_GREATER({ '0' : false }, undefined)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(NaN, false)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(NaN, true)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(NaN, '')); + assertEqual(undefined, AQL_RELATIONAL_GREATER(NaN, 0)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(NaN, null)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(NaN, undefined)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(false, NaN)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(true, NaN)); + assertEqual(undefined, AQL_RELATIONAL_GREATER('', NaN)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(0, NaN)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(null, NaN)); + assertEqual(undefined, AQL_RELATIONAL_GREATER(undefined, NaN)); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_RELATIONAL_GREATER function +//////////////////////////////////////////////////////////////////////////////// + + function testRelationalGreaterTrue () { + assertTrue(AQL_RELATIONAL_GREATER(false, null)); + assertTrue(AQL_RELATIONAL_GREATER(true, null)); + assertTrue(AQL_RELATIONAL_GREATER(0, null)); + assertTrue(AQL_RELATIONAL_GREATER(1, null)); + assertTrue(AQL_RELATIONAL_GREATER(-1, null)); + assertTrue(AQL_RELATIONAL_GREATER('', null)); + assertTrue(AQL_RELATIONAL_GREATER(' ', null)); + assertTrue(AQL_RELATIONAL_GREATER('1', null)); + assertTrue(AQL_RELATIONAL_GREATER('0', null)); + assertTrue(AQL_RELATIONAL_GREATER('abcd', null)); + assertTrue(AQL_RELATIONAL_GREATER('null', null)); + assertTrue(AQL_RELATIONAL_GREATER([ ], null)); + assertTrue(AQL_RELATIONAL_GREATER([ true ], null)); + assertTrue(AQL_RELATIONAL_GREATER([ false ], null)); + assertTrue(AQL_RELATIONAL_GREATER([ null ], null)); + assertTrue(AQL_RELATIONAL_GREATER([ 0 ], null)); + assertTrue(AQL_RELATIONAL_GREATER({ }, null)); + assertTrue(AQL_RELATIONAL_GREATER({ 'a' : null }, null)); + assertTrue(AQL_RELATIONAL_GREATER(true, false)); + assertTrue(AQL_RELATIONAL_GREATER(0, false)); + assertTrue(AQL_RELATIONAL_GREATER(1, false)); + assertTrue(AQL_RELATIONAL_GREATER(-1, false)); + assertTrue(AQL_RELATIONAL_GREATER('', false)); + assertTrue(AQL_RELATIONAL_GREATER(' ', false)); + assertTrue(AQL_RELATIONAL_GREATER('1', false)); + assertTrue(AQL_RELATIONAL_GREATER('0', false)); + assertTrue(AQL_RELATIONAL_GREATER('abcd', false)); + assertTrue(AQL_RELATIONAL_GREATER('true', false)); + assertTrue(AQL_RELATIONAL_GREATER([ ], false)); + assertTrue(AQL_RELATIONAL_GREATER([ true ], false)); + assertTrue(AQL_RELATIONAL_GREATER([ false ], false)); + assertTrue(AQL_RELATIONAL_GREATER([ null ], false)); + assertTrue(AQL_RELATIONAL_GREATER([ 0 ], false)); + assertTrue(AQL_RELATIONAL_GREATER({ }, false)); + assertTrue(AQL_RELATIONAL_GREATER({ 'a' : null }, false)); + assertTrue(AQL_RELATIONAL_GREATER(0, true)); + assertTrue(AQL_RELATIONAL_GREATER(1, true)); + assertTrue(AQL_RELATIONAL_GREATER(-1, true)); + assertTrue(AQL_RELATIONAL_GREATER('', true)); + assertTrue(AQL_RELATIONAL_GREATER(' ', true)); + assertTrue(AQL_RELATIONAL_GREATER('1', true)); + assertTrue(AQL_RELATIONAL_GREATER('0', true)); + assertTrue(AQL_RELATIONAL_GREATER('abcd', true)); + assertTrue(AQL_RELATIONAL_GREATER('true', true)); + assertTrue(AQL_RELATIONAL_GREATER([ ], true)); + assertTrue(AQL_RELATIONAL_GREATER([ true ], true)); + assertTrue(AQL_RELATIONAL_GREATER([ false ], true)); + assertTrue(AQL_RELATIONAL_GREATER([ null ], true)); + assertTrue(AQL_RELATIONAL_GREATER([ 0 ], true)); + assertTrue(AQL_RELATIONAL_GREATER({ }, true)); + assertTrue(AQL_RELATIONAL_GREATER({ 'a' : null }, true)); + assertTrue(AQL_RELATIONAL_GREATER(1, 0)); + assertTrue(AQL_RELATIONAL_GREATER(2, 1)); + assertTrue(AQL_RELATIONAL_GREATER(100, 1)); + assertTrue(AQL_RELATIONAL_GREATER(100, 20)); + assertTrue(AQL_RELATIONAL_GREATER(1, -100)); + assertTrue(AQL_RELATIONAL_GREATER(-10, -100)); + assertTrue(AQL_RELATIONAL_GREATER(-10, -11)); + assertTrue(AQL_RELATIONAL_GREATER(1000, 999)); + assertTrue(AQL_RELATIONAL_GREATER(1, -1)); + assertTrue(AQL_RELATIONAL_GREATER(0, -1)); + assertTrue(AQL_RELATIONAL_GREATER(1.01, 1.0)); + assertTrue(AQL_RELATIONAL_GREATER(1.2, 1.111)); + assertTrue(AQL_RELATIONAL_GREATER(-1.110, -1.111)); + assertTrue(AQL_RELATIONAL_GREATER(-1.1109, -1.111)); + assertTrue(AQL_RELATIONAL_GREATER('', 0)); + assertTrue(AQL_RELATIONAL_GREATER(' ', 0)); + assertTrue(AQL_RELATIONAL_GREATER('0', 0)); + assertTrue(AQL_RELATIONAL_GREATER('1', 0)); + assertTrue(AQL_RELATIONAL_GREATER('-1', 0)); + assertTrue(AQL_RELATIONAL_GREATER('true', 0)); + assertTrue(AQL_RELATIONAL_GREATER('false', 0)); + assertTrue(AQL_RELATIONAL_GREATER('null', 0)); + assertTrue(AQL_RELATIONAL_GREATER('', 1)); + assertTrue(AQL_RELATIONAL_GREATER(' ', 1)); + assertTrue(AQL_RELATIONAL_GREATER('0', 1)); + assertTrue(AQL_RELATIONAL_GREATER('1', 1)); + assertTrue(AQL_RELATIONAL_GREATER('-1', 1)); + assertTrue(AQL_RELATIONAL_GREATER('true', 1)); + assertTrue(AQL_RELATIONAL_GREATER('false', 1)); + assertTrue(AQL_RELATIONAL_GREATER('null', 1)); + assertTrue(AQL_RELATIONAL_GREATER('-1', 0)); + assertTrue(AQL_RELATIONAL_GREATER('-100', 0)); + assertTrue(AQL_RELATIONAL_GREATER('-1.1', 0)); + assertTrue(AQL_RELATIONAL_GREATER('-0.0', 0)); + assertTrue(AQL_RELATIONAL_GREATER('-1', 1000)); + assertTrue(AQL_RELATIONAL_GREATER('10', 1000)); + assertTrue(AQL_RELATIONAL_GREATER('10000', 1000)); + assertTrue(AQL_RELATIONAL_GREATER([ ], 0)); + assertTrue(AQL_RELATIONAL_GREATER([ 0 ], 0)); + assertTrue(AQL_RELATIONAL_GREATER([ ], 10)); + assertTrue(AQL_RELATIONAL_GREATER([ ], 100)); + assertTrue(AQL_RELATIONAL_GREATER([ 0 ], 100)); + assertTrue(AQL_RELATIONAL_GREATER([ 0, 1 ], 100)); + assertTrue(AQL_RELATIONAL_GREATER([ 99 ], 100)); + assertTrue(AQL_RELATIONAL_GREATER([ 100 ], 100)); + assertTrue(AQL_RELATIONAL_GREATER([ 101 ], 100)); + assertTrue(AQL_RELATIONAL_GREATER({ }, 100)); + assertTrue(AQL_RELATIONAL_GREATER({ 'a' : 0 }, 100)); + assertTrue(AQL_RELATIONAL_GREATER({ 'a' : 1 }, 100)); + assertTrue(AQL_RELATIONAL_GREATER({ 'a' : 99 }, 100)); + assertTrue(AQL_RELATIONAL_GREATER({ 'a' : 100 }, 100)); + assertTrue(AQL_RELATIONAL_GREATER({ 'a' : 101 }, 100)); + assertTrue(AQL_RELATIONAL_GREATER({ 'a' : 1000 }, 100)); + assertTrue(AQL_RELATIONAL_GREATER({ 'a' : false }, 'zz')); + assertTrue(AQL_RELATIONAL_GREATER({ 'a' : 'a' }, 'zz')); + assertTrue(AQL_RELATIONAL_GREATER(' ', '')); + assertTrue(AQL_RELATIONAL_GREATER('a', '0')); + assertTrue(AQL_RELATIONAL_GREATER('a ', 'a')); + assertTrue(AQL_RELATIONAL_GREATER('b', 'a')); + assertTrue(AQL_RELATIONAL_GREATER('a', 'A')); + assertTrue(AQL_RELATIONAL_GREATER('Ab', 'AB')); + assertTrue(AQL_RELATIONAL_GREATER('bbcd', 'abcd')); + assertTrue(AQL_RELATIONAL_GREATER('abda', 'abcd')); + assertTrue(AQL_RELATIONAL_GREATER('abdd', 'abcd')); + assertTrue(AQL_RELATIONAL_GREATER('abcde', 'abcd')); + assertTrue(AQL_RELATIONAL_GREATER('abcde', '0abcde')); + assertTrue(AQL_RELATIONAL_GREATER([ 0 ], [ ])); + assertTrue(AQL_RELATIONAL_GREATER([ 1 ], [ 0 ])); + assertTrue(AQL_RELATIONAL_GREATER([ 0, 1, 2, 3 ], [ 0, 1, 2 ])); + assertTrue(AQL_RELATIONAL_GREATER([ 0, 1, 3 ], [ 0, 1, 2 ])); + assertTrue(AQL_RELATIONAL_GREATER([ 1, 0, 0 ], [ 0, 1, 4 ])); + assertTrue(AQL_RELATIONAL_GREATER([ 1 ], [ 0, 1, 4 ])); + assertTrue(AQL_RELATIONAL_GREATER([ 110 ], [ 15, 99 ])); + assertTrue(AQL_RELATIONAL_GREATER([ 15, 100 ], [ 15, 99 ])); + assertTrue(AQL_RELATIONAL_GREATER([ undefined ], [ ])); + assertTrue(AQL_RELATIONAL_GREATER([ null ], [ ])); + assertTrue(AQL_RELATIONAL_GREATER([ false ], [ ])); + assertTrue(AQL_RELATIONAL_GREATER([ true ], [ ])); + assertTrue(AQL_RELATIONAL_GREATER([ 0 ], [ ])); + assertTrue(AQL_RELATIONAL_GREATER([ -1 ], [ ])); + assertTrue(AQL_RELATIONAL_GREATER([ '' ], [ ])); + assertTrue(AQL_RELATIONAL_GREATER([ '0' ], [ ])); + assertTrue(AQL_RELATIONAL_GREATER([ 'abcd' ], [ ])); + assertTrue(AQL_RELATIONAL_GREATER([ [ ] ], [ ])); + assertTrue(AQL_RELATIONAL_GREATER([ [ null ] ], [ ])); + assertTrue(AQL_RELATIONAL_GREATER([ { } ], [ ])); + assertTrue(AQL_RELATIONAL_GREATER([ false ], [ null ])); + assertTrue(AQL_RELATIONAL_GREATER([ true ], [ null ])); + assertTrue(AQL_RELATIONAL_GREATER([ 0 ], [ null ])); + assertTrue(AQL_RELATIONAL_GREATER([ [ ] ], [ null ])); + assertTrue(AQL_RELATIONAL_GREATER([ true ], [ false ])); + assertTrue(AQL_RELATIONAL_GREATER([ 0 ], [ false ])); + assertTrue(AQL_RELATIONAL_GREATER([ -1 ], [ false ])); + assertTrue(AQL_RELATIONAL_GREATER([ '' ], [ false ])); + assertTrue(AQL_RELATIONAL_GREATER([ '0' ], [ false ])); + assertTrue(AQL_RELATIONAL_GREATER([ 'abcd' ], [ false ])); + assertTrue(AQL_RELATIONAL_GREATER([ [ ] ], [ false ])); + assertTrue(AQL_RELATIONAL_GREATER([ [ false ] ], [ false ])); + assertTrue(AQL_RELATIONAL_GREATER([ 0 ], [ true ])); + assertTrue(AQL_RELATIONAL_GREATER([ -1 ], [ true ])); + assertTrue(AQL_RELATIONAL_GREATER([ '' ], [ true ])); + assertTrue(AQL_RELATIONAL_GREATER([ '0' ], [ true ])); + assertTrue(AQL_RELATIONAL_GREATER([ 'abcd' ], [ true ])); + assertTrue(AQL_RELATIONAL_GREATER([ [ ] ], [ true ])); + assertTrue(AQL_RELATIONAL_GREATER([ [ false] ], [ true ])); + assertTrue(AQL_RELATIONAL_GREATER([ true ], [ false, false ])); + assertTrue(AQL_RELATIONAL_GREATER([ false, true ], [ false, false ])); + assertTrue(AQL_RELATIONAL_GREATER([ false, 0 ], [ false, false ])); + assertTrue(AQL_RELATIONAL_GREATER([ null, false ], [ null, null ])); + } + +//////////////////////////////////////////////////////////////////////////////// +/// @brief test AQL_RELATIONAL_GREATER function +//////////////////////////////////////////////////////////////////////////////// + + function testRelationalGreaterFalse () { + assertFalse(AQL_RELATIONAL_GREATER(null, false)); + assertFalse(AQL_RELATIONAL_GREATER(null, true)); + assertFalse(AQL_RELATIONAL_GREATER(null, 0)); + assertFalse(AQL_RELATIONAL_GREATER(null, 1)); + assertFalse(AQL_RELATIONAL_GREATER(null, -1)); + assertFalse(AQL_RELATIONAL_GREATER(null, '')); + assertFalse(AQL_RELATIONAL_GREATER(null, ' ')); + assertFalse(AQL_RELATIONAL_GREATER(null, '1')); + assertFalse(AQL_RELATIONAL_GREATER(null, '0')); + assertFalse(AQL_RELATIONAL_GREATER(null, 'abcd')); + assertFalse(AQL_RELATIONAL_GREATER(null, 'null')); + assertFalse(AQL_RELATIONAL_GREATER(null, [ ])); + assertFalse(AQL_RELATIONAL_GREATER(null, [ true ])); + assertFalse(AQL_RELATIONAL_GREATER(null, [ false ])); + assertFalse(AQL_RELATIONAL_GREATER(null, [ null ])); + assertFalse(AQL_RELATIONAL_GREATER(null, [ 0 ])); + assertFalse(AQL_RELATIONAL_GREATER(null, { })); + assertFalse(AQL_RELATIONAL_GREATER(null, { 'a' : null })); + assertFalse(AQL_RELATIONAL_GREATER(false, true)); + assertFalse(AQL_RELATIONAL_GREATER(false, 0)); + assertFalse(AQL_RELATIONAL_GREATER(false, 1)); + assertFalse(AQL_RELATIONAL_GREATER(false, -1)); + assertFalse(AQL_RELATIONAL_GREATER(false, '')); + assertFalse(AQL_RELATIONAL_GREATER(false, ' ')); + assertFalse(AQL_RELATIONAL_GREATER(false, '1')); + assertFalse(AQL_RELATIONAL_GREATER(false, '0')); + assertFalse(AQL_RELATIONAL_GREATER(false, 'abcd')); + assertFalse(AQL_RELATIONAL_GREATER(false, 'true')); + assertFalse(AQL_RELATIONAL_GREATER(false, [ ])); + assertFalse(AQL_RELATIONAL_GREATER(false, [ true ])); + assertFalse(AQL_RELATIONAL_GREATER(false, [ false ])); + assertFalse(AQL_RELATIONAL_GREATER(false, [ null ])); + assertFalse(AQL_RELATIONAL_GREATER(false, [ 0 ])); + assertFalse(AQL_RELATIONAL_GREATER(false, { })); + assertFalse(AQL_RELATIONAL_GREATER(false, { 'a' : null })); + assertFalse(AQL_RELATIONAL_GREATER(true, 0)); + assertFalse(AQL_RELATIONAL_GREATER(true, 1)); + assertFalse(AQL_RELATIONAL_GREATER(true, -1)); + assertFalse(AQL_RELATIONAL_GREATER(true, '')); + assertFalse(AQL_RELATIONAL_GREATER(true, ' ')); + assertFalse(AQL_RELATIONAL_GREATER(true, '1')); + assertFalse(AQL_RELATIONAL_GREATER(true, '0')); + assertFalse(AQL_RELATIONAL_GREATER(true, 'abcd')); + assertFalse(AQL_RELATIONAL_GREATER(true, 'true')); + assertFalse(AQL_RELATIONAL_GREATER(true, [ ])); + assertFalse(AQL_RELATIONAL_GREATER(true, [ true ])); + assertFalse(AQL_RELATIONAL_GREATER(true, [ false ])); + assertFalse(AQL_RELATIONAL_GREATER(true, [ null ])); + assertFalse(AQL_RELATIONAL_GREATER(true, [ 0 ])); + assertFalse(AQL_RELATIONAL_GREATER(true, { })); + assertFalse(AQL_RELATIONAL_GREATER(true, { 'a' : null })); + assertFalse(AQL_RELATIONAL_GREATER(0, 1)); + assertFalse(AQL_RELATIONAL_GREATER(1, 2)); + assertFalse(AQL_RELATIONAL_GREATER(1, 100)); + assertFalse(AQL_RELATIONAL_GREATER(20, 100)); + assertFalse(AQL_RELATIONAL_GREATER(-100, 1)); + assertFalse(AQL_RELATIONAL_GREATER(-100, -10)); + assertFalse(AQL_RELATIONAL_GREATER(-11, -10)); + assertFalse(AQL_RELATIONAL_GREATER(999, 1000)); + assertFalse(AQL_RELATIONAL_GREATER(-1, 1)); + assertFalse(AQL_RELATIONAL_GREATER(-1, 0)); + assertFalse(AQL_RELATIONAL_GREATER(1.0, 1.01)); + assertFalse(AQL_RELATIONAL_GREATER(1.111, 1.2)); + assertFalse(AQL_RELATIONAL_GREATER(-1.111, -1.110)); + assertFalse(AQL_RELATIONAL_GREATER(-1.111, -1.1109)); + assertFalse(AQL_RELATIONAL_GREATER(0, '')); + assertFalse(AQL_RELATIONAL_GREATER(0, ' ')); + assertFalse(AQL_RELATIONAL_GREATER(0, '0')); + assertFalse(AQL_RELATIONAL_GREATER(0, '1')); + assertFalse(AQL_RELATIONAL_GREATER(0, '-1')); + assertFalse(AQL_RELATIONAL_GREATER(0, 'true')); + assertFalse(AQL_RELATIONAL_GREATER(0, 'false')); + assertFalse(AQL_RELATIONAL_GREATER(0, 'null')); + assertFalse(AQL_RELATIONAL_GREATER(1, '')); + assertFalse(AQL_RELATIONAL_GREATER(1, ' ')); + assertFalse(AQL_RELATIONAL_GREATER(1, '0')); + assertFalse(AQL_RELATIONAL_GREATER(1, '1')); + assertFalse(AQL_RELATIONAL_GREATER(1, '-1')); + assertFalse(AQL_RELATIONAL_GREATER(1, 'true')); + assertFalse(AQL_RELATIONAL_GREATER(1, 'false')); + assertFalse(AQL_RELATIONAL_GREATER(1, 'null')); + assertFalse(AQL_RELATIONAL_GREATER(0, '-1')); + assertFalse(AQL_RELATIONAL_GREATER(0, '-100')); + assertFalse(AQL_RELATIONAL_GREATER(0, '-1.1')); + assertFalse(AQL_RELATIONAL_GREATER(0, '-0.0')); + assertFalse(AQL_RELATIONAL_GREATER(1000, '-1')); + assertFalse(AQL_RELATIONAL_GREATER(1000, '10')); + assertFalse(AQL_RELATIONAL_GREATER(1000, '10000')); + assertFalse(AQL_RELATIONAL_GREATER(0, [ ])); + assertFalse(AQL_RELATIONAL_GREATER(0, [ 0 ])); + assertFalse(AQL_RELATIONAL_GREATER(10, [ ])); + assertFalse(AQL_RELATIONAL_GREATER(100, [ ])); + assertFalse(AQL_RELATIONAL_GREATER(100, [ 0 ])); + assertFalse(AQL_RELATIONAL_GREATER(100, [ 0, 1 ])); + assertFalse(AQL_RELATIONAL_GREATER(100, [ 99 ])); + assertFalse(AQL_RELATIONAL_GREATER(100, [ 100 ])); + assertFalse(AQL_RELATIONAL_GREATER(100, [ 101 ])); + assertFalse(AQL_RELATIONAL_GREATER(100, { })); + assertFalse(AQL_RELATIONAL_GREATER(100, { 'a' : 0 })); + assertFalse(AQL_RELATIONAL_GREATER(100, { 'a' : 1 })); + assertFalse(AQL_RELATIONAL_GREATER(100, { 'a' : 99 })); + assertFalse(AQL_RELATIONAL_GREATER(100, { 'a' : 100 })); + assertFalse(AQL_RELATIONAL_GREATER(100, { 'a' : 101 })); + assertFalse(AQL_RELATIONAL_GREATER(100, { 'a' : 1000 })); + assertFalse(AQL_RELATIONAL_GREATER('', ' ')); + assertFalse(AQL_RELATIONAL_GREATER('0', 'a')); + assertFalse(AQL_RELATIONAL_GREATER('a', 'a ')); + assertFalse(AQL_RELATIONAL_GREATER('a', 'b')); + assertFalse(AQL_RELATIONAL_GREATER('A', 'a')); + assertFalse(AQL_RELATIONAL_GREATER('AB', 'Ab')); + assertFalse(AQL_RELATIONAL_GREATER('abcd', 'bbcd')); + assertFalse(AQL_RELATIONAL_GREATER('abcd', 'abda')); + assertFalse(AQL_RELATIONAL_GREATER('abcd', 'abdd')); + assertFalse(AQL_RELATIONAL_GREATER('abcd', 'abcde')); + assertFalse(AQL_RELATIONAL_GREATER('0abcd', 'abcde')); + assertFalse(AQL_RELATIONAL_GREATER([ ], [ 0 ])); + assertFalse(AQL_RELATIONAL_GREATER([ 0 ], [ 1 ])); + assertFalse(AQL_RELATIONAL_GREATER([ 0, 1, 2 ], [ 0, 1, 2, 3 ])); + assertFalse(AQL_RELATIONAL_GREATER([ 0, 1, 2 ], [ 0, 1, 3 ])); + assertFalse(AQL_RELATIONAL_GREATER([ 0, 1, 4 ], [ 1, 0, 0 ])); + assertFalse(AQL_RELATIONAL_GREATER([ 0, 1, 4 ], [ 1 ])); + assertFalse(AQL_RELATIONAL_GREATER([ 15, 99 ], [ 110 ])); + assertFalse(AQL_RELATIONAL_GREATER([ 15, 99 ], [ 15, 100 ])); + assertFalse(AQL_RELATIONAL_GREATER([ ], [ undefined ])); + assertFalse(AQL_RELATIONAL_GREATER([ ], [ null ])); + assertFalse(AQL_RELATIONAL_GREATER([ ], [ false ])); + assertFalse(AQL_RELATIONAL_GREATER([ ], [ true ])); + assertFalse(AQL_RELATIONAL_GREATER([ ], [ 0 ])); + assertFalse(AQL_RELATIONAL_GREATER([ ], [ -1 ])); + assertFalse(AQL_RELATIONAL_GREATER([ ], [ '' ])); + assertFalse(AQL_RELATIONAL_GREATER([ ], [ '0' ])); + assertFalse(AQL_RELATIONAL_GREATER([ ], [ 'abcd' ])); + assertFalse(AQL_RELATIONAL_GREATER([ ], [ [ ] ])); + assertFalse(AQL_RELATIONAL_GREATER([ ], [ [ null ] ])); + assertFalse(AQL_RELATIONAL_GREATER([ ], [ { } ])); + assertFalse(AQL_RELATIONAL_GREATER([ null ], [ false ])); + assertFalse(AQL_RELATIONAL_GREATER([ null ], [ true ])); + assertFalse(AQL_RELATIONAL_GREATER([ null ], [ 0 ])); + assertFalse(AQL_RELATIONAL_GREATER([ null ], [ [ ] ])); + assertFalse(AQL_RELATIONAL_GREATER([ false ], [ true ])); + assertFalse(AQL_RELATIONAL_GREATER([ false ], [ 0 ])); + assertFalse(AQL_RELATIONAL_GREATER([ false ], [ -1 ])); + assertFalse(AQL_RELATIONAL_GREATER([ false ], [ '' ])); + assertFalse(AQL_RELATIONAL_GREATER([ false ], [ '0' ])); + assertFalse(AQL_RELATIONAL_GREATER([ false ], [ 'abcd' ])); + assertFalse(AQL_RELATIONAL_GREATER([ false ], [ [ ] ])); + assertFalse(AQL_RELATIONAL_GREATER([ false ], [ [ false ] ])); + assertFalse(AQL_RELATIONAL_GREATER([ true ], [ 0 ])); + assertFalse(AQL_RELATIONAL_GREATER([ true ], [ -1 ])); + assertFalse(AQL_RELATIONAL_GREATER([ true ], [ '' ])); + assertFalse(AQL_RELATIONAL_GREATER([ true ], [ '0' ])); + assertFalse(AQL_RELATIONAL_GREATER([ true ], [ 'abcd' ])); + assertFalse(AQL_RELATIONAL_GREATER([ true ], [ [ ] ])); + assertFalse(AQL_RELATIONAL_GREATER([ true ], [ [ false ] ])); + assertFalse(AQL_RELATIONAL_GREATER([ false, false ], [ true ])); + assertFalse(AQL_RELATIONAL_GREATER([ false, false ], [ false, true ])); + assertFalse(AQL_RELATIONAL_GREATER([ false, false ], [ false, 0 ])); + assertFalse(AQL_RELATIONAL_GREATER([ null, null ], [ null, false ])); + } + +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief executes the test suite +//////////////////////////////////////////////////////////////////////////////// + +jsUnity.run(aqlOperatorsTestSuite); + +// Local Variables: +// mode: outline-minor +// outline-regexp: "^\\(/// @brief\\|/// @addtogroup\\|// --SECTION--\\|/// @page\\|/// @}\\)" +// End: