mirror of https://gitee.com/bigwinds/arangodb
785 lines
26 KiB
JavaScript
785 lines
26 KiB
JavaScript
/*jslint indent: 2,
|
|
nomen: true,
|
|
maxlen: 80 */
|
|
/*global require,
|
|
db,
|
|
assertEqual, assertTrue,
|
|
ArangoCollection, ArangoEdgesCollection */
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tests for bitarray indexes
|
|
///
|
|
/// @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. O
|
|
/// @author Copyright 2012, triAGENS GmbH, Cologne, Germany
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var jsunity = require("jsunity");
|
|
var internal = require("internal");
|
|
var console = require("console");
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- basic methods
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite: Creation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function BitarrayIndexSuite() {
|
|
var ERRORS = internal.errors;
|
|
var cn = "UnitTestsCollectionBitarray";
|
|
var collection = null;
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// ...........................................................................
|
|
// jsunity automatically calls this property before each test for you
|
|
// ...........................................................................
|
|
|
|
setUp : function () {
|
|
internal.db._drop(cn);
|
|
collection = internal.db._create(cn, { waitForSync : false });
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// ...........................................................................
|
|
// jsunity automatically calls this property at the end of each test for you
|
|
// ...........................................................................
|
|
|
|
tearDown : function () {
|
|
collection.unload();
|
|
|
|
while (collection.status() != internal.ArangoCollection.STATUS_UNLOADED) {
|
|
console.log("waiting for collection '%s' to unload", cn);
|
|
internal.wait(1);
|
|
}
|
|
|
|
collection.drop();
|
|
|
|
while (collection.status() != internal.ArangoCollection.STATUS_DELETED) {
|
|
console.log("waiting for collection '%s' to drop", cn);
|
|
internal.wait(1);
|
|
}
|
|
},
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: bitarray index creation type 1
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCreationBitarrayIndex_1a : function () {
|
|
var idx;
|
|
|
|
try {
|
|
idx = collection.ensureBitarray("a");
|
|
}
|
|
catch(err) {
|
|
return;
|
|
}
|
|
|
|
throw("Bitarray index can not be constructed in this fashion");
|
|
},
|
|
|
|
|
|
|
|
testCreationBitarrayIndex_1b : function () {
|
|
var idx;
|
|
|
|
try {
|
|
idx = collection.ensureBitarray("a",[0,1,2,3],"b");
|
|
}
|
|
catch(err) {
|
|
return;
|
|
}
|
|
|
|
throw("Bitarray index can not be constructed in this fashion");
|
|
},
|
|
|
|
|
|
testCreationBitarrayIndex_1c : function () {
|
|
var idx;
|
|
|
|
try {
|
|
idx = collection.ensureBitarray("a",[0,1,2,3],"a",[4,5,6,7]);
|
|
}
|
|
catch(err) {
|
|
return;
|
|
}
|
|
|
|
throw("Bitarray index can not be constructed in this fashion");
|
|
},
|
|
|
|
testCreationBitarrayIndex_1d : function () {
|
|
var idx;
|
|
|
|
try {
|
|
idx = collection.ensureBitarray("a",[0,1,2,3],"b",[4,5,6,7,4]);
|
|
}
|
|
catch(err) {
|
|
return;
|
|
}
|
|
|
|
throw("Bitarray index can not be constructed in this fashion");
|
|
},
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: bitarray index creation type 2
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCreationBitarrayIndex_2a : function () {
|
|
var idx;
|
|
|
|
|
|
// .........................................................................
|
|
// Create a bit array index with one attribute
|
|
// .........................................................................
|
|
|
|
idx = collection.ensureBitarray("a",[0,1,2,3,4,5,6,7,8,9,[]]);
|
|
|
|
|
|
// .........................................................................
|
|
// Got through the returned json object and check whether things are as
|
|
// they should be
|
|
// .........................................................................
|
|
|
|
assertNotEqual(0, idx.id);
|
|
assertEqual("bitarray", idx.type);
|
|
assertEqual(false, idx.unique);
|
|
assertEqual([["a", [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, [ ]]]], idx.fields);
|
|
assertEqual(true, idx.isNewlyCreated);
|
|
|
|
|
|
// .........................................................................
|
|
// Attempt to create the index again this time we are going to change
|
|
// the list of values
|
|
// The database should pick up the existing bitarray index with the
|
|
// original attribute/values.
|
|
// .........................................................................
|
|
|
|
idx = collection.ensureBitarray("a",["a","b","c","d",0,1,2,3,4,5,6,7,8,9,[]]);
|
|
|
|
assertNotEqual(0, idx.id);
|
|
assertEqual("bitarray", idx.type);
|
|
assertEqual(false, idx.unique);
|
|
assertEqual([["a", [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, [ ]]]], idx.fields);
|
|
assertEqual(false, idx.isNewlyCreated);
|
|
|
|
return;
|
|
},
|
|
|
|
|
|
testCreationBitarrayIndex_2b : function () {
|
|
var idx;
|
|
var result;
|
|
|
|
// .........................................................................
|
|
// Create a bit array index with one attribute
|
|
// .........................................................................
|
|
|
|
idx = collection.ensureBitarray("a",[0,1,2,3,4,5,6,7,8,9,[]]);
|
|
|
|
|
|
// .........................................................................
|
|
// Got through the returned json object and check whether things are as
|
|
// they should be
|
|
// .........................................................................
|
|
|
|
assertNotEqual(0, idx.id);
|
|
assertEqual("bitarray", idx.type);
|
|
assertEqual(false, idx.unique);
|
|
assertEqual([["a", [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, [ ]]]], idx.fields);
|
|
assertEqual(true, idx.isNewlyCreated);
|
|
|
|
|
|
// .........................................................................
|
|
// Remove the index
|
|
// .........................................................................
|
|
|
|
result = collection.dropIndex(idx.id);
|
|
assertEqual(true,result);
|
|
|
|
// .........................................................................
|
|
// Attempt to create the index again this time we are going to change
|
|
// the list of values.
|
|
// This time the index should show the new attribute/values
|
|
// .........................................................................
|
|
|
|
idx = collection.ensureBitarray("a",["a","b","c","d",0,1,2,3,4,5,6,7,8,9,[]]);
|
|
|
|
assertNotEqual(0, idx.id);
|
|
assertEqual("bitarray", idx.type);
|
|
assertEqual(false, idx.unique);
|
|
assertEqual([["a", ["a", "b", "c", "d", 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, [ ]]]], idx.fields);
|
|
assertEqual(true, idx.isNewlyCreated);
|
|
|
|
return;
|
|
},
|
|
|
|
|
|
testCreationBitarrayIndex_2c : function () {
|
|
var idx;
|
|
|
|
// .........................................................................
|
|
// Create a bit array index with one attribute, with different types of
|
|
// json objects and with 3 attributes and their corresponding values.
|
|
// .........................................................................
|
|
|
|
idx = collection.ensureBitarray("x",["male","female","other"],"y",[0,1,3,[]],"z",[{"z1":0},{"z2":1},[[["hello","goodbye"]],0,1,2,3,["4","4a","4b"],5,6,7,8,9],[]]);
|
|
|
|
|
|
// .........................................................................
|
|
// Got through the returned json object and check whether things are as
|
|
// they should be
|
|
// .........................................................................
|
|
assertNotEqual(0, idx.id);
|
|
assertEqual("bitarray", idx.type);
|
|
assertEqual(false, idx.unique);
|
|
assertEqual([["x", ["male", "female", "other"]], ["y", [0, 1, 3, [ ]]], ["z", [{ "z1" : 0 }, { "z2" : 1 }, [[["hello","goodbye"]],0, 1, 2, 3, ["4","4a","4b"], 5, 6, 7, 8, 9], [ ]]]], idx.fields);
|
|
assertEqual(true, idx.isNewlyCreated);
|
|
|
|
return;
|
|
},
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: bitarray index insertion
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCreationBitarrayIndex_3a : function () {
|
|
var idx;
|
|
var n = 10000;
|
|
|
|
// .........................................................................
|
|
// Create a bit array index with one attribute possible values are 0-9
|
|
// inclusive.
|
|
// .........................................................................
|
|
|
|
idx = collection.ensureBitarray("x",[0,1,2,3,4,5,6,7,8,9]);
|
|
|
|
/* print("Start writing",n," documents into index"); */
|
|
|
|
// .........................................................................
|
|
// Save n random records. All of these records should be inserted into the
|
|
// collection.
|
|
// .........................................................................
|
|
|
|
for (var j = 0; j < n; ++j) {
|
|
var value = Math.floor(Math.random()*10);
|
|
collection.save({"x":value});
|
|
}
|
|
|
|
/* print("End writing",n," documents into index"); */
|
|
|
|
return;
|
|
},
|
|
|
|
testCreationBitarrayIndex_3b : function () {
|
|
var idx;
|
|
var n = 10000;
|
|
|
|
// .........................................................................
|
|
// Create a bit array index with one attribute
|
|
// .........................................................................
|
|
|
|
idx = collection.ensureBitarray("x",[0,1,2,3,4,5,6,7,8,9,[]]);
|
|
|
|
/* print("Start writing",n," documents into index"); */
|
|
|
|
// .........................................................................
|
|
// Save n random records. The values of the attribute x will be in the
|
|
// range 0-19. Later our expections will approx half of these records
|
|
// will be 'other' bitarray column
|
|
// .........................................................................
|
|
|
|
for (var j = 0; j < n; ++j) {
|
|
var value = Math.floor(Math.random()*20);
|
|
collection.save({"x":value});
|
|
//print("saved ",j,value);
|
|
}
|
|
|
|
/* print("End writing",n," documents into index"); */
|
|
|
|
return;
|
|
},
|
|
|
|
|
|
testCreationBitarrayIndex_3c : function () {
|
|
var idx;
|
|
|
|
// .........................................................................
|
|
// Create a bit array index with one attribute
|
|
// .........................................................................
|
|
|
|
idx = collection.ensureBitarray("x",[0,1,2,3,4,5,6,7,8,9]);
|
|
|
|
|
|
// .........................................................................
|
|
// attempting to save this document should fail
|
|
// .........................................................................
|
|
|
|
try {
|
|
collection.save({"x":"hi there!"});
|
|
}
|
|
catch(err) {
|
|
return;
|
|
}
|
|
|
|
|
|
throw("Bitarray index should not allow the insertion of this document within the collection");
|
|
|
|
return;
|
|
},
|
|
|
|
|
|
testCreationBitarrayIndex_3d : function () {
|
|
var idx;
|
|
var n = 10000;
|
|
// .........................................................................
|
|
// Create a bit array index with one attribute
|
|
// .........................................................................
|
|
|
|
idx = collection.ensureBitarray("x",[0,1,2,3,4,5,6,7,8,9,[]],"y.z",["a","b","c","d","e","f","g","h","i","j",[]],
|
|
"a.b.c",["a","b","c"]);
|
|
|
|
/* print("Start writing",n," documents into index"); */
|
|
|
|
// .........................................................................
|
|
// Save n random records
|
|
// .........................................................................
|
|
|
|
for (var j = 0; j < n; ++j) {
|
|
var value = Math.floor(Math.random()*10);
|
|
var alpha1 = Math.floor(Math.random()*10);
|
|
var alpha2 = Math.floor(Math.random()*3);
|
|
collection.save({"x":value,
|
|
"y":{"a":1,"z":String.fromCharCode(97 + alpha1)},
|
|
"a":{"x":2,"b":{"x":3,"c":String.fromCharCode(97 + alpha2)}}
|
|
});
|
|
//print("saved ",j,value,String.fromCharCode(97 + alpha));
|
|
}
|
|
|
|
/* print("End writing",n," documents into index"); */
|
|
|
|
return;
|
|
},
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: bitarray index removal
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCreationBitarrayIndex_4a : function () {
|
|
var idx;
|
|
var n = 10000;
|
|
var docs = new Array();
|
|
var visited = new Array();
|
|
|
|
// .........................................................................
|
|
// Create a bit array index with one attribute
|
|
// .........................................................................
|
|
|
|
idx = collection.ensureBitarray("x",[0,1,2,3,4,5,6,7,8,9,[]],"y.z",["a","b","c","d","e","f","g","h","i","j",[]]);
|
|
|
|
// .........................................................................
|
|
// Save n random records
|
|
// .........................................................................
|
|
|
|
// print("Start writing",n," documents into index");
|
|
|
|
for (var j = 0; j < n; ++j) {
|
|
var value = Math.floor(Math.random()*10);
|
|
var alpha = Math.floor(Math.random()*10);
|
|
var doc;
|
|
|
|
doc = collection.save({"x":value, "y":{"a":1,"z":String.fromCharCode(97 + alpha)} });
|
|
docs.push(doc._id);
|
|
//print("saved ",j,value,String.fromCharCode(97 + alpha), doc);
|
|
}
|
|
|
|
// print("End writing",n," documents into index");
|
|
|
|
|
|
// .........................................................................
|
|
// Remove n random records
|
|
// .........................................................................
|
|
|
|
// print("Start removal ",n," documents into index");
|
|
|
|
for (var j = 0; j < n; ++j) {
|
|
var value = Math.floor(Math.random()*n);
|
|
var doc = docs[value];
|
|
var result;
|
|
//print("a removed ",j,value,doc,visited[doc]);
|
|
if (visited[doc] == undefined) {
|
|
result = collection.remove(doc);
|
|
visited[doc] = true;
|
|
//print("b removed ",j,value,doc,result);
|
|
}
|
|
}
|
|
|
|
// print("End removal ",n," documents into index");
|
|
return;
|
|
},
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: bitarray index lookup
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testLookupBitarrayIndex_5a : function () {
|
|
var idx;
|
|
var n = 1000;
|
|
var bitarrayValues = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,[]];
|
|
var shelves = new Array(bitarrayValues.length);
|
|
var docs = new Array();
|
|
var totalDocs = 0;
|
|
var result;
|
|
|
|
|
|
// .........................................................................
|
|
// initialise our counters to 0
|
|
// .........................................................................
|
|
|
|
for (var j = 0; j < shelves.length; ++j) {
|
|
shelves[j] = 0;
|
|
}
|
|
|
|
// .........................................................................
|
|
// Create a bit array index with one attribute
|
|
// .........................................................................
|
|
|
|
idx = collection.ensureBitarray("x",bitarrayValues);
|
|
|
|
|
|
// .........................................................................
|
|
// Save n random records
|
|
// .........................................................................
|
|
|
|
// print("Start writing",n," documents into index");
|
|
|
|
for (var j = 0; j < n; ++j) {
|
|
var value = Math.floor(Math.random()*(bitarrayValues.length + 5));
|
|
var alpha = Math.floor(Math.random()*(bitarrayValues.length + 5));
|
|
var doc;
|
|
|
|
doc = collection.save({"x":value, "y":{"a":1,"z":String.fromCharCode(97 + alpha)} });
|
|
docs.push(doc._id);
|
|
if (value > bitarrayValues[bitarrayValues.length - 2]) {
|
|
value = bitarrayValues.length - 1;
|
|
}
|
|
shelves[value] = shelves[value] + 1;
|
|
totalDocs += 1;
|
|
}
|
|
|
|
// print("End writing",n," documents into index");
|
|
|
|
// .........................................................................
|
|
// Ensure that we have the total number of written documents stored in the
|
|
// last position
|
|
// .........................................................................
|
|
|
|
assertEqual(totalDocs, n);
|
|
|
|
// print("Start Lookup");
|
|
// print(shelves);
|
|
for (var j = 0; j < bitarrayValues.length; ++j) {
|
|
result = collection.BY_EXAMPLE_BITARRAY(idx.id,{"x":j,"y":6,"z":-1}, null, null);
|
|
//print(result['total'],shelves[j],j);
|
|
assertEqual(result['total'],shelves[j]);
|
|
}
|
|
|
|
// print("End Lookup");
|
|
return;
|
|
|
|
},
|
|
|
|
|
|
/*
|
|
testLookupBitarrayIndex_3 : function () {
|
|
var idx;
|
|
var n = 2000;
|
|
var bitarrayValues = [ [0,1,2,[]], ["a","b",[], "c"] ];
|
|
var maxValues = [2,2];
|
|
var otherPosition = [3,2];
|
|
var shelves = new Array(bitarrayValues[0].length + 1);
|
|
var docs = new Array();
|
|
var result;
|
|
|
|
|
|
// .........................................................................
|
|
// initialise our counters to 0
|
|
// .........................................................................
|
|
|
|
for (var i = 0; i < shelves.length; ++i) {
|
|
shelves[i] = new Array(bitarrayValues[1].length + 1);
|
|
for (var j = 0; j < shelves[i].length; ++j) {
|
|
shelves[i][j] = 0;
|
|
}
|
|
}
|
|
|
|
// .........................................................................
|
|
// Create a bit array index with two attributes
|
|
// .........................................................................
|
|
|
|
idx = collection.ensureBitarray("x", bitarrayValues[0], "y", bitarrayValues[1]);
|
|
|
|
|
|
// .........................................................................
|
|
// Save n random records
|
|
// .........................................................................
|
|
|
|
print("Start writing",n," documents into index");
|
|
|
|
for (var j = 0; j < n; ++j) {
|
|
var value = Math.floor(Math.random()*(bitarrayValues.length + 5));
|
|
var alpha = Math.floor(Math.random()*(bitarrayValues.length + 5));
|
|
var doc;
|
|
var subArray;
|
|
|
|
doc = collection.save({"x":value, "y": String.fromCharCode(97 + alpha), "z": {"xx":value,"yy":alpha} });
|
|
docs.push(doc._id);
|
|
print("j=",j,"value=",value,"alpha=",alpha);
|
|
//var bitarrayValues = [ [0,1,2,[]], ["a","b",[], "c"] ];
|
|
|
|
if (value > maxValues[0]) {
|
|
subArray = shelves[otherPosition[0]];
|
|
}
|
|
else {
|
|
if (value < otherPosition[0]) {
|
|
subArray = shelves[value];
|
|
}
|
|
else {
|
|
subArray = shelves[value + 1];
|
|
}
|
|
}
|
|
|
|
if (alpha > maxValues[1]) {
|
|
subArray[otherPosition[1]] += 1;
|
|
}
|
|
else {
|
|
if (alpha < otherPosition[1]) {
|
|
subArray[alpha] += 1;
|
|
}
|
|
else {
|
|
subArray[alpha + 1] += 1;
|
|
}
|
|
}
|
|
subArray[subArray.length - 1] += 1;
|
|
|
|
//print("j=",j,"value=",value,"alpha=",alpha,subArray);
|
|
}
|
|
|
|
print("End writing",n," documents into index");
|
|
|
|
for (var j = 0; j < (shelves[shelves.length - 1].length) ; ++j) {
|
|
for (var i = 0; i < (shelves.length - 1) ; ++i) {
|
|
shelves[shelves.length - 1][j] += shelves[i][j];
|
|
}
|
|
}
|
|
|
|
|
|
for (var i = 0; i < shelves.length ; ++i) {
|
|
for (var j = 0; j < shelves[i].length; ++j) {
|
|
//print(shelves[i][j]);
|
|
}
|
|
}
|
|
|
|
// .........................................................................
|
|
// Ensure that we have the total number of written documents stored in the
|
|
// last position
|
|
// .........................................................................
|
|
|
|
assertEqual(shelves[shelves.length - 1][shelves[shelves.length - 1].length - 1], n);
|
|
|
|
|
|
|
|
print("Start Lookup");
|
|
print(shelves);
|
|
for (var i = 0; i < bitarrayValues[0].length; ++i) {
|
|
for (var j = 0; j < bitarrayValues[1].length; ++j) {
|
|
var subArray;
|
|
var subSubArray;
|
|
|
|
result = collection.BY_EXAMPLE_BITARRAY(idx.id,{"x":i,"y":String.fromCharCode(97 + j)}, null, null);
|
|
|
|
|
|
if (i > maxValues[0]) {
|
|
subArray = shelves[otherPosition[0]];
|
|
}
|
|
else{
|
|
if (i < otherPosition[0]) {
|
|
subArray = shelves[i];
|
|
}
|
|
else {
|
|
subArray = shelves[i + 1];
|
|
}
|
|
}
|
|
|
|
|
|
if (j > maxValues[1]) {
|
|
subSubArray = subArray[otherPosition[1]];
|
|
}
|
|
else {
|
|
if (j < otherPosition[1]) {
|
|
subSubArray = subArray[j];
|
|
}
|
|
else {
|
|
subSubArray = subArray[j + 1];
|
|
}
|
|
}
|
|
print(result['total'],subSubArray,i,j);
|
|
assertEqual(result['total'],subSubArray);
|
|
}
|
|
}
|
|
print("End Lookup");
|
|
return;
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
// ...........................................................................
|
|
// In this test we have not specified a bitarray column for values outside
|
|
// the range 0-9.
|
|
// ...........................................................................
|
|
|
|
testLookupBitarrayIndex_2 : function () {
|
|
var idx;
|
|
var n = 100;
|
|
var bitarrayValues = [0,1,2,3,4,5,6,7,8,9];
|
|
var shelves = new Array(bitarrayValues.length + 2);
|
|
var docs = new Array();
|
|
var result;
|
|
|
|
|
|
// .........................................................................
|
|
// initialise our counters to 0
|
|
// .........................................................................
|
|
|
|
for (var j = 0; j < shelves.length; ++j) {
|
|
shelves[j] = 0;
|
|
}
|
|
|
|
// .........................................................................
|
|
// Create a bit array index with one attribute
|
|
// .........................................................................
|
|
|
|
idx = collection.ensureBitarray("x",bitarrayValues);
|
|
|
|
|
|
// .........................................................................
|
|
// Save n random records
|
|
// .........................................................................
|
|
|
|
print("Start writing",n," documents into index");
|
|
|
|
for (var j = 0; j < n; ++j) {
|
|
var value = Math.floor(Math.random()*(bitarrayValues.length + 5));
|
|
var alpha = Math.floor(Math.random()*(bitarrayValues.length + 5));
|
|
var doc;
|
|
|
|
doc = collection.save({"x":value, "y":{"a":1,"z":String.fromCharCode(97 + alpha)} });
|
|
docs.push(doc._id);
|
|
if (value > bitarrayValues[bitarrayValues.length - 1]) {
|
|
shelves[shelves.length - 2] = shelves[shelves.length - 2] + 1;
|
|
}
|
|
else {
|
|
shelves[value] = shelves[value] + 1;
|
|
}
|
|
}
|
|
|
|
print("End writing",n," documents into index");
|
|
|
|
for (var j = 0; j < (shelves.length - 1) ; ++j) {
|
|
shelves[shelves.length - 1] = shelves[shelves.length - 1] + shelves[j];
|
|
}
|
|
|
|
// .........................................................................
|
|
// Ensure that we have the total number of written documents stored in the
|
|
// last position
|
|
// .........................................................................
|
|
|
|
assertEqual(shelves[shelves.length - 1], n);
|
|
|
|
|
|
print("Start Lookup");
|
|
print(shelves);
|
|
for (var j = 0; j < bitarrayValues.length; ++j) {
|
|
result = collection.BY_EXAMPLE_BITARRAY(idx.id,{"x":j,"y":6,"z":-1}, null, null);
|
|
print(result['total'],shelves[j]);
|
|
assertEqual(result['total'],shelves[j]);
|
|
}
|
|
|
|
result = collection.BY_EXAMPLE_BITARRAY(idx.id,{"x":"hi there"}, null, null);
|
|
assertEqual(result['total'],shelves[bitarrayValues.length]);
|
|
|
|
print("End Lookup");
|
|
return;
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
*/
|
|
};
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- main
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief executes the test suites
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
print("Starting the bitarray index suite of tests");
|
|
jsunity.run(BitarrayIndexSuite);
|
|
print("ending the bitarray index suite of tests");
|
|
return jsunity.done();
|
|
|
|
// Local Variables:
|
|
// mode: outline-minor
|
|
// outline-regexp: "^\\(/// @brief\\|/// @addtogroup\\|// --SECTION--\\|/// @page\\|/// @}\\)"
|
|
// End:
|