/*jshint globalstrict:false, strict:false, maxlen: 500 */
/*global assertEqual */

////////////////////////////////////////////////////////////////////////////////
/// @brief tests for query language, range optimizations
///
/// @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 helper = require("@arangodb/aql-helper");
var getQueryResults = helper.getQueryResults;

////////////////////////////////////////////////////////////////////////////////
/// @brief test suite
////////////////////////////////////////////////////////////////////////////////

function ahuacatlRangesTestSuite () {

  return {

////////////////////////////////////////////////////////////////////////////////
/// @brief test merging of IN
////////////////////////////////////////////////////////////////////////////////

    testInListAnd1 : function () {
      var expected = [ 1, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i IN [ 1, 3, 5 ] && i IN [ 2, 3, 4, 1 ] RETURN i");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test merging of IN
////////////////////////////////////////////////////////////////////////////////

    testInListAnd2 : function () {
      var expected = [ ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i IN [ 1, 3, 5 ] && i IN [ 2, 4, 6, 8 ] RETURN i");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test merging of IN
////////////////////////////////////////////////////////////////////////////////

    testInListOr1 : function () {
      var expected = [ 1, 2, 3, 4, 5 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i IN [ 1, 3, 5 ] || i IN [ 2, 3, 4, 1 ] RETURN i");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test merging of IN
////////////////////////////////////////////////////////////////////////////////

    testInListOr2 : function () {
      var expected = [ 1, 2, 6, 9 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i IN [ 1, 2 ] || i IN [ 9, 6 ] RETURN i");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, ==
////////////////////////////////////////////////////////////////////////////////

    testEqEqAnd1 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 && i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, ==
////////////////////////////////////////////////////////////////////////////////

    testEqEqAnd2 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 && i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, ==
////////////////////////////////////////////////////////////////////////////////

    testEqEqAnd3 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 && i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, ==
////////////////////////////////////////////////////////////////////////////////

    testEqEqAnd4 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 && i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, ==
////////////////////////////////////////////////////////////////////////////////

    testEqEqAnd5 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 && i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, ==
////////////////////////////////////////////////////////////////////////////////

    testEqEqAnd6 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 && i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, ==
////////////////////////////////////////////////////////////////////////////////

    testEqEqAnd7 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 && i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, ==
////////////////////////////////////////////////////////////////////////////////

    testEqEqAnd8 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 && i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, ==
////////////////////////////////////////////////////////////////////////////////

    testEqEqAnd9 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 && i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, ==
////////////////////////////////////////////////////////////////////////////////

    testEqEqOr1 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 || i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, ==
////////////////////////////////////////////////////////////////////////////////

    testEqEqOr2 : function () {
      var expected = [ 1, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 || i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, ==
////////////////////////////////////////////////////////////////////////////////

    testEqEqOr3 : function () {
      var expected = [ 1, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 || i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, ==
////////////////////////////////////////////////////////////////////////////////

    testEqEqOr4 : function () {
      var expected = [ 1, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 || i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, ==
////////////////////////////////////////////////////////////////////////////////

    testEqEqOr5 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 || i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, ==
////////////////////////////////////////////////////////////////////////////////

    testEqEqOr6 : function () {
      var expected = [ 4, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 || i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, ==
////////////////////////////////////////////////////////////////////////////////

    testEqEqOr7 : function () {
      var expected = [ 1, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 || i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, ==
////////////////////////////////////////////////////////////////////////////////

    testEqEqOr8 : function () {
      var expected = [ 4, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 || i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, ==
////////////////////////////////////////////////////////////////////////////////

    testEqEqOr9 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 || i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, !=
////////////////////////////////////////////////////////////////////////////////

    testEqNeAnd1 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 && i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, !=
////////////////////////////////////////////////////////////////////////////////

    testEqNeAnd2 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 && i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, !=
////////////////////////////////////////////////////////////////////////////////

    testEqNeAnd3 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 && i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, !=
////////////////////////////////////////////////////////////////////////////////

    testEqNeAnd4 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 && i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, !=
////////////////////////////////////////////////////////////////////////////////

    testEqNeAnd5 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 && i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, !=
////////////////////////////////////////////////////////////////////////////////

    testEqNeAnd6 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 && i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, !=
////////////////////////////////////////////////////////////////////////////////

    testEqNeAnd7 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 && i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, !=
////////////////////////////////////////////////////////////////////////////////

    testEqNeAnd8 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 && i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, !=
////////////////////////////////////////////////////////////////////////////////

    testEqNeAnd9 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 && i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, !=
////////////////////////////////////////////////////////////////////////////////

    testEqNeOr1 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 || i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, !=
////////////////////////////////////////////////////////////////////////////////

    testEqNeOr2 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 || i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, !=
////////////////////////////////////////////////////////////////////////////////

    testEqNeOr3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 || i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, !=
////////////////////////////////////////////////////////////////////////////////

    testEqNeOr4 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 || i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, !=
////////////////////////////////////////////////////////////////////////////////

    testEqNeOr5 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 || i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, !=
////////////////////////////////////////////////////////////////////////////////

    testEqNeOr6 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 || i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, !=
////////////////////////////////////////////////////////////////////////////////

    testEqNeOr7 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 || i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, !=
////////////////////////////////////////////////////////////////////////////////

    testEqNeOr8 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 || i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, !=
////////////////////////////////////////////////////////////////////////////////

    testEqNeOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 || i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, >
////////////////////////////////////////////////////////////////////////////////

    testEqGtAnd1 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 && i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, >
////////////////////////////////////////////////////////////////////////////////

    testEqGtAnd2 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 && i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, >
////////////////////////////////////////////////////////////////////////////////

    testEqGtAnd3 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 && i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, >
////////////////////////////////////////////////////////////////////////////////

    testEqGtAnd4 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 && i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, >
////////////////////////////////////////////////////////////////////////////////

    testEqGtAnd5 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 && i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, >
////////////////////////////////////////////////////////////////////////////////

    testEqGtAnd6 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 && i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, >
////////////////////////////////////////////////////////////////////////////////

    testEqGtAnd7 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 && i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, >
////////////////////////////////////////////////////////////////////////////////

    testEqGtAnd8 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 && i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, >
////////////////////////////////////////////////////////////////////////////////

    testEqGtAnd9 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 && i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, >
////////////////////////////////////////////////////////////////////////////////

    testEqGtOr1 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 || i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, >
////////////////////////////////////////////////////////////////////////////////

    testEqGtOr2 : function () {
      var expected = [ 1, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 || i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, >
////////////////////////////////////////////////////////////////////////////////

    testEqGtOr3 : function () {
      var expected = [ 1, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 || i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, >
////////////////////////////////////////////////////////////////////////////////

    testEqGtOr4 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 || i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, >
////////////////////////////////////////////////////////////////////////////////

    testEqGtOr5 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 || i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, >
////////////////////////////////////////////////////////////////////////////////

    testEqGtOr6 : function () {
      var expected = [ 4, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 || i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, >
////////////////////////////////////////////////////////////////////////////////

    testEqGtOr7 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 || i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, >
////////////////////////////////////////////////////////////////////////////////

    testEqGtOr8 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 || i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, >
////////////////////////////////////////////////////////////////////////////////

    testEqGtOr9 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 || i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, >=
////////////////////////////////////////////////////////////////////////////////

    testEqGeAnd1 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 && i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, >=
////////////////////////////////////////////////////////////////////////////////

    testEqGeAnd2 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 && i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, >=
////////////////////////////////////////////////////////////////////////////////

    testEqGeAnd3 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 && i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, >=
////////////////////////////////////////////////////////////////////////////////

    testEqGeAnd4 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 && i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, >=
////////////////////////////////////////////////////////////////////////////////

    testEqGeAnd5 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 && i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, >=
////////////////////////////////////////////////////////////////////////////////

    testEqGeAnd6 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 && i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, >=
////////////////////////////////////////////////////////////////////////////////

    testEqGeAnd7 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 && i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, >=
////////////////////////////////////////////////////////////////////////////////

    testEqGeAnd8 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 && i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, >=
////////////////////////////////////////////////////////////////////////////////

    testEqGeAnd9 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 && i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, >=
////////////////////////////////////////////////////////////////////////////////

    testEqGeOr1 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 || i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, >=
////////////////////////////////////////////////////////////////////////////////

    testEqGeOr2 : function () {
      var expected = [ 1, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 || i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, >=
////////////////////////////////////////////////////////////////////////////////

    testEqGeOr3 : function () {
      var expected = [ 1, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 || i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, >=
////////////////////////////////////////////////////////////////////////////////

    testEqGeOr4 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 || i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, >=
////////////////////////////////////////////////////////////////////////////////

    testEqGeOr5 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 || i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, >=
////////////////////////////////////////////////////////////////////////////////

    testEqGeOr6 : function () {
      var expected = [ 4, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 || i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, >=
////////////////////////////////////////////////////////////////////////////////

    testEqGeOr7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 || i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, >=
////////////////////////////////////////////////////////////////////////////////

    testEqGeOr8 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 || i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, >=
////////////////////////////////////////////////////////////////////////////////

    testEqGeOr9 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 || i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, <
////////////////////////////////////////////////////////////////////////////////

    testEqLtAnd1 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 && i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, <
////////////////////////////////////////////////////////////////////////////////

    testEqLtAnd2 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 && i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, <
////////////////////////////////////////////////////////////////////////////////

    testEqLtAnd3 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 && i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, <
////////////////////////////////////////////////////////////////////////////////

    testEqLtAnd4 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 && i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, <
////////////////////////////////////////////////////////////////////////////////

    testEqLtAnd5 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 && i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, <
////////////////////////////////////////////////////////////////////////////////

    testEqLtAnd6 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 && i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, <
////////////////////////////////////////////////////////////////////////////////

    testEqLtAnd7 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 && i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, <
////////////////////////////////////////////////////////////////////////////////

    testEqLtAnd8 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 && i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, <
////////////////////////////////////////////////////////////////////////////////

    testEqLtAnd9 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 && i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, <
////////////////////////////////////////////////////////////////////////////////

    testEqLtOr1 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 || i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, <
////////////////////////////////////////////////////////////////////////////////

    testEqLtOr2 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 || i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, <
////////////////////////////////////////////////////////////////////////////////

    testEqLtOr3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 || i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, <
////////////////////////////////////////////////////////////////////////////////

    testEqLtOr4 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 || i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, <
////////////////////////////////////////////////////////////////////////////////

    testEqLtOr5 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 || i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, <
////////////////////////////////////////////////////////////////////////////////

    testEqLtOr6 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 || i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, <
////////////////////////////////////////////////////////////////////////////////

    testEqLtOr7 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 || i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, <
////////////////////////////////////////////////////////////////////////////////

    testEqLtOr8 : function () {
      var expected = [ 1, 2, 3, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 || i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, <
////////////////////////////////////////////////////////////////////////////////

    testEqLtOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 || i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, <=
////////////////////////////////////////////////////////////////////////////////

    testEqLeAnd1 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 && i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, <=
////////////////////////////////////////////////////////////////////////////////

    testEqLeAnd2 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 && i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, <=
////////////////////////////////////////////////////////////////////////////////

    testEqLeAnd3 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 && i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, <=
////////////////////////////////////////////////////////////////////////////////

    testEqLeAnd4 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 && i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, <=
////////////////////////////////////////////////////////////////////////////////

    testEqLeAnd5 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 && i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, <=
////////////////////////////////////////////////////////////////////////////////

    testEqLeAnd6 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 && i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, <=
////////////////////////////////////////////////////////////////////////////////

    testEqLeAnd7 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 && i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, <=
////////////////////////////////////////////////////////////////////////////////

    testEqLeAnd8 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 && i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of ==, <=
////////////////////////////////////////////////////////////////////////////////

    testEqLeAnd9 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 && i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, <=
////////////////////////////////////////////////////////////////////////////////

    testEqLeOr1 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 || i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, <=
////////////////////////////////////////////////////////////////////////////////

    testEqLeOr2 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 || i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, <=
////////////////////////////////////////////////////////////////////////////////

    testEqLeOr3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 1 || i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, <=
////////////////////////////////////////////////////////////////////////////////

    testEqLeOr4 : function () {
      var expected = [ 1, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 || i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, <=
////////////////////////////////////////////////////////////////////////////////

    testEqLeOr5 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 || i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, <=
////////////////////////////////////////////////////////////////////////////////

    testEqLeOr6 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 4 || i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, <=
////////////////////////////////////////////////////////////////////////////////

    testEqLeOr7 : function () {
      var expected = [ 1, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 || i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, <=
////////////////////////////////////////////////////////////////////////////////

    testEqLeOr8 : function () {
      var expected = [ 1, 2, 3, 4, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 || i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of ==, <=
////////////////////////////////////////////////////////////////////////////////

    testEqLeOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i == 8 || i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, ==
////////////////////////////////////////////////////////////////////////////////

    testNeEqAnd1 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 && i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, ==
////////////////////////////////////////////////////////////////////////////////

    testNeEqAnd2 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 && i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, ==
////////////////////////////////////////////////////////////////////////////////

    testNeEqAnd3 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 && i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, ==
////////////////////////////////////////////////////////////////////////////////

    testNeEqAnd4 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 && i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, ==
////////////////////////////////////////////////////////////////////////////////

    testNeEqAnd5 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 && i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, ==
////////////////////////////////////////////////////////////////////////////////

    testNeEqAnd6 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 && i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, ==
////////////////////////////////////////////////////////////////////////////////

    testNeEqAnd7 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 && i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, ==
////////////////////////////////////////////////////////////////////////////////

    testNeEqAnd8 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 && i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, ==
////////////////////////////////////////////////////////////////////////////////

    testNeEqAnd9 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 && i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, ==
////////////////////////////////////////////////////////////////////////////////

    testNeEqOr1 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 || i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, ==
////////////////////////////////////////////////////////////////////////////////

    testNeEqOr2 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 || i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, ==
////////////////////////////////////////////////////////////////////////////////

    testNeEqOr3 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 || i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, ==
////////////////////////////////////////////////////////////////////////////////

    testNeEqOr4 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 || i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, ==
////////////////////////////////////////////////////////////////////////////////

    testNeEqOr5 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 || i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, ==
////////////////////////////////////////////////////////////////////////////////

    testNeEqOr6 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 || i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, ==
////////////////////////////////////////////////////////////////////////////////

    testNeEqOr7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 || i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, ==
////////////////////////////////////////////////////////////////////////////////

    testNeEqOr8 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 || i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, ==
////////////////////////////////////////////////////////////////////////////////

    testNeEqOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 || i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, !=
////////////////////////////////////////////////////////////////////////////////

    testNeNeAnd1 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 && i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, !=
////////////////////////////////////////////////////////////////////////////////

    testNeNeAnd2 : function () {
      var expected = [ 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 && i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, !=
////////////////////////////////////////////////////////////////////////////////

    testNeNeAnd3 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 && i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, !=
////////////////////////////////////////////////////////////////////////////////

    testNeNeAnd4 : function () {
      var expected = [ 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 && i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, !=
////////////////////////////////////////////////////////////////////////////////

    testNeNeAnd5 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 && i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, !=
////////////////////////////////////////////////////////////////////////////////

    testNeNeAnd6 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 && i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, !=
////////////////////////////////////////////////////////////////////////////////

    testNeNeAnd7 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 && i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, !=
////////////////////////////////////////////////////////////////////////////////

    testNeNeAnd8 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 && i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, !=
////////////////////////////////////////////////////////////////////////////////

    testNeNeAnd9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 && i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, !=
////////////////////////////////////////////////////////////////////////////////

    testNeNeOr1 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 || i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, !=
////////////////////////////////////////////////////////////////////////////////

    testNeNeOr2 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 || i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, !=
////////////////////////////////////////////////////////////////////////////////

    testNeNeOr3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 || i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, !=
////////////////////////////////////////////////////////////////////////////////

    testNeNeOr4 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 || i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, !=
////////////////////////////////////////////////////////////////////////////////

    testNeNeOr5 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 || i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, !=
////////////////////////////////////////////////////////////////////////////////

    testNeNeOr6 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 || i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, !=
////////////////////////////////////////////////////////////////////////////////

    testNeNeOr7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 || i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, !=
////////////////////////////////////////////////////////////////////////////////

    testNeNeOr8 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 || i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, !=
////////////////////////////////////////////////////////////////////////////////

    testNeNeOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 || i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, >
////////////////////////////////////////////////////////////////////////////////

    testNeGtAnd1 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 && i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, >
////////////////////////////////////////////////////////////////////////////////

    testNeGtAnd2 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 && i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, >
////////////////////////////////////////////////////////////////////////////////

    testNeGtAnd3 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 && i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, >
////////////////////////////////////////////////////////////////////////////////

    testNeGtAnd4 : function () {
      var expected = [ 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 && i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, >
////////////////////////////////////////////////////////////////////////////////

    testNeGtAnd5 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 && i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, >
////////////////////////////////////////////////////////////////////////////////

    testNeGtAnd6 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 && i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, >
////////////////////////////////////////////////////////////////////////////////

    testNeGtAnd7 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 && i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, >
////////////////////////////////////////////////////////////////////////////////

    testNeGtAnd8 : function () {
      var expected = [ 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 && i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, >
////////////////////////////////////////////////////////////////////////////////

    testNeGtAnd9 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 && i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, >
////////////////////////////////////////////////////////////////////////////////

    testNeGtOr1 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 || i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, >
////////////////////////////////////////////////////////////////////////////////

    testNeGtOr2 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 || i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, >
////////////////////////////////////////////////////////////////////////////////

    testNeGtOr3 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 || i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, >
////////////////////////////////////////////////////////////////////////////////

    testNeGtOr4 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 || i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, >
////////////////////////////////////////////////////////////////////////////////

    testNeGtOr5 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 || i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, >
////////////////////////////////////////////////////////////////////////////////

    testNeGtOr6 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 || i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, >
////////////////////////////////////////////////////////////////////////////////

    testNeGtOr7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 || i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, >
////////////////////////////////////////////////////////////////////////////////

    testNeGtOr8 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 || i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, >
////////////////////////////////////////////////////////////////////////////////

    testNeGtOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 || i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, >=
////////////////////////////////////////////////////////////////////////////////

    testNeGeAnd1 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 && i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, >=
////////////////////////////////////////////////////////////////////////////////

    testNeGeAnd2 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 && i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, >=
////////////////////////////////////////////////////////////////////////////////

    testNeGeAnd3 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 && i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, >=
////////////////////////////////////////////////////////////////////////////////

    testNeGeAnd4 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 && i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, >=
////////////////////////////////////////////////////////////////////////////////

    testNeGeAnd5 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 && i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, >=
////////////////////////////////////////////////////////////////////////////////

    testNeGeAnd6 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 && i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, >=
////////////////////////////////////////////////////////////////////////////////

    testNeGeAnd7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 && i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, >=
////////////////////////////////////////////////////////////////////////////////

    testNeGeAnd8 : function () {
      var expected = [ 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 && i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, >=
////////////////////////////////////////////////////////////////////////////////

    testNeGeAnd9 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 && i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, >=
////////////////////////////////////////////////////////////////////////////////

    testNeGeOr1 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 || i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, >=
////////////////////////////////////////////////////////////////////////////////

    testNeGeOr2 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 || i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, >=
////////////////////////////////////////////////////////////////////////////////

    testNeGeOr3 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 || i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, >=
////////////////////////////////////////////////////////////////////////////////

    testNeGeOr4 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 || i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, >=
////////////////////////////////////////////////////////////////////////////////

    testNeGeOr5 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 || i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, >=
////////////////////////////////////////////////////////////////////////////////

    testNeGeOr6 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 || i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, >=
////////////////////////////////////////////////////////////////////////////////

    testNeGeOr7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 || i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, >=
////////////////////////////////////////////////////////////////////////////////

    testNeGeOr8 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 || i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, >=
////////////////////////////////////////////////////////////////////////////////

    testNeGeOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 || i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, <
////////////////////////////////////////////////////////////////////////////////

    testNeLtAnd1 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 && i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, <
////////////////////////////////////////////////////////////////////////////////

    testNeLtAnd2 : function () {
      var expected = [ 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 && i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, <
////////////////////////////////////////////////////////////////////////////////

    testNeLtAnd3 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 && i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, <
////////////////////////////////////////////////////////////////////////////////

    testNeLtAnd4 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 && i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, <
////////////////////////////////////////////////////////////////////////////////

    testNeLtAnd5 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 && i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, <
////////////////////////////////////////////////////////////////////////////////

    testNeLtAnd6 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 && i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, <
////////////////////////////////////////////////////////////////////////////////

    testNeLtAnd7 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 && i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, <
////////////////////////////////////////////////////////////////////////////////

    testNeLtAnd8 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 && i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, <
////////////////////////////////////////////////////////////////////////////////

    testNeLtAnd9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 && i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, <
////////////////////////////////////////////////////////////////////////////////

    testNeLtOr1 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 || i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, <
////////////////////////////////////////////////////////////////////////////////

    testNeLtOr2 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 || i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, <
////////////////////////////////////////////////////////////////////////////////

    testNeLtOr3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 || i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, <
////////////////////////////////////////////////////////////////////////////////

    testNeLtOr4 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 || i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, <
////////////////////////////////////////////////////////////////////////////////

    testNeLtOr5 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 || i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, <
////////////////////////////////////////////////////////////////////////////////

    testNeLtOr6 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 || i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, <
////////////////////////////////////////////////////////////////////////////////

    testNeLtOr7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 || i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, <
////////////////////////////////////////////////////////////////////////////////

    testNeLtOr8 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 || i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, <
////////////////////////////////////////////////////////////////////////////////

    testNeLtOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 || i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, <=
////////////////////////////////////////////////////////////////////////////////

    testNeLeAnd1 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 && i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, <=
////////////////////////////////////////////////////////////////////////////////

    testNeLeAnd2 : function () {
      var expected = [ 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 && i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, <=
////////////////////////////////////////////////////////////////////////////////

    testNeLeAnd3 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 && i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, <=
////////////////////////////////////////////////////////////////////////////////

    testNeLeAnd4 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 && i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, <=
////////////////////////////////////////////////////////////////////////////////

    testNeLeAnd5 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 && i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, <=
////////////////////////////////////////////////////////////////////////////////

    testNeLeAnd6 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 && i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, <=
////////////////////////////////////////////////////////////////////////////////

    testNeLeAnd7 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 && i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, <=
////////////////////////////////////////////////////////////////////////////////

    testNeLeAnd8 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 && i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of !=, <=
////////////////////////////////////////////////////////////////////////////////

    testNeLeAnd9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 && i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, <=
////////////////////////////////////////////////////////////////////////////////

    testNeLeOr1 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 || i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, <=
////////////////////////////////////////////////////////////////////////////////

    testNeLeOr2 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 || i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, <=
////////////////////////////////////////////////////////////////////////////////

    testNeLeOr3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 1 || i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, <=
////////////////////////////////////////////////////////////////////////////////

    testNeLeOr4 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 || i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, <=
////////////////////////////////////////////////////////////////////////////////

    testNeLeOr5 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 || i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, <=
////////////////////////////////////////////////////////////////////////////////

    testNeLeOr6 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 4 || i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, <=
////////////////////////////////////////////////////////////////////////////////

    testNeLeOr7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 || i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, <=
////////////////////////////////////////////////////////////////////////////////

    testNeLeOr8 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 || i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of !=, <=
////////////////////////////////////////////////////////////////////////////////

    testNeLeOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i != 8 || i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, ==
////////////////////////////////////////////////////////////////////////////////

    testGtEqAnd1 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 && i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, ==
////////////////////////////////////////////////////////////////////////////////

    testGtEqAnd2 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 && i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, ==
////////////////////////////////////////////////////////////////////////////////

    testGtEqAnd3 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 && i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, ==
////////////////////////////////////////////////////////////////////////////////

    testGtEqAnd4 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 && i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, ==
////////////////////////////////////////////////////////////////////////////////

    testGtEqAnd5 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 && i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, ==
////////////////////////////////////////////////////////////////////////////////

    testGtEqAnd6 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 && i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, ==
////////////////////////////////////////////////////////////////////////////////

    testGtEqAnd7 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 && i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, ==
////////////////////////////////////////////////////////////////////////////////

    testGtEqAnd8 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 && i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, ==
////////////////////////////////////////////////////////////////////////////////

    testGtEqAnd9 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 && i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, ==
////////////////////////////////////////////////////////////////////////////////

    testGtEqOr1 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 || i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, ==
////////////////////////////////////////////////////////////////////////////////

    testGtEqOr2 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 || i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, ==
////////////////////////////////////////////////////////////////////////////////

    testGtEqOr3 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 || i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, ==
////////////////////////////////////////////////////////////////////////////////

    testGtEqOr4 : function () {
      var expected = [ 1, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 || i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, ==
////////////////////////////////////////////////////////////////////////////////

    testGtEqOr5 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 || i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, ==
////////////////////////////////////////////////////////////////////////////////

    testGtEqOr6 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 || i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, ==
////////////////////////////////////////////////////////////////////////////////

    testGtEqOr7 : function () {
      var expected = [ 1, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 || i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, ==
////////////////////////////////////////////////////////////////////////////////

    testGtEqOr8 : function () {
      var expected = [ 4, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 || i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, ==
////////////////////////////////////////////////////////////////////////////////

    testGtEqOr9 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 || i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, !=
////////////////////////////////////////////////////////////////////////////////

    testGtNeAnd1 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 && i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, !=
////////////////////////////////////////////////////////////////////////////////

    testGtNeAnd2 : function () {
      var expected = [ 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 && i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, !=
////////////////////////////////////////////////////////////////////////////////

    testGtNeAnd3 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 && i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, !=
////////////////////////////////////////////////////////////////////////////////

    testGtNeAnd4 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 && i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, !=
////////////////////////////////////////////////////////////////////////////////

    testGtNeAnd5 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 && i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, !=
////////////////////////////////////////////////////////////////////////////////

    testGtNeAnd6 : function () {
      var expected = [ 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 && i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, !=
////////////////////////////////////////////////////////////////////////////////

    testGtNeAnd7 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 && i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, !=
////////////////////////////////////////////////////////////////////////////////

    testGtNeAnd8 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 && i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, !=
////////////////////////////////////////////////////////////////////////////////

    testGtNeAnd9 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 && i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, !=
////////////////////////////////////////////////////////////////////////////////

    testGtNeOr1 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 || i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, !=
////////////////////////////////////////////////////////////////////////////////

    testGtNeOr2 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 || i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, !=
////////////////////////////////////////////////////////////////////////////////

    testGtNeOr3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 || i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, !=
////////////////////////////////////////////////////////////////////////////////

    testGtNeOr4 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 || i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, !=
////////////////////////////////////////////////////////////////////////////////

    testGtNeOr5 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 || i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, !=
////////////////////////////////////////////////////////////////////////////////

    testGtNeOr6 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 || i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, !=
////////////////////////////////////////////////////////////////////////////////

    testGtNeOr7 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 || i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, !=
////////////////////////////////////////////////////////////////////////////////

    testGtNeOr8 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 || i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, !=
////////////////////////////////////////////////////////////////////////////////

    testGtNeOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 || i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, >
////////////////////////////////////////////////////////////////////////////////

    testGtGtAnd1 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 && i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, >
////////////////////////////////////////////////////////////////////////////////

    testGtGtAnd2 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 && i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, >
////////////////////////////////////////////////////////////////////////////////

    testGtGtAnd3 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 && i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, >
////////////////////////////////////////////////////////////////////////////////

    testGtGtAnd4 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 && i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, >
////////////////////////////////////////////////////////////////////////////////

    testGtGtAnd5 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 && i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, >
////////////////////////////////////////////////////////////////////////////////

    testGtGtAnd6 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 && i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, >
////////////////////////////////////////////////////////////////////////////////

    testGtGtAnd7 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 && i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, >
////////////////////////////////////////////////////////////////////////////////

    testGtGtAnd8 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 && i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, >
////////////////////////////////////////////////////////////////////////////////

    testGtGtAnd9 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 && i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, >
////////////////////////////////////////////////////////////////////////////////

    testGtGtOr1 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 || i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, >
////////////////////////////////////////////////////////////////////////////////

    testGtGtOr2 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 || i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, >
////////////////////////////////////////////////////////////////////////////////

    testGtGtOr3 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 || i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, >
////////////////////////////////////////////////////////////////////////////////

    testGtGtOr4 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 || i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, >
////////////////////////////////////////////////////////////////////////////////

    testGtGtOr5 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 || i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, >
////////////////////////////////////////////////////////////////////////////////

    testGtGtOr6 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 || i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, >
////////////////////////////////////////////////////////////////////////////////

    testGtGtOr7 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 || i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, >
////////////////////////////////////////////////////////////////////////////////

    testGtGtOr8 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 || i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, >
////////////////////////////////////////////////////////////////////////////////

    testGtGtOr9 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 || i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, >=
////////////////////////////////////////////////////////////////////////////////

    testGtGeAnd1 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 && i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, >=
////////////////////////////////////////////////////////////////////////////////

    testGtGeAnd2 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 && i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, >=
////////////////////////////////////////////////////////////////////////////////

    testGtGeAnd3 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 && i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, >=
////////////////////////////////////////////////////////////////////////////////

    testGtGeAnd4 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 && i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, >=
////////////////////////////////////////////////////////////////////////////////

    testGtGeAnd5 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 && i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, >=
////////////////////////////////////////////////////////////////////////////////

    testGtGeAnd6 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 && i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, >=
////////////////////////////////////////////////////////////////////////////////

    testGtGeAnd7 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 && i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, >=
////////////////////////////////////////////////////////////////////////////////

    testGtGeAnd8 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 && i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, >=
////////////////////////////////////////////////////////////////////////////////

    testGtGeAnd9 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 && i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, >=
////////////////////////////////////////////////////////////////////////////////

    testGtGeOr1 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 || i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, >=
////////////////////////////////////////////////////////////////////////////////

    testGtGeOr2 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 || i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, >=
////////////////////////////////////////////////////////////////////////////////

    testGtGeOr3 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 || i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, >=
////////////////////////////////////////////////////////////////////////////////

    testGtGeOr4 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 || i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, >=
////////////////////////////////////////////////////////////////////////////////

    testGtGeOr5 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 || i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, >=
////////////////////////////////////////////////////////////////////////////////

    testGtGeOr6 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 || i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, >=
////////////////////////////////////////////////////////////////////////////////

    testGtGeOr7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 || i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, >=
////////////////////////////////////////////////////////////////////////////////

    testGtGeOr8 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 || i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, >=
////////////////////////////////////////////////////////////////////////////////

    testGtGeOr9 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 || i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, <
////////////////////////////////////////////////////////////////////////////////

    testGtLtAnd1 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 && i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, <
////////////////////////////////////////////////////////////////////////////////

    testGtLtAnd2 : function () {
      var expected = [ 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 && i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, <
////////////////////////////////////////////////////////////////////////////////

    testGtLtAnd3 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 && i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, <
////////////////////////////////////////////////////////////////////////////////

    testGtLtAnd4 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 && i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, <
////////////////////////////////////////////////////////////////////////////////

    testGtLtAnd5 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 && i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, <
////////////////////////////////////////////////////////////////////////////////

    testGtLtAnd6 : function () {
      var expected = [ 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 && i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, <
////////////////////////////////////////////////////////////////////////////////

    testGtLtAnd7 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 && i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, <
////////////////////////////////////////////////////////////////////////////////

    testGtLtAnd8 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 && i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, <
////////////////////////////////////////////////////////////////////////////////

    testGtLtAnd9 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 && i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, <
////////////////////////////////////////////////////////////////////////////////

    testGtLtOr1 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 || i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, <
////////////////////////////////////////////////////////////////////////////////

    testGtLtOr2 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 || i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, <
////////////////////////////////////////////////////////////////////////////////

    testGtLtOr3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 || i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, <
////////////////////////////////////////////////////////////////////////////////

    testGtLtOr4 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 || i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, <
////////////////////////////////////////////////////////////////////////////////

    testGtLtOr5 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 || i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, <
////////////////////////////////////////////////////////////////////////////////

    testGtLtOr6 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 || i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, <
////////////////////////////////////////////////////////////////////////////////

    testGtLtOr7 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 || i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, <
////////////////////////////////////////////////////////////////////////////////

    testGtLtOr8 : function () {
      var expected = [ 1, 2, 3, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 || i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, <
////////////////////////////////////////////////////////////////////////////////

    testGtLtOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 || i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, <=
////////////////////////////////////////////////////////////////////////////////

    testGtLeAnd1 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 && i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, <=
////////////////////////////////////////////////////////////////////////////////

    testGtLeAnd2 : function () {
      var expected = [ 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 && i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, <=
////////////////////////////////////////////////////////////////////////////////

    testGtLeAnd3 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 && i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, <=
////////////////////////////////////////////////////////////////////////////////

    testGtLeAnd4 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 && i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, <=
////////////////////////////////////////////////////////////////////////////////

    testGtLeAnd5 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 && i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, <=
////////////////////////////////////////////////////////////////////////////////

    testGtLeAnd6 : function () {
      var expected = [ 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 && i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, <=
////////////////////////////////////////////////////////////////////////////////

    testGtLeAnd7 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 && i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, <=
////////////////////////////////////////////////////////////////////////////////

    testGtLeAnd8 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 && i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >, <=
////////////////////////////////////////////////////////////////////////////////

    testGtLeAnd9 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 && i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, <=
////////////////////////////////////////////////////////////////////////////////

    testGtLeOr1 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 || i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, <=
////////////////////////////////////////////////////////////////////////////////

    testGtLeOr2 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 || i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, <=
////////////////////////////////////////////////////////////////////////////////

    testGtLeOr3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 1 || i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, <=
////////////////////////////////////////////////////////////////////////////////

    testGtLeOr4 : function () {
      var expected = [ 1, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 || i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, <=
////////////////////////////////////////////////////////////////////////////////

    testGtLeOr5 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 || i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, <=
////////////////////////////////////////////////////////////////////////////////

    testGtLeOr6 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 4 || i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, <=
////////////////////////////////////////////////////////////////////////////////

    testGtLeOr7 : function () {
      var expected = [ 1, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 || i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, <=
////////////////////////////////////////////////////////////////////////////////

    testGtLeOr8 : function () {
      var expected = [ 1, 2, 3, 4, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 || i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >, <=
////////////////////////////////////////////////////////////////////////////////

    testGtLeOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i > 8 || i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, ==
////////////////////////////////////////////////////////////////////////////////

    testGeEqAnd1 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 && i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, ==
////////////////////////////////////////////////////////////////////////////////

    testGeEqAnd2 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 && i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, ==
////////////////////////////////////////////////////////////////////////////////

    testGeEqAnd3 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 && i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, ==
////////////////////////////////////////////////////////////////////////////////

    testGeEqAnd4 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 && i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, ==
////////////////////////////////////////////////////////////////////////////////

    testGeEqAnd5 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 && i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, ==
////////////////////////////////////////////////////////////////////////////////

    testGeEqAnd6 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 && i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, ==
////////////////////////////////////////////////////////////////////////////////

    testGeEqAnd7 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 && i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, ==
////////////////////////////////////////////////////////////////////////////////

    testGeEqAnd8 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 && i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, ==
////////////////////////////////////////////////////////////////////////////////

    testGeEqAnd9 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 && i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, ==
////////////////////////////////////////////////////////////////////////////////

    testGeEqOr1 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 || i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, ==
////////////////////////////////////////////////////////////////////////////////

    testGeEqOr2 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 || i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, ==
////////////////////////////////////////////////////////////////////////////////

    testGeEqOr3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 || i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, ==
////////////////////////////////////////////////////////////////////////////////

    testGeEqOr4 : function () {
      var expected = [ 1, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 || i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, ==
////////////////////////////////////////////////////////////////////////////////

    testGeEqOr5 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 || i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, ==
////////////////////////////////////////////////////////////////////////////////

    testGeEqOr6 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 || i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, ==
////////////////////////////////////////////////////////////////////////////////

    testGeEqOr7 : function () {
      var expected = [ 1, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 || i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, ==
////////////////////////////////////////////////////////////////////////////////

    testGeEqOr8 : function () {
      var expected = [ 4, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 || i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, ==
////////////////////////////////////////////////////////////////////////////////

    testGeEqOr9 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 || i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, !=
////////////////////////////////////////////////////////////////////////////////

    testGeNeAnd1 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 && i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, !=
////////////////////////////////////////////////////////////////////////////////

    testGeNeAnd2 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 && i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, !=
////////////////////////////////////////////////////////////////////////////////

    testGeNeAnd3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 && i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, !=
////////////////////////////////////////////////////////////////////////////////

    testGeNeAnd4 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 && i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, !=
////////////////////////////////////////////////////////////////////////////////

    testGeNeAnd5 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 && i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, !=
////////////////////////////////////////////////////////////////////////////////

    testGeNeAnd6 : function () {
      var expected = [ 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 && i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, !=
////////////////////////////////////////////////////////////////////////////////

    testGeNeAnd7 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 && i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, !=
////////////////////////////////////////////////////////////////////////////////

    testGeNeAnd8 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 && i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, !=
////////////////////////////////////////////////////////////////////////////////

    testGeNeAnd9 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 && i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, !=
////////////////////////////////////////////////////////////////////////////////

    testGeNeOr1 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 || i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, !=
////////////////////////////////////////////////////////////////////////////////

    testGeNeOr2 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 || i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, !=
////////////////////////////////////////////////////////////////////////////////

    testGeNeOr3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 || i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, !=
////////////////////////////////////////////////////////////////////////////////

    testGeNeOr4 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 || i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, !=
////////////////////////////////////////////////////////////////////////////////

    testGeNeOr5 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 || i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, !=
////////////////////////////////////////////////////////////////////////////////

    testGeNeOr6 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 || i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, !=
////////////////////////////////////////////////////////////////////////////////

    testGeNeOr7 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 || i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, !=
////////////////////////////////////////////////////////////////////////////////

    testGeNeOr8 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 || i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, !=
////////////////////////////////////////////////////////////////////////////////

    testGeNeOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 || i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, >
////////////////////////////////////////////////////////////////////////////////

    testGeGtAnd1 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 && i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, >
////////////////////////////////////////////////////////////////////////////////

    testGeGtAnd2 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 && i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, >
////////////////////////////////////////////////////////////////////////////////

    testGeGtAnd3 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 && i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, >
////////////////////////////////////////////////////////////////////////////////

    testGeGtAnd4 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 && i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, >
////////////////////////////////////////////////////////////////////////////////

    testGeGtAnd5 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 && i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, >
////////////////////////////////////////////////////////////////////////////////

    testGeGtAnd6 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 && i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, >
////////////////////////////////////////////////////////////////////////////////

    testGeGtAnd7 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 && i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, >
////////////////////////////////////////////////////////////////////////////////

    testGeGtAnd8 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 && i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, >
////////////////////////////////////////////////////////////////////////////////

    testGeGtAnd9 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 && i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, >
////////////////////////////////////////////////////////////////////////////////

    testGeGtOr1 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 || i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, >
////////////////////////////////////////////////////////////////////////////////

    testGeGtOr2 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 || i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, >
////////////////////////////////////////////////////////////////////////////////

    testGeGtOr3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 || i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, >
////////////////////////////////////////////////////////////////////////////////

    testGeGtOr4 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 || i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, >
////////////////////////////////////////////////////////////////////////////////

    testGeGtOr5 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 || i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, >
////////////////////////////////////////////////////////////////////////////////

    testGeGtOr6 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 || i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, >
////////////////////////////////////////////////////////////////////////////////

    testGeGtOr7 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 || i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, >
////////////////////////////////////////////////////////////////////////////////

    testGeGtOr8 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 || i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, >
////////////////////////////////////////////////////////////////////////////////

    testGeGtOr9 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 || i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, >=
////////////////////////////////////////////////////////////////////////////////

    testGeGeAnd1 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 && i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, >=
////////////////////////////////////////////////////////////////////////////////

    testGeGeAnd2 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 && i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, >=
////////////////////////////////////////////////////////////////////////////////

    testGeGeAnd3 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 && i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, >=
////////////////////////////////////////////////////////////////////////////////

    testGeGeAnd4 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 && i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, >=
////////////////////////////////////////////////////////////////////////////////

    testGeGeAnd5 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 && i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, >=
////////////////////////////////////////////////////////////////////////////////

    testGeGeAnd6 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 && i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, >=
////////////////////////////////////////////////////////////////////////////////

    testGeGeAnd7 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 && i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, >=
////////////////////////////////////////////////////////////////////////////////

    testGeGeAnd8 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 && i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, >=
////////////////////////////////////////////////////////////////////////////////

    testGeGeAnd9 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 && i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, >=
////////////////////////////////////////////////////////////////////////////////

    testGeGeOr1 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 || i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, >=
////////////////////////////////////////////////////////////////////////////////

    testGeGeOr2 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 || i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, >=
////////////////////////////////////////////////////////////////////////////////

    testGeGeOr3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 || i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, >=
////////////////////////////////////////////////////////////////////////////////

    testGeGeOr4 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 || i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, >=
////////////////////////////////////////////////////////////////////////////////

    testGeGeOr5 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 || i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, >=
////////////////////////////////////////////////////////////////////////////////

    testGeGeOr6 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 || i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, >=
////////////////////////////////////////////////////////////////////////////////

    testGeGeOr7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 || i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, >=
////////////////////////////////////////////////////////////////////////////////

    testGeGeOr8 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 || i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, >=
////////////////////////////////////////////////////////////////////////////////

    testGeGeOr9 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 || i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, <
////////////////////////////////////////////////////////////////////////////////

    testGeLtAnd1 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 && i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, <
////////////////////////////////////////////////////////////////////////////////

    testGeLtAnd2 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 && i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, <
////////////////////////////////////////////////////////////////////////////////

    testGeLtAnd3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 && i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, <
////////////////////////////////////////////////////////////////////////////////

    testGeLtAnd4 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 && i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, <
////////////////////////////////////////////////////////////////////////////////

    testGeLtAnd5 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 && i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, <
////////////////////////////////////////////////////////////////////////////////

    testGeLtAnd6 : function () {
      var expected = [ 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 && i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, <
////////////////////////////////////////////////////////////////////////////////

    testGeLtAnd7 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 && i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, <
////////////////////////////////////////////////////////////////////////////////

    testGeLtAnd8 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 && i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, <
////////////////////////////////////////////////////////////////////////////////

    testGeLtAnd9 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 && i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, <
////////////////////////////////////////////////////////////////////////////////

    testGeLtOr1 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 || i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, <
////////////////////////////////////////////////////////////////////////////////

    testGeLtOr2 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 || i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, <
////////////////////////////////////////////////////////////////////////////////

    testGeLtOr3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 || i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, <
////////////////////////////////////////////////////////////////////////////////

    testGeLtOr4 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 || i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, <
////////////////////////////////////////////////////////////////////////////////

    testGeLtOr5 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 || i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, <
////////////////////////////////////////////////////////////////////////////////

    testGeLtOr6 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 || i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, <
////////////////////////////////////////////////////////////////////////////////

    testGeLtOr7 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 || i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, <
////////////////////////////////////////////////////////////////////////////////

    testGeLtOr8 : function () {
      var expected = [ 1, 2, 3, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 || i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, <
////////////////////////////////////////////////////////////////////////////////

    testGeLtOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 || i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, <=
////////////////////////////////////////////////////////////////////////////////

    testGeLeAnd1 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 && i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, <=
////////////////////////////////////////////////////////////////////////////////

    testGeLeAnd2 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 && i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, <=
////////////////////////////////////////////////////////////////////////////////

    testGeLeAnd3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 && i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, <=
////////////////////////////////////////////////////////////////////////////////

    testGeLeAnd4 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 && i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, <=
////////////////////////////////////////////////////////////////////////////////

    testGeLeAnd5 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 && i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, <=
////////////////////////////////////////////////////////////////////////////////

    testGeLeAnd6 : function () {
      var expected = [ 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 && i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, <=
////////////////////////////////////////////////////////////////////////////////

    testGeLeAnd7 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 && i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, <=
////////////////////////////////////////////////////////////////////////////////

    testGeLeAnd8 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 && i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of >=, <=
////////////////////////////////////////////////////////////////////////////////

    testGeLeAnd9 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 && i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, <=
////////////////////////////////////////////////////////////////////////////////

    testGeLeOr1 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 || i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, <=
////////////////////////////////////////////////////////////////////////////////

    testGeLeOr2 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 || i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, <=
////////////////////////////////////////////////////////////////////////////////

    testGeLeOr3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 1 || i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, <=
////////////////////////////////////////////////////////////////////////////////

    testGeLeOr4 : function () {
      var expected = [ 1, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 || i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, <=
////////////////////////////////////////////////////////////////////////////////

    testGeLeOr5 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 || i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, <=
////////////////////////////////////////////////////////////////////////////////

    testGeLeOr6 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 4 || i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, <=
////////////////////////////////////////////////////////////////////////////////

    testGeLeOr7 : function () {
      var expected = [ 1, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 || i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, <=
////////////////////////////////////////////////////////////////////////////////

    testGeLeOr8 : function () {
      var expected = [ 1, 2, 3, 4, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 || i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of >=, <=
////////////////////////////////////////////////////////////////////////////////

    testGeLeOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i >= 8 || i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, ==
////////////////////////////////////////////////////////////////////////////////

    testLtEqAnd1 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 && i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, ==
////////////////////////////////////////////////////////////////////////////////

    testLtEqAnd2 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 && i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, ==
////////////////////////////////////////////////////////////////////////////////

    testLtEqAnd3 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 && i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, ==
////////////////////////////////////////////////////////////////////////////////

    testLtEqAnd4 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 && i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, ==
////////////////////////////////////////////////////////////////////////////////

    testLtEqAnd5 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 && i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, ==
////////////////////////////////////////////////////////////////////////////////

    testLtEqAnd6 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 && i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, ==
////////////////////////////////////////////////////////////////////////////////

    testLtEqAnd7 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 && i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, ==
////////////////////////////////////////////////////////////////////////////////

    testLtEqAnd8 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 && i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, ==
////////////////////////////////////////////////////////////////////////////////

    testLtEqAnd9 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 && i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, ==
////////////////////////////////////////////////////////////////////////////////

    testLtEqOr1 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 || i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, ==
////////////////////////////////////////////////////////////////////////////////

    testLtEqOr2 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 || i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, ==
////////////////////////////////////////////////////////////////////////////////

    testLtEqOr3 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 || i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, ==
////////////////////////////////////////////////////////////////////////////////

    testLtEqOr4 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 || i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, ==
////////////////////////////////////////////////////////////////////////////////

    testLtEqOr5 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 || i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, ==
////////////////////////////////////////////////////////////////////////////////

    testLtEqOr6 : function () {
      var expected = [ 1, 2, 3, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 || i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, ==
////////////////////////////////////////////////////////////////////////////////

    testLtEqOr7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 || i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, ==
////////////////////////////////////////////////////////////////////////////////

    testLtEqOr8 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 || i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, ==
////////////////////////////////////////////////////////////////////////////////

    testLtEqOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 || i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, !=
////////////////////////////////////////////////////////////////////////////////

    testLtNeAnd1 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 && i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, !=
////////////////////////////////////////////////////////////////////////////////

    testLtNeAnd2 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 && i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, !=
////////////////////////////////////////////////////////////////////////////////

    testLtNeAnd3 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 && i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, !=
////////////////////////////////////////////////////////////////////////////////

    testLtNeAnd4 : function () {
      var expected = [ 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 && i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, !=
////////////////////////////////////////////////////////////////////////////////

    testLtNeAnd5 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 && i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, !=
////////////////////////////////////////////////////////////////////////////////

    testLtNeAnd6 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 && i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, !=
////////////////////////////////////////////////////////////////////////////////

    testLtNeAnd7 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 && i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, !=
////////////////////////////////////////////////////////////////////////////////

    testLtNeAnd8 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 && i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, !=
////////////////////////////////////////////////////////////////////////////////

    testLtNeAnd9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 && i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, !=
////////////////////////////////////////////////////////////////////////////////

    testLtNeOr1 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 || i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, !=
////////////////////////////////////////////////////////////////////////////////

    testLtNeOr2 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 || i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, !=
////////////////////////////////////////////////////////////////////////////////

    testLtNeOr3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 || i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, !=
////////////////////////////////////////////////////////////////////////////////

    testLtNeOr4 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 || i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, !=
////////////////////////////////////////////////////////////////////////////////

    testLtNeOr5 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 || i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, !=
////////////////////////////////////////////////////////////////////////////////

    testLtNeOr6 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 || i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, !=
////////////////////////////////////////////////////////////////////////////////

    testLtNeOr7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 || i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, !=
////////////////////////////////////////////////////////////////////////////////

    testLtNeOr8 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 || i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, !=
////////////////////////////////////////////////////////////////////////////////

    testLtNeOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 || i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, >
////////////////////////////////////////////////////////////////////////////////

    testLtGtAnd1 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 && i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, >
////////////////////////////////////////////////////////////////////////////////

    testLtGtAnd2 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 && i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, >
////////////////////////////////////////////////////////////////////////////////

    testLtGtAnd3 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 && i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, >
////////////////////////////////////////////////////////////////////////////////

    testLtGtAnd4 : function () {
      var expected = [ 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 && i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, >
////////////////////////////////////////////////////////////////////////////////

    testLtGtAnd5 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 && i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, >
////////////////////////////////////////////////////////////////////////////////

    testLtGtAnd6 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 && i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, >
////////////////////////////////////////////////////////////////////////////////

    testLtGtAnd7 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 && i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, >
////////////////////////////////////////////////////////////////////////////////

    testLtGtAnd8 : function () {
      var expected = [ 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 && i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, >
////////////////////////////////////////////////////////////////////////////////

    testLtGtAnd9 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 && i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, >
////////////////////////////////////////////////////////////////////////////////

    testLtGtOr1 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 || i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, >
////////////////////////////////////////////////////////////////////////////////

    testLtGtOr2 : function () {
      var expected = [ 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 || i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, >
////////////////////////////////////////////////////////////////////////////////

    testLtGtOr3 : function () {
      var expected = [ 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 || i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, >
////////////////////////////////////////////////////////////////////////////////

    testLtGtOr4 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 || i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, >
////////////////////////////////////////////////////////////////////////////////

    testLtGtOr5 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 || i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, >
////////////////////////////////////////////////////////////////////////////////

    testLtGtOr6 : function () {
      var expected = [ 1, 2, 3, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 || i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, >
////////////////////////////////////////////////////////////////////////////////

    testLtGtOr7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 || i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, >
////////////////////////////////////////////////////////////////////////////////

    testLtGtOr8 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 || i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, >
////////////////////////////////////////////////////////////////////////////////

    testLtGtOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 || i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, >=
////////////////////////////////////////////////////////////////////////////////

    testLtGeAnd1 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 && i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, >=
////////////////////////////////////////////////////////////////////////////////

    testLtGeAnd2 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 && i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, >=
////////////////////////////////////////////////////////////////////////////////

    testLtGeAnd3 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 && i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, >=
////////////////////////////////////////////////////////////////////////////////

    testLtGeAnd4 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 && i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, >=
////////////////////////////////////////////////////////////////////////////////

    testLtGeAnd5 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 && i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, >=
////////////////////////////////////////////////////////////////////////////////

    testLtGeAnd6 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 && i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, >=
////////////////////////////////////////////////////////////////////////////////

    testLtGeAnd7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 && i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, >=
////////////////////////////////////////////////////////////////////////////////

    testLtGeAnd8 : function () {
      var expected = [ 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 && i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, >=
////////////////////////////////////////////////////////////////////////////////

    testLtGeAnd9 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 && i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, >=
////////////////////////////////////////////////////////////////////////////////

    testLtGeOr1 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 || i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, >=
////////////////////////////////////////////////////////////////////////////////

    testLtGeOr2 : function () {
      var expected = [ 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 || i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, >=
////////////////////////////////////////////////////////////////////////////////

    testLtGeOr3 : function () {
      var expected = [ 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 || i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, >=
////////////////////////////////////////////////////////////////////////////////

    testLtGeOr4 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 || i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, >=
////////////////////////////////////////////////////////////////////////////////

    testLtGeOr5 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 || i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, >=
////////////////////////////////////////////////////////////////////////////////

    testLtGeOr6 : function () {
      var expected = [ 1, 2, 3, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 || i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, >=
////////////////////////////////////////////////////////////////////////////////

    testLtGeOr7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 || i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, >=
////////////////////////////////////////////////////////////////////////////////

    testLtGeOr8 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 || i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, >=
////////////////////////////////////////////////////////////////////////////////

    testLtGeOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 || i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, <
////////////////////////////////////////////////////////////////////////////////

    testLtLtAnd1 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 && i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, <
////////////////////////////////////////////////////////////////////////////////

    testLtLtAnd2 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 && i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, <
////////////////////////////////////////////////////////////////////////////////

    testLtLtAnd3 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 && i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, <
////////////////////////////////////////////////////////////////////////////////

    testLtLtAnd4 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 && i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, <
////////////////////////////////////////////////////////////////////////////////

    testLtLtAnd5 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 && i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, <
////////////////////////////////////////////////////////////////////////////////

    testLtLtAnd6 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 && i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, <
////////////////////////////////////////////////////////////////////////////////

    testLtLtAnd7 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 && i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, <
////////////////////////////////////////////////////////////////////////////////

    testLtLtAnd8 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 && i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, <
////////////////////////////////////////////////////////////////////////////////

    testLtLtAnd9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 && i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, <
////////////////////////////////////////////////////////////////////////////////

    testLtLtOr1 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 || i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, <
////////////////////////////////////////////////////////////////////////////////

    testLtLtOr2 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 || i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, <
////////////////////////////////////////////////////////////////////////////////

    testLtLtOr3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 || i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, <
////////////////////////////////////////////////////////////////////////////////

    testLtLtOr4 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 || i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, <
////////////////////////////////////////////////////////////////////////////////

    testLtLtOr5 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 || i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, <
////////////////////////////////////////////////////////////////////////////////

    testLtLtOr6 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 || i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, <
////////////////////////////////////////////////////////////////////////////////

    testLtLtOr7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 || i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, <
////////////////////////////////////////////////////////////////////////////////

    testLtLtOr8 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 || i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, <
////////////////////////////////////////////////////////////////////////////////

    testLtLtOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 || i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, <=
////////////////////////////////////////////////////////////////////////////////

    testLtLeAnd1 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 && i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, <=
////////////////////////////////////////////////////////////////////////////////

    testLtLeAnd2 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 && i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, <=
////////////////////////////////////////////////////////////////////////////////

    testLtLeAnd3 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 && i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, <=
////////////////////////////////////////////////////////////////////////////////

    testLtLeAnd4 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 && i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, <=
////////////////////////////////////////////////////////////////////////////////

    testLtLeAnd5 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 && i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, <=
////////////////////////////////////////////////////////////////////////////////

    testLtLeAnd6 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 && i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, <=
////////////////////////////////////////////////////////////////////////////////

    testLtLeAnd7 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 && i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, <=
////////////////////////////////////////////////////////////////////////////////

    testLtLeAnd8 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 && i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <, <=
////////////////////////////////////////////////////////////////////////////////

    testLtLeAnd9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 && i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, <=
////////////////////////////////////////////////////////////////////////////////

    testLtLeOr1 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 || i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, <=
////////////////////////////////////////////////////////////////////////////////

    testLtLeOr2 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 || i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, <=
////////////////////////////////////////////////////////////////////////////////

    testLtLeOr3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 1 || i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, <=
////////////////////////////////////////////////////////////////////////////////

    testLtLeOr4 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 || i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, <=
////////////////////////////////////////////////////////////////////////////////

    testLtLeOr5 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 || i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, <=
////////////////////////////////////////////////////////////////////////////////

    testLtLeOr6 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 4 || i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, <=
////////////////////////////////////////////////////////////////////////////////

    testLtLeOr7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 || i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, <=
////////////////////////////////////////////////////////////////////////////////

    testLtLeOr8 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 || i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <, <=
////////////////////////////////////////////////////////////////////////////////

    testLtLeOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i < 8 || i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, ==
////////////////////////////////////////////////////////////////////////////////

    testLeEqAnd1 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 && i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, ==
////////////////////////////////////////////////////////////////////////////////

    testLeEqAnd2 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 && i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, ==
////////////////////////////////////////////////////////////////////////////////

    testLeEqAnd3 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 && i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, ==
////////////////////////////////////////////////////////////////////////////////

    testLeEqAnd4 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 && i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, ==
////////////////////////////////////////////////////////////////////////////////

    testLeEqAnd5 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 && i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, ==
////////////////////////////////////////////////////////////////////////////////

    testLeEqAnd6 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 && i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, ==
////////////////////////////////////////////////////////////////////////////////

    testLeEqAnd7 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 && i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, ==
////////////////////////////////////////////////////////////////////////////////

    testLeEqAnd8 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 && i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, ==
////////////////////////////////////////////////////////////////////////////////

    testLeEqAnd9 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 && i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, ==
////////////////////////////////////////////////////////////////////////////////

    testLeEqOr1 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 || i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, ==
////////////////////////////////////////////////////////////////////////////////

    testLeEqOr2 : function () {
      var expected = [ 1, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 || i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, ==
////////////////////////////////////////////////////////////////////////////////

    testLeEqOr3 : function () {
      var expected = [ 1, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 || i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, ==
////////////////////////////////////////////////////////////////////////////////

    testLeEqOr4 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 || i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, ==
////////////////////////////////////////////////////////////////////////////////

    testLeEqOr5 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 || i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, ==
////////////////////////////////////////////////////////////////////////////////

    testLeEqOr6 : function () {
      var expected = [ 1, 2, 3, 4, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 || i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, ==
////////////////////////////////////////////////////////////////////////////////

    testLeEqOr7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 || i == 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, ==
////////////////////////////////////////////////////////////////////////////////

    testLeEqOr8 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 || i == 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, ==
////////////////////////////////////////////////////////////////////////////////

    testLeEqOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 || i == 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, !=
////////////////////////////////////////////////////////////////////////////////

    testLeNeAnd1 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 && i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, !=
////////////////////////////////////////////////////////////////////////////////

    testLeNeAnd2 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 && i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, !=
////////////////////////////////////////////////////////////////////////////////

    testLeNeAnd3 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 && i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, !=
////////////////////////////////////////////////////////////////////////////////

    testLeNeAnd4 : function () {
      var expected = [ 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 && i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, !=
////////////////////////////////////////////////////////////////////////////////

    testLeNeAnd5 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 && i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, !=
////////////////////////////////////////////////////////////////////////////////

    testLeNeAnd6 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 && i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, !=
////////////////////////////////////////////////////////////////////////////////

    testLeNeAnd7 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 && i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, !=
////////////////////////////////////////////////////////////////////////////////

    testLeNeAnd8 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 && i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, !=
////////////////////////////////////////////////////////////////////////////////

    testLeNeAnd9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 && i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, !=
////////////////////////////////////////////////////////////////////////////////

    testLeNeOr1 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 || i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, !=
////////////////////////////////////////////////////////////////////////////////

    testLeNeOr2 : function () {
      var expected = [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 || i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, !=
////////////////////////////////////////////////////////////////////////////////

    testLeNeOr3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 || i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, !=
////////////////////////////////////////////////////////////////////////////////

    testLeNeOr4 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 || i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, !=
////////////////////////////////////////////////////////////////////////////////

    testLeNeOr5 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 || i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, !=
////////////////////////////////////////////////////////////////////////////////

    testLeNeOr6 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 || i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, !=
////////////////////////////////////////////////////////////////////////////////

    testLeNeOr7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 || i != 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, !=
////////////////////////////////////////////////////////////////////////////////

    testLeNeOr8 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 || i != 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, !=
////////////////////////////////////////////////////////////////////////////////

    testLeNeOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 || i != 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, >
////////////////////////////////////////////////////////////////////////////////

    testLeGtAnd1 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 && i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, >
////////////////////////////////////////////////////////////////////////////////

    testLeGtAnd2 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 && i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, >
////////////////////////////////////////////////////////////////////////////////

    testLeGtAnd3 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 && i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, >
////////////////////////////////////////////////////////////////////////////////

    testLeGtAnd4 : function () {
      var expected = [ 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 && i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, >
////////////////////////////////////////////////////////////////////////////////

    testLeGtAnd5 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 && i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, >
////////////////////////////////////////////////////////////////////////////////

    testLeGtAnd6 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 && i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, >
////////////////////////////////////////////////////////////////////////////////

    testLeGtAnd7 : function () {
      var expected = [ 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 && i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, >
////////////////////////////////////////////////////////////////////////////////

    testLeGtAnd8 : function () {
      var expected = [ 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 && i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, >
////////////////////////////////////////////////////////////////////////////////

    testLeGtAnd9 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 && i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, >
////////////////////////////////////////////////////////////////////////////////

    testLeGtOr1 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 || i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, >
////////////////////////////////////////////////////////////////////////////////

    testLeGtOr2 : function () {
      var expected = [ 1, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 || i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, >
////////////////////////////////////////////////////////////////////////////////

    testLeGtOr3 : function () {
      var expected = [ 1, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 || i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, >
////////////////////////////////////////////////////////////////////////////////

    testLeGtOr4 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 || i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, >
////////////////////////////////////////////////////////////////////////////////

    testLeGtOr5 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 || i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, >
////////////////////////////////////////////////////////////////////////////////

    testLeGtOr6 : function () {
      var expected = [ 1, 2, 3, 4, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 || i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, >
////////////////////////////////////////////////////////////////////////////////

    testLeGtOr7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 || i > 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, >
////////////////////////////////////////////////////////////////////////////////

    testLeGtOr8 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 || i > 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, >
////////////////////////////////////////////////////////////////////////////////

    testLeGtOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 || i > 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, >=
////////////////////////////////////////////////////////////////////////////////

    testLeGeAnd1 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 && i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, >=
////////////////////////////////////////////////////////////////////////////////

    testLeGeAnd2 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 && i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, >=
////////////////////////////////////////////////////////////////////////////////

    testLeGeAnd3 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 && i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, >=
////////////////////////////////////////////////////////////////////////////////

    testLeGeAnd4 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 && i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, >=
////////////////////////////////////////////////////////////////////////////////

    testLeGeAnd5 : function () {
      var expected = [ 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 && i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, >=
////////////////////////////////////////////////////////////////////////////////

    testLeGeAnd6 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 && i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, >=
////////////////////////////////////////////////////////////////////////////////

    testLeGeAnd7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 && i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, >=
////////////////////////////////////////////////////////////////////////////////

    testLeGeAnd8 : function () {
      var expected = [ 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 && i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, >=
////////////////////////////////////////////////////////////////////////////////

    testLeGeAnd9 : function () {
      var expected = [ 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 && i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, >=
////////////////////////////////////////////////////////////////////////////////

    testLeGeOr1 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 || i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, >=
////////////////////////////////////////////////////////////////////////////////

    testLeGeOr2 : function () {
      var expected = [ 1, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 || i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, >=
////////////////////////////////////////////////////////////////////////////////

    testLeGeOr3 : function () {
      var expected = [ 1, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 || i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, >=
////////////////////////////////////////////////////////////////////////////////

    testLeGeOr4 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 || i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, >=
////////////////////////////////////////////////////////////////////////////////

    testLeGeOr5 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 || i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, >=
////////////////////////////////////////////////////////////////////////////////

    testLeGeOr6 : function () {
      var expected = [ 1, 2, 3, 4, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 || i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, >=
////////////////////////////////////////////////////////////////////////////////

    testLeGeOr7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 || i >= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, >=
////////////////////////////////////////////////////////////////////////////////

    testLeGeOr8 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 || i >= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, >=
////////////////////////////////////////////////////////////////////////////////

    testLeGeOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 || i >= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, <
////////////////////////////////////////////////////////////////////////////////

    testLeLtAnd1 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 && i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, <
////////////////////////////////////////////////////////////////////////////////

    testLeLtAnd2 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 && i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, <
////////////////////////////////////////////////////////////////////////////////

    testLeLtAnd3 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 && i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, <
////////////////////////////////////////////////////////////////////////////////

    testLeLtAnd4 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 && i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, <
////////////////////////////////////////////////////////////////////////////////

    testLeLtAnd5 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 && i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, <
////////////////////////////////////////////////////////////////////////////////

    testLeLtAnd6 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 && i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, <
////////////////////////////////////////////////////////////////////////////////

    testLeLtAnd7 : function () {
      var expected = [  ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 && i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, <
////////////////////////////////////////////////////////////////////////////////

    testLeLtAnd8 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 && i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, <
////////////////////////////////////////////////////////////////////////////////

    testLeLtAnd9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 && i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, <
////////////////////////////////////////////////////////////////////////////////

    testLeLtOr1 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 || i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, <
////////////////////////////////////////////////////////////////////////////////

    testLeLtOr2 : function () {
      var expected = [ 1, 2, 3 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 || i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, <
////////////////////////////////////////////////////////////////////////////////

    testLeLtOr3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 || i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, <
////////////////////////////////////////////////////////////////////////////////

    testLeLtOr4 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 || i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, <
////////////////////////////////////////////////////////////////////////////////

    testLeLtOr5 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 || i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, <
////////////////////////////////////////////////////////////////////////////////

    testLeLtOr6 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 || i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, <
////////////////////////////////////////////////////////////////////////////////

    testLeLtOr7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 || i < 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, <
////////////////////////////////////////////////////////////////////////////////

    testLeLtOr8 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 || i < 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, <
////////////////////////////////////////////////////////////////////////////////

    testLeLtOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 || i < 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, <=
////////////////////////////////////////////////////////////////////////////////

    testLeLeAnd1 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 && i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, <=
////////////////////////////////////////////////////////////////////////////////

    testLeLeAnd2 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 && i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, <=
////////////////////////////////////////////////////////////////////////////////

    testLeLeAnd3 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 && i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, <=
////////////////////////////////////////////////////////////////////////////////

    testLeLeAnd4 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 && i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, <=
////////////////////////////////////////////////////////////////////////////////

    testLeLeAnd5 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 && i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, <=
////////////////////////////////////////////////////////////////////////////////

    testLeLeAnd6 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 && i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, <=
////////////////////////////////////////////////////////////////////////////////

    testLeLeAnd7 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 && i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, <=
////////////////////////////////////////////////////////////////////////////////

    testLeLeAnd8 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 && i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test && merging of <=, <=
////////////////////////////////////////////////////////////////////////////////

    testLeLeAnd9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 && i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, <=
////////////////////////////////////////////////////////////////////////////////

    testLeLeOr1 : function () {
      var expected = [ 1 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 || i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, <=
////////////////////////////////////////////////////////////////////////////////

    testLeLeOr2 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 || i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, <=
////////////////////////////////////////////////////////////////////////////////

    testLeLeOr3 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 1 || i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, <=
////////////////////////////////////////////////////////////////////////////////

    testLeLeOr4 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 || i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, <=
////////////////////////////////////////////////////////////////////////////////

    testLeLeOr5 : function () {
      var expected = [ 1, 2, 3, 4 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 || i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, <=
////////////////////////////////////////////////////////////////////////////////

    testLeLeOr6 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 4 || i <= 8 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, <=
////////////////////////////////////////////////////////////////////////////////

    testLeLeOr7 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 || i <= 1 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, <=
////////////////////////////////////////////////////////////////////////////////

    testLeLeOr8 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 || i <= 4 RETURN i");
      assertEqual(expected, actual);
    },


////////////////////////////////////////////////////////////////////////////////
/// @brief test || merging of <=, <=
////////////////////////////////////////////////////////////////////////////////

    testLeLeOr9 : function () {
      var expected = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

      var actual = getQueryResults("FOR i IN [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] FILTER i <= 8 || i <= 8 RETURN i");
      assertEqual(expected, actual);
    }

  };
}

////////////////////////////////////////////////////////////////////////////////
/// @brief executes the test suite
////////////////////////////////////////////////////////////////////////////////

jsunity.run(ahuacatlRangesTestSuite);

return jsunity.done();