diff --git a/indra/llcorehttp/tests/test_httprequest.hpp b/indra/llcorehttp/tests/test_httprequest.hpp
index ff84b04070ea75a26d8f602d008bcf98d8c3a06c..900a69988796c3e37753d5455ea533699f47e39b 100755
--- a/indra/llcorehttp/tests/test_httprequest.hpp
+++ b/indra/llcorehttp/tests/test_httprequest.hpp
@@ -45,6 +45,15 @@
 
 using namespace LLCoreInt;
 
+// spin/sleep waiting times for client/server exchange tests
+//
+// These are now fairly generous to try to get around timeout
+// ('reasonable time') failures during execution on a heavily-
+// loaded system where the unit test is in competition with
+// other programs.
+static const int LOOP_SLEEP_INTERVAL(10000);
+static const int LOOP_COUNT_SHORT(500);			// 5-second dwell time
+static const int LOOP_COUNT_LONG(3000);			// 30-second dwell time
 
 namespace
 {
@@ -294,11 +303,11 @@ void HttpRequestTestObjectType::test<3>()
 
 		// Run the notification pump.
 		int count(0);
-		int limit(20);
+		int limit(LOOP_COUNT_SHORT);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Request executed in reasonable time", count < limit);
 		ensure("One handler invocation for request", mHandlerCalls == 1);
@@ -309,21 +318,21 @@ void HttpRequestTestObjectType::test<3>()
 	
 		// Run the notification pump again
 		count = 0;
-		limit = 100;
+		limit = LOOP_COUNT_LONG;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
 		ensure("Second handler invocation", mHandlerCalls == 2);
 
 		// See that we actually shutdown the thread
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_SHORT;
 		while (count++ < limit && ! HttpService::isStopped())
 		{
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Thread actually stopped running", HttpService::isStopped());
 	
@@ -392,12 +401,12 @@ void HttpRequestTestObjectType::test<4>()
 
 		// Run the notification pump.
 		int count(0);
-		int limit(20);
+		int limit(LOOP_COUNT_LONG);
 		while (count++ < limit && mHandlerCalls < 2)
 		{
 			req1->update(1000000);
 			req2->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Request executed in reasonable time", count < limit);
 		ensure("One handler invocation for request", mHandlerCalls == 2);
@@ -409,22 +418,22 @@ void HttpRequestTestObjectType::test<4>()
 	
 		// Run the notification pump again
 		count = 0;
-		limit = 100;
+		limit = LOOP_COUNT_LONG;
 		while (count++ < limit && mHandlerCalls < 3)
 		{
 			req1->update(1000000);
 			req2->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
 		ensure("Second handler invocation", mHandlerCalls == 3);
 
 		// See that we actually shutdown the thread
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_SHORT;
 		while (count++ < limit && ! HttpService::isStopped())
 		{
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Thread actually stopped running", HttpService::isStopped());
 	
@@ -493,11 +502,11 @@ void HttpRequestTestObjectType::test<5>()
 
 		// Run the notification pump.
 		int count(0);
-		int limit(10);
+		int limit(LOOP_COUNT_SHORT);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("NoOp notification received", mHandlerCalls == 1);
 
@@ -569,11 +578,11 @@ void HttpRequestTestObjectType::test<6>()
 
 		// Run the notification pump.
 		int count(0);
-		int limit(10);
+		int limit(LOOP_COUNT_SHORT);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("No notifications received", mHandlerCalls == 0);
 
@@ -650,11 +659,11 @@ void HttpRequestTestObjectType::test<7>()
 
 		// Run the notification pump.
 		int count(0);
-		int limit(50);				// With one retry, should fail quickish
+		int limit(LOOP_COUNT_LONG);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Request executed in reasonable time", count < limit);
 		ensure("One handler invocation for request", mHandlerCalls == 1);
@@ -666,21 +675,21 @@ void HttpRequestTestObjectType::test<7>()
 	
 		// Run the notification pump again
 		count = 0;
-		limit = 100;
+		limit = LOOP_COUNT_LONG;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
 		ensure("Second handler invocation", mHandlerCalls == 2);
 
 		// See that we actually shutdown the thread
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_SHORT;
 		while (count++ < limit && ! HttpService::isStopped())
 		{
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Thread actually stopped running", HttpService::isStopped());
 
@@ -766,11 +775,11 @@ void HttpRequestTestObjectType::test<8>()
 
 		// Run the notification pump.
 		int count(0);
-		int limit(10);
+		int limit(LOOP_COUNT_LONG);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Request executed in reasonable time", count < limit);
 		ensure("One handler invocation for request", mHandlerCalls == 1);
@@ -782,21 +791,21 @@ void HttpRequestTestObjectType::test<8>()
 	
 		// Run the notification pump again
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_LONG;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
 		ensure("Second handler invocation", mHandlerCalls == 2);
 
 		// See that we actually shutdown the thread
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_SHORT;
 		while (count++ < limit && ! HttpService::isStopped())
 		{
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Thread actually stopped running", HttpService::isStopped());
 	
@@ -876,11 +885,11 @@ void HttpRequestTestObjectType::test<9>()
 
 		// Run the notification pump.
 		int count(0);
-		int limit(10);
+		int limit(LOOP_COUNT_LONG);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Request executed in reasonable time", count < limit);
 		ensure("One handler invocation for request", mHandlerCalls == 1);
@@ -892,21 +901,21 @@ void HttpRequestTestObjectType::test<9>()
 	
 		// Run the notification pump again
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_LONG;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
 		ensure("Second handler invocation", mHandlerCalls == 2);
 
 		// See that we actually shutdown the thread
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_SHORT;
 		while (count++ < limit && ! HttpService::isStopped())
 		{
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Thread actually stopped running", HttpService::isStopped());
 	
@@ -988,11 +997,11 @@ void HttpRequestTestObjectType::test<10>()
 
 		// Run the notification pump.
 		int count(0);
-		int limit(10);
+		int limit(LOOP_COUNT_LONG);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Request executed in reasonable time", count < limit);
 		ensure("One handler invocation for request", mHandlerCalls == 1);
@@ -1004,21 +1013,21 @@ void HttpRequestTestObjectType::test<10>()
 	
 		// Run the notification pump again
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_LONG;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
 		ensure("Second handler invocation", mHandlerCalls == 2);
 
 		// See that we actually shutdown the thread
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_SHORT;
 		while (count++ < limit && ! HttpService::isStopped())
 		{
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Thread actually stopped running", HttpService::isStopped());
 
@@ -1106,11 +1115,11 @@ void HttpRequestTestObjectType::test<11>()
 
 		// Run the notification pump.
 		int count(0);
-		int limit(10);
+		int limit(LOOP_COUNT_LONG);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Request executed in reasonable time", count < limit);
 		ensure("One handler invocation for request", mHandlerCalls == 1);
@@ -1122,21 +1131,21 @@ void HttpRequestTestObjectType::test<11>()
 	
 		// Run the notification pump again
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_LONG;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
 		ensure("Second handler invocation", mHandlerCalls == 2);
 
 		// See that we actually shutdown the thread
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_SHORT;
 		while (count++ < limit && ! HttpService::isStopped())
 		{
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Thread actually stopped running", HttpService::isStopped());
 
@@ -1226,11 +1235,11 @@ void HttpRequestTestObjectType::test<12>()
 
 		// Run the notification pump.
 		int count(0);
-		int limit(10);
+		int limit(LOOP_COUNT_LONG);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Request executed in reasonable time", count < limit);
 		ensure("One handler invocation for request", mHandlerCalls == 1);
@@ -1242,21 +1251,21 @@ void HttpRequestTestObjectType::test<12>()
 	
 		// Run the notification pump again
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_LONG;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
 		ensure("Second handler invocation", mHandlerCalls == 2);
 
 		// See that we actually shutdown the thread
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_SHORT;
 		while (count++ < limit && ! HttpService::isStopped())
 		{
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Thread actually stopped running", HttpService::isStopped());
 	
@@ -1339,8 +1348,8 @@ void HttpRequestTestObjectType::test<13>()
 		HttpHandle handle = req->requestGetByteRange(HttpRequest::DEFAULT_POLICY_ID,
 													 0U,
 													 url_base,
-													 0,
-													 0,
+													 0,	
+												 0,
 													 opts,
 													 NULL,
 													 &handler);
@@ -1352,11 +1361,11 @@ void HttpRequestTestObjectType::test<13>()
 
 		// Run the notification pump.
 		int count(0);
-		int limit(10);
+		int limit(LOOP_COUNT_LONG);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Request executed in reasonable time", count < limit);
 		ensure("One handler invocation for request", mHandlerCalls == 1);
@@ -1369,21 +1378,21 @@ void HttpRequestTestObjectType::test<13>()
 	
 		// Run the notification pump again
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_LONG;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
 		ensure("Second handler invocation", mHandlerCalls == 2);
 
 		// See that we actually shutdown the thread
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_SHORT;
 		while (count++ < limit && ! HttpService::isStopped())
 		{
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Thread actually stopped running", HttpService::isStopped());
 	
@@ -1471,11 +1480,11 @@ void HttpRequestTestObjectType::test<14>()
 
 		// Run the notification pump.
 		int count(0);
-		int limit(50);				// With one retry, should fail quickish
+		int limit(LOOP_COUNT_LONG);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Request executed in reasonable time", count < limit);
 		ensure("One handler invocation for request", mHandlerCalls == 1);
@@ -1487,21 +1496,21 @@ void HttpRequestTestObjectType::test<14>()
 	
 		// Run the notification pump again
 		count = 0;
-		limit = 100;
+		limit = LOOP_COUNT_LONG;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
 		ensure("Second handler invocation", mHandlerCalls == 2);
 
 		// See that we actually shutdown the thread
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_SHORT;
 		while (count++ < limit && ! HttpService::isStopped())
 		{
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Thread actually stopped running", HttpService::isStopped());
 
@@ -1594,11 +1603,11 @@ void HttpRequestTestObjectType::test<15>()
 
 		// Run the notification pump.
 		int count(0);
-		int limit(10);
+		int limit(LOOP_COUNT_LONG);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Request executed in reasonable time", count < limit);
 		ensure("One handler invocation for request", mHandlerCalls == 1);
@@ -1611,21 +1620,21 @@ void HttpRequestTestObjectType::test<15>()
 	
 		// Run the notification pump again
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_LONG;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
 		ensure("Second handler invocation", mHandlerCalls == 2);
 
 		// See that we actually shutdown the thread
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_SHORT;
 		while (count++ < limit && ! HttpService::isStopped())
 		{
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Thread actually stopped running", HttpService::isStopped());
 	
@@ -1724,11 +1733,11 @@ void HttpRequestTestObjectType::test<16>()
 
 		// Run the notification pump.
 		int count(0);
-		int limit(10);
+		int limit(LOOP_COUNT_LONG);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Request executed in reasonable time", count < limit);
 		ensure("One handler invocation for request", mHandlerCalls == 1);
@@ -1764,11 +1773,11 @@ void HttpRequestTestObjectType::test<16>()
 
 		// Run the notification pump.
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_LONG;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Request executed in reasonable time", count < limit);
 		ensure("One handler invocation for request", mHandlerCalls == 2);
@@ -1783,21 +1792,21 @@ void HttpRequestTestObjectType::test<16>()
 	
 		// Run the notification pump again
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_LONG;
 		while (count++ < limit && mHandlerCalls < 3)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
 		ensure("Second handler invocation", mHandlerCalls == 3);
 
 		// See that we actually shutdown the thread
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_SHORT;
 		while (count++ < limit && ! HttpService::isStopped())
 		{
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Thread actually stopped running", HttpService::isStopped());
 	
@@ -1919,11 +1928,11 @@ void HttpRequestTestObjectType::test<17>()
 			
 		// Run the notification pump.
 		int count(0);
-		int limit(10);
+		int limit(LOOP_COUNT_LONG);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Request executed in reasonable time", count < limit);
 		ensure("One handler invocation for request", mHandlerCalls == 1);
@@ -1938,21 +1947,21 @@ void HttpRequestTestObjectType::test<17>()
 	
 		// Run the notification pump again
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_LONG;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
 		ensure("Second handler invocation", mHandlerCalls == 2);
 
 		// See that we actually shutdown the thread
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_SHORT;
 		while (count++ < limit && ! HttpService::isStopped())
 		{
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Thread actually stopped running", HttpService::isStopped());
 	
@@ -2079,11 +2088,11 @@ void HttpRequestTestObjectType::test<18>()
 			
 		// Run the notification pump.
 		int count(0);
-		int limit(10);
+		int limit(LOOP_COUNT_LONG);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Request executed in reasonable time", count < limit);
 		ensure("One handler invocation for request", mHandlerCalls == 1);
@@ -2098,21 +2107,21 @@ void HttpRequestTestObjectType::test<18>()
 	
 		// Run the notification pump again
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_LONG;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
 		ensure("Second handler invocation", mHandlerCalls == 2);
 
 		// See that we actually shutdown the thread
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_SHORT;
 		while (count++ < limit && ! HttpService::isStopped())
 		{
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Thread actually stopped running", HttpService::isStopped());
 	
@@ -2237,11 +2246,11 @@ void HttpRequestTestObjectType::test<19>()
 
 		// Run the notification pump.
 		int count(0);
-		int limit(10);
+		int limit(LOOP_COUNT_LONG);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Request executed in reasonable time", count < limit);
 		ensure("One handler invocation for request", mHandlerCalls == 1);
@@ -2255,21 +2264,21 @@ void HttpRequestTestObjectType::test<19>()
 	
 		// Run the notification pump again
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_LONG;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
 		ensure("Second handler invocation", mHandlerCalls == 2);
 
 		// See that we actually shutdown the thread
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_SHORT;
 		while (count++ < limit && ! HttpService::isStopped())
 		{
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Thread actually stopped running", HttpService::isStopped());
 	
@@ -2401,11 +2410,11 @@ void HttpRequestTestObjectType::test<20>()
 			
 		// Run the notification pump.
 		int count(0);
-		int limit(10);
+		int limit(LOOP_COUNT_LONG);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Request executed in reasonable time", count < limit);
 		ensure("One handler invocation for request", mHandlerCalls == 1);
@@ -2420,21 +2429,21 @@ void HttpRequestTestObjectType::test<20>()
 	
 		// Run the notification pump again
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_LONG;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
 		ensure("Second handler invocation", mHandlerCalls == 2);
 
 		// See that we actually shutdown the thread
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_SHORT;
 		while (count++ < limit && ! HttpService::isStopped())
 		{
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Thread actually stopped running", HttpService::isStopped());
 	
@@ -2569,11 +2578,11 @@ void HttpRequestTestObjectType::test<21>()
 			
 		// Run the notification pump.
 		int count(0);
-		int limit(10);
+		int limit(LOOP_COUNT_LONG);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Request executed in reasonable time", count < limit);
 		ensure("One handler invocation for request", mHandlerCalls == 1);
@@ -2588,21 +2597,21 @@ void HttpRequestTestObjectType::test<21>()
 	
 		// Run the notification pump again
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_LONG;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
 		ensure("Second handler invocation", mHandlerCalls == 2);
 
 		// See that we actually shutdown the thread
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_SHORT;
 		while (count++ < limit && ! HttpService::isStopped())
 		{
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Thread actually stopped running", HttpService::isStopped());
 	
@@ -2712,11 +2721,11 @@ void HttpRequestTestObjectType::test<22>()
 		
 		// Run the notification pump.
 		int count(0);
-		int limit(30);
+		int limit(LOOP_COUNT_LONG);
 		while (count++ < limit && mHandlerCalls < test_count)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Request executed in reasonable time - ms1", count < limit);
 		ensure("One handler invocation for each request - ms1", mHandlerCalls == test_count);
@@ -2744,11 +2753,11 @@ void HttpRequestTestObjectType::test<22>()
 		
 		// Run the notification pump.
 		count = 0;
-		limit = 30;
+		limit = LOOP_COUNT_LONG;
 		while (count++ < limit && mHandlerCalls < test2_count)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Request executed in reasonable time - ms2", count < limit);
 		ensure("One handler invocation for each request - ms2", mHandlerCalls == test2_count);
@@ -2776,11 +2785,11 @@ void HttpRequestTestObjectType::test<22>()
 		
 		// Run the notification pump.
 		count = 0;
-		limit = 30;
+		limit = LOOP_COUNT_LONG;
 		while (count++ < limit && mHandlerCalls < test3_count)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Request executed in reasonable time - ms3", count < limit);
 		ensure("One handler invocation for each request - ms3", mHandlerCalls == test3_count);
@@ -2795,21 +2804,21 @@ void HttpRequestTestObjectType::test<22>()
 	
 		// Run the notification pump again
 		count = 0;
-		limit = 20;
+		limit = LOOP_COUNT_LONG;
 		while (count++ < limit && mHandlerCalls < 1)
 		{
 			req->update(1000000);
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Shutdown request executed in reasonable time", count < limit);
 		ensure("Shutdown handler invocation", mHandlerCalls == 1);
 
 		// See that we actually shutdown the thread
 		count = 0;
-		limit = 10;
+		limit = LOOP_COUNT_SHORT;
 		while (count++ < limit && ! HttpService::isStopped())
 		{
-			usleep(100000);
+			usleep(LOOP_SLEEP_INTERVAL);
 		}
 		ensure("Thread actually stopped running", HttpService::isStopped());
 
diff --git a/indra/llcorehttp/tests/test_httpstatus.hpp b/indra/llcorehttp/tests/test_httpstatus.hpp
index 887315befc3e3543e74a9d48cb14fe66df0149d3..b5538528c5b9e7e2ad3804792d57f632d856bb1a 100755
--- a/indra/llcorehttp/tests/test_httpstatus.hpp
+++ b/indra/llcorehttp/tests/test_httpstatus.hpp
@@ -4,7 +4,7 @@
  *
  * $LicenseInfo:firstyear=2012&license=viewerlgpl$
  * Second Life Viewer Source Code
- * Copyright (C) 2012, Linden Research, Inc.
+ * Copyright (C) 2012-2013, Linden Research, Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -91,9 +91,6 @@ template <> template <>
 void HttpStatusTestObjectType::test<2>()
 {
 	set_test_name("HttpStatus memory structure");
-#if LL_WINDOWS
-	skip("MAINT-2302: This frequently (though not always) fails on Windows.");
-#endif
 
 	// Require that an HttpStatus object can be trivially
 	// returned as a function return value in registers.
@@ -106,10 +103,7 @@ void HttpStatusTestObjectType::test<2>()
 template <> template <>
 void HttpStatusTestObjectType::test<3>()
 {
-	set_test_name("HttpStatus valid error string conversion");
-#if LL_WINDOWS
-	skip("MAINT-2302: This frequently (though not always) fails on Windows.");
-#endif
+	set_test_name("HttpStatus valid status string conversion");
 	
 	HttpStatus status;
 	status.mType = HttpStatus::EXT_CURL_EASY;
@@ -141,10 +135,7 @@ void HttpStatusTestObjectType::test<3>()
 template <> template <>
 void HttpStatusTestObjectType::test<4>()
 {
-	set_test_name("HttpStatus invalid error string conversion");
-#if LL_WINDOWS
-	skip("MAINT-2302: This frequently (though not always) fails on Windows.");
-#endif
+	set_test_name("HttpStatus invalid status string conversion");
 	
 	HttpStatus status;
 	status.mType = HttpStatus::EXT_CURL_EASY;
@@ -170,9 +161,6 @@ template <> template <>
 void HttpStatusTestObjectType::test<5>()
 {
 	set_test_name("HttpStatus equality/inequality testing");
-#if LL_WINDOWS
-	skip("MAINT-2302: This frequently (though not always) fails on Windows.");
-#endif
 
 	// Make certain equality/inequality tests do not pass
 	// through the bool conversion.  Distinct successful
@@ -193,9 +181,6 @@ template <> template <>
 void HttpStatusTestObjectType::test<6>()
 {
 	set_test_name("HttpStatus basic HTTP status encoding");
-#if LL_WINDOWS
-	skip("MAINT-2302: This frequently (though not always) fails on Windows.");
-#endif
 	
 	HttpStatus status;
 	status.mType = 200;
@@ -242,10 +227,7 @@ void HttpStatusTestObjectType::test<6>()
 template <> template <>
 void HttpStatusTestObjectType::test<7>()
 {
-	set_test_name("HttpStatus HTTP error text strings");
-#if LL_WINDOWS
-	skip("MAINT-2302: This frequently (though not always) fails on Windows.");
-#endif
+	set_test_name("HttpStatus HTTP status text strings");
 
 	HttpStatus status(100, HE_REPLY_ERROR);
 	std::string msg(status.toString());
diff --git a/indra/llcorehttp/tests/test_llcorehttp_peer.py b/indra/llcorehttp/tests/test_llcorehttp_peer.py
index 8796ae57c7ca58c41fbd09a3e2805424611da956..3c3af8dc75b84f88fae15fd3555813f9d2d342ba 100755
--- a/indra/llcorehttp/tests/test_llcorehttp_peer.py
+++ b/indra/llcorehttp/tests/test_llcorehttp_peer.py
@@ -73,6 +73,8 @@ class TestHTTPRequestHandler(BaseHTTPRequestHandler):
     Some combinations make no sense, there's no effort to protect
     you from that.
     """
+    ignore_exceptions = (Exception,)
+
     def read(self):
         # The following logic is adapted from the library module
         # SimpleXMLRPCServer.py.
@@ -112,20 +114,29 @@ class TestHTTPRequestHandler(BaseHTTPRequestHandler):
 
     def do_GET(self, withdata=True):
         # Of course, don't attempt to read data.
-        self.answer(dict(reply="success", status=200,
-                         reason="Your GET operation worked"))
+        try:
+            self.answer(dict(reply="success", status=200,
+                             reason="Your GET operation worked"))
+        except self.ignore_exceptions, e:
+            print >> sys.stderr, "Exception during GET (ignoring): %s" % str(e)
 
     def do_POST(self):
         # Read the provided POST data.
         # self.answer(self.read())
-        self.answer(dict(reply="success", status=200,
-                         reason=self.read()))
+        try:
+            self.answer(dict(reply="success", status=200,
+                             reason=self.read()))
+        except self.ignore_exceptions, e:
+            print >> sys.stderr, "Exception during POST (ignoring): %s" % str(e)
 
     def do_PUT(self):
         # Read the provided PUT data.
         # self.answer(self.read())
-        self.answer(dict(reply="success", status=200,
-                         reason=self.read()))
+        try:
+            self.answer(dict(reply="success", status=200,
+                             reason=self.read()))
+        except self.ignore_exceptions, e:
+            print >> sys.stderr, "Exception during PUT (ignoring): %s" % str(e)
 
     def answer(self, data, withdata=True):
         debug("%s.answer(%s): self.path = %r", self.__class__.__name__, data, self.path)
@@ -223,6 +234,17 @@ class Server(ThreadingMixIn, HTTPServer):
     # operation of freeport() absolutely depends on it being off.
     allow_reuse_address = False
 
+    # Override of BaseServer.handle_error().  Not too interested
+    # in errors and the default handler emits a scary traceback
+    # to stderr which annoys some.  Disable this override to get
+    # default behavior which *shouldn't* cause the program to return
+    # a failure status.
+    def handle_error(self, request, client_address):
+        print '-'*40
+        print 'Ignoring exception during processing of request from',
+        print client_address
+        print '-'*40
+
 if __name__ == "__main__":
     do_valgrind = False
     path_search = False
@@ -249,3 +271,4 @@ if __name__ == "__main__":
         args = ["valgrind", "--log-file=./valgrind.log"] + args
         path_search = True
     sys.exit(run(server=Thread(name="httpd", target=httpd.serve_forever), use_path=path_search, *args))
+