text: // Test background index creation
  
  parallel = function() {
      return db[ baseName + "_parallelStatus" ];
  }
  
  resetParallel = function() {
      parallel().drop();
  }
  
  doParallel = function(work) {
      resetParallel();
      print("doParallel: " + work);
      startMongoProgramNoConnect("mongo", "--eval", work + "; db." + baseName + "_parallelStatus.save( {done:1} );", db.getMongo().host);
  }
  
  doneParallel = function() {
      return !!parallel().findOne();
  }
  
  waitParallel = function() {
      assert.soon( function() { return doneParallel(); }, "parallel did not finish in time", 300000, 1000 );
  }
  
  // waiting on SERVER-620
  
  print( "index11.js host:" );
  print( db.getMongo().host );
  
  if (1) {
  
  size = 500000;
  while( 1 ) { // if indexing finishes before we can run checks, try indexing w/ more data
      print( "size: " + size );
      baseName = "jstests_index11";
      fullName = "db." + baseName;
      t = db[ baseName ];
      t.drop();
  
      db.eval( function( size ) {
                  for( i = 0; i < size; ++i ) {
                      db.jstests_index11.save( {i:i} );
                  }
              },
              size );
      assert.eq( size, t.count() );
      
      doParallel( fullName + ".ensureIndex( {i:1}, {background:true} )" );
      try {
          // wait for indexing to start
          print("wait for indexing to start");
          assert.soon( function() { return 2 == db.system.indexes.count( {ns:"test."+baseName} ) }, "no index created", 30000, 50 );
          print("started.");
          assert.eq( size, t.count() );
          assert.eq( 100, t.findOne( {i:100} ).i );
          q = t.find();
          for( i = 0; i < 120; ++i ) { // getmore
              q.next();
              assert( q.hasNext(), "no next" );
          }
          assert.eq( "BasicCursor", t.find( {i:100} ).explain().cursor, "used btree cursor" );
          t.remove( {i:40} );
          t.update( {i:10}, {i:-10} );
          id = t.find().hint( {$natural:-1} ).next()._id;
          t.update( {_id:id}, {i:-2} );
          t.save( {i:-50} );
          t.save( {i:size+2} );
          assert( !db.getLastError() );
  
          print("calling ensureIndex");
          t.ensureIndex( {i:1} );
  
          printjson( db.getLastError() );
          assert( db.getLastError() );
          assert.eq( size + 1, t.count() );
          assert( !db.getLastError() );
  
          print("calling dropIndex");
          t.dropIndex( {i:1} );
          printjson( db.getLastError() );
          assert( db.getLastError() );        
      } catch( e ) {
          // only a failure if we're still indexing
          // wait for parallel status to update to reflect indexing status
          print("caught exception");
          sleep( 1000 );
          if ( !doneParallel() ) {
              throw e;
          }
          print("but that's OK")
      }
      if ( !doneParallel() ) {
          break;
      }
      print( "indexing finished too soon, retrying..." );
      size *= 2;
      assert( size < 20000000, "unable to run checks in parallel with index creation" );
  }
  
  print("our tests done, waiting for parallel to finish");
  waitParallel();
  print("finished");
  
  assert.eq( "BtreeCursor i_1", t.find( {i:100} ).explain().cursor );
  assert.eq( 1, t.count( {i:-10} ) );
  assert.eq( 1, t.count( {i:-2} ) );
  assert.eq( 1, t.count( {i:-50} ) );
  assert.eq( 1, t.count( {i:size+2} ) );
  assert.eq( 0, t.count( {i:40} ) );
  assert( !db.getLastError() );
  print("about to drop index");
  t.dropIndex( {i:1} );
  printjson( db.getLastError() );
  assert( !db.getLastError() );
  
  } // if 1
  
  