diff --git a/lib/cpp/test/Benchmark.cpp b/lib/cpp/test/Benchmark.cpp
old mode 100644
new mode 100755
index 36da0bd..413802d
--- a/lib/cpp/test/Benchmark.cpp
+++ b/lib/cpp/test/Benchmark.cpp
@@ -70,7 +70,7 @@
   ooe.zomg_unicode     = "\xd7\n\a\t";
   ooe.base64 = "\1\2\3\255";
 
-  shared_ptr<TMemoryBuffer> buf(new TMemoryBuffer());
+  boost::shared_ptr<TMemoryBuffer> buf(new TMemoryBuffer());
 
   int num = 1000000;
 
@@ -96,7 +96,7 @@
 
     for (int i = 0; i < num; i ++) {
       OneOfEach ooe2;
-      shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
+      boost::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
       //buf2->resetBuffer(data, datasize);
       TBinaryProtocolT<TBufferBase> prot(buf2);
       ooe2.read(&prot);
diff --git a/lib/cpp/test/RWMutexStarveTest.cpp b/lib/cpp/test/RWMutexStarveTest.cpp
index ca04e6e..8042d49 100644
--- a/lib/cpp/test/RWMutexStarveTest.cpp
+++ b/lib/cpp/test/RWMutexStarveTest.cpp
@@ -36,7 +36,7 @@
 class Locker : public Runnable
 {
 protected:
-  Locker(shared_ptr<ReadWriteMutex> rwlock, bool writer) :
+  Locker(boost::shared_ptr<ReadWriteMutex> rwlock, bool writer) :
     rwlock_(rwlock), writer_(writer),
     started_(false), gotLock_(false), signaled_(false) { }
 
@@ -61,7 +61,7 @@
   void signal() { signaled_ = true; }
 
 protected:
-  shared_ptr<ReadWriteMutex> rwlock_;
+  boost::shared_ptr<ReadWriteMutex> rwlock_;
   bool writer_;
   volatile bool started_;
   volatile bool gotLock_;
@@ -71,13 +71,13 @@
 class Reader : public Locker
 {
 public:
-  Reader(shared_ptr<ReadWriteMutex> rwlock) : Locker(rwlock, false) { }
+  Reader(boost::shared_ptr<ReadWriteMutex> rwlock) : Locker(rwlock, false) { }
 };
 
 class Writer : public Locker
 {
 public:
-  Writer(shared_ptr<ReadWriteMutex> rwlock) : Locker(rwlock, true) { }
+  Writer(boost::shared_ptr<ReadWriteMutex> rwlock) : Locker(rwlock, true) { }
 };
 
 void test_starve(PosixThreadFactory::POLICY policy)
@@ -88,15 +88,15 @@
   PosixThreadFactory factory(policy);
   factory.setDetached(false);
 
-  shared_ptr<ReadWriteMutex> rwlock(new NoStarveReadWriteMutex());
+  boost::shared_ptr<ReadWriteMutex> rwlock(new NoStarveReadWriteMutex());
 
-  shared_ptr<Reader> reader1(new Reader(rwlock));
-  shared_ptr<Reader> reader2(new Reader(rwlock));
-  shared_ptr<Writer> writer(new Writer(rwlock));
+  boost::shared_ptr<Reader> reader1(new Reader(rwlock));
+  boost::shared_ptr<Reader> reader2(new Reader(rwlock));
+  boost::shared_ptr<Writer> writer(new Writer(rwlock));
 
-  shared_ptr<Thread> treader1 = factory.newThread(reader1);
-  shared_ptr<Thread> treader2 = factory.newThread(reader2);
-  shared_ptr<Thread> twriter = factory.newThread(writer);
+  boost::shared_ptr<Thread> treader1 = factory.newThread(reader1);
+  boost::shared_ptr<Thread> treader2 = factory.newThread(reader2);
+  boost::shared_ptr<Thread> twriter = factory.newThread(writer);
 
   // launch a reader and make sure he has the lock
   treader1->start();
diff --git a/lib/cpp/test/TPipedTransportTest.cpp b/lib/cpp/test/TPipedTransportTest.cpp
index 5708fd2..e1e372c 100644
--- a/lib/cpp/test/TPipedTransportTest.cpp
+++ b/lib/cpp/test/TPipedTransportTest.cpp
@@ -23,15 +23,14 @@
 #include <transport/TTransportUtils.h>
 #include <transport/TBufferTransports.h>
 using namespace std;
-using boost::shared_ptr;
 using apache::thrift::transport::TTransportException;
 using apache::thrift::transport::TPipedTransport;
 using apache::thrift::transport::TMemoryBuffer;
 
 int main() {
-  shared_ptr<TMemoryBuffer> underlying(new TMemoryBuffer);
-  shared_ptr<TMemoryBuffer> pipe(new TMemoryBuffer);
-  shared_ptr<TPipedTransport> trans(new TPipedTransport(underlying, pipe));
+  boost::shared_ptr<TMemoryBuffer> underlying(new TMemoryBuffer);
+  boost::shared_ptr<TMemoryBuffer> pipe(new TMemoryBuffer);
+  boost::shared_ptr<TPipedTransport> trans(new TPipedTransport(underlying, pipe));
 
   uint8_t buffer[4];
 
diff --git a/lib/cpp/test/ZlibTest.cpp b/lib/cpp/test/ZlibTest.cpp
index 9df9dc4..605e9db 100644
--- a/lib/cpp/test/ZlibTest.cpp
+++ b/lib/cpp/test/ZlibTest.cpp
@@ -142,8 +142,8 @@
  */
 
 void test_write_then_read(const uint8_t* buf, uint32_t buf_len) {
-  shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
-  shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
+  boost::shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
+  boost::shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
   zlib_trans->write(buf, buf_len);
   zlib_trans->finish();
 
@@ -161,8 +161,8 @@
   // it isn't there.  The original implementation complained that
   // the stream was not complete.  I'm about to go fix that.
   // It worked.  Awesome.
-  shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
-  shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
+  boost::shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
+  boost::shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
   zlib_trans->write(buf, buf_len);
   zlib_trans->finish();
   string tmp_buf;
@@ -181,8 +181,8 @@
 void test_incomplete_checksum(const uint8_t* buf, uint32_t buf_len) {
   // Make sure we still get that "not complete" error if
   // it really isn't complete.
-  shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
-  shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
+  boost::shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
+  boost::shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
   zlib_trans->write(buf, buf_len);
   zlib_trans->finish();
   string tmp_buf;
@@ -205,11 +205,11 @@
 }
 
 void test_read_write_mix(const uint8_t* buf, uint32_t buf_len,
-                         const shared_ptr<SizeGenerator>& write_gen,
-                         const shared_ptr<SizeGenerator>& read_gen) {
+                         const boost::shared_ptr<SizeGenerator>& write_gen,
+                         const boost::shared_ptr<SizeGenerator>& read_gen) {
   // Try it with a mix of read/write sizes.
-  shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
-  shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
+  boost::shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
+  boost::shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
   unsigned int tot;
 
   tot = 0;
@@ -244,8 +244,8 @@
 
 void test_invalid_checksum(const uint8_t* buf, uint32_t buf_len) {
   // Verify checksum checking.
-  shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
-  shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
+  boost::shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
+  boost::shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
   zlib_trans->write(buf, buf_len);
   zlib_trans->finish();
   string tmp_buf;
@@ -282,8 +282,8 @@
 
 void test_write_after_flush(const uint8_t* buf, uint32_t buf_len) {
   // write some data
-  shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
-  shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
+  boost::shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
+  boost::shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
   zlib_trans->write(buf, buf_len);
 
   // call finish()
@@ -318,7 +318,7 @@
 void test_no_write() {
   // Verify that no data is written to the underlying transport if we
   // never write data to the TZlibTransport.
-  shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
+  boost::shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
   {
     // Create a TZlibTransport object, and immediately destroy it
     // when it goes out of scope.
@@ -352,8 +352,8 @@
   ADD_TEST_CASE(suite, name, test_invalid_checksum, buf, buf_len);
   ADD_TEST_CASE(suite, name, test_write_after_flush, buf, buf_len);
 
-  shared_ptr<SizeGenerator> size_32k(new ConstantSizeGenerator(1<<15));
-  shared_ptr<SizeGenerator> size_lognormal(new LogNormalSizeGenerator(20, 30));
+  boost::shared_ptr<SizeGenerator> size_32k(new ConstantSizeGenerator(1<<15));
+  boost::shared_ptr<SizeGenerator> size_lognormal(new LogNormalSizeGenerator(20, 30));
   ADD_TEST_CASE(suite, name << "-constant",
                 test_read_write_mix, buf, buf_len,
                 size_32k, size_32k);
@@ -373,8 +373,8 @@
   // Because the SizeGenerator makes a copy of the random number generator,
   // both SizeGenerators should return the exact same set of values, since they
   // both start with random number generators in the same state.
-  shared_ptr<SizeGenerator> write_size_gen(new LogNormalSizeGenerator(20, 30));
-  shared_ptr<SizeGenerator> read_size_gen(new LogNormalSizeGenerator(20, 30));
+  boost::shared_ptr<SizeGenerator> write_size_gen(new LogNormalSizeGenerator(20, 30));
+  boost::shared_ptr<SizeGenerator> read_size_gen(new LogNormalSizeGenerator(20, 30));
   ADD_TEST_CASE(suite, name << "-lognormal-same-distribution",
                 test_read_write_mix, buf, buf_len,
                 write_size_gen, read_size_gen);
diff --git a/test/cpp/src/StressTest.cpp b/test/cpp/src/StressTest.cpp
index 339e7d1..a668fdf 100755
--- a/test/cpp/src/StressTest.cpp
+++ b/test/cpp/src/StressTest.cpp
@@ -109,7 +109,7 @@
 class ClientThread: public Runnable {
 public:
 
-  ClientThread(shared_ptr<TTransport>transport, shared_ptr<ServiceClient> client, Monitor& monitor, size_t& workerCount, size_t loopCount, TType loopType) :
+  ClientThread(boost::shared_ptr<TTransport>transport, boost::shared_ptr<ServiceClient> client, Monitor& monitor, size_t& workerCount, size_t loopCount, TType loopType) :
     _transport(transport),
     _client(client),
     _monitor(monitor),
@@ -200,8 +200,8 @@
     }
   }
 
-  shared_ptr<TTransport> _transport;
-  shared_ptr<ServiceClient> _client;
+  boost::shared_ptr<TTransport> _transport;
+  boost::shared_ptr<ServiceClient> _client;
   Monitor& _monitor;
   size_t& _workerCount;
   size_t _loopCount;
@@ -326,23 +326,23 @@
     cerr << usage;
   }
 
-  shared_ptr<PlatformThreadFactory> threadFactory = shared_ptr<PlatformThreadFactory>(new PlatformThreadFactory());
+  boost::shared_ptr<PlatformThreadFactory> threadFactory = boost::shared_ptr<PlatformThreadFactory>(new PlatformThreadFactory());
 
   // Dispatcher
-  shared_ptr<Server> serviceHandler(new Server());
+  boost::shared_ptr<Server> serviceHandler(new Server());
 
   if (replayRequests) {
-    shared_ptr<Server> serviceHandler(new Server());
-    shared_ptr<ServiceProcessor> serviceProcessor(new ServiceProcessor(serviceHandler));
+    boost::shared_ptr<Server> serviceHandler(new Server());
+    boost::shared_ptr<ServiceProcessor> serviceProcessor(new ServiceProcessor(serviceHandler));
 
     // Transports
-    shared_ptr<TFileTransport> fileTransport(new TFileTransport(requestLogPath));
+    boost::shared_ptr<TFileTransport> fileTransport(new TFileTransport(requestLogPath));
     fileTransport->setChunkSize(2 * 1024 * 1024);
     fileTransport->setMaxEventSize(1024 * 16);
     fileTransport->seekToEnd();
 
     // Protocol Factory
-    shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+    boost::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
 
     TFileProcessor fileProcessor(serviceProcessor,
                                  protocolFactory,
@@ -355,44 +355,44 @@
 
   if (runServer) {
 
-    shared_ptr<ServiceProcessor> serviceProcessor(new ServiceProcessor(serviceHandler));
+    boost::shared_ptr<ServiceProcessor> serviceProcessor(new ServiceProcessor(serviceHandler));
 
     // Transport
-    shared_ptr<TServerSocket> serverSocket(new TServerSocket(port));
+    boost::shared_ptr<TServerSocket> serverSocket(new TServerSocket(port));
 
     // Transport Factory
-    shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
+    boost::shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
 
     // Protocol Factory
-    shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+    boost::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
 
     if (logRequests) {
       // initialize the log file
-      shared_ptr<TFileTransport> fileTransport(new TFileTransport(requestLogPath));
+      boost::shared_ptr<TFileTransport> fileTransport(new TFileTransport(requestLogPath));
       fileTransport->setChunkSize(2 * 1024 * 1024);
       fileTransport->setMaxEventSize(1024 * 16);
 
       transportFactory =
-        shared_ptr<TTransportFactory>(new TPipedTransportFactory(fileTransport));
+        boost::shared_ptr<TTransportFactory>(new TPipedTransportFactory(fileTransport));
     }
 
-    shared_ptr<Thread> serverThread;
+    boost::shared_ptr<Thread> serverThread;
 
     if (serverType == "simple") {
 
-      serverThread = threadFactory->newThread(shared_ptr<TServer>(new TSimpleServer(serviceProcessor, serverSocket, transportFactory, protocolFactory)));
+      serverThread = threadFactory->newThread(boost::shared_ptr<TServer>(new TSimpleServer(serviceProcessor, serverSocket, transportFactory, protocolFactory)));
 
     } else if (serverType == "threaded") {
 
-      serverThread = threadFactory->newThread(shared_ptr<TServer>(new TThreadedServer(serviceProcessor, serverSocket, transportFactory, protocolFactory)));
+      serverThread = threadFactory->newThread(boost::shared_ptr<TServer>(new TThreadedServer(serviceProcessor, serverSocket, transportFactory, protocolFactory)));
 
     } else if (serverType == "thread-pool") {
 
-      shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(workerCount);
+      boost::shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(workerCount);
 
       threadManager->threadFactory(threadFactory);
       threadManager->start();
-      serverThread = threadFactory->newThread(shared_ptr<TServer>(new TThreadPoolServer(serviceProcessor, serverSocket, transportFactory, protocolFactory, threadManager)));
+      serverThread = threadFactory->newThread(boost::shared_ptr<TServer>(new TThreadPoolServer(serviceProcessor, serverSocket, transportFactory, protocolFactory, threadManager)));
     }
 
     cerr << "Starting the server on port " << port << endl;
@@ -412,7 +412,7 @@
 
     size_t threadCount = 0;
 
-    set<shared_ptr<Thread> > clientThreads;
+    set<boost::shared_ptr<Thread> > clientThreads;
 
     if (callName == "echoVoid") { loopType = T_VOID;}
     else if (callName == "echoByte") { loopType = T_BYTE;}
@@ -423,15 +423,15 @@
 
     for (size_t ix = 0; ix < clientCount; ix++) {
 
-      shared_ptr<TSocket> socket(new TSocket("127.0.0.1", port));
-      shared_ptr<TBufferedTransport> bufferedSocket(new TBufferedTransport(socket, 2048));
-      shared_ptr<TProtocol> protocol(new TBinaryProtocol(bufferedSocket));
-      shared_ptr<ServiceClient> serviceClient(new ServiceClient(protocol));
+      boost::shared_ptr<TSocket> socket(new TSocket("127.0.0.1", port));
+      boost::shared_ptr<TBufferedTransport> bufferedSocket(new TBufferedTransport(socket, 2048));
+      boost::shared_ptr<TProtocol> protocol(new TBinaryProtocol(bufferedSocket));
+      boost::shared_ptr<ServiceClient> serviceClient(new ServiceClient(protocol));
 
-      clientThreads.insert(threadFactory->newThread(shared_ptr<ClientThread>(new ClientThread(socket, serviceClient, monitor, threadCount, loopCount, loopType))));
+      clientThreads.insert(threadFactory->newThread(boost::shared_ptr<ClientThread>(new ClientThread(socket, serviceClient, monitor, threadCount, loopCount, loopType))));
     }
 
-    for (std::set<shared_ptr<Thread> >::const_iterator thread = clientThreads.begin(); thread != clientThreads.end(); thread++) {
+    for (std::set<boost::shared_ptr<Thread> >::const_iterator thread = clientThreads.begin(); thread != clientThreads.end(); thread++) {
       (*thread)->start();
     }
 
@@ -461,9 +461,9 @@
     int64_t minTime = 9223372036854775807LL;
     int64_t maxTime = 0;
 
-    for (set<shared_ptr<Thread> >::iterator ix = clientThreads.begin(); ix != clientThreads.end(); ix++) {
+    for (set<boost::shared_ptr<Thread> >::iterator ix = clientThreads.begin(); ix != clientThreads.end(); ix++) {
 
-      shared_ptr<ClientThread> client = dynamic_pointer_cast<ClientThread>((*ix)->runnable());
+      boost::shared_ptr<ClientThread> client = dynamic_pointer_cast<ClientThread>((*ix)->runnable());
 
       int64_t delta = client->_endTime - client->_startTime;
 
diff --git a/test/cpp/src/StressTestNonBlocking.cpp b/test/cpp/src/StressTestNonBlocking.cpp
index 2ff507b..4826a50 100755
--- a/test/cpp/src/StressTestNonBlocking.cpp
+++ b/test/cpp/src/StressTestNonBlocking.cpp
@@ -115,7 +115,7 @@
 class ClientThread: public Runnable {
 public:
 
-  ClientThread(shared_ptr<TTransport>transport, shared_ptr<ServiceClient> client, Monitor& monitor, size_t& workerCount, size_t loopCount, TType loopType) :
+  ClientThread(boost::shared_ptr<TTransport>transport, boost::shared_ptr<ServiceClient> client, Monitor& monitor, size_t& workerCount, size_t loopCount, TType loopType) :
     _transport(transport),
     _client(client),
     _monitor(monitor),
@@ -206,8 +206,8 @@
     }
   }
 
-  shared_ptr<TTransport> _transport;
-  shared_ptr<ServiceClient> _client;
+  boost::shared_ptr<TTransport> _transport;
+  boost::shared_ptr<ServiceClient> _client;
   Monitor& _monitor;
   size_t& _workerCount;
   size_t _loopCount;
@@ -321,23 +321,23 @@
     cerr << usage;
   }
 
-  shared_ptr<PlatformThreadFactory> threadFactory = shared_ptr<PlatformThreadFactory>(new PlatformThreadFactory());
+  boost::shared_ptr<PlatformThreadFactory> threadFactory = boost::shared_ptr<PlatformThreadFactory>(new PlatformThreadFactory());
 
   // Dispatcher
-  shared_ptr<Server> serviceHandler(new Server());
+  boost::shared_ptr<Server> serviceHandler(new Server());
 
   if (replayRequests) {
-    shared_ptr<Server> serviceHandler(new Server());
-    shared_ptr<ServiceProcessor> serviceProcessor(new ServiceProcessor(serviceHandler));
+    boost::shared_ptr<Server> serviceHandler(new Server());
+    boost::shared_ptr<ServiceProcessor> serviceProcessor(new ServiceProcessor(serviceHandler));
 
     // Transports
-    shared_ptr<TFileTransport> fileTransport(new TFileTransport(requestLogPath));
+    boost::shared_ptr<TFileTransport> fileTransport(new TFileTransport(requestLogPath));
     fileTransport->setChunkSize(2 * 1024 * 1024);
     fileTransport->setMaxEventSize(1024 * 16);
     fileTransport->seekToEnd();
 
     // Protocol Factory
-    shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+    boost::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
 
     TFileProcessor fileProcessor(serviceProcessor,
                                  protocolFactory,
@@ -350,40 +350,40 @@
 
   if (runServer) {
 
-    shared_ptr<ServiceProcessor> serviceProcessor(new ServiceProcessor(serviceHandler));
+    boost::shared_ptr<ServiceProcessor> serviceProcessor(new ServiceProcessor(serviceHandler));
 
     // Protocol Factory
-    shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+    boost::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
 
     // Transport Factory
-    shared_ptr<TTransportFactory>      transportFactory;
+    boost::shared_ptr<TTransportFactory>      transportFactory;
 
     if (logRequests) {
       // initialize the log file
-      shared_ptr<TFileTransport> fileTransport(new TFileTransport(requestLogPath));
+      boost::shared_ptr<TFileTransport> fileTransport(new TFileTransport(requestLogPath));
       fileTransport->setChunkSize(2 * 1024 * 1024);
       fileTransport->setMaxEventSize(1024 * 16);
 
       transportFactory =
-        shared_ptr<TTransportFactory>(new TPipedTransportFactory(fileTransport));
+        boost::shared_ptr<TTransportFactory>(new TPipedTransportFactory(fileTransport));
     }
 
-    shared_ptr<Thread> serverThread;
-    shared_ptr<Thread> serverThread2;
+    boost::shared_ptr<Thread> serverThread;
+    boost::shared_ptr<Thread> serverThread2;
 
     if (serverType == "simple") {
 
-      serverThread = threadFactory->newThread(shared_ptr<TServer>(new TNonblockingServer(serviceProcessor, protocolFactory, port)));
-      serverThread2 = threadFactory->newThread(shared_ptr<TServer>(new TNonblockingServer(serviceProcessor, protocolFactory, port+1)));
+      serverThread = threadFactory->newThread(boost::shared_ptr<TServer>(new TNonblockingServer(serviceProcessor, protocolFactory, port)));
+      serverThread2 = threadFactory->newThread(boost::shared_ptr<TServer>(new TNonblockingServer(serviceProcessor, protocolFactory, port+1)));
 
     } else if (serverType == "thread-pool") {
 
-      shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(workerCount);
+      boost::shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(workerCount);
 
       threadManager->threadFactory(threadFactory);
       threadManager->start();
-      serverThread = threadFactory->newThread(shared_ptr<TServer>(new TNonblockingServer(serviceProcessor, protocolFactory, port, threadManager)));
-      serverThread2 = threadFactory->newThread(shared_ptr<TServer>(new TNonblockingServer(serviceProcessor, protocolFactory, port+1, threadManager)));
+      serverThread = threadFactory->newThread(boost::shared_ptr<TServer>(new TNonblockingServer(serviceProcessor, protocolFactory, port, threadManager)));
+      serverThread2 = threadFactory->newThread(boost::shared_ptr<TServer>(new TNonblockingServer(serviceProcessor, protocolFactory, port+1, threadManager)));
     }
 
     cerr << "Starting the server on port " << port << " and " << (port + 1) << endl;
@@ -405,7 +405,7 @@
 
     size_t threadCount = 0;
 
-    set<shared_ptr<Thread> > clientThreads;
+    set<boost::shared_ptr<Thread> > clientThreads;
 
     if (callName == "echoVoid") { loopType = T_VOID;}
     else if (callName == "echoByte") { loopType = T_BYTE;}
@@ -416,15 +416,15 @@
 
     for (size_t ix = 0; ix < clientCount; ix++) {
 
-      shared_ptr<TSocket> socket(new TSocket("127.0.0.1", port + (ix % 2)));
-      shared_ptr<TFramedTransport> framedSocket(new TFramedTransport(socket));
-      shared_ptr<TProtocol> protocol(new TBinaryProtocol(framedSocket));
-      shared_ptr<ServiceClient> serviceClient(new ServiceClient(protocol));
+      boost::shared_ptr<TSocket> socket(new TSocket("127.0.0.1", port + (ix % 2)));
+      boost::shared_ptr<TFramedTransport> framedSocket(new TFramedTransport(socket));
+      boost::shared_ptr<TProtocol> protocol(new TBinaryProtocol(framedSocket));
+      boost::shared_ptr<ServiceClient> serviceClient(new ServiceClient(protocol));
 
-      clientThreads.insert(threadFactory->newThread(shared_ptr<ClientThread>(new ClientThread(socket, serviceClient, monitor, threadCount, loopCount, loopType))));
+      clientThreads.insert(threadFactory->newThread(boost::shared_ptr<ClientThread>(new ClientThread(socket, serviceClient, monitor, threadCount, loopCount, loopType))));
     }
 
-    for (std::set<shared_ptr<Thread> >::const_iterator thread = clientThreads.begin(); thread != clientThreads.end(); thread++) {
+    for (std::set<boost::shared_ptr<Thread> >::const_iterator thread = clientThreads.begin(); thread != clientThreads.end(); thread++) {
       (*thread)->start();
     }
 
@@ -454,9 +454,9 @@
     int64_t minTime = 9223372036854775807LL;
     int64_t maxTime = 0;
 
-    for (set<shared_ptr<Thread> >::iterator ix = clientThreads.begin(); ix != clientThreads.end(); ix++) {
+    for (set<boost::shared_ptr<Thread> >::iterator ix = clientThreads.begin(); ix != clientThreads.end(); ix++) {
 
-      shared_ptr<ClientThread> client = dynamic_pointer_cast<ClientThread>((*ix)->runnable());
+      boost::shared_ptr<ClientThread> client = dynamic_pointer_cast<ClientThread>((*ix)->runnable());
 
       int64_t delta = client->_endTime - client->_startTime;
 
diff --git a/test/cpp/src/TestClient.cpp b/test/cpp/src/TestClient.cpp
index ed560cb..e752f1c 100755
--- a/test/cpp/src/TestClient.cpp
+++ b/test/cpp/src/TestClient.cpp
@@ -82,7 +82,7 @@
 
     // next test
     delete client;
-    shared_ptr<TAsyncChannel> channel(new TEvhttpClientChannel(host, "/", host, port, base));
+    boost::shared_ptr<TAsyncChannel> channel(new TEvhttpClientChannel(host, "/", host, port, base));
     client = new ThriftTestCobClient(channel, protocolFactory);
     client->testString(tr1::bind(testString_clientReturn, host, port, base, protocolFactory, std::tr1::placeholders::_1), "Test");
   } catch (TException& exn) {
@@ -149,44 +149,44 @@
     ssl = true;
   }
 
-  shared_ptr<TTransport> transport;
-  shared_ptr<TProtocol> protocol;
+  boost::shared_ptr<TTransport> transport;
+  boost::shared_ptr<TProtocol> protocol;
 
-  shared_ptr<TSocket> socket;
-  shared_ptr<TSSLSocketFactory> factory;
+  boost::shared_ptr<TSocket> socket;
+  boost::shared_ptr<TSSLSocketFactory> factory;
 
   if (ssl) {
-    factory = shared_ptr<TSSLSocketFactory>(new TSSLSocketFactory());
+    factory = boost::shared_ptr<TSSLSocketFactory>(new TSSLSocketFactory());
     factory->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
     factory->loadTrustedCertificates("./trusted-ca-certificate.pem");
     factory->authenticate(true);
     socket = factory->createSocket(host, port);
   } else {
     if (domain_socket != "") {
-      socket = shared_ptr<TSocket>(new TSocket(domain_socket));
+      socket = boost::shared_ptr<TSocket>(new TSocket(domain_socket));
       port = 0;
     }
     else {
-      socket = shared_ptr<TSocket>(new TSocket(host, port));
+      socket = boost::shared_ptr<TSocket>(new TSocket(host, port));
     }
   }
 
   if (transport_type.compare("http") == 0) {
-    shared_ptr<TTransport> httpSocket(new THttpClient(socket, host, "/service"));
+    boost::shared_ptr<TTransport> httpSocket(new THttpClient(socket, host, "/service"));
     transport = httpSocket;
   } else if (transport_type.compare("framed") == 0){
-    shared_ptr<TFramedTransport> framedSocket(new TFramedTransport(socket));
+    boost::shared_ptr<TFramedTransport> framedSocket(new TFramedTransport(socket));
     transport = framedSocket;
   } else{
-    shared_ptr<TBufferedTransport> bufferedSocket(new TBufferedTransport(socket));
+    boost::shared_ptr<TBufferedTransport> bufferedSocket(new TBufferedTransport(socket));
     transport = bufferedSocket;
   }
 
   if (protocol_type.compare("json") == 0) {
-    shared_ptr<TProtocol> jsonProtocol(new TJSONProtocol(transport));
+    boost::shared_ptr<TProtocol> jsonProtocol(new TJSONProtocol(transport));
     protocol = jsonProtocol;
   } else{
-    shared_ptr<TBinaryProtocol> binaryProtocol(new TBinaryProtocol(transport));
+    boost::shared_ptr<TBinaryProtocol> binaryProtocol(new TBinaryProtocol(transport));
     protocol = binaryProtocol;
   }
 
@@ -205,9 +205,9 @@
     cout << "Libevent Features: 0x" << hex << event_base_get_features(base) << endl;
 #endif
 
-    shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+    boost::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
 
-    shared_ptr<TAsyncChannel> channel(new TEvhttpClientChannel(host.c_str(), "/", host.c_str(), port, base));
+    boost::shared_ptr<TAsyncChannel> channel(new TEvhttpClientChannel(host.c_str(), "/", host.c_str(), port, base));
     ThriftTestCobClient* client = new ThriftTestCobClient(channel, protocolFactory.get());
     client->testVoid(tr1::bind(testVoid_clientReturn, host.c_str(), port, base, protocolFactory.get(), std::tr1::placeholders::_1));
     
diff --git a/test/cpp/src/TestServer.cpp b/test/cpp/src/TestServer.cpp
index 456577f..b8cb880 100755
--- a/test/cpp/src/TestServer.cpp
+++ b/test/cpp/src/TestServer.cpp
@@ -360,7 +360,7 @@
 
 class TestHandlerAsync : public ThriftTestCobSvIf {
 public:
-  TestHandlerAsync(shared_ptr<TestHandler>& handler) : _delegate(handler) {}
+  TestHandlerAsync(boost::shared_ptr<TestHandler>& handler) : _delegate(handler) {}
   virtual ~TestHandlerAsync() {}
 
   virtual void testVoid(std::tr1::function<void()> cob) {
@@ -485,7 +485,7 @@
   }
 
 protected:
-  shared_ptr<TestHandler> _delegate;
+  boost::shared_ptr<TestHandler> _delegate;
 };
 
 
@@ -566,56 +566,56 @@
   }
 
   // Dispatcher
-  shared_ptr<TProtocolFactory> protocolFactory;
+  boost::shared_ptr<TProtocolFactory> protocolFactory;
   if (protocol_type == "json") {
-    shared_ptr<TProtocolFactory> jsonProtocolFactory(new TJSONProtocolFactory());
+    boost::shared_ptr<TProtocolFactory> jsonProtocolFactory(new TJSONProtocolFactory());
     protocolFactory = jsonProtocolFactory;
   } else {
-    shared_ptr<TProtocolFactory> binaryProtocolFactory(new TBinaryProtocolFactoryT<TBufferBase>());
+    boost::shared_ptr<TProtocolFactory> binaryProtocolFactory(new TBinaryProtocolFactoryT<TBufferBase>());
     protocolFactory = binaryProtocolFactory;
   }
 
   // Processor
-  shared_ptr<TestHandler> testHandler(new TestHandler());
-  shared_ptr<ThriftTestProcessor> testProcessor(new ThriftTestProcessor(testHandler));
+  boost::shared_ptr<TestHandler> testHandler(new TestHandler());
+  boost::shared_ptr<ThriftTestProcessor> testProcessor(new ThriftTestProcessor(testHandler));
   
   if (vm.count("processor-events")) {
-    testProcessor->setEventHandler(shared_ptr<TProcessorEventHandler>(
+    testProcessor->setEventHandler(boost::shared_ptr<TProcessorEventHandler>(
           new TestProcessorEventHandler()));
   }
   
   // Transport
-  shared_ptr<TSSLSocketFactory> sslSocketFactory;
-  shared_ptr<TServerSocket> serverSocket;
+  boost::shared_ptr<TSSLSocketFactory> sslSocketFactory;
+  boost::shared_ptr<TServerSocket> serverSocket;
 
   if (ssl) {
-    sslSocketFactory = shared_ptr<TSSLSocketFactory>(new TSSLSocketFactory());
+    sslSocketFactory = boost::shared_ptr<TSSLSocketFactory>(new TSSLSocketFactory());
     sslSocketFactory->loadCertificate("./server-certificate.pem");
     sslSocketFactory->loadPrivateKey("./server-private-key.pem");
     sslSocketFactory->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
-    serverSocket = shared_ptr<TServerSocket>(new TSSLServerSocket(port, sslSocketFactory));
+    serverSocket = boost::shared_ptr<TServerSocket>(new TSSLServerSocket(port, sslSocketFactory));
   } else {
 	if (domain_socket != "") {
 	  unlink(domain_socket.c_str());
-	  serverSocket = shared_ptr<TServerSocket>(new TServerSocket(domain_socket));
+	  serverSocket = boost::shared_ptr<TServerSocket>(new TServerSocket(domain_socket));
 	  port = 0;
 	}
 	else {
-      serverSocket = shared_ptr<TServerSocket>(new TServerSocket(port));
+      serverSocket = boost::shared_ptr<TServerSocket>(new TServerSocket(port));
 	}
   }
 
   // Factory
-  shared_ptr<TTransportFactory> transportFactory;
+  boost::shared_ptr<TTransportFactory> transportFactory;
   
   if (transport_type == "http" && server_type != "nonblocking") {
-    shared_ptr<TTransportFactory> httpTransportFactory(new THttpServerTransportFactory()); 
+    boost::shared_ptr<TTransportFactory> httpTransportFactory(new THttpServerTransportFactory()); 
     transportFactory = httpTransportFactory;
   } else if (transport_type == "framed") {
-    shared_ptr<TTransportFactory> framedTransportFactory(new TFramedTransportFactory()); 
+    boost::shared_ptr<TTransportFactory> framedTransportFactory(new TFramedTransportFactory()); 
     transportFactory = framedTransportFactory;
   } else {
-    shared_ptr<TTransportFactory> bufferedTransportFactory(new TBufferedTransportFactory()); 
+    boost::shared_ptr<TTransportFactory> bufferedTransportFactory(new TBufferedTransportFactory()); 
     transportFactory = bufferedTransportFactory;
   }
 
@@ -638,11 +638,11 @@
 
   } else if (server_type == "thread-pool") {
 
-    shared_ptr<ThreadManager> threadManager =
+    boost::shared_ptr<ThreadManager> threadManager =
       ThreadManager::newSimpleThreadManager(workers);
 
-    shared_ptr<PlatformThreadFactory> threadFactory =
-      shared_ptr<PlatformThreadFactory>(new PlatformThreadFactory());
+    boost::shared_ptr<PlatformThreadFactory> threadFactory =
+      boost::shared_ptr<PlatformThreadFactory>(new PlatformThreadFactory());
 
     threadManager->threadFactory(threadFactory);
 
@@ -667,9 +667,9 @@
 
   } else if (server_type == "nonblocking") {
     if(transport_type == "http") {
-      shared_ptr<TestHandlerAsync> testHandlerAsync(new TestHandlerAsync(testHandler));
-      shared_ptr<TAsyncProcessor> testProcessorAsync(new ThriftTestAsyncProcessor(testHandlerAsync));
-      shared_ptr<TAsyncBufferProcessor> testBufferProcessor(new TAsyncProtocolProcessor(testProcessorAsync, protocolFactory));
+      boost::shared_ptr<TestHandlerAsync> testHandlerAsync(new TestHandlerAsync(testHandler));
+      boost::shared_ptr<TAsyncProcessor> testProcessorAsync(new ThriftTestAsyncProcessor(testHandlerAsync));
+      boost::shared_ptr<TAsyncBufferProcessor> testBufferProcessor(new TAsyncProtocolProcessor(testProcessorAsync, protocolFactory));
       
       TEvhttpServer nonblockingServer(testBufferProcessor, port);
       nonblockingServer.serve();