TransportTCPPtr TransportTCP::accept()
{
ROS_ASSERT(is_server_);
sockaddr client_address;
socklen_t len = sizeof(client_address);
int new_sock = ::accept(sock_, (sockaddr *)&client_address, &len);
if (new_sock >= 0)
{
ROSCPP_LOG_DEBUG("Accepted connection on socket [%d], new socket [%d]", sock_, new_sock);
TransportTCPPtr transport(new TransportTCP(poll_set_, flags_));
if (!transport->setSocket(new_sock))
{
ROS_ERROR("Failed to set socket on transport for socket %d", new_sock);
}
return transport;
}
else
{
ROS_ERROR("accept() on socket [%d] failed with error [%s]", sock_, last_socket_error_string());
}
return TransportTCPPtr();
}
void f_thrift_protocol_write_binary(CObjRef transportobj, const String& method_name,
int64_t msgtype, CObjRef request_struct,
int seqid, bool strict_write) {
PHPOutputTransport transport(transportobj);
if (strict_write) {
int32_t version = VERSION_1 | msgtype;
transport.writeI32(version);
transport.writeString(method_name.data(), method_name.size());
transport.writeI32(seqid);
} else {
transport.writeString(method_name.data(), method_name.size());
transport.writeI8(msgtype);
transport.writeI32(seqid);
}
Variant spec = HHVM_FN(hphp_get_static_property)(
request_struct->o_getClassName(),
s_TSPEC,
false);
binary_serialize_spec(request_struct, transport, spec.toArray());
transport.flush();
}
bool uwsgi_handler::handle_request() {
// Do something with the url for example
// const std::string& url = request().var("REQUEST_URI");
// Or print all incoming variables
// request().print_vars();
typedef tasks::net::uwsgi_thrift_transport<tasks::net::http_response> transport_type;
typedef apache::thrift::protocol::TBinaryProtocol protocol_type;
boost::shared_ptr<transport_type> transport(new transport_type(response_p()));
boost::shared_ptr<protocol_type> protocol(new protocol_type(transport));
tasks::tools::thrift_server_writer<id_name, transport_type, protocol_type> writer("lookup", transport, protocol);
id_name m;
m.id = 33;
m.name = "testtest";
writer.write(m);
// Now send back a response
response().set_status("200 OK");
response().set_header("Content-Type", "application/x-thrift");
send_response();
stats::inc_req();
return true;
}
int main(int argc, char** argv)
{
QApplication application(argc,argv);
ros::init(argc, argv, "pcl_view");
ros::NodeHandle n;
ros::Rate loop_rate(100);
ROS_INFO("Start");
CloudMaker *filter = new Filter();
Viewer *viewer = new Viewer();
viewer->setFPSIsDisplayed(true);
viewer->setFilter(filter);
viewer->setWindowTitle("animation");
image_transport::ImageTransport transport(n);
image_transport::CameraSubscriber depth_sub = transport.subscribeCamera("/camera/depth/image_raw", 1,
&Filter::depthCb, filter);
viewer->show();
return application.exec();
}
int ModuleSpanningTree::OnStats(char statschar, userrec* user, string_list &results)
{
if ((statschar == 'c') || (statschar == 'n'))
{
for (unsigned int i = 0; i < Utils->LinkBlocks.size(); i++)
{
results.push_back(std::string(ServerInstance->Config->ServerName)+" 213 "+user->nick+" "+statschar+" *@"+(Utils->LinkBlocks[i].HiddenFromStats ? "<hidden>" : Utils->LinkBlocks[i].IPAddr)+" * "+Utils->LinkBlocks[i].Name.c_str()+" "+ConvToStr(Utils->LinkBlocks[i].Port)+" "+(Utils->LinkBlocks[i].Hook.empty() ? "plaintext" : Utils->LinkBlocks[i].Hook)+" "+(Utils->LinkBlocks[i].AutoConnect ? 'a' : '-')+'s');
if (statschar == 'c')
results.push_back(std::string(ServerInstance->Config->ServerName)+" 244 "+user->nick+" H * * "+Utils->LinkBlocks[i].Name.c_str());
}
results.push_back(std::string(ServerInstance->Config->ServerName)+" 219 "+user->nick+" "+statschar+" :End of /STATS report");
ServerInstance->SNO->WriteToSnoMask('t',"%s '%c' requested by %s (%s@%s)",(!strcmp(user->server,ServerInstance->Config->ServerName) ? "Stats" : "Remote stats"),statschar,user->nick,user->ident,user->host);
return 1;
}
if (statschar == 'p')
{
/* show all server ports, after showing client ports. -- w00t */
for (unsigned int i = 0; i < Utils->Bindings.size(); i++)
{
std::string ip = Utils->Bindings[i]->IP;
if (ip.empty())
ip = "*";
std::string transport("plaintext");
if (Utils->Bindings[i]->GetHook())
transport = InspSocketNameRequest(this, Utils->Bindings[i]->GetHook()).Send();
results.push_back(ConvToStr(ServerInstance->Config->ServerName) + " 249 "+user->nick+" :" + ip + ":" + ConvToStr(Utils->Bindings[i]->port)+
" (server, " + transport + ")");
}
}
return 0;
}
void rotate(GLfloat x, GLfloat y, GLfloat z){
transport(-x_center[now], -y_center[now], -z_center[now], NO_UPDATE);
GLfloat M[3][4][4] = {0};
for(int i = 0; i < 3; ++i)
for(int j = 0; j < 4; ++j)
M[i][j][j] = 1;
const double PI = std::atan(1.0);
const double ANGLE_X = PI * x / 180.0;
const double ANGLE_Y = PI * y / 180.0;
const double ANGLE_Z = PI * z / 180.0;
const GLfloat COS[] = {
std::cos(ANGLE_X),
std::cos(ANGLE_Y),
std::cos(ANGLE_Z)
};
const GLfloat SIN[] = {
std::sin(ANGLE_X),
std::sin(ANGLE_Y),
std::sin(ANGLE_Z)
};
for(int i = 0; i < 3; ++i){
if (i == 0){
M[i][1][1] = M[i][2][2] = COS[i];
M[i][1][2] = -SIN[i];
M[i][2][1] = SIN[i];
}
else if (i == 1){
M[i][0][0] = M[i][2][2] = COS[i];
M[i][0][2] = -SIN[i];
M[i][2][0] = SIN[i];
}
else {
M[i][0][0] = M[i][1][1] = COS[i];
M[i][0][1] = -SIN[i];
M[i][1][0] = SIN[i];
}
GLfloat I[4][4] = {{1,0,0,0},{0,1,0,0},{0,0,1,0},{0,0,0,1}};
multiMatrix(geoMatrix[now], M[i], geoMatrix[now]);
multiple_all_matrix(M[i]);
copyMatrix(aMVP[now], I);
}
transport(x_center[now], y_center[now], z_center[now], NO_UPDATE);
}
int main(int argc, char **argv)
{
typedef my::MyServiceClient client_type;
typedef tht::TSocket socket_type;
typedef tht::TFramedTransport transp_type;
typedef thp::TBinaryProtocol prot_type;
typedef boost::shared_ptr<tht::TSocket> socket_ptr_type;
typedef boost::shared_ptr<tht::TTransport> transp_ptr_type;
typedef boost::shared_ptr<thp::TProtocol> prot_ptr_type;
const int port_num = 9999;
const std::string address("localhost");
socket_ptr_type socket (new socket_type(address, port_num));
transp_ptr_type transport(new transp_type(socket) );
prot_ptr_type protocol (new prot_type(transport));
client_type client(protocol);
try
{
transport->open();
my::MyValue res;
std::string key1("key-1");
std::string val1("value-1");
client.myPut(res, key1, val1);
std::cout
<< std::boolalpha
<< "response: "
<< '(' << res.exists << ',' << res.content << ')'
<< std::endl;
client.myGet(res, key1);
std::cout
<< std::boolalpha
<< "response: "
<< '(' << res.exists << ',' << res.content << ')'
<< std::endl;
}
catch(const thr::TException& e)
{
std::cerr << "error: " << e.what() << std::endl;
}
catch(const std::exception& e)
{
std::cerr << "error: " << e.what() << std::endl;
}
catch(...)
{
std::cerr << "error: " << "unknown" << std::endl;
}
transport->close();
return 0;
}
LucidaServiceClient *TClient::creatLucidaClient(string host, int port) {
boost::shared_ptr<TTransport> socket(new TSocket(host, port));
boost::shared_ptr<TTransport> transport(new TBufferedTransport(socket));
boost::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));
LucidaServiceClient *client = new LucidaServiceClient(protocol);
transport->open();
return client;
}
void XmlRPC::setTimeout(int Timeout){
m_timeout = Timeout;
xmlrpc_c::clientXmlTransport_curl transport(
xmlrpc_c::clientXmlTransport_curl::constrOpt()
.timeout(m_timeout) // milliseconds
);
}
SchedulerServiceClient *TClient::creatSchedulerClient(string host, int port) {
boost::shared_ptr<TSocket> socket(new TSocket(host, port));
boost::shared_ptr<TTransport> transport(new TFramedTransport(socket));
boost::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));
SchedulerServiceClient *client = new SchedulerServiceClient(protocol);
this->transport = transport;
transport->open();
return client;
}
void
FullStateSenderPlayerV8::sendBall()
{
serializer().serializeFSBall( transport(),
stadium().ball().pos().x,
stadium().ball().pos().y,
stadium().ball().vel().x,
stadium().ball().vel().y );
}
static int setup_transport(void)
{
int rv;
rv = transport()->init(message_recv);
if (rv < 0) {
log_error("failed to init booth_transport %s", transport()->name);
goto out;
}
rv = booth_transport[TCP].init(NULL);
if (rv < 0) {
log_error("failed to init booth_transport[TCP]");
goto out;
}
out:
return rv;
}
XmlRPC::XmlRPC(std::string serverurl, int port, bool authrequired, int Timeout) : m_serverurl(serverurl), m_port(port), m_authrequired(authrequired), m_timeout(Timeout) {
xmlrpc_c::clientXmlTransport_curl transport(
xmlrpc_c::clientXmlTransport_curl::constrOpt()
.timeout(m_timeout) // milliseconds
);
m_authset = false;
}
void matrixInit(){
//printf("Matrix Initialization!!\n");
for(int j = 0; j < 4; ++j)
for(int k = 0; k < 4; ++k)
geoMatrix[now][j][k] = (j == k) ? 1 : 0;
transport(-x_center[now], -y_center[now], -z_center[now]);
scaleAll();
}
std::unique_ptr<TcpTransport> TcpTransport::NewTransport(std::unique_ptr<Socket> socket,
std::string* error) {
std::unique_ptr<TcpTransport> transport(new TcpTransport(std::move(socket)));
if (!transport->InitializeProtocol(error)) {
return nullptr;
}
return transport;
}
void
FullStateSenderPlayerV5::sendFullState()
{
static const char * playmode_string[] = PLAYMODE_STRINGS;
// send begining of FS
serializer().serializeFSBegin( transport(), stadium().time() );
if ( stadium().playmode() == PM_FreeKick_Left
&& stadium().ballCatcher() )
{
serializer().serializeFSPlayMode( transport(),
"goalie_catch_ball_l" );
}
else if ( stadium().playmode() == PM_FreeKick_Right
&& stadium().ballCatcher() )
{
serializer().serializeFSPlayMode( transport(),
"goalie_catch_ball_r" );
}
else
{
serializer().serializeFSPlayMode( transport(),
playmode_string[stadium().playmode()] );
}
serializer().serializeFSViewMode( transport(),
( self().highQuality()
? "high"
: "low" ),
( self().viewWidth() == rcss::pcom::NARROW
? "narrow"
: self().viewWidth() == rcss::pcom::WIDE
? "wide"
: "normal" ) );
sendSelf();
sendScore();
sendBall();
const Stadium::PlayerCont::const_iterator end = stadium().players().end();
for ( Stadium::PlayerCont::const_iterator p = stadium().players().begin();
p != end;
++p )
{
if ( ! (*p)->isEnabled() ) continue;
sendPlayer( *(*p) );
}
// send end of FS
serializer().serializeFSEnd( transport() );
transport() << std::ends << std::flush;
}
Variant HHVM_FUNCTION(thrift_protocol_read_binary_struct,
const Variant& transportobj,
const String& obj_typename) {
PHPInputTransport transport(transportobj.toObject());
Object ret_val = createObject(obj_typename);
Variant spec = HHVM_FN(hphp_get_static_property)(obj_typename, s_TSPEC,
false);
binary_deserialize_spec(ret_val, transport, spec.toArray());
return ret_val;
}
void Entity::strafe(float units) {
if(coll.checkCollision(this->areaID, (pos + side_vec * units))) {
pos += glm::vec4(glm::vec3(side_vec.x, 0, side_vec.z), 1.0) * units;
}
Transport_data td = coll.checkPortals(areaID, pos, (pos + side_vec * units));
if(td.new_areaID != -1) {
transport(td);
}
}
void
InitSenderPlayerV1::sendScore()
{
int our_score = self().team()->point();
int opp_score = 0;
if( self().side() == LEFT
&& stadium().teamRight().enabled() )
{
opp_score = stadium().teamRight().point();
}
else if( self().side() == RIGHT
&& stadium().teamLeft().enabled() )
{
opp_score = stadium().teamLeft().point();
}
serializer().serializeScore( transport(),
stadium().time(),
our_score,
opp_score );
transport() << std::ends << std::flush;
}
/*!
* \brief Open connection to Cassandra cluster
* \param db_id
*/
oac::CassandraClient* dbcassa_open(struct db_id* id)
{
try {
boost::shared_ptr<att::TSocket> socket(new att::TSocket(id->host, id->port));
boost::shared_ptr<att::TTransport> transport(new att::TFramedTransport (socket));
boost::shared_ptr<atp::TProtocol> protocol(new atp::TBinaryProtocol(transport));
socket->setConnTimeout(cassa_conn_timeout);
socket->setSendTimeout(cassa_send_timeout);
socket->setRecvTimeout(cassa_recv_timeout);
std::auto_ptr<oac::CassandraClient> cassa_client(new oac::CassandraClient(protocol));
transport->open();
if (!transport->isOpen()) {
LM_ERR("Failed to open transport to Cassandra\n");
return 0;
}
/* database name -> keyspace */
cassa_client->set_keyspace(id->database);
if(id->username && id->password) {
oac::AuthenticationRequest au_req;
std::map<std::string, std::string> cred;
cred.insert(std::pair<std::string, std::string>("username", id->username));
cred.insert(std::pair<std::string, std::string>("password", id->password));
au_req.credentials = cred;
try {
cassa_client->login(au_req);
} catch (const oac::AuthenticationException& autx) {
LM_ERR("Authentication failure: Credentials not valid, %s\n", autx.why.c_str());
} catch (const oac::AuthorizationException & auzx) {
LM_ERR("Authentication failure: Credentials not valid for the selected database, %s\n", auzx.why.c_str());
}
}
LM_DBG("Opened connection to Cassandra cluster %s:%d\n", id->host, id->port);
return cassa_client.release();
} catch (const oac::InvalidRequestException &irx) {
LM_ERR("Database does not exist %s, %s\n", id->database, irx.why.c_str());
} catch (const at::TException &tx) {
LM_ERR("Failed to open connection to Cassandra cluster %s:%d, %s\n",
id->database, id->port, tx.what());
} catch (const std::exception &ex) {
LM_ERR("Failed: %s\n", ex.what());
} catch (...) {
LM_ERR("Failed to open connection to Cassandra cluster\n");
}
return 0;
}
int main (void)
{
int towns_count, products_count;
inputTP(&towns_count, &products_count);
int graph[towns_count][towns_count];
int products[products_count][towns_count];
input(&towns_count, &products_count, &products , &graph);
transport(towns_count, products_count);
output(towns_count, products_count);
}
///* Computation the function phi used to find the Critical Rate in the Jamishidian decomposition
static double phi(ZCMarketData* ZCMarket, double r, double periodicity, double option_maturity, double contract_maturity, double SwaptionFixedRate, double a, double sigma)
{
int i, nb_payement;
double ci, sum,sum_der,ti;
double ZCPrice_T_ti;
double r0, x0, x;
Data data1, data2;
Omega om;
ZCPrice_T_ti = 0.;
r0=0.0; x0=0.0;
initial_short_rate(ZCMarket, &r0, &x0);
sum=0.;
sum_der=0.;
ci = periodicity * SwaptionFixedRate;
ti = option_maturity;
nb_payement = (int)((contract_maturity-option_maturity)/periodicity);
/* coefficients of P(0,T) */
bond_coeffs(ZCMarket, &data1, option_maturity, a, sigma, x0);
x = sqrt(r);
for(i=1; i<=nb_payement; i++)
{
ti += periodicity;
/* coefficients of P(0,S) */
bond_coeffs(ZCMarket, &data2, ti, a, sigma, x0);
/* omega distribution of P(T,S) */
transport(&om, data1, data2, a, sigma, x0);
ZCPrice_T_ti = exp(-(om.B*r + om.b*M_SQRT2*x + om.c));
sum += ci * ZCPrice_T_ti;
sum_der -= ci * ZCPrice_T_ti * (om.B + om.b/x);
}
sum += ZCPrice_T_ti;
sum_der -= ZCPrice_T_ti * (om.B + om.b/x);
return (sum-1.)/sum_der;
}
TransportUDPPtr TransportUDP::createOutgoing(std::string host, int port, int connection_id, int max_datagram_size)
{
ROS_ASSERT(is_server_);
TransportUDPPtr transport(new TransportUDP(poll_set_, flags_, max_datagram_size));
if (!transport->connect(host, port, connection_id))
{
ROS_ERROR("Failed to create outgoing connection");
return TransportUDPPtr();
}
return transport;
}
void
AudioSenderPlayerv1::sendCoachStdAudio( const rcss::clang::Msg & msg )
{
if ( coachStdPredicate( msg ) )
{
std::string name;
switch( msg.getSide() ) {
case LEFT:
name = OLCOACH_NAME_L;
break;
case RIGHT:
name = OLCOACH_NAME_R;
break;
default:
// don't know what we have here so don't send anything
return;
}
if ( msg.isSupported( listener().clangMinVer(),
listener().clangMaxVer() ) )
{
serializer().serializeCoachStdAudio( transport(),
msg.getTimeSend(),
name,
msg );
}
else
{
serializer().serializeCoachStdAudio( transport(),
msg.getTimeSend(),
name,
rcss::clang::UnsuppMsg() );
}
transport() << std::ends << std::flush;
}
}
void LibEventWorker::doJobImpl(LibEventJobPtr job, bool abort) {
job->stopTimer();
evhttp_request *request = job->request;
assert(m_opaque);
LibEventServer *server = (LibEventServer*)m_opaque;
LibEventTransport transport(server, request, m_id);
#ifdef _EVENT_USE_OPENSSL
if (evhttp_is_connection_ssl(job->request->evcon)) {
transport.setSSL();
}
#endif
bool error = true;
std::string errorMsg;
if (abort) {
transport.sendString("Service Unavailable", 503);
return;
}
try {
std::string cmd = transport.getCommand();
cmd = std::string("/") + cmd;
if (server->shouldHandle(cmd)) {
transport.onRequestStart(job->getStartTimer());
m_handler->handleRequest(&transport);
error = false;
} else {
transport.sendString("Not Found", 404);
return;
}
} catch (Exception &e) {
if (Server::StackTraceOnError) {
errorMsg = e.what();
} else {
errorMsg = e.getMessage();
}
} catch (std::exception &e) {
errorMsg = e.what();
} catch (...) {
errorMsg = "(unknown exception)";
}
if (error) {
if (RuntimeOption::ServerErrorMessage) {
transport.sendString(errorMsg, 500);
} else {
transport.sendString(RuntimeOption::FatalErrorMessage, 500);
}
}
}
void add_application(application app)
{
std::map<unsigned int, application>::iterator it
= apps.insert(std::make_pair(app.application_id, application())).first;
swap(app, it->second);
if(!it->second.transport_protocol_descriptor.empty()
&& !it->second.ginga_location_descriptor.empty())
{
typedef std::vector<char>::const_iterator iterator;
typedef gts::descriptors::transport_protocol_descriptor<iterator>
transport_protocol_descriptor;
typedef transport_protocol_descriptor::protocol_id_iterator
protocol_id_iterator;
typedef transport_protocol_descriptor::transport_protocol_label_iterator
transport_protocol_label_iterator;
typedef transport_protocol_descriptor::selector_byte_iterator
selector_byte_iterator;
transport_protocol_descriptor transport_protocol
(it->second.transport_protocol_descriptor.begin()
, it->second.transport_protocol_descriptor.end());
if(* ++transport_protocol.begin() == gts::constants::etsi::protocol_ids::object_carousel)
{
selector_byte_iterator selector_byte_it = gts::iterators::next<3>(transport_protocol.begin());
typedef transport_protocol_descriptor::object_carousel_transport object_carousel_transport;
object_carousel_transport transport(*selector_byte_it);
typedef object_carousel_transport::component_tag_iterator component_tag_iterator;
component_tag_iterator component_it = gts::iterators::next<4>(transport.begin());
std::cout << "=== Should filter component " << *component_it << std::endl;
boost::optional<unsigned int> pid = sections::pid_from_component_tag(*component_it);
if(pid)
{
dsmcc::start(it->second.dsmcc, *pid
, boost::bind(&application_download_finish
, it->second.application_id));
}
else
std::cout << "Couldn't find ES for component tag" << std::endl;
}
else
{
std::cout << "protocol id is " << * ++transport_protocol.begin() << std::endl;
}
}
else
{
std::cout << "transport_protocol is empty" << std::endl;
}
}
void
FullStateSenderPlayerV5::sendBall()
{
const float quantize_step = .001;
serializer().serializeFSBall( transport(),
Quantize( stadium().ball().pos().x,
quantize_step ),
Quantize( stadium().ball().pos().y,
quantize_step ),
Quantize( stadium().ball().vel().x,
quantize_step ),
Quantize( stadium().ball().vel().y,
quantize_step ) );
}
MulticastSession*
MulticastDataLink::find_or_create_session(MulticastPeer remote_peer)
{
ACE_GUARD_RETURN(ACE_SYNCH_RECURSIVE_MUTEX,
guard,
this->session_lock_,
0);
MulticastSessionMap::iterator it(this->sessions_.find(remote_peer));
if (it != this->sessions_.end()) {
MulticastSession_rch sess = it->second;
return sess._retn();
}
MulticastSession_rch session =
this->session_factory_->create(transport()->reactor(), transport()->reactor_owner(), this, remote_peer);
if (session.is_nil()) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: ")
ACE_TEXT("MulticastDataLink::find_or_create_session: ")
ACE_TEXT("failed to create session for remote peer: 0x%x!\n"),
remote_peer),
0);
}
std::pair<MulticastSessionMap::iterator, bool> pair = this->sessions_.insert(
MulticastSessionMap::value_type(remote_peer, session));
if (pair.first == this->sessions_.end()) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: ")
ACE_TEXT("MulticastDataLink::find_or_create_session: ")
ACE_TEXT("failed to insert session for remote peer: 0x%x!\n"),
remote_peer),
0);
}
return session._retn();
}
void
FullStateSenderPlayerV13::sendPlayer( const Player & p )
{
char side = ( p.team()->side() == LEFT ? 'l' : 'r' );
serializer().serializeFSPlayerBegin( transport(),
side,
p.unum(),
p.isGoalie(),
p.playerTypeId(),
p.pos().x,
p.pos().y,
p.vel().x,
p.vel().y,
Rad2Deg( p.angleBodyCommitted() ),
Rad2Deg( p.angleNeckCommitted() ) );
if ( p.arm().isPointing() )
{
rcss::geom::Vector2D arm_vec;
p.arm().getRelDest( rcss::geom::Vector2D( p.pos().x, p.pos().y ),
p.angleBodyCommitted() + p.angleNeckCommitted(),
arm_vec );
serializer().serializeFSPlayerArm( transport(),
arm_vec.getMag(),
arm_vec.getHead() );
}
serializer().serializeFSPlayerStamina( transport(),
p.stamina(),
p.effort(),
p.recovery(),
p.staminaCapacity() );
serializer().serializeFSPlayerState( transport(), p );
serializer().serializeFSPlayerEnd( transport() );
}
TEST(AsyncTransportTest, getSocketFromWrappedTransport) {
AsyncSocket::UniquePtr transport(new AsyncSocket());
auto transportAddr = transport.get();
test::MockAsyncTransport wrapped1;
test::MockAsyncTransport wrapped2;
EXPECT_CALL(wrapped2, getWrappedTransport())
.WillOnce(Return(&wrapped1));
EXPECT_CALL(wrapped1, getWrappedTransport())
.WillOnce(Return(transportAddr));
auto sock = wrapped2.getUnderlyingTransport<AsyncSocket>();
ASSERT_EQ(transportAddr, sock);
}
