/* jshint globalstrict:false, strict:false */
/* global assertEqual, assertNotNull, assertNull, assertTrue, assertMatch,
  assertFalse */

// //////////////////////////////////////////////////////////////////////////////
// / @brief test the graph class
// /
// / @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 Dr. Frank Celler, Lucas Dohmen
// / @author Copyright 2012, triAGENS GmbH, Cologne, Germany
// //////////////////////////////////////////////////////////////////////////////

var jsunity = require('jsunity');

var db = require('@arangodb').db;
var SimpleQueryArray = require('@arangodb/simple-query').SimpleQueryArray;

// //////////////////////////////////////////////////////////////////////////////
// / @brief test lookup-by-key API
// //////////////////////////////////////////////////////////////////////////////

function SimpleQueryLookupByKeysSuite () {
  'use strict';

  var cn = 'SimpleQueryLookupByKeysSuite';
  var c = null;

  return {

// //////////////////////////////////////////////////////////////////////////////
// / @brief set up
// //////////////////////////////////////////////////////////////////////////////

    setUp: function () {
      db._drop(cn);
      c = db._create(cn);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief tear down
// //////////////////////////////////////////////////////////////////////////////

    tearDown: function () {
      db._drop(cn);
      c = null;
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief lookup in empty collection
// //////////////////////////////////////////////////////////////////////////////

    testEmptyCollection: function () {
      var result = c.documents([ 'foo', 'bar', 'baz' ]);

      assertEqual({ documents: [ ] }, result);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief lookup in empty collection and empty lookup list
// //////////////////////////////////////////////////////////////////////////////

    testEmptyCollectionAndArray: function () {
      var result = c.documents([ ]);

      assertEqual({ documents: [ ] }, result);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief lookup in collection with empty lookup list
// //////////////////////////////////////////////////////////////////////////////

    testEmptyArray: function () {
      for (var i = 0; i < 100; ++i) {
        c.insert({ _key: 'test' + i });
      }

      var result = c.documents([ ]);

      assertEqual({ documents: [ ] }, result);

      // try with alias method
      result = c.lookupByKeys([ ]);
      assertEqual({ documents: [ ] }, result);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief lookup in collection with document ids
// //////////////////////////////////////////////////////////////////////////////

    testDocumentIds: function () {
      var keys = [ ];

      for (var i = 0; i < 100; ++i) {
        c.insert({ _key: 'test' + i });
        keys.push(c.name() + '/test' + i);
      }

      // should have matches
      var result = c.documents(keys);
      assertEqual(100, result.documents.length);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief lookup in collection with document ids
// //////////////////////////////////////////////////////////////////////////////

    testDocumentIdDuplicates: function () {
      var keys = [ ];

      for (var i = 0; i < 100; ++i) {
        c.insert({ _key: 'test' + i });
        // each document is here exactly twice
        keys.push(c.name() + '/test' + i);
        keys.push(c.name() + '/test' + i);
      }

      // should have matches
      var result = c.documents(keys);
      assertEqual(100, result.documents.length);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief lookup in collection with document ids
// //////////////////////////////////////////////////////////////////////////////

    testDocumentIdNonExisting: function () {
      var keys = [ ];

      for (var i = 0; i < 100; ++i) {
        c.insert({ _key: 'test' + i });
        keys.push(c.name() + '/foo' + i);
      }

      // should not have matches
      var result = c.documents(keys);
      assertEqual(0, result.documents.length);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief lookup in collection with document ids
// //////////////////////////////////////////////////////////////////////////////

    testDocumentIdsInvalid: function () {
      var keys = [ ];

      for (var i = 0; i < 100; ++i) {
        c.insert({ _key: 'test' + i });
        keys.push(c.name() + '/');
      }

      // should not have matches
      var result = c.documents(keys);
      assertEqual(0, result.documents.length);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief lookup in collection with document ids
// //////////////////////////////////////////////////////////////////////////////

    testDocumentIdsOtherCollection: function () {
      var keys = [ ];

      for (var i = 0; i < 100; ++i) {
        c.insert({ _key: 'test' + i });
        keys.push('Another' + c.name() + '/test' + i);
      }

      // should not have matches
      var result = c.documents(keys);
      assertEqual(0, result.documents.length);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief lookup in collection with numeric keys
// //////////////////////////////////////////////////////////////////////////////

    testNumericKeys: function () {
      for (var i = 0; i < 100; ++i) {
        c.insert({ _key: String(i) });
      }

      // should have matches
      var result = c.documents([ '1', '2', '3', '0' ]);
      assertEqual(4, result.documents.length);

      // try with alias method
      result = c.lookupByKeys([ '1', '2', '3', '0' ]);
      assertEqual(4, result.documents.length);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief lookup using invalid keys
// //////////////////////////////////////////////////////////////////////////////

    testInvalidKeys: function () {
      var result = c.documents([ ' ', '*  ', ' bfffff/\\&, ', '////.,;::' ]);

      assertEqual({ documents: [ ] }, result);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief lookup in collection
// //////////////////////////////////////////////////////////////////////////////

    testLookup: function () {
      var keys = [ ];
      for (var i = 0; i < 1000; ++i) {
        c.insert({ _key: 'test' + i, value: i });
        keys.push('test' + i);
      }

      var result = c.documents(keys);
      assertEqual(1000, result.documents.length);

      result.documents.forEach(function (doc) {
        assertTrue(doc.hasOwnProperty('_id'));
        assertTrue(doc.hasOwnProperty('_key'));
        assertTrue(doc.hasOwnProperty('_rev'));
        assertTrue(doc.hasOwnProperty('value'));
        assertMatch(/^test\d+$/, doc._key);
        assertEqual(cn + '/' + doc._key, doc._id);
        assertEqual(doc._key, 'test' + doc.value);
      });

      // try with alias method
      result = c.lookupByKeys(keys);
      assertEqual(1000, result.documents.length);

      result.documents.forEach(function (doc) {
        assertTrue(doc.hasOwnProperty('_id'));
        assertTrue(doc.hasOwnProperty('_key'));
        assertTrue(doc.hasOwnProperty('_rev'));
        assertTrue(doc.hasOwnProperty('value'));
        assertMatch(/^test\d+$/, doc._key);
        assertEqual(cn + '/' + doc._key, doc._id);
        assertEqual(doc._key, 'test' + doc.value);
      });
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief lookup in collection
// //////////////////////////////////////////////////////////////////////////////

    testLookupDuplicate: function () {
      var keys = [ ];
      for (var i = 0; i < 100; ++i) {
        c.insert({ _key: 'test' + i, value: i });
        // add same key twice
        keys.push('test' + i);
        keys.push('test' + i);
      }

      var result = c.documents(keys);
      assertEqual(100, result.documents.length);

      result.documents.forEach(function (doc) {
        assertTrue(doc.hasOwnProperty('_id'));
        assertTrue(doc.hasOwnProperty('_key'));
        assertTrue(doc.hasOwnProperty('_rev'));
        assertTrue(doc.hasOwnProperty('value'));
        assertMatch(/^test\d+$/, doc._key);
        assertEqual(cn + '/' + doc._key, doc._id);
        assertEqual(doc._key, 'test' + doc.value);
      });
    }

  };
}

// //////////////////////////////////////////////////////////////////////////////
// / @brief test remove-by-keys API
// //////////////////////////////////////////////////////////////////////////////

function SimpleQueryRemoveByKeysSuite () {
  'use strict';

  var cn = 'SimpleQueryRemoveByKeysSuite';
  var c = null;

  return {

// //////////////////////////////////////////////////////////////////////////////
// / @brief set up
// //////////////////////////////////////////////////////////////////////////////

    setUp: function () {
      db._drop(cn);
      c = db._create(cn);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief tear down
// //////////////////////////////////////////////////////////////////////////////

    tearDown: function () {
      db._drop(cn);
      c = null;
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief remove in empty collection
// //////////////////////////////////////////////////////////////////////////////

    testRemoveEmptyCollection: function () {
      var result = c.removeByKeys([ 'foo', 'bar', 'baz' ]);

      assertEqual({ removed: 0, ignored: 3 }, result);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief remove in empty collection and empty lookup list
// //////////////////////////////////////////////////////////////////////////////

    testRemoveEmptyCollectionAndArray: function () {
      var result = c.removeByKeys([ ]);

      assertEqual({ removed: 0, ignored: 0 }, result);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief remove in collection with empty lookup list
// //////////////////////////////////////////////////////////////////////////////

    testRemoveEmptyArray: function () {
      for (var i = 0; i < 100; ++i) {
        c.insert({ _key: 'test' + i });
      }

      var result = c.removeByKeys([ ]);

      assertEqual({ removed: 0, ignored: 0 }, result);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief remove in collection with existing and nonexisting keys
// //////////////////////////////////////////////////////////////////////////////

    testRemoveMixed: function () {
      var keys = [ ];
      for (var i = 0; i < 500; ++i) {
        c.insert({ _key: 'test' + i });

        if (i % 2 === 0) {
          keys.push('test' + i);
        } else {
          keys.push('foobar' + i);
        }
      }

      var result = c.removeByKeys(keys);

      assertEqual({ removed: 250, ignored: 250 }, result);

      assertEqual(250, c.count());
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief remove in collection with nonexisting keys
// //////////////////////////////////////////////////////////////////////////////

    testRemoveNonExisting: function () {
      var keys = [ ];
      for (var i = 0; i < 100; ++i) {
        keys.push('test' + i);
      }

      var result = c.removeByKeys(keys);

      assertEqual({ removed: 0, ignored: 100 }, result);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief remove in collection with numeric keys
// //////////////////////////////////////////////////////////////////////////////

    testRemoveNumericKeys: function () {
      for (var i = 0; i < 100; ++i) {
        c.insert({ _key: String(i) });
      }

      // should have matches
      var result = c.removeByKeys([ '1', '2', '3', '0' ]);
      assertEqual({ removed: 4, ignored: 0 }, result);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief remove using invalid keys
// //////////////////////////////////////////////////////////////////////////////

    testRemoveInvalidKeys: function () {
      var result = c.removeByKeys([ ' ', '*  ', ' bfffff/\\&, ', '////.,;::' ]);

      assertEqual({ removed: 0, ignored: 4 }, result);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief remove in collection
// //////////////////////////////////////////////////////////////////////////////

    testRemove: function () {
      var keys = [ ];
      for (var i = 0; i < 1000; ++i) {
        c.insert({ _key: 'test' + i, value: i });
        keys.push('test' + i);
      }

      var result = c.removeByKeys(keys);
      assertEqual({ removed: 1000, ignored: 0 }, result);

      assertEqual(0, c.count());
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief remove in collection
// //////////////////////////////////////////////////////////////////////////////

    testRemoveTwice: function () {
      var keys = [ ];
      for (var i = 0; i < 1000; ++i) {
        c.insert({ _key: 'test' + i, value: i });
        keys.push('test' + i);
      }

      var result = c.removeByKeys(keys);
      assertEqual({ removed: 1000, ignored: 0 }, result);

      assertEqual(0, c.count());
      c.insert({ _key: 'test3' });
      c.insert({ _key: 'test1000' });

      result = c.removeByKeys(keys);
      assertEqual({ removed: 1, ignored: 999 }, result);

      assertEqual(1, c.count());
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief remove in collection
// //////////////////////////////////////////////////////////////////////////////

    testRemoveDuplicate: function () {
      var keys = [ ];
      for (var i = 0; i < 100; ++i) {
        c.insert({ _key: 'test' + i, value: i });
        // add same key twice
        keys.push('test' + i);
        keys.push('test' + i);
      }

      var result = c.removeByKeys(keys);
      assertEqual({ removed: 100, ignored: 100 }, result);

      assertEqual(0, c.count());
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief remove in collection
// //////////////////////////////////////////////////////////////////////////////

    testRemovePartial: function () {
      var keys = [ ];
      for (var i = 0; i < 2000; ++i) {
        c.insert({ _key: 'test' + i, value: i });

        if (i % 2 === 0) {
          keys.push('test' + i);
        }
      }

      // result should have been de-duplicated?
      var result = c.removeByKeys(keys);
      assertEqual({ removed: 1000, ignored: 0 }, result);

      assertEqual(1000, c.count());
      assertFalse(c.exists('test0'));
      assertTrue(c.exists('test1'));
      assertFalse(c.exists('test2'));
      assertTrue(c.exists('test3'));
      // ...
      assertFalse(c.exists('test1998'));
      assertTrue(c.exists('test1999'));
    }

  };
}

// //////////////////////////////////////////////////////////////////////////////
// / @brief test suite: skip and limit with a collection
// //////////////////////////////////////////////////////////////////////////////

function SimpleQueryArraySkipLimitSuite () {
  'use strict';
  var numbers = null;
  var query = null;

  return {

// //////////////////////////////////////////////////////////////////////////////
// / @brief set up
// //////////////////////////////////////////////////////////////////////////////

    setUp: function () {
      numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
      query = new SimpleQueryArray(numbers);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: skip
// //////////////////////////////////////////////////////////////////////////////

    testSkip: function () {
      var n = query.clone().skip(0).toArray();

      assertEqual(n, numbers);

      n = query.clone().skip(1).toArray();

      assertEqual(n, numbers.slice(1, 10));

      n = query.clone().skip(2).toArray();

      assertEqual(n, numbers.slice(2, 10));

      n = query.clone().skip(1).skip(1).toArray();

      assertEqual(n, numbers.slice(2, 10));

      n = query.clone().skip(10).toArray();

      assertEqual(n, []);

      n = query.clone().skip(11).toArray();

      assertEqual(n, []);

      n = query.clone().skip(9).toArray();

      assertEqual(n, [numbers[9]]);

      n = query.clone().skip(9).skip(1).toArray();

      assertEqual(n, []);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: limit
// //////////////////////////////////////////////////////////////////////////////

    testLimit: function () {
      var n = query.clone().limit(10).toArray();

      assertEqual(n, numbers);

      n = query.clone().limit(9).toArray();

      assertEqual(n, numbers.slice(0, 9));

      n = query.clone().limit(9).limit(8).limit(7).toArray();

      assertEqual(n, numbers.slice(0, 7));
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: skip and limit
// //////////////////////////////////////////////////////////////////////////////

    testSkipLimit: function () {
      var n = query.clone().skip(0).limit(10).toArray();

      assertEqual(n, numbers);

      n = query.clone().limit(10).skip(0).toArray();

      assertEqual(n, numbers);

      n = query.clone().limit(9).skip(1).toArray();

      assertEqual(n, numbers.slice(1, 9));

      n = query.clone().limit(9).skip(1).limit(7).toArray();

      assertEqual(n, numbers.slice(1, 8));

      n = query.clone().skip(-5).limit(3).toArray();

      assertEqual(n, numbers.slice(5, 8));

      n = query.clone().skip(-8).limit(7).skip(1).limit(4).toArray();

      assertEqual(n, numbers.slice(3, 7));

      n = query.clone().skip(-10).limit(9).skip(1).limit(7).toArray();

      assertEqual(n, numbers.slice(1, 8));
    }
  };
}

// //////////////////////////////////////////////////////////////////////////////
// / @brief test suite: skip and limit with a collection
// //////////////////////////////////////////////////////////////////////////////

function SimpleQueryAllSkipLimitSuite () {
  'use strict';
  var cn = 'UnitTestsCollectionSkipLimit';
  var collection = null;
  var numbers = null;
  var num = function (d) { return d.n; };

  return {

// //////////////////////////////////////////////////////////////////////////////
// / @brief set up
// //////////////////////////////////////////////////////////////////////////////

    setUp: function () {
      db._drop(cn);
      collection = db._create(cn, { waitForSync: false });

      for (var i = 0; i < 10; ++i) {
        collection.save({ n: i });
      }

      numbers = collection.all().toArray().map(num);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief tear down
// //////////////////////////////////////////////////////////////////////////////

    tearDown: function () {
      collection.drop();
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: skip
// //////////////////////////////////////////////////////////////////////////////

    testAllSkip: function () {
      var n = collection.all().skip(0).toArray().map(num);
      assertEqual(n, numbers);

      n = collection.all().skip(1).toArray().map(num);
      assertEqual(n, numbers.slice(1, 10));

      n = collection.all().skip(2).toArray().map(num);
      assertEqual(n, numbers.slice(2, 10));

      n = collection.all().skip(1).skip(1).toArray().map(num);
      assertEqual(n, numbers.slice(2, 10));

      n = collection.all().skip(10).toArray().map(num);
      assertEqual(n, []);

      n = collection.all().skip(11).toArray().map(num);
      assertEqual(n, []);

      n = collection.all().skip(9).toArray().map(num);
      assertEqual(n, [numbers[9]]);

      n = collection.all().skip(9).skip(1).toArray().map(num);
      assertEqual(n, []);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: limit
// //////////////////////////////////////////////////////////////////////////////

    testAllLimit: function () {
      var n = collection.all().limit(10).toArray().map(num);
      assertEqual(n, numbers);

      n = collection.all().limit(9).toArray().map(num);
      assertEqual(n, numbers.slice(0, 9));

      n = collection.all().limit(9).limit(8).limit(7).toArray().map(num);
      assertEqual(n, numbers.slice(0, 7));
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: skip and limit
// //////////////////////////////////////////////////////////////////////////////

    testAllSkipLimit: function () {
      var n = collection.all().skip(0).limit(10).toArray().map(num);
      assertEqual(n, numbers);

      n = collection.all().limit(10).skip(0).toArray().map(num);
      assertEqual(n, numbers);

      n = collection.all().limit(9).skip(1).toArray().map(num);
      assertEqual(n, numbers.slice(1, 9));

      n = collection.all().limit(9).skip(1).limit(7).toArray().map(num);
      assertEqual(n, numbers.slice(1, 8));
    }
  };
}

// //////////////////////////////////////////////////////////////////////////////
// / @brief test suite: query-by-example
// //////////////////////////////////////////////////////////////////////////////

function SimpleQueryByExampleSuite () {
  'use strict';
  var cn = 'UnitTestsCollectionByExample';
  var collection = null;
  var id = function (d) { return d._id; };

  return {

// //////////////////////////////////////////////////////////////////////////////
// / @brief set up
// //////////////////////////////////////////////////////////////////////////////

    setUp: function () {
      db._drop(cn);
      collection = db._create(cn);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief tear down
// //////////////////////////////////////////////////////////////////////////////

    tearDown: function () {
      collection.drop();
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample, using indexes
// //////////////////////////////////////////////////////////////////////////////

    testByExampleHash1: function () {
      var d, s;
      var example = { 'a': { 'b': true, 'c': 'foo' }, 'd': true };

      collection.ensureHashIndex('d');

      d = collection.save(example);
      s = collection.firstExample({ 'd': true });
      assertEqual(d._id, s._id);

      s = collection.firstExample({ 'd': false });
      assertNull(s);

      s = collection.firstExample({ 'a.b': true });
      assertEqual(d._id, s._id);

      s = collection.firstExample({ 'a.c': 'foo' });
      assertEqual(d._id, s._id);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample, using indexes
// //////////////////////////////////////////////////////////////////////////////

    testByExampleHash2: function () {
      var d1, d2, d4, s;
      var example1 = { 'a': { 'b': true } };
      var example2 = { 'a': { 'b': 'foo' } };
      var example3 = { 'a': { 'b': null } };
      var example4 = { 'c': 1 };

      collection.ensureHashIndex('a.b');

      d1 = collection.save(example1);
      d2 = collection.save(example2);
      collection.save(example3);
      d4 = collection.save(example4);

      s = collection.firstExample({ 'a.b': true });
      assertEqual(d1._id, s._id);
      s = collection.firstExample({ 'a.b': 'foo' });
      assertEqual(d2._id, s._id);
      s = collection.firstExample({ 'a.b': false });
      assertNull(s);
      s = collection.firstExample({ 'a.b': null });
      assertNotNull(s);
      s = collection.firstExample({ 'c': 1 });
      assertEqual(d4._id, s._id);

      s = collection.firstExample(example1);
      assertEqual(d1._id, s._id);
      s = collection.firstExample(example2);
      assertEqual(d2._id, s._id);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample, using indexes
// //////////////////////////////////////////////////////////////////////////////

    testByExampleSparseHash: function () {
      var d1, d2, d4, s;
      var example1 = { 'a': { 'b': true } };
      var example2 = { 'a': { 'b': 'foo' } };
      var example3 = { 'a': { 'b': null } };
      var example4 = { 'c': 1 };

      collection.ensureHashIndex('a.b', { sparse: true });

      d1 = collection.save(example1);
      d2 = collection.save(example2);
      collection.save(example3);
      d4 = collection.save(example4);

      s = collection.firstExample({ 'a.b': true });
      assertEqual(d1._id, s._id);
      s = collection.firstExample({ 'a.b': 'foo' });
      assertEqual(d2._id, s._id);
      s = collection.firstExample({ 'a.b': false });
      assertNull(s);
      s = collection.firstExample({ 'a.b': null });
      assertNotNull(s);
      s = collection.firstExample({ 'c': 1 });
      assertEqual(d4._id, s._id);

      s = collection.firstExample(example1);
      assertEqual(d1._id, s._id);
      s = collection.firstExample(example2);
      assertEqual(d2._id, s._id);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample, using indexes
// //////////////////////////////////////////////////////////////////////////////

    testByExampleSkiplist1: function () {
      var d, s;
      var example = { 'a': { 'b': true, 'c': 'foo' }, 'd': true };

      collection.ensureSkiplist('d');

      d = collection.save(example);
      s = collection.firstExample({ 'd': true });
      assertEqual(d._id, s._id);

      s = collection.firstExample({ 'd': false });
      assertNull(s);

      s = collection.firstExample({ 'a.b': true });
      assertEqual(d._id, s._id);

      s = collection.firstExample({ 'a.c': 'foo' });
      assertEqual(d._id, s._id);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample, using indexes
// //////////////////////////////////////////////////////////////////////////////

    testByExampleSkiplist2: function () {
      var d1, d2, d4, s;
      var example1 = { 'a': { 'b': true } };
      var example2 = { 'a': { 'b': 'foo' } };
      var example3 = { 'a': { 'b': null } };
      var example4 = { 'c': 1 };

      collection.ensureSkiplist('a.b');

      d1 = collection.save(example1);
      d2 = collection.save(example2);
      collection.save(example3);
      d4 = collection.save(example4);

      s = collection.firstExample({ 'a.b': true });
      assertEqual(d1._id, s._id);
      s = collection.firstExample({ 'a.b': 'foo' });
      assertEqual(d2._id, s._id);
      s = collection.firstExample({ 'a.b': false });
      assertNull(s);
      s = collection.firstExample({ 'a.b': null });
      assertNotNull(s);
      s = collection.firstExample({ 'c': 1 });
      assertEqual(d4._id, s._id);

      s = collection.firstExample(example1);
      assertEqual(d1._id, s._id);
      s = collection.firstExample(example2);
      assertEqual(d2._id, s._id);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample, using indexes
// //////////////////////////////////////////////////////////////////////////////

    testByExampleSparseSkiplist: function () {
      var d1, d2, d4, s;
      var example1 = { 'a': { 'b': true } };
      var example2 = { 'a': { 'b': 'foo' } };
      var example3 = { 'a': { 'b': null } };
      var example4 = { 'c': 1 };

      collection.ensureSkiplist('a.b', { sparse: true });

      d1 = collection.save(example1);
      d2 = collection.save(example2);
      collection.save(example3);
      d4 = collection.save(example4);

      s = collection.firstExample({ 'a.b': true });
      assertEqual(d1._id, s._id);
      s = collection.firstExample({ 'a.b': 'foo' });
      assertEqual(d2._id, s._id);
      s = collection.firstExample({ 'a.b': false });
      assertNull(s);
      s = collection.firstExample({ 'a.b': null });
      assertNotNull(s);
      s = collection.firstExample({ 'c': 1 });
      assertEqual(d4._id, s._id);

      s = collection.firstExample(example1);
      assertEqual(d1._id, s._id);
      s = collection.firstExample(example2);
      assertEqual(d2._id, s._id);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample
// //////////////////////////////////////////////////////////////////////////////

    testByExampleMultipleValues: function () {
      [ null, 1, 2, true, false, '1', '2', 'foo', 'barbazbark', [ ] ].forEach(function (v) {
        for (var i = 0; i < 5; ++i) {
          collection.save({ value: v });
        }

        var result = collection.byExample({ value: v }).toArray();
        assertEqual(5, result.length);
      });
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample
// //////////////////////////////////////////////////////////////////////////////

    testByExampleMultipleValuesHashIndex: function () {
      collection.ensureHashIndex('value');

      [ null, 1, 2, true, false, '1', '2', 'foo', 'barbazbark', [ ] ].forEach(function (v) {
        for (var i = 0; i < 5; ++i) {
          collection.save({ value: v });
        }

        var result = collection.byExample({ value: v }).toArray();
        assertEqual(5, result.length);
      });
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample
// //////////////////////////////////////////////////////////////////////////////

    testByExampleMultipleValuesSparseHashIndex: function () {
      collection.ensureHashIndex('value', { sparse: true });

      [ null, 1, 2, true, false, '1', '2', 'foo', 'barbazbark', [ ] ].forEach(function (v) {
        for (var i = 0; i < 5; ++i) {
          collection.save({ value: v });
        }

        var result = collection.byExample({ value: v }).toArray();
        assertEqual(5, result.length);
      });
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample
// //////////////////////////////////////////////////////////////////////////////

    testByExampleMultipleValuesSkiplist: function () {
      collection.ensureSkiplist('value');

      [ null, 1, 2, true, false, '1', '2', 'foo', 'barbazbark', [ ] ].forEach(function (v) {
        for (var i = 0; i < 5; ++i) {
          collection.save({ value: v });
        }

        var result = collection.byExample({ value: v }).toArray();
        assertEqual(5, result.length);
      });
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample
// //////////////////////////////////////////////////////////////////////////////

    testByExampleMultipleValuesSparseSkiplist: function () {
      collection.ensureSkiplist('value', { sparse: true });

      [ null, 1, 2, true, false, '1', '2', 'foo', 'barbazbark', [ ] ].forEach(function (v) {
        for (var i = 0; i < 5; ++i) {
          collection.save({ value: v });
        }

        var result = collection.byExample({ value: v }).toArray();
        assertEqual(5, result.length);
      });
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample, using _key
// //////////////////////////////////////////////////////////////////////////////

    testByExampleKey: function () {
      var d, s;

      d = collection.save({ _key: 'meow' });
      s = collection.firstExample({ _key: 'foo' });
      assertNull(s);

      s = collection.firstExample({ _key: 'meow' });
      assertEqual(d._id, s._id);
      assertEqual(d._key, s._key);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample, using _key & others
// //////////////////////////////////////////////////////////////////////////////

    testByExampleKeyMore: function () {
      var d, s;

      d = collection.save({ _key: 'meow' });
      s = collection.firstExample({ _key: 'meow', a: 1 });
      assertNull(s);

      d = collection.save({ _key: 'foo', a: 2 });
      s = collection.firstExample({ _key: 'foo', a: 2 });
      assertEqual(d._id, s._id);
      assertEqual(d._key, s._key);
      assertEqual(2, s.a);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample, using _rev
// //////////////////////////////////////////////////////////////////////////////

    testByExampleRev: function () {
      var d, s;

      d = collection.save({ _key: 'meow' });
      s = collection.firstExample({ _rev: d._rev });
      assertEqual(d._rev, s._rev);

      s = collection.firstExample({ _rev: 'foo' });
      assertNull(s);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample, using _rev
// //////////////////////////////////////////////////////////////////////////////

    testByExampleRevId: function () {
      var d, s;

      d = collection.save({ _key: 'meow' });
      s = collection.firstExample({ _rev: d._rev, _id: cn + '/meow' });
      assertEqual(d._rev, s._rev);

      s = collection.firstExample({ _rev: d._rev, _id: cn + '/foo' });
      assertNull(s);

      s = collection.firstExample({ _rev: 'foo', _id: cn + '/meow' });
      assertNull(s);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample, using _rev
// //////////////////////////////////////////////////////////////////////////////

    testByExampleRevMore: function () {
      var d, s;

      d = collection.save({ _key: 'meow', a: 1, b: 2 });
      s = collection.firstExample({ _rev: d._rev, b: 2, a: 1 });
      assertEqual(d._rev, s._rev);
      assertEqual('meow', s._key);

      s = collection.firstExample({ _rev: d._rev, a: 1 });
      assertEqual(d._rev, s._rev);
      assertEqual('meow', s._key);

      s = collection.firstExample({ _rev: d._rev, b: 2 });
      assertEqual(d._rev, s._rev);
      assertEqual('meow', s._key);

      s = collection.firstExample({ _rev: d._rev, a: 2 });
      assertNull(s);

      s = collection.firstExample({ _rev: d._rev, b: 1 });
      assertNull(s);

      s = collection.firstExample({ _rev: d._rev, a: 1, b: 3 });
      assertNull(s);

      s = collection.firstExample({ _rev: 'foo', a: 1 });
      assertNull(s);

      s = collection.firstExample({ _rev: 'foo', b: 2 });
      assertNull(s);

      s = collection.firstExample({ _rev: 'foo', a: 1, b: 2 });
      assertNull(s);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample, using _id
// //////////////////////////////////////////////////////////////////////////////

    testByExampleId: function () {
      var d, s;

      d = collection.save({ _key: 'meow' });
      s = collection.firstExample({ _id: cn + '/foo' });
      assertNull(s);

      s = collection.firstExample({ _id: cn + '/meow' });
      assertEqual(d._id, s._id);
      assertEqual(d._key, s._key);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample, using _id & others
// //////////////////////////////////////////////////////////////////////////////

    testByExampleIdMore: function () {
      var d, s;

      d = collection.save({ _key: 'meow' });
      s = collection.firstExample({ _id: cn + '/meow', a: 1 });
      assertEqual(null, s);

      d = collection.save({ _key: 'foo', a: 2 });
      s = collection.firstExample({ _id: cn + '/foo', a: 2 });
      assertEqual(d._id, s._id);
      assertEqual(d._key, s._key);
      assertEqual(2, s.a);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample, using _id & sub-attributes
// //////////////////////////////////////////////////////////////////////////////

    testByExampleIdSubAttributes: function () {
      var d, s;

      d = collection.save({ _key: 'meow', foo: { bar: 'baz' } });
      s = collection.firstExample({ _id: cn + '/meow', foo: { bar: 'baz' } });
      assertEqual(d._id, s._id);
      assertEqual(d._key, s._key);
      assertEqual({ bar: 'baz' }, s.foo);

      d = collection.save({ _key: 'foo', values: [ { foo: 'bar', baz: 'bam' } ] });
      s = collection.firstExample({ _id: cn + '/foo', values: [ { foo: 'bar', baz: 'bam' } ] });
      assertEqual(d._id, s._id);
      assertEqual(d._key, s._key);
      assertEqual([ { foo: 'bar', baz: 'bam' } ], s.values);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample, using non existing system attribute
// //////////////////////////////////////////////////////////////////////////////

    testByExampleNonExisting: function () {
      var s;

      collection.save({ _key: 'meow' });
      s = collection.firstExample({ _foo: 'foo' });
      assertEqual(null, s);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample
// //////////////////////////////////////////////////////////////////////////////

    testByExampleObject: function () {
      var d1 = collection.save({ i: 1 });
      var d2 = collection.save({ i: 1, a: { j: 1 } });
      var d3 = collection.save({ i: 1, a: { j: 1, k: 1 } });
      var d4 = collection.save({ i: 1, a: { j: 2, k: 2 } });
      var d5 = collection.save({ i: 2 });
      var d6 = collection.save({ i: 2, a: 2 });
      var d7 = collection.save({ i: 2, a: { j: 2, k: 2 } });
      var s;

      s = collection.byExample({ i: 1 }).toArray().map(id).sort();
      assertEqual([d1._id, d2._id, d3._id, d4._id].sort(), s);

      s = collection.byExample({ i: 2 }).toArray().map(id).sort();
      assertEqual([d5._id, d6._id, d7._id].sort(), s);

      s = collection.byExample({ a: { j: 1 } }).toArray().map(id).sort();
      assertEqual([d2._id], s);

      s = collection.byExample({ 'a.j': 1 }).toArray().map(id).sort();
      assertEqual([d2._id, d3._id].sort(), s);

      s = collection.byExample({ i: 2, 'a.k': 2 }).toArray().map(id).sort();
      assertEqual([d7._id], s);

      s = collection.firstExample({ 'i': 2, 'a.k': 2 });
      assertEqual(d7._id, s._id);

      s = collection.firstExample({ 'i': 2, 'a.k': 27 });
      assertEqual(null, s);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample
// //////////////////////////////////////////////////////////////////////////////

    testByExampleList: function () {
      var d1 = collection.save({ i: 1 });
      var d2 = collection.save({ i: 1, a: { j: 1 } });
      var d3 = collection.save({ i: 1, a: { j: 1, k: 1 } });
      var d4 = collection.save({ i: 1, a: { j: 2, k: 2 } });
      var d5 = collection.save({ i: 2 });
      var d6 = collection.save({ i: 2, a: 2 });
      var d7 = collection.save({ i: 2, a: { j: 2, k: 2 } });
      var s;

      s = collection.byExample('i', 1).toArray().map(id).sort();
      assertEqual([d1._id, d2._id, d3._id, d4._id].sort(), s);

      s = collection.byExample('i', 2).toArray().map(id).sort();
      assertEqual([d5._id, d6._id, d7._id].sort(), s);

      s = collection.byExample('a', { j: 1 }).toArray().map(id).sort();
      assertEqual([d2._id], s);

      s = collection.byExample('a.j', 1).toArray().map(id).sort();
      assertEqual([d2._id, d3._id].sort(), s);

      s = collection.byExample('i', 2, 'a.k', 2).toArray().map(id).sort();
      assertEqual([d7._id], s);

      s = collection.firstExample('i', 2, 'a.k', 2);
      assertEqual(d7._id, s._id);

      s = collection.firstExample('i', 2, 'a.k', 27);
      assertEqual(null, s);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: removeByExample
// //////////////////////////////////////////////////////////////////////////////

    testRemoveByExample: function () {
      var deleted;

      for (var i = 0; i < 50; ++i) {
        collection.save({ value: i });
      }

      deleted = collection.removeByExample({ value: 2 });
      assertEqual(1, deleted);

      deleted = collection.removeByExample({ value: 2 });
      assertEqual(0, deleted);

      deleted = collection.removeByExample({ value: 20 });
      assertEqual(1, deleted);

      deleted = collection.removeByExample({ value: 20 });
      assertEqual(0, deleted);

      deleted = collection.removeByExample({ value: 1 });
      assertEqual(1, deleted);

      // not existing documents
      deleted = collection.removeByExample({ value: 50 });
      assertEqual(0, deleted);

      deleted = collection.removeByExample({ value: null });
      assertEqual(0, deleted);

      deleted = collection.removeByExample({ value: '5' });
      assertEqual(0, deleted);

      deleted = collection.removeByExample({ peter: 'meow' });
      assertEqual(0, deleted);

      collection.truncate({ compact: false });
      deleted = collection.removeByExample({ value: 4 });
      assertEqual(0, deleted);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: removeByExample with new signature
// //////////////////////////////////////////////////////////////////////////////

    testRemoveByExampleWithNewSignature: function () {
      var deleted;

      collection.save({ b: 1, value: 2222 });

      for (var i = 0; i < 50; ++i) {
        collection.save({ a: 1, value: i });
      }
      // test default parameter
      deleted = collection.removeByExample({ b: 1 });
      assertEqual(1, deleted);

      deleted = collection.removeByExample({ a: 1 }, {limit: 10});
      assertEqual(10, deleted);

      deleted = collection.removeByExample({ a: 1 }, {waitForSync: true, limit: 15});
      assertEqual(15, deleted);

      // not existing documents
      deleted = collection.removeByExample({ value: 500 });
      assertEqual(0, deleted);

      deleted = collection.removeByExample({ value: null });
      assertEqual(0, deleted);

      deleted = collection.removeByExample({ value: '5' });
      assertEqual(0, deleted);

      deleted = collection.removeByExample({ peter: 'meow' });
      assertEqual(0, deleted);

      collection.truncate({ compact: false });
      deleted = collection.removeByExample({ value: 4 });
      assertEqual(0, deleted);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: removeByExample
// //////////////////////////////////////////////////////////////////////////////

    testRemoveByExampleMult: function () {
      var deleted;

      for (var i = 0; i < 5; ++i) {
        for (var j = 0; j < 5; ++j) {
          collection.save({ value1: i, value2: j });
        }
      }

      deleted = collection.removeByExample({ value2: 2 });
      assertEqual(5, deleted);

      deleted = collection.removeByExample({ value2: 2 });
      assertEqual(0, deleted);

      deleted = collection.removeByExample({ value1: 4 });
      assertEqual(4, deleted);

      deleted = collection.removeByExample({ value1: 4 });
      assertEqual(0, deleted);

      // not existing documents
      deleted = collection.removeByExample({ value1: 99 });
      assertEqual(0, deleted);

      deleted = collection.removeByExample({ value1: '0' });
      assertEqual(0, deleted);

      deleted = collection.removeByExample({ meow: 1 });
      assertEqual(0, deleted);

      deleted = collection.removeByExample({ meow: 'peter' });
      assertEqual(0, deleted);

      collection.truncate({ compact: false });
      deleted = collection.removeByExample({ value1: 3 });
      assertEqual(0, deleted);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: removeByExample
// //////////////////////////////////////////////////////////////////////////////

    testRemoveByExampleLimit: function () {
      var deleted;

      for (var i = 0; i < 50; ++i) {
        collection.save({ value: 1 });
      }

      deleted = collection.removeByExample({ value: 1 }, false, 10);
      assertEqual(10, deleted);

      assertEqual(40, collection.count());

      deleted = collection.removeByExample({ value: 1 }, false, 20);
      assertEqual(20, deleted);

      assertEqual(20, collection.count());

      deleted = collection.removeByExample({ value: 1 }, false, 20);
      assertEqual(20, deleted);

      assertEqual(0, collection.count());

      deleted = collection.removeByExample({ value: 1 }, false, 20);
      assertEqual(0, deleted);

      assertEqual(0, collection.count());
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: replaceByExample
// //////////////////////////////////////////////////////////////////////////////

    testReplaceByExample: function () {
      var replaced;

      for (var i = 0; i < 50; ++i) {
        collection.save({ value: i });
      }

      replaced = collection.replaceByExample({ value: 2 }, { foo: 'bar', bar: 'baz' });
      assertEqual(1, replaced);

      assertEqual(50, collection.count());

      var doc = collection.firstExample({ foo: 'bar', bar: 'baz' });
      assertEqual('bar', doc.foo);
      assertEqual('baz', doc.bar);
      assertEqual(undefined, doc.value);

      // not existing documents
      replaced = collection.replaceByExample({ meow: true }, { });

      assertEqual(0, replaced);

      replaced = collection.replaceByExample({ value: 142 }, { });
      assertEqual(0, replaced);

      replaced = collection.replaceByExample({ value: 'peng!' }, { });
      assertEqual(0, replaced);

      collection.truncate({ compact: false });
      replaced = collection.replaceByExample({ value: 6 }, { });
      assertEqual(0, replaced);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: replaceByExampleWithNewSignature
// //////////////////////////////////////////////////////////////////////////////

    testReplaceByExampleWithNewSignature: function () {
      var replaced;

      for (var i = 0; i < 50; ++i) {
        collection.save({ value: 2, a: i, b: i + 1 });
      }

      replaced = collection.replaceByExample({ value: 2 },
                                             { foo: 'bar', bar: 'baz' },
                                             {limit: 20, waitForSync: true});
      assertEqual(20, replaced);

      assertEqual(50, collection.count());

      var doc = collection.firstExample({ foo: 'bar', bar: 'baz' });
      assertEqual('bar', doc.foo);
      assertEqual('baz', doc.bar);
      assertEqual(undefined, doc.value);
      assertEqual(undefined, doc.a);
      assertEqual(undefined, doc.b);

      // not existing documents
      replaced = collection.replaceByExample({ meow: true }, { });
      assertEqual(0, replaced);

      replaced = collection.replaceByExample({ value: 142 }, { });
      assertEqual(0, replaced);

      replaced = collection.replaceByExample({ value: 'peng!' }, { });
      assertEqual(0, replaced);

      collection.truncate({ compact: false });
      replaced = collection.replaceByExample({ value: 6 }, { });
      assertEqual(0, replaced);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: replaceByExample
// //////////////////////////////////////////////////////////////////////////////

    testReplaceByExampleLimit: function () {
      var replaced, docs;

      for (var i = 0; i < 50; ++i) {
        collection.save({ value: 1 });
      }

      replaced = collection.replaceByExample({ value: 1 }, { foo: 'bar', bar: 'baz' }, false, 10);
      assertEqual(10, replaced);

      assertEqual(50, collection.count());

      docs = collection.byExample({ foo: 'bar', bar: 'baz' }).toArray();
      assertEqual(10, docs.length);
      docs = collection.byExample({ value: 1 }).toArray();
      assertEqual(40, docs.length);

      replaced = collection.replaceByExample({ value: 1 }, { meow: false }, false, 15);
      assertEqual(15, replaced);

      assertEqual(50, collection.count());

      docs = collection.byExample({ foo: 'bar', bar: 'baz' }).toArray();
      assertEqual(10, docs.length);
      docs = collection.byExample({ meow: false }).toArray();
      assertEqual(15, docs.length);
      docs = collection.byExample({ value: 1 }).toArray();
      assertEqual(25, docs.length);

      // not existing documents
      replaced = collection.replaceByExample({ meow: true }, { }, false, 99);
      assertEqual(0, replaced);

      replaced = collection.replaceByExample({ value: 42 }, { }, false, 99);
      assertEqual(0, replaced);

      replaced = collection.replaceByExample({ value: 'peng!' }, { }, false, 99);
      assertEqual(0, replaced);

      // check counts
      docs = collection.byExample({ foo: 'bar', bar: 'baz' }).toArray();
      assertEqual(10, docs.length);
      docs = collection.byExample({ meow: false }).toArray();
      assertEqual(15, docs.length);
      docs = collection.byExample({ value: 1 }).toArray();
      assertEqual(25, docs.length);

      collection.truncate({ compact: false });
      replaced = collection.replaceByExample({ value: 1 }, { }, false);
      assertEqual(0, replaced);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: updateByExample
// //////////////////////////////////////////////////////////////////////////////

    testUpdateByExample: function () {
      var updated;

      for (var i = 0; i < 50; ++i) {
        collection.save({ value: i });
      }

      // update and keep old values
      updated = collection.updateByExample({ value: 2 }, { foo: 'bar', bar: 'baz' });
      assertEqual(1, updated);

      assertEqual(50, collection.count());

      var doc = collection.firstExample({ foo: 'bar', bar: 'baz' });
      assertEqual('bar', doc.foo);
      assertEqual('baz', doc.bar);
      assertEqual(2, doc.value);

      // update and remove old values
      updated = collection.updateByExample({ value: 5 }, { foo: 'bart', bar: 'baz', value: null }, false);
      assertEqual(1, updated);

      doc = collection.firstExample({ foo: 'bart', bar: 'baz' });
      assertEqual('bart', doc.foo);
      assertEqual('baz', doc.bar);
      assertEqual(undefined, doc.value);

      // update and overwrite old values
      updated = collection.updateByExample({ value: 17 }, { foo: 'barw', bar: 'baz', value: 9 }, false);
      assertEqual(1, updated);

      doc = collection.firstExample({ foo: 'barw', bar: 'baz' });
      assertEqual('barw', doc.foo);
      assertEqual('baz', doc.bar);
      assertEqual(9, doc.value);

      // not existing documents
      updated = collection.updateByExample({ meow: true }, { });
      assertEqual(0, updated);

      updated = collection.updateByExample({ value: 142 }, { });
      assertEqual(0, updated);

      updated = collection.updateByExample({ value: 'peng!' }, { });
      assertEqual(0, updated);

      collection.truncate({ compact: false });
      updated = collection.updateByExample({ value: 6 }, { });
      assertEqual(0, updated);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: updateByExample with new Signature
// //////////////////////////////////////////////////////////////////////////////

    testUpdateByExampleWithNewSignature: function () {
      var updated;

      for (var i = 0; i < 50; ++i) {
        collection.save({
          value: i,
          a: 1
        });
      }

      // update and keep old values
      updated = collection.updateByExample({ value: 2 }, { foo: 'bar', bar: 'baz' });
      assertEqual(1, updated);

      assertEqual(50, collection.count());

      var doc = collection.firstExample({ foo: 'bar', bar: 'baz' });
      assertEqual('bar', doc.foo);
      assertEqual('baz', doc.bar);
      assertEqual(2, doc.value);

      // update and remove old values
      updated = collection.updateByExample({ value: 5 },
                                           { foo: 'bart', bar: 'baz', value: null },
                                           {keepNull: false});
      assertEqual(1, updated);

      doc = collection.firstExample({ foo: 'bart', bar: 'baz' });
      assertEqual('bart', doc.foo);
      assertEqual('baz', doc.bar);
      assertEqual(undefined, doc.value);

      // update and overwrite old values
      updated = collection.updateByExample({ value: 17 }, { foo: 'barw', bar: 'baz', value: 9 }, {keepNull: false});
      assertEqual(1, updated);

      doc = collection.firstExample({ foo: 'barw', bar: 'baz' });
      assertEqual('barw', doc.foo);
      assertEqual('baz', doc.bar);
      assertEqual(9, doc.value);

      // update and remove old values keep null values
      updated = collection.updateByExample({ value: 6 },
                                           { foo: 'bart6', bar: 'baz6', value: null },
                                           {keepNull: true});
      assertEqual(1, updated);

      doc = collection.firstExample({ foo: 'bart6', bar: 'baz6' });
      assertEqual('bart6', doc.foo);
      assertEqual('baz6', doc.bar);
      assertEqual(null, doc.value);

      // not existing documents
      updated = collection.updateByExample({ meow: true }, { });
      assertEqual(0, updated);

      updated = collection.updateByExample({ nonExistentValue: 'foo' }, { });
      assertEqual(0, updated);

      collection.truncate({ compact: false });
      updated = collection.updateByExample({ value: 6 }, { });
      assertEqual(0, updated);

      for (i = 0; i < 50; ++i) {
        collection.save({
          test: i,
          limitTest: 1
        });
      }
      // update and remove old values keep null values
      updated = collection.updateByExample(
        { limitTest: 1 },
        { foo: 'bart', bar: 'baz', value: null },
        {keepNull: true, limit: 30});
      assertEqual(30, updated);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: updateByExample
// //////////////////////////////////////////////////////////////////////////////

    testUpdateByExampleLimit: function () {
      var updated, docs;

      for (var i = 0; i < 50; ++i) {
        collection.save({ value: 1 });
      }

      // update some, keep old values
      updated = collection.updateByExample({ value: 1 }, { foo: 'bar', bar: 'baz' }, false, false, 10);
      assertEqual(10, updated);

      assertEqual(50, collection.count());

      docs = collection.byExample({ foo: 'bar', bar: 'baz' }).toArray();
      assertEqual(10, docs.length);
      docs = collection.byExample({ value: 1 }).toArray();
      assertEqual(50, docs.length);

      // update some others
      updated = collection.updateByExample({ value: 1 }, { meow: false }, false, false, 15);
      assertEqual(15, updated);

      assertEqual(50, collection.count());

      docs = collection.byExample({ foo: 'bar', bar: 'baz' }).toArray();
      assertEqual(10, docs.length);
      docs = collection.byExample({ meow: false }).toArray();
      assertEqual(15, docs.length);
      docs = collection.byExample({ value: 1 }).toArray();
      assertEqual(50, docs.length);

      // update some, remove old values
      updated = collection.updateByExample({ value: 1 }, { value: null, fox: true }, false, false, 5);
      assertEqual(5, updated);

      assertEqual(50, collection.count());

      docs = collection.byExample({ fox: true }).toArray();
      assertEqual(5, docs.length);
      docs = collection.byExample({ value: 1 }).toArray();
      assertEqual(45, docs.length);

      // update some, overwrite old values
      updated = collection.updateByExample({ value: 1 }, { value: 16 }, false, false, 10);
      assertEqual(10, updated);

      assertEqual(50, collection.count());

      docs = collection.byExample({ value: 16 }).toArray();
      assertEqual(10, docs.length);
      docs = collection.byExample({ fox: true }).toArray();
      assertEqual(5, docs.length);
      docs = collection.byExample({ value: 1 }).toArray();
      assertEqual(35, docs.length);

      // not existing documents
      updated = collection.updateByExample({ meow: true }, { }, false, false, 99);
      assertEqual(0, updated);

      updated = collection.updateByExample({ value: 42 }, { }, false, false, 99);
      assertEqual(0, updated);

      updated = collection.updateByExample({ value: 'peng!' }, { }, false, false, 99);
      assertEqual(0, updated);

      collection.truncate({ compact: false });
      updated = collection.updateByExample({ value: 1 }, { });
      assertEqual(0, updated);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: updateByExample, mergeObjects
// //////////////////////////////////////////////////////////////////////////////

    testUpdateByExampleMergeObjectsSameUnspecified: function () {
      var updated;

      collection.save({ _key: 'one', value: { foo: 'test' } });

      // update don't specify mergeObjects behavior
      updated = collection.updateByExample({ value: { foo: 'test' } }, { value: { foo: 'baz' } });
      assertEqual(1, updated);

      var doc = collection.document('one');
      assertEqual({ foo: 'baz' }, doc.value);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: updateByExample, mergeObjects
// //////////////////////////////////////////////////////////////////////////////

    testUpdateByExampleMergeObjectsUnspecified: function () {
      var updated;

      collection.save({ _key: 'one', value: { foo: 'test' } });

      // update don't specify mergeObjects behavior
      updated = collection.updateByExample({ value: { foo: 'test' } },
                                           { value: { bar: 'baz' } });
      assertEqual(1, updated);

      var doc = collection.document('one');
      assertEqual({ foo: 'test', bar: 'baz' }, doc.value);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: updateByExample, mergeObjects
// //////////////////////////////////////////////////////////////////////////////

    testUpdateByExampleMergeObjectsTrue: function () {
      var updated;

      collection.save({ _key: 'one', value: { foo: 'test' } });

      // update don't specify mergeObjects behavior
      updated = collection.updateByExample({ value: { foo: 'test' } },
                                           { value: { bar: 'baz' } },
                                           { mergeObjects: true });
      assertEqual(1, updated);

      var doc = collection.document('one');
      assertEqual({ foo: 'test', bar: 'baz' }, doc.value);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: updateByExample, mergeObjects
// //////////////////////////////////////////////////////////////////////////////

    testUpdateByExampleMergeObjectsFalse: function () {
      var updated;

      collection.save({ _key: 'one', value: { foo: 'test' } });

      // update don't specify mergeObjects behavior
      updated = collection.updateByExample({ value: { foo: 'test' } },
                                           { value: { bar: 'baz' } },
                                           { mergeObjects: false });
      assertEqual(1, updated);

      var doc = collection.document('one');
      assertEqual({ bar: 'baz' }, doc.value);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: updateByExample, mergeObjects
// //////////////////////////////////////////////////////////////////////////////

    testUpdateByExampleMergeObjectsEmptyObject: function () {
      var updated;

      collection.save({ _key: 'one', value: { foo: 'test' } });

      // update don't specify mergeObjects behavior
      updated = collection.updateByExample({ value: { foo: 'test' } }, { value: { } });
      assertEqual(1, updated);

      var doc = collection.document('one');
      assertEqual({ foo: 'test' }, doc.value);
    }
  };
}

// //////////////////////////////////////////////////////////////////////////////
// / @brief test suite: query-by-example
// //////////////////////////////////////////////////////////////////////////////

function SimpleQueryByExampleEdgeSuite () {
  'use strict';
  var cn = 'UnitTestsCollectionByExample';
  var c1 = 'UnitTestsCollectionByExampleEdge';
  var collection = null;
  var edge = null;

  return {

// //////////////////////////////////////////////////////////////////////////////
// / @brief set up
// //////////////////////////////////////////////////////////////////////////////

    setUp: function () {
      db._drop(cn);
      db._drop(c1);
      collection = db._create(cn);
      edge = db._createEdgeCollection(c1);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief tear down
// //////////////////////////////////////////////////////////////////////////////

    tearDown: function () {
      collection.drop();
      edge.drop();
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample, using edge index
// //////////////////////////////////////////////////////////////////////////////

    testByExampleEdgeFrom: function () {
      edge.save(cn + '/foo', cn + '/bar', { _key: 'e1', foo: 'bar' });
      edge.save(cn + '/bar', cn + '/foo', { _key: 'e2', bar: 'foo' });

      var doc;
      doc = edge.firstExample({ _from: cn + '/foo' });
      assertEqual(c1 + '/e1', doc._id);
      assertEqual('e1', doc._key);
      assertEqual('bar', doc.foo);
      assertEqual(cn + '/foo', doc._from);
      assertEqual(cn + '/bar', doc._to);

      doc = edge.firstExample({ _from: cn + '/barbaz' });
      assertNull(doc);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample, using edge index
// //////////////////////////////////////////////////////////////////////////////

    testByExampleEdgeFromMore: function () {
      edge.save(cn + '/foo', cn + '/bar', { _key: 'e1', foo: 'bar' });
      edge.save(cn + '/bar', cn + '/foo', { _key: 'e2', bar: 'foo' });

      var doc;
      doc = edge.firstExample({ _from: cn + '/foo', foo: 'bar' });
      assertEqual(c1 + '/e1', doc._id);
      assertEqual('e1', doc._key);
      assertEqual('bar', doc.foo);
      assertEqual(cn + '/foo', doc._from);
      assertEqual(cn + '/bar', doc._to);

      doc = edge.firstExample({ _from: cn + '/foo', foo: 'baz' });
      assertNull(doc);

      doc = edge.firstExample({ _from: cn + '/foo', bar: 'foo' });
      assertNull(doc);

      doc = edge.firstExample({ _from: cn + '/foo', boo: 'far' });
      assertNull(doc);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample, using edge index
// //////////////////////////////////////////////////////////////////////////////

    testByExampleEdgeTo: function () {
      edge.save(cn + '/foo', cn + '/bar', { _key: 'e1', foo: 'bar' });
      edge.save(cn + '/bar', cn + '/foo', { _key: 'e2', bar: 'foo' });

      var doc;
      doc = edge.firstExample({ _to: cn + '/foo' });
      assertEqual(c1 + '/e2', doc._id);
      assertEqual('e2', doc._key);
      assertEqual('foo', doc.bar);
      assertEqual(cn + '/bar', doc._from);
      assertEqual(cn + '/foo', doc._to);

      doc = edge.firstExample({ _to: cn + '/bart' });
      assertNull(doc);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample, using edge index
// //////////////////////////////////////////////////////////////////////////////

    testByExampleEdgeToMore: function () {
      edge.save(cn + '/foo', cn + '/bar', { _key: 'e1', foo: 'bar' });
      edge.save(cn + '/bar', cn + '/foo', { _key: 'e2', bar: 'foo' });

      var doc;
      doc = edge.firstExample({ _to: cn + '/foo', bar: 'foo' });
      assertEqual(c1 + '/e2', doc._id);
      assertEqual('e2', doc._key);
      assertEqual('foo', doc.bar);
      assertEqual(cn + '/bar', doc._from);
      assertEqual(cn + '/foo', doc._to);

      doc = edge.firstExample({ _to: cn + '/foo', bar: 'baz' });
      assertNull(doc);

      doc = edge.firstExample({ _to: cn + '/foo', foo: 'bar' });
      assertNull(doc);

      doc = edge.firstExample({ _to: cn + '/foo', boo: 'far' });
      assertNull(doc);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample, using edge index
// //////////////////////////////////////////////////////////////////////////////

    testByExampleEdgeFromTo: function () {
      edge.save(cn + '/foo', cn + '/bar', { _key: 'e1', foo: 'bar' });
      edge.save(cn + '/bar', cn + '/foo', { _key: 'e2', bar: 'foo' });

      var doc;
      doc = edge.firstExample({ _to: cn + '/foo', _from: cn + '/bar' });
      assertEqual(c1 + '/e2', doc._id);
      assertEqual('e2', doc._key);
      assertEqual('foo', doc.bar);
      assertEqual(cn + '/bar', doc._from);
      assertEqual(cn + '/foo', doc._to);

      doc = edge.firstExample({ _to: cn + '/foo', _from: cn + '/baz' });
      assertNull(doc);

      doc = edge.firstExample({ _to: cn + '/bar', _from: cn + '/bar' });
      assertNull(doc);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: byExample, using edge index
// //////////////////////////////////////////////////////////////////////////////

    testByExampleEdgeFromToMore: function () {
      edge.save(cn + '/foo', cn + '/bar', { _key: 'e1', foo: 'bar' });
      edge.save(cn + '/bar', cn + '/foo', { _key: 'e2', bar: 'foo' });

      var doc;
      doc = edge.firstExample({ _to: cn + '/foo', _from: cn + '/bar', bar: 'foo' });
      assertEqual(c1 + '/e2', doc._id);
      assertEqual('e2', doc._key);
      assertEqual('foo', doc.bar);
      assertEqual(cn + '/bar', doc._from);
      assertEqual(cn + '/foo', doc._to);

      doc = edge.firstExample({ _to: cn + '/foo', _from: cn + '/baz', bar: 'baz' });
      assertNull(doc);

      doc = edge.firstExample({ _to: cn + '/foo', _from: cn + '/baz', foo: 'bar' });
      assertNull(doc);

      doc = edge.firstExample({ _to: cn + '/bar', _from: cn + '/bar', boo: 'far' });
      assertNull(doc);
    }

  };
}

// //////////////////////////////////////////////////////////////////////////////
// / @brief test suite: range
// //////////////////////////////////////////////////////////////////////////////

function SimpleQueryRangeSuite () {
  'use strict';
  var cn = 'UnitTestsCollectionRange';
  var collection = null;
  var age = function (d) { return d.age; };
  var ageSort = function (l, r) { if (l !== r) { if (l < r) { return -1; } return 1; } return 0; };

  return {

// //////////////////////////////////////////////////////////////////////////////
// / @brief set up
// //////////////////////////////////////////////////////////////////////////////

    setUp: function () {
      db._drop(cn);
      collection = db._create(cn);

      for (var i = 0; i < 100; ++i) {
        collection.save({ age: i });
      }

      collection.ensureSkiplist('age');
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief tear down
// //////////////////////////////////////////////////////////////////////////////

    tearDown: function () {
      collection.drop();
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: range
// //////////////////////////////////////////////////////////////////////////////

    testRange: function () {
      var l = collection.range('age', 10, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 10, 11, 12 ], l);

      l = collection.closedRange('age', 10, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 10, 11, 12, 13 ], l);

      l = collection.range('age', null, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ], l);

      l = collection.closedRange('age', null, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 ], l);
    }
  };
}

// //////////////////////////////////////////////////////////////////////////////
// / @brief test suite: range
// //////////////////////////////////////////////////////////////////////////////

function SimpleQuerySparseRangeSuite () {
  'use strict';
  var cn = 'UnitTestsCollectionRange';
  var collection = null;
  var age = function (d) { return d.age; };
  var ageSort = function (l, r) { if (l !== r) { if (l < r) { return -1; } return 1; } return 0; };

  return {

// //////////////////////////////////////////////////////////////////////////////
// / @brief set up
// //////////////////////////////////////////////////////////////////////////////

    setUp: function () {
      db._drop(cn);
      collection = db._create(cn);

      for (var i = 0; i < 100; ++i) {
        collection.save({ age: i });
      }

      collection.ensureSkiplist('age', { sparse: true });
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief tear down
// //////////////////////////////////////////////////////////////////////////////

    tearDown: function () {
      collection.drop();
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: range
// //////////////////////////////////////////////////////////////////////////////

    testSparseRange: function () {
      var l = collection.range('age', 10, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 10, 11, 12 ], l);

      l = collection.closedRange('age', 10, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 10, 11, 12, 13 ], l);

      l = collection.range('age', null, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ], l);

      l = collection.closedRange('age', null, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 ], l);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: range
// //////////////////////////////////////////////////////////////////////////////

    testSparseRangeMultipleIndexes: function () {
      // now we have a sparse and a non-sparse index
      collection.ensureSkiplist('age', { sparse: false });

      var l = collection.range('age', 10, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 10, 11, 12 ], l);

      l = collection.closedRange('age', 10, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 10, 11, 12, 13 ], l);

      l = collection.range('age', null, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ], l);

      l = collection.closedRange('age', null, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 ], l);
    }

  };
}

// //////////////////////////////////////////////////////////////////////////////
// / @brief test suite: range
// //////////////////////////////////////////////////////////////////////////////

function SimpleQueryUniqueRangeSuite () {
  'use strict';
  var cn = 'UnitTestsCollectionRange';
  var collection = null;
  var age = function (d) { return d.age; };
  var ageSort = function (l, r) { if (l !== r) { if (l < r) { return -1; } return 1; } return 0; };

  return {

// //////////////////////////////////////////////////////////////////////////////
// / @brief set up
// //////////////////////////////////////////////////////////////////////////////

    setUp: function () {
      db._drop(cn);
      collection = db._create(cn);

      for (var i = 0; i < 100; ++i) {
        collection.save({ age: i });
      }

      collection.ensureUniqueSkiplist('age');
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief tear down
// //////////////////////////////////////////////////////////////////////////////

    tearDown: function () {
      collection.drop();
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: range
// //////////////////////////////////////////////////////////////////////////////

    testUniqueRange: function () {
      var l = collection.range('age', 10, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 10, 11, 12 ], l);

      l = collection.closedRange('age', 10, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 10, 11, 12, 13 ], l);

      l = collection.range('age', null, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ], l);

      l = collection.closedRange('age', null, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 ], l);
    }
  };
}

// //////////////////////////////////////////////////////////////////////////////
// / @brief test suite: range
// //////////////////////////////////////////////////////////////////////////////

function SimpleQueryUniqueSparseRangeSuite () {
  'use strict';
  var cn = 'UnitTestsCollectionRange';
  var collection = null;
  var age = function (d) { return d.age; };
  var ageSort = function (l, r) { if (l !== r) { if (l < r) { return -1; } return 1; } return 0; };

  return {

// //////////////////////////////////////////////////////////////////////////////
// / @brief set up
// //////////////////////////////////////////////////////////////////////////////

    setUp: function () {
      db._drop(cn);
      collection = db._create(cn);

      for (var i = 0; i < 100; ++i) {
        collection.save({ age: i });
      }

      collection.ensureUniqueSkiplist('age', { sparse: true });
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief tear down
// //////////////////////////////////////////////////////////////////////////////

    tearDown: function () {
      collection.drop();
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: range
// //////////////////////////////////////////////////////////////////////////////

    testUniqueSparseRange: function () {
      var l = collection.range('age', 10, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 10, 11, 12 ], l);

      l = collection.closedRange('age', 10, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 10, 11, 12, 13 ], l);

      l = collection.range('age', null, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ], l);

      l = collection.closedRange('age', null, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 ], l);
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: range
// //////////////////////////////////////////////////////////////////////////////

    testUniqueSparseRangeMultipleIndexes: function () {
      // now we have a sparse and a non-sparse index
      collection.ensureUniqueSkiplist('age', { sparse: false });

      var l = collection.range('age', 10, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 10, 11, 12 ], l);

      l = collection.closedRange('age', 10, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 10, 11, 12, 13 ], l);

      l = collection.range('age', null, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ], l);

      l = collection.closedRange('age', null, 13).toArray().map(age).sort(ageSort);
      assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 ], l);
    }
  };
}

// //////////////////////////////////////////////////////////////////////////////
// / @brief test suite: range
// //////////////////////////////////////////////////////////////////////////////

function SimpleQueryAnySuite () {
  'use strict';
  var cn = 'UnitTestsCollectionAny';
  var collectionEmpty = null;
  var collectionOne = null;

  return {

// //////////////////////////////////////////////////////////////////////////////
// / @brief set up
// //////////////////////////////////////////////////////////////////////////////

    setUp: function () {
      var name;

      name = cn + 'Empty';
      db._drop(name);
      collectionEmpty = db._create(name);

      name = cn + 'One';
      db._drop(name);
      collectionOne = db._create(name, { waitForSync: false });
      collectionOne.save({ age: 1 });
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief tear down
// //////////////////////////////////////////////////////////////////////////////

    tearDown: function () {
      collectionEmpty.drop();
      collectionOne.drop();
    },

// //////////////////////////////////////////////////////////////////////////////
// / @brief test: any
// //////////////////////////////////////////////////////////////////////////////

    testAny: function () {
      var d = collectionEmpty.any();
      assertEqual(null, d);

      d = collectionOne.any();
      assertNotNull(d);
      assertEqual(1, d.age);
    }
  };
}

// //////////////////////////////////////////////////////////////////////////////
// / @brief executes the test suites
// //////////////////////////////////////////////////////////////////////////////

jsunity.run(SimpleQueryLookupByKeysSuite);
jsunity.run(SimpleQueryRemoveByKeysSuite);
jsunity.run(SimpleQueryArraySkipLimitSuite);
jsunity.run(SimpleQueryAllSkipLimitSuite);
jsunity.run(SimpleQueryByExampleSuite);
jsunity.run(SimpleQueryByExampleEdgeSuite);
jsunity.run(SimpleQueryRangeSuite);
jsunity.run(SimpleQuerySparseRangeSuite);
jsunity.run(SimpleQueryUniqueRangeSuite);
jsunity.run(SimpleQueryUniqueSparseRangeSuite);
jsunity.run(SimpleQueryAnySuite);

return jsunity.done();