SERVER-18272 Update jstests to use allocatePort() instead of hard coding ports

57 files changed, 414 insertions, 398 deletions

diff --git a/jstests/auth/auth1.js b/jstests/auth/auth1.js
index 32628e8bf57..a15d4a46995 100644
--- a/jstests/auth/auth1.js
+++ b/jstests/auth/auth1.js
@@ -3,12 +3,9 @@
 
 function setupTest() {
     print("START auth1.js");
-
-    port = allocatePorts( 1 )[ 0 ];
     baseName = "jstests_auth_auth1";
 
     m = MongoRunner.runMongod({auth: "",
-                               port: port,
                                nohttpinterface: "",
                                bind_ip: "127.0.0.1",
                                useHostname: false});
diff --git a/jstests/auth/auth3.js b/jstests/auth/auth3.js
index 2f28111da24..fde160d06ce 100644
--- a/jstests/auth/auth3.js
+++ b/jstests/auth/auth3.js
@@ -1,4 +1,8 @@
-var conn = MongoRunner.runMongod({auth : "", port : 31001});
+(function() {
+
+'use strict'
+
+var conn = MongoRunner.runMongod({ auth: "" });
 
 var admin = conn.getDB("admin");
 var errorCodeUnauthorized = 13;
@@ -24,3 +28,5 @@ conn.getDB("admin").auth("foo","bar");
 assert("inprog" in admin.currentOp());
 assert("info" in admin.killOp(123));
 assert.eq(admin.fsyncUnlock().errmsg, "not locked");
+
+})();
diff --git a/jstests/auth/localhostAuthBypass.js b/jstests/auth/localhostAuthBypass.js
index b3b40598015..1b07456fbe3 100644
--- a/jstests/auth/localhostAuthBypass.js
+++ b/jstests/auth/localhostAuthBypass.js
@@ -7,8 +7,6 @@ var baseName = "auth_server-6591";
 var dbpath = MongoRunner.dataPath + baseName;
 var username = "foo";
 var password = "bar";
-var port = allocatePorts(1)[0];
-var host = "localhost:" + port;
 
 load("jstests/libs/host_ipaddr.js");
 
@@ -101,18 +99,18 @@ var authenticate = function(mongo) {
     mongo.getDB("admin").auth(username, password);
 };
 
-var shutdown = function(mongo) {
+var shutdown = function(conn) {
     print("============ shutting down.");
-    MongoRunner.stopMongod(port, /*signal*/false, { auth: { user: username, pwd: password}});
+    MongoRunner.stopMongod(conn.port, /*signal*/false, { auth: { user: username, pwd: password}});
 };
 
 var runTest = function(useHostName) {
     print("==========================");
     print("starting mongod: useHostName=" + useHostName);
     print("==========================");
-    MongoRunner.runMongod({auth: "", port: port, dbpath: dbpath, useHostName: useHostName});
+    var conn = MongoRunner.runMongod({auth: "", dbpath: dbpath, useHostName: useHostName});
 
-    var mongo = new Mongo(host);
+    var mongo = new Mongo("localhost:" + conn.port);
 
     assertCannotRunCommands(mongo);
 
@@ -125,7 +123,7 @@ var runTest = function(useHostName) {
     assertCanRunCommands(mongo);
 
     print("============ reconnecting with new client.");
-    mongo = new Mongo(host);
+    mongo = new Mongo("localhost:" + conn.port);
 
     assertCannotRunCommands(mongo);
 
@@ -133,26 +131,26 @@ var runTest = function(useHostName) {
 
     assertCanRunCommands(mongo);
 
-    shutdown(mongo);
+    shutdown(conn);
 };
 
-var runNonlocalTest = function(hostPort) {
+var runNonlocalTest = function(host) {
     print("==========================");
-    print("starting mongod: non-local host access "+hostPort);
+    print("starting mongod: non-local host access " + host);
     print("==========================");
-    MongoRunner.runMongod({auth: "", port: port, dbpath: dbpath});
+    var conn = MongoRunner.runMongod({auth: "", dbpath: dbpath});
 
-    var mongo = new Mongo(hostPort);
+    var mongo = new Mongo(host + ":" + conn.port);
 
     assertCannotRunCommands(mongo);
     assert.throws(function() { mongo.getDB("admin").createUser
         ({ user:username, pwd: password, roles: jsTest.adminUserRoles }); });
     assert.throws(function() { mongo.getDB("$external").createUser
         ({ user:username, pwd: password, roles: jsTest.adminUserRoles }); });
-    shutdown(mongo);
+    shutdown(conn);
 };
 
 runTest(false);
 runTest(true);
 
-runNonlocalTest(get_ipaddr()+":"+port);
+runNonlocalTest(get_ipaddr());
diff --git a/jstests/auth/logout_reconnect.js b/jstests/auth/logout_reconnect.js
index 20d46836780..119284ce9d4 100644
--- a/jstests/auth/logout_reconnect.js
+++ b/jstests/auth/logout_reconnect.js
@@ -4,11 +4,8 @@
  * It is a regression test for SERVER-8798.
  */
 
-port = allocatePorts( 1 )[ 0 ];
-
-conn = MongoRunner.runMongod({ 
+var conn = MongoRunner.runMongod({
     auth : "",
-    port : port,
     remember : true
 });
 
diff --git a/jstests/auth/server-4892.js b/jstests/auth/server-4892.js
index 12fc0d8c067..3053fcab4dc 100644
--- a/jstests/auth/server-4892.js
+++ b/jstests/auth/server-4892.js
@@ -7,24 +7,25 @@
 
 var baseName = 'jstests_auth_server4892';
 var dbpath = MongoRunner.dataPath + baseName;
-var port = allocatePorts( 1 )[ 0 ];
-var mongod_common_args = [
-    '--port', port, '--dbpath', dbpath, '--bind_ip', '127.0.0.1', '--nohttpinterface' ];
+resetDbpath(dbpath);
+var mongodCommonArgs = {
+    dbpath: dbpath,
+    noCleanData: true,
+};
 
 /*
  * Start an instance of mongod, pass it as a parameter to operation(), then stop the instance of
  * mongod before unwinding or returning out of with_mongod().
  *
- * extra_mongod_args are extra arguments to pass on the mongod command line, in an Array.
+ * 'extraMongodArgs' are extra arguments to pass on the mongod command line, as an object.
  */
-function with_mongod( extra_mongod_args, operation ) {
-    var mongod = startMongoProgram.apply(
-        null, ['mongod'].concat( mongod_common_args, extra_mongod_args ) );
+function withMongod(extraMongodArgs, operation) {
+    var mongod = MongoRunner.runMongod(Object.merge(mongodCommonArgs, extraMongodArgs));
 
     try {
         operation( mongod );
     } finally {
-        MongoRunner.stopMongod( port );
+        MongoRunner.stopMongod( mongod.port );
     }
 }
 
@@ -42,9 +43,7 @@ function expectNumLiveCursors(mongod, expectedNumLiveCursors) {
           + expectedNumLiveCursors + ")");
 }
 
-resetDbpath( dbpath );
-
-with_mongod( ['--noauth'], function setupTest( mongod ) {
+withMongod({noauth: ""}, function setupTest(mongod) {
     var admin, somedb, conn;
     conn = new Mongo( mongod.host );
     admin = conn.getDB( 'admin' );
@@ -59,7 +58,7 @@ with_mongod( ['--noauth'], function setupTest( mongod ) {
     admin.logout();
 } );
 
-with_mongod( ['--auth'], function runTest( mongod ) {
+withMongod({auth: ""}, function runTest(mongod) {
     var conn = new Mongo( mongod.host );
     var somedb = conn.getDB( 'somedb' );
     somedb.auth('frim', 'fram');
diff --git a/jstests/disk/directoryperdb.js b/jstests/disk/directoryperdb.js
index 157efbd07b6..b6e2ab5f9e5 100644
--- a/jstests/disk/directoryperdb.js
+++ b/jstests/disk/directoryperdb.js
@@ -1,9 +1,6 @@
 var baseDir = "jstests_disk_directoryper";
 var baseName = "directoryperdb"
-port = allocatePorts( 1 )[ 0 ];
-dbpath = MongoRunner.dataPath + baseDir + "/";
-
-
+var dbpath = MongoRunner.dataPath + baseDir + "/";
 var storageEngine = db.serverStatus().storageEngine.name;
 
 // The pattern which matches the names of database files
diff --git a/jstests/disk/filesize.js b/jstests/disk/filesize.js
index 77295c7b4bd..bb1291c0777 100644
--- a/jstests/disk/filesize.js
+++ b/jstests/disk/filesize.js
@@ -1,9 +1,8 @@
-// test for SERVER-7430: Warning about smallfiles should include filename
-var port = allocatePorts( 1 )[ 0 ];
+// Test for SERVER-7430: Warning about smallfiles should include filename
 var baseName = "filesize";
 
 // Start mongod with --smallfiles
-var m = MongoRunner.runMongod({bind_ip: "127.0.0.1", nojournal: "", smallfiles: ""});
+var m = MongoRunner.runMongod({nojournal: "", smallfiles: ""});
 
 var db = m.getDB( baseName );
 
@@ -14,7 +13,12 @@ if (db.serverBuildInfo().bits == 32) {
     // Restart mongod without --smallFiles
     MongoRunner.stopMongod(m);
     m = MongoRunner.runMongod({
-        restart: true, cleanData: false, dbpath: m.dbpath, bind_ip: "127.0.0.1", nojournal: ""});
+        restart: true,
+        cleanData: false,
+        dbpath: m.dbpath,
+        port: m.port,
+        nojournal: "",
+    });
 
     db = m.getDB( baseName );
     var log = db.adminCommand( { getLog : "global" } ).log
diff --git a/jstests/disk/killall.js b/jstests/disk/killall.js
index ba294a53504..beb3e99e778 100644
--- a/jstests/disk/killall.js
+++ b/jstests/disk/killall.js
@@ -6,19 +6,17 @@
  * would not result in a zero return code.
  */
 
-var port = allocatePorts( 1 )[ 0 ]
-
 var baseName = "jstests_disk_killall";
 var dbpath = MongoRunner.dataPath + baseName;
 
-var mongod = MongoRunner.runMongod({port: port, dbpath: dbpath});
+var mongod = MongoRunner.runMongod({dbpath: dbpath});
 var db = mongod.getDB( "test" );
 var collection = db.getCollection( baseName );
 assert.writeOK(collection.insert({}));
 
 var awaitShell = startParallelShell(
             "db." + baseName + ".count( { $where: function() { while( 1 ) { ; } } } )",
-            port);
+            mongod.port);
 sleep( 1000 );
 
 /**
@@ -36,7 +34,7 @@ exitCode = awaitShell({checkExitSuccess: false});
 assert.neq(0, exitCode, "expected shell to exit abnormally due to mongod being terminated");
 
 mongod = MongoRunner.runMongod({
-    port: port,
+    port: mongod.port,
     restart: true,
     cleanData: false,
     dbpath: mongod.dbpath
diff --git a/jstests/disk/norepeat.js b/jstests/disk/norepeat.js
deleted file mode 100644
index 1379ff1af20..00000000000
--- a/jstests/disk/norepeat.js
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
-baseName = "jstests_disk_norepeat";
-
-ports = allocatePorts( 1 );
-m = startMongod( "--port", ports[ 0 ], "--deDupMem", "200", "--dbpath", MongoRunner.dataPath + baseName, "--nohttpinterface", "--bind_ip", "127.0.0.1" );
-
-t = m.getDB( baseName ).getCollection( baseName );
-
-t.drop();
-t.ensureIndex( { i: 1 } );
-for( i = 0; i < 3; ++i ) {
-    t.save( { i: i } );
-}
-
-c = t.find().hint( { i: 1 } ).limit( 2 );
-assert.eq( 0, c.next().i );
-t.update( { i: 0 }, { i: 3 } );
-assert.eq( 1, c.next().i );
-assert.eq( 2, c.next().i );
-assert.throws( function() { c.next() }, [], "unexpected: object found" );
-
-// now force upgrade to disk storage
-
-t.drop();
-t.ensureIndex( { i: 1 } );
-for( i = 0; i < 10; ++i ) {
-    t.save( { i: i } );
-}
-// apparently this means we also request 2 in subsequent getMore's
-c = t.find().hint( {i:1} ).limit( 2 );
-assert.eq( 0, c.next().i );
-t.update( { i: 0 }, { i: 10 } );
-for( i = 1; i < 10; ++i ) {
-    if ( i == 7 ) {
-        t.update( { i: 6 }, { i: 11 } );
-        t.update( { i: 9 }, { i: 12 } );
-    }
-    if ( i == 9 ) {
-        i = 12;
-    }
-    assert.eq( i, c.next().i );
-}
-assert.throws( function() { c.next() }, [], "unexpected: object found" );
-
-m.getDB( "local" ).getCollectionNames().forEach( function( x ) { assert( !x.match( /^temp/ ), "temp collection found" ); } );
-
-t.drop();
-m.getDB( baseName ).createCollection( baseName, { capped:true, size:100000, autoIndexId:false } );
-t = m.getDB( baseName ).getCollection( baseName );
-t.insert( {_id:"a"} );
-t.insert( {_id:"a"} );
-t.insert( {_id:"a"} );
-
-c = t.find().limit( 2 );
-assert.eq( "a", c.next()._id );
-assert.eq( "a", c.next()._id );
-assert.eq( "a", c.next()._id );
-assert( !c.hasNext() );
-
-assert( t.validate().valid );
-*/
diff --git a/jstests/disk/repair.js b/jstests/disk/repair.js
index 0a92658252b..699dbabf0d8 100644
--- a/jstests/disk/repair.js
+++ b/jstests/disk/repair.js
@@ -1,15 +1,17 @@
 // check --repairpath and --repair
 
 var baseName = "jstests_disk_repair";
-
-port = allocatePorts( 1 )[ 0 ];
-dbpath = MongoRunner.dataPath + baseName + "/";
-repairpath = dbpath + "repairDir/"
+var dbpath = MongoRunner.dataPath + baseName + "/";
+var repairpath = dbpath + "repairDir/"
 
 resetDbpath( dbpath );
 resetDbpath( repairpath );
 
-m = startMongoProgram( "mongod", "--port", port, "--dbpath", dbpath, "--repairpath", repairpath, "--nohttpinterface", "--bind_ip", "127.0.0.1" );
+var m = MongoRunner.runMongod({
+    dbpath: dbpath,
+    repairpath: repairpath,
+    noCleanData: true,
+});
 db = m.getDB( baseName );
 db[ baseName ].save( {} );
 assert.commandWorked( db.runCommand( {repairDatabase:1, backupOriginalFiles:true} ) );
@@ -22,26 +24,39 @@ function check() {
     assert.eq.automsg( "1", "db[ baseName ].count()" );
 }
 check();
-MongoRunner.stopMongod( port );
+MongoRunner.stopMongod( m.port );
 
 resetDbpath( repairpath );
-m = startMongoProgram( "mongod", "--port", port, "--dbpath", dbpath, "--nohttpinterface", "--bind_ip", "127.0.0.1" );
+m = MongoRunner.runMongod({
+    port: m.port,
+    dbpath: dbpath,
+    noCleanData: true,
+});
 db = m.getDB( baseName );
 assert.commandWorked( db.runCommand( {repairDatabase:1} ) );
 check();
-MongoRunner.stopMongod( port );
+MongoRunner.stopMongod( m.port );
 
 resetDbpath( repairpath );
-rc = runMongoProgram( "mongod", "--repair", "--port", port, "--dbpath", dbpath, "--repairpath", repairpath, "--nohttpinterface", "--bind_ip", "127.0.0.1" );
+rc = runMongoProgram("mongod", "--repair", "--port", m.port, "--dbpath", dbpath,
+                     "--repairpath", repairpath);
 assert.eq.automsg( "0", "rc" );
-m = startMongoProgram( "mongod", "--port", port, "--dbpath", dbpath, "--repairpath", repairpath, "--nohttpinterface", "--bind_ip", "127.0.0.1" );
+m = MongoRunner.runMongod({
+    port: m.port,
+    dbpath: dbpath,
+    noCleanData: true,
+});
 db = m.getDB( baseName );
 check();
-MongoRunner.stopMongod( port );
+MongoRunner.stopMongod( m.port );
 
 resetDbpath( repairpath );
-rc = runMongoProgram( "mongod", "--repair", "--port", port, "--dbpath", dbpath, "--nohttpinterface", "--bind_ip", "127.0.0.1" );
+rc = runMongoProgram("mongod", "--repair", "--port", m.port, "--dbpath", dbpath);
 assert.eq.automsg( "0", "rc" );
-m = startMongoProgram( "mongod", "--port", port, "--dbpath", dbpath, "--nohttpinterface", "--bind_ip", "127.0.0.1" );
+m = MongoRunner.runMongod({
+    port: m.port,
+    dbpath: dbpath,
+    noCleanData: true,
+});
 db = m.getDB( baseName );
 check();
diff --git a/jstests/disk/repair2.js b/jstests/disk/repair2.js
index a582d06a0ec..9a8da991f2d 100644
--- a/jstests/disk/repair2.js
+++ b/jstests/disk/repair2.js
@@ -12,16 +12,20 @@ function check() {
     assert.eq.automsg( "1", "db[ baseName ].count()" );
 }
 
-port = allocatePorts( 1 )[ 0 ];
-dbpath = MongoRunner.dataPath + baseName + "/";
-repairpath = dbpath + "repairDir/";
-longDBName = Array(61).join('a');
-longRepairPath = dbpath + Array(61).join('b') + '/';
+var dbpath = MongoRunner.dataPath + baseName + "/";
+var repairpath = dbpath + "repairDir/";
+var longDBName = Array(61).join('a');
+var longRepairPath = dbpath + Array(61).join('b') + '/';
 
 resetDbpath( dbpath );
 resetDbpath( repairpath );
 
-m = startMongoProgram( "mongod", "--directoryperdb", "--port", port, "--dbpath", dbpath, "--repairpath", repairpath, "--nohttpinterface", "--bind_ip", "127.0.0.1" );
+var m = MongoRunner.runMongod({
+    directoryperdb: "",
+    dbpath: dbpath,
+    repairpath: repairpath,
+    noCleanData: true,
+});
 db = m.getDB( baseName );
 db[ baseName ].save( {} );
 assert.commandWorked( db.runCommand( {repairDatabase:1, backupOriginalFiles:true} ) );
@@ -41,48 +45,97 @@ for( f in files ) {
 assert( fileCount > 0, "Expected more than zero nondirectory files in the database directory" );
 
 check();
-MongoRunner.stopMongod( port );
+MongoRunner.stopMongod( m.port );
 
 resetDbpath( repairpath );
-m = startMongoProgram( "mongod", "--directoryperdb", "--port", port, "--dbpath", dbpath, "--nohttpinterface", "--bind_ip", "127.0.0.1" );
+m = MongoRunner.runMongod({
+    port: m.port,
+    directoryperdb: "",
+    dbpath: dbpath,
+    noCleanData: true,
+});
 db = m.getDB( baseName );
 assert.commandWorked( db.runCommand( {repairDatabase:1} ) );
 check();
-MongoRunner.stopMongod( port );
+MongoRunner.stopMongod( m.port );
 
 //Test long database names
 resetDbpath( repairpath );
-m = startMongoProgram( "mongod", "--directoryperdb", "--port", port, "--dbpath", dbpath, "--nohttpinterface", "--bind_ip", "127.0.0.1" );
+m = MongoRunner.runMongod({
+    port: m.port,
+    directoryperdb: "",
+    dbpath: dbpath,
+    noCleanData: true,
+});
 db = m.getDB( longDBName );
 assert.writeOK(db[ baseName ].save( {} ));
 assert.commandWorked( db.runCommand( {repairDatabase:1} ) );
-MongoRunner.stopMongod( port );
+MongoRunner.stopMongod( m.port );
 
 //Test long repairPath
 resetDbpath( longRepairPath )
-m = startMongoProgram( "mongod", "--directoryperdb", "--port", port, "--dbpath", dbpath, "--repairpath", longRepairPath, "--nohttpinterface", "--bind_ip", "127.0.0.1" );
+m = MongoRunner.runMongod({
+    port: m.port,
+    directoryperdb: "",
+    dbpath: dbpath,
+    repairpath: longRepairPath,
+    noCleanData: true,
+});
 db = m.getDB( longDBName );
 assert.commandWorked( db.runCommand( {repairDatabase:1, backupOriginalFiles: true} ) );
 check();
-MongoRunner.stopMongod( port );
+MongoRunner.stopMongod( m.port );
 
 //Test database name and repairPath with --repair
 resetDbpath( longRepairPath )
-m = startMongoProgram( "mongod", "--repair", "--directoryperdb", "--port", port, "--dbpath", dbpath, "--repairpath", longRepairPath, "--nohttpinterface", "--bind_ip", "127.0.0.1" );
-m = startMongoProgram( "mongod", "--directoryperdb", "--port", port, "--dbpath", dbpath, "--nohttpinterface", "--bind_ip", "127.0.0.1" );
+var returnCode = runMongoProgram("mongod",
+                                 "--port", m.port,
+                                 "--repair",
+                                 "--directoryperdb",
+                                 "--dbpath", dbpath,
+                                 "--repairpath", longRepairPath);
+assert.eq(returnCode, 0);
+m = MongoRunner.runMongod({
+    port: m.port,
+    directoryperdb: "",
+    dbpath: dbpath,
+    noCleanData: true,
+});
 db = m.getDB( longDBName );
 check();
-MongoRunner.stopMongod( port );
+MongoRunner.stopMongod( m.port );
 
 resetDbpath( repairpath );
-runMongoProgram( "mongod", "--repair", "--directoryperdb", "--port", port, "--dbpath", dbpath, "--repairpath", repairpath, "--nohttpinterface", "--bind_ip", "127.0.0.1" );
-m = startMongoProgram( "mongod", "--directoryperdb", "--port", port, "--dbpath", dbpath, "--repairpath", repairpath, "--nohttpinterface", "--bind_ip", "127.0.0.1" );
+returnCode = runMongoProgram("mongod",
+                             "--port", m.port,
+                             "--repair",
+                             "--directoryperdb",
+                             "--dbpath", dbpath,
+                             "--repairpath", repairpath);
+assert.eq(returnCode, 0);
+m = MongoRunner.runMongod({
+    port: m.port,
+    directoryperdb: "",
+    dbpath: dbpath,
+    repairpath: repairpath,
+    noCleanData: true,
+});
 db = m.getDB( baseName );
 check();
-MongoRunner.stopMongod( port );
+MongoRunner.stopMongod( m.port );
 
 resetDbpath( repairpath );
-runMongoProgram( "mongod", "--repair", "--directoryperdb", "--port", port, "--dbpath", dbpath, "--nohttpinterface", "--bind_ip", "127.0.0.1" );
-m = startMongoProgram( "mongod", "--directoryperdb", "--port", port, "--dbpath", dbpath, "--nohttpinterface", "--bind_ip", "127.0.0.1" );
+returnCode = runMongoProgram("mongod",
+                             "--port", m.port,
+                             "--repair",
+                             "--directoryperdb",
+                             "--dbpath", dbpath);
+assert.eq(returnCode, 0);
+m = MongoRunner.runMongod({
+    port: m.port,
+    directoryperdb: "",
+    dbpath: dbpath,
+    noCleanData: true,
+});
 db = m.getDB( baseName );
 check();
diff --git a/jstests/disk/repair3.js b/jstests/disk/repair3.js
index 6b4997cc83c..12c5356a2d6 100644
--- a/jstests/disk/repair3.js
+++ b/jstests/disk/repair3.js
@@ -17,15 +17,19 @@ if ( !doIt ) {
     doIt = false;
 }
 
-if ( doIt ) {
-
-    port = allocatePorts( 1 )[ 0 ];
-    dbpath = MongoRunner.dataPath + baseName + "/";
+if (doIt) {
+    var dbpath = MongoRunner.dataPath + baseName + "/";
 
     resetDbpath( dbpath );
     resetDbpath( repairpath );
 
-    m = startMongoProgram( "mongod", "--nssize", "8", "--noprealloc", "--smallfiles", "--port", port, "--dbpath", dbpath, "--repairpath", repairpath, "--nohttpinterface", "--bind_ip", "127.0.0.1" );
+    var m = MongoRunner.runMongod({
+        nssize: 8,
+        noprealloc: "",
+        smallfiles: "",
+        dbpath: dbpath,
+        repairpath: repairpath,
+    });
     db = m.getDB( baseName );
     db[ baseName ].save( {} );
     assert.commandWorked( db.runCommand( {repairDatabase:1, backupOriginalFiles:false} ) );
@@ -39,14 +43,21 @@ if ( doIt ) {
     }
 
     check();
-    MongoRunner.stopMongod( port );
+    MongoRunner.stopMongod( m.port );
 
     resetDbpath( repairpath );
-    rc = runMongoProgram( "mongod", "--nssize", "8", "--noprealloc", "--smallfiles", "--repair", "--port", port, "--dbpath", dbpath, "--repairpath", repairpath, "--nohttpinterface", "--bind_ip", "127.0.0.1" );
+    var rc = runMongoProgram("mongod", "--nssize", "8", "--noprealloc", "--smallfiles", "--repair",
+                             "--port", m.port, "--dbpath", dbpath, "--repairpath", repairpath);
     assert.eq.automsg( "0", "rc" );
-    m = startMongoProgram( "mongod", "--nssize", "8", "--noprealloc", "--smallfiles", "--port", port, "--dbpath", dbpath, "--repairpath", repairpath, "--nohttpinterface", "--bind_ip", "127.0.0.1" );
+    m = MongoRunner.runMongod({
+        nssize: 8,
+        noprealloc: "",
+        smallfiles: "",
+        port: m.port,
+        dbpath: dbpath,
+        repairpath: repairpath,
+    });
     db = m.getDB( baseName );
     check();
-    MongoRunner.stopMongod( port );
-
-}
\ No newline at end of file
+    MongoRunner.stopMongod( m.port );
+}
diff --git a/jstests/disk/repair4.js b/jstests/disk/repair4.js
index 944a4f6fd11..38049ee1f9b 100644
--- a/jstests/disk/repair4.js
+++ b/jstests/disk/repair4.js
@@ -18,14 +18,21 @@ if ( !doIt ) {
 }
 
 if ( doIt ) {
+    var repairpath = MongoRunner.dataPath + baseName + "/";
 
-    port = allocatePorts( 1 )[ 0 ];
-    repairpath = MongoRunner.dataPath + baseName + "/";
-    
     resetDbpath( smallpath );
     resetDbpath( repairpath );
     
-    m = startMongoProgram( "mongod", "--nssize", "8", "--noprealloc", "--smallfiles", "--port", port, "--dbpath", smallpath, "--repairpath", repairpath, "--nohttpinterface", "--bind_ip", "127.0.0.1" );
+    var m = MongoRunner.runMongod({
+        nssize: "8",
+        noprealloc: "",
+        smallfiles: "",
+        dbpath: smallpath,
+        repairpath: repairpath,
+        nohttpinterface: "",
+        bind_ip: "127.0.0.1",
+    });
+
     db = m.getDB( baseName );
     db[ baseName ].save( {} );
     assert.commandWorked( db.runCommand( {repairDatabase:1, backupOriginalFiles:true} ) );
@@ -41,4 +48,4 @@ if ( doIt ) {
     check();
     MongoRunner.stopMongod( port );
 
-}
\ No newline at end of file
+}
diff --git a/jstests/dur/checksum.js b/jstests/dur/checksum.js
index 2ee387261a8..ac932ab08fe 100644
--- a/jstests/dur/checksum.js
+++ b/jstests/dur/checksum.js
@@ -75,7 +75,7 @@ copyFile("jstests/libs/dur_checksum_bad_first.journal", path + "/journal/j._0");
 copyFile("jstests/libs/dur_checksum_good.journal", path + "/journal/j._1");
 
 exitCode = runMongoProgram("mongod",
-                           "--port", 30001,
+                           "--port", allocatePort(),
                            "--dbpath", path,
                            "--journal",
                            "--smallfiles",
diff --git a/jstests/dur/dropdb.js b/jstests/dur/dropdb.js
index 56a4a3608f1..8c847c3a0aa 100644
--- a/jstests/dur/dropdb.js
+++ b/jstests/dur/dropdb.js
@@ -143,7 +143,7 @@ conn = MongoRunner.runMongod({restart: true,
 log("verify after recovery");
 verify();
 
-log("stop mongod 30002");
+log("stop mongod");
 MongoRunner.stopMongod(conn);
 sleep(5000);
 
diff --git a/jstests/dur/dur_jscore_passthrough.js b/jstests/dur/dur_jscore_passthrough.js
index 99a2ea7fb89..354cb76a132 100644
--- a/jstests/dur/dur_jscore_passthrough.js
+++ b/jstests/dur/dur_jscore_passthrough.js
@@ -2,9 +2,6 @@
 // simple runner to run toplevel tests in jstests
 //
 
-//TODO(mathias) add --master or make another test
-//conn = startMongodEmpty("--port", 30200, "--dbpath", MongoRunner.dataDir + "/dur_passthrough", "--dur", "--smallfiles", "--durOptions", "24");
-
 var conn = MongoRunner.runMongod({journal: "", nopreallocj: "", smallfiles: "", journalOptions: 8});
 db = conn.getDB("test");
 conn.forceWriteMode("commands");
diff --git a/jstests/fail_point/fail_point.js b/jstests/fail_point/fail_point.js
index 42e7b1ebd9c..7a3ba663c0e 100644
--- a/jstests/fail_point/fail_point.js
+++ b/jstests/fail_point/fail_point.js
@@ -59,7 +59,7 @@ var runTest = function(adminDB) {
     expectedFPState(adminDB.runCommand({ configureFailPoint: 'dummy' }), 1, { x: 1 });
 };
 
-var conn = MongoRunner.runMongod({ port: 29000 });
+var conn = MongoRunner.runMongod();
 runTest(conn.getDB('admin'));
 MongoRunner.stopMongod(conn.port);
 
diff --git a/jstests/gle/get_last_error.js b/jstests/gle/get_last_error.js
index 2cd9836350e..5db97283d37 100644
--- a/jstests/gle/get_last_error.js
+++ b/jstests/gle/get_last_error.js
@@ -85,13 +85,12 @@ assert.eq(gle.wtimeout, null);
 
 replTest.stopSet();
 
-// Next check that it still works on a lone mongod
+// Next check that it still works on a standalone mongod.
 // Need to start a single server manually to keep this test in the jstests/replsets test suite
-var port = allocatePorts(1)[0];
 var baseName = "SERVER-9005";
 
-var mongod = MongoRunner.runMongod({port: port});
-var sdb = new Mongo("localhost:"+port).getDB("test");
+var mongod = MongoRunner.runMongod({});
+var sdb = mongod.getDB("test");
 
 sdb.foo.drop();
 sdb.foo.insert({ _id: "1" });
diff --git a/jstests/libs/slow_weekly_util.js b/jstests/libs/slow_weekly_util.js
index 18fc0874daa..69b8fb27624 100644
--- a/jstests/libs/slow_weekly_util.js
+++ b/jstests/libs/slow_weekly_util.js
@@ -1,11 +1,10 @@
 
 SlowWeeklyMongod = function( name ) {
     this.name = name;
-    this.port = 30201;
-    
     this.start = new Date();
 
-    this.conn = MongoRunner.runMongod({port: this.port, smallfiles: "", nojournal: ""});
+    this.conn = MongoRunner.runMongod({smallfiles: "", nojournal: ""});
+    this.port = this.conn.port;
 };
 
 SlowWeeklyMongod.prototype.getDB = function( name ) {
diff --git a/jstests/libs/ssl_test.js b/jstests/libs/ssl_test.js
index cfb899ab3d0..59380776bf8 100644
--- a/jstests/libs/ssl_test.js
+++ b/jstests/libs/ssl_test.js
@@ -36,14 +36,11 @@ function SSLTest(serverOpts, clientOpts) {
         return canonical;
     };
 
-    this.port = allocatePorts(1)[0];
     this.serverOpts = MongoRunner.mongodOptions(canonicalServerOpts(serverOpts));
+    this.port = this.serverOpts.port;
     resetDbpath(this.serverOpts.dbpath);
 
     this.clientOpts = Object.extend({}, clientOpts || this.defaultSSLClientOptions);
-
-    // Add our allocated port to the options objects.
-    this.serverOpts.port = this.port;
     this.clientOpts.port = this.port;
 }
 
diff --git a/jstests/noPassthrough/dir_per_db_and_split.js b/jstests/noPassthrough/dir_per_db_and_split.js
index 8047ec9fda2..b402e0375f1 100644
--- a/jstests/noPassthrough/dir_per_db_and_split.js
+++ b/jstests/noPassthrough/dir_per_db_and_split.js
@@ -1,13 +1,10 @@
-
 if (!jsTest.options().storageEngine || jsTest.options().storageEngine === "wiredTiger") {
 
     var baseDir = "jstests_per_db_and_split_c_and_i";
-    port = allocatePorts( 1 )[ 0 ];
-    dbpath = MongoRunner.dataPath + baseDir + "/";
+    var dbpath = MongoRunner.dataPath + baseDir + "/";
 
     var m = MongoRunner.runMongod({
         dbpath: dbpath,
-        port: port,
         wiredTigerDirectoryForIndexes: '',
         directoryperdb: ''});
     db = m.getDB( "foo" );
@@ -19,22 +16,22 @@ if (!jsTest.options().storageEngine || jsTest.options().storageEngine === "wired
     assert( listFiles( dbpath + "/foo/index" ).length > 0 );
     assert( listFiles( dbpath + "/foo/collection" ).length > 0 );
 
-    MongoRunner.stopMongod(port);
+    MongoRunner.stopMongod(m.port);
 
     // Subsequent attempts to start server using same dbpath but different
     // wiredTigerDirectoryForIndexes and directoryperdb options should fail.
     assert.isnull(MongoRunner.runMongod({
         dbpath: dbpath,
-        port: port,
+        port: m.port,
         restart: true}));
     assert.isnull(MongoRunner.runMongod({
         dbpath: dbpath,
-        port: port,
+        port: m.port,
         restart: true,
         directoryperdb: ''}));
     assert.isnull(MongoRunner.runMongod({
         dbpath: dbpath,
-        port: port,
+        port: m.port,
         restart: true,
         wiredTigerDirectoryForIndexes: ''}));
 }
diff --git a/jstests/noPassthrough/directoryperdb.js b/jstests/noPassthrough/directoryperdb.js
index 6e2522d62a2..2421dc23172 100644
--- a/jstests/noPassthrough/directoryperdb.js
+++ b/jstests/noPassthrough/directoryperdb.js
@@ -1,7 +1,7 @@
 (function() {
     'use strict';
+
     var baseDir = "jstests_directoryperdb";
-    var port = allocatePorts( 1 )[ 0 ];
     var dbpath = MongoRunner.dataPath + baseDir + "/";
 
     var isDirectoryPerDBSupported =
@@ -11,7 +11,6 @@
 
     var m = MongoRunner.runMongod({
         dbpath: dbpath,
-        port: port,
         directoryperdb: ''});
 
     if (!isDirectoryPerDBSupported) {
@@ -37,11 +36,10 @@
     files = listFiles( files[0].name );
     assert( files.length > 0 );
 
-    MongoRunner.stopMongod(port);
+    MongoRunner.stopMongod(m.port);
 
     // Subsequent attempt to start server using same dbpath without directoryperdb should fail.
     assert.isnull(MongoRunner.runMongod({
         dbpath: dbpath,
-        port: port,
         restart: true}));
 }());
diff --git a/jstests/noPassthrough/split_collections_and_indexes.js b/jstests/noPassthrough/split_collections_and_indexes.js
index 73d2eede111..991a5fe2937 100644
--- a/jstests/noPassthrough/split_collections_and_indexes.js
+++ b/jstests/noPassthrough/split_collections_and_indexes.js
@@ -1,13 +1,10 @@
-
 if (!jsTest.options().storageEngine || jsTest.options().storageEngine === "wiredTiger") {
-
     var baseDir = "jstests_split_c_and_i";
-    port = allocatePorts( 1 )[ 0 ];
-    dbpath = MongoRunner.dataPath + baseDir + "/";
+
+    var dbpath = MongoRunner.dataPath + baseDir + "/";
 
     var m = MongoRunner.runMongod({
         dbpath: dbpath,
-        port: port,
         wiredTigerDirectoryForIndexes: ''});
     db = m.getDB( "foo" );
     db.bar.insert( { x : 1 } );
@@ -18,22 +15,19 @@ if (!jsTest.options().storageEngine || jsTest.options().storageEngine === "wired
     assert( listFiles( dbpath + "/index" ).length > 0 );
     assert( listFiles( dbpath + "/collection" ).length > 0 );
 
-    MongoRunner.stopMongod(port);
+    MongoRunner.stopMongod(m.port);
 
     // Subsequent attempts to start server using same dbpath but different
     // wiredTigerDirectoryForIndexes and directoryperdb options should fail.
     assert.isnull(MongoRunner.runMongod({
         dbpath: dbpath,
-        port: port,
         restart: true}));
     assert.isnull(MongoRunner.runMongod({
         dbpath: dbpath,
-        port: port,
         restart: true,
         directoryperdb: ''}));
     assert.isnull(MongoRunner.runMongod({
         dbpath: dbpath,
-        port: port,
         restart: true,
         wiredTigerDirectoryForIndexes: '',
         directoryperdb: ''}));
diff --git a/jstests/noPassthrough/ttl_capped.js b/jstests/noPassthrough/ttl_capped.js
index f3ca9cb15a7..f245056e05d 100644
--- a/jstests/noPassthrough/ttl_capped.js
+++ b/jstests/noPassthrough/ttl_capped.js
@@ -6,13 +6,12 @@
  */
 (function() {
     "use strict";
+
     var baseDir = "jstests_ttl_capped";
-    var port = allocatePorts( 1 )[ 0 ];
     var dbpath = MongoRunner.dataPath + baseDir + "/";
     
     var m = MongoRunner.runMongod({
                                     dbpath: dbpath,
-                                    port: port,
                                     setParameter:"ttlMonitorSleepSecs=1"});
     var db = m.getDB( "test" );
     
@@ -49,5 +48,5 @@
     assert.eq(t.count(), 1);
     assert.eq(ac.count(), 0);
     
-    MongoRunner.stopMongod(port);
-})();
\ No newline at end of file
+    MongoRunner.stopMongod(m.port);
+})();
diff --git a/jstests/noPassthrough/wt_nojournal_fsync.js b/jstests/noPassthrough/wt_nojournal_fsync.js
index 46a881de16d..1e2f84b7e36 100644
--- a/jstests/noPassthrough/wt_nojournal_fsync.js
+++ b/jstests/noPassthrough/wt_nojournal_fsync.js
@@ -23,6 +23,7 @@ function writeDataAndRestart(doFsync) {
 
     jsTestLog("restart node");
     conn = MongoRunner.runMongod({restart: true,
+                                  port: conn.port,
                                   cleanData: false,
                                   storageEngine: "wiredTiger",
                                   nojournal: ""});
diff --git a/jstests/noPassthroughWithMongod/httpinterface.js b/jstests/noPassthroughWithMongod/httpinterface.js
index 191a185975e..d3804cc40f1 100644
--- a/jstests/noPassthroughWithMongod/httpinterface.js
+++ b/jstests/noPassthroughWithMongod/httpinterface.js
@@ -1,11 +1,10 @@
 // SERVER-9137 test that the httpinterface parameter enables the web interface
-port = allocatePorts(1)[0];
-httpPort = port + 1000;
-var conn = MongoRunner.runMongod({port: port, smallfiles: ""});
+var conn = MongoRunner.runMongod({smallfiles: ""});
+var httpPort = conn.port + 1000;
 
 tryHttp = function() {
     try {
-        var mongo = new Mongo('localhost:'+httpPort) ;
+        var mongo = new Mongo('localhost:' + httpPort) ;
     }
     catch (e) {
         return false;
@@ -18,7 +17,7 @@ assert.throws(function() {assert.soon(tryHttp, "tryHttp failed, like we expected
 
 MongoRunner.stopMongod(conn);
 
-conn = MongoRunner.runMongod({ port:port, smallfiles: "", httpinterface: ""});
+conn = MongoRunner.runMongod({port: conn.port, smallfiles: "", httpinterface: ""});
 assert.soon(tryHttp,
             "the web interface should be running on " + httpPort);
 
diff --git a/jstests/noPassthroughWithMongod/index_no_retry.js b/jstests/noPassthroughWithMongod/index_no_retry.js
index 0264f308f16..7f7c39a235f 100644
--- a/jstests/noPassthroughWithMongod/index_no_retry.js
+++ b/jstests/noPassthroughWithMongod/index_no_retry.js
@@ -3,10 +3,9 @@
     'use strict';
     var baseName = 'index_retry';
     var dbpath = MongoRunner.dataPath + baseName;
-    var ports = allocatePorts(1);
+
     var conn = MongoRunner.runMongod({
         dbpath: dbpath,
-        port: ports[0],
         journal: ''});
 
     var test = conn.getDB("test");
@@ -64,7 +63,7 @@
     function abortDuringIndexBuild(options) {
         var createIdx = startParallelShell(
             'db.' + name + '.createIndex({ a: 1 }, { background: true });',
-            ports[0]);
+            conn.port);
 
         // Wait for the index build to start.
         var times = 0;
@@ -75,7 +74,7 @@
         );
 
         print("killing the mongod");
-        MongoRunner.stopMongod(ports[0], /* signal */ 9);
+        MongoRunner.stopMongod(conn.port, /* signal */ 9);
 
         var exitCode = createIdx({checkExitSuccess: false});
         assert.neq(0, exitCode, "expected shell to exit abnormally due to mongod being terminated");
@@ -85,7 +84,6 @@
 
     conn = MongoRunner.runMongod({
         dbpath: dbpath,
-        port: ports[0],
         journal: '',
         noIndexBuildRetry: '',
         restart: true});
@@ -101,6 +99,6 @@
 
     print("Index rebuilding disabled successfully");
 
-    MongoRunner.stopMongod(ports[0]);
+    MongoRunner.stopMongod(conn.port);
     print("SUCCESS!");
 }());
diff --git a/jstests/noPassthroughWithMongod/index_retry.js b/jstests/noPassthroughWithMongod/index_retry.js
index cf26b780008..806c334e151 100644
--- a/jstests/noPassthroughWithMongod/index_retry.js
+++ b/jstests/noPassthroughWithMongod/index_retry.js
@@ -3,10 +3,9 @@
     'use strict';
     var baseName = 'index_retry';
     var dbpath = MongoRunner.dataPath + baseName;
-    var ports = allocatePorts(1);
+
     var conn = MongoRunner.runMongod({
         dbpath: dbpath,
-        port: ports[0],
         journal: ''});
 
     var test = conn.getDB("test");
@@ -64,7 +63,7 @@
     function abortDuringIndexBuild(options) {
         var createIdx = startParallelShell(
             'db.' + name + '.createIndex({ a: 1 }, { background: true });',
-            ports[0]);
+            conn.port);
 
         // Wait for the index build to start.
         var times = 0;
@@ -75,7 +74,7 @@
         );
 
         print("killing the mongod");
-        MongoRunner.stopMongod(ports[0], /* signal */ 9);
+        MongoRunner.stopMongod(conn.port, /* signal */ 9);
 
         var exitCode = createIdx({checkExitSuccess: false});
         assert.neq(0, exitCode, "expected shell to exit abnormally due to mongod being terminated");
@@ -85,7 +84,6 @@
 
     conn = MongoRunner.runMongod({
         dbpath: dbpath,
-        port: ports[0],
         journal: '',
         restart: true});
     test = conn.getDB("test");
@@ -100,6 +98,6 @@
 
     print("Index built");
 
-    MongoRunner.stopMongod(ports[0]);
+    MongoRunner.stopMongod(conn.port);
     print("SUCCESS!");
 }());
diff --git a/jstests/noPassthroughWithMongod/ipv6_connection_string_validation.js b/jstests/noPassthroughWithMongod/ipv6_connection_string_validation.js
index c4896e56406..9f544248ef1 100644
--- a/jstests/noPassthroughWithMongod/ipv6_connection_string_validation.js
+++ b/jstests/noPassthroughWithMongod/ipv6_connection_string_validation.js
@@ -6,28 +6,26 @@
 // and a command line to run the test in inner_mode.  The inner mode test is the actual test.
 
 if ("undefined" == typeof inner_mode) {
-
     // Start a mongod with --ipv6
-    port = allocatePorts( 1 )[ 0 ];
     jsTest.log("Outer mode test starting mongod with --ipv6");
     // NOTE: bind_ip arg is present to test if it can parse ipv6 addresses (::1 in this case).
     // Unfortunately, having bind_ip = ::1 won't work in the test framework (But does work when
     // tested manually), so 127.0.0.1 is also present so the test mongo shell can connect
     // with that address.
-    var mongod = MongoRunner.runMongod({port: port, ipv6: "", bind_ip: "::1,127.0.0.1"});
+    var mongod = MongoRunner.runMongod({ipv6: "", bind_ip: "::1,127.0.0.1"});
     var args = ["mongo",
                 "--nodb",
                 "--ipv6",
                 "--host", "::1",
-                "--port", port,
-                "--eval", "inner_mode=true;port=" + port + ";",
+                "--port", mongod.port,
+                "--eval", "inner_mode=true;port=" + mongod.port + ";",
                 "jstests/noPassthroughWithMongod/ipv6_connection_string_validation.js" ];
     var exitCode = _runMongoProgram.apply(null, args);
     jsTest.log("Inner mode test finished, exit code was " + exitCode);
 
     // Stop the server we started
     jsTest.log("Outer mode test stopping server");
-    MongoRunner.stopMongod(port, 15);
+    MongoRunner.stopMongod(mongod.port, 15);
 
     // Pass the inner test's exit code back as the outer test's exit code
     quit(exitCode);
diff --git a/jstests/noPassthroughWithMongod/server7428.js b/jstests/noPassthroughWithMongod/server7428.js
index ed62e7adbf6..1c6c2997804 100644
--- a/jstests/noPassthroughWithMongod/server7428.js
+++ b/jstests/noPassthroughWithMongod/server7428.js
@@ -6,15 +6,17 @@
 // Verify that the copyDatabase command works appropriately when the
 // target mongo instance has authentication enabled.
 
+(function() {
 
 // Setup fromDb with no auth
-var fromDb = MongoRunner.runMongod({ port: 29000 });
- 
+var fromDb = MongoRunner.runMongod();
+
 // Setup toDb with auth
-var toDb = MongoRunner.runMongod({auth : "", port : 31001});
+var toDb = MongoRunner.runMongod({auth: ""});
 var admin = toDb.getDB("admin");
 admin.createUser({user: "foo", pwd: "bar", roles: jsTest.adminUserRoles});
 admin.auth("foo","bar");
-  
+
 admin.copyDatabase('test', 'test', fromDb.host)
 
+})();
diff --git a/jstests/noPassthroughWithMongod/sharding_rs_arb1.js b/jstests/noPassthroughWithMongod/sharding_rs_arb1.js
index 4470a82ee88..4c36ff4f05d 100644
--- a/jstests/noPassthroughWithMongod/sharding_rs_arb1.js
+++ b/jstests/noPassthroughWithMongod/sharding_rs_arb1.js
@@ -1,5 +1,5 @@
 var name = "sharding_rs_arb1"
-var replTest = new ReplSetTest( { name : name , nodes : 3 , startPort : 31000 } );
+var replTest = new ReplSetTest( { name : name , nodes : 3 } );
 replTest.startSet();
 var port = replTest.ports;
 replTest.initiate({_id : name, members :
@@ -25,4 +25,3 @@ assert( res.ok , tojson(res) )
 
 st.stop();
 replTest.stopSet();
-
diff --git a/jstests/noPassthroughWithMongod/unix_socket1.js b/jstests/noPassthroughWithMongod/unix_socket1.js
index 8e28715558c..1b607063923 100644
--- a/jstests/noPassthroughWithMongod/unix_socket1.js
+++ b/jstests/noPassthroughWithMongod/unix_socket1.js
@@ -22,15 +22,14 @@ if ( ! _isWindows() ) {
     sockdb = sock.getDB(db.getName())
     assert( sockdb.runCommand('ping').ok );
 
-    // test unix socket path
-    var ports = allocatePorts(1);
+    // Test unix socket path
     var path = MongoRunner.dataDir + "/sockpath";
     mkdir(path);
     var dataPath = MongoRunner.dataDir + "/sockpath_data";
     
-    var conn = MongoRunner.runMongod({port: ports[0], dbpath: dataPath, unixSocketPrefix: path});
+    var conn = MongoRunner.runMongod({dbpath: dataPath, unixSocketPrefix: path});
     
-    var sock2 = new Mongo(path+"/mongodb-"+ports[0]+".sock");
+    var sock2 = new Mongo(path + "/mongodb-" + conn.port + ".sock");
     sockdb2 = sock2.getDB(db.getName())
     assert( sockdb2.runCommand('ping').ok );
 
diff --git a/jstests/replsets/initial_sync3.js b/jstests/replsets/initial_sync3.js
index 200e0a30213..dc0455dd108 100644
--- a/jstests/replsets/initial_sync3.js
+++ b/jstests/replsets/initial_sync3.js
@@ -7,18 +7,18 @@
 load("jstests/replsets/rslib.js");
 var name = "initialsync3";
 var host = getHostName();
-var port = allocatePorts(7);
 
 print("Start set with three nodes");
 var replTest = new ReplSetTest( {name: name, nodes: 3} );
 var nodes = replTest.startSet();
 replTest.initiate({
-    _id : name,
-    members : [
-        {_id:0, host : host+":"+port[0], priority: 10},
-        {_id:1, host : host+":"+port[1], priority: 0},
-        {_id:2, host : host+":"+port[2], priority : 0, buildIndexes : false},
-               ]});
+    _id: name,
+    members: [
+        {_id: 0, host: host + ":" + nodes[0].port, priority: 10},
+        {_id: 1, host: host + ":" + nodes[1].port, priority: 0},
+        {_id: 2, host: host + ":" + nodes[2].port, priority: 0, buildIndexes: false},
+    ]
+});
 
 var master = replTest.getMaster();
 
diff --git a/jstests/replsets/stepdown.js b/jstests/replsets/stepdown.js
index a9c2b1060ff..38408d27d11 100644
--- a/jstests/replsets/stepdown.js
+++ b/jstests/replsets/stepdown.js
@@ -82,16 +82,16 @@ print("\nawait");
 replTest.awaitSecondaryNodes(90000);
 replTest.awaitReplication();
 
-// 31000 may have just voted for 31001, preventing it from becoming primary for the first 30 seconds
+// 'n0' may have just voted for 'n1', preventing it from becoming primary for the first 30 seconds
 // of this assert.soon
 assert.soon(function() {
     try {
         var result = master.getDB("admin").runCommand({isMaster: 1});
-        return /31000$/.test(result.primary);
+        return new RegExp(":" + replTest.nodes[0].port + "$").test(result.primary);
     } catch (x) {
         return false;
     }
-}, 'wait for 31000 to be primary', 60000);
+}, "wait for n0 to be primary", 60000);
 
 master = replTest.getMaster();
 var firstMaster = master;
diff --git a/jstests/replsets/tags.js b/jstests/replsets/tags.js
index 3053f28e180..2a1f77608a6 100644
--- a/jstests/replsets/tags.js
+++ b/jstests/replsets/tags.js
@@ -6,7 +6,7 @@ var num = 5;
 var host = getHostName();
 var name = "tags";
 
-var replTest = new ReplSetTest( {name: name, nodes: num, startPort:31000} );
+var replTest = new ReplSetTest( {name: name, nodes: num} );
 var nodes = replTest.startSet();
 var port = replTest.ports;
 replTest.initiate({_id : name, members :
diff --git a/jstests/replsets/tags2.js b/jstests/replsets/tags2.js
index 074aa7b9dda..62ca15e82d8 100644
--- a/jstests/replsets/tags2.js
+++ b/jstests/replsets/tags2.js
@@ -1,7 +1,7 @@
 // Change a write concern mode from 2 to 3 servers
 
 var host = getHostName();
-var replTest = new ReplSetTest( {name: "rstag", nodes: 4, startPort: 31000} );
+var replTest = new ReplSetTest({ name: "rstag", nodes: 4 });
 var nodes = replTest.startSet();
 var ports = replTest.ports;
 var conf = {_id : "rstag", version: 1, members : [
diff --git a/jstests/replsets/tags_with_reconfig.js b/jstests/replsets/tags_with_reconfig.js
index 755fd744de5..22b2404e009 100644
--- a/jstests/replsets/tags_with_reconfig.js
+++ b/jstests/replsets/tags_with_reconfig.js
@@ -6,7 +6,7 @@
 
 // Start a replica set with 3 nodes
 var host = getHostName();
-var replTest = new ReplSetTest( {name: "tags_with_reconfig", nodes: 3, startPort: 32000} );
+var replTest = new ReplSetTest({ name: "tags_with_reconfig", nodes: 3 });
 var nodes = replTest.startSet();
 var ports = replTest.ports;
 
diff --git a/jstests/sharding/addshard2.js b/jstests/sharding/addshard2.js
index e6ebac9ab5f..b582ff6ed7a 100644
--- a/jstests/sharding/addshard2.js
+++ b/jstests/sharding/addshard2.js
@@ -1,35 +1,34 @@
+// Don't start any shards, yet
+var s = new ShardingTest("add_shard2", 1, 0, 1, {useHostname : true});
 
-// don't start any shards, yet
-s = new ShardingTest( "add_shard2", 1, 0, 1, {useHostname : true} );
-
+// Start two new instances, which will be used for shards
 var conn1 = MongoRunner.runMongod({useHostname: true});
 var conn2 = MongoRunner.runMongod({useHostname: true});
 
-var rs1 = new ReplSetTest( { "name" : "add_shard2_rs1", nodes : 3 , startPort : 31200 } );
+var rs1 = new ReplSetTest( { "name" : "add_shard2_rs1", nodes : 3 } );
 rs1.startSet();
 rs1.initiate();
 var master1 = rs1.getMaster();
 
-var rs2 = new ReplSetTest( { "name" : "add_shard2_rs2", nodes : 3 , startPort : 31203 } );
+var rs2 = new ReplSetTest( { "name" : "add_shard2_rs2", nodes : 3 } );
 rs2.startSet();
 rs2.initiate();
 var master2 = rs2.getMaster();
 
 // replica set with set name = 'config'
-var rs3 = new ReplSetTest({ 'name': 'config', nodes: 3, startPort: 31206 });
+var rs3 = new ReplSetTest({ 'name': 'config', nodes: 3 });
 rs3.startSet();
 rs3.initiate();
 
 // replica set with set name = 'admin'
-var rs4 = new ReplSetTest({ 'name': 'admin', nodes: 3, startPort: 31209 });
+var rs4 = new ReplSetTest({ 'name': 'admin', nodes: 3 });
 rs4.startSet();
 rs4.initiate();
 
 // replica set with configsvr: true should *not* be allowed to be added as a shard
-var rs5 = new ReplSetTest({ name: 'csrs',
-                            nodes: 3,
-                            startPort: 31212,
-                            nodeOptions: {configsvr: "", storageEngine: "wiredTiger" }});
+var rs5 = new ReplSetTest({name: 'csrs',
+                           nodes: 3,
+                           nodeOptions: {configsvr: "", storageEngine: "wiredTiger"}});
 rs5.startSet();
 var conf = rs5.getReplSetConfig();
 conf.configsvr = true;
@@ -44,13 +43,16 @@ assert(shard, "shard wasn't found");
 assert.eq("bar", shard._id, "shard has incorrect name");
 
 // step 2. replica set
-assert(s.admin.runCommand({"addshard" : "add_shard2_rs1/"+getHostName()+":31200"}).ok, "failed to add shard in step 2");
+assert(s.admin.runCommand(
+            {"addshard" : "add_shard2_rs1/" + getHostName() + ":" + master1.port}).ok,
+       "failed to add shard in step 2");
 shard = s.getDB("config").shards.findOne({"_id" : {"$nin" : ["shard0000", "bar"]}});
 assert(shard, "shard wasn't found");
 assert.eq("add_shard2_rs1", shard._id, "t2 name");
 
 // step 3. replica set w/ name given
-assert(s.admin.runCommand({"addshard" : "add_shard2_rs2/"+getHostName()+":31203", "name" : "myshard"}).ok,
+assert(s.admin.runCommand({"addshard" : "add_shard2_rs2/" + getHostName() + ":" + master2.port,
+                           "name" : "myshard"}).ok,
        "failed to add shard in step 4");
 shard = s.getDB("config").shards.findOne({"_id" : {"$nin" : ["shard0000", "bar", "add_shard2_rs1"]}});
 assert(shard, "shard wasn't found");
@@ -66,28 +68,37 @@ assert.eq("shard0001", shard._id, "t4 name");
 assert.eq(s.getDB("config").shards.count(), 5, "unexpected number of shards");
 
 // step 5. replica set w/ a wrong host
-assert(!s.admin.runCommand({"addshard" : "add_shard2_rs2/NonExistingHost:31203"}).ok, "accepted bad hostname in step 5");
+var portWithoutHostRunning = allocatePort();
+assert(!s.admin.runCommand({
+           addshard: "add_shard2_rs2/NonExistingHost:" + portWithoutHostRunning
+       }).ok,
+       "accepted bad hostname in step 5");
 
 // step 6. replica set w/ mixed wrong/right hosts
-assert(!s.admin.runCommand({"addshard" : "add_shard2_rs2/"+getHostName()+":31203,foo:9999"}).ok,
+assert(!s.admin.runCommand({
+           addshard: "add_shard2_rs2/" + getHostName() + ":" + master2.port +
+                     ",foo:" + portWithoutHostRunning
+       }).ok,
        "accepted bad hostname in step 6");
 
 //
 // SERVER-17231 Adding replica set w/ set name = 'config'
 //
-var configReplURI = 'config/' + getHostName() + ':31206';
+var configReplURI = 'config/' + getHostName() + ':' + rs3.getMaster().port;
+
 assert(!s.admin.runCommand({ 'addshard': configReplURI }).ok,
        'accepted replica set shard with set name "config"');
 // but we should be allowed to add that replica set using a different shard name
 assert(s.admin.runCommand({ 'addshard': configReplURI, name: 'not_config' }).ok,
        'unable to add replica set using valid replica set name');
+
 shard = s.getDB('config').shards.findOne({ '_id': 'not_config' });
 assert(shard, 'shard with name "not_config" not found');
 
 //
 // SERVER-17232 Try inserting into shard with name 'admin'
 //
-assert(s.admin.runCommand({ 'addshard': 'admin/' + getHostName() + ':31209' }).ok,
+assert(s.admin.runCommand({ 'addshard': 'admin/' + getHostName() + ':' + rs4.getMaster().port}).ok,
        'adding replica set with name "admin" should work');
 var wRes = s.getDB('test').foo.insert({ x: 1 });
 assert(!wRes.hasWriteError() && wRes.nInserted === 1,
@@ -101,4 +112,4 @@ rs1.stopSet();
 rs2.stopSet();
 rs3.stopSet();
 rs4.stopSet();
-rs5.stopSet();
\ No newline at end of file
+rs5.stopSet();
diff --git a/jstests/sharding/addshard3.js b/jstests/sharding/addshard3.js
index aa5a21efa92..f8d43587fc0 100644
--- a/jstests/sharding/addshard3.js
+++ b/jstests/sharding/addshard3.js
@@ -1,9 +1,11 @@
+(function() {
 
-s = new ShardingTest( "add_shard3", 1 );
+var st = new ShardingTest("add_shard3", 1);
 
-var result = s.admin.runCommand({"addshard" : "localhost:31000"});
+var result = st.admin.runCommand({addshard: st.s.host});
 
 printjson(result);
 
 assert.eq(result.ok, 0, "don't add mongos as a shard");
 
+})();
diff --git a/jstests/sharding/addshard4.js b/jstests/sharding/addshard4.js
index ce459ac2824..885227a1d7c 100644
--- a/jstests/sharding/addshard4.js
+++ b/jstests/sharding/addshard4.js
@@ -2,7 +2,7 @@
 
 s = new ShardingTest( "addshard4", 2 , 0 , 1 , {useHostname : true});
 
-r = new ReplSetTest({name : "addshard4", nodes : 3, startPort : 31100});
+var r = new ReplSetTest({name: "addshard4", nodes: 3});
 r.startSet();
 
 var config = r.getReplSetConfig();
@@ -31,7 +31,7 @@ var result = s.adminCommand({"addshard" : shardName});
 printjson(result);
 assert.eq(result, true);
 
-r = new ReplSetTest({name : "addshard42", nodes : 3, startPort : 31200});
+r = new ReplSetTest({name : "addshard42", nodes : 3});
 r.startSet();
 
 config = r.getReplSetConfig();
diff --git a/jstests/sharding/auth.js b/jstests/sharding/auth.js
index 4e519126ec1..d6d018719e5 100644
--- a/jstests/sharding/auth.js
+++ b/jstests/sharding/auth.js
@@ -1,31 +1,36 @@
-adminUser = {
+(function() {
+
+'use strict';
+
+var adminUser = {
     db : "admin",
     username : "foo",
     password : "bar"
 };
 
-testUser = {
+var testUser = {
     db : "test",
     username : "bar",
     password : "baz"
 };
 
-testUserReadOnly = {
+var testUserReadOnly = {
     db : "test",
     username : "sad",
     password : "bat"
 };
 
 
-function login(userObj , thingToUse ) {
-    if ( ! thingToUse )
+function login(userObj, thingToUse) {
+    if (!thingToUse) {
         thingToUse = s;
+    }
 
     thingToUse.getDB(userObj.db).auth(userObj.username, userObj.password);
 }
 
-function logout(userObj, thingToUse ) {
-    if ( ! thingToUse )
+function logout(userObj, thingToUse) {
+    if (!thingToUse)
         thingToUse = s;
 
     s.getDB(userObj.db).runCommand({logout:1});
@@ -38,17 +43,6 @@ function getShardName(rsTest) {
     return config._id+"/"+members.join(",");
 }
 
-function setupTest() {
-    var s = new ShardingTest( "auth1", 0 , 0 , 1 ,
-      {
-        rs: true,
-        extraOptions : {"keyFile" : "jstests/libs/key1"},
-        noChunkSize : true,
-        enableBalancer:true
-      } );
-    return s;
-}
-
 function runTest(s) {
     print("adding user");
     s.getDB(adminUser.db).createUser({user: adminUser.username,
@@ -60,15 +54,16 @@ function runTest(s) {
                                                        { $set: { value : 1 }}, true ));
     printjson(s.getDB("config").settings.find().toArray());
 
-    print("restart mongos");
-    MongoRunner.stopMongos(31000);
-    var opts = { port : 31000, v : 2, configdb : s._configDB, keyFile : "jstests/libs/key1", chunkSize : 1 };
-    var conn = startMongos( opts );
-    s.s = s._mongos[0] = s["s0"] = conn;
+    print("restart mongos with different auth options");
 
+    s.restartMongos(0, { port: s.port,
+                         v: 2,
+                         configdb: s._configDB,
+                         keyFile: "jstests/libs/key1",
+                         chunkSize: 1 });
     login(adminUser);
 
-    d1 = new ReplSetTest({name : "d1", nodes : 3, startPort : 31100, useHostName : true });
+    var d1 = new ReplSetTest({name : "d1", nodes : 3, useHostName : true });
     d1.startSet({keyFile : "jstests/libs/key2", verbose : 0});
     d1.initiate();
 
@@ -99,12 +94,14 @@ function runTest(s) {
     assert(thrown);
 
     print("start rs w/correct key");
+
     d1.stopSet();
     d1.startSet({keyFile : "jstests/libs/key1", verbose : 0});
     d1.initiate();
+
     var master = d1.getMaster();
 
-    print("adding shard w/auth "+shardName);
+    print("adding shard w/auth " + shardName);
 
     result = s.getDB("admin").runCommand({addShard : shardName});
     assert.eq(result.ok, 1, tojson(result));
@@ -125,12 +122,12 @@ function runTest(s) {
 
     print("query try");
     var e = assert.throws(function() {
-        conn.getDB("foo").bar.findOne();
+        s.s.getDB("foo").bar.findOne();
     });
     printjson(e);
 
     print("cmd try");
-    assert.eq( 0, conn.getDB("foo").runCommand({listDatabases:1}).ok );
+    assert.eq(0, s.s.getDB("foo").runCommand({listDatabases:1}).ok);
 
     print("insert try 1");
     s.getDB("test").foo.insert({x:1});
@@ -144,7 +141,7 @@ function runTest(s) {
 
     logout(testUser);
 
-    d2 = new ReplSetTest({name : "d2", nodes : 3, startPort : 31200, useHostName : true });
+    var d2 = new ReplSetTest({name : "d2", nodes : 3, useHostName : true });
     d2.startSet({keyFile : "jstests/libs/key1", verbose : 0});
     d2.initiate();
     d2.awaitSecondaryNodes();
@@ -218,7 +215,6 @@ function runTest(s) {
         assert(false, "Number of docs found does not equal the number inserted. Missing docs: " + missingDocNumbers);
     }
 
-
     // We're only sure we aren't duplicating documents iff there's no balancing going on here
     // This call also waits for any ongoing balancing to stop
     s.stopBalancer(60000);
@@ -253,9 +249,10 @@ function runTest(s) {
 
     login(testUser);
     print( "testing map reduce" );
-    /* sharded map reduce can be tricky since all components talk to each other.
-       for example SERVER-4114 is triggered when 1 mongod connects to another for final reduce
-       it's not properly tested here since addresses are localhost, which is more permissive */
+
+    // Sharded map reduce can be tricky since all components talk to each other. For example
+    // SERVER-4114 is triggered when 1 mongod connects to another for final reduce it's not
+    // properly tested here since addresses are localhost, which is more permissive.
     var res = s.getDB("test").runCommand(
         {mapreduce : "foo",
          map : function() { emit(this.x, 1); },
@@ -265,18 +262,20 @@ function runTest(s) {
     printjson(res);
     assert.commandWorked(res);
 
-    // check that dump doesn't get stuck with auth
-    var x = runMongoProgram( "mongodump", "--host", "127.0.0.1:31000", "-d", testUser.db, "-u",
-                             testUser.username, "-p", testUser.password, "--authenticationMechanism",
-                             "SCRAM-SHA-1");
-    print("result: "+x);
-
-    // test read only users
+    // Check that dump doesn't get stuck with auth
+    var x = runMongoProgram("mongodump",
+                            "--host", s.s.host,
+                            "-d", testUser.db,
+                            "-u", testUser.username,
+                            "-p", testUser.password,
+                            "--authenticationMechanism", "SCRAM-SHA-1");
+    print("result: " + x);
 
+    // Test read only users
     print( "starting read only tests" );
 
-    readOnlyS = new Mongo( s.getDB( "test" ).getMongo().host )
-    readOnlyDB = readOnlyS.getDB( "test" );
+    var readOnlyS = new Mongo( s.getDB( "test" ).getMongo().host )
+    var readOnlyDB = readOnlyS.getDB( "test" );
 
     print( "   testing find that should fail" );
     assert.throws( function(){ readOnlyDB.foo.findOne(); } )
@@ -296,6 +295,7 @@ function runTest(s) {
     print("make sure currentOp/killOp fail");
     assert.commandFailed(readOnlyDB.currentOp());
     assert.commandFailed(readOnlyDB.killOp(123));
+
     // fsyncUnlock doesn't work in mongos anyway, so no need check authorization for it
     /*
     broken because of SERVER-4156
@@ -307,20 +307,30 @@ function runTest(s) {
          out:"blarg"
         }));
     */
+
     print( "   testing logout (should succeed)" );
     assert.commandWorked(readOnlyDB.runCommand({logout : 1}));
 
     print("make sure currentOp/killOp fail again");
     assert.commandFailed(readOnlyDB.currentOp());
     assert.commandFailed(readOnlyDB.killOp(123));
-    // fsyncUnlock doesn't work in mongos anyway, so no need check authorization for it
 }
 
-var s = setupTest();
-if (s.getDB( "admin" ).runCommand( "buildInfo" ).bits < 64) {
-    print("Skipping test on 32-bit platforms");
+var s = new ShardingTest("auth1", 0, 0, 1,
+                         {
+                            rs: true,
+                            extraOptions: { "keyFile": "jstests/libs/key1" },
+                            noChunkSize: true,
+                            enableBalancer: true
+                         });
+
+if (s.getDB('admin').runCommand('buildInfo').bits < 64) {
+    print('Skipping test on 32-bit platforms');
 }
 else {
     runTest(s);
 }
+
 s.stop();
+
+})();
diff --git a/jstests/sharding/csrs_upgrade.js b/jstests/sharding/csrs_upgrade.js
index b8b6b0d6de2..a94cd2bf4e0 100644
--- a/jstests/sharding/csrs_upgrade.js
+++ b/jstests/sharding/csrs_upgrade.js
@@ -207,9 +207,11 @@ var st;
     var sconfig = Object.extend({}, st.s0.fullOptions, /* deep */ true);
     delete sconfig.port;
     sconfig.configdb = csrsName + "/" + csrs[0].name;
-    assertCanSplit(startMongos(sconfig), "when mongos started with --configdb=" + sconfig.configdb);
+    assertCanSplit(MongoRunner.runMongos(sconfig),
+                   "when mongos started with --configdb=" + sconfig.configdb);
     sconfig.configdb = st.s0.fullOptions.configdb;
-    assertCanSplit(startMongos(sconfig), "when mongos started with --configdb=" + sconfig.configdb);
+    assertCanSplit(MongoRunner.runMongos(sconfig),
+                   "when mongos started with --configdb=" + sconfig.configdb);
     assertCanSplit(st.s0, "on mongos that drove the upgrade");
     assertCanSplit(st.s1, "on mongos that was previously unaware of the upgrade");
 }());
diff --git a/jstests/sharding/diffservers1.js b/jstests/sharding/diffservers1.js
index 8a7f2bac0a2..0d477147be8 100644
--- a/jstests/sharding/diffservers1.js
+++ b/jstests/sharding/diffservers1.js
@@ -1,6 +1,4 @@
-
-
-s = new ShardingTest( "diffservers1" , 2 );
+var s = new ShardingTest( "diffservers1" , 2 );
 
 assert.eq( 2 , s.config.shards.count() , "server count wrong" );
 assert.eq( 2 , s._configServers[0].getDB( "config" ).shards.count() , "where are servers!" );
@@ -14,8 +12,10 @@ test1.save( { a : 3 } );
 assert( 3 , test1.count() );
 
 assert( ! s.admin.runCommand( { addshard: "sdd$%" } ).ok , "bad hostname" );
-assert( ! s.admin.runCommand( { addshard: "127.0.0.1:43415" } ).ok , "host not up" );
-assert( ! s.admin.runCommand( { addshard: "10.0.0.1:43415" } ).ok , "allowed shard in IP when config is localhost" );
+var portWithoutHostRunning = allocatePort();
+assert(!s.admin.runCommand({addshard: "127.0.0.1:" + portWithoutHostRunning}).ok, "host not up");
+assert(!s.admin.runCommand({ addshard: "10.0.0.1:" + portWithoutHostRunning}).ok,
+       "allowed shard in IP when config is localhost" );
 
 s.stop();
 
diff --git a/jstests/sharding/names.js b/jstests/sharding/names.js
index ff775184116..17e98f82b30 100644
--- a/jstests/sharding/names.js
+++ b/jstests/sharding/names.js
@@ -2,8 +2,8 @@
 
 var st = new ShardingTest( name = "test", shards = 0, verbose = 2, mongos = 2, other = { rs : true } )
 
-var rsA = new ReplSetTest({ nodes : 2, name : "rsA", startPort : 28000 })
-var rsB = new ReplSetTest({ nodes : 2, name : "rsB", startPort : 28010 })
+var rsA = new ReplSetTest({ nodes : 2, name : "rsA" })
+var rsB = new ReplSetTest({ nodes : 2, name : "rsB" })
 
 rsA.startSet()
 rsB.startSet()
diff --git a/jstests/sharding/remove2.js b/jstests/sharding/remove2.js
index 48bb95e1e95..74f760050db 100644
--- a/jstests/sharding/remove2.js
+++ b/jstests/sharding/remove2.js
@@ -6,9 +6,6 @@ seedString = function(replTest) {
 };
 
 removeShard = function(st, replTest) {
-
-
-
     print( "Removing shard with name: " + replTest.name );
     res = st.admin.runCommand( { removeshard: replTest.name } )
     printjson(res);
@@ -192,7 +189,7 @@ print( "Sleeping for 20 seconds to let the other shard's ReplicaSetMonitor time
 sleep( 20000 );
 
 
-var rst2 = new ReplSetTest({name : rst1.name, nodes : 2, startPort : rst1.startPort + 1500, useHostName : true});
+var rst2 = new ReplSetTest({name : rst1.name, nodes : 2, useHostName : true});
 rst2.startSet();
 rst2.initiate();
 rst2.awaitReplication();
diff --git a/jstests/sharding/sync_cluster_config/configdb_str.js b/jstests/sharding/sync_cluster_config/configdb_str.js
index 6cd592bbda4..e7a5985836e 100644
--- a/jstests/sharding/sync_cluster_config/configdb_str.js
+++ b/jstests/sharding/sync_cluster_config/configdb_str.js
@@ -10,12 +10,12 @@ st.stopBalancer();
 
 var badConfStr = st.c1.name + ',' + st.c0.name + ',' + st.c2.name;
 
-var otherMongos = MongoRunner.runMongos({ port: 30998, configdb: badConfStr });
+var otherMongos = MongoRunner.runMongos({configdb: badConfStr});
 var configDB = otherMongos.getDB('config');
 
 var res = configDB.user.insert({ x: 1 });
 assert.writeError(res);
-MongoRunner.stopMongos(30998);
+MongoRunner.stopMongos(otherMongos.port);
 
 st.stop();
 
diff --git a/jstests/sharding/sync_cluster_config/rs_stepdown_and_pooling.js b/jstests/sharding/sync_cluster_config/rs_stepdown_and_pooling.js
index cd1efbbd8d6..d40cbf25e21 100644
--- a/jstests/sharding/sync_cluster_config/rs_stepdown_and_pooling.js
+++ b/jstests/sharding/sync_cluster_config/rs_stepdown_and_pooling.js
@@ -37,9 +37,7 @@ else {
         conns.push(new Mongo(mongos.host));
         conns[i].getCollection(coll + "").findOne();
     }
-    
-    assert.eq(primary.port, 31100);
-    
+
     jsTest.log("Returning the connections back to the pool.");
     
     for ( var i = 0; i < conns.length; i++ ) {
diff --git a/jstests/sharding/sync_cluster_config/sync7.js b/jstests/sharding/sync_cluster_config/sync7.js
index 65ac5b48d1b..33cf31bc899 100644
--- a/jstests/sharding/sync_cluster_config/sync7.js
+++ b/jstests/sharding/sync_cluster_config/sync7.js
@@ -13,7 +13,7 @@ s._configServers[1].getDB( "admin" ).runCommand( { _skewClockCommand : 1, skew :
 
 // We need to start another mongos after skewing the clock, since the first mongos will have already
 // tested the config servers (via the balancer) before we manually skewed them
-otherMongos = startMongos( { port : 30020, v : 2, configdb : s._configDB } );
+var otherMongos = MongoRunner.runMongos({v: 2, configdb: s._configDB});
 
 // Initialize DB data
 initDB = function(name) {
diff --git a/jstests/sharding/version1.js b/jstests/sharding/version1.js
index c7a8eb0d1a5..afe3f709fad 100644
--- a/jstests/sharding/version1.js
+++ b/jstests/sharding/version1.js
@@ -32,7 +32,7 @@ assert( a.runCommand({ setShardVersion: "alleyinsider.foo",
                        version: new Timestamp(2, 0),
                        authoritative: true,
                        shard: "shard0000",
-                       shardHost: "localhost:30000" }),
+                       shardHost: s.s.host }),
         "should have failed because version is config is 1|0" );
 
 var epoch = s.getDB('config').chunks.findOne().lastmodEpoch;
@@ -42,7 +42,7 @@ assert.commandWorked( a.runCommand({ setShardVersion: "alleyinsider.foo",
                                      versionEpoch: epoch,
                                      authoritative: true,
                                      shard: "shard0000",
-                                     shardHost: "localhost:30000" }),
+                                     shardHost: s.s.host }),
                      "should have worked" );
 
 assert( a.runCommand({ setShardVersion: "alleyinsider.foo",
diff --git a/jstests/sharding/version2.js b/jstests/sharding/version2.js
index f41342dcb8a..5a375f89c21 100644
--- a/jstests/sharding/version2.js
+++ b/jstests/sharding/version2.js
@@ -14,13 +14,16 @@ assert.eq( a.runCommand( { "getShardVersion" : "alleyinsider.foo" , configdb : s
 assert.eq( a.runCommand( { "getShardVersion" : "alleyinsider.foo" , configdb : s._configDB } ).global.i, 0 );
 
 var fooEpoch = s.getDB('config').chunks.findOne({ ns: 'alleyinsider.foo' }).lastmodEpoch;
-assert( a.runCommand({ setShardVersion: "alleyinsider.foo",
-                       configdb: s._configDB,
-                       authoritative: true,
-                       version: new Timestamp(1, 0),
-                       versionEpoch: fooEpoch,
-                       shard: "shard0000",
-                       shardHost: "localhost:30000" }).ok == 1 );
+assert.commandWorked(
+    a.runCommand({
+        setShardVersion: "alleyinsider.foo",
+        configdb: s._configDB,
+        authoritative: true,
+        version: new Timestamp(1, 0),
+        versionEpoch: fooEpoch,
+        shard: "shard0000",
+        shardHost: s.s.host,
+    }));
 
 printjson( s.config.chunks.findOne() );
 
diff --git a/jstests/ssl/set_parameter_ssl.js b/jstests/ssl/set_parameter_ssl.js
index 801d4e15b72..98a4065b8a0 100644
--- a/jstests/ssl/set_parameter_ssl.js
+++ b/jstests/ssl/set_parameter_ssl.js
@@ -1,16 +1,15 @@
-// Test changing the --sslMode and --clusterAuthMode 
-// parameters using setParameter
+// Test changing the --sslMode and --clusterAuthMode parameters using setParameter
 
 var SERVER_CERT = "jstests/libs/server.pem"
 var CA_CERT = "jstests/libs/ca.pem" 
-port = allocatePorts(1)[0];
 
 function testSSLTransition(oldMode, newMode, shouldSucceed) {
-    var conn = MongoRunner.runMongod({port: port,
-                           sslMode: oldMode,
-                           sslPEMKeyFile: SERVER_CERT,
-                           sslCAFile: CA_CERT});
-    
+    var conn = MongoRunner.runMongod({
+        sslMode: oldMode,
+        sslPEMKeyFile: SERVER_CERT,
+        sslCAFile: CA_CERT
+    });
+
     var adminDB = conn.getDB("admin");
     adminDB.createUser({user: "root", pwd: "pwd", roles: ['root']});
     adminDB.auth("root", "pwd");
@@ -18,16 +17,17 @@ function testSSLTransition(oldMode, newMode, shouldSucceed) {
                                    "sslMode" : newMode });
 
     assert(res["ok"] == shouldSucceed, tojson(res));
-    MongoRunner.stopMongod(port);
+    MongoRunner.stopMongod(conn.port);
 }
 
 function testAuthModeTransition(oldMode, newMode, sslMode, shouldSucceed) {
-    var conn = MongoRunner.runMongod({port: port,
-                           sslMode: sslMode,
-                           sslPEMKeyFile: SERVER_CERT,
-                           sslCAFile: CA_CERT,
-                           clusterAuthMode: oldMode});
-    
+    var conn = MongoRunner.runMongod({
+        sslMode: sslMode,
+        sslPEMKeyFile: SERVER_CERT,
+        sslCAFile: CA_CERT,
+        clusterAuthMode: oldMode
+    });
+
     var adminDB = conn.getDB("admin");
     adminDB.createUser({user: "root", pwd: "pwd", roles: ['root']});
     adminDB.auth("root", "pwd");
@@ -35,7 +35,7 @@ function testAuthModeTransition(oldMode, newMode, sslMode, shouldSucceed) {
                                    "clusterAuthMode" : newMode });
 
     assert(res["ok"] == shouldSucceed, tojson(res));
-    MongoRunner.stopMongod(port);
+    MongoRunner.stopMongod(conn.port);
 }
 
 testSSLTransition("allowSSL", "invalid", false);
diff --git a/jstests/ssl/ssl_cert_password.js b/jstests/ssl/ssl_cert_password.js
index 1c0e271be20..7e04755329a 100644
--- a/jstests/ssl/ssl_cert_password.js
+++ b/jstests/ssl/ssl_cert_password.js
@@ -2,7 +2,6 @@
 // This tests that providing a proper password works and that providing no password or incorrect
 // password fails.  It uses both mongod and mongo to run the tests, since the mongod binary
 // does not return error statuses to indicate an error.
-port = allocatePorts( 1 )[ 0 ];
 var baseName = "jstests_ssl_ssl_cert_password";
 var dbpath = MongoRunner.dataPath + baseName;
 var external_scratch_dir = MongoRunner.dataPath + baseName + "/external/";
@@ -11,7 +10,6 @@ mkdir(external_scratch_dir);
 
 // Password is correct
 var md = MongoRunner.runMongod({nopreallocj: "",
-                                port: port,
                                 dbpath: dbpath,
                                 sslMode: "requireSSL",
                                 sslPEMKeyFile: "jstests/libs/password_protected.pem",
@@ -21,7 +19,7 @@ var md = MongoRunner.runMongod({nopreallocj: "",
 
 // Password incorrect; error logged is:
 //  error:06065064:digital envelope routines:EVP_DecryptFinal_ex:bad decrypt
-var exit_code = runMongoProgram("mongo", "--port", port,
+var exit_code = runMongoProgram("mongo", "--port", md.port,
                                 "--ssl", "--sslAllowInvalidCertificates",
                                 "--sslPEMKeyFile", "jstests/libs/password_protected.pem",
                                 "--sslPEMKeyPassword", "barf");
@@ -36,7 +34,7 @@ c.save({ a : 22 });
 assert.eq(1, c.count(), "failed to insert document into dumprestore_ssl.foo collection");
 
 exit_code = runMongoProgram("mongodump", "--out", external_scratch_dir,
-                            "--port", port,
+                            "--port", md.port,
                             "--ssl",
                             "--sslPEMKeyFile", "jstests/libs/password_protected.pem",
                             "--sslPEMKeyPassword", "qwerty");
@@ -47,7 +45,7 @@ c.drop();
 assert.eq(0, c.count(), "dumprestore_ssl.foo collection is not empty after drop");
 
 exit_code = runMongoProgram("mongorestore", "--dir", external_scratch_dir,
-                            "--port", port,
+                            "--port", md.port,
                             "--ssl",
                             "--sslPEMKeyFile", "jstests/libs/password_protected.pem",
                             "--sslPEMKeyPassword", "qwerty");
@@ -71,7 +69,7 @@ var exportimport_file = "data.json";
 
 exit_code = runMongoProgram("mongoexport", "--out", external_scratch_dir + exportimport_file,
                             "-d", exportimport_ssl_dbname, "-c", "foo",
-                            "--port", port,
+                            "--port", md.port,
                             "--ssl",
                             "--sslPEMKeyFile", "jstests/libs/password_protected.pem",
                             "--sslPEMKeyPassword", "qwerty");
@@ -83,7 +81,7 @@ assert.eq(0, c.count(), "afterdrop", "-d", exportimport_ssl_dbname, "-c", "foo")
 
 exit_code = runMongoProgram("mongoimport", "--file", external_scratch_dir + exportimport_file,
                             "-d", exportimport_ssl_dbname, "-c", "foo",
-                            "--port", port,
+                            "--port", md.port,
                             "--ssl",
                             "--sslPEMKeyFile", "jstests/libs/password_protected.pem",
                             "--sslPEMKeyPassword", "qwerty");
@@ -104,7 +102,7 @@ source_filename = 'jstests/ssl/ssl_cert_password.js'
 filename = 'ssl_cert_password.js'
 
 exit_code = runMongoProgram("mongofiles", "-d", mongofiles_ssl_dbname, "put", source_filename,
-                            "--port", port,
+                            "--port", md.port,
                             "--ssl",
                             "--sslPEMKeyFile", "jstests/libs/password_protected.pem",
                             "--sslPEMKeyPassword", "qwerty");
@@ -122,7 +120,7 @@ assert.eq(md5, md5_computed, "md5 computed incorrectly by server");
 
 exit_code = runMongoProgram("mongofiles", "-d", mongofiles_ssl_dbname, "get", source_filename,
                             "-l", external_scratch_dir + filename,
-                            "--port", port,
+                            "--port", md.port,
                             "--ssl",
                             "--sslPEMKeyFile", "jstests/libs/password_protected.pem",
                             "--sslPEMKeyPassword", "qwerty");
@@ -134,6 +132,6 @@ assert.eq(md5, md5_stored, "hash of stored file does not match the expected valu
 
 if (!_isWindows()) {
     // Stop the server
-    var exitCode = MongoRunner.stopMongod(port, 15);
+    var exitCode = MongoRunner.stopMongod(md.port, 15);
     assert(exitCode == 0);
 }
diff --git a/jstests/ssl/ssl_fips.js b/jstests/ssl/ssl_fips.js
index 3de4696d582..c831a040f52 100644
--- a/jstests/ssl/ssl_fips.js
+++ b/jstests/ssl/ssl_fips.js
@@ -1,14 +1,11 @@
 // Test mongod start with FIPS mode enabled
-ports = allocatePorts(1);
-port1 = ports[0];
-var md = MongoRunner.runMongod({port: port1,
-                                sslMode: "requireSSL",
+var md = MongoRunner.runMongod({sslMode: "requireSSL",
                                 sslPEMKeyFile: "jstests/libs/server.pem",
                                 sslCAFile: "jstests/libs/ca.pem",
                                 sslFIPSMode: ""});
 
 var mongo = runMongoProgram("mongo",
-                            "--port", port1,
+                            "--port", md.port,
                             "--ssl",
                             "--sslAllowInvalidCertificates",
                             "--sslPEMKeyFile", "jstests/libs/client.pem",
diff --git a/jstests/ssl/ssl_hostname_validation.js b/jstests/ssl/ssl_hostname_validation.js
index 98f99b557e2..6ec02381094 100644
--- a/jstests/ssl/ssl_hostname_validation.js
+++ b/jstests/ssl/ssl_hostname_validation.js
@@ -7,31 +7,34 @@ var SAN_CERT = "jstests/libs/localhostnameSAN.pem";
 var CLIENT_CERT = "jstests/libs/client.pem"
 var BAD_SAN_CERT = "jstests/libs/badSAN.pem";
 
-port = allocatePorts(1)[0];
-
 function testCombination(certPath, allowInvalidHost, allowInvalidCert, shouldSucceed) {
-    MongoRunner.runMongod({port: port,
-                           sslMode: "requireSSL", 
-                           sslPEMKeyFile: certPath,
-                           sslCAFile: CA_CERT});
+    var mongod = MongoRunner.runMongod({sslMode: "requireSSL",
+                                        sslPEMKeyFile: certPath,
+                                        sslCAFile: CA_CERT});
 
     var mongo;
     if (allowInvalidCert) {
-        mongo = runMongoProgram("mongo", "--port", port, "--ssl", 
-                                "--sslCAFile", CA_CERT, 
+        mongo = runMongoProgram("mongo",
+                                "--port", mongod.port,
+                                "--ssl",
+                                "--sslCAFile", CA_CERT,
                                 "--sslPEMKeyFile", CLIENT_CERT,
                                 "--sslAllowInvalidCertificates",
                                 "--eval", ";");
     }
     else if (allowInvalidHost) {
-        mongo = runMongoProgram("mongo", "--port", port, "--ssl",
+        mongo = runMongoProgram("mongo",
+                                "--port", mongod.port,
+                                "--ssl",
                                 "--sslCAFile", CA_CERT,
                                 "--sslPEMKeyFile", CLIENT_CERT,
                                 "--sslAllowInvalidHostnames",
                                 "--eval", ";");
     } else {
-        mongo = runMongoProgram("mongo", "--port", port, "--ssl", 
-                                "--sslCAFile", CA_CERT, 
+        mongo = runMongoProgram("mongo",
+                                "--port", mongod.port,
+                                "--ssl",
+                                "--sslCAFile", CA_CERT,
                                 "--sslPEMKeyFile", CLIENT_CERT,
                                 "--eval", ";");
     }
@@ -46,7 +49,7 @@ function testCombination(certPath, allowInvalidHost, allowInvalidCert, shouldSuc
         assert.eq(1, mongo, "Connection attempt succeeded when it should fail certPath: " + 
                   certPath);
     }
-    MongoRunner.stopMongod(port);
+    MongoRunner.stopMongod(mongod.port);
 }
 
 // 1. Test client connections with different server certificates
diff --git a/jstests/ssl/x509_client.js b/jstests/ssl/x509_client.js
index 642c87ff289..59b5b268e63 100644
--- a/jstests/ssl/x509_client.js
+++ b/jstests/ssl/x509_client.js
@@ -20,8 +20,6 @@ var CA_CERT = "jstests/libs/ca.pem"
 var CLIENT_USER = "C=US,ST=New York,L=New York City,O=MongoDB,OU=KernelUser,CN=client"
 var INVALID_CLIENT_USER = "C=US,ST=New York,L=New York City,O=MongoDB,OU=KernelUser,CN=invalid"
 
-port = allocatePorts(1)[0];
-
 function authAndTest(mongo) {
     external = mongo.getDB("$external")
     test = mongo.getDB("test");
@@ -53,10 +51,10 @@ var x509_options = {sslMode : "requireSSL",
                     sslPEMKeyFile : SERVER_CERT,
                     sslCAFile : CA_CERT};
 
-var mongo = MongoRunner.runMongod(Object.merge(x509_options, {port: port, auth: ""}));
+var mongo = MongoRunner.runMongod(Object.merge(x509_options, {auth: ""}));
 
 authAndTest(mongo);
-MongoRunner.stopMongod(port);
+MongoRunner.stopMongod(mongo.port);
 
 print("2. Testing x.509 auth to mongos");
 
diff --git a/jstests/sslSpecial/set_parameter_nossl.js b/jstests/sslSpecial/set_parameter_nossl.js
index 0b5e72dd4fb..280d47b6130 100644
--- a/jstests/sslSpecial/set_parameter_nossl.js
+++ b/jstests/sslSpecial/set_parameter_nossl.js
@@ -1,15 +1,12 @@
-// Test changing the --sslMode and --clusterAuthMode 
+// Test changing the --sslMode and --clusterAuthMode
 // parameters using setParameter
 
-port = allocatePorts(1)[0];
-
 // setParameter should always fail since it
 // cannot be used to transition from disabled/keyFile modes
 function testTransition(newSSLMode, newClusterAuthMode) {
     // If no parameters are given sslMode defaults to disabled
-    var conn = MongoRunner.runMongod({port: port,
-                                      clusterAuthMode: "keyFile"})
-    var adminDB = conn.getDB("admin"); 
+    var conn = MongoRunner.runMongod({clusterAuthMode: "keyFile"});
+    var adminDB = conn.getDB("admin");
     var res = adminDB.runCommand({ "setParameter" : 1,
                                    "sslMode" : newSSLMode });
     assert(!res["ok"]);
@@ -17,10 +14,9 @@ function testTransition(newSSLMode, newClusterAuthMode) {
     var res = adminDB.runCommand({ "setParameter" : 1,
                                    "clusterAuthMode" : newClusterAuthMode });
     assert(!res["ok"]);
-    MongoRunner.stopMongod(port);
+    MongoRunner.stopMongod(conn.port);
 }
 
 testTransition("allowSSL", "sendKeyFile");
 testTransition("preferSSL", "sendX509");
 testTransition("requireSSL", "x509");
-
diff --git a/jstests/tool/oplog_all_ops.js b/jstests/tool/oplog_all_ops.js
index 8f231cb233d..fb51f2b0b53 100644
--- a/jstests/tool/oplog_all_ops.js
+++ b/jstests/tool/oplog_all_ops.js
@@ -36,8 +36,14 @@ testColl.remove({ y: 2 });
 var oplogColl = repl1Conn.getCollection('local.oplog.rs');
 oplogColl.insert({ ts: new Timestamp(), op: 'n', ns: testColl.getFullName(), 'o': { x: 'noop' }});
 
-var repl2 = new ReplSetTest({ name: 'rs2', startPort: 31100, nodes: [{ nopreallocj: '' },
-    { arbiter: true }, { arbiter: true }]});
+var repl2 = new ReplSetTest({
+    name: 'rs2',
+    nodes: [
+        {nopreallocj: ''},
+        {arbiter: true},
+        {arbiter: true}
+    ]
+});
 
 repl2.startSet({ oplogSize: 10 });
 repl2.initiate();