THRIFT-2221: detect C++11 and use std namespace for memory operations (smart_ptr)
Client: C++
This closes #1328
diff --git a/lib/cpp/test/AllProtocolTests.tcc b/lib/cpp/test/AllProtocolTests.tcc
index 3e0b833..b6df656 100644
--- a/lib/cpp/test/AllProtocolTests.tcc
+++ b/lib/cpp/test/AllProtocolTests.tcc
@@ -28,7 +28,7 @@
#include "GenericHelpers.h"
-using boost::shared_ptr;
+using apache::thrift::stdcxx::shared_ptr;
using namespace apache::thrift;
using namespace apache::thrift::protocol;
using namespace apache::thrift::transport;
diff --git a/lib/cpp/test/Benchmark.cpp b/lib/cpp/test/Benchmark.cpp
index 69e6414..afde7d4 100644
--- a/lib/cpp/test/Benchmark.cpp
+++ b/lib/cpp/test/Benchmark.cpp
@@ -23,8 +23,9 @@
#include <iostream>
#define _USE_MATH_DEFINES
#include <math.h>
-#include "thrift/transport/TBufferTransports.h"
#include "thrift/protocol/TBinaryProtocol.h"
+#include "thrift/stdcxx.h"
+#include "thrift/transport/TBufferTransports.h"
#include "gen-cpp/DebugProtoTest_types.h"
#ifdef HAVE_SYS_TIME_H
@@ -48,11 +49,11 @@
};
int main() {
- using namespace std;
using namespace thrift::test::debug;
using namespace apache::thrift::transport;
using namespace apache::thrift::protocol;
- using namespace boost;
+ using std::cout;
+ using std::endl;
OneOfEach ooe;
ooe.im_true = true;
@@ -67,7 +68,7 @@
ooe.base64 = "\1\2\3\255";
int num = 100000;
- boost::shared_ptr<TMemoryBuffer> buf(new TMemoryBuffer(num*1000));
+ apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buf(new TMemoryBuffer(num*1000));
uint8_t* data = NULL;
uint32_t datasize = 0;
@@ -88,7 +89,7 @@
buf->getBuffer(&data, &datasize);
{
- boost::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
+ apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
TBinaryProtocolT<TMemoryBuffer> prot(buf2);
OneOfEach ooe2;
double elapsed = 0.0;
@@ -116,7 +117,7 @@
{
OneOfEach ooe2;
- boost::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
+ apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
TBinaryProtocolT<TMemoryBuffer, TNetworkLittleEndian> prot(buf2);
double elapsed = 0.0;
Timer timer;
@@ -142,7 +143,7 @@
}
{
- boost::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
+ apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
TBinaryProtocolT<TMemoryBuffer> prot(buf2);
OneOfEach ooe2;
double elapsed = 0.0;
@@ -181,7 +182,7 @@
buf->getBuffer(&data, &datasize);
{
- boost::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
+ apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
TBinaryProtocolT<TMemoryBuffer> prot(buf2);
ListDoublePerf listDoublePerf2;
double elapsed = 0.0;
@@ -205,7 +206,7 @@
{
ListDoublePerf listDoublePerf2;
- boost::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
+ apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
TBinaryProtocolT<TMemoryBuffer, TNetworkLittleEndian> prot(buf2);
double elapsed = 0.0;
Timer timer;
@@ -227,7 +228,7 @@
}
{
- boost::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
+ apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
TBinaryProtocolT<TMemoryBuffer> prot(buf2);
ListDoublePerf listDoublePerf2;
double elapsed = 0.0;
diff --git a/lib/cpp/test/CMakeLists.txt b/lib/cpp/test/CMakeLists.txt
index 6d4aa5e..1a6062d 100644
--- a/lib/cpp/test/CMakeLists.txt
+++ b/lib/cpp/test/CMakeLists.txt
@@ -1,4 +1,4 @@
-#
+#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
@@ -298,7 +298,21 @@
LINK_AGAINST_THRIFT_LIBRARY(TNonblockingServerTest thrift)
LINK_AGAINST_THRIFT_LIBRARY(TNonblockingServerTest thriftnb)
add_test(NAME TNonblockingServerTest COMMAND TNonblockingServerTest)
-endif()
+
+if(OPENSSL_FOUND AND WITH_OPENSSL)
+ set(TNonblockingSSLServerTest_SOURCES TNonblockingSSLServerTest.cpp)
+ add_executable(TNonblockingSSLServerTest ${TNonblockingSSLServerTest_SOURCES})
+ include_directories(${LIBEVENT_INCLUDE_DIRS})
+ target_link_libraries(TNonblockingSSLServerTest
+ testgencpp_cob
+ ${LIBEVENT_LIBRARIES}
+ ${Boost_LIBRARIES}
+ )
+ LINK_AGAINST_THRIFT_LIBRARY(TNonblockingSSLServerTest thrift)
+ LINK_AGAINST_THRIFT_LIBRARY(TNonblockingSSLServerTest thriftnb)
+ add_test(NAME TNonblockingSSLServerTest COMMAND TNonblockingSSLServerTest -- "${CMAKE_CURRENT_SOURCE_DIR}/../../../test/keys")
+endif(OPENSSL_FOUND AND WITH_OPENSSL)
+endif(WITH_LIBEVENT)
if(OPENSSL_FOUND AND WITH_OPENSSL)
add_executable(OpenSSLManualInitTest OpenSSLManualInitTest.cpp)
diff --git a/lib/cpp/test/DebugProtoTest.cpp b/lib/cpp/test/DebugProtoTest.cpp
index c070af2..e04600a 100644
--- a/lib/cpp/test/DebugProtoTest.cpp
+++ b/lib/cpp/test/DebugProtoTest.cpp
@@ -21,14 +21,14 @@
#include <cmath>
#include "gen-cpp/DebugProtoTest_types.h"
#include <thrift/protocol/TDebugProtocol.h>
-#include <boost/scoped_ptr.hpp>
+#include <thrift/stdcxx.h>
#define BOOST_TEST_MODULE DebugProtoTest
#include <boost/test/unit_test.hpp>
using namespace thrift::test::debug;
-static boost::scoped_ptr<OneOfEach> ooe;
+static ::apache::thrift::stdcxx::shared_ptr<OneOfEach> ooe;
void testCaseSetup_1() {
ooe.reset(new OneOfEach);
@@ -81,7 +81,7 @@
"Expected:\n" << expected_result << "\nGotten:\n" << result);
}
-static boost::scoped_ptr<Nesting> n;
+static ::apache::thrift::stdcxx::shared_ptr<Nesting> n;
void testCaseSetup_2() {
testCaseSetup_1();
@@ -149,7 +149,7 @@
"Expected:\n" << expected_result << "\nGotten:\n" << result);
}
-static boost::scoped_ptr<HolyMoley> hm;
+static ::apache::thrift::stdcxx::shared_ptr<HolyMoley> hm;
void testCaseSetup_3() {
testCaseSetup_2();
diff --git a/lib/cpp/test/GenericHelpers.h b/lib/cpp/test/GenericHelpers.h
index c175561..e131c42 100644
--- a/lib/cpp/test/GenericHelpers.h
+++ b/lib/cpp/test/GenericHelpers.h
@@ -20,13 +20,10 @@
#ifndef _THRIFT_TEST_GENERICHELPERS_H_
#define _THRIFT_TEST_GENERICHELPERS_H_ 1
-#include <thrift/protocol/TBinaryProtocol.h>
-#include <thrift/transport/TBufferTransports.h>
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/stdcxx.h>
#include <thrift/Thrift.h>
-using boost::shared_ptr;
-using namespace apache::thrift::protocol;
-
/* ClassName Helper for cleaner exceptions */
class ClassNames {
public:
@@ -66,43 +63,43 @@
public:
/* Write functions */
- static uint32_t write(shared_ptr<TProtocol> proto, const int8_t& val) {
+ static uint32_t write(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, const int8_t& val) {
return proto->writeByte(val);
}
- static uint32_t write(shared_ptr<TProtocol> proto, const int16_t& val) {
+ static uint32_t write(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, const int16_t& val) {
return proto->writeI16(val);
}
- static uint32_t write(shared_ptr<TProtocol> proto, const int32_t& val) {
+ static uint32_t write(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, const int32_t& val) {
return proto->writeI32(val);
}
- static uint32_t write(shared_ptr<TProtocol> proto, const double& val) {
+ static uint32_t write(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, const double& val) {
return proto->writeDouble(val);
}
- static uint32_t write(shared_ptr<TProtocol> proto, const int64_t& val) {
+ static uint32_t write(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, const int64_t& val) {
return proto->writeI64(val);
}
- static uint32_t write(shared_ptr<TProtocol> proto, const std::string& val) {
+ static uint32_t write(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, const std::string& val) {
return proto->writeString(val);
}
/* Read functions */
- static uint32_t read(shared_ptr<TProtocol> proto, int8_t& val) { return proto->readByte(val); }
+ static uint32_t read(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, int8_t& val) { return proto->readByte(val); }
- static uint32_t read(shared_ptr<TProtocol> proto, int16_t& val) { return proto->readI16(val); }
+ static uint32_t read(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, int16_t& val) { return proto->readI16(val); }
- static uint32_t read(shared_ptr<TProtocol> proto, int32_t& val) { return proto->readI32(val); }
+ static uint32_t read(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, int32_t& val) { return proto->readI32(val); }
- static uint32_t read(shared_ptr<TProtocol> proto, int64_t& val) { return proto->readI64(val); }
+ static uint32_t read(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, int64_t& val) { return proto->readI64(val); }
- static uint32_t read(shared_ptr<TProtocol> proto, double& val) { return proto->readDouble(val); }
+ static uint32_t read(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, double& val) { return proto->readDouble(val); }
- static uint32_t read(shared_ptr<TProtocol> proto, std::string& val) {
+ static uint32_t read(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, std::string& val) {
return proto->readString(val);
}
};
diff --git a/lib/cpp/test/JSONProtoTest.cpp b/lib/cpp/test/JSONProtoTest.cpp
index 2ac7adc..77bc250 100644
--- a/lib/cpp/test/JSONProtoTest.cpp
+++ b/lib/cpp/test/JSONProtoTest.cpp
@@ -21,19 +21,20 @@
#include <cmath>
#include <iomanip>
#include <sstream>
-#include <thrift/transport/TBufferTransports.h>
#include <thrift/protocol/TJSONProtocol.h>
-#include <boost/scoped_ptr.hpp>
+#include <thrift/stdcxx.h>
+#include <thrift/transport/TBufferTransports.h>
#include "gen-cpp/DebugProtoTest_types.h"
#define BOOST_TEST_MODULE JSONProtoTest
#include <boost/test/unit_test.hpp>
using namespace thrift::test::debug;
+using namespace apache::thrift;
using apache::thrift::transport::TMemoryBuffer;
using apache::thrift::protocol::TJSONProtocol;
-static boost::scoped_ptr<OneOfEach> ooe;
+static stdcxx::shared_ptr<OneOfEach> ooe;
void testCaseSetup_1() {
ooe.reset(new OneOfEach);
@@ -66,7 +67,7 @@
"Expected:\n" << expected_result << "\nGotten:\n" << result);
}
-static boost::scoped_ptr<Nesting> n;
+static stdcxx::shared_ptr<Nesting> n;
void testCaseSetup_2() {
testCaseSetup_1();
@@ -106,7 +107,7 @@
"Expected:\n" << expected_result << "\nGotten:\n" << result);
}
-static boost::scoped_ptr<HolyMoley> hm;
+static stdcxx::shared_ptr<HolyMoley> hm;
void testCaseSetup_3() {
testCaseSetup_2();
@@ -184,8 +185,8 @@
BOOST_AUTO_TEST_CASE(test_json_proto_4) {
testCaseSetup_1();
- boost::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
- boost::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
+ stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
+ stdcxx::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
ooe->write(proto.get());
OneOfEach ooe2;
@@ -197,8 +198,8 @@
BOOST_AUTO_TEST_CASE(test_json_proto_5) {
testCaseSetup_3();
- boost::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
- boost::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
+ stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
+ stdcxx::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
hm->write(proto.get());
HolyMoley hm2;
@@ -235,8 +236,8 @@
}
BOOST_AUTO_TEST_CASE(test_json_proto_7) {
- boost::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
- boost::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
+ stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
+ stdcxx::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
Base64 base;
base.a = 123;
@@ -264,9 +265,9 @@
"\",3,1,2,3]}}";
const std::size_t bufSiz = strlen(json_string) * sizeof(char);
- boost::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
+ stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
(uint8_t*)(json_string), static_cast<uint32_t>(bufSiz)));
- boost::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
+ stdcxx::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
OneOfEach ooe2;
@@ -293,9 +294,9 @@
"\",3,1,2,3]}}";
const char* expected_zomg_unicode = "\xe0\xb8\x81 \xf0\x9d\x94\xbe";
- boost::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
+ stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
(uint8_t*)(json_string), sizeof(json_string)));
- boost::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
+ stdcxx::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
OneOfEach ooe2;
ooe2.read(proto.get());
@@ -314,9 +315,9 @@
":[\"i8\",3,1,2,3]},\"13\":{\"lst\":[\"i16\",3,1,2,3]},\"14\":{\"lst\":[\"i64"
"\",3,1,2,3]}}";
- boost::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
+ stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
(uint8_t*)(json_string), sizeof(json_string)));
- boost::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
+ stdcxx::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
OneOfEach ooe2;
BOOST_CHECK_THROW(ooe2.read(proto.get()),
@@ -332,9 +333,9 @@
":[\"i8\",3,1,2,3]},\"13\":{\"lst\":[\"i16\",3,1,2,3]},\"14\":{\"lst\":[\"i64"
"\",3,1,2,3]}}";
- boost::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
+ stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
(uint8_t*)(json_string), sizeof(json_string)));
- boost::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
+ stdcxx::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
OneOfEach ooe2;
BOOST_CHECK_THROW(ooe2.read(proto.get()),
diff --git a/lib/cpp/test/OpenSSLManualInitTest.cpp b/lib/cpp/test/OpenSSLManualInitTest.cpp
index 5cd5e48..a30b303 100644
--- a/lib/cpp/test/OpenSSLManualInitTest.cpp
+++ b/lib/cpp/test/OpenSSLManualInitTest.cpp
@@ -28,7 +28,6 @@
#include <openssl/evp.h>
#include <thrift/transport/TSSLSocket.h>
-using namespace std;
using namespace apache::thrift::transport;
void make_isolated_sslsocketfactory() {
diff --git a/lib/cpp/test/OptionalRequiredTest.cpp b/lib/cpp/test/OptionalRequiredTest.cpp
index b0e5ef7..55fe249 100644
--- a/lib/cpp/test/OptionalRequiredTest.cpp
+++ b/lib/cpp/test/OptionalRequiredTest.cpp
@@ -40,7 +40,7 @@
void trywrite(const Struct& s, bool should_work) {
bool worked;
try {
- TBinaryProtocol protocol(boost::shared_ptr<TTransport>(new TMemoryBuffer));
+ TBinaryProtocol protocol(stdcxx::shared_ptr<TTransport>(new TMemoryBuffer));
s.write(&protocol);
worked = true;
} catch (TProtocolException & ex) {
@@ -52,7 +52,7 @@
template <typename Struct1, typename Struct2>
void write_to_read(const Struct1& w, Struct2& r) {
- TBinaryProtocol protocol(boost::shared_ptr<TTransport>(new TMemoryBuffer));
+ TBinaryProtocol protocol(stdcxx::shared_ptr<TTransport>(new TMemoryBuffer));
w.write(&protocol);
r.read(&protocol);
}
@@ -303,7 +303,7 @@
o1.im_big.push_back(mymap);
BOOST_CHECK(o1 == o2);
- TBinaryProtocol protocol(boost::shared_ptr<TTransport>(new TMemoryBuffer));
+ TBinaryProtocol protocol(stdcxx::shared_ptr<TTransport>(new TMemoryBuffer));
o1.write(&protocol);
o1.im_big.push_back(mymap);
diff --git a/lib/cpp/test/RecursiveTest.cpp b/lib/cpp/test/RecursiveTest.cpp
index e3e3f50..ce5569b 100644
--- a/lib/cpp/test/RecursiveTest.cpp
+++ b/lib/cpp/test/RecursiveTest.cpp
@@ -22,20 +22,21 @@
*/
#include "gen-cpp/Recursive_types.h"
-#include <thrift/transport/TBufferTransports.h>
#include <thrift/protocol/TBinaryProtocol.h>
+#include <thrift/stdcxx.h>
+#include <thrift/transport/TBufferTransports.h>
#define BOOST_TEST_MODULE RecursiveTest
#include <boost/test/unit_test.hpp>
using apache::thrift::transport::TMemoryBuffer;
using apache::thrift::protocol::TBinaryProtocol;
-using boost::shared_ptr;
+using apache::thrift::stdcxx::shared_ptr;
BOOST_AUTO_TEST_CASE(test_recursive_1) {
shared_ptr<TMemoryBuffer> buf(new TMemoryBuffer());
shared_ptr<TBinaryProtocol> prot(new TBinaryProtocol(buf));
-
+
RecTree tree;
RecTree child;
tree.children.push_back(child);
@@ -50,9 +51,9 @@
BOOST_AUTO_TEST_CASE(test_recursive_2) {
shared_ptr<TMemoryBuffer> buf(new TMemoryBuffer());
shared_ptr<TBinaryProtocol> prot(new TBinaryProtocol(buf));
-
+
RecList l;
- boost::shared_ptr<RecList> l2(new RecList);
+ shared_ptr<RecList> l2(new RecList);
l.nextitem = l2;
l.write(prot.get());
@@ -68,7 +69,7 @@
shared_ptr<TBinaryProtocol> prot(new TBinaryProtocol(buf));
CoRec c;
- boost::shared_ptr<CoRec2> r(new CoRec2);
+ shared_ptr<CoRec2> r(new CoRec2);
c.other = r;
c.write(prot.get());
@@ -82,7 +83,7 @@
shared_ptr<TMemoryBuffer> buf(new TMemoryBuffer());
shared_ptr<TBinaryProtocol> prot(new TBinaryProtocol(buf));
- boost::shared_ptr<RecList> depthLimit(new RecList);
+ shared_ptr<RecList> depthLimit(new RecList);
depthLimit->nextitem = depthLimit;
BOOST_CHECK_THROW(depthLimit->write(prot.get()),
apache::thrift::protocol::TProtocolException);
diff --git a/lib/cpp/test/SecurityTest.cpp b/lib/cpp/test/SecurityTest.cpp
index 23650d6..6eb1fe3 100644
--- a/lib/cpp/test/SecurityTest.cpp
+++ b/lib/cpp/test/SecurityTest.cpp
@@ -19,13 +19,11 @@
#define BOOST_TEST_MODULE SecurityTest
#include <boost/test/unit_test.hpp>
-#include <boost/bind.hpp>
#include <boost/filesystem.hpp>
#include <boost/foreach.hpp>
#include <boost/format.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/shared_ptr.hpp>
#include <boost/thread.hpp>
+#include <thrift/stdcxx.h>
#include <thrift/transport/TSSLServerSocket.h>
#include <thrift/transport/TSSLSocket.h>
#include <thrift/transport/TTransport.h>
@@ -42,6 +40,9 @@
using apache::thrift::transport::TTransportException;
using apache::thrift::transport::TTransportFactory;
+using apache::thrift::stdcxx::bind;
+using apache::thrift::stdcxx::shared_ptr;
+
boost::filesystem::path keyDir;
boost::filesystem::path certFile(const std::string& filename)
{
@@ -54,36 +55,36 @@
GlobalFixture()
{
using namespace boost::unit_test::framework;
- for (int i = 0; i < master_test_suite().argc; ++i)
- {
- BOOST_TEST_MESSAGE(boost::format("argv[%1%] = \"%2%\"") % i % master_test_suite().argv[i]);
- }
+ for (int i = 0; i < master_test_suite().argc; ++i)
+ {
+ BOOST_TEST_MESSAGE(boost::format("argv[%1%] = \"%2%\"") % i % master_test_suite().argv[i]);
+ }
#ifdef __linux__
- // OpenSSL calls send() without MSG_NOSIGPIPE so writing to a socket that has
- // disconnected can cause a SIGPIPE signal...
- signal(SIGPIPE, SIG_IGN);
+ // OpenSSL calls send() without MSG_NOSIGPIPE so writing to a socket that has
+ // disconnected can cause a SIGPIPE signal...
+ signal(SIGPIPE, SIG_IGN);
#endif
- TSSLSocketFactory::setManualOpenSSLInitialization(true);
- apache::thrift::transport::initializeOpenSSL();
+ TSSLSocketFactory::setManualOpenSSLInitialization(true);
+ apache::thrift::transport::initializeOpenSSL();
- keyDir = boost::filesystem::current_path().parent_path().parent_path().parent_path() / "test" / "keys";
- if (!boost::filesystem::exists(certFile("server.crt")))
- {
- keyDir = boost::filesystem::path(master_test_suite().argv[master_test_suite().argc - 1]);
- if (!boost::filesystem::exists(certFile("server.crt")))
- {
- throw std::invalid_argument("The last argument to this test must be the directory containing the test certificate(s).");
- }
- }
+ keyDir = boost::filesystem::current_path().parent_path().parent_path().parent_path() / "test" / "keys";
+ if (!boost::filesystem::exists(certFile("server.crt")))
+ {
+ keyDir = boost::filesystem::path(master_test_suite().argv[master_test_suite().argc - 1]);
+ if (!boost::filesystem::exists(certFile("server.crt")))
+ {
+ throw std::invalid_argument("The last argument to this test must be the directory containing the test certificate(s).");
+ }
+ }
}
virtual ~GlobalFixture()
{
- apache::thrift::transport::cleanupOpenSSL();
+ apache::thrift::transport::cleanupOpenSSL();
#ifdef __linux__
- signal(SIGPIPE, SIG_DFL);
+ signal(SIGPIPE, SIG_DFL);
#endif
}
};
@@ -102,8 +103,8 @@
{
boost::mutex::scoped_lock lock(mMutex);
- boost::shared_ptr<TSSLSocketFactory> pServerSocketFactory;
- boost::shared_ptr<TSSLServerSocket> pServerSocket;
+ shared_ptr<TSSLSocketFactory> pServerSocketFactory;
+ shared_ptr<TSSLServerSocket> pServerSocket;
pServerSocketFactory.reset(new TSSLSocketFactory(static_cast<apache::thrift::transport::SSLProtocol>(protocol)));
pServerSocketFactory->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
@@ -111,7 +112,7 @@
pServerSocketFactory->loadPrivateKey(certFile("server.key").string().c_str());
pServerSocketFactory->server(true);
pServerSocket.reset(new TSSLServerSocket("localhost", 0, pServerSocketFactory));
- boost::shared_ptr<TTransport> connectedClient;
+ shared_ptr<TTransport> connectedClient;
try
{
@@ -153,8 +154,8 @@
{
try
{
- boost::shared_ptr<TSSLSocketFactory> pClientSocketFactory;
- boost::shared_ptr<TSSLSocket> pClientSocket;
+ shared_ptr<TSSLSocketFactory> pClientSocketFactory;
+ shared_ptr<TSSLSocket> pClientSocket;
try
{
@@ -255,10 +256,10 @@
mConnected = false;
boost::thread_group threads;
- threads.create_thread(boost::bind(&SecurityFixture::server, this, static_cast<apache::thrift::transport::SSLProtocol>(si)));
+ threads.create_thread(bind(&SecurityFixture::server, this, static_cast<apache::thrift::transport::SSLProtocol>(si)));
mCVar.wait(lock); // wait for listen() to succeed
lock.unlock();
- threads.create_thread(boost::bind(&SecurityFixture::client, this, static_cast<apache::thrift::transport::SSLProtocol>(ci)));
+ threads.create_thread(bind(&SecurityFixture::client, this, static_cast<apache::thrift::transport::SSLProtocol>(ci)));
threads.join_all();
BOOST_CHECK_MESSAGE(mConnected == matrix[ci][si],
diff --git a/lib/cpp/test/SpecializationTest.cpp b/lib/cpp/test/SpecializationTest.cpp
index e851bac..a060b4f 100644
--- a/lib/cpp/test/SpecializationTest.cpp
+++ b/lib/cpp/test/SpecializationTest.cpp
@@ -82,8 +82,8 @@
stage2.back().message = "nevermore";
hm.bonks["poe"] = stage2;
- boost::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
- boost::shared_ptr<TProtocol> proto(new MyProtocol(buffer));
+ apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
+ apache::thrift::stdcxx::shared_ptr<TProtocol> proto(new MyProtocol(buffer));
ooe.write(proto.get());
OneOfEach ooe2;
diff --git a/lib/cpp/test/TBufferBaseTest.cpp b/lib/cpp/test/TBufferBaseTest.cpp
index 5d0bf45..4e3509e 100644
--- a/lib/cpp/test/TBufferBaseTest.cpp
+++ b/lib/cpp/test/TBufferBaseTest.cpp
@@ -21,13 +21,14 @@
#include <boost/test/auto_unit_test.hpp>
#include <thrift/transport/TBufferTransports.h>
#include <thrift/transport/TShortReadTransport.h>
+#include <thrift/stdcxx.h>
-using std::string;
-using boost::shared_ptr;
+using apache::thrift::stdcxx::shared_ptr;
using apache::thrift::transport::TMemoryBuffer;
using apache::thrift::transport::TBufferedTransport;
using apache::thrift::transport::TFramedTransport;
using apache::thrift::transport::test::TShortReadTransport;
+using std::string;
// Shamelessly copied from ZlibTransport. TODO: refactor.
unsigned int dist[][5000] = {
diff --git a/lib/cpp/test/TMemoryBufferTest.cpp b/lib/cpp/test/TMemoryBufferTest.cpp
index 84103e3..1586609 100644
--- a/lib/cpp/test/TMemoryBufferTest.cpp
+++ b/lib/cpp/test/TMemoryBufferTest.cpp
@@ -21,8 +21,9 @@
#include <iostream>
#include <climits>
#include <vector>
-#include <thrift/transport/TBufferTransports.h>
#include <thrift/protocol/TBinaryProtocol.h>
+#include <thrift/stdcxx.h>
+#include <thrift/transport/TBufferTransports.h>
#include "gen-cpp/ThriftTest_types.h"
BOOST_AUTO_TEST_SUITE(TMemoryBufferTest)
@@ -30,7 +31,7 @@
using apache::thrift::protocol::TBinaryProtocol;
using apache::thrift::transport::TMemoryBuffer;
using apache::thrift::transport::TTransportException;
-using boost::shared_ptr;
+using apache::thrift::stdcxx::shared_ptr;
using std::cout;
using std::endl;
using std::string;
diff --git a/lib/cpp/test/TNonblockingSSLServerTest.cpp b/lib/cpp/test/TNonblockingSSLServerTest.cpp
index f21dd18..3e9700f 100644
--- a/lib/cpp/test/TNonblockingSSLServerTest.cpp
+++ b/lib/cpp/test/TNonblockingSSLServerTest.cpp
@@ -105,8 +105,8 @@
BOOST_GLOBAL_FIXTURE(GlobalFixtureSSL)
#endif
-boost::shared_ptr<TSSLSocketFactory> createServerSocketFactory() {
- boost::shared_ptr<TSSLSocketFactory> pServerSocketFactory;
+stdcxx::shared_ptr<TSSLSocketFactory> createServerSocketFactory() {
+ stdcxx::shared_ptr<TSSLSocketFactory> pServerSocketFactory;
pServerSocketFactory.reset(new TSSLSocketFactory());
pServerSocketFactory->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
@@ -116,8 +116,8 @@
return pServerSocketFactory;
}
-boost::shared_ptr<TSSLSocketFactory> createClientSocketFactory() {
- boost::shared_ptr<TSSLSocketFactory> pClientSocketFactory;
+stdcxx::shared_ptr<TSSLSocketFactory> createClientSocketFactory() {
+ stdcxx::shared_ptr<TSSLSocketFactory> pClientSocketFactory;
pClientSocketFactory.reset(new TSSLSocketFactory());
pClientSocketFactory->authenticate(true);
@@ -145,12 +145,12 @@
struct Runner : public apache::thrift::concurrency::Runnable {
int port;
- boost::shared_ptr<event_base> userEventBase;
- boost::shared_ptr<TProcessor> processor;
- boost::shared_ptr<server::TNonblockingServer> server;
- boost::shared_ptr<ListenEventHandler> listenHandler;
- boost::shared_ptr<TSSLSocketFactory> pServerSocketFactory;
- boost::shared_ptr<transport::TNonblockingSSLServerSocket> socket;
+ stdcxx::shared_ptr<event_base> userEventBase;
+ stdcxx::shared_ptr<TProcessor> processor;
+ stdcxx::shared_ptr<server::TNonblockingServer> server;
+ stdcxx::shared_ptr<ListenEventHandler> listenHandler;
+ stdcxx::shared_ptr<TSSLSocketFactory> pServerSocketFactory;
+ stdcxx::shared_ptr<transport::TNonblockingSSLServerSocket> socket;
Mutex mutex_;
Runner() {
@@ -198,7 +198,7 @@
};
protected:
- Fixture() : processor(new test::ParentServiceProcessor(boost::make_shared<Handler>())) {}
+ Fixture() : processor(new test::ParentServiceProcessor(stdcxx::make_shared<Handler>())) {}
~Fixture() {
if (server) {
@@ -214,12 +214,12 @@
}
int startServer(int port) {
- boost::shared_ptr<Runner> runner(new Runner);
+ stdcxx::shared_ptr<Runner> runner(new Runner);
runner->port = port;
runner->processor = processor;
runner->userEventBase = userEventBase_;
- boost::scoped_ptr<apache::thrift::concurrency::ThreadFactory> threadFactory(
+ apache::thrift::stdcxx::scoped_ptr<apache::thrift::concurrency::ThreadFactory> threadFactory(
new apache::thrift::concurrency::PlatformThreadFactory(
#if !USE_BOOST_THREAD && !USE_STD_THREAD
concurrency::PlatformThreadFactory::OTHER, concurrency::PlatformThreadFactory::NORMAL,
@@ -235,11 +235,11 @@
}
bool canCommunicate(int serverPort) {
- boost::shared_ptr<TSSLSocketFactory> pClientSocketFactory = createClientSocketFactory();
- boost::shared_ptr<TSSLSocket> socket = pClientSocketFactory->createSocket("localhost", serverPort);
+ stdcxx::shared_ptr<TSSLSocketFactory> pClientSocketFactory = createClientSocketFactory();
+ stdcxx::shared_ptr<TSSLSocket> socket = pClientSocketFactory->createSocket("localhost", serverPort);
socket->open();
- test::ParentServiceClient client(boost::make_shared<protocol::TBinaryProtocol>(
- boost::make_shared<transport::TFramedTransport>(socket)));
+ test::ParentServiceClient client(stdcxx::make_shared<protocol::TBinaryProtocol>(
+ stdcxx::make_shared<transport::TFramedTransport>(socket)));
client.addString("foo");
std::vector<std::string> strings;
client.getStrings(strings);
@@ -247,12 +247,12 @@
}
private:
- boost::shared_ptr<event_base> userEventBase_;
- boost::shared_ptr<test::ParentServiceProcessor> processor;
+ stdcxx::shared_ptr<event_base> userEventBase_;
+ stdcxx::shared_ptr<test::ParentServiceProcessor> processor;
protected:
- boost::shared_ptr<server::TNonblockingServer> server;
+ stdcxx::shared_ptr<server::TNonblockingServer> server;
private:
- boost::shared_ptr<apache::thrift::concurrency::Thread> thread;
+ stdcxx::shared_ptr<apache::thrift::concurrency::Thread> thread;
};
diff --git a/lib/cpp/test/TNonblockingServerTest.cpp b/lib/cpp/test/TNonblockingServerTest.cpp
index 36c64b1..74ffd1d 100644
--- a/lib/cpp/test/TNonblockingServerTest.cpp
+++ b/lib/cpp/test/TNonblockingServerTest.cpp
@@ -19,22 +19,29 @@
#define BOOST_TEST_MODULE TNonblockingServerTest
#include <boost/test/unit_test.hpp>
-#include <boost/smart_ptr.hpp>
#include "thrift/concurrency/Monitor.h"
#include "thrift/concurrency/Thread.h"
#include "thrift/server/TNonblockingServer.h"
#include "thrift/transport/TNonblockingServerSocket.h"
+#include "thrift/stdcxx.h"
#include "gen-cpp/ParentService.h"
#include <event.h>
-using namespace apache::thrift;
using apache::thrift::concurrency::Guard;
using apache::thrift::concurrency::Monitor;
using apache::thrift::concurrency::Mutex;
+using apache::thrift::concurrency::PlatformThreadFactory;
+using apache::thrift::concurrency::Runnable;
+using apache::thrift::concurrency::Thread;
+using apache::thrift::concurrency::ThreadFactory;
using apache::thrift::server::TServerEventHandler;
+using apache::thrift::stdcxx::make_shared;
+using apache::thrift::stdcxx::shared_ptr;
+
+using namespace apache::thrift;
struct Handler : public test::ParentServiceIf {
void addString(const std::string& s) { strings_.push_back(s); }
@@ -66,13 +73,13 @@
bool ready_;
};
- struct Runner : public apache::thrift::concurrency::Runnable {
+ struct Runner : public Runnable {
int port;
- boost::shared_ptr<event_base> userEventBase;
- boost::shared_ptr<TProcessor> processor;
- boost::shared_ptr<server::TNonblockingServer> server;
- boost::shared_ptr<ListenEventHandler> listenHandler;
- boost::shared_ptr<transport::TNonblockingServerSocket> socket;
+ shared_ptr<event_base> userEventBase;
+ shared_ptr<TProcessor> processor;
+ shared_ptr<server::TNonblockingServer> server;
+ shared_ptr<ListenEventHandler> listenHandler;
+ shared_ptr<transport::TNonblockingServerSocket> socket;
Mutex mutex_;
Runner() {
@@ -118,7 +125,7 @@
};
protected:
- Fixture() : processor(new test::ParentServiceProcessor(boost::make_shared<Handler>())) {}
+ Fixture() : processor(new test::ParentServiceProcessor(make_shared<Handler>())) {}
~Fixture() {
if (server) {
@@ -134,15 +141,15 @@
}
int startServer(int port) {
- boost::shared_ptr<Runner> runner(new Runner);
+ shared_ptr<Runner> runner(new Runner);
runner->port = port;
runner->processor = processor;
runner->userEventBase = userEventBase_;
- boost::scoped_ptr<apache::thrift::concurrency::ThreadFactory> threadFactory(
- new apache::thrift::concurrency::PlatformThreadFactory(
+ shared_ptr<ThreadFactory> threadFactory(
+ new PlatformThreadFactory(
#if !USE_BOOST_THREAD && !USE_STD_THREAD
- concurrency::PlatformThreadFactory::OTHER, concurrency::PlatformThreadFactory::NORMAL,
+ PlatformThreadFactory::OTHER, PlatformThreadFactory::NORMAL,
1,
#endif
false));
@@ -155,10 +162,10 @@
}
bool canCommunicate(int serverPort) {
- boost::shared_ptr<transport::TSocket> socket(new transport::TSocket("localhost", serverPort));
+ shared_ptr<transport::TSocket> socket(new transport::TSocket("localhost", serverPort));
socket->open();
- test::ParentServiceClient client(boost::make_shared<protocol::TBinaryProtocol>(
- boost::make_shared<transport::TFramedTransport>(socket)));
+ test::ParentServiceClient client(make_shared<protocol::TBinaryProtocol>(
+ make_shared<transport::TFramedTransport>(socket)));
client.addString("foo");
std::vector<std::string> strings;
client.getStrings(strings);
@@ -166,12 +173,12 @@
}
private:
- boost::shared_ptr<event_base> userEventBase_;
- boost::shared_ptr<test::ParentServiceProcessor> processor;
+ shared_ptr<event_base> userEventBase_;
+ shared_ptr<test::ParentServiceProcessor> processor;
protected:
- boost::shared_ptr<server::TNonblockingServer> server;
+ shared_ptr<server::TNonblockingServer> server;
private:
- boost::shared_ptr<apache::thrift::concurrency::Thread> thread;
+ shared_ptr<concurrency::Thread> thread;
};
diff --git a/lib/cpp/test/TPipeInterruptTest.cpp b/lib/cpp/test/TPipeInterruptTest.cpp
index 80e4c1f..232e4bb 100644
--- a/lib/cpp/test/TPipeInterruptTest.cpp
+++ b/lib/cpp/test/TPipeInterruptTest.cpp
@@ -22,17 +22,18 @@
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test_suite.hpp>
-#include <boost/bind.hpp>
#include <boost/chrono/duration.hpp>
#include <boost/date_time/posix_time/posix_time_duration.hpp>
#include <boost/thread/thread.hpp>
#include <thrift/transport/TPipe.h>
#include <thrift/transport/TPipeServer.h>
+#include <thrift/stdcxx.h>
using apache::thrift::transport::TPipeServer;
using apache::thrift::transport::TPipe;
using apache::thrift::transport::TTransport;
using apache::thrift::transport::TTransportException;
+using namespace apache::thrift;
BOOST_AUTO_TEST_SUITE(TPipeInterruptTest)
@@ -51,7 +52,7 @@
{
for (;;)
{
- boost::shared_ptr<TTransport> temp = pipe->accept();
+ stdcxx::shared_ptr<TTransport> temp = pipe->accept();
}
}
catch (...) {/*just want to make sure nothing crashes*/ }
@@ -69,8 +70,8 @@
{
TPipeServer pipeServer("TPipeInterruptTest");
pipeServer.listen();
- boost::thread acceptThread(boost::bind(acceptWorker, &pipeServer));
- boost::thread interruptThread(boost::bind(interruptWorker, &pipeServer));
+ boost::thread acceptThread(stdcxx::bind(acceptWorker, &pipeServer));
+ boost::thread interruptThread(stdcxx::bind(interruptWorker, &pipeServer));
try
{
for (;;)
diff --git a/lib/cpp/test/TPipedTransportTest.cpp b/lib/cpp/test/TPipedTransportTest.cpp
index 3221fb9..a3ce662 100644
--- a/lib/cpp/test/TPipedTransportTest.cpp
+++ b/lib/cpp/test/TPipedTransportTest.cpp
@@ -18,6 +18,7 @@
*/
#include <thrift/Thrift.h>
+#include <thrift/stdcxx.h>
#include <thrift/transport/TTransportUtils.h>
#include <thrift/transport/TBufferTransports.h>
@@ -27,11 +28,12 @@
using apache::thrift::transport::TTransportException;
using apache::thrift::transport::TPipedTransport;
using apache::thrift::transport::TMemoryBuffer;
+using namespace apache::thrift;
BOOST_AUTO_TEST_CASE(test_read_write) {
- boost::shared_ptr<TMemoryBuffer> underlying(new TMemoryBuffer);
- boost::shared_ptr<TMemoryBuffer> pipe(new TMemoryBuffer);
- boost::shared_ptr<TPipedTransport> trans(new TPipedTransport(underlying, pipe));
+ stdcxx::shared_ptr<TMemoryBuffer> underlying(new TMemoryBuffer);
+ stdcxx::shared_ptr<TMemoryBuffer> pipe(new TMemoryBuffer);
+ stdcxx::shared_ptr<TPipedTransport> trans(new TPipedTransport(underlying, pipe));
uint8_t buffer[4];
diff --git a/lib/cpp/test/TSSLSocketInterruptTest.cpp b/lib/cpp/test/TSSLSocketInterruptTest.cpp
index bf5c7d7..85f6c39 100644
--- a/lib/cpp/test/TSSLSocketInterruptTest.cpp
+++ b/lib/cpp/test/TSSLSocketInterruptTest.cpp
@@ -19,13 +19,12 @@
#include <boost/test/auto_unit_test.hpp>
#include <boost/test/unit_test_suite.hpp>
-#include <boost/bind.hpp>
#include <boost/chrono/duration.hpp>
#include <boost/date_time/posix_time/posix_time_duration.hpp>
#include <boost/thread/thread.hpp>
#include <boost/filesystem.hpp>
#include <boost/format.hpp>
-#include <boost/shared_ptr.hpp>
+#include <thrift/stdcxx.h>
#include <thrift/transport/TSSLSocket.h>
#include <thrift/transport/TSSLServerSocket.h>
#ifdef __linux__
@@ -38,6 +37,9 @@
using apache::thrift::transport::TTransportException;
using apache::thrift::transport::TSSLSocketFactory;
+using apache::thrift::stdcxx::static_pointer_cast;
+using apache::thrift::stdcxx::shared_ptr;
+
BOOST_AUTO_TEST_SUITE(TSSLSocketInterruptTest)
boost::filesystem::path keyDir;
@@ -92,7 +94,7 @@
BOOST_GLOBAL_FIXTURE(GlobalFixtureSSL)
#endif
-void readerWorker(boost::shared_ptr<TTransport> tt, uint32_t expectedResult) {
+void readerWorker(shared_ptr<TTransport> tt, uint32_t expectedResult) {
uint8_t buf[4];
try {
tt->read(buf, 1);
@@ -102,7 +104,7 @@
}
}
-void readerWorkerMustThrow(boost::shared_ptr<TTransport> tt) {
+void readerWorkerMustThrow(shared_ptr<TTransport> tt) {
try {
uint8_t buf[400];
tt->read(buf, 1);
@@ -113,8 +115,8 @@
}
}
-boost::shared_ptr<TSSLSocketFactory> createServerSocketFactory() {
- boost::shared_ptr<TSSLSocketFactory> pServerSocketFactory;
+shared_ptr<TSSLSocketFactory> createServerSocketFactory() {
+ shared_ptr<TSSLSocketFactory> pServerSocketFactory;
pServerSocketFactory.reset(new TSSLSocketFactory());
pServerSocketFactory->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
@@ -124,8 +126,8 @@
return pServerSocketFactory;
}
-boost::shared_ptr<TSSLSocketFactory> createClientSocketFactory() {
- boost::shared_ptr<TSSLSocketFactory> pClientSocketFactory;
+shared_ptr<TSSLSocketFactory> createClientSocketFactory() {
+ shared_ptr<TSSLSocketFactory> pClientSocketFactory;
pClientSocketFactory.reset(new TSSLSocketFactory());
pClientSocketFactory->authenticate(true);
@@ -136,15 +138,15 @@
}
BOOST_AUTO_TEST_CASE(test_ssl_interruptable_child_read_while_handshaking) {
- boost::shared_ptr<TSSLSocketFactory> pServerSocketFactory = createServerSocketFactory();
+ shared_ptr<TSSLSocketFactory> pServerSocketFactory = createServerSocketFactory();
TSSLServerSocket sock1("localhost", 0, pServerSocketFactory);
sock1.listen();
int port = sock1.getPort();
- boost::shared_ptr<TSSLSocketFactory> pClientSocketFactory = createClientSocketFactory();
- boost::shared_ptr<TSSLSocket> clientSock = pClientSocketFactory->createSocket("localhost", port);
+ shared_ptr<TSSLSocketFactory> pClientSocketFactory = createClientSocketFactory();
+ shared_ptr<TSSLSocket> clientSock = pClientSocketFactory->createSocket("localhost", port);
clientSock->open();
- boost::shared_ptr<TTransport> accepted = sock1.accept();
- boost::thread readThread(boost::bind(readerWorkerMustThrow, accepted));
+ shared_ptr<TTransport> accepted = sock1.accept();
+ boost::thread readThread(apache::thrift::stdcxx::bind(readerWorkerMustThrow, accepted));
boost::this_thread::sleep(boost::posix_time::milliseconds(50));
// readThread is practically guaranteed to be blocking now
sock1.interruptChildren();
@@ -156,15 +158,15 @@
}
BOOST_AUTO_TEST_CASE(test_ssl_interruptable_child_read) {
- boost::shared_ptr<TSSLSocketFactory> pServerSocketFactory = createServerSocketFactory();
+ shared_ptr<TSSLSocketFactory> pServerSocketFactory = createServerSocketFactory();
TSSLServerSocket sock1("localhost", 0, pServerSocketFactory);
sock1.listen();
int port = sock1.getPort();
- boost::shared_ptr<TSSLSocketFactory> pClientSocketFactory = createClientSocketFactory();
- boost::shared_ptr<TSSLSocket> clientSock = pClientSocketFactory->createSocket("localhost", port);
+ shared_ptr<TSSLSocketFactory> pClientSocketFactory = createClientSocketFactory();
+ shared_ptr<TSSLSocket> clientSock = pClientSocketFactory->createSocket("localhost", port);
clientSock->open();
- boost::shared_ptr<TTransport> accepted = sock1.accept();
- boost::thread readThread(boost::bind(readerWorkerMustThrow, accepted));
+ shared_ptr<TTransport> accepted = sock1.accept();
+ boost::thread readThread(apache::thrift::stdcxx::bind(readerWorkerMustThrow, accepted));
clientSock->write((const uint8_t*)"0", 1);
boost::this_thread::sleep(boost::posix_time::milliseconds(50));
// readThread is practically guaranteed to be blocking now
@@ -177,17 +179,17 @@
}
BOOST_AUTO_TEST_CASE(test_ssl_non_interruptable_child_read) {
- boost::shared_ptr<TSSLSocketFactory> pServerSocketFactory = createServerSocketFactory();
+ shared_ptr<TSSLSocketFactory> pServerSocketFactory = createServerSocketFactory();
TSSLServerSocket sock1("localhost", 0, pServerSocketFactory);
sock1.setInterruptableChildren(false); // returns to pre-THRIFT-2441 behavior
sock1.listen();
int port = sock1.getPort();
- boost::shared_ptr<TSSLSocketFactory> pClientSocketFactory = createClientSocketFactory();
- boost::shared_ptr<TSSLSocket> clientSock = pClientSocketFactory->createSocket("localhost", port);
+ shared_ptr<TSSLSocketFactory> pClientSocketFactory = createClientSocketFactory();
+ shared_ptr<TSSLSocket> clientSock = pClientSocketFactory->createSocket("localhost", port);
clientSock->open();
- boost::shared_ptr<TTransport> accepted = sock1.accept();
- boost::static_pointer_cast<TSSLSocket>(accepted)->setRecvTimeout(1000);
- boost::thread readThread(boost::bind(readerWorker, accepted, 0));
+ shared_ptr<TTransport> accepted = sock1.accept();
+ static_pointer_cast<TSSLSocket>(accepted)->setRecvTimeout(1000);
+ boost::thread readThread(apache::thrift::stdcxx::bind(readerWorker, accepted, 0));
clientSock->write((const uint8_t*)"0", 1);
boost::this_thread::sleep(boost::posix_time::milliseconds(50));
// readThread is practically guaranteed to be blocking here
@@ -203,14 +205,14 @@
}
BOOST_AUTO_TEST_CASE(test_ssl_cannot_change_after_listen) {
- boost::shared_ptr<TSSLSocketFactory> pServerSocketFactory = createServerSocketFactory();
+ shared_ptr<TSSLSocketFactory> pServerSocketFactory = createServerSocketFactory();
TSSLServerSocket sock1("localhost", 0, pServerSocketFactory);
sock1.listen();
BOOST_CHECK_THROW(sock1.setInterruptableChildren(false), std::logic_error);
sock1.close();
}
-void peekerWorker(boost::shared_ptr<TTransport> tt, bool expectedResult) {
+void peekerWorker(shared_ptr<TTransport> tt, bool expectedResult) {
uint8_t buf[400];
try {
tt->read(buf, 1);
@@ -220,7 +222,7 @@
}
}
-void peekerWorkerInterrupt(boost::shared_ptr<TTransport> tt) {
+void peekerWorkerInterrupt(shared_ptr<TTransport> tt) {
uint8_t buf[400];
try {
tt->read(buf, 1);
@@ -231,15 +233,15 @@
}
BOOST_AUTO_TEST_CASE(test_ssl_interruptable_child_peek) {
- boost::shared_ptr<TSSLSocketFactory> pServerSocketFactory = createServerSocketFactory();
+ shared_ptr<TSSLSocketFactory> pServerSocketFactory = createServerSocketFactory();
TSSLServerSocket sock1("localhost", 0, pServerSocketFactory);
sock1.listen();
int port = sock1.getPort();
- boost::shared_ptr<TSSLSocketFactory> pClientSocketFactory = createClientSocketFactory();
- boost::shared_ptr<TSSLSocket> clientSock = pClientSocketFactory->createSocket("localhost", port);
+ shared_ptr<TSSLSocketFactory> pClientSocketFactory = createClientSocketFactory();
+ shared_ptr<TSSLSocket> clientSock = pClientSocketFactory->createSocket("localhost", port);
clientSock->open();
- boost::shared_ptr<TTransport> accepted = sock1.accept();
- boost::thread peekThread(boost::bind(peekerWorkerInterrupt, accepted));
+ shared_ptr<TTransport> accepted = sock1.accept();
+ boost::thread peekThread(apache::thrift::stdcxx::bind(peekerWorkerInterrupt, accepted));
clientSock->write((const uint8_t*)"0", 1);
boost::this_thread::sleep(boost::posix_time::milliseconds(50));
// peekThread is practically guaranteed to be blocking now
@@ -252,17 +254,17 @@
}
BOOST_AUTO_TEST_CASE(test_ssl_non_interruptable_child_peek) {
- boost::shared_ptr<TSSLSocketFactory> pServerSocketFactory = createServerSocketFactory();
+ shared_ptr<TSSLSocketFactory> pServerSocketFactory = createServerSocketFactory();
TSSLServerSocket sock1("localhost", 0, pServerSocketFactory);
sock1.setInterruptableChildren(false); // returns to pre-THRIFT-2441 behavior
sock1.listen();
int port = sock1.getPort();
- boost::shared_ptr<TSSLSocketFactory> pClientSocketFactory = createClientSocketFactory();
- boost::shared_ptr<TSSLSocket> clientSock = pClientSocketFactory->createSocket("localhost", port);
+ shared_ptr<TSSLSocketFactory> pClientSocketFactory = createClientSocketFactory();
+ shared_ptr<TSSLSocket> clientSock = pClientSocketFactory->createSocket("localhost", port);
clientSock->open();
- boost::shared_ptr<TTransport> accepted = sock1.accept();
- boost::static_pointer_cast<TSSLSocket>(accepted)->setRecvTimeout(1000);
- boost::thread peekThread(boost::bind(peekerWorker, accepted, false));
+ shared_ptr<TTransport> accepted = sock1.accept();
+ static_pointer_cast<TSSLSocket>(accepted)->setRecvTimeout(1000);
+ boost::thread peekThread(apache::thrift::stdcxx::bind(peekerWorker, accepted, false));
clientSock->write((const uint8_t*)"0", 1);
boost::this_thread::sleep(boost::posix_time::milliseconds(50));
// peekThread is practically guaranteed to be blocking now
diff --git a/lib/cpp/test/TServerIntegrationTest.cpp b/lib/cpp/test/TServerIntegrationTest.cpp
index fd7bae2..a6e02f1 100644
--- a/lib/cpp/test/TServerIntegrationTest.cpp
+++ b/lib/cpp/test/TServerIntegrationTest.cpp
@@ -20,16 +20,14 @@
#define BOOST_TEST_MODULE TServerIntegrationTest
#include <boost/test/auto_unit_test.hpp>
#include <boost/atomic.hpp>
-#include <boost/bind.hpp>
#include <boost/date_time/posix_time/ptime.hpp>
#include <boost/foreach.hpp>
#include <boost/format.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/shared_ptr.hpp>
#include <boost/thread.hpp>
#include <thrift/server/TSimpleServer.h>
#include <thrift/server/TThreadPoolServer.h>
#include <thrift/server/TThreadedServer.h>
+#include <thrift/stdcxx.h>
#include <thrift/protocol/TBinaryProtocol.h>
#include <thrift/transport/TServerSocket.h>
#include <thrift/transport/TSocket.h>
@@ -57,6 +55,9 @@
using apache::thrift::server::TSimpleServer;
using apache::thrift::server::TThreadPoolServer;
using apache::thrift::server::TThreadedServer;
+using apache::thrift::stdcxx::dynamic_pointer_cast;
+using apache::thrift::stdcxx::make_shared;
+using apache::thrift::stdcxx::shared_ptr;
using apache::thrift::test::ParentServiceClient;
using apache::thrift::test::ParentServiceIf;
using apache::thrift::test::ParentServiceIfFactory;
@@ -79,8 +80,8 @@
isListening_ = true;
notify();
}
- virtual void* createContext(boost::shared_ptr<TProtocol> input,
- boost::shared_ptr<TProtocol> output) {
+ virtual void* createContext(shared_ptr<TProtocol> input,
+ shared_ptr<TProtocol> output) {
Synchronized sync(*this);
++accepted_;
notify();
@@ -149,26 +150,26 @@
template <class TServerType>
class TServerIntegrationTestFixture {
public:
- TServerIntegrationTestFixture(const boost::shared_ptr<TProcessorFactory>& _processorFactory)
+ TServerIntegrationTestFixture(const shared_ptr<TProcessorFactory>& _processorFactory)
: pServer(new TServerType(_processorFactory,
- boost::shared_ptr<TServerTransport>(
+ shared_ptr<TServerTransport>(
new TServerSocket("localhost", 0)),
- boost::shared_ptr<TTransportFactory>(new TTransportFactory),
- boost::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory))),
- pEventHandler(boost::shared_ptr<TServerReadyEventHandler>(new TServerReadyEventHandler)),
+ shared_ptr<TTransportFactory>(new TTransportFactory),
+ shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory))),
+ pEventHandler(shared_ptr<TServerReadyEventHandler>(new TServerReadyEventHandler)),
bStressDone(false),
bStressConnectionCount(0),
bStressRequestCount(0) {
pServer->setServerEventHandler(pEventHandler);
}
- TServerIntegrationTestFixture(const boost::shared_ptr<TProcessor>& _processor)
+ TServerIntegrationTestFixture(const shared_ptr<TProcessor>& _processor)
: pServer(
new TServerType(_processor,
- boost::shared_ptr<TServerTransport>(new TServerSocket("localhost", 0)),
- boost::shared_ptr<TTransportFactory>(new TTransportFactory),
- boost::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory))),
- pEventHandler(boost::shared_ptr<TServerReadyEventHandler>(new TServerReadyEventHandler)),
+ shared_ptr<TServerTransport>(new TServerSocket("localhost", 0)),
+ shared_ptr<TTransportFactory>(new TTransportFactory),
+ shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory))),
+ pEventHandler(shared_ptr<TServerReadyEventHandler>(new TServerReadyEventHandler)),
bStressDone(false),
bStressConnectionCount(0),
bStressRequestCount(0) {
@@ -176,7 +177,7 @@
}
void startServer() {
- pServerThread.reset(new boost::thread(boost::bind(&TServerType::serve, pServer.get())));
+ pServerThread.reset(new boost::thread(apache::thrift::stdcxx::bind(&TServerType::serve, pServer.get())));
// block until listen() completes so clients will be able to connect
Synchronized sync(*(pEventHandler.get()));
@@ -222,19 +223,19 @@
startServer();
- std::vector<boost::shared_ptr<TSocket> > holdSockets;
- std::vector<boost::shared_ptr<boost::thread> > holdThreads;
+ std::vector<shared_ptr<TSocket> > holdSockets;
+ std::vector<shared_ptr<boost::thread> > holdThreads;
for (int64_t i = 0; i < numToMake; ++i) {
- boost::shared_ptr<TSocket> pClientSock(new TSocket("localhost", getServerPort()),
+ shared_ptr<TSocket> pClientSock(new TSocket("localhost", getServerPort()),
autoSocketCloser);
holdSockets.push_back(pClientSock);
- boost::shared_ptr<TProtocol> pClientProtocol(new TBinaryProtocol(pClientSock));
+ shared_ptr<TProtocol> pClientProtocol(new TBinaryProtocol(pClientSock));
ParentServiceClient client(pClientProtocol);
pClientSock->open();
client.incrementGeneration();
- holdThreads.push_back(boost::shared_ptr<boost::thread>(
- new boost::thread(boost::bind(&TServerIntegrationTestFixture::delayClose,
+ holdThreads.push_back(shared_ptr<boost::thread>(
+ new boost::thread(apache::thrift::stdcxx::bind(&TServerIntegrationTestFixture::delayClose,
this,
pClientSock,
milliseconds(10 * numToMake)))));
@@ -242,7 +243,7 @@
BOOST_CHECK_EQUAL(expectedHWM, pServer->getConcurrentClientCountHWM());
- BOOST_FOREACH (boost::shared_ptr<boost::thread> pThread, holdThreads) { pThread->join(); }
+ BOOST_FOREACH (shared_ptr<boost::thread> pThread, holdThreads) { pThread->join(); }
holdThreads.clear();
holdSockets.clear();
@@ -254,7 +255,7 @@
* \param[in] toClose the connection to close
* \param[in] after the delay to impose
*/
- void delayClose(boost::shared_ptr<TTransport> toClose, boost::posix_time::time_duration after) {
+ void delayClose(shared_ptr<TTransport> toClose, boost::posix_time::time_duration after) {
boost::this_thread::sleep(after);
toClose->close();
}
@@ -279,10 +280,10 @@
startServer();
- std::vector<boost::shared_ptr<boost::thread> > holdThreads;
+ std::vector<shared_ptr<boost::thread> > holdThreads;
for (int64_t i = 0; i < numToMake; ++i) {
- holdThreads.push_back(boost::shared_ptr<boost::thread>(
- new boost::thread(boost::bind(&TServerIntegrationTestFixture::stressor, this))));
+ holdThreads.push_back(shared_ptr<boost::thread>(
+ new boost::thread(apache::thrift::stdcxx::bind(&TServerIntegrationTestFixture::stressor, this))));
}
boost::this_thread::sleep(duration);
@@ -291,7 +292,7 @@
BOOST_TEST_MESSAGE(boost::format(" serviced %1% connections (HWM %2%) totaling %3% requests")
% bStressConnectionCount % pServer->getConcurrentClientCountHWM() % bStressRequestCount);
- BOOST_FOREACH (boost::shared_ptr<boost::thread> pThread, holdThreads) { pThread->join(); }
+ BOOST_FOREACH (shared_ptr<boost::thread> pThread, holdThreads) { pThread->join(); }
holdThreads.clear();
BOOST_CHECK(bStressRequestCount > 0);
@@ -304,8 +305,8 @@
*/
void stressor() {
while (!bStressDone) {
- boost::shared_ptr<TSocket> pSocket(new TSocket("localhost", getServerPort()), autoSocketCloser);
- boost::shared_ptr<TProtocol> pProtocol(new TBinaryProtocol(pSocket));
+ shared_ptr<TSocket> pSocket(new TSocket("localhost", getServerPort()), autoSocketCloser);
+ shared_ptr<TProtocol> pProtocol(new TBinaryProtocol(pSocket));
ParentServiceClient client(pProtocol);
pSocket->open();
bStressConnectionCount.fetch_add(1, boost::memory_order_relaxed);
@@ -316,9 +317,9 @@
}
}
- boost::shared_ptr<TServerType> pServer;
- boost::shared_ptr<TServerReadyEventHandler> pEventHandler;
- boost::shared_ptr<boost::thread> pServerThread;
+ shared_ptr<TServerType> pServer;
+ shared_ptr<TServerReadyEventHandler> pEventHandler;
+ shared_ptr<boost::thread> pServerThread;
bool bStressDone;
boost::atomic_int64_t bStressConnectionCount;
boost::atomic_int64_t bStressRequestCount;
@@ -329,9 +330,9 @@
: public TServerIntegrationTestFixture<TServerType> {
public:
TServerIntegrationProcessorFactoryTestFixture()
- : TServerIntegrationTestFixture<TServerType>(boost::make_shared<ParentServiceProcessorFactory>(
- boost::make_shared<ParentServiceIfSingletonFactory>(
- boost::make_shared<ParentHandler>()))) {}
+ : TServerIntegrationTestFixture<TServerType>(make_shared<ParentServiceProcessorFactory>(
+ make_shared<ParentServiceIfSingletonFactory>(
+ make_shared<ParentHandler>()))) {}
};
template <class TServerType>
@@ -339,7 +340,7 @@
public:
TServerIntegrationProcessorTestFixture()
: TServerIntegrationTestFixture<TServerType>(
- boost::make_shared<ParentServiceProcessor>(boost::make_shared<ParentHandler>())) {}
+ make_shared<ParentServiceProcessor>(make_shared<ParentHandler>())) {}
};
BOOST_AUTO_TEST_SUITE(constructors)
@@ -376,7 +377,7 @@
BOOST_FIXTURE_TEST_CASE(test_threadpool_factory,
TServerIntegrationProcessorFactoryTestFixture<TThreadPoolServer>) {
pServer->getThreadManager()->threadFactory(
- boost::shared_ptr<apache::thrift::concurrency::ThreadFactory>(
+ shared_ptr<apache::thrift::concurrency::ThreadFactory>(
new apache::thrift::concurrency::PlatformThreadFactory));
pServer->getThreadManager()->start();
@@ -391,7 +392,7 @@
BOOST_FIXTURE_TEST_CASE(test_threadpool,
TServerIntegrationProcessorTestFixture<TThreadPoolServer>) {
pServer->getThreadManager()->threadFactory(
- boost::shared_ptr<apache::thrift::concurrency::ThreadFactory>(
+ shared_ptr<apache::thrift::concurrency::ThreadFactory>(
new apache::thrift::concurrency::PlatformThreadFactory));
pServer->getThreadManager()->start();
@@ -406,7 +407,7 @@
BOOST_FIXTURE_TEST_CASE(test_threadpool_bound,
TServerIntegrationProcessorTestFixture<TThreadPoolServer>) {
pServer->getThreadManager()->threadFactory(
- boost::shared_ptr<apache::thrift::concurrency::ThreadFactory>(
+ shared_ptr<apache::thrift::concurrency::ThreadFactory>(
new apache::thrift::concurrency::PlatformThreadFactory));
pServer->getThreadManager()->start();
pServer->setConcurrentClientLimit(4);
@@ -417,7 +418,7 @@
BOOST_FIXTURE_TEST_CASE(test_threadpool_stress,
TServerIntegrationProcessorTestFixture<TThreadPoolServer>) {
pServer->getThreadManager()->threadFactory(
- boost::shared_ptr<apache::thrift::concurrency::ThreadFactory>(
+ shared_ptr<apache::thrift::concurrency::ThreadFactory>(
new apache::thrift::concurrency::PlatformThreadFactory));
pServer->getThreadManager()->start();
@@ -435,11 +436,11 @@
startServer();
- boost::shared_ptr<TSocket> pClientSock1(new TSocket("localhost", getServerPort()),
+ shared_ptr<TSocket> pClientSock1(new TSocket("localhost", getServerPort()),
autoSocketCloser);
pClientSock1->open();
- boost::shared_ptr<TSocket> pClientSock2(new TSocket("localhost", getServerPort()),
+ shared_ptr<TSocket> pClientSock2(new TSocket("localhost", getServerPort()),
autoSocketCloser);
pClientSock2->open();
@@ -461,27 +462,27 @@
// disconnect.
BOOST_TEST_MESSAGE("Testing stop with uninterruptable clients");
- boost::dynamic_pointer_cast<TServerSocket>(pServer->getServerTransport())
+ dynamic_pointer_cast<TServerSocket>(pServer->getServerTransport())
->setInterruptableChildren(false); // returns to pre-THRIFT-2441 behavior
startServer();
- boost::shared_ptr<TSocket> pClientSock1(new TSocket("localhost", getServerPort()),
+ shared_ptr<TSocket> pClientSock1(new TSocket("localhost", getServerPort()),
autoSocketCloser);
pClientSock1->open();
- boost::shared_ptr<TSocket> pClientSock2(new TSocket("localhost", getServerPort()),
+ shared_ptr<TSocket> pClientSock2(new TSocket("localhost", getServerPort()),
autoSocketCloser);
pClientSock2->open();
// Ensure they have been accepted
blockUntilAccepted(2);
- boost::thread t1(boost::bind(&TServerIntegrationTestFixture::delayClose,
+ boost::thread t1(apache::thrift::stdcxx::bind(&TServerIntegrationTestFixture::delayClose,
this,
pClientSock1,
milliseconds(250)));
- boost::thread t2(boost::bind(&TServerIntegrationTestFixture::delayClose,
+ boost::thread t2(apache::thrift::stdcxx::bind(&TServerIntegrationTestFixture::delayClose,
this,
pClientSock2,
milliseconds(250)));
@@ -502,24 +503,24 @@
BOOST_CHECK_EQUAL(0, pServer->getConcurrentClientCount());
BOOST_CHECK_EQUAL(2, pServer->getConcurrentClientLimit());
- boost::shared_ptr<TSocket> pClientSock1(new TSocket("localhost", getServerPort()),
+ shared_ptr<TSocket> pClientSock1(new TSocket("localhost", getServerPort()),
autoSocketCloser);
pClientSock1->open();
blockUntilAccepted(1);
BOOST_CHECK_EQUAL(1, pServer->getConcurrentClientCount());
- boost::shared_ptr<TSocket> pClientSock2(new TSocket("localhost", getServerPort()),
+ shared_ptr<TSocket> pClientSock2(new TSocket("localhost", getServerPort()),
autoSocketCloser);
pClientSock2->open();
blockUntilAccepted(2);
BOOST_CHECK_EQUAL(2, pServer->getConcurrentClientCount());
// a third client cannot connect until one of the other two closes
- boost::thread t2(boost::bind(&TServerIntegrationTestFixture::delayClose,
+ boost::thread t2(apache::thrift::stdcxx::bind(&TServerIntegrationTestFixture::delayClose,
this,
pClientSock2,
milliseconds(250)));
- boost::shared_ptr<TSocket> pClientSock3(new TSocket("localhost", getServerPort()),
+ shared_ptr<TSocket> pClientSock3(new TSocket("localhost", getServerPort()),
autoSocketCloser);
pClientSock2->open();
blockUntilAccepted(2);
diff --git a/lib/cpp/test/TServerSocketTest.cpp b/lib/cpp/test/TServerSocketTest.cpp
index 1da5d36..a191147 100644
--- a/lib/cpp/test/TServerSocketTest.cpp
+++ b/lib/cpp/test/TServerSocketTest.cpp
@@ -20,6 +20,7 @@
#include <boost/test/auto_unit_test.hpp>
#include <thrift/transport/TSocket.h>
#include <thrift/transport/TServerSocket.h>
+#include <thrift/stdcxx.h>
#include "TTransportCheckThrow.h"
#include <iostream>
@@ -27,6 +28,7 @@
using apache::thrift::transport::TSocket;
using apache::thrift::transport::TTransport;
using apache::thrift::transport::TTransportException;
+using apache::thrift::stdcxx::shared_ptr;
BOOST_AUTO_TEST_SUITE(TServerSocketTest)
@@ -36,7 +38,7 @@
int port = sock1.getPort();
TSocket clientSock("localhost", port);
clientSock.open();
- boost::shared_ptr<TTransport> accepted = sock1.accept();
+ shared_ptr<TTransport> accepted = sock1.accept();
accepted->close();
sock1.close();
diff --git a/lib/cpp/test/TServerTransportTest.cpp b/lib/cpp/test/TServerTransportTest.cpp
index a554622..dc6aede 100644
--- a/lib/cpp/test/TServerTransportTest.cpp
+++ b/lib/cpp/test/TServerTransportTest.cpp
@@ -20,10 +20,12 @@
#include <boost/test/auto_unit_test.hpp>
#include <thrift/transport/TSocket.h>
#include <thrift/transport/TServerTransport.h>
+#include <thrift/stdcxx.h>
using apache::thrift::transport::TServerTransport;
using apache::thrift::transport::TTransport;
using apache::thrift::transport::TTransportException;
+using apache::thrift::stdcxx::shared_ptr;
BOOST_AUTO_TEST_SUITE(TServerTransportTest)
@@ -36,9 +38,9 @@
bool valid_;
protected:
- boost::shared_ptr<TTransport> acceptImpl() {
- return valid_ ? boost::shared_ptr<TestTTransport>(new TestTTransport)
- : boost::shared_ptr<TestTTransport>();
+ shared_ptr<TTransport> acceptImpl() {
+ return valid_ ? shared_ptr<TestTTransport>(new TestTTransport)
+ : shared_ptr<TestTTransport>();
}
};
diff --git a/lib/cpp/test/TSocketInterruptTest.cpp b/lib/cpp/test/TSocketInterruptTest.cpp
index 27b89eb..3a189cc 100644
--- a/lib/cpp/test/TSocketInterruptTest.cpp
+++ b/lib/cpp/test/TSocketInterruptTest.cpp
@@ -20,26 +20,27 @@
#define BOOST_TEST_MODULE TSocketInterruptTest
#include <boost/test/auto_unit_test.hpp>
-#include <boost/bind.hpp>
#include <boost/chrono/duration.hpp>
#include <boost/date_time/posix_time/posix_time_duration.hpp>
#include <boost/thread/thread.hpp>
#include <thrift/transport/TSocket.h>
#include <thrift/transport/TServerSocket.h>
+#include <thrift/stdcxx.h>
using apache::thrift::transport::TServerSocket;
using apache::thrift::transport::TSocket;
using apache::thrift::transport::TTransport;
using apache::thrift::transport::TTransportException;
+using namespace apache::thrift;
BOOST_AUTO_TEST_SUITE(TSocketInterruptTest)
-void readerWorker(boost::shared_ptr<TTransport> tt, uint32_t expectedResult) {
+void readerWorker(stdcxx::shared_ptr<TTransport> tt, uint32_t expectedResult) {
uint8_t buf[4];
BOOST_CHECK_EQUAL(expectedResult, tt->read(buf, 4));
}
-void readerWorkerMustThrow(boost::shared_ptr<TTransport> tt) {
+void readerWorkerMustThrow(stdcxx::shared_ptr<TTransport> tt) {
try {
uint8_t buf[4];
tt->read(buf, 4);
@@ -55,8 +56,8 @@
int port = sock1.getPort();
TSocket clientSock("localhost", port);
clientSock.open();
- boost::shared_ptr<TTransport> accepted = sock1.accept();
- boost::thread readThread(boost::bind(readerWorkerMustThrow, accepted));
+ stdcxx::shared_ptr<TTransport> accepted = sock1.accept();
+ boost::thread readThread(stdcxx::bind(readerWorkerMustThrow, accepted));
boost::this_thread::sleep(boost::posix_time::milliseconds(50));
// readThread is practically guaranteed to be blocking now
sock1.interruptChildren();
@@ -74,8 +75,8 @@
int port = sock1.getPort();
TSocket clientSock("localhost", port);
clientSock.open();
- boost::shared_ptr<TTransport> accepted = sock1.accept();
- boost::thread readThread(boost::bind(readerWorker, accepted, 0));
+ stdcxx::shared_ptr<TTransport> accepted = sock1.accept();
+ boost::thread readThread(stdcxx::bind(readerWorker, accepted, 0));
boost::this_thread::sleep(boost::posix_time::milliseconds(50));
// readThread is practically guaranteed to be blocking here
sock1.interruptChildren();
@@ -96,7 +97,7 @@
sock1.close();
}
-void peekerWorker(boost::shared_ptr<TTransport> tt, bool expectedResult) {
+void peekerWorker(stdcxx::shared_ptr<TTransport> tt, bool expectedResult) {
BOOST_CHECK_EQUAL(expectedResult, tt->peek());
}
@@ -106,9 +107,9 @@
int port = sock1.getPort();
TSocket clientSock("localhost", port);
clientSock.open();
- boost::shared_ptr<TTransport> accepted = sock1.accept();
+ stdcxx::shared_ptr<TTransport> accepted = sock1.accept();
// peek() will return false if child is interrupted
- boost::thread peekThread(boost::bind(peekerWorker, accepted, false));
+ boost::thread peekThread(stdcxx::bind(peekerWorker, accepted, false));
boost::this_thread::sleep(boost::posix_time::milliseconds(50));
// peekThread is practically guaranteed to be blocking now
sock1.interruptChildren();
@@ -126,9 +127,9 @@
int port = sock1.getPort();
TSocket clientSock("localhost", port);
clientSock.open();
- boost::shared_ptr<TTransport> accepted = sock1.accept();
+ stdcxx::shared_ptr<TTransport> accepted = sock1.accept();
// peek() will return false when remote side is closed
- boost::thread peekThread(boost::bind(peekerWorker, accepted, false));
+ boost::thread peekThread(stdcxx::bind(peekerWorker, accepted, false));
boost::this_thread::sleep(boost::posix_time::milliseconds(50));
// peekThread is practically guaranteed to be blocking now
sock1.interruptChildren();
diff --git a/lib/cpp/test/TransportTest.cpp b/lib/cpp/test/TransportTest.cpp
index ccef9d5..d6ab457 100644
--- a/lib/cpp/test/TransportTest.cpp
+++ b/lib/cpp/test/TransportTest.cpp
@@ -26,7 +26,7 @@
#endif
#include <sstream>
#include <fstream>
-#include <thrift/cxxfunctional.h>
+#include <thrift/stdcxx.h>
#include <boost/mpl/list.hpp>
#include <boost/shared_array.hpp>
@@ -43,10 +43,12 @@
#include <thrift/concurrency/FunctionRunner.h>
#if _WIN32
+#include <thrift/transport/TPipe.h>
#include <thrift/windows/TWinsockSingleton.h>
#endif
using namespace apache::thrift::transport;
+using namespace apache::thrift;
static boost::mt19937 rng;
@@ -112,7 +114,7 @@
std::string describe() const { return generator_->describe(); }
private:
- boost::shared_ptr<SizeGenerator> generator_;
+ stdcxx::shared_ptr<SizeGenerator> generator_;
};
/**************************************************************************
@@ -135,8 +137,8 @@
CoupledTransports() : in(), out() {}
- boost::shared_ptr<Transport_> in;
- boost::shared_ptr<Transport_> out;
+ stdcxx::shared_ptr<Transport_> in;
+ stdcxx::shared_ptr<Transport_> out;
private:
CoupledTransports(const CoupledTransports&);
@@ -153,7 +155,7 @@
out = buf;
}
- boost::shared_ptr<TMemoryBuffer> buf;
+ stdcxx::shared_ptr<TMemoryBuffer> buf;
};
/**
@@ -219,6 +221,22 @@
out.reset(new TFDTransport(pipes[1], TFDTransport::CLOSE_ON_DESTROY));
}
};
+#else
+/**
+ * Coupled pipe transports
+ */
+class CoupledPipeTransports : public CoupledTransports<TPipe> {
+public:
+ HANDLE hRead;
+ HANDLE hWrite;
+
+ CoupledPipeTransports() {
+ BOOST_REQUIRE(CreatePipe(&hRead, &hWrite, NULL, 1048576 * 2));
+ in.reset(new TPipe(hRead, hWrite));
+ in->open();
+ out = in;
+ }
+};
#endif
/**
@@ -323,11 +341,11 @@
**************************************************************************/
struct TriggerInfo {
- TriggerInfo(int seconds, const boost::shared_ptr<TTransport>& transport, uint32_t writeLength)
+ TriggerInfo(int seconds, const stdcxx::shared_ptr<TTransport>& transport, uint32_t writeLength)
: timeoutSeconds(seconds), transport(transport), writeLength(writeLength), next(NULL) {}
int timeoutSeconds;
- boost::shared_ptr<TTransport> transport;
+ stdcxx::shared_ptr<TTransport> transport;
uint32_t writeLength;
TriggerInfo* next;
};
@@ -402,7 +420,7 @@
* to the end.)
*/
void add_trigger(unsigned int seconds,
- const boost::shared_ptr<TTransport>& transport,
+ const stdcxx::shared_ptr<TTransport>& transport,
uint32_t write_len) {
TriggerInfo* info = new TriggerInfo(seconds, transport, write_len);
{
@@ -442,7 +460,7 @@
}
void set_trigger(unsigned int seconds,
- const boost::shared_ptr<TTransport>& transport,
+ const stdcxx::shared_ptr<TTransport>& transport,
uint32_t write_len) {
clear_triggers();
add_trigger(seconds, transport, write_len);
@@ -840,6 +858,19 @@
TEST_RW(CoupledFDTransports, 1024 * 16, 1, 1, rand4k, rand4k, fd_max_outstanding);
TEST_BLOCKING_BEHAVIOR(CoupledFDTransports);
+#else
+ // TPipe tests (WIN32 only)
+ TEST_RW(CoupledPipeTransports, 1024 * 1024, 0, 0);
+ TEST_RW(CoupledPipeTransports, 1024 * 256, rand4k, rand4k);
+ TEST_RW(CoupledPipeTransports, 1024 * 256, 167, 163);
+ TEST_RW(CoupledPipeTransports, 1024 * 16, 1, 1);
+
+ TEST_RW(CoupledPipeTransports, 1024 * 256, 0, 0, rand4k, rand4k);
+ TEST_RW(CoupledPipeTransports, 1024 * 256, rand4k, rand4k, rand4k, rand4k);
+ TEST_RW(CoupledPipeTransports, 1024 * 256, 167, 163, rand4k, rand4k);
+ TEST_RW(CoupledPipeTransports, 1024 * 16, 1, 1, rand4k, rand4k);
+
+ TEST_BLOCKING_BEHAVIOR(CoupledPipeTransports);
#endif //_WIN32
// TSocket tests
@@ -945,11 +976,11 @@
<< rChunkSizeGen.describe() << ", " << maxOutstanding << ")";
#if (BOOST_VERSION >= 105900)
- boost::function<void ()> test_func
+ stdcxx::function<void ()> test_func
#else
boost::unit_test::callback0<> test_func
#endif
- = apache::thrift::stdcxx::bind(test_rw<CoupledTransports>,
+ = stdcxx::bind(test_rw<CoupledTransports>,
totalSize,
wSizeGen,
rSizeGen,
@@ -995,7 +1026,7 @@
**************************************************************************/
struct global_fixture {
- boost::shared_ptr<apache::thrift::concurrency::Thread> alarmThread_;
+ stdcxx::shared_ptr<apache::thrift::concurrency::Thread> alarmThread_;
global_fixture() {
#if _WIN32
apache::thrift::transport::TWinsockSingleton::create();
diff --git a/lib/cpp/test/ZlibTest.cpp b/lib/cpp/test/ZlibTest.cpp
index 25db4b8..a4479eb 100644
--- a/lib/cpp/test/ZlibTest.cpp
+++ b/lib/cpp/test/ZlibTest.cpp
@@ -36,9 +36,8 @@
#include <cstddef>
#include <fstream>
#include <iostream>
-#include <thrift/cxxfunctional.h>
+#include <thrift/stdcxx.h>
-#include <boost/function.hpp>
#include <boost/random.hpp>
#include <boost/shared_array.hpp>
#include <boost/test/unit_test.hpp>
@@ -47,8 +46,9 @@
#include <thrift/transport/TBufferTransports.h>
#include <thrift/transport/TZlibTransport.h>
-using namespace std;
using namespace apache::thrift::transport;
+using apache::thrift::stdcxx::shared_ptr;
+using std::string;
boost::mt19937 rng;
@@ -147,8 +147,8 @@
*/
void test_write_then_read(const boost::shared_array<uint8_t> buf, uint32_t buf_len) {
- boost::shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
- boost::shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
+ shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
+ shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
zlib_trans->write(buf.get(), buf_len);
zlib_trans->finish();
@@ -166,8 +166,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.
- boost::shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
- boost::shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
+ shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
+ shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
zlib_trans->write(buf.get(), buf_len);
zlib_trans->finish();
string tmp_buf;
@@ -186,8 +186,8 @@
void test_incomplete_checksum(const boost::shared_array<uint8_t> buf, uint32_t buf_len) {
// Make sure we still get that "not complete" error if
// it really isn't complete.
- boost::shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
- boost::shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
+ shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
+ shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
zlib_trans->write(buf.get(), buf_len);
zlib_trans->finish();
string tmp_buf;
@@ -210,11 +210,11 @@
void test_read_write_mix(const boost::shared_array<uint8_t> buf,
uint32_t buf_len,
- const boost::shared_ptr<SizeGenerator>& write_gen,
- const boost::shared_ptr<SizeGenerator>& read_gen) {
+ const shared_ptr<SizeGenerator>& write_gen,
+ const shared_ptr<SizeGenerator>& read_gen) {
// Try it with a mix of read/write sizes.
- boost::shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
- boost::shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
+ shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
+ shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
unsigned int tot;
tot = 0;
@@ -249,8 +249,8 @@
void test_invalid_checksum(const boost::shared_array<uint8_t> buf, uint32_t buf_len) {
// Verify checksum checking.
- boost::shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
- boost::shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
+ shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
+ shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
zlib_trans->write(buf.get(), buf_len);
zlib_trans->finish();
string tmp_buf;
@@ -286,8 +286,8 @@
void test_write_after_flush(const boost::shared_array<uint8_t> buf, uint32_t buf_len) {
// write some data
- boost::shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
- boost::shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
+ shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
+ shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
zlib_trans->write(buf.get(), buf_len);
// call finish()
@@ -322,7 +322,7 @@
void test_no_write() {
// Verify that no data is written to the underlying transport if we
// never write data to the TZlibTransport.
- boost::shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
+ shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
{
// Create a TZlibTransport object, and immediately destroy it
// when it goes out of scope.
@@ -341,7 +341,8 @@
do { \
::std::ostringstream name_ss; \
name_ss << name << "-" << BOOST_STRINGIZE(_FUNC); \
- boost::function<void ()> test_func = ::apache::thrift::stdcxx::bind(_FUNC, ##__VA_ARGS__); \
+ ::apache::thrift::stdcxx::function<void ()> test_func = \
+ ::apache::thrift::stdcxx::bind(_FUNC, ##__VA_ARGS__); \
::boost::unit_test::test_case* tc \
= ::boost::unit_test::make_test_case(test_func, name_ss.str(), __FILE__, __LINE__); \
(suite)->add(tc); \
@@ -369,8 +370,8 @@
ADD_TEST_CASE(suite, name, test_invalid_checksum, buf, buf_len);
ADD_TEST_CASE(suite, name, test_write_after_flush, buf, buf_len);
- boost::shared_ptr<SizeGenerator> size_32k(new ConstantSizeGenerator(1 << 15));
- boost::shared_ptr<SizeGenerator> size_lognormal(new LogNormalSizeGenerator(20, 30));
+ shared_ptr<SizeGenerator> size_32k(new ConstantSizeGenerator(1 << 15));
+ 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);
ADD_TEST_CASE(suite,
name << "-lognormal-write",
@@ -400,8 +401,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.
- boost::shared_ptr<SizeGenerator> write_size_gen(new LogNormalSizeGenerator(20, 30));
- boost::shared_ptr<SizeGenerator> read_size_gen(new LogNormalSizeGenerator(20, 30));
+ shared_ptr<SizeGenerator> write_size_gen(new LogNormalSizeGenerator(20, 30));
+ shared_ptr<SizeGenerator> read_size_gen(new LogNormalSizeGenerator(20, 30));
ADD_TEST_CASE(suite,
name << "-lognormal-same-distribution",
test_read_write_mix,
diff --git a/lib/cpp/test/concurrency/RWMutexStarveTest.cpp b/lib/cpp/test/concurrency/RWMutexStarveTest.cpp
index 63d780f..849e078 100644
--- a/lib/cpp/test/concurrency/RWMutexStarveTest.cpp
+++ b/lib/cpp/test/concurrency/RWMutexStarveTest.cpp
@@ -19,22 +19,21 @@
// This is linked into the UnitTests test executable
-#include <boost/shared_ptr.hpp>
#include <boost/test/unit_test.hpp>
#include "thrift/concurrency/Mutex.h"
#include "thrift/concurrency/PosixThreadFactory.h"
+#include <thrift/stdcxx.h>
-using boost::shared_ptr;
+using apache::thrift::stdcxx::shared_ptr;
using boost::unit_test::test_suite;
using boost::unit_test::framework::master_test_suite;
using namespace apache::thrift::concurrency;
-using namespace std;
class Locker : public Runnable {
protected:
- Locker(boost::shared_ptr<ReadWriteMutex> rwlock, bool writer)
+ Locker(shared_ptr<ReadWriteMutex> rwlock, bool writer)
: rwlock_(rwlock), writer_(writer), started_(false), gotLock_(false), signaled_(false) {}
public:
@@ -57,7 +56,7 @@
void signal() { signaled_ = true; }
protected:
- boost::shared_ptr<ReadWriteMutex> rwlock_;
+ shared_ptr<ReadWriteMutex> rwlock_;
bool writer_;
volatile bool started_;
volatile bool gotLock_;
@@ -66,12 +65,12 @@
class Reader : public Locker {
public:
- Reader(boost::shared_ptr<ReadWriteMutex> rwlock) : Locker(rwlock, false) {}
+ Reader(shared_ptr<ReadWriteMutex> rwlock) : Locker(rwlock, false) {}
};
class Writer : public Locker {
public:
- Writer(boost::shared_ptr<ReadWriteMutex> rwlock) : Locker(rwlock, true) {}
+ Writer(shared_ptr<ReadWriteMutex> rwlock) : Locker(rwlock, true) {}
};
void test_starve(PosixThreadFactory::POLICY policy) {
@@ -81,15 +80,15 @@
PosixThreadFactory factory(policy);
factory.setDetached(false);
- boost::shared_ptr<ReadWriteMutex> rwlock(new NoStarveReadWriteMutex());
+ shared_ptr<ReadWriteMutex> rwlock(new NoStarveReadWriteMutex());
- 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<Reader> reader1(new Reader(rwlock));
+ shared_ptr<Reader> reader2(new Reader(rwlock));
+ shared_ptr<Writer> writer(new Writer(rwlock));
- boost::shared_ptr<Thread> treader1 = factory.newThread(reader1);
- boost::shared_ptr<Thread> treader2 = factory.newThread(reader2);
- boost::shared_ptr<Thread> twriter = factory.newThread(writer);
+ shared_ptr<Thread> treader1 = factory.newThread(reader1);
+ shared_ptr<Thread> treader2 = factory.newThread(reader2);
+ 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/concurrency/ThreadFactoryTests.h b/lib/cpp/test/concurrency/ThreadFactoryTests.h
index 4fc688c..bd6ed32 100644
--- a/lib/cpp/test/concurrency/ThreadFactoryTests.h
+++ b/lib/cpp/test/concurrency/ThreadFactoryTests.h
@@ -32,7 +32,7 @@
namespace concurrency {
namespace test {
-using boost::shared_ptr;
+using stdcxx::shared_ptr;
using namespace apache::thrift::concurrency;
/**
diff --git a/lib/cpp/test/concurrency/ThreadManagerTests.h b/lib/cpp/test/concurrency/ThreadManagerTests.h
index b5925ac..c07a21b 100644
--- a/lib/cpp/test/concurrency/ThreadManagerTests.h
+++ b/lib/cpp/test/concurrency/ThreadManagerTests.h
@@ -36,8 +36,8 @@
using namespace apache::thrift::concurrency;
-static std::deque<boost::shared_ptr<Runnable> > m_expired;
-static void expiredNotifier(boost::shared_ptr<Runnable> runnable)
+static std::deque<stdcxx::shared_ptr<Runnable> > m_expired;
+static void expiredNotifier(stdcxx::shared_ptr<Runnable> runnable)
{
m_expired.push_back(runnable);
}
diff --git a/lib/cpp/test/processor/EventLog.cpp b/lib/cpp/test/processor/EventLog.cpp
index 360307a..e3ddbcc 100644
--- a/lib/cpp/test/processor/EventLog.cpp
+++ b/lib/cpp/test/processor/EventLog.cpp
@@ -21,7 +21,6 @@
#include <stdarg.h>
#include <stdlib.h>
-using namespace std;
using namespace apache::thrift::concurrency;
namespace {
@@ -82,7 +81,7 @@
void EventLog::append(EventType type,
uint32_t connectionId,
uint32_t callId,
- const string& message) {
+ const std::string& message) {
Synchronized s(monitor_);
debug("%d <-- %u, %u, %s \"%s\"", id_, connectionId, callId, type, message.c_str());
diff --git a/lib/cpp/test/processor/Handlers.h b/lib/cpp/test/processor/Handlers.h
index 041fd3d..ad47229 100644
--- a/lib/cpp/test/processor/Handlers.h
+++ b/lib/cpp/test/processor/Handlers.h
@@ -29,7 +29,7 @@
class ParentHandler : virtual public ParentServiceIf {
public:
- ParentHandler(const boost::shared_ptr<EventLog>& log)
+ ParentHandler(const stdcxx::shared_ptr<EventLog>& log)
: triggerMonitor(&mutex_), generation_(0), wait_(false), log_(log) {}
int32_t incrementGeneration() {
@@ -136,7 +136,7 @@
int32_t generation_;
bool wait_;
std::vector<std::string> strings_;
- boost::shared_ptr<EventLog> log_;
+ stdcxx::shared_ptr<EventLog> log_;
};
#ifdef _WIN32
@@ -146,7 +146,7 @@
class ChildHandler : public ParentHandler, virtual public ChildServiceIf {
public:
- ChildHandler(const boost::shared_ptr<EventLog>& log) : ParentHandler(log), value_(0) {}
+ ChildHandler(const stdcxx::shared_ptr<EventLog>& log) : ParentHandler(log), value_(0) {}
int32_t setValue(const int32_t value) {
concurrency::Guard g(mutex_);
@@ -174,13 +174,13 @@
struct ConnContext {
public:
- ConnContext(boost::shared_ptr<protocol::TProtocol> in,
- boost::shared_ptr<protocol::TProtocol> out,
+ ConnContext(stdcxx::shared_ptr<protocol::TProtocol> in,
+ stdcxx::shared_ptr<protocol::TProtocol> out,
uint32_t id)
: input(in), output(out), id(id) {}
- boost::shared_ptr<protocol::TProtocol> input;
- boost::shared_ptr<protocol::TProtocol> output;
+ stdcxx::shared_ptr<protocol::TProtocol> input;
+ stdcxx::shared_ptr<protocol::TProtocol> output;
uint32_t id;
};
@@ -196,12 +196,12 @@
class ServerEventHandler : public server::TServerEventHandler {
public:
- ServerEventHandler(const boost::shared_ptr<EventLog>& log) : nextId_(1), log_(log) {}
+ ServerEventHandler(const stdcxx::shared_ptr<EventLog>& log) : nextId_(1), log_(log) {}
virtual void preServe() {}
- virtual void* createContext(boost::shared_ptr<protocol::TProtocol> input,
- boost::shared_ptr<protocol::TProtocol> output) {
+ virtual void* createContext(stdcxx::shared_ptr<protocol::TProtocol> input,
+ stdcxx::shared_ptr<protocol::TProtocol> output) {
ConnContext* context = new ConnContext(input, output, nextId_);
++nextId_;
log_->append(EventLog::ET_CONN_CREATED, context->id, 0);
@@ -209,8 +209,8 @@
}
virtual void deleteContext(void* serverContext,
- boost::shared_ptr<protocol::TProtocol> input,
- boost::shared_ptr<protocol::TProtocol> output) {
+ stdcxx::shared_ptr<protocol::TProtocol> input,
+ stdcxx::shared_ptr<protocol::TProtocol> output) {
ConnContext* context = reinterpret_cast<ConnContext*>(serverContext);
if (input != context->input) {
@@ -226,7 +226,7 @@
}
virtual void processContext(void* serverContext,
- boost::shared_ptr<transport::TTransport> transport) {
+ stdcxx::shared_ptr<transport::TTransport> transport) {
// TODO: We currently don't test the behavior of the processContext()
// calls. The various server implementations call processContext() at
// slightly different times, and it is too annoying to try and account for
@@ -251,12 +251,12 @@
protected:
uint32_t nextId_;
- boost::shared_ptr<EventLog> log_;
+ stdcxx::shared_ptr<EventLog> log_;
};
class ProcessorEventHandler : public TProcessorEventHandler {
public:
- ProcessorEventHandler(const boost::shared_ptr<EventLog>& log) : nextId_(1), log_(log) {}
+ ProcessorEventHandler(const stdcxx::shared_ptr<EventLog>& log) : nextId_(1), log_(log) {}
void* getContext(const char* fnName, void* serverContext) {
ConnContext* connContext = reinterpret_cast<ConnContext*>(serverContext);
@@ -329,7 +329,7 @@
}
uint32_t nextId_;
- boost::shared_ptr<EventLog> log_;
+ stdcxx::shared_ptr<EventLog> log_;
};
}
}
diff --git a/lib/cpp/test/processor/ProcessorTest.cpp b/lib/cpp/test/processor/ProcessorTest.cpp
index 486b8cf..c9e186f 100644
--- a/lib/cpp/test/processor/ProcessorTest.cpp
+++ b/lib/cpp/test/processor/ProcessorTest.cpp
@@ -40,15 +40,14 @@
#include "Handlers.h"
#include "gen-cpp/ChildService.h"
-using namespace std;
-using namespace boost;
using namespace apache::thrift;
using namespace apache::thrift::concurrency;
using namespace apache::thrift::protocol;
using namespace apache::thrift::server;
-using namespace apache::thrift::transport;
-
using namespace apache::thrift::test;
+using namespace apache::thrift::transport;
+using std::string;
+using std::vector;
/*
* Traits classes that encapsulate how to create various types of servers.
@@ -58,13 +57,13 @@
public:
typedef TSimpleServer ServerType;
- boost::shared_ptr<TSimpleServer> createServer(
- const boost::shared_ptr<TProcessor>& processor,
+ stdcxx::shared_ptr<TSimpleServer> createServer(
+ const stdcxx::shared_ptr<TProcessor>& processor,
uint16_t port,
- const boost::shared_ptr<TTransportFactory>& transportFactory,
- const boost::shared_ptr<TProtocolFactory>& protocolFactory) {
- boost::shared_ptr<TServerSocket> socket(new TServerSocket(port));
- return boost::shared_ptr<TSimpleServer>(
+ const stdcxx::shared_ptr<TTransportFactory>& transportFactory,
+ const stdcxx::shared_ptr<TProtocolFactory>& protocolFactory) {
+ stdcxx::shared_ptr<TServerSocket> socket(new TServerSocket(port));
+ return stdcxx::shared_ptr<TSimpleServer>(
new TSimpleServer(processor, socket, transportFactory, protocolFactory));
}
};
@@ -73,13 +72,13 @@
public:
typedef TThreadedServer ServerType;
- boost::shared_ptr<TThreadedServer> createServer(
- const boost::shared_ptr<TProcessor>& processor,
+ stdcxx::shared_ptr<TThreadedServer> createServer(
+ const stdcxx::shared_ptr<TProcessor>& processor,
uint16_t port,
- const boost::shared_ptr<TTransportFactory>& transportFactory,
- const boost::shared_ptr<TProtocolFactory>& protocolFactory) {
- boost::shared_ptr<TServerSocket> socket(new TServerSocket(port));
- return boost::shared_ptr<TThreadedServer>(
+ const stdcxx::shared_ptr<TTransportFactory>& transportFactory,
+ const stdcxx::shared_ptr<TProtocolFactory>& protocolFactory) {
+ stdcxx::shared_ptr<TServerSocket> socket(new TServerSocket(port));
+ return stdcxx::shared_ptr<TThreadedServer>(
new TThreadedServer(processor, socket, transportFactory, protocolFactory));
}
};
@@ -88,19 +87,19 @@
public:
typedef TThreadPoolServer ServerType;
- boost::shared_ptr<TThreadPoolServer> createServer(
- const boost::shared_ptr<TProcessor>& processor,
+ stdcxx::shared_ptr<TThreadPoolServer> createServer(
+ const stdcxx::shared_ptr<TProcessor>& processor,
uint16_t port,
- const boost::shared_ptr<TTransportFactory>& transportFactory,
- const boost::shared_ptr<TProtocolFactory>& protocolFactory) {
- boost::shared_ptr<TServerSocket> socket(new TServerSocket(port));
+ const stdcxx::shared_ptr<TTransportFactory>& transportFactory,
+ const stdcxx::shared_ptr<TProtocolFactory>& protocolFactory) {
+ stdcxx::shared_ptr<TServerSocket> socket(new TServerSocket(port));
- boost::shared_ptr<PlatformThreadFactory> threadFactory(new PlatformThreadFactory);
- boost::shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(8);
+ stdcxx::shared_ptr<PlatformThreadFactory> threadFactory(new PlatformThreadFactory);
+ stdcxx::shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(8);
threadManager->threadFactory(threadFactory);
threadManager->start();
- return boost::shared_ptr<TThreadPoolServer>(
+ return stdcxx::shared_ptr<TThreadPoolServer>(
new TThreadPoolServer(processor, socket, transportFactory, protocolFactory, threadManager));
}
};
@@ -109,11 +108,11 @@
public:
typedef TNonblockingServer ServerType;
- boost::shared_ptr<TNonblockingServer> createServer(
- const boost::shared_ptr<TProcessor>& processor,
+ stdcxx::shared_ptr<TNonblockingServer> createServer(
+ const stdcxx::shared_ptr<TProcessor>& processor,
uint16_t port,
- const boost::shared_ptr<TTransportFactory>& transportFactory,
- const boost::shared_ptr<TProtocolFactory>& protocolFactory) {
+ const stdcxx::shared_ptr<TTransportFactory>& transportFactory,
+ const stdcxx::shared_ptr<TProtocolFactory>& protocolFactory) {
// TNonblockingServer automatically uses TFramedTransport.
// Raise an exception if the supplied transport factory is not a
// TFramedTransportFactory
@@ -122,13 +121,14 @@
if (framedFactory == NULL) {
throw TException("TNonblockingServer must use TFramedTransport");
}
- boost::shared_ptr<TNonblockingServerSocket> socket(new TNonblockingServerSocket(port));
- boost::shared_ptr<PlatformThreadFactory> threadFactory(new PlatformThreadFactory);
- boost::shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(8);
+
+ stdcxx::shared_ptr<TNonblockingServerSocket> socket(new TNonblockingServerSocket(port));
+ stdcxx::shared_ptr<PlatformThreadFactory> threadFactory(new PlatformThreadFactory);
+ stdcxx::shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(8);
threadManager->threadFactory(threadFactory);
threadManager->start();
- return boost::shared_ptr<TNonblockingServer>(
+ return stdcxx::shared_ptr<TNonblockingServer>(
new TNonblockingServer(processor, protocolFactory, socket, threadManager));
}
};
@@ -137,11 +137,11 @@
public:
typedef TNonblockingServer ServerType;
- boost::shared_ptr<TNonblockingServer> createServer(
- const boost::shared_ptr<TProcessor>& processor,
+ stdcxx::shared_ptr<TNonblockingServer> createServer(
+ const stdcxx::shared_ptr<TProcessor>& processor,
uint16_t port,
- const boost::shared_ptr<TTransportFactory>& transportFactory,
- const boost::shared_ptr<TProtocolFactory>& protocolFactory) {
+ const stdcxx::shared_ptr<TTransportFactory>& transportFactory,
+ const stdcxx::shared_ptr<TProtocolFactory>& protocolFactory) {
// TNonblockingServer automatically uses TFramedTransport.
// Raise an exception if the supplied transport factory is not a
// TFramedTransportFactory
@@ -151,10 +151,10 @@
throw TException("TNonblockingServer must use TFramedTransport");
}
- boost::shared_ptr<TNonblockingServerSocket> socket(new TNonblockingServerSocket(port));
+ stdcxx::shared_ptr<TNonblockingServerSocket> socket(new TNonblockingServerSocket(port));
// Use a NULL ThreadManager
- boost::shared_ptr<ThreadManager> threadManager;
- return boost::shared_ptr<TNonblockingServer>(
+ stdcxx::shared_ptr<ThreadManager> threadManager;
+ return stdcxx::shared_ptr<TNonblockingServer>(
new TNonblockingServer(processor, protocolFactory, socket, threadManager));
}
};
@@ -244,48 +244,48 @@
processor_->setEventHandler(processorEventHandler_);
}
- boost::shared_ptr<TServer> createServer(uint16_t port) {
+ stdcxx::shared_ptr<TServer> createServer(uint16_t port) {
ServerTraits_ serverTraits;
return serverTraits.createServer(processor_, port, transportFactory_, protocolFactory_);
}
- boost::shared_ptr<TServerEventHandler> getServerEventHandler() { return serverEventHandler_; }
+ stdcxx::shared_ptr<TServerEventHandler> getServerEventHandler() { return serverEventHandler_; }
void bindSuccessful(uint16_t port) { port_ = port; }
uint16_t getPort() const { return port_; }
- const boost::shared_ptr<EventLog>& getLog() const { return log_; }
+ const stdcxx::shared_ptr<EventLog>& getLog() const { return log_; }
- const boost::shared_ptr<Handler>& getHandler() const { return handler_; }
+ const stdcxx::shared_ptr<Handler>& getHandler() const { return handler_; }
- boost::shared_ptr<Client> createClient() {
+ stdcxx::shared_ptr<Client> createClient() {
typedef typename ServiceTraits_::Protocol Protocol;
- boost::shared_ptr<TSocket> socket(new TSocket("127.0.0.1", port_));
- boost::shared_ptr<Transport_> transport(new Transport_(socket));
- boost::shared_ptr<Protocol> protocol(new Protocol(transport));
+ stdcxx::shared_ptr<TSocket> socket(new TSocket("127.0.0.1", port_));
+ stdcxx::shared_ptr<Transport_> transport(new Transport_(socket));
+ stdcxx::shared_ptr<Protocol> protocol(new Protocol(transport));
transport->open();
- boost::shared_ptr<Client> client(new Client(protocol));
+ stdcxx::shared_ptr<Client> client(new Client(protocol));
return client;
}
private:
uint16_t port_;
- boost::shared_ptr<EventLog> log_;
- boost::shared_ptr<Handler> handler_;
- boost::shared_ptr<Processor> processor_;
- boost::shared_ptr<TTransportFactory> transportFactory_;
- boost::shared_ptr<TProtocolFactory> protocolFactory_;
- boost::shared_ptr<TServerEventHandler> serverEventHandler_;
- boost::shared_ptr<TProcessorEventHandler> processorEventHandler_;
+ stdcxx::shared_ptr<EventLog> log_;
+ stdcxx::shared_ptr<Handler> handler_;
+ stdcxx::shared_ptr<Processor> processor_;
+ stdcxx::shared_ptr<TTransportFactory> transportFactory_;
+ stdcxx::shared_ptr<TProtocolFactory> protocolFactory_;
+ stdcxx::shared_ptr<TServerEventHandler> serverEventHandler_;
+ stdcxx::shared_ptr<TProcessorEventHandler> processorEventHandler_;
};
/**
* Check that there are no more events in the log
*/
-void checkNoEvents(const boost::shared_ptr<EventLog>& log) {
+void checkNoEvents(const stdcxx::shared_ptr<EventLog>& log) {
// Wait for an event with a very short timeout period. We don't expect
// anything to be present, so we will normally wait for the full timeout.
// On the other hand, a non-zero timeout is nice since it does give a short
@@ -299,7 +299,7 @@
*
* Returns the connection ID allocated by the server.
*/
-uint32_t checkNewConnEvents(const boost::shared_ptr<EventLog>& log) {
+uint32_t checkNewConnEvents(const stdcxx::shared_ptr<EventLog>& log) {
// Check for an ET_CONN_CREATED event
Event event = log->waitForEvent(2500);
BOOST_CHECK_EQUAL(EventLog::ET_CONN_CREATED, event.type);
@@ -314,7 +314,7 @@
/**
* Check for the events that should be logged when a connection is closed.
*/
-void checkCloseEvents(const boost::shared_ptr<EventLog>& log, uint32_t connId) {
+void checkCloseEvents(const stdcxx::shared_ptr<EventLog>& log, uint32_t connId) {
// Check for an ET_CONN_DESTROYED event
Event event = log->waitForEvent();
BOOST_CHECK_EQUAL(EventLog::ET_CONN_DESTROYED, event.type);
@@ -332,7 +332,7 @@
*
* Returns the call ID allocated by the server.
*/
-uint32_t checkCallHandlerEvents(const boost::shared_ptr<EventLog>& log,
+uint32_t checkCallHandlerEvents(const stdcxx::shared_ptr<EventLog>& log,
uint32_t connId,
EventType callType,
const string& callName) {
@@ -369,7 +369,7 @@
/**
* Check for the events that should be after a handler returns.
*/
-void checkCallPostHandlerEvents(const boost::shared_ptr<EventLog>& log,
+void checkCallPostHandlerEvents(const stdcxx::shared_ptr<EventLog>& log,
uint32_t connId,
uint32_t callId,
const string& callName) {
@@ -409,7 +409,7 @@
*
* Returns the call ID allocated by the server.
*/
-uint32_t checkCallEvents(const boost::shared_ptr<EventLog>& log,
+uint32_t checkCallEvents(const stdcxx::shared_ptr<EventLog>& log,
uint32_t connId,
EventType callType,
const string& callName) {
@@ -424,8 +424,8 @@
*/
template <typename State_>
-void testParentService(const boost::shared_ptr<State_>& state) {
- boost::shared_ptr<typename State_::Client> client = state->createClient();
+void testParentService(const stdcxx::shared_ptr<State_>& state) {
+ stdcxx::shared_ptr<typename State_::Client> client = state->createClient();
int32_t gen = client->getGeneration();
int32_t newGen = client->incrementGeneration();
@@ -446,8 +446,8 @@
}
template <typename State_>
-void testChildService(const boost::shared_ptr<State_>& state) {
- boost::shared_ptr<typename State_::Client> client = state->createClient();
+void testChildService(const stdcxx::shared_ptr<State_>& state) {
+ stdcxx::shared_ptr<typename State_::Client> client = state->createClient();
// Test calling some of the parent methids via the a child client
int32_t gen = client->getGeneration();
@@ -468,7 +468,7 @@
typedef ServiceState<ServerTraits, ParentServiceTraits<TemplateTraits> > State;
// Start the server
- boost::shared_ptr<State> state(new State);
+ stdcxx::shared_ptr<State> state(new State);
ServerThread serverThread(state, true);
testParentService(state);
@@ -479,7 +479,7 @@
typedef ServiceState<ServerTraits, ChildServiceTraits<TemplateTraits> > State;
// Start the server
- boost::shared_ptr<State> state(new State);
+ stdcxx::shared_ptr<State> state(new State);
ServerThread serverThread(state, true);
testParentService(state);
@@ -502,10 +502,10 @@
TBufferedTransport> State;
// Start the server
- boost::shared_ptr<State> state(new State);
+ stdcxx::shared_ptr<State> state(new State);
ServerThread serverThread(state, true);
- const boost::shared_ptr<EventLog>& log = state->getLog();
+ const stdcxx::shared_ptr<EventLog>& log = state->getLog();
// Make sure we're at the end of the log
checkNoEvents(log);
@@ -514,7 +514,7 @@
// Make sure createContext() is called after a connection has been
// established. We open a plain socket instead of creating a client.
- boost::shared_ptr<TSocket> socket(new TSocket("127.0.0.1", state->getPort()));
+ stdcxx::shared_ptr<TSocket> socket(new TSocket("127.0.0.1", state->getPort()));
socket->open();
// Make sure the proper events occurred after a new connection
@@ -592,7 +592,7 @@
checkNoEvents(log);
// Read the response header
- std::string responseName;
+ string responseName;
int32_t responseSeqid = 0;
apache::thrift::protocol::TMessageType responseType;
protocol.readMessageBegin(responseName, responseType, responseSeqid);
@@ -635,19 +635,19 @@
typedef ServiceState<ServerTraits, ChildServiceTraits<TemplateTraits> > State;
// Start the server
- boost::shared_ptr<State> state(new State);
+ stdcxx::shared_ptr<State> state(new State);
ServerThread serverThread(state, true);
- const boost::shared_ptr<EventLog>& log = state->getLog();
+ const stdcxx::shared_ptr<EventLog>& log = state->getLog();
// Create a client
- boost::shared_ptr<typename State::Client> client1 = state->createClient();
+ stdcxx::shared_ptr<typename State::Client> client1 = state->createClient();
// Make sure the expected events were logged
uint32_t client1Id = checkNewConnEvents(log);
// Create a second client
- boost::shared_ptr<typename State::Client> client2 = state->createClient();
+ stdcxx::shared_ptr<typename State::Client> client2 = state->createClient();
// Make sure the expected events were logged
uint32_t client2Id = checkNewConnEvents(log);
@@ -683,13 +683,13 @@
typedef ServiceState<ServerTraits, ChildServiceTraits<TemplateTraits> > State;
// Start the server
- boost::shared_ptr<State> state(new State);
+ stdcxx::shared_ptr<State> state(new State);
ServerThread serverThread(state, true);
- const boost::shared_ptr<EventLog>& log = state->getLog();
+ const stdcxx::shared_ptr<EventLog>& log = state->getLog();
// Create a client
- boost::shared_ptr<typename State::Client> client = state->createClient();
+ stdcxx::shared_ptr<typename State::Client> client = state->createClient();
uint32_t connId = checkNewConnEvents(log);
// Make a oneway call
@@ -735,13 +735,13 @@
typedef ServiceState<ServerTraits, ChildServiceTraits<TemplateTraits> > State;
// Start the server
- boost::shared_ptr<State> state(new State);
+ stdcxx::shared_ptr<State> state(new State);
ServerThread serverThread(state, true);
- const boost::shared_ptr<EventLog>& log = state->getLog();
+ const stdcxx::shared_ptr<EventLog>& log = state->getLog();
// Create a client
- boost::shared_ptr<typename State::Client> client = state->createClient();
+ stdcxx::shared_ptr<typename State::Client> client = state->createClient();
uint32_t connId = checkNewConnEvents(log);
// Send the exceptionWait() call
@@ -768,8 +768,8 @@
} catch (const MyError& e) {
BOOST_CHECK_EQUAL(message, e.message);
// Check if std::exception::what() is handled properly
- size_t message_pos = std::string(e.what()).find("TException - service has thrown: MyError");
- BOOST_CHECK_NE(message_pos, std::string::npos);
+ size_t message_pos = string(e.what()).find("TException - service has thrown: MyError");
+ BOOST_CHECK_NE(message_pos, string::npos);
}
// Now we should see the events for a normal call finish
@@ -790,13 +790,13 @@
typedef ServiceState<ServerTraits, ChildServiceTraits<TemplateTraits> > State;
// Start the server
- boost::shared_ptr<State> state(new State);
+ stdcxx::shared_ptr<State> state(new State);
ServerThread serverThread(state, true);
- const boost::shared_ptr<EventLog>& log = state->getLog();
+ const stdcxx::shared_ptr<EventLog>& log = state->getLog();
// Create a client
- boost::shared_ptr<typename State::Client> client = state->createClient();
+ stdcxx::shared_ptr<typename State::Client> client = state->createClient();
uint32_t connId = checkNewConnEvents(log);
// Send the unexpectedExceptionWait() call
@@ -912,7 +912,7 @@
// For now, it is known not to work correctly with TProcessorEventHandler.
#ifdef BOOST_TEST_DYN_LINK
bool init_unit_test_suite() {
- unit_test::framework::master_test_suite().p_name.value = "ProcessorTest";
+ ::boost::unit_test::framework::master_test_suite().p_name.value = "ProcessorTest";
return true;
}
@@ -920,10 +920,10 @@
return ::boost::unit_test::unit_test_main(&init_unit_test_suite,argc,argv);
}
#else
-unit_test::test_suite* init_unit_test_suite(int argc, char* argv[]) {
+::boost::unit_test::test_suite* init_unit_test_suite(int argc, char* argv[]) {
THRIFT_UNUSED_VARIABLE(argc);
THRIFT_UNUSED_VARIABLE(argv);
- unit_test::framework::master_test_suite().p_name.value = "ProcessorTest";
+ ::boost::unit_test::framework::master_test_suite().p_name.value = "ProcessorTest";
return NULL;
}
#endif
diff --git a/lib/cpp/test/processor/ServerThread.cpp b/lib/cpp/test/processor/ServerThread.cpp
index 009c4c6..e752d5e 100644
--- a/lib/cpp/test/processor/ServerThread.cpp
+++ b/lib/cpp/test/processor/ServerThread.cpp
@@ -130,7 +130,7 @@
serverState_->bindSuccessful(port_);
// Set the real server event handler (replacing ourself)
- boost::shared_ptr<server::TServerEventHandler> serverEventHandler
+ stdcxx::shared_ptr<server::TServerEventHandler> serverEventHandler
= serverState_->getServerEventHandler();
server_->setServerEventHandler(serverEventHandler);
diff --git a/lib/cpp/test/processor/ServerThread.h b/lib/cpp/test/processor/ServerThread.h
index 3803e7e..21c3b60 100644
--- a/lib/cpp/test/processor/ServerThread.h
+++ b/lib/cpp/test/processor/ServerThread.h
@@ -43,7 +43,7 @@
* If the server returned fails to bind to the specified port when serve() is
* called on it, createServer() may be called again on a different port.
*/
- virtual boost::shared_ptr<server::TServer> createServer(uint16_t port) = 0;
+ virtual stdcxx::shared_ptr<server::TServer> createServer(uint16_t port) = 0;
/**
* Get the TServerEventHandler to set on the server.
@@ -52,8 +52,8 @@
* start serving traffic. It is invoked from the server thread, rather than
* the main thread.
*/
- virtual boost::shared_ptr<server::TServerEventHandler> getServerEventHandler() {
- return boost::shared_ptr<server::TServerEventHandler>();
+ virtual stdcxx::shared_ptr<server::TServerEventHandler> getServerEventHandler() {
+ return stdcxx::shared_ptr<server::TServerEventHandler>();
}
/**
@@ -70,7 +70,7 @@
*/
class ServerThread {
public:
- ServerThread(const boost::shared_ptr<ServerState>& state, bool autoStart)
+ ServerThread(const stdcxx::shared_ptr<ServerState>& state, bool autoStart)
: port_(0),
running_(false),
serving_(false),
@@ -116,7 +116,7 @@
void run();
void preServe();
- boost::shared_ptr<Helper> helper_;
+ stdcxx::shared_ptr<Helper> helper_;
uint16_t port_;
bool running_;
@@ -124,9 +124,9 @@
bool error_;
concurrency::Monitor serverMonitor_;
- boost::shared_ptr<ServerState> serverState_;
- boost::shared_ptr<server::TServer> server_;
- boost::shared_ptr<concurrency::Thread> thread_;
+ stdcxx::shared_ptr<ServerState> serverState_;
+ stdcxx::shared_ptr<server::TServer> server_;
+ stdcxx::shared_ptr<concurrency::Thread> thread_;
};
}
}
diff --git a/lib/cpp/test/qt/TQTcpServerTest.cpp b/lib/cpp/test/qt/TQTcpServerTest.cpp
index 422d771..8a327aa 100644
--- a/lib/cpp/test/qt/TQTcpServerTest.cpp
+++ b/lib/cpp/test/qt/TQTcpServerTest.cpp
@@ -8,12 +8,12 @@
#include <QThread>
#ifndef Q_MOC_RUN
- #include <boost/smart_ptr.hpp>
+ #include "thrift/stdcxx.h"
#include "thrift/protocol/TBinaryProtocol.h"
#include "thrift/async/TAsyncProcessor.h"
#include "thrift/qt/TQTcpServer.h"
#include "thrift/qt/TQIODeviceTransport.h"
-
+
#include "gen-cpp/ParentService.h"
#endif
@@ -21,25 +21,25 @@
struct AsyncHandler : public test::ParentServiceCobSvIf {
std::vector<std::string> strings;
- virtual void addString(tcxx::function<void()> cob, const std::string& s) {
+ virtual void addString(stdcxx::function<void()> cob, const std::string& s) {
strings.push_back(s);
cob();
}
- virtual void getStrings(tcxx::function<void(std::vector<std::string> const& _return)> cob) {
+ virtual void getStrings(stdcxx::function<void(std::vector<std::string> const& _return)> cob) {
cob(strings);
}
// Overrides not used in this test
- virtual void incrementGeneration(tcxx::function<void(int32_t const& _return)> cob) {}
- virtual void getGeneration(tcxx::function<void(int32_t const& _return)> cob) {}
- virtual void getDataWait(tcxx::function<void(std::string const& _return)> cob,
+ virtual void incrementGeneration(stdcxx::function<void(int32_t const& _return)> cob) {}
+ virtual void getGeneration(stdcxx::function<void(int32_t const& _return)> cob) {}
+ virtual void getDataWait(stdcxx::function<void(std::string const& _return)> cob,
const int32_t length) {}
- virtual void onewayWait(tcxx::function<void()> cob) {}
+ virtual void onewayWait(stdcxx::function<void()> cob) {}
virtual void exceptionWait(
- tcxx::function<void()> cob,
- tcxx::function<void(::apache::thrift::TDelayedException* _throw)> /* exn_cob */,
+ stdcxx::function<void()> cob,
+ stdcxx::function<void(::apache::thrift::TDelayedException* _throw)> /* exn_cob */,
const std::string& message) {}
- virtual void unexpectedExceptionWait(tcxx::function<void()> cob, const std::string& message) {}
+ virtual void unexpectedExceptionWait(stdcxx::function<void()> cob, const std::string& message) {}
};
class TQTcpServerTest : public QObject {
@@ -51,18 +51,18 @@
void test_communicate();
private:
- boost::shared_ptr<QThread> serverThread;
- boost::shared_ptr<async::TQTcpServer> server;
- boost::shared_ptr<test::ParentServiceClient> client;
+ stdcxx::shared_ptr<QThread> serverThread;
+ stdcxx::shared_ptr<async::TQTcpServer> server;
+ stdcxx::shared_ptr<test::ParentServiceClient> client;
};
void TQTcpServerTest::initTestCase() {
// setup server
- boost::shared_ptr<QTcpServer> serverSocket = boost::make_shared<QTcpServer>();
+ stdcxx::shared_ptr<QTcpServer> serverSocket = stdcxx::make_shared<QTcpServer>();
server.reset(new async::TQTcpServer(serverSocket,
- boost::make_shared<test::ParentServiceAsyncProcessor>(
- boost::make_shared<AsyncHandler>()),
- boost::make_shared<protocol::TBinaryProtocolFactory>()));
+ stdcxx::make_shared<test::ParentServiceAsyncProcessor>(
+ stdcxx::make_shared<AsyncHandler>()),
+ stdcxx::make_shared<protocol::TBinaryProtocolFactory>()));
QVERIFY(serverSocket->listen(QHostAddress::LocalHost));
int port = serverSocket->serverPort();
QVERIFY(port > 0);
@@ -74,9 +74,9 @@
serverThread->start();
// setup client
- boost::shared_ptr<QTcpSocket> socket = boost::make_shared<QTcpSocket>();
- client.reset(new test::ParentServiceClient(boost::make_shared<protocol::TBinaryProtocol>(
- boost::make_shared<transport::TQIODeviceTransport>(socket))));
+ stdcxx::shared_ptr<QTcpSocket> socket = stdcxx::make_shared<QTcpSocket>();
+ client.reset(new test::ParentServiceClient(stdcxx::make_shared<protocol::TBinaryProtocol>(
+ stdcxx::make_shared<transport::TQIODeviceTransport>(socket))));
socket->connectToHost(QHostAddress::LocalHost, port);
QVERIFY(socket->waitForConnected());
}