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

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

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

function ahuacatlQuerySimpleTestSuite () {
  return {

    testNoArraySorting1 : function () {
      let query = "LET values = [9,16,8,15,7,14,6,13,5,12,4,11,3,10,2,1] RETURN values";
      assertEqual([9, 16, 8, 15, 7, 14, 6, 13, 5, 12, 4, 11, 3, 10, 2, 1], AQL_EXECUTE(query).json[0]);
    },
    
    testNoArraySorting2 : function () {
      let query = "LET values = [9,16,8,15,7,14,6,13,5,12,4,11,3,10,2,1] FOR v IN values FILTER v IN values LIMIT 1 RETURN values";
      assertEqual([9, 16, 8, 15, 7, 14, 6, 13, 5, 12, 4, 11, 3, 10, 2, 1], AQL_EXECUTE(query).json[0]);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test filters with special characters
////////////////////////////////////////////////////////////////////////////////

    testSpecialChars1 : function () {
      var data = [ 
        "the quick\nbrown fox jumped over\r\nthe lazy dog",
        "'the \"\\quick\\\n \"brown\\\rfox' jumped",
        '"the fox"" jumped \\over the \newline \roof"'
      ];

      data.forEach(function(value) {
        var actual = getQueryResults("FOR doc IN [ { text: " + JSON.stringify(value) + " } ] FILTER doc.text == " + JSON.stringify(value) + " RETURN doc.text");
        assertEqual([ value ], actual);
      });
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test filters with special characters
////////////////////////////////////////////////////////////////////////////////

    testSpecialChars2 : function () {
      var data = [ 
        "the quick\nbrown fox jumped over\r\nthe lazy dog",
        "'the \"\\quick\\\n \"brown\\\rfox' jumped",
        '"the fox"" jumped \\over the \newline \roof"'
      ];

      data.forEach(function(value) {
        var actual = getQueryResults("FOR doc IN [ { text: @value } ] FILTER doc.text == @value RETURN doc.text", { value: value });
        assertEqual([ value ], actual);
      });
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief range
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("RETURN 1..3");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief range
////////////////////////////////////////////////////////////////////////////////

    testRange2 : function () {
      var expected = [ [ 7, 8, 9, 10, 11, 12, 13, 14, 15 ] ];

      var actual = getQueryResults("RETURN 7..15");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief range
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("RETURN -5..-10");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief range
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("RETURN -5..2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief range
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("RETURN 5..-2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief range
////////////////////////////////////////////////////////////////////////////////

    testRange6 : function () {
      var expected = [ [ 0 ] ];

      var actual = getQueryResults("RETURN 0..0");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief range
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("LET a = 3, b = 9 RETURN a..b");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief range
////////////////////////////////////////////////////////////////////////////////

    testRange8 : function () {
      var result = [ ], i ,j;
      for (i = 1; i <= 10; ++i) {
        for (j = 1; j <= 10; ++j) {
          result.push(i * j);
        }
      }

      var actual = getQueryResults("FOR i IN 1..10 FOR j IN 1..10 RETURN i * j");
      assertEqual(result, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief range
////////////////////////////////////////////////////////////////////////////////

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

      var actual = AQL_EXECUTE("RETURN 1.5..4.76").json;
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief multi let
////////////////////////////////////////////////////////////////////////////////

    testMultiLet1 : function () {
      var expected = [ 6 ];

      var actual = getQueryResults("let a = 1, b = 2, c = 3 return a + b+ c");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief multi let
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("FOR i IN [ 1, 2, 3 ] LET a = 1, b = 2, c = 3 RETURN 1");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief multi let
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("FOR i IN [ 1, 2, 3 ] LET a = 1, b = 2, c = 3 RETURN i > a ? b : c");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief multi let
////////////////////////////////////////////////////////////////////////////////

    testMultiLet4 : function () {
      assertQueryError(errors.ERROR_QUERY_PARSE.code, "LET a = 1, b = RETURN a"); 
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief multi let
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("LET a = 1, b = (FOR i IN [ 1, 2, 3 ] RETURN i) RETURN b");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief multi let
////////////////////////////////////////////////////////////////////////////////

    testMultiLetOrder1 : function () {
      var expected = [ 14 ];

      var actual = getQueryResults("LET a = 1, b = a + 1, c = b * 7 RETURN c");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief multi let
////////////////////////////////////////////////////////////////////////////////

    testMultiLetOrder2 : function () {
      var expected = [ 5 ];

      var actual = getQueryResults("LET a = [ 3, 5 ], r = (FOR i IN a RETURN i) RETURN r[1]");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief multi let
////////////////////////////////////////////////////////////////////////////////

    testMultiLetOrder3 : function () {
      var expected = [ 5 ];

      var actual = getQueryResults("LET a = [ 3, 5 ], r = (FOR i IN a RETURN i), t = r[1] RETURN t");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return null
////////////////////////////////////////////////////////////////////////////////

    testReturnOnlyQuery1 : function () {
      var expected = [ null ];

      var actual = getQueryResults("return null");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a number
////////////////////////////////////////////////////////////////////////////////

    testReturnOnlyQuery2 : function () {
      var expected = [ 0 ];

      var actual = getQueryResults("return 0");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a string
////////////////////////////////////////////////////////////////////////////////

    testReturnOnlyQuery3 : function () {
      var expected = [ "a string value" ];

      var actual = getQueryResults("return \"a string value\"");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a list
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("return [ 1, 2, 9 ]");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return an array
////////////////////////////////////////////////////////////////////////////////

    testReturnOnlyQuery5 : function () {
      var expected = [ { "active" : false, "age" : 35, "id" : 15, "likes" : [ ], "name" : "Peter" } ];

      var actual = getQueryResults("return { \"name\" : \"Peter\", \"id\" : 15, \"age\" : 35, \"active\" : false, \"likes\" : [ ] }");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a list of arrays
////////////////////////////////////////////////////////////////////////////////

    testReturnOnlyQuery6 : function () {
      var expected = [ [ { "name" : "Max", "id" : 1 }, { "name" : "Vanessa", "id" : 2 }, { "unrelated" : [ "some", "stuff", "goes", "here" ] } ] ];

      var actual = getQueryResults("return [ { \"name\" : \"Max\", \"id\" : 1 }, { \"name\" : \"Vanessa\", \"id\" : 2 }, { \"unrelated\" : [ \"some\", \"stuff\", \"goes\", \"here\" ] } ]");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a computed value
////////////////////////////////////////////////////////////////////////////////

    testReturnOnlyQuery7 : function () {
      var expected = [ 42 ];

      var actual = getQueryResults("return 1 + 40 + 1");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from let
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("let x = 1 return x");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from let
////////////////////////////////////////////////////////////////////////////////

    testReturnLet2 : function () {
      var expected = [ [ 1, 2, 42 ] ];

      var actual = getQueryResults("let x = [ 1, 2, 42 ] return x");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from let
////////////////////////////////////////////////////////////////////////////////

    testReturnLet3 : function () {
      var expected = [ null ];

      var actual = getQueryResults("let x = null return x");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from let
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("let x = (for u in [ 1, 2, 3 ] return u) return x");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from let
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("let x = (for u in (for v in [ 1, 2, 3 ] return v + 1) return u) return x");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from let
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("let x = (return 1) return x");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("filter 1 == 0 return 1");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("filter 1 == 1 filter 1 == 0 return 1");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("filter 1 == 1 return 1");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("filter 1 == 1 filter \"true\" == \"true\" return 1");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

    testReturnFilter5 : function () {
      var expected = [ 2 ];

      var actual = getQueryResults("let x = (filter 1 == 1 return 1) return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

    testReturnFilter6 : function () {
      var expected = [ 2 ];

      var actual = getQueryResults("let x = (filter 0 == 1 return 1) return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("let x = (filter 0 == 1 return 1) filter x == [ 1 ] return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

    testReturnFilter8 : function () {
      var expected = [ 2 ];

      var actual = getQueryResults("let x = (filter 1 == 1 return 1) filter x == [ 1 ] return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("filter 1 == 0 filter 2 == 3 return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("let a = 1 filter a > 1 && a < 0 filter a > 2 && a < 1 return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("let a = 1 filter a == 1 && a == 2 && a == 3 return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

    testReturnFilter12 : function () {
      var expected = [ 2 ];

      var actual = getQueryResults("let a = 1 let b = 1 filter a == b return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("let a = 1 let b = 1 filter a != b return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

    testReturnFilter14 : function () {
      var expected = [ 2 ];

      var actual = getQueryResults("let a = 1 let b = 1 filter a >= b return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("let a = 1 let b = 1 filter a > b return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

    testReturnFilter16 : function () {
      var expected = [ 2 ];

      var actual = getQueryResults("let a = 1 let b = 1 filter a <= b return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("let a = 1 let b = 1 filter a < b return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

    testReturnFilter18 : function () {
      var expected = [ 2 ];

      var actual = getQueryResults("let a = 1 let b = 1 filter a >= b filter a <= b return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("let a = 1 let b = 1 filter a >= b filter a < b return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("let a = 1 let b = 1 filter a >= b filter a > b return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

    testReturnFilter21 : function () {
      var expected = [ 2 ];

      var actual = getQueryResults("let a = 1 let b = 1 filter a >= b filter a >= b return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

    testReturnFilter22 : function () {
      var expected = [ 2 ];

      var actual = getQueryResults("let a = 1 let b = 1 filter a >= b filter a == b return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("let a = 1 let b = 1 filter a > b filter a <= b return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("let a = 1 let b = 1 filter a > b filter a < b return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("let a = 1 let b = 1 filter a > b filter a > b return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("let a = 1 let b = 1 filter a > b filter a >= b return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("let a = 1 let b = 1 filter a > b filter a == b return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

    testReturnFilter28 : function () {
      var expected = [ 2 ];

      var actual = getQueryResults("let a = 1 let b = 1 filter a == b filter a <= b return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("let a = 1 let b = 1 filter a == b filter a < b return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

    testReturnFilter30 : function () {
      var expected = [ 2 ];

      var actual = getQueryResults("let a = 1 let b = 1 filter a == b filter a >= b return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief return a value from a filter
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("let a = 1 let b = 1 filter a == b filter a > b return 2");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief sort and return
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("sort null return 1");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief sort and return
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("sort [ 1, 2 ] return 1");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief sort and return
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("sort rand() return 1");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief sort and return
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("let a=(for x in [1,2,3] sort x desc return x) return a");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief limit and return
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("limit 0 return 1");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief limit and return
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("limit 1 return 1");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief limit and return
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("limit 0, 0 return 1");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief limit and return
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("limit 1, 1 return 1");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief limit and return
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("limit 0, 1 return 1");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief collect and return
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("collect city = 1 return 1");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief collect and return
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("collect city = 1 into g return 1");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief collect and return
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("collect city = 1, nonsense = 2 return 1");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief comments
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("/* return 2 */ return 1");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief comments
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("/* return 1 */ return [/*1,2,3,*/4 /*5,6,7*/]");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief comments
////////////////////////////////////////////////////////////////////////////////

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

      var actual = getQueryResults("/* for u in [1,2,3] */ return 1");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief list index access 
////////////////////////////////////////////////////////////////////////////////

    testListIndexes: function () {
      var actual;
      
      actual = getQueryResults("LET l = [ 1, 2, 3 ] RETURN l[0]");
      assertEqual([ 1 ], actual);
      
      actual = getQueryResults("LET l = [ 1, 2, 3 ] RETURN l[1]");
      assertEqual([ 2 ], actual);
      
      actual = getQueryResults("LET l = [ 1, 2, 3 ] RETURN l[2]");
      assertEqual([ 3 ], actual);

      actual = getQueryResults("LET l = [ 1, 2, 3 ] RETURN l[3]");
      assertEqual([ null ], actual);
      
      actual = getQueryResults("LET l = [ 1, 2, 3 ] RETURN l[-1]");
      assertEqual([ 3 ], actual);
      
      actual = getQueryResults("LET l = [ 1, 2, 3 ] RETURN l[-2]");
      assertEqual([ 2 ], actual);
      
      actual = getQueryResults("LET l = [ 1, 2, 3 ] RETURN l[-3]");
      assertEqual([ 1 ], actual);
      
      actual = getQueryResults("LET l = [ 1, 2, 3 ] RETURN l[-4]");
      assertEqual([ null ], actual);
      
      actual = getQueryResults("LET l = [ 1, 2, 3 ] RETURN l['a']");
      assertEqual([ null ], actual);
  
      actual = getQueryResults("LET l = [ 1, 2, 3 ] RETURN l['0']");
      assertEqual([ 1 ], actual);
      
      actual = getQueryResults("LET l = { '1': 1, '2': 2, '3': 3 } RETURN l[0]");
      assertEqual([ null ], actual);
      
      actual = getQueryResults("LET l = { '1': 1, '2': 2, '3': 3 } RETURN l[1]");
      assertEqual([ '1' ], actual);
      
      actual = getQueryResults("LET l = { '1': 1, '2': 2, '3': 3 } RETURN l[-1]");
      assertEqual([ null ], actual);
      
      actual = getQueryResults("LET l = { '1': 1, '2': 2, '3': 3 } RETURN l['0']");
      assertEqual([ null ], actual);
      
      actual = getQueryResults("LET l = { '1': 1, '2': 2, '3': 3 } RETURN l['1']");
      assertEqual([ 1 ], actual);
      
      actual = getQueryResults("LET l = { '1': 1, '2': 2, '3': 3 } RETURN l['2']");
      assertEqual([ 2 ], actual);
      
      actual = getQueryResults("LET l = { '1': 1, '2': 2, '3': 3 } RETURN l['24']");
      assertEqual([ null ], actual);
      
      actual = getQueryResults("LET l = { '1': 1, '2': 2, '3': 3 } RETURN l['-1']");
      assertEqual([ null ], actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief naming
////////////////////////////////////////////////////////////////////////////////

    testNaming: function () {
      var actual;
      
      actual = getQueryResults("LET a = [ 1 ] RETURN a[0]");
      assertEqual([ 1 ], actual);
      
      actual = getQueryResults("LET `a` = [ 1 ] RETURN `a`[0]");
      assertEqual([ 1 ], actual);
    
      actual = getQueryResults("LET `a b` = [ 1 ] RETURN `a b`[0]");
      assertEqual([ 1 ], actual);
      
      actual = getQueryResults("LET `a b c` = [ 1 ] RETURN `a b c`[0]");
      assertEqual([ 1 ], actual);
      
      actual = getQueryResults("LET `a b c` = { `d e f`: 1 } RETURN `a b c`['d e f']");
      assertEqual([ 1 ], actual);
      
      assertQueryError(errors.ERROR_ARANGO_ILLEGAL_NAME.code, "LET a = 1 RETURN `a b c`"); 
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief numeric overflow at compile time
////////////////////////////////////////////////////////////////////////////////

    testOverflowCompileInt: function () {
      assertEqual([ 0 ], getQueryResults("LET l = 4444444444444555555555555555555555555555555555554444333333333333333333333334444444544 RETURN l * l * l * l * l"));
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief numeric overflow at compile time
////////////////////////////////////////////////////////////////////////////////

    testOverflowCompileDouble: function () {
      assertEqual([ 0 ], getQueryResults("LET l = 4.0e999 RETURN l * l * l * l * l")); 
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief numeric underflow at compile time
////////////////////////////////////////////////////////////////////////////////

    testUnderflowCompileInt: function () {
      assertEqual([ 0 ], getQueryResults("LET l = -4444444444444555555555555555555555555555555555554444333333333333333333333334444444544 RETURN l * l * l * l * l"));
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief numeric underflow at compile time
////////////////////////////////////////////////////////////////////////////////

    testUnderflowCompileDouble: function () {
      assertEqual([ 0 ], getQueryResults("LET l = -4.0e999 RETURN l * l * l * l * l")); 
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief numeric overflow at execution time
////////////////////////////////////////////////////////////////////////////////

    testOverflowExecutionInt: function () {
      assertEqual([ null ], getQueryResults("FOR l IN [ 33939359949454345354858882332 ] RETURN l * l * l * l * l * l * l * l * l * l * l")); 
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief numeric overflow at execution time
////////////////////////////////////////////////////////////////////////////////

    testOverflowExecutionDouble: function () {
      assertEqual([ 0 ], getQueryResults("FOR l IN [ 3.0e300 ] RETURN l * l * l * l * l * l * l * l * l * l * l")); 
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief numeric underflow at execution time
////////////////////////////////////////////////////////////////////////////////

    testUnderflowExecutionInt: function () {
      assertEqual([ null ], getQueryResults("FOR l IN [ -33939359949454345354858882332 ] RETURN l * l * l * l * l * l * l * l * l * l * l")); 
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief numeric underflow at execution time
////////////////////////////////////////////////////////////////////////////////

    testUnderflowExecutionDouble: function () {
      assertEqual([ 0 ], getQueryResults("FOR l IN [ -3.0e300 ] RETURN l * l * l * l * l * l * l * l * l * l * l")); 
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief big integer overflow
////////////////////////////////////////////////////////////////////////////////

    testBigIntOverflow: function () {
      assertEqual([ 9223372036854776000 ], getQueryResults("RETURN 9223372036854775808")); 
    },
    
////////////////////////////////////////////////////////////////////////////////
/// @brief big integer underflow
////////////////////////////////////////////////////////////////////////////////

    testBigIntUnderflow: function () {
      assertEqual([ -9223372036854776000 ], getQueryResults("RETURN -9223372036854775809")); 
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief big integers
////////////////////////////////////////////////////////////////////////////////

    testBigInt: function () {
      var actual;

      actual = getQueryResults("FOR i IN [ 2147483647, 2147483648, -2147483648, -2147483649 /*,  9223372036854775807,*/ /*-9223372036854775808*/ ] RETURN 1");
      assertEqual([ 1, 1, 1, 1 ], actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief negative numbers
////////////////////////////////////////////////////////////////////////////////

    testNegativeNumbers1: function () {
      var actual;

      actual = getQueryResults("FOR i IN [ -1, -2, -2.5, -5.5, -1 - 3, -5.5 - 1.5, -5.5 - (-1.5) ] RETURN i");
      assertEqual([ -1, -2, -2.5, -5.5, -4, -7, -4 ], actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief negative numbers
////////////////////////////////////////////////////////////////////////////////
    
    testNegativeNumbers2: function () {
      var actual;

      actual = getQueryResults("FOR i IN [ 1 ] RETURN { a: -1 -3, b: 2 - 0 }");
      assertEqual([ { a: -4, b: 2 } ], actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test empty lists
////////////////////////////////////////////////////////////////////////////////

    testEmptyLists1: function () {
      var actual;

      actual = getQueryResults("LET l1 = [ ] LET l2 = [ ] RETURN { l1: l1, l2: l2 }");
      assertEqual([ { l1: [ ], l2: [ ] } ], actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test empty lists
////////////////////////////////////////////////////////////////////////////////

    testEmptyLists2: function () {
      var actual;

      actual = getQueryResults("LET l1 = (FOR i IN [] RETURN i) LET l2 = (FOR i IN [ ] RETURN i) RETURN { l1: l1, l2: l2 }");
      assertEqual([ { l1: [ ], l2: [ ] } ], actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test empty lists
////////////////////////////////////////////////////////////////////////////////

    testEmptyLists3: function () {
      var actual;

      actual = getQueryResults("LET l1 = @l1 LET l2 = @l2 RETURN { l1: l1, l2: l2 }", { l1: [ ], l2: [ ] });
      assertEqual([ { l1: [ ], l2: [ ] } ], actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test empty lists
////////////////////////////////////////////////////////////////////////////////

    testEmptyLists4: function () {
      var actual;

      actual = getQueryResults("LET l1 = (FOR i IN @l1 RETURN i) LET l2 = (FOR i IN @l2 RETURN i) RETURN { l1: l1, l2: l2 }", { l1: [ ], l2: [ ] });
      assertEqual([ { l1: [ ], l2: [ ] } ], actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test constant filter
////////////////////////////////////////////////////////////////////////////////

    testConstantFilter1: function () {
      var actual;

      actual = getQueryResults("FOR i IN [1, 2, 3, 4] FILTER 1 >= 0 RETURN i");
      assertEqual([ 1, 2, 3, 4 ], actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test constant filter
////////////////////////////////////////////////////////////////////////////////

    testConstantFilter2: function () {
      var actual;

      actual = getQueryResults("FOR i IN [1, 2, 3, 4] FOR j IN [1, 2, 3, 4] FILTER 2 < 0 RETURN i");
      assertEqual([ ], actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test constant filter
////////////////////////////////////////////////////////////////////////////////

    testConstantFilter3: function () {
      var actual;

      actual = getQueryResults("FOR i IN [1, 2, 3, 4] FILTER 2 < 0 FOR j IN [1, 2, 3, 4] FILTER 2 < 0 RETURN i");
      assertEqual([ ], actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test constant filter
////////////////////////////////////////////////////////////////////////////////

    testConstantFilter4: function () {
      var actual;

      actual = getQueryResults("LET l1 = (FOR i IN [1, 2, 3, 4] FILTER 3 < 0 RETURN i) LET l2 = (FOR i IN [1, 2, 3, 4] FILTER 3 < 0 RETURN i) RETURN { l1: l1, l2: l2 }");
      assertEqual([ { l1: [ ], l2: [ ] } ], actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief stable sort after COLLECT
////////////////////////////////////////////////////////////////////////////////
    
    testStableSort1: function () {
      var data = [ 
        { "city" : "london", "order" : 4 }, 
        { "city" : "paris", "order" : 4 }, 
        { "city" : "london", "order" : 2 }, 
        { "city" : "paris", "order" : 3 }, 
        { "city" : "new york", "order" : 2 }, 
        { "city" : "london", "order" : 3 }, 
        { "city" : "new york", "order" : 4 }, 
        { "city" : "new york", "order" : 3 }, 
        { "city" : "paris", "order" : 1 }, 
        { "city" : "new york", "order" : 1 }, 
        { "city" : "paris", "order" : 2 }, 
        { "city" : "london", "order" : 1 }
      ];

      var actual, expected;

      expected = [ 
        { "city" : "london", "orders" : [ 4, 3, 2, 1 ] }, 
        { "city" : "new york", "orders" : [ 4, 3, 2, 1 ] }, 
        { "city" : "paris", "orders" : [ 4, 3, 2, 1 ] } 
      ];

      actual = getQueryResults("FOR value IN " + JSON.stringify(data) + " SORT value.order DESC COLLECT city = value.city INTO orders RETURN { city: city, orders: orders[*].value.order }");
      assertEqual(expected, actual);
      
      expected = [ 
        { "city" : "london", "orders" : [ 1, 2, 3, 4 ] }, 
        { "city" : "new york", "orders" : [ 1, 2, 3, 4 ] }, 
        { "city" : "paris", "orders" : [ 1, 2, 3, 4 ] } 
      ];

      actual = getQueryResults("FOR value IN " + JSON.stringify(data) + " SORT value.order ASC COLLECT city = value.city INTO orders RETURN { city: city, orders: orders[*].value.order }");
      assertEqual(expected, actual);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief stable sort after COLLECT
////////////////////////////////////////////////////////////////////////////////
    
    testStableSort2: function () {
      var data = [ 
        { "city" : "london", "order" : 4 }, 
        { "city" : "paris", "order" : 4 }, 
        { "city" : "london", "order" : 2 }, 
        { "city" : "paris", "order" : 3 }, 
        { "city" : "new york", "order" : 2 }, 
        { "city" : "london", "order" : 3 }, 
        { "city" : "new york", "order" : 4 }, 
        { "city" : "new york", "order" : 3 }, 
        { "city" : "paris", "order" : 1 }, 
        { "city" : "new york", "order" : 1 }, 
        { "city" : "paris", "order" : 2 }, 
        { "city" : "london", "order" : 1 }
      ];

      var actual, expected;

      expected = [ 
        { "cities" : [ "paris", "new york", "london" ], "order" : 1 }, 
        { "cities" : [ "paris", "new york", "london" ], "order" : 2 }, 
        { "cities" : [ "paris", "new york", "london" ], "order" : 3 }, 
        { "cities" : [ "paris", "new york", "london" ], "order" : 4 } 
      ];

      actual = getQueryResults("FOR value IN " + JSON.stringify(data) + " SORT value.city DESC COLLECT order = value.order INTO cities RETURN { order: order, cities: cities[*].value.city }");
      assertEqual(expected, actual);
      
      expected = [ 
        { "cities" : [ "london", "new york", "paris" ], "order" : 4 }, 
        { "cities" : [ "london", "new york", "paris" ], "order" : 3 }, 
        { "cities" : [ "london", "new york", "paris" ], "order" : 2 }, 
        { "cities" : [ "london", "new york", "paris" ], "order" : 1 } 
      ];

      actual = getQueryResults("FOR value IN " + JSON.stringify(data) + " SORT value.city ASC COLLECT order = value.order INTO cities SORT order DESC RETURN { order: order, cities: cities[*].value.city }");
      assertEqual(expected, actual);
    },


    testLimitForLists: function () {
      var queries = [
        ["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 0 RETURN doc2", []], 
        ["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 1 RETURN doc2", [1]], 
        ["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 2 RETURN doc2", [1,2]], 
        ["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 3 RETURN doc2", [1,2,3]], 
        ["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 4 RETURN doc2", [1,2,3]], 
        ["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 1,0 RETURN doc2", []], 
        ["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 1,1 RETURN doc2", [2]], 
        ["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 1,2 RETURN doc2", [2,3]], 
        ["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 1,3 RETURN doc2", [2,3]], 
        ["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 1,4 RETURN doc2", [2,3]], 
        ["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 2,0 RETURN doc2", []], 
        ["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 2,1 RETURN doc2", [3]], 
        ["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 2,2 RETURN doc2", [3]], 
        ["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 2,3 RETURN doc2", [3]], 
        ["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 2,4 RETURN doc2", [3]], 
        ["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 3,0 RETURN doc2", []], 
        ["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 3,1 RETURN doc2", []], 
        ["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 3,2 RETURN doc2", []], 
        ["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 3,3 RETURN doc2", []], 
        ["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 3,4 RETURN doc2", []] 
      ];

      queries.forEach(function(query) {
        var actual = getQueryResults(query[0]);
        assertEqual(query[1], actual);
      });
    },

    testForWithoutArray : function () {
      assertQueryError(errors.ERROR_QUERY_ARRAY_EXPECTED.code, "LET a = null FOR x IN a RETURN 1"); 
      
      assertQueryError(errors.ERROR_QUERY_ARRAY_EXPECTED.code, "LET a = NOOPT(null) FOR x IN a RETURN 1"); 
    },

  };
}

////////////////////////////////////////////////////////////////////////////////
/// @brief executes the test suite
////////////////////////////////////////////////////////////////////////////////

jsunity.run(ahuacatlQuerySimpleTestSuite);

return jsunity.done();