/*jshint globalstrict:false, strict:false */
/*global fail, assertEqual, assertTrue, assertNull */

////////////////////////////////////////////////////////////////////////////////
/// @brief test simple queries in a cluster
///
/// @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 2014, triAGENS GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////

var jsunity = require("jsunity");
var arangodb = require("@arangodb");
var ERRORS = arangodb.errors;
var db = arangodb.db;
var _ = require("lodash");

var createCollection = function (properties) {
  'use strict';
  try {
    db._drop("UnitTestsClusterCrud");
  }
  catch (err) {
  }

  if (properties === undefined) {
    properties = { };
  }

  return db._create("UnitTestsClusterCrud", properties);
};



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

function ClusterCrudSimpleSuite () {
  'use strict';

  var queryToArray = function (q, n, cb) {
    var result = q.toArray();
    assertEqual(n, result.length);

    if (n > 0 && cb !== undefined) {
      cb(result[0]);
    }
  };

  var queryToCursor = function (q, n, cb) {
    var result = q, count = 0;

    while (result.hasNext()) {
      if (cb !== undefined) {
        cb(result.next());
      }
      else {
        result.next();
      }
      count++;
    }
    assertEqual(n, count);
  };

  var checkQuery = function (q, n, cb) {
    q = _.toPlainObject(q); // Clone inherited methods too
    var qc = _.clone(q);
    queryToArray(qc, n, cb);
    qc = _.clone(q);
    queryToCursor(qc, n, cb);
  };

////////////////////////////////////////////////////////////////////////////////
/// @brief helper function for all
////////////////////////////////////////////////////////////////////////////////

  var executeAll = function (c) {
    var i, n = 6000;
    for (i = 0; i < n; ++i) {
      c.save({ _key: "test" + i, value1 : i, value2 : "test" + i });
    }

    checkQuery(c.all().limit(20), 20, function (r0) {
      assertTrue(r0.hasOwnProperty("_id"));
      assertTrue(r0.hasOwnProperty("_key"));
      assertTrue(r0.hasOwnProperty("_rev"));
      assertTrue(r0.hasOwnProperty("value1"));
      assertTrue(r0.hasOwnProperty("value2"));
      assertEqual(r0._key, r0.value2);
    });

    checkQuery(c.all().skip(5981).limit(20), 19, function (r0) {
      assertTrue(r0.hasOwnProperty("_id"));
      assertTrue(r0.hasOwnProperty("_key"));
      assertTrue(r0.hasOwnProperty("_rev"));
      assertTrue(r0.hasOwnProperty("value1"));
      assertTrue(r0.hasOwnProperty("value2"));
      assertEqual(r0._key, r0.value2);
    });
  };

////////////////////////////////////////////////////////////////////////////////
/// @brief helper function for byExample
////////////////////////////////////////////////////////////////////////////////

  var executeByExample = function (c) {
    var i, n = 6000;
    for (i = 0; i < n; ++i) {
      c.save({ _key: "test" + i, value1 : (i % 10), value2 : "test" + i, value3 : 1 });
    }

    checkQuery(c.byExample({ }).limit(20), 20, function (r0) {
      assertTrue(r0.hasOwnProperty("_id"));
      assertTrue(r0.hasOwnProperty("_key"));
      assertTrue(r0.hasOwnProperty("_rev"));
      assertTrue(r0.hasOwnProperty("value1"));
      assertTrue(r0.hasOwnProperty("value2"));
      assertTrue(r0.hasOwnProperty("value3"));
      assertEqual(r0._key, r0.value2);
      assertEqual(1, r0.value3);
    });

    checkQuery(c.byExample({ value3 : 1 }).limit(20), 20, function (r0) {
      assertTrue(r0.hasOwnProperty("_id"));
      assertTrue(r0.hasOwnProperty("_key"));
      assertTrue(r0.hasOwnProperty("_rev"));
      assertTrue(r0.hasOwnProperty("value1"));
      assertTrue(r0.hasOwnProperty("value2"));
      assertTrue(r0.hasOwnProperty("value3"));
      assertEqual(r0._key, r0.value2);
      assertEqual(1, r0.value3);
    });

    checkQuery(c.byExample({ value1 : 5 }), n / 10, function (r0) {
      assertTrue(r0.hasOwnProperty("_id"));
      assertTrue(r0.hasOwnProperty("_key"));
      assertTrue(r0.hasOwnProperty("_rev"));
      assertTrue(r0.hasOwnProperty("value1"));
      assertTrue(r0.hasOwnProperty("value2"));
      assertTrue(r0.hasOwnProperty("value3"));
      assertEqual(5, r0.value1);
      assertEqual(r0._key, r0.value2);
      assertEqual(1, r0.value3);
    });

    checkQuery(c.byExample({ value1 : 5 }).limit(4), 4, function (r0) {
      assertTrue(r0.hasOwnProperty("_id"));
      assertTrue(r0.hasOwnProperty("_key"));
      assertTrue(r0.hasOwnProperty("_rev"));
      assertTrue(r0.hasOwnProperty("value1"));
      assertTrue(r0.hasOwnProperty("value2"));
      assertTrue(r0.hasOwnProperty("value3"));
      assertEqual(5, r0.value1);
      assertEqual(r0._key, r0.value2);
      assertEqual(1, r0.value3);
    });

    checkQuery(c.byExample({ value2 : "test999" }), 1, function (r0) {
      assertTrue(r0.hasOwnProperty("_id"));
      assertTrue(r0.hasOwnProperty("_key"));
      assertTrue(r0.hasOwnProperty("_rev"));
      assertTrue(r0.hasOwnProperty("value1"));
      assertTrue(r0.hasOwnProperty("value2"));
      assertTrue(r0.hasOwnProperty("value3"));
      assertEqual(9, r0.value1);
      assertEqual("test999", r0.value2);
      assertEqual(1, r0.value3);
    });

    checkQuery(c.byExample({ value1 : 9, value2 : "test999", value3 : 1 }), 1);
    checkQuery(c.byExample({ _key : "test999" }), 1);
    checkQuery(c.byExample({ value2: "test999" }).skip(1), 0);
    checkQuery(c.byExample({ value1 : 9, value2 : "test999", value3 : 1, _key : "test999" }), 1);
    checkQuery(c.byExample({ value1 : 9, value2 : "test999", value3 : 1, _key : "test999" }).skip(1), 0);
    checkQuery(c.byExample({ value2: "foxx" }), 0);
    checkQuery(c.byExample({ clobber: "clubber" }), 0);
  };

////////////////////////////////////////////////////////////////////////////////
/// @brief helper function for firstExample
////////////////////////////////////////////////////////////////////////////////

  var executeFirstExample = function (c) {
    var i, n = 1000;
    for (i = 0; i < n; ++i) {
      c.save({ _key: "test" + i, value1 : (i % 10), value2 : "test" + i, value3 : 1 });
    }

    var r0 = c.firstExample({ _key : "test35" });
    assertTrue(r0.hasOwnProperty("_id"));
    assertTrue(r0.hasOwnProperty("_key"));
    assertTrue(r0.hasOwnProperty("_rev"));
    assertTrue(r0.hasOwnProperty("value1"));
    assertTrue(r0.hasOwnProperty("value2"));
    assertTrue(r0.hasOwnProperty("value3"));
    assertEqual("test35", r0._key);
    assertEqual(5, r0.value1);
    assertEqual("test35", r0.value2);
    assertEqual(1, r0.value3);

    r0 = c.firstExample({ _key : "test35", value1 : 5, value2 : "test35", value3 : 1 });
    assertTrue(r0.hasOwnProperty("_id"));
    assertTrue(r0.hasOwnProperty("_key"));
    assertTrue(r0.hasOwnProperty("_rev"));
    assertTrue(r0.hasOwnProperty("value1"));
    assertTrue(r0.hasOwnProperty("value2"));
    assertTrue(r0.hasOwnProperty("value3"));
    assertEqual("test35", r0._key);
    assertEqual(5, r0.value1);
    assertEqual("test35", r0.value2);
    assertEqual(1, r0.value3);

    r0 = c.firstExample({ _key : "test35", value1: 6 });
    assertNull(r0);

    r0 = c.firstExample({ _key : "test2000" });
    assertNull(r0);

    r0 = c.firstExample({ value2 : "test2000" });
    assertNull(r0);

    r0 = c.firstExample({ _key : "test2000", foobar : "baz" });
    assertNull(r0);

    r0 = c.firstExample({ foobar : "baz" });
    assertNull(r0);
  };

////////////////////////////////////////////////////////////////////////////////
/// @brief helper function for count
////////////////////////////////////////////////////////////////////////////////

  var executeCount = function (c) {
    var i, n = 1000;
    for (i = 0; i < n; ++i) {
      c.save({ _key: "test" + i, value1 : (i % 10), value2 : "test" + i, value3 : 1 });
    }

    assertEqual(n, c.count());

    c.removeByExample({ value1 : 7 });
    assertEqual(n - (n / 10), c.count());

    c.removeByExample({ value1 : 6 });
    assertEqual(n - 2 * (n / 10), c.count());

    // this shouldn't remove anything
    c.removeByExample({ value1 : 6 });
    assertEqual(n - 2 * (n / 10), c.count());

    c.removeByExample({ value3 : 1 });
    assertEqual(0, c.count());

    var doc = c.save({ a : 1 });
    assertEqual(1, c.count());
    c.remove(doc);
    assertEqual(0, c.count());
  };

////////////////////////////////////////////////////////////////////////////////
/// @brief helper function for any
////////////////////////////////////////////////////////////////////////////////

  var executeAny = function (c) {
    var i, n = 1000;

    assertNull(c.any());

    for (i = 0; i < n; ++i) {
      c.save({ _key: "test" + i, value1 : (i % 10), value2 : "test" + i, value3 : 1 });
    }

    var doc = c.any();
    assertTrue(doc.hasOwnProperty("_id"));
    assertTrue(doc.hasOwnProperty("_key"));
    assertTrue(doc.hasOwnProperty("_rev"));
    assertTrue(doc.hasOwnProperty("value1"));
    assertTrue(doc.hasOwnProperty("value2"));
    assertTrue(doc.hasOwnProperty("value3"));
    assertEqual(doc._key, doc.value2);
    assertEqual(1, doc.value3);

    c.truncate();
    assertNull(c.any());
  };

////////////////////////////////////////////////////////////////////////////////
/// @brief helper function for truncate
////////////////////////////////////////////////////////////////////////////////

  var executeTruncate = function (c) {
    var i, n = 1000;

    for (i = 0; i < n; ++i) {
      c.save({ _key: "test" + i, value1 : (i % 10), value2 : "test" + i, value3 : 1 });
    }

    assertEqual(n, c.count());

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

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

    c.save({ _key : "foo" });
    assertEqual(1, c.count());

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

////////////////////////////////////////////////////////////////////////////////
/// @brief helper function for removeByExample
////////////////////////////////////////////////////////////////////////////////

  var executeRemoveByExample = function (c) {
    var i, n = 1000;

    for (i = 0; i < n; ++i) {
      c.save({ _key: "test" + i, value1 : (i % 10), value2 : "test" + i, value3 : 1 });
    }

    assertEqual(n, c.count());

    assertEqual(0, c.removeByExample({ value1 : 11 }));
    assertEqual(n, c.count());

    assertEqual(0, c.removeByExample({ value1 : 4, value2 : "test37" }));
    assertEqual(n, c.count());

    assertEqual(0, c.removeByExample({ foobar : "baz" }));
    assertEqual(n, c.count());

    assertEqual(n / 10, c.removeByExample({ value1 : 1 }));
    assertEqual(n - (n / 10), c.count());

    assertEqual(n / 10, c.removeByExample({ value1 : 2 }));
    assertEqual(n - 2 * (n / 10), c.count());

    assertEqual(1, c.removeByExample({ _key : "test44" }));
    assertEqual(n - 2 * (n / 10) - 1, c.count());

    assertEqual(0, c.removeByExample({ _key : "test44" }));

    assertEqual(n - 2 * (n / 10) - 1, c.removeByExample({ value3 : 1 }));
    assertEqual(0, c.count());

    assertEqual(0, c.removeByExample({ value3 : 1 }));
  };

////////////////////////////////////////////////////////////////////////////////
/// @brief helper function for replaceByExample
////////////////////////////////////////////////////////////////////////////////

  var executeReplaceByExample = function (c) {
    var i, n = 1000;

    assertEqual(0, c.replaceByExample({ value3 : 1 }, { value9 : 17 }));

    for (i = 0; i < n; ++i) {
      c.save({ _key: "test" + i, value1 : (i % 10), value2 : "test" + i, value3 : 1 });
    }

    assertEqual(n, c.count());

    assertEqual(0, c.replaceByExample({ value1 : 11 }, { value1 : 17 }));
    assertEqual(n, c.count());

    assertEqual(0, c.replaceByExample({ value1 : 4, value2 : "test37" }, { value2 : "foxx" }));
    assertEqual(n, c.count());

    assertEqual(0, c.replaceByExample({ foobar : "baz" }, { boom : "bar" }));
    assertEqual(n, c.count());

    assertEqual(n / 10, c.replaceByExample({ value1 : 1 }, { value1 : 4 }));
    assertEqual(0, c.replaceByExample({ value1 : 1 }, { value1 : 4 }));
    assertEqual(n, c.count());

    assertEqual(n / 10, c.replaceByExample({ value1 : 2 }, { value1 : 5 }));
    assertEqual(0, c.replaceByExample({ value1 : 2 }, { value1 : 5 }));
    assertEqual(n, c.count());

    assertEqual(1, c.replaceByExample({ _key : "test44" }, { value3 : 2 }));
    assertEqual(1, c.replaceByExample({ _key : "test44" }, { value3 : 4 }));

    assertEqual(n, c.replaceByExample({ }, { value3 : 99, value2 : 1 }));
    assertEqual(0, c.replaceByExample({ value3 : 99, value2 : 2 }, { }));
    assertEqual(n, c.replaceByExample({ value3 : 99, value2 : 1 }, { value2 : 2, value3 : "test" }));
  };

////////////////////////////////////////////////////////////////////////////////
/// @brief helper function for replaceByExample
////////////////////////////////////////////////////////////////////////////////

  var executeReplaceByExampleShardKeys = function (c) {
    var i, n = 1000;

    for (i = 0; i < n; ++i) {
      c.save({ a : (i % 10), b : (i % 100) });
    }

    assertEqual(0, c.replaceByExample({ a : 11 }, { a : 11, b : 13, c : 1 }));

    try {
      c.replaceByExample({ a : 1, b : 1 }, { a : 12542, b : 13239, c : 1 });
      fail();
    }
    catch (err1) {
      if (ERRORS.ERROR_CLUSTER_MUST_NOT_CHANGE_SHARDING_ATTRIBUTES.code !== err1.errorNum) {
        assertEqual(ERRORS.ERROR_ARANGO_DOCUMENT_NOT_FOUND.code, err1.errorNum);
      }
    }

    try {
      c.replaceByExample({ a : 2 }, { a : 2, b : 13, c : 1 });
      fail();
    }
    catch (err2) {
      if (ERRORS.ERROR_CLUSTER_MUST_NOT_CHANGE_SHARDING_ATTRIBUTES.code !== err2.errorNum) {
        assertEqual(ERRORS.ERROR_ARANGO_DOCUMENT_NOT_FOUND.code, err2.errorNum);
      }
    }

    try {
      c.replaceByExample({ a : 2 }, { a : 2, c : 1 });
      fail();
    }
    catch (err3) {
      if (ERRORS.ERROR_CLUSTER_MUST_NOT_CHANGE_SHARDING_ATTRIBUTES.code !== err3.errorNum) {
        assertEqual(ERRORS.ERROR_ARANGO_DOCUMENT_NOT_FOUND.code, err3.errorNum);
      }
    }

    assertEqual(n / 100, c.replaceByExample({ a : 7, b : 17 }, { a : 7, b : 17, c : 12 }));
    assertEqual(n / 100, c.replaceByExample({ a : 7, b : 17, c : 12 }, { a : 7, b : 17, d : 9 }));
    assertEqual(0, c.replaceByExample({ a : 7, b : 17, c : 12 }, { }));
  };

////////////////////////////////////////////////////////////////////////////////
/// @brief helper function for updateByExample
////////////////////////////////////////////////////////////////////////////////

  var executeUpdateByExample = function (c) {
    var i, n = 1000;

    assertEqual(0, c.updateByExample({ value3 : 1 }, { value9 : 17 }));

    for (i = 0; i < n; ++i) {
      c.save({ _key: "test" + i, value1 : (i % 10), value2 : "test" + i, value3 : 1 });
    }

    assertEqual(0, c.updateByExample({ value1 : 11 }, { value1 : 17 }));

    assertEqual(0, c.updateByExample({ value1 : 4, value2 : "test37" }, { value2 : "foxx" }));

    assertEqual(0, c.updateByExample({ foobar : "baz" }, { boom : "bar" }));

    assertEqual(n / 10, c.updateByExample({ value1 : 1 }, { value1 : 4 }));
    assertEqual(0, c.updateByExample({ value1 : 1 }, { value1 : 4 }));

    assertEqual(n / 10, c.updateByExample({ value1 : 2 }, { value1 : 5 }));
    assertEqual(0, c.updateByExample({ value1 : 2 }, { value1 : 5 }));

    assertEqual(1, c.updateByExample({ _key : "test44" }, { value3 : 2 }));
    assertEqual(1, c.updateByExample({ _key : "test44" }, { value3 : 4 }));

    assertEqual(n - 1, c.updateByExample({ value3 : 1 }, { value3 : 99 }));
    assertEqual(1, c.updateByExample({ value3 : 4 }, { value3 : 99 }));

    assertEqual(n / 10, c.updateByExample({ value3 : 99, value1 : 0 }, { value1 : 9 }));
    assertEqual(n, c.updateByExample({ value3 : 99 }, { }));
    assertEqual(2 * (n / 10), c.updateByExample({ value3 : 99, value1 : 9 }, { value12 : 7 }));
    assertEqual(n, c.updateByExample({ }, { value12 : 7 }));

    assertEqual(n, c.updateByExample({ value12 : 7 }, { value12 : null }, false));
    assertEqual(0, c.byExample({ value12: 7 }).toArray().length);
  };

////////////////////////////////////////////////////////////////////////////////
/// @brief helper function for updateByExample
////////////////////////////////////////////////////////////////////////////////

  var executeUpdateByExampleShardKeys = function (c) {
    var i, n = 1000;

    for (i = 0; i < n; ++i) {
      c.save({ a : (i % 10), b : (i % 100) });
    }

    assertEqual(0, c.updateByExample({ a : 11 }, { a : 17 }));
    assertEqual(0, c.updateByExample({ foobar : "baz" }, { a : 17 }));

    assertEqual(10, c.updateByExample({ a : 1, b : 1 }, { a : 1, b : 1, c : "test" }));

    try {
      c.updateByExample({ a : 1, b : 1 }, { a : 2, b : 1 });
      fail();
    }
    catch (err1) {
      assertEqual(ERRORS.ERROR_CLUSTER_MUST_NOT_CHANGE_SHARDING_ATTRIBUTES.code, err1.errorNum);
    }

    assertEqual(10, c.updateByExample({ a : 2, b : 2 }, { d : "test" }));

    try {
      c.updateByExample({ a : 1, b : 1 }, { a : 2, d : 4 });
      fail();
    }
    catch (err2) {
      assertEqual(ERRORS.ERROR_CLUSTER_MUST_NOT_CHANGE_SHARDING_ATTRIBUTES.code, err2.errorNum);
    }

    try {
      c.updateByExample({ a : 1, b : 1 }, { a : 2 });
      fail();
    }
    catch (err3) {
      assertEqual(ERRORS.ERROR_CLUSTER_MUST_NOT_CHANGE_SHARDING_ATTRIBUTES.code, err3.errorNum);
    }
  };

  return {

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

    setUp : function () {
    },

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

    tearDown : function () {
      try {
        db._drop("UnitTestsClusterCrud");
      }
      catch (err) {
      }
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test all, one shard
////////////////////////////////////////////////////////////////////////////////

    testAllOneShard : function () {
      var c = createCollection({ numberOfShards: 1 });
      executeAll(c);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test all, multiple shards
////////////////////////////////////////////////////////////////////////////////

    testAllMultipleShards : function () {
      var c = createCollection({ numberOfShards: 5 });
      executeAll(c);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test byExample, one shard
////////////////////////////////////////////////////////////////////////////////

    testByExampleOneShard : function () {
      var c = createCollection({ numberOfShards: 1 });
      executeByExample(c);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test all, multiple shards
////////////////////////////////////////////////////////////////////////////////

    testByExampleMultipleShards : function () {
      var c = createCollection({ numberOfShards: 5 });
      executeByExample(c);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test firstExample, one shard
////////////////////////////////////////////////////////////////////////////////

    testFirstExampleOneShard : function () {
      var c = createCollection({ numberOfShards: 1 });
      executeFirstExample(c);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test all, multiple shards
////////////////////////////////////////////////////////////////////////////////

    testFirstExampleMultipleShards : function () {
      var c = createCollection({ numberOfShards: 5 });
      executeFirstExample(c);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test count, one shard
////////////////////////////////////////////////////////////////////////////////

    testCountOneShard : function () {
      var c = createCollection({ numberOfShards: 1 });
      executeCount(c);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test count, multiple shards
////////////////////////////////////////////////////////////////////////////////

    testCountMultipleShards : function () {
      var c = createCollection({ numberOfShards: 5 });
      executeCount(c);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test any, one shard
////////////////////////////////////////////////////////////////////////////////

    testAnyOneShard : function () {
      var c = createCollection({ numberOfShards: 1 });
      executeAny(c);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test any, multiple shards
////////////////////////////////////////////////////////////////////////////////

    testAnyMultipleShards : function () {
      var c = createCollection({ numberOfShards: 5 });
      executeAny(c);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test truncate, one shard
////////////////////////////////////////////////////////////////////////////////

    testTruncateOneShard : function () {
      var c = createCollection({ numberOfShards: 1 });
      executeTruncate(c);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test truncate, multiple shards
////////////////////////////////////////////////////////////////////////////////

    testTruncateMultipleShards : function () {
      var c = createCollection({ numberOfShards: 5 });
      executeTruncate(c);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test removeByExample, one shard
////////////////////////////////////////////////////////////////////////////////

    testRemoveByExampleOneShard : function () {
      var c = createCollection({ numberOfShards: 1 });
      executeRemoveByExample(c);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test removeByExample, multiple shards
////////////////////////////////////////////////////////////////////////////////

    testRemoveByExampleMultipleShards : function () {
      var c = createCollection({ numberOfShards: 5 });
      executeRemoveByExample(c);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test replaceByExample, one shard
////////////////////////////////////////////////////////////////////////////////

    testReplaceByExampleOneShard : function () {
      var c = createCollection({ numberOfShards: 1 });
      executeReplaceByExample(c);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test replaceByExample, multiple shards
////////////////////////////////////////////////////////////////////////////////

    testReplaceByExampleMultipleShards : function () {
      var c = createCollection({ numberOfShards: 5 });
      executeReplaceByExample(c);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test replaceByExample, one shard
////////////////////////////////////////////////////////////////////////////////

    testReplaceByExampleShardKeysOneShard : function () {
      var c = createCollection({ numberOfShards: 1, shardKeys: [ "a", "b" ] });
      executeReplaceByExampleShardKeys(c);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test replaceByExample, multiple shards
////////////////////////////////////////////////////////////////////////////////

    testReplaceByExampleShardKeysMultipleShards : function () {
      var c = createCollection({ numberOfShards: 5, shardKeys: [ "a", "b" ] });
      executeReplaceByExampleShardKeys(c);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test updateByExample, one shard
////////////////////////////////////////////////////////////////////////////////

    testUpdateByExampleOneShard : function () {
      var c = createCollection({ numberOfShards: 1 });
      executeUpdateByExample(c);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test updateByExample, multiple shards
////////////////////////////////////////////////////////////////////////////////

    testUpdateByExampleMultipleShards : function () {
      var c = createCollection({ numberOfShards: 5 });
      executeUpdateByExample(c);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test updateByExample, one shard
////////////////////////////////////////////////////////////////////////////////

    testUpdateByExampleShardKeysOneShard : function () {
      var c = createCollection({ numberOfShards: 1, shardKeys: [ "a", "b" ] });
      executeUpdateByExampleShardKeys(c);
    },

////////////////////////////////////////////////////////////////////////////////
/// @brief test updateByExample, multiple shards
////////////////////////////////////////////////////////////////////////////////

    testUpdateByExampleShardKeysMultipleShards : function () {
      var c = createCollection({ numberOfShards: 5, shardKeys: [ "a", "b" ] });
      executeUpdateByExampleShardKeys(c);
    }

  };
}


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

jsunity.run(ClusterCrudSimpleSuite);

return jsunity.done();