Revert "SERVER-13741 Migrate remaining tests to use write commands"

This reverts commit 87dc3ae516e1d12a632dc604710661e38ed7b3dd.

1 files changed, 384 insertions, 355 deletions

diff --git a/jstests/noPassthrough/geo_full.js b/jstests/noPassthrough/geo_full.js
index 9d9203242d3..ffeb26a2606 100644
--- a/jstests/noPassthrough/geo_full.js
+++ b/jstests/noPassthrough/geo_full.js
@@ -22,89 +22,96 @@ testServer = new SlowWeeklyMongod( "geo_full" )
 db = testServer.getDB( "test" );
 
 var randEnvironment = function(){
-
-    // Normal earth environment
-    if( Random.rand() < 0.5 ){
-        return { max : 180,
-                 min : -180,
-                 bits : Math.floor( Random.rand() * 32 ) + 1,
-                 earth : true,
-                 bucketSize : 360 / ( 4 * 1024 * 1024 * 1024 ) };
-    }
-
-    var scales = [ 0.0001, 0.001, 0.01, 0.1, 1, 10, 100, 1000, 10000, 100000 ]
-    var scale = scales[ Math.floor( Random.rand() * scales.length ) ]
-    var offset = Random.rand() * scale
-
+	
+	// Normal earth environment
+	if( Random.rand() < 0.5 ){
+		return { max : 180, 
+				 min : -180, 
+				 bits : Math.floor( Random.rand() * 32 ) + 1, 
+				 earth : true,
+				 bucketSize : 360 / ( 4 * 1024 * 1024 * 1024 ) }
+	}
+	
+	var scales = [ 0.0001, 0.001, 0.01, 0.1, 1, 10, 100, 1000, 10000, 100000 ]
+	var scale = scales[ Math.floor( Random.rand() * scales.length ) ]
+	var offset = Random.rand() * scale
+	
     var max = Random.rand() * scale + offset
-    var min = - Random.rand() * scale + offset
-    var bits = Math.floor( Random.rand() * 32 ) + 1
-    var bits = Math.floor( Random.rand() * 32 ) + 1
-    var range = max - min
+	var min = - Random.rand() * scale + offset
+	var bits = Math.floor( Random.rand() * 32 ) + 1
+	var bits = Math.floor( Random.rand() * 32 ) + 1
+	var range = max - min
     var bucketSize = range / ( 4 * 1024 * 1024 * 1024 )
-
-    return { max : max,
-             min : min,
-             bits : bits,
-             earth : false,
-             bucketSize : bucketSize }
-};
+    	
+	return { max : max,
+		     min : min,
+		     bits : bits,
+		     earth : false,
+		     bucketSize : bucketSize }
+	
+}
 
 var randPoint = function( env, query ) {
-
-    if( query && Random.rand() > 0.5 )
-        return query.exact
-
-    if( env.earth )
-        return [ Random.rand() * 360 - 180, Random.rand() * 180 - 90 ]
-
-    var range = env.max - env.min
-    return [ Random.rand() * range + env.min, Random.rand() * range + env.min ];
+	
+	if( query && Random.rand() > 0.5 )
+		return query.exact
+	
+	if( env.earth )
+		return [ Random.rand() * 360 - 180, Random.rand() * 180 - 90 ]
+	
+	var range = env.max - env.min
+	return [ Random.rand() * range + env.min, Random.rand() * range + env.min ];
 }
 
 var randLocType = function( loc, wrapIn ){
-    return randLocTypes( [ loc ], wrapIn )[0]
+	return randLocTypes( [ loc ], wrapIn )[0]
 }
 
 var randLocTypes = function( locs, wrapIn ) {
-
-    var rLocs = []
-
-    for( var i = 0; i < locs.length; i++ ){
+	
+	var rLocs = []
+	
+	for( var i = 0; i < locs.length; i++ ){
         rLocs.push( locs[i] )
-    }
-
-    if( wrapIn ){
-        var wrappedLocs = []
-        for( var i = 0; i < rLocs.length; i++ ){
-            var wrapper = {}
-            wrapper[wrapIn] = rLocs[i]
-            wrappedLocs.push( wrapper )
-        }
-
-        return wrappedLocs
-    }
-
-    return rLocs
-};
+        // {x:1, y:1} \ne [1,1].
+		//if( Random.rand() < 0.5 )
+			//rLocs.push( { x : locs[i][0], y : locs[i][1] } )
+		//else
+	}
+	
+	if( wrapIn ){
+		var wrappedLocs = []
+		for( var i = 0; i < rLocs.length; i++ ){
+			var wrapper = {}
+			wrapper[wrapIn] = rLocs[i]
+			wrappedLocs.push( wrapper )
+		}
+		
+		return wrappedLocs
+	}
+	
+	return rLocs
+	
+}
 
 var randDataType = function() {
 
-    var scales = [ 1, 10, 100, 1000, 10000 ]
-    var docScale = scales[ Math.floor( Random.rand() * scales.length ) ]
-    var locScale = scales[ Math.floor( Random.rand() * scales.length ) ]
-
-    var numDocs = 40000
-    var maxLocs = 40000
-    // Make sure we don't blow past our test resources
-    while( numDocs * maxLocs > 40000 ){
-        numDocs = Math.floor( Random.rand() * docScale ) + 1
-        maxLocs = Math.floor( Random.rand() * locScale ) + 1
-    }
-
-    return { numDocs : numDocs,
-             maxLocs : maxLocs }
-};
+	var scales = [ 1, 10, 100, 1000, 10000 ]
+	var docScale = scales[ Math.floor( Random.rand() * scales.length ) ]	
+	var locScale = scales[ Math.floor( Random.rand() * scales.length ) ]
+	
+	var numDocs = 40000
+	var maxLocs = 40000
+	// Make sure we don't blow past our test resources
+	while( numDocs * maxLocs > 40000 ){
+		numDocs = Math.floor( Random.rand() * docScale ) + 1
+		maxLocs = Math.floor( Random.rand() * locScale ) + 1
+	}
+			
+	return { numDocs : numDocs,
+			 maxLocs : maxLocs }
+	
+}
 
 function deg2rad(arg) { return arg * Math.PI / 180.0; }
 function rad2deg(arg) { return arg * 180.0 / Math.PI; }
@@ -133,181 +140,194 @@ function pointIsOK(startPoint, radius, env) {
 }
 
 var randQuery = function( env ) {
-    var center = randPoint( env )
-
-    var sphereRadius = -1
-    var sphereCenter = null
-    if( env.earth ){
-        // Get a start point that doesn't require wrapping
-        // TODO: Are we a bit too aggressive with wrapping issues?
-        var i
-        for( i = 0; i < 5; i++ ){
+	
+	var center = randPoint( env )
+	
+	var sphereRadius = -1
+	var sphereCenter = null
+	if( env.earth ){
+		// Get a start point that doesn't require wrapping
+		// TODO: Are we a bit too aggressive with wrapping issues?
+		var i
+		for( i = 0; i < 5; i++ ){
             sphereRadius = Random.rand() * 45 * Math.PI / 180
             sphereCenter = randPoint( env )
             if (pointIsOK(sphereCenter, sphereRadius, env)) { break; }
-        }
-        if( i == 5 ) sphereRadius = -1;
-
-    }
-
-    var box = [ randPoint( env ), randPoint( env ) ]
-
-    var boxPoly = [[ box[0][0], box[0][1] ],
-                   [ box[0][0], box[1][1] ],
-                   [ box[1][0], box[1][1] ],
-                   [ box[1][0], box[0][1] ] ]
-
-    if( box[0][0] > box[1][0] ){
-        var swap = box[0][0]
-        box[0][0] = box[1][0]
-        box[1][0] = swap
-    }
-
-    if( box[0][1] > box[1][1] ){
-        var swap = box[0][1]
-        box[0][1] = box[1][1]
-        box[1][1] = swap
-    }
+            /*
+			var t = db.testSphere; t.drop(); t.ensureIndex({ loc : "2d" }, env )
+			try{ t.find({ loc : { $within : { $centerSphere : [ sphereCenter, sphereRadius ] } } } ).count(); var err; if( err = db.getLastError() ) throw err;  }
+			catch(e) { print( e ); continue }
+			print( " Radius " + sphereRadius + " and center " + sphereCenter + " ok ! ")
+			break;
+            */
+		}
+		if( i == 5 ) sphereRadius = -1;
+	
+	}
+		
+	var box = [ randPoint( env ), randPoint( env ) ]
+	
+	var boxPoly = [[ box[0][0], box[0][1] ], 
+	               [ box[0][0], box[1][1] ], 
+	               [ box[1][0], box[1][1] ], 
+	               [ box[1][0], box[0][1] ] ]
+	
+	if( box[0][0] > box[1][0] ){
+		var swap = box[0][0]
+		box[0][0] = box[1][0]
+		box[1][0] = swap
+	}
+	
+	if( box[0][1] > box[1][1] ){
+		var swap = box[0][1]
+		box[0][1] = box[1][1]
+		box[1][1] = swap
+	}
+	
+	return { center : center,
+		     radius : box[1][0] - box[0][0],
+		     exact : randPoint( env ),
+		     sphereCenter : sphereCenter,
+		     sphereRadius : sphereRadius,
+			 box : box,
+			 boxPoly : boxPoly }
+	
+}
 
-    return { center : center,
-             radius : box[1][0] - box[0][0],
-             exact : randPoint( env ),
-             sphereCenter : sphereCenter,
-             sphereRadius : sphereRadius,
-             box : box,
-             boxPoly : boxPoly }
-};
 
 var resultTypes = {
 "exact" : function( loc ){
-    return query.exact[0] == loc[0] && query.exact[1] == loc[1]
+	return query.exact[0] == loc[0] && query.exact[1] == loc[1]
 },
 "center" : function( loc ){
-    return Geo.distance( query.center, loc ) <= query.radius
+	return Geo.distance( query.center, loc ) <= query.radius
 },
 "box" : function( loc ){
-    return loc[0] >= query.box[0][0] && loc[0] <= query.box[1][0] &&
-           loc[1] >= query.box[0][1] && loc[1] <= query.box[1][1]
-
-},
+	return loc[0] >= query.box[0][0] && loc[0] <= query.box[1][0] &&
+	 	   loc[1] >= query.box[0][1] && loc[1] <= query.box[1][1]
+	
+}, 
 "sphere" : function( loc ){
-    return ( query.sphereRadius >= 0 ?
-             ( Geo.sphereDistance( query.sphereCenter, loc ) <= query.sphereRadius ) : false );
-},
+	return ( query.sphereRadius >= 0 ? ( Geo.sphereDistance( query.sphereCenter, loc ) <= query.sphereRadius ) : false )
+}, 
 "poly" : function( loc ){
-    return loc[0] >= query.box[0][0] && loc[0] <= query.box[1][0] &&
-           loc[1] >= query.box[0][1] && loc[1] <= query.box[1][1];
+	return loc[0] >= query.box[0][0] && loc[0] <= query.box[1][0] &&
+ 	       loc[1] >= query.box[0][1] && loc[1] <= query.box[1][1] 
 }}
 
 var queryResults = function( locs, query, results ){
-
-    if( ! results["center"] ){
-        for( var type in resultTypes ){
-            results[type] = {
-                docsIn : 0,
-                docsOut : 0,
-                locsIn : 0,
-                locsOut : 0
-            }
-        }
-    }
-
-    var indResults = {}
-    for( var type in resultTypes ){
-        indResults[type] = {
-            docIn : false,
-            locsIn : 0,
-            locsOut : 0
-        }
-    }
-
-    for( var type in resultTypes ){
-
-        var docIn = false
-        for( var i = 0; i < locs.length; i++ ){
-            if( resultTypes[type]( locs[i] ) ){
-                results[type].locsIn++
-                indResults[type].locsIn++
-                indResults[type].docIn = true
-            }
-            else{
-                results[type].locsOut++
-                indResults[type].locsOut++
-            }
-        }
-        if( indResults[type].docIn ) results[type].docsIn++
-        else results[type].docsOut++
-
-    }
-
-    return indResults
+		
+	if( ! results["center"] ){	
+		for( var type in resultTypes ){
+			results[type] = {
+			    docsIn : 0,
+				docsOut : 0,
+				locsIn : 0,
+				locsOut : 0
+			}
+		}		
+	}
+	
+	var indResults = {}
+	for( var type in resultTypes ){
+		indResults[type] = {
+		    docIn : false,
+			locsIn : 0,
+			locsOut : 0
+		}
+	}
+	
+	for( var type in resultTypes ){
+		
+		var docIn = false
+		for( var i = 0; i < locs.length; i++ ){
+			if( resultTypes[type]( locs[i] ) ){
+				results[type].locsIn++
+				indResults[type].locsIn++
+				indResults[type].docIn = true
+			}
+			else{
+				results[type].locsOut++
+				indResults[type].locsOut++
+			}
+		}
+		if( indResults[type].docIn ) results[type].docsIn++
+		else results[type].docsOut++
+		
+	}
+	
+	return indResults
+	
 }
 
 var randQueryAdditions = function( doc, indResults ){
-
-    for( var type in resultTypes ){
-        var choice = Random.rand()
-        if( Random.rand() < 0.25 )
-            doc[type] = ( indResults[type].docIn ? { docIn : "yes" } : { docIn : "no" } )
-        else if( Random.rand() < 0.5 )
-            doc[type] = ( indResults[type].docIn ? { docIn : [ "yes" ] } : { docIn : [ "no" ] } )
-        else if( Random.rand() < 0.75 )
-            doc[type] = ( indResults[type].docIn ? [ { docIn : "yes" } ] : [ { docIn : "no" } ] )
-        else
-            doc[type] = ( indResults[type].docIn ? [{ docIn: [ "yes" ] }] : [{ docIn: [ "no" ] }]);
-    }
+	
+	for( var type in resultTypes ){
+		var choice = Random.rand()
+		if( Random.rand() < 0.25 )
+			doc[type] = ( indResults[type].docIn ? { docIn : "yes" } : { docIn : "no" } )
+		else if( Random.rand() < 0.5 )
+			doc[type] = ( indResults[type].docIn ? { docIn : [ "yes" ] } : { docIn : [ "no" ] } )
+		else if( Random.rand() < 0.75 )
+			doc[type] = ( indResults[type].docIn ? [ { docIn : "yes" } ] : [ { docIn : "no" } ] )
+		else
+			doc[type] = ( indResults[type].docIn ? [ { docIn : [ "yes" ] } ] : [ { docIn : [ "no" ] } ] )	
+	}
+	
 }
 
 var randIndexAdditions = function( indexDoc ){
-
-    for( var type in resultTypes ){
-
-        if( Random.rand() < 0.5 ) continue;
-
-        var choice = Random.rand()
-        if( Random.rand() < 0.5 )
-            indexDoc[type] = 1
-        else
-            indexDoc[type + ".docIn"] = 1;
-    }
-};
+	
+	for( var type in resultTypes ){
+		
+		if( Random.rand() < 0.5 ) continue;
+		
+		var choice = Random.rand()
+		if( Random.rand() < 0.5 )
+			indexDoc[type] = 1
+		else
+			indexDoc[type + ".docIn"] = 1	
+	
+	}
+	
+}
 
 var randYesQuery = function(){
-
-    var choice = Math.floor( Random.rand() * 7 )
-    if( choice == 0 )
-        return  { $ne : "no" }
-    else if( choice == 1 )
-        return "yes"
-    else if( choice == 2 )
-        return /^yes/
-    else if( choice == 3 )
-        return { $in : [ "good", "yes", "ok" ] }
-    else if( choice == 4 )
-        return { $exists : true }
-    else if( choice == 5 )
-        return { $nin : [ "bad", "no", "not ok" ] }
-    else if( choice == 6 )
-        return { $not : /^no/ }
+	
+	var choice = Math.floor( Random.rand() * 7 )
+	if( choice == 0 )
+		return  { $ne : "no" }
+	else if( choice == 1 )
+		return "yes"
+	else if( choice == 2 )
+		return /^yes/
+	else if( choice == 3 )
+		return { $in : [ "good", "yes", "ok" ] }
+	else if( choice == 4 )
+		return { $exists : true }
+	else if( choice == 5 )
+		return { $nin : [ "bad", "no", "not ok" ] }
+	else if( choice == 6 )
+		return { $not : /^no/ }
 }
 
 var locArray = function( loc ){
-    if( loc.x ) return [ loc.x, loc.y ]
-    if( ! loc.length ) return [ loc[0], loc[1] ]
-    return loc
+	if( loc.x ) return [ loc.x, loc.y ]
+	if( ! loc.length ) return [ loc[0], loc[1] ]
+	return loc
 }
 
 var locsArray = function( locs ){
-    if( locs.loc ){
-        arr = []
-        for( var i = 0; i < locs.loc.length; i++ ) arr.push( locArray( locs.loc[i] ) )
-        return arr
-    }
-    else{
-        arr = []
-        for( var i = 0; i < locs.length; i++ ) arr.push( locArray( locs[i].loc ) )
-        return arr
-    }
+	if( locs.loc ){
+		arr = []
+		for( var i = 0; i < locs.loc.length; i++ ) arr.push( locArray( locs.loc[i] ) )
+		return arr
+	}
+	else{
+		arr = []
+		for( var i = 0; i < locs.length; i++ ) arr.push( locArray( locs[i].loc ) )
+		return arr
+	}
 }
 
 var minBoxSize = function( env, box ){
@@ -315,16 +335,16 @@ var minBoxSize = function( env, box ){
 }
 
 var minBucketScale = function( env, box ){
-
+        
     if( box.length && box[0].length )
         box = [ box[0][0] - box[1][0], box[0][1] - box[1][1] ]
-
+    
     if( box.length )
         box = Math.max( box[0], box[1] )
-
+        
     print( box )
     print( env.bucketSize )
-
+        
     return Math.ceil( Math.log( box / env.bucketSize ) / Math.log( 2 ) )
 
 }
@@ -332,114 +352,119 @@ var minBucketScale = function( env, box ){
 // TODO:  Add spherical $uniqueDocs tests
 var numTests = 100
 
-// Our seed will change every time this is run, but
+// Our seed will change every time this is run, but 
 // each individual test will be reproducible given
 // that seed and test number
 var seed = new Date().getTime()
 //seed = 175 + 288 + 12
 
 for ( var test = 0; test < numTests; test++ ) {
-
-    Random.srand( seed + test );
-    //Random.srand( 42240 )
-    //Random.srand( 7344 )
-    var t = db.testAllGeo
-    t.drop()
-
-    print( "Generating test environment #" + test )
-    var env = randEnvironment()
-    //env.bits = 11
-    var query = randQuery( env )
-    var data = randDataType()
-    //data.numDocs = 5; data.maxLocs = 1;
-    var paddingSize = Math.floor( Random.rand() * 10 + 1 )
-    var results = {}
-    var totalPoints = 0
-    print( "Calculating target results for " + data.numDocs + " docs with max " + data.maxLocs + " locs " )
-
-    var bulk = t.initializeUnorderedBulkOp();
-    for ( var i = 0; i < data.numDocs; i++ ) {
-        var numLocs = Math.floor( Random.rand() * data.maxLocs + 1 )
-        totalPoints += numLocs
-
-        var multiPoint = []
-        for ( var p = 0; p < numLocs; p++ ) {
-            var point = randPoint( env, query )
-            multiPoint.push( point )
-        }
-
-        var indResults = queryResults( multiPoint, query, results )
-
-        var doc
-        // Nest the keys differently
-        if( Random.rand() < 0.5 )
-            doc = { locs : { loc : randLocTypes( multiPoint ) } }
-        else
-            doc = { locs : randLocTypes( multiPoint, "loc" ) }
-
-        randQueryAdditions( doc, indResults )
-
-        doc._id = i
-        bulk.insert( doc );
-    }
-    assert.writeOK(bulk.execute());
-
-    var indexDoc = { "locs.loc" : "2d" };
-    randIndexAdditions( indexDoc );
-    t.ensureIndex( indexDoc, env );
-    assert.isnull( db.getLastError() );
-
-    var padding = "x"
-    for( var i = 0; i < paddingSize; i++ ) padding = padding + padding
-
-    print( padding )
-
-    printjson( { seed : seed,
-                 test: test,
-                 env : env,
-                 query : query,
-                 data : data,
-                 results : results,
-                 paddingSize : paddingSize } )
-
-    // exact
-    print( "Exact query..." )
-    assert.eq( results.exact.docsIn, t.find( { "locs.loc" : randLocType( query.exact ), "exact.docIn" : randYesQuery() } ).count() )
-
-    // $center
-    print( "Center query..." )
-    print( "Min box : " + minBoxSize( env, query.radius ) )
-    assert.eq( results.center.docsIn, t.find( { "locs.loc" : { $within : { $center : [ query.center, query.radius ], $uniqueDocs : 1 } }, "center.docIn" : randYesQuery() } ).count() )
-
-    print( "Center query update..." )
-    var res = t.update({ "locs.loc": { $within: { $center: [ query.center, query.radius ],
-                                                  $uniqueDocs: true }},
-                         "center.docIn": randYesQuery() },
-                       { $set: { centerPaddingA: padding }}, false, true);
-    assert.eq( results.center.docsIn, res.nModified );
-
-    if( query.sphereRadius >= 0 ){
-
-        print( "Center sphere query...")
-        // $centerSphere
-        assert.eq( results.sphere.docsIn, t.find( { "locs.loc" : { $within : { $centerSphere : [ query.sphereCenter, query.sphereRadius ] } }, "sphere.docIn" : randYesQuery() } ).count() )
-
-        print( "Center sphere query update..." )
-        res = t.update({ "locs.loc": { $within: {
-                                       $centerSphere: [ query.sphereCenter, query.sphereRadius ],
-                                       $uniqueDocs: true } },
-                         "sphere.docIn" : randYesQuery() },
-                       { $set: { spherePaddingA: padding } }, false, true);
-        assert.eq( results.sphere.docsIn, res.nModified );
-    }
-
-    // $box
-    print( "Box query..." )
-    assert.eq( results.box.docsIn, t.find( { "locs.loc" : { $within : { $box : query.box, $uniqueDocs : true } }, "box.docIn" : randYesQuery() } ).count() )
-
-    // $polygon
-    print( "Polygon query..." )
-    assert.eq( results.poly.docsIn, t.find( { "locs.loc" : { $within : { $polygon : query.boxPoly } }, "poly.docIn" : randYesQuery() } ).count() )
+	
+	Random.srand( seed + test );
+	//Random.srand( 42240 )
+	//Random.srand( 7344 )
+	var t = db.testAllGeo
+	t.drop()
+	
+	print( "Generating test environment #" + test )
+	var env = randEnvironment()
+	//env.bits = 11
+	var query = randQuery( env )
+	var data = randDataType()
+	//data.numDocs = 5; data.maxLocs = 1;
+	var paddingSize = Math.floor( Random.rand() * 10 + 1 )
+	var results = {}
+	var totalPoints = 0
+	print( "Calculating target results for " + data.numDocs + " docs with max " + data.maxLocs + " locs " )
+
+	// Index after a random number of docs added
+	var indexIt = Math.floor( Random.rand() * data.numDocs )
+		
+	for ( var i = 0; i < data.numDocs; i++ ) {
+
+		if( indexIt == i ){
+			var indexDoc = { "locs.loc" : "2d" }
+			randIndexAdditions( indexDoc )
+			
+			// printjson( indexDoc )
+			
+			t.ensureIndex( indexDoc, env )
+			assert.isnull( db.getLastError() )
+		}
+		
+		var numLocs = Math.floor( Random.rand() * data.maxLocs + 1 )
+		totalPoints += numLocs
+		
+		var multiPoint = []
+		for ( var p = 0; p < numLocs; p++ ) {
+			var point = randPoint( env, query )
+			multiPoint.push( point )
+		}
+
+		var indResults = queryResults( multiPoint, query, results )
+		
+		var doc
+		// Nest the keys differently
+		if( Random.rand() < 0.5 )
+			doc = { locs : { loc : randLocTypes( multiPoint ) } }
+		else
+			doc = { locs : randLocTypes( multiPoint, "loc" ) }
+		
+		randQueryAdditions( doc, indResults )
+		
+		//printjson( doc )
+		doc._id = i
+		t.insert( doc )
+		
+	}
+	
+	var padding = "x"
+	for( var i = 0; i < paddingSize; i++ ) padding = padding + padding
+	
+	print( padding )
+	
+	printjson( { seed : seed,
+				 test: test,
+				 env : env,
+				 query : query,
+				 data : data,
+				 results : results,
+				 paddingSize : paddingSize } )
+								 
+	// exact
+	print( "Exact query..." )
+	assert.eq( results.exact.docsIn, t.find( { "locs.loc" : randLocType( query.exact ), "exact.docIn" : randYesQuery() } ).count() )
+		
+	// $center
+	print( "Center query..." )
+	print( "Min box : " + minBoxSize( env, query.radius ) )
+	assert.eq( results.center.docsIn, t.find( { "locs.loc" : { $within : { $center : [ query.center, query.radius ], $uniqueDocs : 1 } }, "center.docIn" : randYesQuery() } ).count() )
+	
+	print( "Center query update..." )
+	// printjson( t.find( { "locs.loc" : { $within : { $center : [ query.center, query.radius ], $uniqueDocs : 1 } }, "center.docIn" : randYesQuery() } ).toArray() )
+	t.update( { "locs.loc" : { $within : { $center : [ query.center, query.radius ], $uniqueDocs : true } }, "center.docIn" : randYesQuery() }, { $set : { "centerPaddingA" : padding } }, false, true )
+	assert.eq( results.center.docsIn, t.getDB().getLastErrorObj().n )
+	
+	if( query.sphereRadius >= 0 ){
+	    
+		print( "Center sphere query...")
+		// $centerSphere
+		assert.eq( results.sphere.docsIn, t.find( { "locs.loc" : { $within : { $centerSphere : [ query.sphereCenter, query.sphereRadius ] } }, "sphere.docIn" : randYesQuery() } ).count() )
+		
+		print( "Center sphere query update..." )
+		// printjson( t.find( { "locs.loc" : { $within : { $center : [ query.center, query.radius ], $uniqueDocs : 1 } }, "center.docIn" : randYesQuery() } ).toArray() )
+		t.update( { "locs.loc" : { $within : { $centerSphere : [ query.sphereCenter, query.sphereRadius ], $uniqueDocs : true } }, "sphere.docIn" : randYesQuery() }, { $set : { "spherePaddingA" : padding } }, false, true )
+		assert.eq( results.sphere.docsIn, t.getDB().getLastErrorObj().n )
+		
+	}
+	
+	// $box
+	print( "Box query..." )
+	assert.eq( results.box.docsIn, t.find( { "locs.loc" : { $within : { $box : query.box, $uniqueDocs : true } }, "box.docIn" : randYesQuery() } ).count() )
+	
+	// $polygon
+	print( "Polygon query..." )
+	assert.eq( results.poly.docsIn, t.find( { "locs.loc" : { $within : { $polygon : query.boxPoly } }, "poly.docIn" : randYesQuery() } ).count() )
 
     // $near, $nearSphere and geoNear results have a default document limit of 100.
     var defaultDocLimit = 100;
@@ -481,12 +506,12 @@ for ( var test = 0; test < numTests; test++ ) {
 
         var num = Math.min( 2* defaultDocLimit, 2 * results.center.docsIn);
 
-        var output = db.runCommand( {
-            geoNear : "testAllGeo",
-            near : query.center,
-            maxDistance : query.radius ,
-            includeLocs : true,
-            num : num } ).results
+		var output = db.runCommand( {
+			geoNear : "testAllGeo", 
+			near : query.center, 
+			maxDistance : query.radius ,
+			includeLocs : true,
+			num : num } ).results
 
         assert.eq( Math.min( num, results.center.docsIn ),
                    output.length,
@@ -495,36 +520,40 @@ for ( var test = 0; test < numTests; test++ ) {
                    "; radius: " + query.radius +
                    "; docs: " + results.center.docsIn + "; locs: " + results.center.locsIn )
 
-        var distance = 0;
-        for ( var i = 0; i < output.length; i++ ) {
-            var retDistance = output[i].dis
-            var retLoc = locArray( output[i].loc )
-
-            var arrLocs = locsArray( output[i].obj.locs )
-
-            assert.contains( retLoc, arrLocs )
-
-            var distInObj = false
-            for ( var j = 0; j < arrLocs.length && distInObj == false; j++ ) {
-                var newDistance = Geo.distance( locArray( query.center ) , arrLocs[j] )
-                distInObj = ( newDistance >= retDistance - 0.0001 && newDistance <= retDistance + 0.0001 )
-            }
-
-            assert( distInObj )
-            assert.between( retDistance - 0.0001 , Geo.distance( locArray( query.center ), retLoc ), retDistance + 0.0001 )
-            assert.lte( retDistance, query.radius )
-            assert.gte( retDistance, distance )
-            distance = retDistance
-        }
-
-    }
-
-    // $polygon
+    	var distance = 0;
+		for ( var i = 0; i < output.length; i++ ) {
+			var retDistance = output[i].dis
+			var retLoc = locArray( output[i].loc )
+			
+			// print( "Dist from : " + results[i].loc + " to " + startPoint + " is "
+			// + retDistance + " vs " + radius )
+			
+			var arrLocs = locsArray( output[i].obj.locs )
+						
+			assert.contains( retLoc, arrLocs )
+			
+			// printjson( arrLocs )
+			
+			var distInObj = false
+			for ( var j = 0; j < arrLocs.length && distInObj == false; j++ ) {
+				var newDistance = Geo.distance( locArray( query.center ) , arrLocs[j] )
+				distInObj = ( newDistance >= retDistance - 0.0001 && newDistance <= retDistance + 0.0001 )
+			}
+			
+			assert( distInObj )
+			assert.between( retDistance - 0.0001 , Geo.distance( locArray( query.center ), retLoc ), retDistance + 0.0001 )
+			assert.lte( retDistance, query.radius )
+			assert.gte( retDistance, distance )
+			distance = retDistance
+		}
+		
+	}
+	
+	// $polygon
     print( "Polygon remove..." )
-    res = t.remove({ "locs.loc": { $within: { $polygon: query.boxPoly }},
-                     "poly.docIn": randYesQuery() });
-    assert.eq( results.poly.docsIn, res.nRemoved );
-
+    t.remove( { "locs.loc" : { $within : { $polygon : query.boxPoly } }, "poly.docIn" : randYesQuery() } )
+    assert.eq( results.poly.docsIn, t.getDB().getLastErrorObj().n )
+    	
 }