text: // Check that doing updates done during a migrate all go to the right place
  (function() {
  
      var s = new ShardingTest({
          name: "slow_sharding_balance4",
          shards: 2,
          mongos: 1,
          other: {chunkSize: 1, enableAutoSplit: true}
      });
  
      s.adminCommand({enablesharding: "test"});
      s.ensurePrimaryShard('test', 'shard0001');
      s.adminCommand({shardcollection: "test.foo", key: {_id: 1}});
      assert.eq(1, s.config.chunks.count(), "setup1");
  
      s.config.settings.find().forEach(printjson);
  
      db = s.getDB("test");
  
      bigString = "";
      while (bigString.length < 10000)
          bigString += "asdasdasdasdadasdasdasdasdasdasdasdasda";
  
      N = 3000;
  
      num = 0;
  
      counts = {};
  
      //
      // TODO: Rewrite to make much clearer.
      //
      // The core behavior of this test is to add a bunch of documents to a sharded collection, then
      // incrementally update each document and make sure the counts in the document match our update
      // counts while balancing occurs (doUpdate()).  Every once in a while we also check (check())
      // our counts via a query.
      //
      // If during a chunk migration an update is missed, we trigger an assertion and fail.
      //
  
      function doUpdate(bulk, includeString, optionalId) {
          var up = {
              $inc: {x: 1}
          };
          if (includeString)
              up["$set"] = {
                  s: bigString
              };
          var myid = optionalId == undefined ? Random.randInt(N) : optionalId;
          bulk.find({_id: myid}).upsert().update(up);
  
          counts[myid] = (counts[myid] ? counts[myid] : 0) + 1;
          return myid;
      }
  
      // Initially update all documents from 1 to N, otherwise later checks can fail because no
      // document
      // previously existed
      var bulk = db.foo.initializeUnorderedBulkOp();
      for (i = 0; i < N; i++) {
          doUpdate(bulk, true, i);
      }
  
      for (i = 0; i < N * 9; i++) {
          doUpdate(bulk, false);
      }
      assert.writeOK(bulk.execute());
  
      for (var i = 0; i < 50; i++) {
          s.printChunks("test.foo");
          if (check("initial:" + i, true))
              break;
          sleep(5000);
      }
      check("initial at end");
  
      assert.lt(20, s.config.chunks.count(), "setup2");
  
      function check(msg, dontAssert) {
          for (var x in counts) {
              var e = counts[x];
              var z = db.foo.findOne({_id: parseInt(x)});
  
              if (z && z.x == e)
                  continue;
  
              if (dontAssert) {
                  if (z)
                      delete z.s;
                  print("not asserting for key failure: " + x + " want: " + e + " got: " + tojson(z));
                  return false;
              }
  
              s.s.getDB("admin").runCommand({setParameter: 1, logLevel: 2});
  
              printjson(db.foo.findOne({_id: parseInt(x)}));
  
              var y = db.foo.findOne({_id: parseInt(x)});
  
              if (y) {
                  delete y.s;
              }
  
              s.printChunks("test.foo");
  
              assert(z, "couldn't find : " + x + " y:" + tojson(y) + " e: " + e + " " + msg);
              assert.eq(e, z.x, "count for : " + x + " y:" + tojson(y) + " " + msg);
          }
  
          return true;
      }
  
      function diff1() {
          jsTest.log("Running diff1...");
  
          bulk = db.foo.initializeUnorderedBulkOp();
          var myid = doUpdate(bulk, false);
          var res = assert.writeOK(bulk.execute());
  
          assert.eq(1,
                    res.nModified,
                    "diff myid: " + myid + " 2: " + res.toString() + "\n" + " correct count is: " +
                        counts[myid] + " db says count is: " + tojson(db.foo.findOne({_id: myid})));
  
          var x = s.chunkCounts("foo");
          if (Math.random() > .999)
              printjson(x);
          return Math.max(x.shard0000, x.shard0001) - Math.min(x.shard0000, x.shard0001);
      }
  
      assert.lt(20, diff1(), "initial load");
      print(diff1());
  
      s.startBalancer();
  
      assert.soon(function() {
          var d = diff1();
          return d < 5;
      }, "balance didn't happen", 1000 * 60 * 20, 1);
  
      s.stop();
  
  })();
  