mirror of https://gitee.com/bigwinds/arangodb
3528 lines
168 KiB
JavaScript
3528 lines
168 KiB
JavaScript
/*jshint globalstrict:false, strict:false, maxlen: 500 */
|
|
/*global assertEqual, assertFalse, assertTrue, AQL_EXECUTE */
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tests for query language, 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
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var jsunity = require("jsunity");
|
|
var aql = require("@arangodb/aql");
|
|
var db = require("internal").db;
|
|
|
|
var LOGICAL_AND = function (a, b) {
|
|
return db._query("RETURN " + JSON.stringify(a) + " && " + JSON.stringify(b)).toArray()[0];
|
|
};
|
|
var LOGICAL_OR = function (a, b) {
|
|
return db._query("RETURN " + JSON.stringify(a) + " || " + JSON.stringify(b)).toArray()[0];
|
|
};
|
|
var LOGICAL_NOT = function (a) {
|
|
return db._query("RETURN !" + JSON.stringify(a)).toArray()[0];
|
|
};
|
|
var UNARY_PLUS = function (a) {
|
|
return db._query("RETURN +" + JSON.stringify(a)).toArray()[0];
|
|
};
|
|
var UNARY_MINUS = function (a) {
|
|
return db._query("RETURN -" + JSON.stringify(a)).toArray()[0];
|
|
};
|
|
var ARITHMETIC_PLUS = function (a, b) {
|
|
return db._query("RETURN " + JSON.stringify(a) + " + " + JSON.stringify(b)).toArray()[0];
|
|
};
|
|
var ARITHMETIC_MINUS = function (a, b) {
|
|
return db._query("RETURN " + JSON.stringify(a) + " - " + JSON.stringify(b)).toArray()[0];
|
|
};
|
|
var ARITHMETIC_TIMES = function (a, b) {
|
|
return db._query("RETURN " + JSON.stringify(a) + " * " + JSON.stringify(b)).toArray()[0];
|
|
};
|
|
var ARITHMETIC_DIVIDE = function (a, b) {
|
|
return db._query("RETURN " + JSON.stringify(a) + " / " + JSON.stringify(b)).toArray()[0];
|
|
};
|
|
var ARITHMETIC_MODULUS = function (a, b) {
|
|
return db._query("RETURN " + JSON.stringify(a) + " % " + JSON.stringify(b)).toArray()[0];
|
|
};
|
|
var RELATIONAL_EQUAL = function (a, b) {
|
|
return db._query("RETURN " + JSON.stringify(a) + " == " + JSON.stringify(b)).toArray()[0];
|
|
};
|
|
var RELATIONAL_UNEQUAL = function (a, b) {
|
|
return db._query("RETURN " + JSON.stringify(a) + " != " + JSON.stringify(b)).toArray()[0];
|
|
};
|
|
var RELATIONAL_LESS = function (a, b) {
|
|
return db._query("RETURN " + JSON.stringify(a) + " < " + JSON.stringify(b)).toArray()[0];
|
|
};
|
|
var RELATIONAL_LESSEQUAL = function (a, b) {
|
|
return db._query("RETURN " + JSON.stringify(a) + " <= " + JSON.stringify(b)).toArray()[0];
|
|
};
|
|
var RELATIONAL_GREATER = function (a, b) {
|
|
return db._query("RETURN " + JSON.stringify(a) + " > " + JSON.stringify(b)).toArray()[0];
|
|
};
|
|
var RELATIONAL_GREATEREQUAL = function (a, b) {
|
|
return db._query("RETURN " + JSON.stringify(a) + " >= " + JSON.stringify(b)).toArray()[0];
|
|
};
|
|
var RELATIONAL_IN = function (a, b) {
|
|
return db._query("RETURN " + JSON.stringify(a) + " IN " + JSON.stringify(b)).toArray()[0];
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function ahuacatlOperatorsTestSuite () {
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp: function() {},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown: function() {},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.IS_NULL function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testIsNullTrue: function() {
|
|
var values = [ null ];
|
|
values.forEach(function (v) {
|
|
assertTrue(db._query(`RETURN IS_NULL(${v})`).next());
|
|
assertTrue(db._query(`RETURN NOOPT(IS_NULL(${v}))`).next());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.IS_NULL function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testIsNullFalse: function() {
|
|
var values = [
|
|
0,
|
|
1,
|
|
-1,
|
|
0.1,
|
|
-0.1,
|
|
false,
|
|
true,
|
|
'"abc"',
|
|
'"null"',
|
|
'"false"',
|
|
'"undefined"',
|
|
'""',
|
|
'" "',
|
|
"[ ]",
|
|
"[ 0 ]",
|
|
"[ 0, 1 ]",
|
|
"[ 1, 2 ]",
|
|
"{ }",
|
|
"{ 'a' : 0 }",
|
|
"{ 'a' : 1 }",
|
|
"{ 'a' : 0, 'b' :1 }"
|
|
];
|
|
values.forEach(function (v) {
|
|
assertFalse(db._query(`RETURN IS_NULL(${v})`).next());
|
|
assertFalse(db._query(`RETURN NOOPT(IS_NULL(${v}))`).next());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.IS_BOOL function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testIsBoolTrue: function() {
|
|
var values = [ false, true ];
|
|
values.forEach(function (v) {
|
|
assertTrue(db._query(`RETURN IS_BOOL(${v})`).next());
|
|
assertTrue(db._query(`RETURN NOOPT(IS_BOOL(${v}))`).next());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.IS_BOOL function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testIsBoolFalse: function() {
|
|
var values = [
|
|
0,
|
|
1,
|
|
-1,
|
|
0.1,
|
|
-0.1,
|
|
null,
|
|
'"abc"',
|
|
'"null"',
|
|
'"false"',
|
|
'"undefined"',
|
|
'""',
|
|
'" "',
|
|
"[ ]",
|
|
"[ 0 ]",
|
|
"[ 0, 1 ]",
|
|
"[ 1, 2 ]",
|
|
"[ '' ]",
|
|
"[ '0' ]",
|
|
"[ '1' ]",
|
|
"[ true ]",
|
|
"[ false ]",
|
|
"{ }",
|
|
"{ 'a' : 0 }",
|
|
"{ 'a' : 1 }",
|
|
"{ 'a' : 0, 'b' :1 }"
|
|
];
|
|
|
|
values.forEach(function (v) {
|
|
assertFalse(db._query(`RETURN IS_BOOL(${v})`).next());
|
|
assertFalse(db._query(`RETURN NOOPT(IS_BOOL(${v}))`).next());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.IS_NUMBER function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testIsNumberTrue: function() {
|
|
var values = [0, 1, -1, 0.1, 12.5356, -235.26436, -23.3e17, 563.44576e19];
|
|
|
|
values.forEach(function (v) {
|
|
assertTrue(db._query(`RETURN IS_NUMBER(${v})`).next());
|
|
assertTrue(db._query(`RETURN NOOPT(IS_NUMBER(${v}))`).next());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.IS_NUMBER function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testIsNumberFalse: function() {
|
|
var values = [
|
|
false,
|
|
true,
|
|
null,
|
|
'"abc"',
|
|
'"null"',
|
|
'"false"',
|
|
'"undefined"',
|
|
'""',
|
|
'" "',
|
|
"[ ]",
|
|
"[ 0 ]",
|
|
"[ 0, 1 ]",
|
|
"[ 1, 2 ]",
|
|
"[ '' ]",
|
|
"[ '0' ]",
|
|
"[ '1' ]",
|
|
"[ true ]",
|
|
"[ false ]",
|
|
"{ }",
|
|
"{ 'a' : 0 }",
|
|
"{ 'a' : 1 }",
|
|
"{ 'a' : 0, 'b' :1 }"
|
|
];
|
|
|
|
values.forEach(function (v) {
|
|
assertFalse(db._query(`RETURN IS_NUMBER(${v})`).next());
|
|
assertFalse(db._query(`RETURN NOOPT(IS_NUMBER(${v}))`).next());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.IS_STRING function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testIsStringTrue: function() {
|
|
var values = ["'abc'", "'null'", "'false'", "'undefined'", "''", "' '"];
|
|
values.forEach(function (v) {
|
|
assertTrue(db._query(`RETURN IS_STRING(${v})`).next());
|
|
assertTrue(db._query(`RETURN NOOPT(IS_STRING(${v}))`).next());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.IS_STRING function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testIsStringFalse: function() {
|
|
var values = [
|
|
false,
|
|
true,
|
|
0,
|
|
1,
|
|
-1,
|
|
0.1,
|
|
-0.1,
|
|
null,
|
|
"[ ]",
|
|
"[ 0 ]",
|
|
"[ 0, 1 ]",
|
|
"[ 1, 2 ]",
|
|
"[ '' ]",
|
|
"[ '0' ]",
|
|
"[ '1' ]",
|
|
"[ true ]",
|
|
"[ false ]",
|
|
"{ }",
|
|
"{ 'a' : 0 }",
|
|
"{ 'a' : 1 }",
|
|
"{ 'a' : 0, 'b' :1 }"
|
|
];
|
|
|
|
values.forEach(function (v) {
|
|
assertFalse(db._query(`RETURN IS_STRING(${v})`).next());
|
|
assertFalse(db._query(`RETURN NOOPT(IS_STRING(${v}))`).next());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.IS_LIST function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testIsListTrue: function() {
|
|
var values = [
|
|
"[ ]",
|
|
"[ 0 ]",
|
|
"[ 0, 1 ]",
|
|
"[ 1, 2 ]",
|
|
"[ '' ]",
|
|
"[ '0' ]",
|
|
"[ '1' ]",
|
|
"[ true ]",
|
|
"[ false ]",
|
|
];
|
|
values.forEach(function (v) {
|
|
assertTrue(db._query(`RETURN IS_LIST(${v})`).next());
|
|
assertTrue(db._query(`RETURN NOOPT(IS_LIST(${v}))`).next());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.IS_LIST function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testIsListFalse: function() {
|
|
var values = [
|
|
0,
|
|
1,
|
|
-1,
|
|
0.1,
|
|
-0.1,
|
|
null,
|
|
false,
|
|
true,
|
|
'"abc"',
|
|
'"null"',
|
|
'"false"',
|
|
'"undefined"',
|
|
'""',
|
|
'" "',
|
|
"{ }",
|
|
"{ 'a' : 0 }",
|
|
"{ 'a' : 1 }",
|
|
"{ 'a' : 0, 'b' :1 }"
|
|
];
|
|
values.forEach(function (v) {
|
|
assertFalse(db._query(`RETURN IS_LIST(${v})`).next());
|
|
assertFalse(db._query(`RETURN NOOPT(IS_LIST(${v}))`).next());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.IS_ARRAY function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testIsArrayTrue: function() {
|
|
var values = [
|
|
"[ ]",
|
|
"[ 0 ]",
|
|
"[ 0, 1 ]",
|
|
"[ 1, 2 ]",
|
|
"[ '' ]",
|
|
"[ '0' ]",
|
|
"[ '1' ]",
|
|
"[ true ]",
|
|
"[ false ]",
|
|
];
|
|
values.forEach(function (v) {
|
|
assertTrue(db._query(`RETURN IS_ARRAY(${v})`).next());
|
|
assertTrue(db._query(`RETURN NOOPT(IS_ARRAY(${v}))`).next());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.IS_ARRAY function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testIsArrayFalse: function() {
|
|
var values = [
|
|
0,
|
|
1,
|
|
-1,
|
|
0.1,
|
|
-0.1,
|
|
null,
|
|
false,
|
|
true,
|
|
'"abc"',
|
|
'"null"',
|
|
'"false"',
|
|
'"undefined"',
|
|
'""',
|
|
'" "',
|
|
"{ }",
|
|
"{ 'a' : 0 }",
|
|
"{ 'a' : 1 }",
|
|
"{ 'a' : 0, 'b' :1 }"
|
|
];
|
|
values.forEach(function (v) {
|
|
assertFalse(db._query(`RETURN IS_ARRAY(${v})`).next());
|
|
assertFalse(db._query(`RETURN NOOPT(IS_ARRAY(${v}))`).next());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.IS_DOCUMENT function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testIsDocumentTrue: function() {
|
|
var values = [
|
|
"{ }",
|
|
"{ 'a' : 0 }",
|
|
"{ 'a' : 1 }",
|
|
"{ 'a' : 0, 'b' : 1 }",
|
|
"{ '1' : false, 'b' : false }",
|
|
"{ '0' : false }",
|
|
];
|
|
values.forEach(function(v) {
|
|
assertTrue(db._query(`RETURN IS_DOCUMENT(${v})`).next());
|
|
assertTrue(db._query(`RETURN NOOPT(IS_DOCUMENT(${v}))`).next());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.IS_DOCUMENT function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testIsDocumentFalse: function() {
|
|
var values = [
|
|
0,
|
|
1,
|
|
-1,
|
|
0.1,
|
|
-0.1,
|
|
null,
|
|
false,
|
|
true,
|
|
'"abc"',
|
|
'"null"',
|
|
'"false"',
|
|
'"undefined"',
|
|
'""',
|
|
'" "',
|
|
"[ ]",
|
|
"[ 0 ]",
|
|
"[ 0, 1 ]",
|
|
"[ 1, 2 ]",
|
|
"[ '' ]",
|
|
"[ '0' ]",
|
|
"[ '1' ]",
|
|
"[ true ]",
|
|
"[ false ]",
|
|
];
|
|
values.forEach(function(v) {
|
|
assertFalse(db._query(`RETURN IS_DOCUMENT(${v})`).next());
|
|
assertFalse(db._query(`RETURN NOOPT(IS_DOCUMENT(${v}))`).next());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.IS_OBJECT function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testIsObjectTrue: function() {
|
|
var values = [
|
|
"{ }",
|
|
"{ 'a' : 0 }",
|
|
"{ 'a' : 1 }",
|
|
"{ 'a' : 0, 'b' : 1 }",
|
|
"{ '1' : false, 'b' : false }",
|
|
"{ '0' : false }",
|
|
];
|
|
values.forEach(function(v) {
|
|
assertTrue(db._query(`RETURN IS_OBJECT(${v})`).next());
|
|
assertTrue(db._query(`RETURN NOOPT(IS_OBJECT(${v}))`).next());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.IS_OBJECT function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testIsObjecttFalse: function() {
|
|
var values = [
|
|
0,
|
|
1,
|
|
-1,
|
|
0.1,
|
|
-0.1,
|
|
null,
|
|
false,
|
|
true,
|
|
'"abc"',
|
|
'"null"',
|
|
'"false"',
|
|
'"undefined"',
|
|
'""',
|
|
'" "',
|
|
"[ ]",
|
|
"[ 0 ]",
|
|
"[ 0, 1 ]",
|
|
"[ 1, 2 ]",
|
|
"[ '' ]",
|
|
"[ '0' ]",
|
|
"[ '1' ]",
|
|
"[ true ]",
|
|
"[ false ]",
|
|
];
|
|
values.forEach(function(v) {
|
|
assertFalse(db._query(`RETURN IS_OBJECT(${v})`).next());
|
|
assertFalse(db._query(`RETURN NOOPT(IS_OBJECT(${v}))`).next());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.TO_BOOL function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCastBoolTrue: function() {
|
|
var values = [
|
|
1,
|
|
2,
|
|
-1,
|
|
100,
|
|
100.01,
|
|
0.001,
|
|
-0.001,
|
|
true,
|
|
'"abc"',
|
|
'"null"',
|
|
'"false"',
|
|
'"undefined"',
|
|
'" "',
|
|
'" "',
|
|
'"1"',
|
|
'"1 "',
|
|
'"0"',
|
|
'"-1"',
|
|
"[ ]",
|
|
"[ 0 ]",
|
|
"[ 0, 1 ]",
|
|
"[ 1, 2 ]",
|
|
"[ -1, 0 ]",
|
|
"[ '' ]",
|
|
"[ true ]",
|
|
"[ false ]",
|
|
"{ }",
|
|
"{ 'a' : true }",
|
|
"{ 'a' : false }",
|
|
"{ 'a' : false, 'b' : 0 }",
|
|
"{ '0' : false }"
|
|
];
|
|
values.forEach(function(v) {
|
|
assertEqual(true, db._query(`RETURN TO_BOOL(${v})`).next());
|
|
assertEqual(true, db._query(`RETURN NOOPT(TO_BOOL(${v}))`).next());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.TO_BOOL function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCastBoolFalse: function() {
|
|
var values = [0, "''", null, false];
|
|
values.forEach(function(v) {
|
|
assertEqual(false, db._query(`RETURN TO_BOOL(${v})`).next());
|
|
assertEqual(false, db._query(`RETURN NOOPT(TO_BOOL(${v}))`).next());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.TO_NUMBER function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCastNumber: function() {
|
|
var values = [
|
|
{ex: 0, val: null},
|
|
{ex: 0, val: false},
|
|
{ex: 1, val: true},
|
|
{ex: 1, val: 1},
|
|
{ex: 2, val: 2},
|
|
{ex: -1, val: -1},
|
|
{ex: 0, val: 0},
|
|
{ex: 0, val: "''"},
|
|
{ex: 0, val: "' '"},
|
|
{ex: 0, val: "' '"},
|
|
{ex: 1, val: "'1'"},
|
|
{ex: 1, val: "'1 '"},
|
|
{ex: 1, val: "' 1 '"},
|
|
{ex: 0, val: "'0'"},
|
|
{ex: -1, val: "'-1'"},
|
|
{ex: -1, val: "'-1 '"},
|
|
{ex: -1, val: "' -1 '"},
|
|
{ex: null, val: "' -1a '"},
|
|
{ex: null, val: "' 1a '"},
|
|
{ex: null, val: "' 12335.3 a '"},
|
|
{ex: null, val: "'a1bc'"},
|
|
{ex: null, val: "'aaa1'"},
|
|
{ex: null, val: "'-a1'"},
|
|
{ex: -1.255, val: "'-1.255'"},
|
|
{ex: -1.23456, val: "'-1.23456'"},
|
|
{ex: -1.23456, val: "'-1.23456 '"},
|
|
{ex: 1.23456, val: "' 1.23456 '"},
|
|
{ex: null, val: "' 1.23456a'"},
|
|
{ex: null, val: "'--1'"},
|
|
{ex: 1, val: "'+1'"},
|
|
{ex: 12.42e32, val: "'12.42e32'"},
|
|
{ex: 0, val: "[]"},
|
|
{ex: 0, val: "[ 0 ]"},
|
|
{ex: -17, val: "[ -17 ]"},
|
|
{ex: null, val: "[ 0, 1 ]"},
|
|
{ex: null, val: "[ 1, 2 ]"},
|
|
{ex: null, val: "[ -1, 0 ]"},
|
|
{ex: null, val: "[ 0, 1, [ 1, 2 ], [ [ 9, 4 ] ] ]"},
|
|
{ex: null, val: "[ { } ]"},
|
|
{ex: null, val: "[ 0, 1, { } ]"},
|
|
{ex: null, val: "[ { }, { } ]"},
|
|
{ex: 0, val: "[ '' ]"},
|
|
{ex: 0, val: "[ false ]"},
|
|
{ex: 1, val: "[ true ]"},
|
|
{ex: null, val: "{ }"},
|
|
{ex: null, val: "{ 'a' : true }"},
|
|
{ex: null, val: "{ 'a' : true, 'b' : 0 }"},
|
|
{ex: null, val: "{ 'a' : { }, 'b' : { } }"},
|
|
{ex: null, val: "{ 'a' : [ ], 'b' : [ ] }"}
|
|
];
|
|
values.forEach(function(v) {
|
|
// double precission check for e=0.0001
|
|
var q = `RETURN TO_NUMBER(${v.val})`;
|
|
var diff = db._query(q).next() - v.ex;
|
|
assertTrue(diff < 0.0001, q);
|
|
q = `RETURN NOOPT(TO_NUMBER(${v.val}))`;
|
|
diff = db._query(q).next() - v.ex;
|
|
assertTrue(diff < 0.0001, q);
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.TO_STRING function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCastString: function() {
|
|
var values = [
|
|
{ex: "", val: null},
|
|
{ex: "false", val: false},
|
|
{ex: "true", val: true},
|
|
{ex: "1", val: 1},
|
|
{ex: "2", val: 2},
|
|
{ex: "-1", val: -1},
|
|
{ex: "0", val: 0},
|
|
{ex: "", val: "''"},
|
|
{ex: " ", val: "' '"},
|
|
{ex: " ", val: "' '"},
|
|
{ex: "1", val: "'1'"},
|
|
{ex: "1 ", val: "'1 '"},
|
|
{ex: "0", val: "'0'"},
|
|
{ex: "-1", val: "'-1'"},
|
|
{ex: "[]", val: "[ ]"},
|
|
{ex: "[0]", val: "[ 0 ]"},
|
|
{ex: "[0,1]", val: "[ 0, 1 ]"},
|
|
{ex: "[1,2]", val: "[ 1, 2 ]"},
|
|
{ex: "[-1,0]", val: "[ -1, 0 ]"},
|
|
{ex: "[0,1,[1,2],[[9,4]]]", val: "[ 0, 1, [1, 2], [ [ 9, 4 ] ] ]"},
|
|
{ex: "[{}]", val: "[ { } ]"},
|
|
{ex: "[0,1,{}]", val: "[ 0, 1, { } ]"},
|
|
{ex: "[{},{}]", val: "[ { }, { } ]"},
|
|
{ex: "[\"\"]", val: "['']"},
|
|
{ex: "[false]", val: "[ false ]"},
|
|
{ex: "[true]", val: "[ true ]"},
|
|
{ex: "{}", val: "{ }"},
|
|
{ex: "{\"a\":true}", val: "{ 'a' : true }"},
|
|
{ex: "{\"a\":true,\"b\":0}", val: "{ 'a' : true, 'b' : 0 }"},
|
|
{ex: "{\"a\":{},\"b\":{}}", val: "{ 'a' : { }, 'b' : { } }"},
|
|
{ex: "{\"a\":[],\"b\":[]}", val: "{ 'a' : [ ], 'b' : [ ] }"}
|
|
];
|
|
values.forEach(function(v) {
|
|
var q = `RETURN TO_STRING(${v.val})`;
|
|
assertEqual(v.ex, db._query(q).next(), q);
|
|
q = `RETURN NOOPT(TO_STRING(${v.val}))`;
|
|
assertEqual(v.ex, db._query(q).next(), q);
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.LOGICAL_AND function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testLogicalAndUndefined: function() {
|
|
assertEqual(null, LOGICAL_AND(true, null));
|
|
assertEqual(null, LOGICAL_AND(null, true));
|
|
assertEqual('', LOGICAL_AND(true, ''));
|
|
assertEqual('', LOGICAL_AND('', true));
|
|
assertEqual(' ', LOGICAL_AND(true, ' '));
|
|
assertEqual(true, LOGICAL_AND(' ', true));
|
|
assertEqual('0', LOGICAL_AND(true, '0'));
|
|
assertEqual(true, LOGICAL_AND('0', true));
|
|
assertEqual('1', LOGICAL_AND(true, '1'));
|
|
assertEqual(true, LOGICAL_AND('1', true));
|
|
assertEqual('true', LOGICAL_AND(true, 'true'));
|
|
assertEqual(true, LOGICAL_AND('true', true));
|
|
assertEqual('false', LOGICAL_AND(true, 'false'));
|
|
assertEqual(true, LOGICAL_AND('false', true));
|
|
assertEqual(0, LOGICAL_AND(true, 0));
|
|
assertEqual(0, LOGICAL_AND(0, true));
|
|
assertEqual(1, LOGICAL_AND(true, 1));
|
|
assertEqual(true, LOGICAL_AND(1, true));
|
|
assertEqual(-1, LOGICAL_AND(true, -1));
|
|
assertEqual(true, LOGICAL_AND(-1, true));
|
|
assertEqual(1.1, LOGICAL_AND(true, 1.1));
|
|
assertEqual(true, LOGICAL_AND(1.1, true));
|
|
assertEqual([ ], LOGICAL_AND(true, [ ]));
|
|
assertEqual(true, LOGICAL_AND([ ], true));
|
|
assertEqual([ 0 ], LOGICAL_AND(true, [ 0 ]));
|
|
assertEqual(true, LOGICAL_AND([ 0 ], true));
|
|
assertEqual([ 0, 1 ], LOGICAL_AND(true, [ 0, 1 ]));
|
|
assertEqual(true, LOGICAL_AND([ 0, 1 ], true));
|
|
assertEqual([ true ], LOGICAL_AND(true, [ true ]));
|
|
assertEqual(true, LOGICAL_AND([ true ], true));
|
|
assertEqual([ false ], LOGICAL_AND(true, [ false ]));
|
|
assertEqual(true, LOGICAL_AND([ false ], true));
|
|
assertEqual({ }, LOGICAL_AND(true, { }));
|
|
assertEqual(true, LOGICAL_AND({ }, true));
|
|
assertEqual({ 'a' : true }, LOGICAL_AND(true, { 'a' : true }));
|
|
assertEqual(true, LOGICAL_AND({ 'a' : true }, true));
|
|
assertEqual({ 'a' : true, 'b' : false }, LOGICAL_AND(true, { 'a' : true, 'b' : false }));
|
|
assertEqual(true, LOGICAL_AND({ 'a' : true, 'b' : false }, true));
|
|
|
|
assertEqual(false, LOGICAL_AND(false, null));
|
|
assertEqual(null, LOGICAL_AND(null, false));
|
|
assertEqual(false, LOGICAL_AND(false, ''));
|
|
assertEqual('', LOGICAL_AND('', false));
|
|
assertEqual(false, LOGICAL_AND(false, ' '));
|
|
assertEqual(false, LOGICAL_AND(' ', false));
|
|
assertEqual(false, LOGICAL_AND(false, '0'));
|
|
assertEqual(false, LOGICAL_AND('0', false));
|
|
assertEqual(false, LOGICAL_AND(false, '1'));
|
|
assertEqual(false, LOGICAL_AND('1', false));
|
|
assertEqual(false, LOGICAL_AND(false, 'true'));
|
|
assertEqual(false, LOGICAL_AND('true', false));
|
|
assertEqual(false, LOGICAL_AND(false, 'false'));
|
|
assertEqual(false, LOGICAL_AND('false', false));
|
|
assertEqual(false, LOGICAL_AND(false, 0));
|
|
assertEqual(0, LOGICAL_AND(0, false));
|
|
assertEqual(false, LOGICAL_AND(false, 1));
|
|
assertEqual(false, LOGICAL_AND(1, false));
|
|
assertEqual(false, LOGICAL_AND(false, -1));
|
|
assertEqual(false, LOGICAL_AND(-1, false));
|
|
assertEqual(false, LOGICAL_AND(false, 1.1));
|
|
assertEqual(false, LOGICAL_AND(1.1, false));
|
|
assertEqual(false, LOGICAL_AND(false, [ ]));
|
|
assertEqual(false, LOGICAL_AND([ ], false));
|
|
assertEqual(false, LOGICAL_AND(false, [ 0 ]));
|
|
assertEqual(false, LOGICAL_AND([ 0 ], false));
|
|
assertEqual(false, LOGICAL_AND(false, [ 0, 1 ]));
|
|
assertEqual(false, LOGICAL_AND([ 0, 1 ], false));
|
|
assertEqual(false, LOGICAL_AND(false, [ true ]));
|
|
assertEqual(true, LOGICAL_AND([ false ], true));
|
|
assertEqual(false, LOGICAL_AND(false, [ false ]));
|
|
assertEqual(false, LOGICAL_AND([ false ], false));
|
|
assertEqual(false, LOGICAL_AND(false, { }));
|
|
assertEqual(false, LOGICAL_AND({ }, false));
|
|
assertEqual(false, LOGICAL_AND(false, { 'a' : true }));
|
|
assertEqual(true, LOGICAL_AND({ 'a' : false }, true));
|
|
assertEqual(false, LOGICAL_AND(false, { 'a' : true, 'b' : false }));
|
|
assertEqual(true, LOGICAL_AND({ 'a' : false, 'b' : false }, true));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.LOGICAL_AND function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testLogicalAndBool: function() {
|
|
assertTrue(LOGICAL_AND(true, true));
|
|
assertFalse(LOGICAL_AND(true, false));
|
|
assertFalse(LOGICAL_AND(false, true));
|
|
assertFalse(LOGICAL_AND(false, false));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.LOGICAL_OR function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testLogicalOrUndefined: function() {
|
|
assertEqual(true, LOGICAL_OR(true, null));
|
|
assertEqual(true, LOGICAL_OR(null, true));
|
|
assertEqual(true, LOGICAL_OR(true, ''));
|
|
assertEqual(true, LOGICAL_OR('', true));
|
|
assertEqual(true, LOGICAL_OR(true, ' '));
|
|
assertEqual(' ', LOGICAL_OR(' ', true));
|
|
assertEqual(true, LOGICAL_OR(true, '0'));
|
|
assertEqual('0', LOGICAL_OR('0', true));
|
|
assertEqual(true, LOGICAL_OR(true, '1'));
|
|
assertEqual('1', LOGICAL_OR('1', true));
|
|
assertEqual(true, LOGICAL_OR(true, 'true'));
|
|
assertEqual('true', LOGICAL_OR('true', true));
|
|
assertEqual(true, LOGICAL_OR(true, 'false'));
|
|
assertEqual('false', LOGICAL_OR('false', true));
|
|
assertEqual(true, LOGICAL_OR(true, 0));
|
|
assertEqual(true, LOGICAL_OR(0, true));
|
|
assertEqual(true, LOGICAL_OR(true, 1));
|
|
assertEqual(1, LOGICAL_OR(1, true));
|
|
assertEqual(true, LOGICAL_OR(true, -1));
|
|
assertEqual(-1, LOGICAL_OR(-1, true));
|
|
assertEqual(true, LOGICAL_OR(true, 1.1));
|
|
assertEqual(1.1, LOGICAL_OR(1.1, true));
|
|
assertEqual(true, LOGICAL_OR(true, [ ]));
|
|
assertEqual([ ], LOGICAL_OR([ ], true));
|
|
assertEqual(true, LOGICAL_OR(true, [ 0 ]));
|
|
assertEqual([ 0 ], LOGICAL_OR([ 0 ], true));
|
|
assertEqual(true, LOGICAL_OR(true, [ 0, 1 ]));
|
|
assertEqual([ 0, 1 ], LOGICAL_OR([ 0, 1 ], true));
|
|
assertEqual(true, LOGICAL_OR(true, [ true ]));
|
|
assertEqual([ true ], LOGICAL_OR([ true ], true));
|
|
assertEqual(true, LOGICAL_OR(true, [ false ]));
|
|
assertEqual([ false ], LOGICAL_OR([ false ], true));
|
|
assertEqual(true, LOGICAL_OR(true, { }));
|
|
assertEqual({ }, LOGICAL_OR({ }, true));
|
|
assertEqual(true, LOGICAL_OR(true, { 'a' : true }));
|
|
assertEqual({ 'a' : true }, LOGICAL_OR({ 'a' : true }, true));
|
|
assertEqual(true, LOGICAL_OR(true, { 'a' : true, 'b' : false }));
|
|
assertEqual({ 'a' : true, 'b' : false }, LOGICAL_OR({ 'a' : true, 'b' : false }, true));
|
|
|
|
assertEqual(null, LOGICAL_OR(false, null));
|
|
assertEqual(false, LOGICAL_OR(null, false));
|
|
assertEqual('', LOGICAL_OR(false, ''));
|
|
assertEqual(false, LOGICAL_OR('', false));
|
|
assertEqual(' ', LOGICAL_OR(false, ' '));
|
|
assertEqual(' ', LOGICAL_OR(' ', false));
|
|
assertEqual('0', LOGICAL_OR(false, '0'));
|
|
assertEqual('0', LOGICAL_OR('0', false));
|
|
assertEqual('1', LOGICAL_OR(false, '1'));
|
|
assertEqual('1', LOGICAL_OR('1', false));
|
|
assertEqual('true', LOGICAL_OR(false, 'true'));
|
|
assertEqual('true', LOGICAL_OR('true', false));
|
|
assertEqual('false', LOGICAL_OR(false, 'false'));
|
|
assertEqual('false', LOGICAL_OR('false', false));
|
|
assertEqual(0, LOGICAL_OR(false, 0));
|
|
assertEqual(false, LOGICAL_OR(0, false));
|
|
assertEqual(1, LOGICAL_OR(false, 1));
|
|
assertEqual(1, LOGICAL_OR(1, false));
|
|
assertEqual(-1, LOGICAL_OR(false, -1));
|
|
assertEqual(-1, LOGICAL_OR(-1, false));
|
|
assertEqual(1.1, LOGICAL_OR(false, 1.1));
|
|
assertEqual(1.1, LOGICAL_OR(1.1, false));
|
|
assertEqual([ ], LOGICAL_OR(false, [ ]));
|
|
assertEqual([ ], LOGICAL_OR([ ], false));
|
|
assertEqual([ 0 ], LOGICAL_OR(false, [ 0 ]));
|
|
assertEqual([ 0 ], LOGICAL_OR([ 0 ], false));
|
|
assertEqual([ 0, 1 ], LOGICAL_OR(false, [ 0, 1 ]));
|
|
assertEqual([ 0, 1 ], LOGICAL_OR([ 0, 1 ], false));
|
|
assertEqual([ true ], LOGICAL_OR(false, [ true ]));
|
|
assertEqual([ false ], LOGICAL_OR([ false ], true));
|
|
assertEqual([ false ], LOGICAL_OR(false, [ false ]));
|
|
assertEqual([ false ], LOGICAL_OR([ false ], false));
|
|
assertEqual({ }, LOGICAL_OR(false, { }));
|
|
assertEqual({ }, LOGICAL_OR({ }, false));
|
|
assertEqual({ 'a' : true }, LOGICAL_OR(false, { 'a' : true }));
|
|
assertEqual({ 'a' : false }, LOGICAL_OR({ 'a' : false }, true));
|
|
assertEqual({ 'a' : true, 'b' : false }, LOGICAL_OR(false, { 'a' : true, 'b' : false }));
|
|
assertEqual({ 'a' : false, 'b' : false }, LOGICAL_OR({ 'a' : false, 'b' : false }, true));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.LOGICAL_OR function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testLogicalOrBool: function() {
|
|
assertTrue(LOGICAL_OR(true, true));
|
|
assertTrue(LOGICAL_OR(true, false));
|
|
assertTrue(LOGICAL_OR(false, true));
|
|
assertFalse(LOGICAL_OR(false, false));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.LOGICAL_NOT function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testLogicalNotUndefined: function() {
|
|
assertEqual(true, LOGICAL_NOT(null));
|
|
assertEqual(true, LOGICAL_NOT(false));
|
|
assertEqual(false, LOGICAL_NOT(true));
|
|
assertEqual(true, LOGICAL_NOT(0.0));
|
|
assertEqual(false, LOGICAL_NOT(1.0));
|
|
assertEqual(false, LOGICAL_NOT(-1.0));
|
|
assertEqual(true, LOGICAL_NOT(''));
|
|
assertEqual(false, LOGICAL_NOT('0'));
|
|
assertEqual(false, LOGICAL_NOT('1'));
|
|
assertEqual(false, LOGICAL_NOT([ ]));
|
|
assertEqual(false, LOGICAL_NOT([ 0 ]));
|
|
assertEqual(false, LOGICAL_NOT([ 0, 1 ]));
|
|
assertEqual(false, LOGICAL_NOT([ 1, 2 ]));
|
|
assertEqual(false, LOGICAL_NOT({ }));
|
|
assertEqual(false, LOGICAL_NOT({ 'a' : 0 }));
|
|
assertEqual(false, LOGICAL_NOT({ 'a' : 1 }));
|
|
assertEqual(false, LOGICAL_NOT({ '0' : false}));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.LOGICAL_NOT function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testLogicalNotBool: function() {
|
|
assertTrue(LOGICAL_NOT(false));
|
|
assertFalse(LOGICAL_NOT(true));
|
|
|
|
assertTrue(LOGICAL_NOT(LOGICAL_NOT(true)));
|
|
assertFalse(LOGICAL_NOT(LOGICAL_NOT(false)));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.RELATIONAL_EQUAL function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRelationalEqualTrue: function() {
|
|
assertTrue(RELATIONAL_EQUAL(1, 1));
|
|
assertTrue(RELATIONAL_EQUAL(0, 0));
|
|
assertTrue(RELATIONAL_EQUAL(-1, -1));
|
|
assertTrue(RELATIONAL_EQUAL(1.345, 1.345));
|
|
assertTrue(RELATIONAL_EQUAL(1.0, 1.00));
|
|
assertTrue(RELATIONAL_EQUAL(1.0, 1.000));
|
|
assertTrue(RELATIONAL_EQUAL(1.1, 1.1));
|
|
assertTrue(RELATIONAL_EQUAL(1.01, 1.01));
|
|
assertTrue(RELATIONAL_EQUAL(1.001, 1.001));
|
|
assertTrue(RELATIONAL_EQUAL(1.0001, 1.0001));
|
|
assertTrue(RELATIONAL_EQUAL(1.00001, 1.00001));
|
|
assertTrue(RELATIONAL_EQUAL(1.000001, 1.000001));
|
|
assertTrue(RELATIONAL_EQUAL(1.245e307, 1.245e307));
|
|
assertTrue(RELATIONAL_EQUAL(-99.43423, -99.43423));
|
|
assertTrue(RELATIONAL_EQUAL(true, true));
|
|
assertTrue(RELATIONAL_EQUAL(false, false));
|
|
assertTrue(RELATIONAL_EQUAL('', ''));
|
|
assertTrue(RELATIONAL_EQUAL(' ', ' '));
|
|
assertTrue(RELATIONAL_EQUAL(' 1', ' 1'));
|
|
assertTrue(RELATIONAL_EQUAL('0', '0'));
|
|
assertTrue(RELATIONAL_EQUAL('abc', 'abc'));
|
|
assertTrue(RELATIONAL_EQUAL('-1', '-1'));
|
|
assertTrue(RELATIONAL_EQUAL('true', 'true'));
|
|
assertTrue(RELATIONAL_EQUAL('false', 'false'));
|
|
assertTrue(RELATIONAL_EQUAL('undefined', 'undefined'));
|
|
assertTrue(RELATIONAL_EQUAL('null', 'null'));
|
|
assertTrue(RELATIONAL_EQUAL([ ], [ ]));
|
|
assertTrue(RELATIONAL_EQUAL([ null ], [ ]));
|
|
assertTrue(RELATIONAL_EQUAL([ ], [ null ]));
|
|
assertTrue(RELATIONAL_EQUAL([ 0 ], [ 0 ]));
|
|
assertTrue(RELATIONAL_EQUAL([ 0, 1 ], [ 0, 1 ]));
|
|
assertTrue(RELATIONAL_EQUAL([ 0, 1, 4 ], [ 0, 1, 4 ]));
|
|
assertTrue(RELATIONAL_EQUAL([ 3, 4, -99 ], [ 3, 4, -99 ]));
|
|
assertTrue(RELATIONAL_EQUAL([ 'a', 4, [ 1, 'a' ], false ], [ 'a', 4, [ 1, 'a' ], false ]));
|
|
assertTrue(RELATIONAL_EQUAL({ }, { }));
|
|
assertTrue(RELATIONAL_EQUAL({ 'a' : true }, { 'a' : true }));
|
|
assertTrue(RELATIONAL_EQUAL({ 'a' : true, 'b': true }, { 'a' : true, 'b': true }));
|
|
assertTrue(RELATIONAL_EQUAL({ 'a' : true, 'b': true }, { 'b' : true, 'a': true }));
|
|
assertTrue(RELATIONAL_EQUAL({ 'b' : true, 'a': true }, { 'b' : true, 'a': true }));
|
|
assertTrue(RELATIONAL_EQUAL({ 'b' : true, 'a': true }, { 'a' : true, 'b': true }));
|
|
assertTrue(RELATIONAL_EQUAL({ 'a' : [ 0, 1 ], 'b' : [ 1, 9 ] }, { 'a' : [ 0, 1 ], 'b' : [ 1, 9 ] }));
|
|
assertTrue(RELATIONAL_EQUAL({ 'a' : [ 0, 1 ], 'b' : [ 1, 9 ] }, { 'b' : [ 1, 9 ], 'a' : [ 0, 1 ] }));
|
|
assertTrue(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 RELATIONAL_EQUAL function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRelationalEqualFalse: function() {
|
|
assertFalse(RELATIONAL_EQUAL(1, 0));
|
|
assertFalse(RELATIONAL_EQUAL(0, 1));
|
|
assertFalse(RELATIONAL_EQUAL(0, false));
|
|
assertFalse(RELATIONAL_EQUAL(false, 0));
|
|
assertFalse(RELATIONAL_EQUAL(false, 0));
|
|
assertFalse(RELATIONAL_EQUAL(-1, 1));
|
|
assertFalse(RELATIONAL_EQUAL(1, -1));
|
|
assertFalse(RELATIONAL_EQUAL(-1, 0));
|
|
assertFalse(RELATIONAL_EQUAL(0, -1));
|
|
assertFalse(RELATIONAL_EQUAL(true, false));
|
|
assertFalse(RELATIONAL_EQUAL(false, true));
|
|
assertFalse(RELATIONAL_EQUAL(true, 1));
|
|
assertFalse(RELATIONAL_EQUAL(1, true));
|
|
assertFalse(RELATIONAL_EQUAL(0, true));
|
|
assertFalse(RELATIONAL_EQUAL(true, 0));
|
|
assertFalse(RELATIONAL_EQUAL(true, 'true'));
|
|
assertFalse(RELATIONAL_EQUAL(false, 'false'));
|
|
assertFalse(RELATIONAL_EQUAL('true', true));
|
|
assertFalse(RELATIONAL_EQUAL('false', false));
|
|
assertFalse(RELATIONAL_EQUAL(-1.345, 1.345));
|
|
assertFalse(RELATIONAL_EQUAL(1.345, -1.345));
|
|
assertFalse(RELATIONAL_EQUAL(1.345, 1.346));
|
|
assertFalse(RELATIONAL_EQUAL(1.346, 1.345));
|
|
assertFalse(RELATIONAL_EQUAL(1.344, 1.345));
|
|
assertFalse(RELATIONAL_EQUAL(1.345, 1.344));
|
|
assertFalse(RELATIONAL_EQUAL(1, 2));
|
|
assertFalse(RELATIONAL_EQUAL(2, 1));
|
|
assertFalse(RELATIONAL_EQUAL(1.246e307, 1.245e307));
|
|
assertFalse(RELATIONAL_EQUAL(1.246e307, 1.247e307));
|
|
assertFalse(RELATIONAL_EQUAL(1.246e307, 1.2467e307));
|
|
assertFalse(RELATIONAL_EQUAL(-99.43423, -99.434233));
|
|
assertFalse(RELATIONAL_EQUAL(1.00001, 1.000001));
|
|
assertFalse(RELATIONAL_EQUAL(1.00001, 1.0001));
|
|
assertFalse(RELATIONAL_EQUAL(null, 1));
|
|
assertFalse(RELATIONAL_EQUAL(1, null));
|
|
assertFalse(RELATIONAL_EQUAL(null, 0));
|
|
assertFalse(RELATIONAL_EQUAL(0, null));
|
|
assertFalse(RELATIONAL_EQUAL(null, ''));
|
|
assertFalse(RELATIONAL_EQUAL('', null));
|
|
assertFalse(RELATIONAL_EQUAL(null, '0'));
|
|
assertFalse(RELATIONAL_EQUAL('0', null));
|
|
assertFalse(RELATIONAL_EQUAL(null, false));
|
|
assertFalse(RELATIONAL_EQUAL(false, null));
|
|
assertFalse(RELATIONAL_EQUAL(null, true));
|
|
assertFalse(RELATIONAL_EQUAL(true, null));
|
|
assertFalse(RELATIONAL_EQUAL(null, 'null'));
|
|
assertFalse(RELATIONAL_EQUAL('null', null));
|
|
assertFalse(RELATIONAL_EQUAL(0, ''));
|
|
assertFalse(RELATIONAL_EQUAL('', 0));
|
|
assertFalse(RELATIONAL_EQUAL(1, ''));
|
|
assertFalse(RELATIONAL_EQUAL('', 1));
|
|
assertFalse(RELATIONAL_EQUAL(' ', ''));
|
|
assertFalse(RELATIONAL_EQUAL('', ' '));
|
|
assertFalse(RELATIONAL_EQUAL(' 1', '1'));
|
|
assertFalse(RELATIONAL_EQUAL('1', ' 1'));
|
|
assertFalse(RELATIONAL_EQUAL('1 ', '1'));
|
|
assertFalse(RELATIONAL_EQUAL('1', '1 '));
|
|
assertFalse(RELATIONAL_EQUAL('1 ', ' 1'));
|
|
assertFalse(RELATIONAL_EQUAL(' 1', '1 '));
|
|
assertFalse(RELATIONAL_EQUAL(' 1 ', '1'));
|
|
assertFalse(RELATIONAL_EQUAL('0', ''));
|
|
assertFalse(RELATIONAL_EQUAL('', ' '));
|
|
assertFalse(RELATIONAL_EQUAL('abc', 'abcd'));
|
|
assertFalse(RELATIONAL_EQUAL('abcd', 'abc'));
|
|
assertFalse(RELATIONAL_EQUAL('dabc', 'abcd'));
|
|
assertFalse(RELATIONAL_EQUAL('1', 1));
|
|
assertFalse(RELATIONAL_EQUAL(1, '1'));
|
|
assertFalse(RELATIONAL_EQUAL('0', 0));
|
|
assertFalse(RELATIONAL_EQUAL('1.0', 1.0));
|
|
assertFalse(RELATIONAL_EQUAL('1.0', 1));
|
|
assertFalse(RELATIONAL_EQUAL('-1', -1));
|
|
assertFalse(RELATIONAL_EQUAL('1.234', 1.234));
|
|
assertFalse(RELATIONAL_EQUAL([ 0 ], [ ]));
|
|
assertFalse(RELATIONAL_EQUAL([ ], [ 0 ]));
|
|
assertFalse(RELATIONAL_EQUAL([ ], [ 0, 1 ]));
|
|
assertFalse(RELATIONAL_EQUAL([ 0 ], [ 0, 1 ]));
|
|
assertFalse(RELATIONAL_EQUAL([ 1, 1, 0 ], [ 1, 0, 1 ]));
|
|
assertFalse(RELATIONAL_EQUAL([ 1, 0, 0 ], [ 1, 0, 1 ]));
|
|
assertFalse(RELATIONAL_EQUAL([ 1, 0, 0 ], [ 1, 0 ]));
|
|
assertFalse(RELATIONAL_EQUAL([ 1, 0 ], [ 1, 0, 0 ]));
|
|
assertFalse(RELATIONAL_EQUAL([ 1, 0 ], [ 0, 1 ]));
|
|
assertFalse(RELATIONAL_EQUAL([ 1, 0 ], [ 0 ]));
|
|
assertFalse(RELATIONAL_EQUAL([ 1, 0 ], [ 1 ]));
|
|
assertFalse(RELATIONAL_EQUAL([ 1, 2, 3 ], [ 3, 2, 1 ]));
|
|
assertFalse(RELATIONAL_EQUAL([ [ 1 ] ], [ [ 0 ] ]));
|
|
assertFalse(RELATIONAL_EQUAL([ 1, [ 1 , 0 ] ], [ 1, [ 0, 1 ] ]));
|
|
assertFalse(RELATIONAL_EQUAL([ 1, [ 1 , 0, [ ] ] ], [ 1, [ [ ], 1, 0 ] ]));
|
|
assertFalse(RELATIONAL_EQUAL([ '' ], false));
|
|
assertFalse(RELATIONAL_EQUAL([ '' ], ''));
|
|
assertFalse(RELATIONAL_EQUAL([ '' ], [ ]));
|
|
assertFalse(RELATIONAL_EQUAL([ true ], [ ]));
|
|
assertFalse(RELATIONAL_EQUAL([ true ], [ false ]));
|
|
assertFalse(RELATIONAL_EQUAL([ false ], [ ]));
|
|
assertFalse(RELATIONAL_EQUAL([ null ], [ false ]));
|
|
assertFalse(RELATIONAL_EQUAL([ ], ''));
|
|
assertFalse(RELATIONAL_EQUAL({ }, { 'a' : false }));
|
|
assertFalse(RELATIONAL_EQUAL({ 'a' : false }, { }));
|
|
assertFalse(RELATIONAL_EQUAL({ 'a' : true }, { 'a' : false }));
|
|
assertFalse(RELATIONAL_EQUAL({ 'a' : true }, { 'b' : true }));
|
|
assertFalse(RELATIONAL_EQUAL({ 'b' : true }, { 'a' : true }));
|
|
assertFalse(RELATIONAL_EQUAL({ 'a' : true, 'b' : [ 0, 1 ] }, { 'a' : true, 'b' : [ 1, 0 ] }));
|
|
assertFalse(RELATIONAL_EQUAL({ 'a' : true, 'b' : { 'a' : false, 'b' : true } }, { 'a' : true, 'b' : { 'a' : true, 'b': true } }));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test RELATIONAL_UNEQUAL function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRelationalUnequalTrue: function() {
|
|
assertTrue(RELATIONAL_UNEQUAL(1, 0));
|
|
assertTrue(RELATIONAL_UNEQUAL(0, 1));
|
|
assertTrue(RELATIONAL_UNEQUAL(0, false));
|
|
assertTrue(RELATIONAL_UNEQUAL(false, 0));
|
|
assertTrue(RELATIONAL_UNEQUAL(false, 0));
|
|
assertTrue(RELATIONAL_UNEQUAL(-1, 1));
|
|
assertTrue(RELATIONAL_UNEQUAL(1, -1));
|
|
assertTrue(RELATIONAL_UNEQUAL(-1, 0));
|
|
assertTrue(RELATIONAL_UNEQUAL(0, -1));
|
|
assertTrue(RELATIONAL_UNEQUAL(true, false));
|
|
assertTrue(RELATIONAL_UNEQUAL(false, true));
|
|
assertTrue(RELATIONAL_UNEQUAL(true, 1));
|
|
assertTrue(RELATIONAL_UNEQUAL(1, true));
|
|
assertTrue(RELATIONAL_UNEQUAL(0, true));
|
|
assertTrue(RELATIONAL_UNEQUAL(true, 0));
|
|
assertTrue(RELATIONAL_UNEQUAL(true, 'true'));
|
|
assertTrue(RELATIONAL_UNEQUAL(false, 'false'));
|
|
assertTrue(RELATIONAL_UNEQUAL('true', true));
|
|
assertTrue(RELATIONAL_UNEQUAL('false', false));
|
|
assertTrue(RELATIONAL_UNEQUAL(-1.345, 1.345));
|
|
assertTrue(RELATIONAL_UNEQUAL(1.345, -1.345));
|
|
assertTrue(RELATIONAL_UNEQUAL(1.345, 1.346));
|
|
assertTrue(RELATIONAL_UNEQUAL(1.346, 1.345));
|
|
assertTrue(RELATIONAL_UNEQUAL(1.344, 1.345));
|
|
assertTrue(RELATIONAL_UNEQUAL(1.345, 1.344));
|
|
assertTrue(RELATIONAL_UNEQUAL(1, 2));
|
|
assertTrue(RELATIONAL_UNEQUAL(2, 1));
|
|
assertTrue(RELATIONAL_UNEQUAL(1.246e307, 1.245e307));
|
|
assertTrue(RELATIONAL_UNEQUAL(1.246e307, 1.247e307));
|
|
assertTrue(RELATIONAL_UNEQUAL(1.246e307, 1.2467e307));
|
|
assertTrue(RELATIONAL_UNEQUAL(-99.43423, -99.434233));
|
|
assertTrue(RELATIONAL_UNEQUAL(1.00001, 1.000001));
|
|
assertTrue(RELATIONAL_UNEQUAL(1.00001, 1.0001));
|
|
assertTrue(RELATIONAL_UNEQUAL(null, 1));
|
|
assertTrue(RELATIONAL_UNEQUAL(1, null));
|
|
assertTrue(RELATIONAL_UNEQUAL(null, 0));
|
|
assertTrue(RELATIONAL_UNEQUAL(0, null));
|
|
assertTrue(RELATIONAL_UNEQUAL(null, ''));
|
|
assertTrue(RELATIONAL_UNEQUAL('', null));
|
|
assertTrue(RELATIONAL_UNEQUAL(null, '0'));
|
|
assertTrue(RELATIONAL_UNEQUAL('0', null));
|
|
assertTrue(RELATIONAL_UNEQUAL(null, false));
|
|
assertTrue(RELATIONAL_UNEQUAL(false, null));
|
|
assertTrue(RELATIONAL_UNEQUAL(null, true));
|
|
assertTrue(RELATIONAL_UNEQUAL(true, null));
|
|
assertTrue(RELATIONAL_UNEQUAL(null, 'null'));
|
|
assertTrue(RELATIONAL_UNEQUAL('null', null));
|
|
assertTrue(RELATIONAL_UNEQUAL(0, ''));
|
|
assertTrue(RELATIONAL_UNEQUAL('', 0));
|
|
assertTrue(RELATIONAL_UNEQUAL(1, ''));
|
|
assertTrue(RELATIONAL_UNEQUAL('', 1));
|
|
assertTrue(RELATIONAL_UNEQUAL(' ', ''));
|
|
assertTrue(RELATIONAL_UNEQUAL('', ' '));
|
|
assertTrue(RELATIONAL_UNEQUAL(' 1', '1'));
|
|
assertTrue(RELATIONAL_UNEQUAL('1', ' 1'));
|
|
assertTrue(RELATIONAL_UNEQUAL('1 ', '1'));
|
|
assertTrue(RELATIONAL_UNEQUAL('1', '1 '));
|
|
assertTrue(RELATIONAL_UNEQUAL('1 ', ' 1'));
|
|
assertTrue(RELATIONAL_UNEQUAL(' 1', '1 '));
|
|
assertTrue(RELATIONAL_UNEQUAL(' 1 ', '1'));
|
|
assertTrue(RELATIONAL_UNEQUAL('0', ''));
|
|
assertTrue(RELATIONAL_UNEQUAL('', ' '));
|
|
assertTrue(RELATIONAL_UNEQUAL('abc', 'abcd'));
|
|
assertTrue(RELATIONAL_UNEQUAL('abcd', 'abc'));
|
|
assertTrue(RELATIONAL_UNEQUAL('dabc', 'abcd'));
|
|
assertTrue(RELATIONAL_UNEQUAL('1', 1));
|
|
assertTrue(RELATIONAL_UNEQUAL(1, '1'));
|
|
assertTrue(RELATIONAL_UNEQUAL('0', 0));
|
|
assertTrue(RELATIONAL_UNEQUAL('1.0', 1.0));
|
|
assertTrue(RELATIONAL_UNEQUAL('1.0', 1));
|
|
assertTrue(RELATIONAL_UNEQUAL('-1', -1));
|
|
assertTrue(RELATIONAL_UNEQUAL('1.234', 1.234));
|
|
assertTrue(RELATIONAL_UNEQUAL([ 0 ], [ ]));
|
|
assertTrue(RELATIONAL_UNEQUAL([ ], [ 0 ]));
|
|
assertTrue(RELATIONAL_UNEQUAL([ ], [ 0, 1 ]));
|
|
assertTrue(RELATIONAL_UNEQUAL([ 0 ], [ 0, 1 ]));
|
|
assertTrue(RELATIONAL_UNEQUAL([ 1, 1, 0 ], [ 1, 0, 1 ]));
|
|
assertTrue(RELATIONAL_UNEQUAL([ 1, 0, 0 ], [ 1, 0, 1 ]));
|
|
assertTrue(RELATIONAL_UNEQUAL([ 1, 0, 0 ], [ 1, 0 ]));
|
|
assertTrue(RELATIONAL_UNEQUAL([ 1, 0 ], [ 1, 0, 0 ]));
|
|
assertTrue(RELATIONAL_UNEQUAL([ 1, 0 ], [ 0, 1 ]));
|
|
assertTrue(RELATIONAL_UNEQUAL([ 1, 0 ], [ 0 ]));
|
|
assertTrue(RELATIONAL_UNEQUAL([ 1, 0 ], [ 1 ]));
|
|
assertTrue(RELATIONAL_UNEQUAL([ 1, 2, 3 ], [ 3, 2, 1 ]));
|
|
assertTrue(RELATIONAL_UNEQUAL([ [ 1 ] ], [ [ 0 ] ]));
|
|
assertTrue(RELATIONAL_UNEQUAL([ 1, [ 1 , 0 ] ], [ 1, [ 0, 1 ] ]));
|
|
assertTrue(RELATIONAL_UNEQUAL([ 1, [ 1 , 0, [ ] ] ], [ 1, [ [ ], 1, 0 ] ]));
|
|
assertTrue(RELATIONAL_UNEQUAL([ '' ], false));
|
|
assertTrue(RELATIONAL_UNEQUAL([ '' ], ''));
|
|
assertTrue(RELATIONAL_UNEQUAL([ '' ], [ ]));
|
|
assertTrue(RELATIONAL_UNEQUAL([ true ], [ ]));
|
|
assertTrue(RELATIONAL_UNEQUAL([ true ], [ false ]));
|
|
assertTrue(RELATIONAL_UNEQUAL([ false ], [ ]));
|
|
assertTrue(RELATIONAL_UNEQUAL([ null ], [ false ]));
|
|
assertTrue(RELATIONAL_UNEQUAL([ ], null));
|
|
assertTrue(RELATIONAL_UNEQUAL([ ], ''));
|
|
assertTrue(RELATIONAL_UNEQUAL({ }, { 'a' : false }));
|
|
assertTrue(RELATIONAL_UNEQUAL({ 'a' : false }, { }));
|
|
assertTrue(RELATIONAL_UNEQUAL({ 'a' : true }, { 'a' : false }));
|
|
assertTrue(RELATIONAL_UNEQUAL({ 'a' : true }, { 'b' : true }));
|
|
assertTrue(RELATIONAL_UNEQUAL({ 'b' : true }, { 'a' : true }));
|
|
assertTrue(RELATIONAL_UNEQUAL({ 'a' : true, 'b' : [ 0, 1 ] }, { 'a' : true, 'b' : [ 1, 0 ] }));
|
|
assertTrue(RELATIONAL_UNEQUAL({ 'a' : true, 'b' : { 'a' : false, 'b' : true } }, { 'a' : true, 'b' : { 'a' : true, 'b': true } }));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test RELATIONAL_UNEQUAL function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRelationalUnequalFalse: function() {
|
|
assertFalse(RELATIONAL_UNEQUAL(1, 1));
|
|
assertFalse(RELATIONAL_UNEQUAL(0, 0));
|
|
assertFalse(RELATIONAL_UNEQUAL(-1, -1));
|
|
assertFalse(RELATIONAL_UNEQUAL(1.345, 1.345));
|
|
assertFalse(RELATIONAL_UNEQUAL(1.0, 1.00));
|
|
assertFalse(RELATIONAL_UNEQUAL(1.0, 1.000));
|
|
assertFalse(RELATIONAL_UNEQUAL(1.1, 1.1));
|
|
assertFalse(RELATIONAL_UNEQUAL(1.01, 1.01));
|
|
assertFalse(RELATIONAL_UNEQUAL(1.001, 1.001));
|
|
assertFalse(RELATIONAL_UNEQUAL(1.0001, 1.0001));
|
|
assertFalse(RELATIONAL_UNEQUAL(1.00001, 1.00001));
|
|
assertFalse(RELATIONAL_UNEQUAL(1.000001, 1.000001));
|
|
assertFalse(RELATIONAL_UNEQUAL(1.245e307, 1.245e307));
|
|
assertFalse(RELATIONAL_UNEQUAL(-99.43423, -99.43423));
|
|
assertFalse(RELATIONAL_UNEQUAL(true, true));
|
|
assertFalse(RELATIONAL_UNEQUAL(false, false));
|
|
assertFalse(RELATIONAL_UNEQUAL('', ''));
|
|
assertFalse(RELATIONAL_UNEQUAL(' ', ' '));
|
|
assertFalse(RELATIONAL_UNEQUAL(' 1', ' 1'));
|
|
assertFalse(RELATIONAL_UNEQUAL('0', '0'));
|
|
assertFalse(RELATIONAL_UNEQUAL('abc', 'abc'));
|
|
assertFalse(RELATIONAL_UNEQUAL('-1', '-1'));
|
|
assertFalse(RELATIONAL_UNEQUAL(null, null));
|
|
assertFalse(RELATIONAL_UNEQUAL('true', 'true'));
|
|
assertFalse(RELATIONAL_UNEQUAL('false', 'false'));
|
|
assertFalse(RELATIONAL_UNEQUAL('undefined', 'undefined'));
|
|
assertFalse(RELATIONAL_UNEQUAL('null', 'null'));
|
|
assertFalse(RELATIONAL_UNEQUAL([ ], [ ]));
|
|
assertFalse(RELATIONAL_UNEQUAL([ null ], [ ]));
|
|
assertFalse(RELATIONAL_UNEQUAL([ ], [ null ]));
|
|
assertFalse(RELATIONAL_UNEQUAL([ 0 ], [ 0 ]));
|
|
assertFalse(RELATIONAL_UNEQUAL([ 0, 1 ], [ 0, 1 ]));
|
|
assertFalse(RELATIONAL_UNEQUAL([ 0, 1, 4 ], [ 0, 1, 4 ]));
|
|
assertFalse(RELATIONAL_UNEQUAL([ 3, 4, -99 ], [ 3, 4, -99 ]));
|
|
assertFalse(RELATIONAL_UNEQUAL([ 'a', 4, [ 1, 'a' ], false ], [ 'a', 4, [ 1, 'a' ], false ]));
|
|
assertFalse(RELATIONAL_UNEQUAL({ }, { }));
|
|
assertFalse(RELATIONAL_UNEQUAL({ 'a' : true }, { 'a' : true }));
|
|
assertFalse(RELATIONAL_UNEQUAL({ 'a' : true, 'b': true }, { 'a' : true, 'b': true }));
|
|
assertFalse(RELATIONAL_UNEQUAL({ 'a' : true, 'b': true }, { 'b' : true, 'a': true }));
|
|
assertFalse(RELATIONAL_UNEQUAL({ 'b' : true, 'a': true }, { 'b' : true, 'a': true }));
|
|
assertFalse(RELATIONAL_UNEQUAL({ 'b' : true, 'a': true }, { 'a' : true, 'b': true }));
|
|
assertFalse(RELATIONAL_UNEQUAL({ 'a' : [ 0, 1 ], 'b' : [ 1, 9 ] }, { 'a' : [ 0, 1 ], 'b' : [ 1, 9 ] }));
|
|
assertFalse(RELATIONAL_UNEQUAL({ 'a' : [ 0, 1 ], 'b' : [ 1, 9 ] }, { 'b' : [ 1, 9 ], 'a' : [ 0, 1 ] }));
|
|
assertFalse(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 RELATIONAL_LESS function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRelationalLessTrue: function() {
|
|
assertTrue(RELATIONAL_LESS(null, false));
|
|
assertTrue(RELATIONAL_LESS(null, true));
|
|
assertTrue(RELATIONAL_LESS(null, 0));
|
|
assertTrue(RELATIONAL_LESS(null, 1));
|
|
assertTrue(RELATIONAL_LESS(null, -1));
|
|
assertTrue(RELATIONAL_LESS(null, ''));
|
|
assertTrue(RELATIONAL_LESS(null, ' '));
|
|
assertTrue(RELATIONAL_LESS(null, '1'));
|
|
assertTrue(RELATIONAL_LESS(null, '0'));
|
|
assertTrue(RELATIONAL_LESS(null, 'abcd'));
|
|
assertTrue(RELATIONAL_LESS(null, 'null'));
|
|
assertTrue(RELATIONAL_LESS(null, [ ]));
|
|
assertTrue(RELATIONAL_LESS(null, [ true ]));
|
|
assertTrue(RELATIONAL_LESS(null, [ false ]));
|
|
assertTrue(RELATIONAL_LESS(null, [ null ]));
|
|
assertTrue(RELATIONAL_LESS(null, [ 0 ]));
|
|
assertTrue(RELATIONAL_LESS(null, { }));
|
|
assertTrue(RELATIONAL_LESS(null, { 'a' : null }));
|
|
assertTrue(RELATIONAL_LESS(false, true));
|
|
assertTrue(RELATIONAL_LESS(false, 0));
|
|
assertTrue(RELATIONAL_LESS(false, 1));
|
|
assertTrue(RELATIONAL_LESS(false, -1));
|
|
assertTrue(RELATIONAL_LESS(false, ''));
|
|
assertTrue(RELATIONAL_LESS(false, ' '));
|
|
assertTrue(RELATIONAL_LESS(false, '1'));
|
|
assertTrue(RELATIONAL_LESS(false, '0'));
|
|
assertTrue(RELATIONAL_LESS(false, 'abcd'));
|
|
assertTrue(RELATIONAL_LESS(false, 'true'));
|
|
assertTrue(RELATIONAL_LESS(false, [ ]));
|
|
assertTrue(RELATIONAL_LESS(false, [ true ]));
|
|
assertTrue(RELATIONAL_LESS(false, [ false ]));
|
|
assertTrue(RELATIONAL_LESS(false, [ null ]));
|
|
assertTrue(RELATIONAL_LESS(false, [ 0 ]));
|
|
assertTrue(RELATIONAL_LESS(false, { }));
|
|
assertTrue(RELATIONAL_LESS(false, { 'a' : null }));
|
|
assertTrue(RELATIONAL_LESS(true, 0));
|
|
assertTrue(RELATIONAL_LESS(true, 1));
|
|
assertTrue(RELATIONAL_LESS(true, -1));
|
|
assertTrue(RELATIONAL_LESS(true, ''));
|
|
assertTrue(RELATIONAL_LESS(true, ' '));
|
|
assertTrue(RELATIONAL_LESS(true, '1'));
|
|
assertTrue(RELATIONAL_LESS(true, '0'));
|
|
assertTrue(RELATIONAL_LESS(true, 'abcd'));
|
|
assertTrue(RELATIONAL_LESS(true, 'true'));
|
|
assertTrue(RELATIONAL_LESS(true, [ ]));
|
|
assertTrue(RELATIONAL_LESS(true, [ true ]));
|
|
assertTrue(RELATIONAL_LESS(true, [ false ]));
|
|
assertTrue(RELATIONAL_LESS(true, [ null ]));
|
|
assertTrue(RELATIONAL_LESS(true, [ 0 ]));
|
|
assertTrue(RELATIONAL_LESS(true, { }));
|
|
assertTrue(RELATIONAL_LESS(true, { 'a' : null }));
|
|
assertTrue(RELATIONAL_LESS(0, 1));
|
|
assertTrue(RELATIONAL_LESS(1, 2));
|
|
assertTrue(RELATIONAL_LESS(1, 100));
|
|
assertTrue(RELATIONAL_LESS(20, 100));
|
|
assertTrue(RELATIONAL_LESS(-100, 1));
|
|
assertTrue(RELATIONAL_LESS(-100, -10));
|
|
assertTrue(RELATIONAL_LESS(-11, -10));
|
|
assertTrue(RELATIONAL_LESS(999, 1000));
|
|
assertTrue(RELATIONAL_LESS(-1, 1));
|
|
assertTrue(RELATIONAL_LESS(-1, 0));
|
|
assertTrue(RELATIONAL_LESS(1.0, 1.01));
|
|
assertTrue(RELATIONAL_LESS(1.111, 1.2));
|
|
assertTrue(RELATIONAL_LESS(-1.111, -1.110));
|
|
assertTrue(RELATIONAL_LESS(-1.111, -1.1109));
|
|
assertTrue(RELATIONAL_LESS(0, ''));
|
|
assertTrue(RELATIONAL_LESS(0, ' '));
|
|
assertTrue(RELATIONAL_LESS(0, '0'));
|
|
assertTrue(RELATIONAL_LESS(0, '1'));
|
|
assertTrue(RELATIONAL_LESS(0, '-1'));
|
|
assertTrue(RELATIONAL_LESS(0, 'true'));
|
|
assertTrue(RELATIONAL_LESS(0, 'false'));
|
|
assertTrue(RELATIONAL_LESS(0, 'null'));
|
|
assertTrue(RELATIONAL_LESS(1, ''));
|
|
assertTrue(RELATIONAL_LESS(1, ' '));
|
|
assertTrue(RELATIONAL_LESS(1, '0'));
|
|
assertTrue(RELATIONAL_LESS(1, '1'));
|
|
assertTrue(RELATIONAL_LESS(1, '-1'));
|
|
assertTrue(RELATIONAL_LESS(1, 'true'));
|
|
assertTrue(RELATIONAL_LESS(1, 'false'));
|
|
assertTrue(RELATIONAL_LESS(1, 'null'));
|
|
assertTrue(RELATIONAL_LESS(0, '-1'));
|
|
assertTrue(RELATIONAL_LESS(0, '-100'));
|
|
assertTrue(RELATIONAL_LESS(0, '-1.1'));
|
|
assertTrue(RELATIONAL_LESS(0, '-0.0'));
|
|
assertTrue(RELATIONAL_LESS(1000, '-1'));
|
|
assertTrue(RELATIONAL_LESS(1000, '10'));
|
|
assertTrue(RELATIONAL_LESS(1000, '10000'));
|
|
assertTrue(RELATIONAL_LESS(0, [ ]));
|
|
assertTrue(RELATIONAL_LESS(0, [ 0 ]));
|
|
assertTrue(RELATIONAL_LESS(10, [ ]));
|
|
assertTrue(RELATIONAL_LESS(100, [ ]));
|
|
assertTrue(RELATIONAL_LESS(100, [ 0 ]));
|
|
assertTrue(RELATIONAL_LESS(100, [ 0, 1 ]));
|
|
assertTrue(RELATIONAL_LESS(100, [ 99 ]));
|
|
assertTrue(RELATIONAL_LESS(100, [ 100 ]));
|
|
assertTrue(RELATIONAL_LESS(100, [ 101 ]));
|
|
assertTrue(RELATIONAL_LESS(100, { }));
|
|
assertTrue(RELATIONAL_LESS(100, { 'a' : 0 }));
|
|
assertTrue(RELATIONAL_LESS(100, { 'a' : 1 }));
|
|
assertTrue(RELATIONAL_LESS(100, { 'a' : 99 }));
|
|
assertTrue(RELATIONAL_LESS(100, { 'a' : 100 }));
|
|
assertTrue(RELATIONAL_LESS(100, { 'a' : 101 }));
|
|
assertTrue(RELATIONAL_LESS(100, { 'a' : 1000 }));
|
|
assertTrue(RELATIONAL_LESS('', ' '));
|
|
assertTrue(RELATIONAL_LESS('0', 'a'));
|
|
assertTrue(RELATIONAL_LESS('a', 'a '));
|
|
assertTrue(RELATIONAL_LESS('a', 'b'));
|
|
assertTrue(RELATIONAL_LESS('A', 'a'));
|
|
assertTrue(RELATIONAL_LESS('AB', 'Ab'));
|
|
assertTrue(RELATIONAL_LESS('abcd', 'bbcd'));
|
|
assertTrue(RELATIONAL_LESS('abcd', 'abda'));
|
|
assertTrue(RELATIONAL_LESS('abcd', 'abdd'));
|
|
assertTrue(RELATIONAL_LESS('abcd', 'abcde'));
|
|
assertTrue(RELATIONAL_LESS('0abcd', 'abcde'));
|
|
assertTrue(RELATIONAL_LESS('abcd', [ ]));
|
|
assertTrue(RELATIONAL_LESS('abcd', [ 0 ]));
|
|
assertTrue(RELATIONAL_LESS('abcd', [ -1 ]));
|
|
assertTrue(RELATIONAL_LESS('abcd', [ " " ]));
|
|
assertTrue(RELATIONAL_LESS('abcd', [ "" ]));
|
|
assertTrue(RELATIONAL_LESS('abcd', [ "abc" ]));
|
|
assertTrue(RELATIONAL_LESS('abcd', [ "abcd" ]));
|
|
assertTrue(RELATIONAL_LESS('abcd', { } ));
|
|
assertTrue(RELATIONAL_LESS('abcd', { 'a' : true } ));
|
|
assertTrue(RELATIONAL_LESS('abcd', { 'abc' : true } ));
|
|
assertTrue(RELATIONAL_LESS('ABCD', { 'a' : true } ));
|
|
assertTrue(RELATIONAL_LESS([ ], [ 0 ]));
|
|
assertTrue(RELATIONAL_LESS([ 0 ], [ 1 ]));
|
|
assertTrue(RELATIONAL_LESS([ 0, 1, 2 ], [ 0, 1, 2, 3 ]));
|
|
assertTrue(RELATIONAL_LESS([ 0, 1, 2 ], [ 0, 1, 3 ]));
|
|
assertTrue(RELATIONAL_LESS([ 0, 1, 4 ], [ 1, 0, 0 ]));
|
|
assertTrue(RELATIONAL_LESS([ 0, 1, 4 ], [ 1 ]));
|
|
assertTrue(RELATIONAL_LESS([ 15, 99 ], [ 110 ]));
|
|
assertTrue(RELATIONAL_LESS([ 15, 99 ], [ 15, 100 ]));
|
|
assertTrue(RELATIONAL_LESS([ ], [ false ]));
|
|
assertTrue(RELATIONAL_LESS([ ], [ true ]));
|
|
assertTrue(RELATIONAL_LESS([ ], [ 0 ]));
|
|
assertTrue(RELATIONAL_LESS([ ], [ -1 ]));
|
|
assertTrue(RELATIONAL_LESS([ ], [ '' ]));
|
|
assertTrue(RELATIONAL_LESS([ ], [ '0' ]));
|
|
assertTrue(RELATIONAL_LESS([ ], [ 'abcd' ]));
|
|
assertTrue(RELATIONAL_LESS([ ], [ [ ] ]));
|
|
assertTrue(RELATIONAL_LESS([ ], [ [ null ] ]));
|
|
assertTrue(RELATIONAL_LESS([ ], [ { } ]));
|
|
assertTrue(RELATIONAL_LESS([ null ], [ false ]));
|
|
assertTrue(RELATIONAL_LESS([ null ], [ true ]));
|
|
assertTrue(RELATIONAL_LESS([ null ], [ 0 ]));
|
|
assertTrue(RELATIONAL_LESS([ null ], [ [ ] ]));
|
|
assertTrue(RELATIONAL_LESS([ false ], [ true ]));
|
|
assertTrue(RELATIONAL_LESS([ false ], [ 0 ]));
|
|
assertTrue(RELATIONAL_LESS([ false ], [ -1 ]));
|
|
assertTrue(RELATIONAL_LESS([ false ], [ '' ]));
|
|
assertTrue(RELATIONAL_LESS([ false ], [ '0' ]));
|
|
assertTrue(RELATIONAL_LESS([ false ], [ 'abcd' ]));
|
|
assertTrue(RELATIONAL_LESS([ false ], [ [ ] ]));
|
|
assertTrue(RELATIONAL_LESS([ false ], [ [ false ] ]));
|
|
assertTrue(RELATIONAL_LESS([ true ], [ 0 ]));
|
|
assertTrue(RELATIONAL_LESS([ true ], [ -1 ]));
|
|
assertTrue(RELATIONAL_LESS([ true ], [ '' ]));
|
|
assertTrue(RELATIONAL_LESS([ true ], [ '0' ]));
|
|
assertTrue(RELATIONAL_LESS([ true ], [ 'abcd' ]));
|
|
assertTrue(RELATIONAL_LESS([ true ], [ [ ] ]));
|
|
assertTrue(RELATIONAL_LESS([ true ], [ [ false ] ]));
|
|
assertTrue(RELATIONAL_LESS([ false, false ], [ true ]));
|
|
assertTrue(RELATIONAL_LESS([ false, false ], [ false, true ]));
|
|
assertTrue(RELATIONAL_LESS([ false, false ], [ false, 0 ]));
|
|
assertTrue(RELATIONAL_LESS([ null, null ], [ null, false ]));
|
|
assertTrue(RELATIONAL_LESS([ ], { }));
|
|
assertTrue(RELATIONAL_LESS([ ], { 'a' : true }));
|
|
assertTrue(RELATIONAL_LESS([ ], { 'a' : null }));
|
|
assertTrue(RELATIONAL_LESS([ ], { 'a' : false }));
|
|
assertTrue(RELATIONAL_LESS([ '' ], { }));
|
|
assertTrue(RELATIONAL_LESS([ 0 ], { }));
|
|
assertTrue(RELATIONAL_LESS([ null ], { }));
|
|
assertTrue(RELATIONAL_LESS([ false ], { }));
|
|
assertTrue(RELATIONAL_LESS([ false ], { 'a' : false }));
|
|
assertTrue(RELATIONAL_LESS([ true ], { 'a' : false }));
|
|
assertTrue(RELATIONAL_LESS([ 'abcd' ], { 'a' : false }));
|
|
assertTrue(RELATIONAL_LESS([ 5 ], { 'a' : false }));
|
|
assertTrue(RELATIONAL_LESS([ 5, 6 ], { 'a' : 2, 'b' : 2 }));
|
|
assertTrue(RELATIONAL_LESS([ 5, 6, 7 ], { }));
|
|
assertTrue(RELATIONAL_LESS([ 5, 6, false ], [ 5, 6, true ]));
|
|
assertTrue(RELATIONAL_LESS([ 5, 6, true ], [ 5, 6, 0 ]));
|
|
assertTrue(RELATIONAL_LESS([ 5, 6, 999 ], [ 5, 6, '' ]));
|
|
assertTrue(RELATIONAL_LESS([ 5, 6, 'a' ], [ 5, 6, 'b' ]));
|
|
assertTrue(RELATIONAL_LESS([ 5, 6, 'A' ], [ 5, 6, 'a' ]));
|
|
assertTrue(RELATIONAL_LESS([ 5, 6, '' ], [ 5, 6, 'a' ]));
|
|
assertTrue(RELATIONAL_LESS([ 5, 6, 9, 9 ], [ 5, 6, [ ] ]));
|
|
assertTrue(RELATIONAL_LESS([ 5, 6, true ], [ 5, 6, [ ] ]));
|
|
assertTrue(RELATIONAL_LESS([ 5, 6, true ], [ 5, 6, { } ]));
|
|
assertTrue(RELATIONAL_LESS([ 5, 6, 9, 9 ], [ 5, 6, { } ]));
|
|
assertTrue(RELATIONAL_LESS({ }, { 'a' : 0 }));
|
|
assertTrue(RELATIONAL_LESS({ 'a' : 1 }, { 'a' : 2 }));
|
|
assertTrue(RELATIONAL_LESS({ 'b' : 2 }, { 'a' : 1 }));
|
|
assertTrue(RELATIONAL_LESS({ 'z' : 1 }, { 'c' : 1 }));
|
|
assertTrue(RELATIONAL_LESS({ 'a' : [ 9 ], 'b' : false }, { 'a' : [ 10 ], 'b' : true }));
|
|
assertTrue(RELATIONAL_LESS({ 'a' : [ 9 ], 'b' : true }, { 'a' : [ 10 ], 'b' : true }));
|
|
assertTrue(RELATIONAL_LESS({ 'a' : [ ], 'b' : true }, { 'a' : [ 10 ], 'b' : true }));
|
|
assertTrue(RELATIONAL_LESS({ 'a' : [ 10 ], 'b' : true }, { 'a' : [ 10, 1 ] }));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test RELATIONAL_LESS function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRelationalLessFalse: function() {
|
|
assertFalse(RELATIONAL_LESS(null, null));
|
|
assertFalse(RELATIONAL_LESS(false, null));
|
|
assertFalse(RELATIONAL_LESS(true, null));
|
|
assertFalse(RELATIONAL_LESS(0, null));
|
|
assertFalse(RELATIONAL_LESS(1, null));
|
|
assertFalse(RELATIONAL_LESS(-1, null));
|
|
assertFalse(RELATIONAL_LESS('', null));
|
|
assertFalse(RELATIONAL_LESS(' ', null));
|
|
assertFalse(RELATIONAL_LESS('1', null));
|
|
assertFalse(RELATIONAL_LESS('0', null));
|
|
assertFalse(RELATIONAL_LESS('abcd', null));
|
|
assertFalse(RELATIONAL_LESS('null', null));
|
|
assertFalse(RELATIONAL_LESS([ ], null));
|
|
assertFalse(RELATIONAL_LESS([ true ], null));
|
|
assertFalse(RELATIONAL_LESS([ false ], null));
|
|
assertFalse(RELATIONAL_LESS([ null ], null));
|
|
assertFalse(RELATIONAL_LESS([ 0 ], null));
|
|
assertFalse(RELATIONAL_LESS({ }, null));
|
|
assertFalse(RELATIONAL_LESS({ 'a' : null }, null));
|
|
assertFalse(RELATIONAL_LESS(false, false));
|
|
assertFalse(RELATIONAL_LESS(true, true));
|
|
assertFalse(RELATIONAL_LESS(true, false));
|
|
assertFalse(RELATIONAL_LESS(0, false));
|
|
assertFalse(RELATIONAL_LESS(1, false));
|
|
assertFalse(RELATIONAL_LESS(-1, false));
|
|
assertFalse(RELATIONAL_LESS('', false));
|
|
assertFalse(RELATIONAL_LESS(' ', false));
|
|
assertFalse(RELATIONAL_LESS('1', false));
|
|
assertFalse(RELATIONAL_LESS('0', false));
|
|
assertFalse(RELATIONAL_LESS('abcd', false));
|
|
assertFalse(RELATIONAL_LESS('true', false));
|
|
assertFalse(RELATIONAL_LESS([ ], false));
|
|
assertFalse(RELATIONAL_LESS([ true ], false));
|
|
assertFalse(RELATIONAL_LESS([ false ], false));
|
|
assertFalse(RELATIONAL_LESS([ null ], false));
|
|
assertFalse(RELATIONAL_LESS([ 0 ], false));
|
|
assertFalse(RELATIONAL_LESS({ }, false));
|
|
assertFalse(RELATIONAL_LESS({ 'a' : null }, false));
|
|
assertFalse(RELATIONAL_LESS(0, true));
|
|
assertFalse(RELATIONAL_LESS(1, true));
|
|
assertFalse(RELATIONAL_LESS(-1, true));
|
|
assertFalse(RELATIONAL_LESS('', true));
|
|
assertFalse(RELATIONAL_LESS(' ', true));
|
|
assertFalse(RELATIONAL_LESS('1', true));
|
|
assertFalse(RELATIONAL_LESS('0', true));
|
|
assertFalse(RELATIONAL_LESS('abcd', true));
|
|
assertFalse(RELATIONAL_LESS('true', true));
|
|
assertFalse(RELATIONAL_LESS([ ], true));
|
|
assertFalse(RELATIONAL_LESS([ true ], true));
|
|
assertFalse(RELATIONAL_LESS([ false ], true));
|
|
assertFalse(RELATIONAL_LESS([ null ], true));
|
|
assertFalse(RELATIONAL_LESS([ 0 ], true));
|
|
assertFalse(RELATIONAL_LESS({ }, true));
|
|
assertFalse(RELATIONAL_LESS({ 'a' : null }, true));
|
|
assertFalse(RELATIONAL_LESS(0, 0));
|
|
assertFalse(RELATIONAL_LESS(1, 1));
|
|
assertFalse(RELATIONAL_LESS(-10, -10));
|
|
assertFalse(RELATIONAL_LESS(-100, -100));
|
|
assertFalse(RELATIONAL_LESS(-334.5, -334.5));
|
|
assertFalse(RELATIONAL_LESS(1, 0));
|
|
assertFalse(RELATIONAL_LESS(2, 1));
|
|
assertFalse(RELATIONAL_LESS(100, 1));
|
|
assertFalse(RELATIONAL_LESS(100, 20));
|
|
assertFalse(RELATIONAL_LESS(1, -100));
|
|
assertFalse(RELATIONAL_LESS(-10, -100));
|
|
assertFalse(RELATIONAL_LESS(-10, -11));
|
|
assertFalse(RELATIONAL_LESS(1000, 999));
|
|
assertFalse(RELATIONAL_LESS(1, -1));
|
|
assertFalse(RELATIONAL_LESS(0, -1));
|
|
assertFalse(RELATIONAL_LESS(1.01, 1.0));
|
|
assertFalse(RELATIONAL_LESS(1.2, 1.111));
|
|
assertFalse(RELATIONAL_LESS(-1.110, -1.111));
|
|
assertFalse(RELATIONAL_LESS(-1.1109, -1.111));
|
|
assertFalse(RELATIONAL_LESS('', 0));
|
|
assertFalse(RELATIONAL_LESS(' ', 0));
|
|
assertFalse(RELATIONAL_LESS('0', 0));
|
|
assertFalse(RELATIONAL_LESS('1', 0));
|
|
assertFalse(RELATIONAL_LESS('-1', 0));
|
|
assertFalse(RELATIONAL_LESS('true', 0));
|
|
assertFalse(RELATIONAL_LESS('false', 0));
|
|
assertFalse(RELATIONAL_LESS('null', 0));
|
|
assertFalse(RELATIONAL_LESS('', 1));
|
|
assertFalse(RELATIONAL_LESS(' ', 1));
|
|
assertFalse(RELATIONAL_LESS('0', 1));
|
|
assertFalse(RELATIONAL_LESS('1', 1));
|
|
assertFalse(RELATIONAL_LESS('-1', 1));
|
|
assertFalse(RELATIONAL_LESS('true', 1));
|
|
assertFalse(RELATIONAL_LESS('false', 1));
|
|
assertFalse(RELATIONAL_LESS('null', 1));
|
|
assertFalse(RELATIONAL_LESS('-1', 0));
|
|
assertFalse(RELATIONAL_LESS('-100', 0));
|
|
assertFalse(RELATIONAL_LESS('-1.1', 0));
|
|
assertFalse(RELATIONAL_LESS('-0.0', 0));
|
|
assertFalse(RELATIONAL_LESS('-1', 1000));
|
|
assertFalse(RELATIONAL_LESS('10', 1000));
|
|
assertFalse(RELATIONAL_LESS('10000', 1000));
|
|
assertFalse(RELATIONAL_LESS([ ], 0));
|
|
assertFalse(RELATIONAL_LESS([ 0 ], 0));
|
|
assertFalse(RELATIONAL_LESS([ ], 10));
|
|
assertFalse(RELATIONAL_LESS([ ], 100));
|
|
assertFalse(RELATIONAL_LESS([ 0 ], 100));
|
|
assertFalse(RELATIONAL_LESS([ 0, 1 ], 100));
|
|
assertFalse(RELATIONAL_LESS([ 99 ], 100));
|
|
assertFalse(RELATIONAL_LESS([ 100 ], 100));
|
|
assertFalse(RELATIONAL_LESS([ 101 ], 100));
|
|
assertFalse(RELATIONAL_LESS({ }, 100));
|
|
assertFalse(RELATIONAL_LESS({ 'a' : 0 }, 100));
|
|
assertFalse(RELATIONAL_LESS({ 'a' : 1 }, 100));
|
|
assertFalse(RELATIONAL_LESS({ 'a' : 99 }, 100));
|
|
assertFalse(RELATIONAL_LESS({ 'a' : 100 }, 100));
|
|
assertFalse(RELATIONAL_LESS({ 'a' : 101 }, 100));
|
|
assertFalse(RELATIONAL_LESS({ 'a' : 1000 }, 100));
|
|
assertFalse(RELATIONAL_LESS({ 'a' : false }, 'zz'));
|
|
assertFalse(RELATIONAL_LESS({ 'a' : 'a' }, 'zz'));
|
|
assertFalse(RELATIONAL_LESS('', ''));
|
|
assertFalse(RELATIONAL_LESS(' ', ' '));
|
|
assertFalse(RELATIONAL_LESS('a', 'a'));
|
|
assertFalse(RELATIONAL_LESS(' a', ' a'));
|
|
assertFalse(RELATIONAL_LESS('abcd', 'abcd'));
|
|
assertFalse(RELATIONAL_LESS(' ', ''));
|
|
assertFalse(RELATIONAL_LESS('a', '0'));
|
|
assertFalse(RELATIONAL_LESS('a ', 'a'));
|
|
assertFalse(RELATIONAL_LESS('b', 'a'));
|
|
assertFalse(RELATIONAL_LESS('a', 'A'));
|
|
assertFalse(RELATIONAL_LESS('Ab', 'AB'));
|
|
assertFalse(RELATIONAL_LESS('bbcd', 'abcd'));
|
|
assertFalse(RELATIONAL_LESS('abda', 'abcd'));
|
|
assertFalse(RELATIONAL_LESS('abdd', 'abcd'));
|
|
assertFalse(RELATIONAL_LESS('abcde', 'abcd'));
|
|
assertFalse(RELATIONAL_LESS('abcde', '0abcde'));
|
|
assertFalse(RELATIONAL_LESS([ ], [ ]));
|
|
assertFalse(RELATIONAL_LESS([ 0 ], [ 0 ]));
|
|
assertFalse(RELATIONAL_LESS([ 1 ], [ 1 ]));
|
|
assertFalse(RELATIONAL_LESS([ true ], [ true ]));
|
|
assertFalse(RELATIONAL_LESS([ false ], [ false ]));
|
|
assertFalse(RELATIONAL_LESS([ [ 0, 1, 2 ] ], [ [ 0, 1, 2 ] ]));
|
|
assertFalse(RELATIONAL_LESS([ [ 1, [ "true", 0, -99 , false ] ], 4 ], [ [ 1, [ "true", 0, -99, false ] ], 4 ]));
|
|
assertFalse(RELATIONAL_LESS([ 0 ], [ ]));
|
|
assertFalse(RELATIONAL_LESS([ 1 ], [ 0 ]));
|
|
assertFalse(RELATIONAL_LESS([ 0, 1, 2, 3 ], [ 0, 1, 2 ]));
|
|
assertFalse(RELATIONAL_LESS([ 0, 1, 3 ], [ 0, 1, 2 ]));
|
|
assertFalse(RELATIONAL_LESS([ 1, 0, 0 ], [ 0, 1, 4 ]));
|
|
assertFalse(RELATIONAL_LESS([ 1 ], [ 0, 1, 4 ]));
|
|
assertFalse(RELATIONAL_LESS([ 110 ], [ 15, 99 ]));
|
|
assertFalse(RELATIONAL_LESS([ 15, 100 ], [ 15, 99 ]));
|
|
assertFalse(RELATIONAL_LESS([ null ], [ ]));
|
|
assertFalse(RELATIONAL_LESS([ false ], [ ]));
|
|
assertFalse(RELATIONAL_LESS([ true ], [ ]));
|
|
assertFalse(RELATIONAL_LESS([ 0 ], [ ]));
|
|
assertFalse(RELATIONAL_LESS([ -1 ], [ ]));
|
|
assertFalse(RELATIONAL_LESS([ '' ], [ ]));
|
|
assertFalse(RELATIONAL_LESS([ '0' ], [ ]));
|
|
assertFalse(RELATIONAL_LESS([ 'abcd' ], [ ]));
|
|
assertFalse(RELATIONAL_LESS([ [ ] ], [ ]));
|
|
assertFalse(RELATIONAL_LESS([ [ null ] ], [ ]));
|
|
assertFalse(RELATIONAL_LESS([ { } ], [ ]));
|
|
assertFalse(RELATIONAL_LESS([ false ], [ null ]));
|
|
assertFalse(RELATIONAL_LESS([ true ], [ null ]));
|
|
assertFalse(RELATIONAL_LESS([ 0 ], [ null ]));
|
|
assertFalse(RELATIONAL_LESS([ [ ] ], [ null ]));
|
|
assertFalse(RELATIONAL_LESS([ true ], [ false ]));
|
|
assertFalse(RELATIONAL_LESS([ 0 ], [ false ]));
|
|
assertFalse(RELATIONAL_LESS([ -1 ], [ false ]));
|
|
assertFalse(RELATIONAL_LESS([ '' ], [ false ]));
|
|
assertFalse(RELATIONAL_LESS([ '0' ], [ false ]));
|
|
assertFalse(RELATIONAL_LESS([ 'abcd' ], [ false ]));
|
|
assertFalse(RELATIONAL_LESS([ [ ] ], [ false ]));
|
|
assertFalse(RELATIONAL_LESS([ [ false ] ], [ false ]));
|
|
assertFalse(RELATIONAL_LESS([ 0 ], [ true ]));
|
|
assertFalse(RELATIONAL_LESS([ -1 ], [ true ]));
|
|
assertFalse(RELATIONAL_LESS([ '' ], [ true ]));
|
|
assertFalse(RELATIONAL_LESS([ '0' ], [ true ]));
|
|
assertFalse(RELATIONAL_LESS([ 'abcd' ], [ true ]));
|
|
assertFalse(RELATIONAL_LESS([ [ ] ], [ true ]));
|
|
assertFalse(RELATIONAL_LESS([ [ false] ], [ true ]));
|
|
assertFalse(RELATIONAL_LESS([ true ], [ false, false ]));
|
|
assertFalse(RELATIONAL_LESS([ false, true ], [ false, false ]));
|
|
assertFalse(RELATIONAL_LESS([ false, 0 ], [ false, false ]));
|
|
assertFalse(RELATIONAL_LESS([ null, false ], [ null, null ]));
|
|
assertFalse(RELATIONAL_LESS({ }, [ ]));
|
|
assertFalse(RELATIONAL_LESS({ 'a' : true }, [ ]));
|
|
assertFalse(RELATIONAL_LESS({ 'a' : null }, [ ]));
|
|
assertFalse(RELATIONAL_LESS({ 'a' : false }, [ ]));
|
|
assertFalse(RELATIONAL_LESS({ }, [ '' ]));
|
|
assertFalse(RELATIONAL_LESS({ }, [ 0 ]));
|
|
assertFalse(RELATIONAL_LESS({ }, [ null ]));
|
|
assertFalse(RELATIONAL_LESS({ }, [ false ]));
|
|
assertFalse(RELATIONAL_LESS({ 'a' : false }, [ false ]));
|
|
assertFalse(RELATIONAL_LESS({ 'a' : false }, [ true ]));
|
|
assertFalse(RELATIONAL_LESS({ 'a' : false }, [ 'abcd' ]));
|
|
assertFalse(RELATIONAL_LESS({ 'a' : false }, [ 5 ]));
|
|
assertFalse(RELATIONAL_LESS({ 'a' : 2, 'b' : 2 }, [ 5, 6 ]));
|
|
assertFalse(RELATIONAL_LESS({ 'a' : 1, 'b' : 2 }, { 'a' : 1, 'b' : 2, 'c' : null }));
|
|
assertFalse(RELATIONAL_LESS({ 'b' : 2, 'a' : 1 }, { 'a' : 1, 'b' : 2, 'c' : null }));
|
|
assertFalse(RELATIONAL_LESS({ }, [ 5, 6, 7 ]));
|
|
assertFalse(RELATIONAL_LESS([ 5, 6, true ], [ 5, 6, false ]));
|
|
assertFalse(RELATIONAL_LESS([ 5, 6, 0 ], [ 5, 6, true ]));
|
|
assertFalse(RELATIONAL_LESS([ 5, 6, '' ], [ 5, 6, 999 ]));
|
|
assertFalse(RELATIONAL_LESS([ 5, 6, 'b' ], [ 5, 6, 'a' ]));
|
|
assertFalse(RELATIONAL_LESS([ 5, 6, 'a' ], [ 5, 6, 'A' ]));
|
|
assertFalse(RELATIONAL_LESS([ 5, 6, 'a' ], [ 5, 6, '' ]));
|
|
assertFalse(RELATIONAL_LESS([ 5, 6, [ ] ], [ 5, 6, 9 ,9 ]));
|
|
assertFalse(RELATIONAL_LESS([ 5, 6, [ ] ], [ 5, 6, true ]));
|
|
assertFalse(RELATIONAL_LESS([ 5, 6, { } ], [ 5, 6, true ]));
|
|
assertFalse(RELATIONAL_LESS([ 5, 6, { } ], [ 5, 6, 9, 9 ]));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test RELATIONAL_GREATER function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRelationalGreaterTrue: function() {
|
|
assertTrue(RELATIONAL_GREATER(false, null));
|
|
assertTrue(RELATIONAL_GREATER(true, null));
|
|
assertTrue(RELATIONAL_GREATER(0, null));
|
|
assertTrue(RELATIONAL_GREATER(1, null));
|
|
assertTrue(RELATIONAL_GREATER(-1, null));
|
|
assertTrue(RELATIONAL_GREATER('', null));
|
|
assertTrue(RELATIONAL_GREATER(' ', null));
|
|
assertTrue(RELATIONAL_GREATER('1', null));
|
|
assertTrue(RELATIONAL_GREATER('0', null));
|
|
assertTrue(RELATIONAL_GREATER('abcd', null));
|
|
assertTrue(RELATIONAL_GREATER('null', null));
|
|
assertTrue(RELATIONAL_GREATER([ ], null));
|
|
assertTrue(RELATIONAL_GREATER([ true ], null));
|
|
assertTrue(RELATIONAL_GREATER([ false ], null));
|
|
assertTrue(RELATIONAL_GREATER([ null ], null));
|
|
assertTrue(RELATIONAL_GREATER([ 0 ], null));
|
|
assertTrue(RELATIONAL_GREATER({ }, null));
|
|
assertTrue(RELATIONAL_GREATER({ 'a' : null }, null));
|
|
assertTrue(RELATIONAL_GREATER(true, false));
|
|
assertTrue(RELATIONAL_GREATER(0, false));
|
|
assertTrue(RELATIONAL_GREATER(1, false));
|
|
assertTrue(RELATIONAL_GREATER(-1, false));
|
|
assertTrue(RELATIONAL_GREATER('', false));
|
|
assertTrue(RELATIONAL_GREATER(' ', false));
|
|
assertTrue(RELATIONAL_GREATER('1', false));
|
|
assertTrue(RELATIONAL_GREATER('0', false));
|
|
assertTrue(RELATIONAL_GREATER('abcd', false));
|
|
assertTrue(RELATIONAL_GREATER('true', false));
|
|
assertTrue(RELATIONAL_GREATER([ ], false));
|
|
assertTrue(RELATIONAL_GREATER([ true ], false));
|
|
assertTrue(RELATIONAL_GREATER([ false ], false));
|
|
assertTrue(RELATIONAL_GREATER([ null ], false));
|
|
assertTrue(RELATIONAL_GREATER([ 0 ], false));
|
|
assertTrue(RELATIONAL_GREATER({ }, false));
|
|
assertTrue(RELATIONAL_GREATER({ 'a' : null }, false));
|
|
assertTrue(RELATIONAL_GREATER(0, true));
|
|
assertTrue(RELATIONAL_GREATER(1, true));
|
|
assertTrue(RELATIONAL_GREATER(-1, true));
|
|
assertTrue(RELATIONAL_GREATER('', true));
|
|
assertTrue(RELATIONAL_GREATER(' ', true));
|
|
assertTrue(RELATIONAL_GREATER('1', true));
|
|
assertTrue(RELATIONAL_GREATER('0', true));
|
|
assertTrue(RELATIONAL_GREATER('abcd', true));
|
|
assertTrue(RELATIONAL_GREATER('true', true));
|
|
assertTrue(RELATIONAL_GREATER([ ], true));
|
|
assertTrue(RELATIONAL_GREATER([ true ], true));
|
|
assertTrue(RELATIONAL_GREATER([ false ], true));
|
|
assertTrue(RELATIONAL_GREATER([ null ], true));
|
|
assertTrue(RELATIONAL_GREATER([ 0 ], true));
|
|
assertTrue(RELATIONAL_GREATER({ }, true));
|
|
assertTrue(RELATIONAL_GREATER({ 'a' : null }, true));
|
|
assertTrue(RELATIONAL_GREATER(1, 0));
|
|
assertTrue(RELATIONAL_GREATER(2, 1));
|
|
assertTrue(RELATIONAL_GREATER(100, 1));
|
|
assertTrue(RELATIONAL_GREATER(100, 20));
|
|
assertTrue(RELATIONAL_GREATER(1, -100));
|
|
assertTrue(RELATIONAL_GREATER(-10, -100));
|
|
assertTrue(RELATIONAL_GREATER(-10, -11));
|
|
assertTrue(RELATIONAL_GREATER(1000, 999));
|
|
assertTrue(RELATIONAL_GREATER(1, -1));
|
|
assertTrue(RELATIONAL_GREATER(0, -1));
|
|
assertTrue(RELATIONAL_GREATER(1.01, 1.0));
|
|
assertTrue(RELATIONAL_GREATER(1.2, 1.111));
|
|
assertTrue(RELATIONAL_GREATER(-1.110, -1.111));
|
|
assertTrue(RELATIONAL_GREATER(-1.1109, -1.111));
|
|
assertTrue(RELATIONAL_GREATER('', 0));
|
|
assertTrue(RELATIONAL_GREATER(' ', 0));
|
|
assertTrue(RELATIONAL_GREATER('0', 0));
|
|
assertTrue(RELATIONAL_GREATER('1', 0));
|
|
assertTrue(RELATIONAL_GREATER('-1', 0));
|
|
assertTrue(RELATIONAL_GREATER('true', 0));
|
|
assertTrue(RELATIONAL_GREATER('false', 0));
|
|
assertTrue(RELATIONAL_GREATER('null', 0));
|
|
assertTrue(RELATIONAL_GREATER('', 1));
|
|
assertTrue(RELATIONAL_GREATER(' ', 1));
|
|
assertTrue(RELATIONAL_GREATER('0', 1));
|
|
assertTrue(RELATIONAL_GREATER('1', 1));
|
|
assertTrue(RELATIONAL_GREATER('-1', 1));
|
|
assertTrue(RELATIONAL_GREATER('true', 1));
|
|
assertTrue(RELATIONAL_GREATER('false', 1));
|
|
assertTrue(RELATIONAL_GREATER('null', 1));
|
|
assertTrue(RELATIONAL_GREATER('-1', 0));
|
|
assertTrue(RELATIONAL_GREATER('-100', 0));
|
|
assertTrue(RELATIONAL_GREATER('-1.1', 0));
|
|
assertTrue(RELATIONAL_GREATER('-0.0', 0));
|
|
assertTrue(RELATIONAL_GREATER('-1', 1000));
|
|
assertTrue(RELATIONAL_GREATER('10', 1000));
|
|
assertTrue(RELATIONAL_GREATER('10000', 1000));
|
|
assertTrue(RELATIONAL_GREATER([ ], 0));
|
|
assertTrue(RELATIONAL_GREATER([ 0 ], 0));
|
|
assertTrue(RELATIONAL_GREATER([ ], 10));
|
|
assertTrue(RELATIONAL_GREATER([ ], 100));
|
|
assertTrue(RELATIONAL_GREATER([ 0 ], 100));
|
|
assertTrue(RELATIONAL_GREATER([ 0, 1 ], 100));
|
|
assertTrue(RELATIONAL_GREATER([ 99 ], 100));
|
|
assertTrue(RELATIONAL_GREATER([ 100 ], 100));
|
|
assertTrue(RELATIONAL_GREATER([ 101 ], 100));
|
|
assertTrue(RELATIONAL_GREATER({ }, 100));
|
|
assertTrue(RELATIONAL_GREATER({ 'a' : 0 }, 100));
|
|
assertTrue(RELATIONAL_GREATER({ 'a' : 1 }, 100));
|
|
assertTrue(RELATIONAL_GREATER({ 'a' : 99 }, 100));
|
|
assertTrue(RELATIONAL_GREATER({ 'a' : 100 }, 100));
|
|
assertTrue(RELATIONAL_GREATER({ 'a' : 101 }, 100));
|
|
assertTrue(RELATIONAL_GREATER({ 'a' : 1000 }, 100));
|
|
assertTrue(RELATIONAL_GREATER({ 'a' : false }, 'zz'));
|
|
assertTrue(RELATIONAL_GREATER({ 'a' : 'a' }, 'zz'));
|
|
assertTrue(RELATIONAL_GREATER(' ', ''));
|
|
assertTrue(RELATIONAL_GREATER('a', '0'));
|
|
assertTrue(RELATIONAL_GREATER('a ', 'a'));
|
|
assertTrue(RELATIONAL_GREATER('b', 'a'));
|
|
assertTrue(RELATIONAL_GREATER('a', 'A'));
|
|
assertTrue(RELATIONAL_GREATER('Ab', 'AB'));
|
|
assertTrue(RELATIONAL_GREATER('bbcd', 'abcd'));
|
|
assertTrue(RELATIONAL_GREATER('abda', 'abcd'));
|
|
assertTrue(RELATIONAL_GREATER('abdd', 'abcd'));
|
|
assertTrue(RELATIONAL_GREATER('abcde', 'abcd'));
|
|
assertTrue(RELATIONAL_GREATER('abcde', '0abcde'));
|
|
assertTrue(RELATIONAL_GREATER([ 0 ], [ ]));
|
|
assertTrue(RELATIONAL_GREATER([ 1 ], [ 0 ]));
|
|
assertTrue(RELATIONAL_GREATER([ 0, 1, 2, 3 ], [ 0, 1, 2 ]));
|
|
assertTrue(RELATIONAL_GREATER([ 0, 1, 3 ], [ 0, 1, 2 ]));
|
|
assertTrue(RELATIONAL_GREATER([ 1, 0, 0 ], [ 0, 1, 4 ]));
|
|
assertTrue(RELATIONAL_GREATER([ 1 ], [ 0, 1, 4 ]));
|
|
assertTrue(RELATIONAL_GREATER([ 110 ], [ 15, 99 ]));
|
|
assertTrue(RELATIONAL_GREATER([ 15, 100 ], [ 15, 99 ]));
|
|
assertTrue(RELATIONAL_GREATER([ false ], [ ]));
|
|
assertTrue(RELATIONAL_GREATER([ true ], [ ]));
|
|
assertTrue(RELATIONAL_GREATER([ 0 ], [ ]));
|
|
assertTrue(RELATIONAL_GREATER([ -1 ], [ ]));
|
|
assertTrue(RELATIONAL_GREATER([ '' ], [ ]));
|
|
assertTrue(RELATIONAL_GREATER([ '0' ], [ ]));
|
|
assertTrue(RELATIONAL_GREATER([ 'abcd' ], [ ]));
|
|
assertTrue(RELATIONAL_GREATER([ [ ] ], [ ]));
|
|
assertTrue(RELATIONAL_GREATER([ [ null ] ], [ ]));
|
|
assertTrue(RELATIONAL_GREATER([ { } ], [ ]));
|
|
assertTrue(RELATIONAL_GREATER([ false ], [ null ]));
|
|
assertTrue(RELATIONAL_GREATER([ true ], [ null ]));
|
|
assertTrue(RELATIONAL_GREATER([ 0 ], [ null ]));
|
|
assertTrue(RELATIONAL_GREATER([ [ ] ], [ null ]));
|
|
assertTrue(RELATIONAL_GREATER([ true ], [ false ]));
|
|
assertTrue(RELATIONAL_GREATER([ 0 ], [ false ]));
|
|
assertTrue(RELATIONAL_GREATER([ -1 ], [ false ]));
|
|
assertTrue(RELATIONAL_GREATER([ '' ], [ false ]));
|
|
assertTrue(RELATIONAL_GREATER([ '0' ], [ false ]));
|
|
assertTrue(RELATIONAL_GREATER([ 'abcd' ], [ false ]));
|
|
assertTrue(RELATIONAL_GREATER([ [ ] ], [ false ]));
|
|
assertTrue(RELATIONAL_GREATER([ [ false ] ], [ false ]));
|
|
assertTrue(RELATIONAL_GREATER([ 0 ], [ true ]));
|
|
assertTrue(RELATIONAL_GREATER([ -1 ], [ true ]));
|
|
assertTrue(RELATIONAL_GREATER([ '' ], [ true ]));
|
|
assertTrue(RELATIONAL_GREATER([ '0' ], [ true ]));
|
|
assertTrue(RELATIONAL_GREATER([ 'abcd' ], [ true ]));
|
|
assertTrue(RELATIONAL_GREATER([ [ ] ], [ true ]));
|
|
assertTrue(RELATIONAL_GREATER([ [ false] ], [ true ]));
|
|
assertTrue(RELATIONAL_GREATER([ true ], [ false, false ]));
|
|
assertTrue(RELATIONAL_GREATER([ false, true ], [ false, false ]));
|
|
assertTrue(RELATIONAL_GREATER([ false, 0 ], [ false, false ]));
|
|
assertTrue(RELATIONAL_GREATER([ null, false ], [ null, null ]));
|
|
assertTrue(RELATIONAL_GREATER({ 'a' : 0 }, { }));
|
|
assertTrue(RELATIONAL_GREATER({ 'a' : 2 }, { 'a' : 1 }));
|
|
assertTrue(RELATIONAL_GREATER({ 'A' : 2 }, { 'a' : 1 }));
|
|
assertTrue(RELATIONAL_GREATER({ 'A' : 1 }, { 'a' : 2 }));
|
|
assertTrue(RELATIONAL_GREATER({ 'a' : 1 }, { 'b' : 1 }));
|
|
assertTrue(RELATIONAL_GREATER({ 'a' : [ 10 ], 'b' : true }, { 'a' : [ 9 ], 'b' : false }));
|
|
assertTrue(RELATIONAL_GREATER({ 'a' : [ 10 ], 'b' : true }, { 'a' : [ 9 ], 'b' : true }));
|
|
assertTrue(RELATIONAL_GREATER({ 'a' : [ 10 ], 'b' : true }, { 'a' : [ ], 'b' : true }));
|
|
assertTrue(RELATIONAL_GREATER({ 'a' : [ 10, 1 ] }, { 'a' : [ 10 ], 'b' : true }));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test RELATIONAL_GREATER function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRelationalGreaterFalse: function() {
|
|
assertFalse(RELATIONAL_GREATER(null, false));
|
|
assertFalse(RELATIONAL_GREATER(null, true));
|
|
assertFalse(RELATIONAL_GREATER(null, 0));
|
|
assertFalse(RELATIONAL_GREATER(null, 1));
|
|
assertFalse(RELATIONAL_GREATER(null, -1));
|
|
assertFalse(RELATIONAL_GREATER(null, ''));
|
|
assertFalse(RELATIONAL_GREATER(null, ' '));
|
|
assertFalse(RELATIONAL_GREATER(null, '1'));
|
|
assertFalse(RELATIONAL_GREATER(null, '0'));
|
|
assertFalse(RELATIONAL_GREATER(null, 'abcd'));
|
|
assertFalse(RELATIONAL_GREATER(null, 'null'));
|
|
assertFalse(RELATIONAL_GREATER(null, [ ]));
|
|
assertFalse(RELATIONAL_GREATER(null, [ true ]));
|
|
assertFalse(RELATIONAL_GREATER(null, [ false ]));
|
|
assertFalse(RELATIONAL_GREATER(null, [ null ]));
|
|
assertFalse(RELATIONAL_GREATER(null, [ 0 ]));
|
|
assertFalse(RELATIONAL_GREATER(null, { }));
|
|
assertFalse(RELATIONAL_GREATER(null, { 'a' : null }));
|
|
assertFalse(RELATIONAL_GREATER(false, false));
|
|
assertFalse(RELATIONAL_GREATER(true, true));
|
|
assertFalse(RELATIONAL_GREATER(false, true));
|
|
assertFalse(RELATIONAL_GREATER(false, 0));
|
|
assertFalse(RELATIONAL_GREATER(false, 1));
|
|
assertFalse(RELATIONAL_GREATER(false, -1));
|
|
assertFalse(RELATIONAL_GREATER(false, ''));
|
|
assertFalse(RELATIONAL_GREATER(false, ' '));
|
|
assertFalse(RELATIONAL_GREATER(false, '1'));
|
|
assertFalse(RELATIONAL_GREATER(false, '0'));
|
|
assertFalse(RELATIONAL_GREATER(false, 'abcd'));
|
|
assertFalse(RELATIONAL_GREATER(false, 'true'));
|
|
assertFalse(RELATIONAL_GREATER(false, [ ]));
|
|
assertFalse(RELATIONAL_GREATER(false, [ true ]));
|
|
assertFalse(RELATIONAL_GREATER(false, [ false ]));
|
|
assertFalse(RELATIONAL_GREATER(false, [ null ]));
|
|
assertFalse(RELATIONAL_GREATER(false, [ 0 ]));
|
|
assertFalse(RELATIONAL_GREATER(false, { }));
|
|
assertFalse(RELATIONAL_GREATER(false, { 'a' : null }));
|
|
assertFalse(RELATIONAL_GREATER(true, 0));
|
|
assertFalse(RELATIONAL_GREATER(true, 1));
|
|
assertFalse(RELATIONAL_GREATER(true, -1));
|
|
assertFalse(RELATIONAL_GREATER(true, ''));
|
|
assertFalse(RELATIONAL_GREATER(true, ' '));
|
|
assertFalse(RELATIONAL_GREATER(true, '1'));
|
|
assertFalse(RELATIONAL_GREATER(true, '0'));
|
|
assertFalse(RELATIONAL_GREATER(true, 'abcd'));
|
|
assertFalse(RELATIONAL_GREATER(true, 'true'));
|
|
assertFalse(RELATIONAL_GREATER(true, [ ]));
|
|
assertFalse(RELATIONAL_GREATER(true, [ true ]));
|
|
assertFalse(RELATIONAL_GREATER(true, [ false ]));
|
|
assertFalse(RELATIONAL_GREATER(true, [ null ]));
|
|
assertFalse(RELATIONAL_GREATER(true, [ 0 ]));
|
|
assertFalse(RELATIONAL_GREATER(true, { }));
|
|
assertFalse(RELATIONAL_GREATER(true, { 'a' : null }));
|
|
assertFalse(RELATIONAL_GREATER(0, 0));
|
|
assertFalse(RELATIONAL_GREATER(1, 1));
|
|
assertFalse(RELATIONAL_GREATER(-10, -10));
|
|
assertFalse(RELATIONAL_GREATER(-100, -100));
|
|
assertFalse(RELATIONAL_GREATER(-334.5, -334.5));
|
|
assertFalse(RELATIONAL_GREATER(0, 1));
|
|
assertFalse(RELATIONAL_GREATER(1, 2));
|
|
assertFalse(RELATIONAL_GREATER(1, 100));
|
|
assertFalse(RELATIONAL_GREATER(20, 100));
|
|
assertFalse(RELATIONAL_GREATER(-100, 1));
|
|
assertFalse(RELATIONAL_GREATER(-100, -10));
|
|
assertFalse(RELATIONAL_GREATER(-11, -10));
|
|
assertFalse(RELATIONAL_GREATER(999, 1000));
|
|
assertFalse(RELATIONAL_GREATER(-1, 1));
|
|
assertFalse(RELATIONAL_GREATER(-1, 0));
|
|
assertFalse(RELATIONAL_GREATER(1.0, 1.01));
|
|
assertFalse(RELATIONAL_GREATER(1.111, 1.2));
|
|
assertFalse(RELATIONAL_GREATER(-1.111, -1.110));
|
|
assertFalse(RELATIONAL_GREATER(-1.111, -1.1109));
|
|
assertFalse(RELATIONAL_GREATER(0, ''));
|
|
assertFalse(RELATIONAL_GREATER(0, ' '));
|
|
assertFalse(RELATIONAL_GREATER(0, '0'));
|
|
assertFalse(RELATIONAL_GREATER(0, '1'));
|
|
assertFalse(RELATIONAL_GREATER(0, '-1'));
|
|
assertFalse(RELATIONAL_GREATER(0, 'true'));
|
|
assertFalse(RELATIONAL_GREATER(0, 'false'));
|
|
assertFalse(RELATIONAL_GREATER(0, 'null'));
|
|
assertFalse(RELATIONAL_GREATER(1, ''));
|
|
assertFalse(RELATIONAL_GREATER(1, ' '));
|
|
assertFalse(RELATIONAL_GREATER(1, '0'));
|
|
assertFalse(RELATIONAL_GREATER(1, '1'));
|
|
assertFalse(RELATIONAL_GREATER(1, '-1'));
|
|
assertFalse(RELATIONAL_GREATER(1, 'true'));
|
|
assertFalse(RELATIONAL_GREATER(1, 'false'));
|
|
assertFalse(RELATIONAL_GREATER(1, 'null'));
|
|
assertFalse(RELATIONAL_GREATER(0, '-1'));
|
|
assertFalse(RELATIONAL_GREATER(0, '-100'));
|
|
assertFalse(RELATIONAL_GREATER(0, '-1.1'));
|
|
assertFalse(RELATIONAL_GREATER(0, '-0.0'));
|
|
assertFalse(RELATIONAL_GREATER(1000, '-1'));
|
|
assertFalse(RELATIONAL_GREATER(1000, '10'));
|
|
assertFalse(RELATIONAL_GREATER(1000, '10000'));
|
|
assertFalse(RELATIONAL_GREATER(0, [ ]));
|
|
assertFalse(RELATIONAL_GREATER(0, [ 0 ]));
|
|
assertFalse(RELATIONAL_GREATER(10, [ ]));
|
|
assertFalse(RELATIONAL_GREATER(100, [ ]));
|
|
assertFalse(RELATIONAL_GREATER(100, [ 0 ]));
|
|
assertFalse(RELATIONAL_GREATER(100, [ 0, 1 ]));
|
|
assertFalse(RELATIONAL_GREATER(100, [ 99 ]));
|
|
assertFalse(RELATIONAL_GREATER(100, [ 100 ]));
|
|
assertFalse(RELATIONAL_GREATER(100, [ 101 ]));
|
|
assertFalse(RELATIONAL_GREATER(100, { }));
|
|
assertFalse(RELATIONAL_GREATER(100, { 'a' : 0 }));
|
|
assertFalse(RELATIONAL_GREATER(100, { 'a' : 1 }));
|
|
assertFalse(RELATIONAL_GREATER(100, { 'a' : 99 }));
|
|
assertFalse(RELATIONAL_GREATER(100, { 'a' : 100 }));
|
|
assertFalse(RELATIONAL_GREATER(100, { 'a' : 101 }));
|
|
assertFalse(RELATIONAL_GREATER(100, { 'a' : 1000 }));
|
|
assertFalse(RELATIONAL_GREATER('', ''));
|
|
assertFalse(RELATIONAL_GREATER(' ', ' '));
|
|
assertFalse(RELATIONAL_GREATER('a', 'a'));
|
|
assertFalse(RELATIONAL_GREATER(' a', ' a'));
|
|
assertFalse(RELATIONAL_GREATER('abcd', 'abcd'));
|
|
assertFalse(RELATIONAL_GREATER('', ' '));
|
|
assertFalse(RELATIONAL_GREATER('0', 'a'));
|
|
assertFalse(RELATIONAL_GREATER('a', 'a '));
|
|
assertFalse(RELATIONAL_GREATER('a', 'b'));
|
|
assertFalse(RELATIONAL_GREATER('A', 'a'));
|
|
assertFalse(RELATIONAL_GREATER('AB', 'Ab'));
|
|
assertFalse(RELATIONAL_GREATER('abcd', 'bbcd'));
|
|
assertFalse(RELATIONAL_GREATER('abcd', 'abda'));
|
|
assertFalse(RELATIONAL_GREATER('abcd', 'abdd'));
|
|
assertFalse(RELATIONAL_GREATER('abcd', 'abcde'));
|
|
assertFalse(RELATIONAL_GREATER('0abcd', 'abcde'));
|
|
assertFalse(RELATIONAL_GREATER([ ], [ ]));
|
|
assertFalse(RELATIONAL_GREATER([ 0 ], [ 0 ]));
|
|
assertFalse(RELATIONAL_GREATER([ 1 ], [ 1 ]));
|
|
assertFalse(RELATIONAL_GREATER([ true ], [ true ]));
|
|
assertFalse(RELATIONAL_GREATER([ false ], [ false ]));
|
|
assertFalse(RELATIONAL_GREATER([ [ 0, 1, 2 ] ], [ [ 0, 1, 2 ] ]));
|
|
assertFalse(RELATIONAL_GREATER([ [ 1, [ "true", 0, -99 , false ] ], 4 ], [ [ 1, [ "true", 0, -99, false ] ], 4 ]));
|
|
assertFalse(RELATIONAL_GREATER([ ], [ 0 ]));
|
|
assertFalse(RELATIONAL_GREATER([ 0 ], [ 1 ]));
|
|
assertFalse(RELATIONAL_GREATER([ 0, 1, 2 ], [ 0, 1, 2, 3 ]));
|
|
assertFalse(RELATIONAL_GREATER([ 0, 1, 2 ], [ 0, 1, 3 ]));
|
|
assertFalse(RELATIONAL_GREATER([ 0, 1, 4 ], [ 1, 0, 0 ]));
|
|
assertFalse(RELATIONAL_GREATER([ 0, 1, 4 ], [ 1 ]));
|
|
assertFalse(RELATIONAL_GREATER([ 15, 99 ], [ 110 ]));
|
|
assertFalse(RELATIONAL_GREATER([ 15, 99 ], [ 15, 100 ]));
|
|
assertFalse(RELATIONAL_GREATER([ ], [ null ]));
|
|
assertFalse(RELATIONAL_GREATER([ ], [ false ]));
|
|
assertFalse(RELATIONAL_GREATER([ ], [ true ]));
|
|
assertFalse(RELATIONAL_GREATER([ ], [ 0 ]));
|
|
assertFalse(RELATIONAL_GREATER([ ], [ -1 ]));
|
|
assertFalse(RELATIONAL_GREATER([ ], [ '' ]));
|
|
assertFalse(RELATIONAL_GREATER([ ], [ '0' ]));
|
|
assertFalse(RELATIONAL_GREATER([ ], [ 'abcd' ]));
|
|
assertFalse(RELATIONAL_GREATER([ ], [ [ ] ]));
|
|
assertFalse(RELATIONAL_GREATER([ ], [ [ null ] ]));
|
|
assertFalse(RELATIONAL_GREATER([ ], [ { } ]));
|
|
assertFalse(RELATIONAL_GREATER([ null ], [ false ]));
|
|
assertFalse(RELATIONAL_GREATER([ null ], [ true ]));
|
|
assertFalse(RELATIONAL_GREATER([ null ], [ 0 ]));
|
|
assertFalse(RELATIONAL_GREATER([ null ], [ [ ] ]));
|
|
assertFalse(RELATIONAL_GREATER([ null ], [ ]));
|
|
assertFalse(RELATIONAL_GREATER([ false ], [ true ]));
|
|
assertFalse(RELATIONAL_GREATER([ false ], [ 0 ]));
|
|
assertFalse(RELATIONAL_GREATER([ false ], [ -1 ]));
|
|
assertFalse(RELATIONAL_GREATER([ false ], [ '' ]));
|
|
assertFalse(RELATIONAL_GREATER([ false ], [ '0' ]));
|
|
assertFalse(RELATIONAL_GREATER([ false ], [ 'abcd' ]));
|
|
assertFalse(RELATIONAL_GREATER([ false ], [ [ ] ]));
|
|
assertFalse(RELATIONAL_GREATER([ false ], [ [ false ] ]));
|
|
assertFalse(RELATIONAL_GREATER([ true ], [ 0 ]));
|
|
assertFalse(RELATIONAL_GREATER([ true ], [ -1 ]));
|
|
assertFalse(RELATIONAL_GREATER([ true ], [ '' ]));
|
|
assertFalse(RELATIONAL_GREATER([ true ], [ '0' ]));
|
|
assertFalse(RELATIONAL_GREATER([ true ], [ 'abcd' ]));
|
|
assertFalse(RELATIONAL_GREATER([ true ], [ [ ] ]));
|
|
assertFalse(RELATIONAL_GREATER([ true ], [ [ false ] ]));
|
|
assertFalse(RELATIONAL_GREATER([ false, false ], [ true ]));
|
|
assertFalse(RELATIONAL_GREATER([ false, false ], [ false, true ]));
|
|
assertFalse(RELATIONAL_GREATER([ false, false ], [ false, 0 ]));
|
|
assertFalse(RELATIONAL_GREATER([ null, null ], [ null, false ]));
|
|
assertFalse(RELATIONAL_GREATER({ 'a' : 1, 'b' : 2, 'c': null }, { 'b' : 2, 'a' : 1 }));
|
|
assertFalse(RELATIONAL_GREATER({ 'a' : 1, 'b' : 2, 'c' : null }, { 'a' : 1, 'b' : 2 }));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test RELATIONAL_LESSEQUAL function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRelationalLessEqualTrue: function() {
|
|
assertTrue(RELATIONAL_LESSEQUAL(null, false));
|
|
assertTrue(RELATIONAL_LESSEQUAL(null, true));
|
|
assertTrue(RELATIONAL_LESSEQUAL(null, 0));
|
|
assertTrue(RELATIONAL_LESSEQUAL(null, 1));
|
|
assertTrue(RELATIONAL_LESSEQUAL(null, -1));
|
|
assertTrue(RELATIONAL_LESSEQUAL(null, ''));
|
|
assertTrue(RELATIONAL_LESSEQUAL(null, ' '));
|
|
assertTrue(RELATIONAL_LESSEQUAL(null, '1'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(null, '0'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(null, 'abcd'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(null, 'null'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(null, [ ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(null, [ true ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(null, [ false ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(null, [ null ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(null, [ 0 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(null, { }));
|
|
assertTrue(RELATIONAL_LESSEQUAL(null, { 'a' : null }));
|
|
assertTrue(RELATIONAL_LESSEQUAL(null, null));
|
|
assertTrue(RELATIONAL_LESSEQUAL(false, true));
|
|
assertTrue(RELATIONAL_LESSEQUAL(false, 0));
|
|
assertTrue(RELATIONAL_LESSEQUAL(false, 1));
|
|
assertTrue(RELATIONAL_LESSEQUAL(false, -1));
|
|
assertTrue(RELATIONAL_LESSEQUAL(false, ''));
|
|
assertTrue(RELATIONAL_LESSEQUAL(false, ' '));
|
|
assertTrue(RELATIONAL_LESSEQUAL(false, '1'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(false, '0'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(false, 'abcd'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(false, 'true'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(false, [ ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(false, [ true ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(false, [ false ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(false, [ null ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(false, [ 0 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(false, { }));
|
|
assertTrue(RELATIONAL_LESSEQUAL(false, { 'a' : null }));
|
|
assertTrue(RELATIONAL_LESSEQUAL(false, false));
|
|
assertTrue(RELATIONAL_LESSEQUAL(true, 0));
|
|
assertTrue(RELATIONAL_LESSEQUAL(true, 1));
|
|
assertTrue(RELATIONAL_LESSEQUAL(true, -1));
|
|
assertTrue(RELATIONAL_LESSEQUAL(true, ''));
|
|
assertTrue(RELATIONAL_LESSEQUAL(true, ' '));
|
|
assertTrue(RELATIONAL_LESSEQUAL(true, '1'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(true, '0'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(true, 'abcd'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(true, 'true'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(true, [ ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(true, [ true ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(true, [ false ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(true, [ null ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(true, [ 0 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(true, { }));
|
|
assertTrue(RELATIONAL_LESSEQUAL(true, { 'a' : null }));
|
|
assertTrue(RELATIONAL_LESSEQUAL(true, true));
|
|
assertTrue(RELATIONAL_LESSEQUAL(0, 1));
|
|
assertTrue(RELATIONAL_LESSEQUAL(1, 2));
|
|
assertTrue(RELATIONAL_LESSEQUAL(1, 100));
|
|
assertTrue(RELATIONAL_LESSEQUAL(20, 100));
|
|
assertTrue(RELATIONAL_LESSEQUAL(-100, 1));
|
|
assertTrue(RELATIONAL_LESSEQUAL(-100, -10));
|
|
assertTrue(RELATIONAL_LESSEQUAL(-11, -10));
|
|
assertTrue(RELATIONAL_LESSEQUAL(999, 1000));
|
|
assertTrue(RELATIONAL_LESSEQUAL(-1, 1));
|
|
assertTrue(RELATIONAL_LESSEQUAL(-1, 0));
|
|
assertTrue(RELATIONAL_LESSEQUAL(1.0, 1.01));
|
|
assertTrue(RELATIONAL_LESSEQUAL(1.111, 1.2));
|
|
assertTrue(RELATIONAL_LESSEQUAL(-1.111, -1.110));
|
|
assertTrue(RELATIONAL_LESSEQUAL(-1.111, -1.1109));
|
|
assertTrue(RELATIONAL_LESSEQUAL(0, 0));
|
|
assertTrue(RELATIONAL_LESSEQUAL(1, 1));
|
|
assertTrue(RELATIONAL_LESSEQUAL(2, 2));
|
|
assertTrue(RELATIONAL_LESSEQUAL(20, 20));
|
|
assertTrue(RELATIONAL_LESSEQUAL(100, 100));
|
|
assertTrue(RELATIONAL_LESSEQUAL(-100, -100));
|
|
assertTrue(RELATIONAL_LESSEQUAL(-11, -11));
|
|
assertTrue(RELATIONAL_LESSEQUAL(999, 999));
|
|
assertTrue(RELATIONAL_LESSEQUAL(-1, -1));
|
|
assertTrue(RELATIONAL_LESSEQUAL(1.0, 1.0));
|
|
assertTrue(RELATIONAL_LESSEQUAL(1.111, 1.111));
|
|
assertTrue(RELATIONAL_LESSEQUAL(1.2, 1.2));
|
|
assertTrue(RELATIONAL_LESSEQUAL(-1.111, -1.111));
|
|
assertTrue(RELATIONAL_LESSEQUAL(0, ''));
|
|
assertTrue(RELATIONAL_LESSEQUAL(0, ' '));
|
|
assertTrue(RELATIONAL_LESSEQUAL(0, '0'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(0, '1'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(0, '-1'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(0, 'true'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(0, 'false'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(0, 'null'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(1, ''));
|
|
assertTrue(RELATIONAL_LESSEQUAL(1, ' '));
|
|
assertTrue(RELATIONAL_LESSEQUAL(1, '0'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(1, '1'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(1, '-1'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(1, 'true'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(1, 'false'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(1, 'null'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(0, '-1'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(0, '-100'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(0, '-1.1'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(0, '-0.0'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(1000, '-1'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(1000, '10'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(1000, '10000'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(0, [ ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(0, [ 0 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(10, [ ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(100, [ ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(100, [ 0 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(100, [ 0, 1 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(100, [ 99 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(100, [ 100 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(100, [ 101 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL(100, { }));
|
|
assertTrue(RELATIONAL_LESSEQUAL(100, { 'a' : 0 }));
|
|
assertTrue(RELATIONAL_LESSEQUAL(100, { 'a' : 1 }));
|
|
assertTrue(RELATIONAL_LESSEQUAL(100, { 'a' : 99 }));
|
|
assertTrue(RELATIONAL_LESSEQUAL(100, { 'a' : 100 }));
|
|
assertTrue(RELATIONAL_LESSEQUAL(100, { 'a' : 101 }));
|
|
assertTrue(RELATIONAL_LESSEQUAL(100, { 'a' : 1000 }));
|
|
assertTrue(RELATIONAL_LESSEQUAL('', ' '));
|
|
assertTrue(RELATIONAL_LESSEQUAL('0', 'a'));
|
|
assertTrue(RELATIONAL_LESSEQUAL('a', 'a '));
|
|
assertTrue(RELATIONAL_LESSEQUAL('a', 'b'));
|
|
assertTrue(RELATIONAL_LESSEQUAL('A', 'a'));
|
|
assertTrue(RELATIONAL_LESSEQUAL('AB', 'Ab'));
|
|
assertTrue(RELATIONAL_LESSEQUAL('abcd', 'bbcd'));
|
|
assertTrue(RELATIONAL_LESSEQUAL('abcd', 'abda'));
|
|
assertTrue(RELATIONAL_LESSEQUAL('abcd', 'abdd'));
|
|
assertTrue(RELATIONAL_LESSEQUAL('abcd', 'abcde'));
|
|
assertTrue(RELATIONAL_LESSEQUAL('0abcd', 'abcde'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(' abcd', 'abcd'));
|
|
assertTrue(RELATIONAL_LESSEQUAL('', ''));
|
|
assertTrue(RELATIONAL_LESSEQUAL('0', '0'));
|
|
assertTrue(RELATIONAL_LESSEQUAL('a', 'a'));
|
|
assertTrue(RELATIONAL_LESSEQUAL('A', 'A'));
|
|
assertTrue(RELATIONAL_LESSEQUAL('AB', 'AB'));
|
|
assertTrue(RELATIONAL_LESSEQUAL('Ab', 'Ab'));
|
|
assertTrue(RELATIONAL_LESSEQUAL('abcd', 'abcd'));
|
|
assertTrue(RELATIONAL_LESSEQUAL('0abcd', '0abcd'));
|
|
assertTrue(RELATIONAL_LESSEQUAL(' ', ' '));
|
|
assertTrue(RELATIONAL_LESSEQUAL(' ', ' '));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ ], [ 0 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 0 ], [ 1 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 0, 1, 2 ], [ 0, 1, 2, 3 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 0, 1, 2 ], [ 0, 1, 3 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 0, 1, 4 ], [ 1, 0, 0 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 0, 1, 4 ], [ 1 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 15, 99 ], [ 110 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 15, 99 ], [ 15, 100 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ ], [ null ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ ], [ false ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ ], [ true ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ ], [ 0 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ ], [ -1 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ ], [ '' ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ ], [ '0' ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ ], [ 'abcd' ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ ], [ [ ] ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ ], [ [ null ] ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ ], [ { } ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ ], [ ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 0 ], [ 0 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 0, 1, 2 ], [ 0, 1, 2 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 15, 99 ], [ 15, 99 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ null ], [ null ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ [ [ null, 1, 9 ], [ 12, "true", false ] ] , 0 ], [ [ [ null, 1, 9 ], [ 12, "true", false ] ] ,0 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ false ], [ false ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ false, true ], [ false, true ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ null ], [ false ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ null ], [ true ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ null ], [ 0 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ null ], [ [ ] ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ false ], [ true ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ false ], [ 0 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ false ], [ -1 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ false ], [ '' ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ false ], [ '0' ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ false ], [ 'abcd' ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ false ], [ [ ] ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ false ], [ [ false ] ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ true ], [ 0 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ true ], [ -1 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ true ], [ '' ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ true ], [ '0' ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ true ], [ 'abcd' ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ true ], [ [ ] ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ true ], [ [ false ] ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ false, false ], [ true ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ false, false ], [ false, true ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ false, false ], [ false, 0 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ null, null ], [ null, false ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ ], { }));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ ], { 'a' : true }));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ ], { 'a' : null }));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ ], { 'a' : false }));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ '' ], { }));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 0 ], { }));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ null ], { }));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ false ], { }));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ false ], { 'a' : false }));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ true ], { 'a' : false }));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 'abcd' ], { 'a' : false }));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 5 ], { 'a' : false }));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 5, 6 ], { 'a' : 2, 'b' : 2 }));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 5, 6, 7 ], { }));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 5, 6, false ], [ 5, 6, true ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 5, 6, true ], [ 5, 6, 0 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 5, 6, 999 ], [ 5, 6, '' ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 5, 6, 'a' ], [ 5, 6, 'b' ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 5, 6, 'A' ], [ 5, 6, 'a' ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 5, 6, '' ], [ 5, 6, 'a' ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 5, 6, 9, 9 ], [ 5, 6, [ ] ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 5, 6, true ], [ 5, 6, [ ] ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 5, 6, true ], [ 5, 6, { } ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ 5, 6, 9, 9 ], [ 5, 6, { } ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL({ }, { }));
|
|
assertTrue(RELATIONAL_LESSEQUAL({ 'A' : true }, { 'A' : true }));
|
|
assertTrue(RELATIONAL_LESSEQUAL({ 'a' : true, 'b' : false }, { 'a' : true, 'b' : false }));
|
|
assertTrue(RELATIONAL_LESSEQUAL({ 'a' : true, 'b' : false }, { 'b' : false, 'a' : true }));
|
|
assertTrue(RELATIONAL_LESSEQUAL({ 'a' : true, 'b' : { 'c' : 1, 'f' : 2 }, 'x' : 9 }, { 'x' : 9, 'b' : { 'f' : 2, 'c' : 1 }, 'a' : true }));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test RELATIONAL_LESSEQUAL function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRelationalLessEqualFalse: function() {
|
|
assertFalse(RELATIONAL_LESSEQUAL(false, null));
|
|
assertFalse(RELATIONAL_LESSEQUAL(true, null));
|
|
assertFalse(RELATIONAL_LESSEQUAL(0, null));
|
|
assertFalse(RELATIONAL_LESSEQUAL(1, null));
|
|
assertFalse(RELATIONAL_LESSEQUAL(-1, null));
|
|
assertFalse(RELATIONAL_LESSEQUAL('', null));
|
|
assertFalse(RELATIONAL_LESSEQUAL(' ', null));
|
|
assertFalse(RELATIONAL_LESSEQUAL('1', null));
|
|
assertFalse(RELATIONAL_LESSEQUAL('0', null));
|
|
assertFalse(RELATIONAL_LESSEQUAL('abcd', null));
|
|
assertFalse(RELATIONAL_LESSEQUAL('null', null));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ ], null));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ true ], null));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ false ], null));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ null ], null));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 0 ], null));
|
|
assertFalse(RELATIONAL_LESSEQUAL({ }, null));
|
|
assertFalse(RELATIONAL_LESSEQUAL({ 'a' : null }, null));
|
|
assertFalse(RELATIONAL_LESSEQUAL(true, false));
|
|
assertFalse(RELATIONAL_LESSEQUAL(0, false));
|
|
assertFalse(RELATIONAL_LESSEQUAL(1, false));
|
|
assertFalse(RELATIONAL_LESSEQUAL(-1, false));
|
|
assertFalse(RELATIONAL_LESSEQUAL('', false));
|
|
assertFalse(RELATIONAL_LESSEQUAL(' ', false));
|
|
assertFalse(RELATIONAL_LESSEQUAL('1', false));
|
|
assertFalse(RELATIONAL_LESSEQUAL('0', false));
|
|
assertFalse(RELATIONAL_LESSEQUAL('abcd', false));
|
|
assertFalse(RELATIONAL_LESSEQUAL('true', false));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ ], false));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ true ], false));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ false ], false));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ null ], false));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 0 ], false));
|
|
assertFalse(RELATIONAL_LESSEQUAL({ }, false));
|
|
assertFalse(RELATIONAL_LESSEQUAL({ 'a' : null }, false));
|
|
assertFalse(RELATIONAL_LESSEQUAL(0, true));
|
|
assertFalse(RELATIONAL_LESSEQUAL(1, true));
|
|
assertFalse(RELATIONAL_LESSEQUAL(-1, true));
|
|
assertFalse(RELATIONAL_LESSEQUAL('', true));
|
|
assertFalse(RELATIONAL_LESSEQUAL(' ', true));
|
|
assertFalse(RELATIONAL_LESSEQUAL('1', true));
|
|
assertFalse(RELATIONAL_LESSEQUAL('0', true));
|
|
assertFalse(RELATIONAL_LESSEQUAL('abcd', true));
|
|
assertFalse(RELATIONAL_LESSEQUAL('true', true));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ ], true));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ true ], true));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ false ], true));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ null ], true));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 0 ], true));
|
|
assertFalse(RELATIONAL_LESSEQUAL({ }, true));
|
|
assertFalse(RELATIONAL_LESSEQUAL({ 'a' : null }, true));
|
|
assertFalse(RELATIONAL_LESSEQUAL(1, 0));
|
|
assertFalse(RELATIONAL_LESSEQUAL(2, 1));
|
|
assertFalse(RELATIONAL_LESSEQUAL(100, 1));
|
|
assertFalse(RELATIONAL_LESSEQUAL(100, 20));
|
|
assertFalse(RELATIONAL_LESSEQUAL(1, -100));
|
|
assertFalse(RELATIONAL_LESSEQUAL(-10, -100));
|
|
assertFalse(RELATIONAL_LESSEQUAL(-10, -11));
|
|
assertFalse(RELATIONAL_LESSEQUAL(1000, 999));
|
|
assertFalse(RELATIONAL_LESSEQUAL(1, -1));
|
|
assertFalse(RELATIONAL_LESSEQUAL(0, -1));
|
|
assertFalse(RELATIONAL_LESSEQUAL(1.01, 1.0));
|
|
assertFalse(RELATIONAL_LESSEQUAL(1.2, 1.111));
|
|
assertFalse(RELATIONAL_LESSEQUAL(-1.110, -1.111));
|
|
assertFalse(RELATIONAL_LESSEQUAL(-1.1109, -1.111));
|
|
assertFalse(RELATIONAL_LESSEQUAL('', 0));
|
|
assertFalse(RELATIONAL_LESSEQUAL(' ', 0));
|
|
assertFalse(RELATIONAL_LESSEQUAL('0', 0));
|
|
assertFalse(RELATIONAL_LESSEQUAL('1', 0));
|
|
assertFalse(RELATIONAL_LESSEQUAL('-1', 0));
|
|
assertFalse(RELATIONAL_LESSEQUAL('true', 0));
|
|
assertFalse(RELATIONAL_LESSEQUAL('false', 0));
|
|
assertFalse(RELATIONAL_LESSEQUAL('null', 0));
|
|
assertFalse(RELATIONAL_LESSEQUAL('', 1));
|
|
assertFalse(RELATIONAL_LESSEQUAL(' ', 1));
|
|
assertFalse(RELATIONAL_LESSEQUAL('0', 1));
|
|
assertFalse(RELATIONAL_LESSEQUAL('1', 1));
|
|
assertFalse(RELATIONAL_LESSEQUAL('-1', 1));
|
|
assertFalse(RELATIONAL_LESSEQUAL('true', 1));
|
|
assertFalse(RELATIONAL_LESSEQUAL('false', 1));
|
|
assertFalse(RELATIONAL_LESSEQUAL('null', 1));
|
|
assertFalse(RELATIONAL_LESSEQUAL('-1', 0));
|
|
assertFalse(RELATIONAL_LESSEQUAL('-100', 0));
|
|
assertFalse(RELATIONAL_LESSEQUAL('-1.1', 0));
|
|
assertFalse(RELATIONAL_LESSEQUAL('-0.0', 0));
|
|
assertFalse(RELATIONAL_LESSEQUAL('-1', 1000));
|
|
assertFalse(RELATIONAL_LESSEQUAL('10', 1000));
|
|
assertFalse(RELATIONAL_LESSEQUAL('10000', 1000));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ ], 0));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 0 ], 0));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ ], 10));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ ], 100));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 0 ], 100));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 0, 1 ], 100));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 99 ], 100));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 100 ], 100));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 101 ], 100));
|
|
assertFalse(RELATIONAL_LESSEQUAL({ }, 100));
|
|
assertFalse(RELATIONAL_LESSEQUAL({ 'a' : 0 }, 100));
|
|
assertFalse(RELATIONAL_LESSEQUAL({ 'a' : 1 }, 100));
|
|
assertFalse(RELATIONAL_LESSEQUAL({ 'a' : 99 }, 100));
|
|
assertFalse(RELATIONAL_LESSEQUAL({ 'a' : 100 }, 100));
|
|
assertFalse(RELATIONAL_LESSEQUAL({ 'a' : 101 }, 100));
|
|
assertFalse(RELATIONAL_LESSEQUAL({ 'a' : 1000 }, 100));
|
|
assertFalse(RELATIONAL_LESSEQUAL({ 'a' : false }, 'zz'));
|
|
assertFalse(RELATIONAL_LESSEQUAL({ 'a' : 'a' }, 'zz'));
|
|
assertFalse(RELATIONAL_LESSEQUAL(' ', ''));
|
|
assertFalse(RELATIONAL_LESSEQUAL('a', '0'));
|
|
assertFalse(RELATIONAL_LESSEQUAL('a ', 'a'));
|
|
assertFalse(RELATIONAL_LESSEQUAL('b', 'a'));
|
|
assertFalse(RELATIONAL_LESSEQUAL('a', 'A'));
|
|
assertFalse(RELATIONAL_LESSEQUAL('Ab', 'AB'));
|
|
assertFalse(RELATIONAL_LESSEQUAL('bbcd', 'abcd'));
|
|
assertFalse(RELATIONAL_LESSEQUAL('abda', 'abcd'));
|
|
assertFalse(RELATIONAL_LESSEQUAL('abdd', 'abcd'));
|
|
assertFalse(RELATIONAL_LESSEQUAL('abcde', 'abcd'));
|
|
assertFalse(RELATIONAL_LESSEQUAL('abcde', '0abcde'));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 0 ], [ ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 1 ], [ 0 ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 0, 1, 2, 3 ], [ 0, 1, 2 ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 0, 1, 3 ], [ 0, 1, 2 ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 1, 0, 0 ], [ 0, 1, 4 ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 1 ], [ 0, 1, 4 ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 110 ], [ 15, 99 ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 15, 100 ], [ 15, 99 ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ false ], [ ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ true ], [ ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 0 ], [ ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ -1 ], [ ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ '' ], [ ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ '0' ], [ ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 'abcd' ], [ ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ [ ] ], [ ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ [ null ] ], [ ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ { } ], [ ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ false ], [ null ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ true ], [ null ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 0 ], [ null ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ [ ] ], [ null ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ true ], [ false ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 0 ], [ false ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ -1 ], [ false ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ '' ], [ false ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ '0' ], [ false ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 'abcd' ], [ false ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ [ ] ], [ false ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ [ false ] ], [ false ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 0 ], [ true ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ -1 ], [ true ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ '' ], [ true ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ '0' ], [ true ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ 'abcd' ], [ true ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ [ ] ], [ true ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ [ false] ], [ true ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ true ], [ false, false ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ false, true ], [ false, false ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ false, 0 ], [ false, false ]));
|
|
assertFalse(RELATIONAL_LESSEQUAL([ null, false ], [ null, null ]));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test RELATIONAL_GREATEREQUAL function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRelationalGreaterEqualTrue: function() {
|
|
assertTrue(RELATIONAL_GREATEREQUAL(false, null));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(true, null));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(0, null));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(1, null));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(-1, null));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('', null));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(' ', null));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('1', null));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('0', null));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('abcd', null));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('null', null));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ ], null));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ true ], null));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ false ], null));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ null ], null));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 0 ], null));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ }, null));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : null }, null));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(true, false));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(0, false));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(1, false));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(-1, false));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('', false));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(' ', false));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('1', false));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('0', false));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('abcd', false));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('true', false));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ ], false));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ true ], false));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ false ], false));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ null ], false));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 0 ], false));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ }, false));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : null }, false));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(0, true));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(1, true));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(-1, true));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('', true));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(' ', true));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('1', true));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('0', true));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('abcd', true));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('true', true));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ ], true));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ true ], true));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ false ], true));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ null ], true));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 0 ], true));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ }, true));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : null }, true));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(1, 0));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(2, 1));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(100, 1));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(100, 20));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(1, -100));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(-10, -100));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(-10, -11));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(1000, 999));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(1, -1));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(0, -1));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(1.01, 1.0));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(1.2, 1.111));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(-1.110, -1.111));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(-1.1109, -1.111));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('', 0));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(' ', 0));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('0', 0));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('1', 0));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('-1', 0));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('true', 0));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('false', 0));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('null', 0));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('', 1));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(' ', 1));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('0', 1));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('1', 1));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('-1', 1));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('true', 1));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('false', 1));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('null', 1));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('-1', 0));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('-100', 0));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('-1.1', 0));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('-0.0', 0));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('-1', 1000));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('10', 1000));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('10000', 1000));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ ], 0));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 0 ], 0));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ ], 10));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ ], 100));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 0 ], 100));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 0, 1 ], 100));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 99 ], 100));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 100 ], 100));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 101 ], 100));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ }, 100));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : 0 }, 100));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : 1 }, 100));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : 99 }, 100));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : 100 }, 100));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : 101 }, 100));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : 1000 }, 100));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : false }, 'zz'));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : 'a' }, 'zz'));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(' ', ''));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('a', '0'));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('a ', 'a'));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('b', 'a'));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('a', 'A'));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('Ab', 'AB'));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('bbcd', 'abcd'));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('abda', 'abcd'));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('abdd', 'abcd'));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('abcde', 'abcd'));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('abcde', '0abcde'));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 0 ], [ ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 1 ], [ 0 ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 0, 1, 2, 3 ], [ 0, 1, 2 ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 0, 1, 3 ], [ 0, 1, 2 ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 1, 0, 0 ], [ 0, 1, 4 ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 1 ], [ 0, 1, 4 ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 110 ], [ 15, 99 ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 15, 100 ], [ 15, 99 ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ null ], [ ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ false ], [ ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ true ], [ ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 0 ], [ ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ -1 ], [ ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ '' ], [ ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ '0' ], [ ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 'abcd' ], [ ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ [ ] ], [ ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ [ null ] ], [ ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ { } ], [ ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ false ], [ null ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ true ], [ null ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 0 ], [ null ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ [ ] ], [ null ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ true ], [ false ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 0 ], [ false ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ -1 ], [ false ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ '' ], [ false ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ '0' ], [ false ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 'abcd' ], [ false ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ [ ] ], [ false ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ [ false ] ], [ false ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 0 ], [ true ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ -1 ], [ true ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ '' ], [ true ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ '0' ], [ true ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 'abcd' ], [ true ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ [ ] ], [ true ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ [ false] ], [ true ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ true ], [ false, false ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ false, true ], [ false, false ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ false, 0 ], [ false, false ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ null, false ], [ null, null ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(null, null));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(false, false));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(true, true));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(0, 0));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(1, 1));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(2, 2));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(20, 20));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(100, 100));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(-100, -100));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(-11, -11));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(999, 999));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(-1, -1));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(1.0, 1.0));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(1.111, 1.111));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(1.2, 1.2));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(-1.111, -1.111));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('', ''));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('0', '0'));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('a', 'a'));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('A', 'A'));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('AB', 'AB'));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('Ab', 'Ab'));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('abcd', 'abcd'));
|
|
assertTrue(RELATIONAL_GREATEREQUAL('0abcd', '0abcd'));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(' ', ' '));
|
|
assertTrue(RELATIONAL_GREATEREQUAL(' ', ' '));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ ], [ ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 0 ], [ 0 ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 0, 1, 2 ], [ 0, 1, 2 ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 15, 99 ], [ 15, 99 ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ null ], [ null ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ [ [ null, 1, 9 ], [ 12, "true", false ] ] , 0 ], [ [ [ null, 1, 9 ], [ 12, "true", false ] ] ,0 ]));
|
|
assertTrue(RELATIONAL_LESSEQUAL([ null ], [ ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ ], [ null ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ false ], [ false ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ false, true ], [ false, true ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ }, [ ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : true }, [ ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : null }, [ ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : false }, [ ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ }, [ '' ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ }, [ 0 ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ }, [ null ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ }, [ false ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : false }, [ false ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : false }, [ true ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : false }, [ 'abcd' ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : false }, [ 5 ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : 2, 'b' : 2 }, [ 5, 6 ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ }, [ 5, 6, 7 ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 5, 6, true ], [ 5, 6, false ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 5, 6, 0 ], [ 5, 6, true ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 5, 6, '' ], [ 5, 6, 999 ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 5, 6, 'b' ], [ 5, 6, 'a' ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 5, 6, 'a' ], [ 5, 6, 'A' ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 5, 6, 'a' ], [ 5, 6, '' ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 5, 6, [ ] ], [ 5, 6, 9, 9 ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 5, 6, [ ] ], [ 5, 6, true ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 5, 6, { } ], [ 5, 6, true ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL([ 5, 6, { } ], [ 5, 6, 9, 9 ]));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : 0 }, { }));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : 2 }, { 'a' : 1 }));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'A' : 2 }, { 'a' : 1 }));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'A' : 1 }, { 'a' : 2 }));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : 1, 'b' : 2, 'c' : null }, { 'a' : 1, 'b' : 2 }));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : 1 }, { 'b' : 1 }));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : 1, 'b' : 2, 'c': null }, { 'b' : 2, 'a' : 1 }));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : [ 10 ], 'b' : true }, { 'a' : [ 9 ], 'b' : false }));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : [ 10 ], 'b' : true }, { 'a' : [ 9 ], 'b' : true }));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : [ 10 ], 'b' : true }, { 'a' : [ ], 'b' : true }));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : [ 10, 1 ] }, { 'a' : [ 10 ], 'b' : true }));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ }, { }));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'A' : true }, { 'A' : true }));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : true, 'b' : false }, { 'a' : true, 'b' : false }));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : true, 'b' : false }, { 'b' : false, 'a' : true }));
|
|
assertTrue(RELATIONAL_GREATEREQUAL({ 'a' : true, 'b' : { 'c' : 1, 'f' : 2 }, 'x' : 9 }, { 'x' : 9, 'b' : { 'f' : 2, 'c' : 1 }, 'a' : true }));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test RELATIONAL_GREATEREQUAL function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRelationalGreaterEqualFalse: function() {
|
|
assertFalse(RELATIONAL_GREATEREQUAL(null, false));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(null, true));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(null, 0));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(null, 1));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(null, -1));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(null, ''));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(null, ' '));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(null, '1'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(null, '0'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(null, 'abcd'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(null, 'null'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(null, [ ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(null, [ true ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(null, [ false ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(null, [ null ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(null, [ 0 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(null, { }));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(null, { 'a' : null }));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(false, true));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(false, 0));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(false, 1));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(false, -1));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(false, ''));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(false, ' '));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(false, '1'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(false, '0'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(false, 'abcd'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(false, 'true'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(false, [ ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(false, [ true ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(false, [ false ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(false, [ null ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(false, [ 0 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(false, { }));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(false, { 'a' : null }));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(true, 0));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(true, 1));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(true, -1));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(true, ''));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(true, ' '));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(true, '1'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(true, '0'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(true, 'abcd'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(true, 'true'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(true, [ ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(true, [ true ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(true, [ false ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(true, [ null ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(true, [ 0 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(true, { }));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(true, { 'a' : null }));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(0, 1));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(1, 2));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(1, 100));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(20, 100));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(-100, 1));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(-100, -10));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(-11, -10));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(999, 1000));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(-1, 1));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(-1, 0));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(1.0, 1.01));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(1.111, 1.2));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(-1.111, -1.110));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(-1.111, -1.1109));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(0, ''));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(0, ' '));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(0, '0'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(0, '1'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(0, '-1'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(0, 'true'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(0, 'false'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(0, 'null'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(1, ''));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(1, ' '));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(1, '0'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(1, '1'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(1, '-1'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(1, 'true'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(1, 'false'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(1, 'null'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(0, '-1'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(0, '-100'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(0, '-1.1'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(0, '-0.0'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(1000, '-1'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(1000, '10'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(1000, '10000'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(0, [ ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(0, [ 0 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(10, [ ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(100, [ ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(100, [ 0 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(100, [ 0, 1 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(100, [ 99 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(100, [ 100 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(100, [ 101 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(100, { }));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(100, { 'a' : 0 }));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(100, { 'a' : 1 }));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(100, { 'a' : 99 }));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(100, { 'a' : 100 }));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(100, { 'a' : 101 }));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(100, { 'a' : 1000 }));
|
|
assertFalse(RELATIONAL_GREATEREQUAL('', ' '));
|
|
assertFalse(RELATIONAL_GREATEREQUAL('0', 'a'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL('a', 'a '));
|
|
assertFalse(RELATIONAL_GREATEREQUAL('a', 'b'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL('A', 'a'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL('AB', 'Ab'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL('abcd', 'bbcd'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL('abcd', 'abda'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL('abcd', 'abdd'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL('abcd', 'abcde'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL('0abcd', 'abcde'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL(' abcd', 'abcd'));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ ], [ 0 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ 0 ], [ 1 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ 0, 1, 2 ], [ 0, 1, 2, 3 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ 0, 1, 2 ], [ 0, 1, 3 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ 0, 1, 4 ], [ 1, 0, 0 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ 0, 1, 4 ], [ 1 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ 15, 99 ], [ 110 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ 15, 99 ], [ 15, 100 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ ], [ false ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ ], [ true ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ ], [ 0 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ ], [ -1 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ ], [ '' ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ ], [ '0' ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ ], [ 'abcd' ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ ], [ [ ] ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ ], [ [ null ] ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ ], [ { } ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ null ], [ false ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ null ], [ true ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ null ], [ 0 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ null ], [ [ ] ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ false ], [ true ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ false ], [ 0 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ false ], [ -1 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ false ], [ '' ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ false ], [ '0' ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ false ], [ 'abcd' ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ false ], [ [ ] ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ false ], [ [ false ] ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ true ], [ 0 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ true ], [ -1 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ true ], [ '' ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ true ], [ '0' ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ true ], [ 'abcd' ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ true ], [ [ ] ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ true ], [ [ false ] ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ false, false ], [ true ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ false, false ], [ false, true ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ false, false ], [ false, 0 ]));
|
|
assertFalse(RELATIONAL_GREATEREQUAL([ null, null ], [ null, false ]));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test RELATIONAL_IN function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRelationalInUndefined: function() {
|
|
assertFalse(RELATIONAL_IN(null, null));
|
|
assertFalse(RELATIONAL_IN(null, false));
|
|
assertFalse(RELATIONAL_IN(null, true));
|
|
assertFalse(RELATIONAL_IN(null, 0));
|
|
assertFalse(RELATIONAL_IN(null, 1));
|
|
assertFalse(RELATIONAL_IN(null, ''));
|
|
assertFalse(RELATIONAL_IN(null, '1'));
|
|
assertFalse(RELATIONAL_IN(null, 'a'));
|
|
assertFalse(RELATIONAL_IN(null, { }));
|
|
assertFalse(RELATIONAL_IN(null, { 'A' : true }));
|
|
assertFalse(RELATIONAL_IN(false, null));
|
|
assertFalse(RELATIONAL_IN(false, false));
|
|
assertFalse(RELATIONAL_IN(false, true));
|
|
assertFalse(RELATIONAL_IN(false, 0));
|
|
assertFalse(RELATIONAL_IN(false, 1));
|
|
assertFalse(RELATIONAL_IN(false, ''));
|
|
assertFalse(RELATIONAL_IN(false, '1'));
|
|
assertFalse(RELATIONAL_IN(false, 'a'));
|
|
assertFalse(RELATIONAL_IN(false, { }));
|
|
assertFalse(RELATIONAL_IN(false, { 'A' : true }));
|
|
assertFalse(RELATIONAL_IN(true, null));
|
|
assertFalse(RELATIONAL_IN(true, false));
|
|
assertFalse(RELATIONAL_IN(true, true));
|
|
assertFalse(RELATIONAL_IN(true, 0));
|
|
assertFalse(RELATIONAL_IN(true, 1));
|
|
assertFalse(RELATIONAL_IN(true, ''));
|
|
assertFalse(RELATIONAL_IN(true, '1'));
|
|
assertFalse(RELATIONAL_IN(true, 'a'));
|
|
assertFalse(RELATIONAL_IN(true, { }));
|
|
assertFalse(RELATIONAL_IN(true, { 'A' : true }));
|
|
assertFalse(RELATIONAL_IN(0, null));
|
|
assertFalse(RELATIONAL_IN(0, false));
|
|
assertFalse(RELATIONAL_IN(0, true));
|
|
assertFalse(RELATIONAL_IN(0, 0));
|
|
assertFalse(RELATIONAL_IN(0, 1));
|
|
assertFalse(RELATIONAL_IN(0, ''));
|
|
assertFalse(RELATIONAL_IN(0, '1'));
|
|
assertFalse(RELATIONAL_IN(0, 'a'));
|
|
assertFalse(RELATIONAL_IN(0, { }));
|
|
assertFalse(RELATIONAL_IN(0, { 'A' : true }));
|
|
assertFalse(RELATIONAL_IN(1, null));
|
|
assertFalse(RELATIONAL_IN(1, false));
|
|
assertFalse(RELATIONAL_IN(1, true));
|
|
assertFalse(RELATIONAL_IN(1, 0));
|
|
assertFalse(RELATIONAL_IN(1, 1));
|
|
assertFalse(RELATIONAL_IN(1, ''));
|
|
assertFalse(RELATIONAL_IN(1, '1'));
|
|
assertFalse(RELATIONAL_IN(1, 'a'));
|
|
assertFalse(RELATIONAL_IN(1, { }));
|
|
assertFalse(RELATIONAL_IN(1, { 'A' : true }));
|
|
assertFalse(RELATIONAL_IN('', null));
|
|
assertFalse(RELATIONAL_IN('', false));
|
|
assertFalse(RELATIONAL_IN('', true));
|
|
assertFalse(RELATIONAL_IN('', 0));
|
|
assertFalse(RELATIONAL_IN('', 1));
|
|
assertFalse(RELATIONAL_IN('', ''));
|
|
assertFalse(RELATIONAL_IN('', '1'));
|
|
assertFalse(RELATIONAL_IN('', 'a'));
|
|
assertFalse(RELATIONAL_IN('', { }));
|
|
assertFalse(RELATIONAL_IN('', { 'A' : true }));
|
|
assertFalse(RELATIONAL_IN('a', null));
|
|
assertFalse(RELATIONAL_IN('a', false));
|
|
assertFalse(RELATIONAL_IN('a', true));
|
|
assertFalse(RELATIONAL_IN('a', 0));
|
|
assertFalse(RELATIONAL_IN('a', 1));
|
|
assertFalse(RELATIONAL_IN('a', ''));
|
|
assertFalse(RELATIONAL_IN('a', '1'));
|
|
assertFalse(RELATIONAL_IN('a', 'a'));
|
|
assertFalse(RELATIONAL_IN('a', { }));
|
|
assertFalse(RELATIONAL_IN('a', { 'A' : true }));
|
|
assertFalse(RELATIONAL_IN([ ], null));
|
|
assertFalse(RELATIONAL_IN([ ], false));
|
|
assertFalse(RELATIONAL_IN([ ], true));
|
|
assertFalse(RELATIONAL_IN([ ], 0));
|
|
assertFalse(RELATIONAL_IN([ ], 1));
|
|
assertFalse(RELATIONAL_IN([ ], ''));
|
|
assertFalse(RELATIONAL_IN([ ], '1'));
|
|
assertFalse(RELATIONAL_IN([ ], 'a'));
|
|
assertFalse(RELATIONAL_IN([ ], { }));
|
|
assertFalse(RELATIONAL_IN([ ], { 'A' : true }));
|
|
assertFalse(RELATIONAL_IN([ 0 ], null));
|
|
assertFalse(RELATIONAL_IN([ 0 ], false));
|
|
assertFalse(RELATIONAL_IN([ 0 ], true));
|
|
assertFalse(RELATIONAL_IN([ 0 ], 0));
|
|
assertFalse(RELATIONAL_IN([ 0 ], 1));
|
|
assertFalse(RELATIONAL_IN([ 0 ], ''));
|
|
assertFalse(RELATIONAL_IN([ 0 ], '1'));
|
|
assertFalse(RELATIONAL_IN([ 0 ], 'a'));
|
|
assertFalse(RELATIONAL_IN([ 0 ], { }));
|
|
assertFalse(RELATIONAL_IN([ 0 ], { 'A' : true }));
|
|
assertFalse(RELATIONAL_IN([ 1 ], null));
|
|
assertFalse(RELATIONAL_IN([ 1 ], false));
|
|
assertFalse(RELATIONAL_IN([ 1 ], true));
|
|
assertFalse(RELATIONAL_IN([ 1 ], 0));
|
|
assertFalse(RELATIONAL_IN([ 1 ], 1));
|
|
assertFalse(RELATIONAL_IN([ 1 ], ''));
|
|
assertFalse(RELATIONAL_IN([ 1 ], '1'));
|
|
assertFalse(RELATIONAL_IN([ 1 ], 'a'));
|
|
assertFalse(RELATIONAL_IN([ 1 ], { }));
|
|
assertFalse(RELATIONAL_IN([ 1 ], { 'A' : true }));
|
|
assertFalse(RELATIONAL_IN({ }, null));
|
|
assertFalse(RELATIONAL_IN({ }, false));
|
|
assertFalse(RELATIONAL_IN({ }, true));
|
|
assertFalse(RELATIONAL_IN({ }, 0));
|
|
assertFalse(RELATIONAL_IN({ }, 1));
|
|
assertFalse(RELATIONAL_IN({ }, ''));
|
|
assertFalse(RELATIONAL_IN({ }, '1'));
|
|
assertFalse(RELATIONAL_IN({ }, 'a'));
|
|
assertFalse(RELATIONAL_IN({ }, { }));
|
|
assertFalse(RELATIONAL_IN({ }, { 'A' : true }));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test RELATIONAL_IN function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRelationalInTrue: function() {
|
|
assertTrue(RELATIONAL_IN(null, [ null ]));
|
|
assertTrue(RELATIONAL_IN(null, [ null, false ]));
|
|
assertTrue(RELATIONAL_IN(null, [ false, null ]));
|
|
assertTrue(RELATIONAL_IN(false, [ false ]));
|
|
assertTrue(RELATIONAL_IN(false, [ true, false ]));
|
|
assertTrue(RELATIONAL_IN(false, [ 0, false ]));
|
|
assertTrue(RELATIONAL_IN(true, [ true ]));
|
|
assertTrue(RELATIONAL_IN(true, [ false, true ]));
|
|
assertTrue(RELATIONAL_IN(true, [ 0, false, true ]));
|
|
assertTrue(RELATIONAL_IN(0, [ 0 ]));
|
|
assertTrue(RELATIONAL_IN(1, [ 1 ]));
|
|
assertTrue(RELATIONAL_IN(0, [ 3, 2, 1, 0 ]));
|
|
assertTrue(RELATIONAL_IN(1, [ 3, 2, 1, 0 ]));
|
|
assertTrue(RELATIONAL_IN(-35.5, [ 3, 2, 1, -35.5, 0 ]));
|
|
assertTrue(RELATIONAL_IN(1.23e32, [ 3, 2, 1, 1.23e32, 35.5, 0 ]));
|
|
assertTrue(RELATIONAL_IN('', [ '' ]));
|
|
assertTrue(RELATIONAL_IN('', [ ' ', '' ]));
|
|
assertTrue(RELATIONAL_IN('', [ 'a', 'b', 'c', '' ]));
|
|
assertTrue(RELATIONAL_IN('A', [ 'c', 'b', 'a', 'A' ]));
|
|
assertTrue(RELATIONAL_IN(' ', [ ' ' ]));
|
|
assertTrue(RELATIONAL_IN(' a', [ ' a' ]));
|
|
assertTrue(RELATIONAL_IN(' a ', [ ' a ' ]));
|
|
assertTrue(RELATIONAL_IN([ ], [ [ ] ]));
|
|
assertTrue(RELATIONAL_IN([ ], [ 1, null, 2, 3, [ ], 5 ]));
|
|
assertTrue(RELATIONAL_IN([ null ], [ [ null ] ]));
|
|
assertTrue(RELATIONAL_IN([ null ], [ null, [ null ], true ]));
|
|
assertTrue(RELATIONAL_IN([ null, false ], [ [ null, false ] ]));
|
|
assertTrue(RELATIONAL_IN([ 'a', 'A', false ], [ 'a', true, [ 'a', 'A', false ] ]));
|
|
assertTrue(RELATIONAL_IN({ }, [ { } ]));
|
|
assertTrue(RELATIONAL_IN({ }, [ 'a', null, false, 0, { } ]));
|
|
assertTrue(RELATIONAL_IN({ 'a' : true }, [ 'a', null, false, 0, { 'a' : true } ]));
|
|
assertTrue(RELATIONAL_IN({ 'a' : true, 'A': false }, [ 'a', null, false, 0, { 'A' : false, 'a' : true } ]));
|
|
assertTrue(RELATIONAL_IN({ 'a' : { 'b' : null, 'c': 1 } }, [ { 'a' : { 'c' : 1, 'b' : null } } ]));
|
|
assertTrue(RELATIONAL_IN({ 'a' : { 'b' : null, 'c': 1 } }, [ 'a', 'b', { 'a' : { 'c' : 1, 'b' : null } } ]));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test RELATIONAL_IN function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRelationalInFalse: function() {
|
|
assertFalse(RELATIONAL_IN(null, [ ]));
|
|
assertFalse(RELATIONAL_IN(false, [ ]));
|
|
assertFalse(RELATIONAL_IN(true, [ ]));
|
|
assertFalse(RELATIONAL_IN(0, [ ]));
|
|
assertFalse(RELATIONAL_IN(1, [ ]));
|
|
assertFalse(RELATIONAL_IN('', [ ]));
|
|
assertFalse(RELATIONAL_IN('0', [ ]));
|
|
assertFalse(RELATIONAL_IN('1', [ ]));
|
|
assertFalse(RELATIONAL_IN([ ], [ ]));
|
|
assertFalse(RELATIONAL_IN([ 0 ], [ ]));
|
|
assertFalse(RELATIONAL_IN({ }, [ ]));
|
|
assertFalse(RELATIONAL_IN({ 'a' : true }, [ ]));
|
|
assertFalse(RELATIONAL_IN(null, [ '0', '1', '', 'null', 'true', 'false', -1, 0, 1, 2, 3, true, false, { }, [ ] ]));
|
|
assertFalse(RELATIONAL_IN(true, [ '0', '1', '', 'null', 'true', 'false', -1, 0, 1, 2, 3, null, false, { }, [ ] ]));
|
|
assertFalse(RELATIONAL_IN(false, [ '0', '1', '', 'null', 'true', 'false', -1, 0, 1, 2, 3, null, true, { }, [ ] ]));
|
|
assertFalse(RELATIONAL_IN(0, [ '0', '1', '', 'null', 'true', 'false', -1, 1, 2, 3, null, true, false, { }, [ ] ]));
|
|
assertFalse(RELATIONAL_IN(1, [ '0', '1', '', 'null', 'true', 'false', -1, 0, 2, 3, null, true, false, { }, [ ] ]));
|
|
assertFalse(RELATIONAL_IN(-1, [ '0', '1', '', 'null', 'true', 'false', 0, 1, 2, 3, null, true, false, { }, [ ] ]));
|
|
assertFalse(RELATIONAL_IN('', [ '0', '1', 'null', 'true', 'false', -1, 0, 1, 2, 3, null, true, false, { }, [ ] ]));
|
|
assertFalse(RELATIONAL_IN('0', [ '1', '', 'null', 'true', 'false', -1, 0, 1, 2, 3, null, true, false, { }, [ ] ]));
|
|
assertFalse(RELATIONAL_IN('1', [ '0', '', 'null', 'true', 'false', -1, 0, 1, 2, 3, null, true, false, { }, [ ] ]));
|
|
assertFalse(RELATIONAL_IN([ ], [ '0', '1', '', 'null', 'true', 'false', -1, 0, 1, 2, 3, null, true, false, { } ]));
|
|
assertFalse(RELATIONAL_IN({ }, [ '0', '1', '', 'null', 'true', 'false', -1, 0, 1, 2, 3, null, true, false, [ ] ]));
|
|
assertFalse(RELATIONAL_IN(null, [ [ null ]]));
|
|
assertFalse(RELATIONAL_IN(false, [ [ false ]]));
|
|
assertFalse(RELATIONAL_IN(true, [ [ true ]]));
|
|
assertFalse(RELATIONAL_IN(0, [ [ 0 ]]));
|
|
assertFalse(RELATIONAL_IN(1, [ [ 1 ]]));
|
|
assertFalse(RELATIONAL_IN('', [ [ '' ]]));
|
|
assertFalse(RELATIONAL_IN('1', [ [ '1' ]]));
|
|
assertFalse(RELATIONAL_IN('', [ [ '' ]]));
|
|
assertFalse(RELATIONAL_IN(' ', [ [ ' ' ]]));
|
|
assertFalse(RELATIONAL_IN('a', [ 'A' ]));
|
|
assertFalse(RELATIONAL_IN('a', [ 'b', 'c', 'd' ]));
|
|
assertFalse(RELATIONAL_IN('', [ ' ', ' ' ]));
|
|
assertFalse(RELATIONAL_IN(' ', [ '', ' ' ]));
|
|
assertFalse(RELATIONAL_IN([ ], [ 0 ]));
|
|
assertFalse(RELATIONAL_IN([ ], [ 1, 2 ]));
|
|
assertFalse(RELATIONAL_IN([ 0 ], [ 1, 2 ]));
|
|
assertFalse(RELATIONAL_IN([ 1 ], [ 1, 2 ]));
|
|
assertFalse(RELATIONAL_IN([ 2 ], [ 1, 2 ]));
|
|
assertFalse(RELATIONAL_IN([ 1, 2 ], [ 1, 2 ]));
|
|
assertFalse(RELATIONAL_IN([ 1, 2 ], [ [ 1 ], [ 2 ] ]));
|
|
assertFalse(RELATIONAL_IN([ 1, 2 ], [ [ 2, 1 ] ]));
|
|
assertFalse(RELATIONAL_IN([ 1, 2 ], [ [ 1, 2, 3 ] ]));
|
|
assertFalse(RELATIONAL_IN([ 1, 2, 3 ], [ [ 1, 2, 4 ] ]));
|
|
assertFalse(RELATIONAL_IN([ 1, 2, 3 ], [ [ 0, 1, 2, 3 ] ]));
|
|
assertFalse(RELATIONAL_IN({ 'a' : true }, [ { 'a' : true, 'b' : false } ]));
|
|
assertFalse(RELATIONAL_IN({ 'a' : true }, [ { 'a' : false } ]));
|
|
assertFalse(RELATIONAL_IN({ 'a' : true }, [ { 'b' : true } ]));
|
|
assertFalse(RELATIONAL_IN({ 'a' : true }, [ [ { 'a' : true } ] ]));
|
|
assertFalse(RELATIONAL_IN({ 'a' : true }, [ 1, 2, { 'a' : { 'a' : true } } ]));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test UNARY_PLUS function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUnaryPlusUndefined: function() {
|
|
assertEqual(0, UNARY_PLUS(null));
|
|
assertEqual(0, UNARY_PLUS(false));
|
|
assertEqual(1, UNARY_PLUS(true));
|
|
assertEqual(0, UNARY_PLUS(' '));
|
|
assertEqual(0, UNARY_PLUS('abc'));
|
|
assertEqual(0, UNARY_PLUS('1abc'));
|
|
assertEqual(0, UNARY_PLUS('abc1'));
|
|
assertEqual(1, UNARY_PLUS('1 '));
|
|
assertEqual(1, UNARY_PLUS(' 1 '));
|
|
assertEqual(0, UNARY_PLUS(''));
|
|
assertEqual(-1, UNARY_PLUS('-1'));
|
|
assertEqual(0, UNARY_PLUS('0'));
|
|
assertEqual(1, UNARY_PLUS('1'));
|
|
assertEqual(1.5, UNARY_PLUS('1.5'));
|
|
assertEqual(0, UNARY_PLUS([ ]));
|
|
assertEqual(0, UNARY_PLUS([ 0 ]));
|
|
assertEqual(1, UNARY_PLUS([ 1 ]));
|
|
assertEqual(17, UNARY_PLUS([ 17 ]));
|
|
assertEqual(0, UNARY_PLUS({ 'a' : 1 }));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test UNARY_PLUS function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUnaryPlusValue: function() {
|
|
assertEqual(0, UNARY_PLUS(0));
|
|
assertEqual(1, UNARY_PLUS(1));
|
|
assertEqual(-1, UNARY_PLUS(-1));
|
|
assertEqual(0.0001, UNARY_PLUS(0.0001));
|
|
assertEqual(-0.0001, UNARY_PLUS(-0.0001));
|
|
assertEqual(100, UNARY_PLUS(100));
|
|
assertEqual(1054.342, UNARY_PLUS(1054.342));
|
|
assertEqual(-1054.342, UNARY_PLUS(-1054.342));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test UNARY_MINUS function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUnaryMinusUndefined: function() {
|
|
assertEqual(0, UNARY_MINUS(null));
|
|
assertEqual(0, UNARY_MINUS(false));
|
|
assertEqual(-1, UNARY_MINUS(true));
|
|
assertEqual(0, UNARY_MINUS(''));
|
|
assertEqual(0, UNARY_MINUS(' '));
|
|
assertEqual(0, UNARY_MINUS('abc'));
|
|
assertEqual(0, UNARY_MINUS('1abc'));
|
|
assertEqual(0, UNARY_MINUS('abc1'));
|
|
assertEqual(-1, UNARY_MINUS(' 1'));
|
|
assertEqual(-1, UNARY_MINUS('1 '));
|
|
assertEqual(1, UNARY_MINUS('-1'));
|
|
assertEqual(0, UNARY_MINUS('0'));
|
|
assertEqual(-1, UNARY_MINUS('1'));
|
|
assertEqual(-1.5, UNARY_MINUS('1.5'));
|
|
assertEqual(1.5, UNARY_MINUS('-1.5'));
|
|
assertEqual(0, UNARY_MINUS([ ]));
|
|
assertEqual(0, UNARY_MINUS([ 0 ]));
|
|
assertEqual(-1, UNARY_MINUS([ 1 ]));
|
|
assertEqual(23, UNARY_MINUS([ -23 ]));
|
|
assertEqual(0, UNARY_MINUS([ 1, 2 ]));
|
|
assertEqual(0, UNARY_MINUS({ 'a' : 1 }));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test UNARY_MINUS function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUnaryMinusValue: function() {
|
|
assertEqual(0, UNARY_MINUS(0));
|
|
assertEqual(1, UNARY_MINUS(-1));
|
|
assertEqual(-1, UNARY_MINUS(1));
|
|
assertEqual(0.0001, UNARY_MINUS(-0.0001));
|
|
assertEqual(-0.0001, UNARY_MINUS(0.0001));
|
|
assertEqual(100, UNARY_MINUS(-100));
|
|
assertEqual(-100, UNARY_MINUS(100));
|
|
assertEqual(1054.342, UNARY_MINUS(-1054.342));
|
|
assertEqual(-1054.342, UNARY_MINUS(1054.342));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test ARITHMETIC_PLUS function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testArithmeticPlusUndefined: function() {
|
|
assertEqual(1, ARITHMETIC_PLUS(1, null));
|
|
assertEqual(1, ARITHMETIC_PLUS(1, false));
|
|
assertEqual(2, ARITHMETIC_PLUS(1, true));
|
|
assertEqual('1', ARITHMETIC_PLUS(1, ''));
|
|
assertEqual(1, ARITHMETIC_PLUS(1, ' '));
|
|
assertEqual(1, ARITHMETIC_PLUS(1, '0'));
|
|
assertEqual(2, ARITHMETIC_PLUS(1, '1'));
|
|
assertEqual(1, ARITHMETIC_PLUS(1, 'a'));
|
|
assertEqual(1, ARITHMETIC_PLUS(1, [ ]));
|
|
assertEqual(1, ARITHMETIC_PLUS(1, [ 0 ]));
|
|
assertEqual(1, ARITHMETIC_PLUS(1, { }));
|
|
assertEqual(1, ARITHMETIC_PLUS(1, { 'a' : 0 }));
|
|
assertEqual(1, ARITHMETIC_PLUS(null, 1));
|
|
assertEqual(1, ARITHMETIC_PLUS(false, 1));
|
|
assertEqual(2, ARITHMETIC_PLUS(true, 1));
|
|
assertEqual(1, ARITHMETIC_PLUS('', 1));
|
|
assertEqual(1, ARITHMETIC_PLUS(' ', 1));
|
|
assertEqual(1, ARITHMETIC_PLUS('0', 1));
|
|
assertEqual(2, ARITHMETIC_PLUS('1', 1));
|
|
assertEqual(1, ARITHMETIC_PLUS('a', 1));
|
|
assertEqual(1, ARITHMETIC_PLUS([ ], 1));
|
|
assertEqual(1, ARITHMETIC_PLUS([ 0 ], 1));
|
|
assertEqual(4, ARITHMETIC_PLUS([ 3 ], 1));
|
|
assertEqual(1, ARITHMETIC_PLUS({ }, 1));
|
|
assertEqual(1, ARITHMETIC_PLUS({ 'a' : 0 }, 1));
|
|
assertEqual(0, ARITHMETIC_PLUS('0', '0'));
|
|
assertEqual(8, ARITHMETIC_PLUS('4', '4'));
|
|
assertEqual(0, ARITHMETIC_PLUS('4', '-4'));
|
|
assertEqual(0, ARITHMETIC_PLUS(1.3e308 * 10, 1.3e308 * 10));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test ARITHMETIC_PLUS function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testArithmeticPlusValue: function() {
|
|
assertEqual(0, ARITHMETIC_PLUS(0, 0));
|
|
assertEqual(0, ARITHMETIC_PLUS(1, -1));
|
|
assertEqual(0, ARITHMETIC_PLUS(-1, 1));
|
|
assertEqual(0, ARITHMETIC_PLUS(-100, 100));
|
|
assertEqual(0, ARITHMETIC_PLUS(100, -100));
|
|
assertEqual(0, ARITHMETIC_PLUS(0.11, -0.11));
|
|
assertEqual(10, ARITHMETIC_PLUS(5, 5));
|
|
assertEqual(10, ARITHMETIC_PLUS(4, 6));
|
|
assertEqual(10, ARITHMETIC_PLUS(1, 9));
|
|
assertEqual(10, ARITHMETIC_PLUS(0.1, 9.9));
|
|
assertEqual(9.8, ARITHMETIC_PLUS(-0.1, 9.9));
|
|
assertEqual(-34.2, ARITHMETIC_PLUS(-17.1, -17.1));
|
|
assertEqual(-2, ARITHMETIC_PLUS(-1, -1));
|
|
assertEqual(2.6e307, ARITHMETIC_PLUS(1.3e307, 1.3e307));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test ARITHMETIC_MINUS function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testArithmeticMinusUndefined: function() {
|
|
assertEqual(1, ARITHMETIC_MINUS(1, null));
|
|
assertEqual(1, ARITHMETIC_MINUS(1, false));
|
|
assertEqual(0, ARITHMETIC_MINUS(1, true));
|
|
assertEqual(1, ARITHMETIC_MINUS(1, ''));
|
|
assertEqual(1, ARITHMETIC_MINUS(1, ' '));
|
|
assertEqual(1, ARITHMETIC_MINUS(1, '0'));
|
|
assertEqual(0, ARITHMETIC_MINUS(1, '1'));
|
|
assertEqual(1, ARITHMETIC_MINUS(1, 'a'));
|
|
assertEqual(1, ARITHMETIC_MINUS(1, [ ]));
|
|
assertEqual(1, ARITHMETIC_MINUS(1, [ 0 ]));
|
|
assertEqual(1, ARITHMETIC_MINUS(1, { }));
|
|
assertEqual(1, ARITHMETIC_MINUS(1, { 'a' : 0 }));
|
|
assertEqual(-1, ARITHMETIC_MINUS(null, 1));
|
|
assertEqual(-1, ARITHMETIC_MINUS(false, 1));
|
|
assertEqual(0, ARITHMETIC_MINUS(true, 1));
|
|
assertEqual(-1, ARITHMETIC_MINUS('', 1));
|
|
assertEqual(-1, ARITHMETIC_MINUS(' ', 1));
|
|
assertEqual(-1, ARITHMETIC_MINUS('0', 1));
|
|
assertEqual(0, ARITHMETIC_MINUS('1', 1));
|
|
assertEqual(-1, ARITHMETIC_MINUS('a', 1));
|
|
assertEqual(-1, ARITHMETIC_MINUS([ ], 1));
|
|
assertEqual(-1, ARITHMETIC_MINUS([ 0 ], 1));
|
|
assertEqual(-1, ARITHMETIC_MINUS({ }, 1));
|
|
assertEqual(-1, ARITHMETIC_MINUS({ 'a' : 0 }, 1));
|
|
assertEqual(0, ARITHMETIC_MINUS('0', '0'));
|
|
assertEqual(0, ARITHMETIC_MINUS(-1.3e308 * 10, 1.3e308 * 10));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test ARITHMETIC_MINUS function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testArithmeticMinusValue: function() {
|
|
assertEqual(0, ARITHMETIC_MINUS(0, 0));
|
|
assertEqual(-1, ARITHMETIC_MINUS(0, 1));
|
|
assertEqual(0, ARITHMETIC_MINUS(-1, -1));
|
|
assertEqual(0, ARITHMETIC_MINUS(1, 1));
|
|
assertEqual(2, ARITHMETIC_MINUS(1, -1));
|
|
assertEqual(-2, ARITHMETIC_MINUS(-1, 1));
|
|
assertEqual(-200, ARITHMETIC_MINUS(-100, 100));
|
|
assertEqual(200, ARITHMETIC_MINUS(100, -100));
|
|
assertEqual(0.22, ARITHMETIC_MINUS(0.11, -0.11));
|
|
assertEqual(0, ARITHMETIC_MINUS(5, 5));
|
|
assertEqual(-2, ARITHMETIC_MINUS(4, 6));
|
|
assertEqual(-8, ARITHMETIC_MINUS(1, 9));
|
|
assertEqual(-9.8, ARITHMETIC_MINUS(0.1, 9.9));
|
|
assertEqual(-10, ARITHMETIC_MINUS(-0.1, 9.9));
|
|
assertEqual(0, ARITHMETIC_MINUS(-17.1, -17.1));
|
|
assertEqual(0, ARITHMETIC_MINUS(1.3e307, 1.3e307));
|
|
assertEqual(2.6e307, ARITHMETIC_MINUS(1.3e307, -1.3e307));
|
|
assertEqual(-2.6e307, ARITHMETIC_MINUS(-1.3e307, 1.3e307));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test ARITHMETIC_TIMES function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testArithmeticTimesUndefined: function() {
|
|
assertEqual(0, ARITHMETIC_TIMES(1, null));
|
|
assertEqual(0, ARITHMETIC_TIMES(1, false));
|
|
assertEqual(1, ARITHMETIC_TIMES(1, true));
|
|
assertEqual(2, ARITHMETIC_TIMES(2, true));
|
|
assertEqual(0, ARITHMETIC_TIMES(1, ''));
|
|
assertEqual(0, ARITHMETIC_TIMES(1, ' '));
|
|
assertEqual(0, ARITHMETIC_TIMES(1, '0'));
|
|
assertEqual(1, ARITHMETIC_TIMES(1, '1'));
|
|
assertEqual(0, ARITHMETIC_TIMES(1, 'a'));
|
|
assertEqual(0, ARITHMETIC_TIMES(1, [ ]));
|
|
assertEqual(0, ARITHMETIC_TIMES(1, [ 0 ]));
|
|
assertEqual(2, ARITHMETIC_TIMES(1, [ 2 ]));
|
|
assertEqual(0, ARITHMETIC_TIMES(1, { }));
|
|
assertEqual(0, ARITHMETIC_TIMES(1, { 'a' : 0 }));
|
|
assertEqual(0, ARITHMETIC_TIMES(null, 1));
|
|
assertEqual(0, ARITHMETIC_TIMES(false, 1));
|
|
assertEqual(1, ARITHMETIC_TIMES(true, 1));
|
|
assertEqual(2, ARITHMETIC_TIMES(true, 2));
|
|
assertEqual(0, ARITHMETIC_TIMES('', 1));
|
|
assertEqual(0, ARITHMETIC_TIMES(' ', 1));
|
|
assertEqual(0, ARITHMETIC_TIMES('0', 1));
|
|
assertEqual(1, ARITHMETIC_TIMES('1', 1));
|
|
assertEqual(0, ARITHMETIC_TIMES('a', 1));
|
|
assertEqual(0, ARITHMETIC_TIMES([ ], 1));
|
|
assertEqual(0, ARITHMETIC_TIMES([ 0 ], 1));
|
|
assertEqual(0, ARITHMETIC_TIMES({ }, 1));
|
|
assertEqual(0, ARITHMETIC_TIMES({ 'a' : 0 }, 1));
|
|
assertEqual(null, ARITHMETIC_TIMES(1.3e190, 1.3e190));
|
|
assertEqual(null, ARITHMETIC_TIMES(1.3e307, 1.3e307));
|
|
assertEqual(0, ARITHMETIC_TIMES(1.3e308 * 10, 1.3e308 * 10));
|
|
assertEqual(0, ARITHMETIC_TIMES('0', '0'));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test ARITHMETIC_TIMES function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testArithmeticTimesValue: function() {
|
|
assertEqual(0, ARITHMETIC_TIMES(0, 0));
|
|
assertEqual(0, ARITHMETIC_TIMES(1, 0));
|
|
assertEqual(0, ARITHMETIC_TIMES(0, 1));
|
|
assertEqual(1, ARITHMETIC_TIMES(1, 1));
|
|
assertEqual(2, ARITHMETIC_TIMES(2, 1));
|
|
assertEqual(2, ARITHMETIC_TIMES(1, 2));
|
|
assertEqual(4, ARITHMETIC_TIMES(2, 2));
|
|
assertEqual(100, ARITHMETIC_TIMES(10, 10));
|
|
assertEqual(1000, ARITHMETIC_TIMES(10, 100));
|
|
assertEqual(1.44, ARITHMETIC_TIMES(1.2, 1.2));
|
|
assertEqual(-1.44, ARITHMETIC_TIMES(1.2, -1.2));
|
|
assertEqual(1.44, ARITHMETIC_TIMES(-1.2, -1.2));
|
|
assertEqual(2, ARITHMETIC_TIMES(0.25, 8));
|
|
assertEqual(2, ARITHMETIC_TIMES(8, 0.25));
|
|
assertEqual(2.25, ARITHMETIC_TIMES(9, 0.25));
|
|
assertEqual(-2.25, ARITHMETIC_TIMES(9, -0.25));
|
|
assertEqual(-2.25, ARITHMETIC_TIMES(-9, 0.25));
|
|
assertEqual(2.25, ARITHMETIC_TIMES(-9, -0.25));
|
|
assertEqual(4, ARITHMETIC_TIMES(-2, -2));
|
|
assertEqual(-4, ARITHMETIC_TIMES(-2, 2));
|
|
assertEqual(-4, ARITHMETIC_TIMES(2, -2));
|
|
assertEqual(1000000, ARITHMETIC_TIMES(1000, 1000));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test ARITHMETIC_DIVIDE function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testArithmeticDivideUndefined: function() {
|
|
assertEqual(null, ARITHMETIC_DIVIDE(1, null));
|
|
assertEqual(null, ARITHMETIC_DIVIDE(1, false));
|
|
assertEqual(1, ARITHMETIC_DIVIDE(1, true));
|
|
assertEqual(2, ARITHMETIC_DIVIDE(2, true));
|
|
assertEqual(null, ARITHMETIC_DIVIDE(1, ''));
|
|
assertEqual(null, ARITHMETIC_DIVIDE(1, ' '));
|
|
assertEqual(null, ARITHMETIC_DIVIDE(1, '0'));
|
|
assertEqual(1, ARITHMETIC_DIVIDE(1, '1'));
|
|
assertEqual(2, ARITHMETIC_DIVIDE(2, '1'));
|
|
assertEqual(null, ARITHMETIC_DIVIDE(1, 'a'));
|
|
assertEqual(null, ARITHMETIC_DIVIDE(1, [ ]));
|
|
assertEqual(null, ARITHMETIC_DIVIDE(1, [ 0 ]));
|
|
assertEqual(0.5, ARITHMETIC_DIVIDE(1, [ 2 ]));
|
|
assertEqual(null, ARITHMETIC_DIVIDE(1, { }));
|
|
assertEqual(null, ARITHMETIC_DIVIDE(1, { 'a' : 0 }));
|
|
assertEqual(0, ARITHMETIC_DIVIDE(null, 1));
|
|
assertEqual(0, ARITHMETIC_DIVIDE(false, 1));
|
|
assertEqual(1, ARITHMETIC_DIVIDE(true, 1));
|
|
assertEqual(0, ARITHMETIC_DIVIDE('', 1));
|
|
assertEqual(0, ARITHMETIC_DIVIDE(' ', 1));
|
|
assertEqual(0, ARITHMETIC_DIVIDE('0', 1));
|
|
assertEqual(1, ARITHMETIC_DIVIDE('1', 1));
|
|
assertEqual(0, ARITHMETIC_DIVIDE('a', 1));
|
|
assertEqual(0, ARITHMETIC_DIVIDE([ ], 1));
|
|
assertEqual(0, ARITHMETIC_DIVIDE([ 0 ], 1));
|
|
assertEqual(0, ARITHMETIC_DIVIDE({ }, 1));
|
|
assertEqual(0, ARITHMETIC_DIVIDE({ 'a' : 0 }, 1));
|
|
assertEqual(null, ARITHMETIC_DIVIDE(1, 0));
|
|
assertEqual(null, ARITHMETIC_DIVIDE(100, 0));
|
|
assertEqual(null, ARITHMETIC_DIVIDE(-1, 0));
|
|
assertEqual(null, ARITHMETIC_DIVIDE(-100, 0));
|
|
assertEqual(null, ARITHMETIC_DIVIDE(0, 0));
|
|
assertEqual(null, ARITHMETIC_DIVIDE('0', '0'));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test ARITHMETIC_DIVIDE function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testArithmeticDivideValue: function() {
|
|
assertEqual(0, ARITHMETIC_DIVIDE(0, 1));
|
|
assertEqual(0, ARITHMETIC_DIVIDE(0, 2));
|
|
assertEqual(0, ARITHMETIC_DIVIDE(0, 10));
|
|
assertEqual(0, ARITHMETIC_DIVIDE(0, -1));
|
|
assertEqual(0, ARITHMETIC_DIVIDE(0, -2));
|
|
assertEqual(0, ARITHMETIC_DIVIDE(0, -10));
|
|
assertEqual(1, ARITHMETIC_DIVIDE(1, 1));
|
|
assertEqual(2, ARITHMETIC_DIVIDE(2, 1));
|
|
assertEqual(-1, ARITHMETIC_DIVIDE(-1, 1));
|
|
assertEqual(100, ARITHMETIC_DIVIDE(100, 1));
|
|
assertEqual(-100, ARITHMETIC_DIVIDE(-100, 1));
|
|
assertEqual(-1, ARITHMETIC_DIVIDE(1, -1));
|
|
assertEqual(-2, ARITHMETIC_DIVIDE(2, -1));
|
|
assertEqual(1, ARITHMETIC_DIVIDE(-1, -1));
|
|
assertEqual(-100, ARITHMETIC_DIVIDE(100, -1));
|
|
assertEqual(100, ARITHMETIC_DIVIDE(-100, -1));
|
|
assertEqual(0.5, ARITHMETIC_DIVIDE(1, 2));
|
|
assertEqual(1, ARITHMETIC_DIVIDE(2, 2));
|
|
assertEqual(2, ARITHMETIC_DIVIDE(4, 2));
|
|
assertEqual(1, ARITHMETIC_DIVIDE(4, 4));
|
|
assertEqual(5, ARITHMETIC_DIVIDE(10, 2));
|
|
assertEqual(2, ARITHMETIC_DIVIDE(10, 5));
|
|
assertEqual(2.5, ARITHMETIC_DIVIDE(10, 4));
|
|
assertEqual(1, ARITHMETIC_DIVIDE(1.2, 1.2));
|
|
assertEqual(-1, ARITHMETIC_DIVIDE(1.2, -1.2));
|
|
assertEqual(1, ARITHMETIC_DIVIDE(-1.2, -1.2));
|
|
assertEqual(2, ARITHMETIC_DIVIDE(1, 0.5));
|
|
assertEqual(4, ARITHMETIC_DIVIDE(1, 0.25));
|
|
assertEqual(16, ARITHMETIC_DIVIDE(4, 0.25));
|
|
assertEqual(-16, ARITHMETIC_DIVIDE(4, -0.25));
|
|
assertEqual(-16, ARITHMETIC_DIVIDE(-4, 0.25));
|
|
assertEqual(100, ARITHMETIC_DIVIDE(25, 0.25));
|
|
assertEqual(-100, ARITHMETIC_DIVIDE(25, -0.25));
|
|
assertEqual(-100, ARITHMETIC_DIVIDE(-25, 0.25));
|
|
assertEqual(1, ARITHMETIC_DIVIDE(0.22, 0.22));
|
|
assertEqual(0.5, ARITHMETIC_DIVIDE(0.22, 0.44));
|
|
assertEqual(2, ARITHMETIC_DIVIDE(0.22, 0.11));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test ARITHMETIC_MODULUS function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testArithmeticModulusUndefined: function() {
|
|
assertEqual(null, ARITHMETIC_MODULUS(1, null));
|
|
assertEqual(null, ARITHMETIC_MODULUS(1, false));
|
|
assertEqual(0, ARITHMETIC_MODULUS(1, true));
|
|
assertEqual(null, ARITHMETIC_MODULUS(1, ''));
|
|
assertEqual(null, ARITHMETIC_MODULUS(1, ' '));
|
|
assertEqual(null, ARITHMETIC_MODULUS(1, '0'));
|
|
assertEqual(0, ARITHMETIC_MODULUS(1, '1'));
|
|
assertEqual(null, ARITHMETIC_MODULUS(1, 'a'));
|
|
assertEqual(null, ARITHMETIC_MODULUS(1, [ ]));
|
|
assertEqual(null, ARITHMETIC_MODULUS(1, [ 0 ]));
|
|
assertEqual(0, ARITHMETIC_MODULUS(1, [ 1 ]));
|
|
assertEqual(1, ARITHMETIC_MODULUS(4, [ 3 ]));
|
|
assertEqual(null, ARITHMETIC_MODULUS(1, { }));
|
|
assertEqual(null, ARITHMETIC_MODULUS(1, { 'a' : 0 }));
|
|
assertEqual(0, ARITHMETIC_MODULUS(null, 1));
|
|
assertEqual(0, ARITHMETIC_MODULUS(false, 1));
|
|
assertEqual(0, ARITHMETIC_MODULUS(true, 1));
|
|
assertEqual(0, ARITHMETIC_MODULUS('', 1));
|
|
assertEqual(0, ARITHMETIC_MODULUS(' ', 1));
|
|
assertEqual(0, ARITHMETIC_MODULUS('0', 1));
|
|
assertEqual(0, ARITHMETIC_MODULUS('1', 1));
|
|
assertEqual(0, ARITHMETIC_MODULUS('a', 1));
|
|
assertEqual(0, ARITHMETIC_MODULUS([ ], 1));
|
|
assertEqual(0, ARITHMETIC_MODULUS([ 0 ], 1));
|
|
assertEqual(0, ARITHMETIC_MODULUS({ }, 1));
|
|
assertEqual(0, ARITHMETIC_MODULUS({ 'a' : 0 }, 1));
|
|
assertEqual(null, ARITHMETIC_MODULUS(1, 0));
|
|
assertEqual(null, ARITHMETIC_MODULUS(100, 0));
|
|
assertEqual(null, ARITHMETIC_MODULUS(-1, 0));
|
|
assertEqual(null, ARITHMETIC_MODULUS(-100, 0));
|
|
assertEqual(null, ARITHMETIC_MODULUS(0, 0));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test ARITHMETIC_MODULUS function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testArithmeticModulusValue: function() {
|
|
assertEqual(0, ARITHMETIC_MODULUS(0, 1));
|
|
assertEqual(0, ARITHMETIC_MODULUS(1, 1));
|
|
assertEqual(1, ARITHMETIC_MODULUS(1, 2));
|
|
assertEqual(1, ARITHMETIC_MODULUS(1, 3));
|
|
assertEqual(1, ARITHMETIC_MODULUS(1, 4));
|
|
assertEqual(0, ARITHMETIC_MODULUS(2, 2));
|
|
assertEqual(2, ARITHMETIC_MODULUS(2, 3));
|
|
assertEqual(0, ARITHMETIC_MODULUS(3, 3));
|
|
assertEqual(0, ARITHMETIC_MODULUS(10, 1));
|
|
assertEqual(0, ARITHMETIC_MODULUS(10, 2));
|
|
assertEqual(1, ARITHMETIC_MODULUS(10, 3));
|
|
assertEqual(2, ARITHMETIC_MODULUS(10, 4));
|
|
assertEqual(0, ARITHMETIC_MODULUS(10, 5));
|
|
assertEqual(4, ARITHMETIC_MODULUS(10, 6));
|
|
assertEqual(3, ARITHMETIC_MODULUS(10, 7));
|
|
assertEqual(2, ARITHMETIC_MODULUS(10, 8));
|
|
assertEqual(1, ARITHMETIC_MODULUS(10, 9));
|
|
assertEqual(0, ARITHMETIC_MODULUS(10, 10));
|
|
assertEqual(10, ARITHMETIC_MODULUS(10, 11));
|
|
assertEqual(1, ARITHMETIC_MODULUS(4, 3));
|
|
assertEqual(2, ARITHMETIC_MODULUS(5, 3));
|
|
assertEqual(0, ARITHMETIC_MODULUS(6, 3));
|
|
assertEqual(1, ARITHMETIC_MODULUS(7, 3));
|
|
assertEqual(2, ARITHMETIC_MODULUS(8, 3));
|
|
assertEqual(0, ARITHMETIC_MODULUS(9, 3));
|
|
assertEqual(1, ARITHMETIC_MODULUS(10, 3));
|
|
assertEqual(0, ARITHMETIC_MODULUS(10, -1));
|
|
assertEqual(0, ARITHMETIC_MODULUS(10, -2));
|
|
assertEqual(1, ARITHMETIC_MODULUS(10, -3));
|
|
assertEqual(2, ARITHMETIC_MODULUS(10, -4));
|
|
assertEqual(0, ARITHMETIC_MODULUS(10, -5));
|
|
assertEqual(4, ARITHMETIC_MODULUS(10, -6));
|
|
assertEqual(3, ARITHMETIC_MODULUS(10, -7));
|
|
assertEqual(2, ARITHMETIC_MODULUS(10, -8));
|
|
assertEqual(1, ARITHMETIC_MODULUS(10, -9));
|
|
assertEqual(0, ARITHMETIC_MODULUS(10, -10));
|
|
assertEqual(10, ARITHMETIC_MODULUS(10, -11));
|
|
assertEqual(-1, ARITHMETIC_MODULUS(-1, 3));
|
|
assertEqual(-2, ARITHMETIC_MODULUS(-2, 3));
|
|
assertEqual(0, ARITHMETIC_MODULUS(-3, 3));
|
|
assertEqual(-1, ARITHMETIC_MODULUS(-4, 3));
|
|
assertEqual(-2, ARITHMETIC_MODULUS(-5, 3));
|
|
assertEqual(0, ARITHMETIC_MODULUS(-6, 3));
|
|
assertEqual(-1, ARITHMETIC_MODULUS(-7, 3));
|
|
assertEqual(-2, ARITHMETIC_MODULUS(-8, 3));
|
|
assertEqual(0, ARITHMETIC_MODULUS(-9, 3));
|
|
assertEqual(-1, ARITHMETIC_MODULUS(-10, 3));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aql.CONCAT function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStringConcatValue: function() {
|
|
assertEqual('', db._query(`RETURN CONCAT('')`).toArray()[0]);
|
|
assertEqual('a', db._query(`RETURN CONCAT('a')`).toArray()[0]);
|
|
assertEqual('a', db._query(`RETURN CONCAT('a', null)`).toArray()[0]);
|
|
assertEqual('', db._query(`RETURN CONCAT('', null)`).toArray()[0]);
|
|
assertEqual('', db._query(`RETURN CONCAT('', '')`).toArray()[0]);
|
|
assertEqual(' ', db._query(`RETURN CONCAT(' ', '')`).toArray()[0]);
|
|
assertEqual(' ', db._query(`RETURN CONCAT('', ' ')`).toArray()[0]);
|
|
assertEqual(' ', db._query(`RETURN CONCAT(' ', ' ')`).toArray()[0]);
|
|
assertEqual(' a a', db._query(`RETURN CONCAT(' a', ' a')`).toArray()[0]);
|
|
assertEqual(' a a ', db._query(`RETURN CONCAT(' a', ' a ')`).toArray()[0]);
|
|
assertEqual('a', db._query(`RETURN CONCAT('a', '')`).toArray()[0]);
|
|
assertEqual('a', db._query(`RETURN CONCAT('', 'a')`).toArray()[0]);
|
|
assertEqual('a ', db._query(`RETURN CONCAT('', 'a ')`).toArray()[0]);
|
|
assertEqual('a ', db._query(`RETURN CONCAT('', 'a ')`).toArray()[0]);
|
|
assertEqual('a ', db._query(`RETURN CONCAT('a ', '')`).toArray()[0]);
|
|
assertEqual('ab', db._query(`RETURN CONCAT('a', 'b')`).toArray()[0]);
|
|
assertEqual('ba', db._query(`RETURN CONCAT('b', 'a')`).toArray()[0]);
|
|
assertEqual('AA', db._query(`RETURN CONCAT('A', 'A')`).toArray()[0]);
|
|
assertEqual('AaA', db._query(`RETURN CONCAT('A', 'aA')`).toArray()[0]);
|
|
assertEqual('AaA', db._query(`RETURN CONCAT('Aa', 'A')`).toArray()[0]);
|
|
assertEqual('0.00', db._query(`RETURN CONCAT('0.00', '')`).toArray()[0]);
|
|
assertEqual('abc', db._query(`RETURN CONCAT('a', CONCAT('b', 'c'))`).toArray()[0]);
|
|
assertEqual('', db._query(`RETURN CONCAT('', CONCAT('', ''))`).toArray()[0]);
|
|
assertEqual('fux', db._query(`RETURN CONCAT('f', 'u', 'x')`).toArray()[0]);
|
|
assertEqual('fux', db._query(`RETURN CONCAT('f', 'u', null, 'x')`).toArray()[0]);
|
|
assertEqual('fux', db._query(`RETURN CONCAT(null, 'f', null, 'u', null, 'x', null)`).toArray()[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test ranges
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRanges: function() {
|
|
assertEqual([ [ 1, 2, 3 ] ], AQL_EXECUTE("RETURN 1..3").json);
|
|
assertEqual([ [ 0, 1, 2, 3 ] ], AQL_EXECUTE("RETURN null..3").json);
|
|
assertEqual([ [ 1, 2, 3, 4, 5, 6, 7 ] ], AQL_EXECUTE("RETURN 1..3 + 4").json);
|
|
assertEqual([ [ -4, -3, -2, -1, 0, 1, 2, 3, 4, 5 ] ], AQL_EXECUTE("RETURN -1 - 3..3 + 2").json);
|
|
assertEqual([ [ 0, 1, 2, 3 ] ], AQL_EXECUTE("RETURN 1..2..3").json);
|
|
assertEqual([ [ 1, 2, 3, 4 ] ], AQL_EXECUTE("RETURN 1..1..4").json);
|
|
},
|
|
|
|
testNumberConversion: function() {
|
|
assertEqual([ [ true, 0, 0 ] ], AQL_EXECUTE('LET str = "3a" RETURN [ 0 + str == TO_NUMBER(str), 0 + str, TO_NUMBER(str) ]').json);
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief executes the test suite
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
jsunity.run(ahuacatlOperatorsTestSuite);
|
|
|
|
return jsunity.done();
|
|
|