int test_main(int argc, char **argv)
{
printTestHeader(__FILE__);
RCF::RcfInitDeinit rcfInitDeinit;
using namespace Test_General;
util::CommandLine::getSingleton().parse(argc, argv);
for (std::size_t i=0; i<RCF::getTransportFactories().size(); ++i)
{
RCF::TransportFactoryPtr transportFactoryPtr = RCF::getTransportFactories()[i];
RCF::TransportPair transports = transportFactoryPtr->createTransports();
RCF::ServerTransportPtr serverTransportPtr( transports.first );
RCF::ClientTransportAutoPtr clientTransportAutoPtr( *transports.second );
std::cout << transportFactoryPtr->desc() << std::endl;
RCF::RcfServer server(serverTransportPtr);
unsigned int numberOfTokens = 50;
unsigned int objectTimeoutS = 60;
RCF::ObjectFactoryServicePtr objectFactoryServicePtr( new RCF::ObjectFactoryService(numberOfTokens, objectTimeoutS) );
objectFactoryServicePtr->bind( (A::Calculator*) 0, (A::B::Calculator**) 0);
objectFactoryServicePtr->bind( (A::X*) 0, (A::B::X**) 0);
server.addService( RCF::ServicePtr(objectFactoryServicePtr) );
A::B::Calculator calculator;
server.bind( (A::Calculator*) 0, calculator);
A::B::X x;
server.bind( (A::X*) 0, x);
A::B::Y y;
server.bind( (A::Y*) 0, y);
A::B::Z z;
server.bind( (A::Z*) 0, z);
server.start();
int nReps = 2;
boost::shared_ptr<RCF::I_ClientTransport> clientTransportPtr(
clientTransportAutoPtr->clone().release());
testCalculatorClientReps(clientTransportPtr, nReps);
server.stop();
}
return 0;
}
int test_main(int argc, char **argv)
{
printTestHeader(__FILE__);
RCF::RcfInitDeinit rcfInitDeinit;
using namespace Test_InitDeinit;
util::CommandLine::getSingleton().parse(argc, argv);
RCF::deinit();
for (unsigned int i=0; i<RCF::getTransportFactories().size(); ++i)
{
RCF::init();
{
RCF::TransportFactoryPtr transportFactoryPtr = RCF::getTransportFactories()[i];
RCF::TransportPair transports = transportFactoryPtr->createTransports();
RCF::ServerTransportPtr serverTransportPtr( transports.first );
RCF::ClientTransportAutoPtr clientTransportAutoPtr( *transports.second );
std::cout << transportFactoryPtr->desc() << std::endl;
std::string s0 = "something special";
Echo echo;
RCF::RcfServer server( boost::dynamic_pointer_cast<RCF::I_Service>(serverTransportPtr) );
server.start();
server.bind( (I_Echo*) 0, echo);
std::string s = RcfClient<I_Echo>( clientTransportAutoPtr->clone() ).echo(s0);
RCF_CHECK_EQ(s0 , s);
}
RCF::deinit();
}
RCF::init();
RCF::init();
RCF::deinit();
RCF::deinit();
RCF::init();
return 0;
}
int test_main(int argc, char **argv)
{
printTestHeader(__FILE__);
RCF::RcfInitDeinit rcfInitDeinit;
using namespace Test_ErrorReporting;
util::CommandLine::getSingleton().parse(argc, argv);
// Check error translation.
int rcfError = RCF::RcfError_ClientCancel;
RCF::Error err(rcfError);
RCF::Exception e(err);
std::string eWhat = e.what();
std::string errorMsg = RCF::getErrorString(rcfError);
// Assuming here that RcfError_ClientCancel has no replacements...
RCF_CHECK( eWhat.find(errorMsg) != std::string::npos );
{
RCF::Error err(RCF::_RcfError_ClientConnectTimeout(5000, ""));
std::string s = err.getErrorString();
RCF_CHECK( s.find("5000") != std::string::npos );
}
for (unsigned int i=0; i<RCF::getTransportFactories().size(); ++i)
{
RCF::TransportFactoryPtr transportFactoryPtr = RCF::getTransportFactories()[i];
RCF::TransportPair transports = transportFactoryPtr->createTransports();
RCF::ServerTransportPtr serverTransportPtr( transports.first );
RCF::ClientTransportAutoPtr clientTransportAutoPtr( *transports.second );
std::cout << transportFactoryPtr->desc() << std::endl;
serverTransportPtr->setMaxMessageLength(1000*10);
clientTransportAutoPtr->setMaxMessageLength(1000*10);
std::string s0 = "something special";
Echo echo;
RCF::RcfServer server( serverTransportPtr );
server.start();
server.bind( (I_Echo *) 0, echo);
//***********************************************
// message size errors
// no error
{
serverTransportPtr->setMaxMessageLength(1000*10);
clientTransportAutoPtr->setMaxMessageLength(1000*10);
RcfClient<I_Echo> client( clientTransportAutoPtr->clone() );
RCF_CHECK_EQ(client.putString(makeString(50)) , 50);
std::string s = client.getString(50);
RCF_CHECK_EQ(s.size() , 50);
}
// try to trigger client transport send error
{
serverTransportPtr->setMaxMessageLength(1000*10);
clientTransportAutoPtr->setMaxMessageLength(100);
RcfClient<I_Echo>( clientTransportAutoPtr->clone() ).putString(makeString(500));
RCF_CHECK_OK();
}
// trigger client transport receive error
{
serverTransportPtr->setMaxMessageLength(1000*10);
clientTransportAutoPtr->setMaxMessageLength(500);
try
{
RcfClient<I_Echo>( clientTransportAutoPtr->clone() ).getString(500);
RCF_CHECK_FAIL();
}
catch(RCF::Exception &e)
{
RCF_CHECK_OK();
RCF_CHECK_EQ(e.getErrorId() , RCF::RcfError_ClientMessageLength );
}
}
// trigger server transport receive error
{
serverTransportPtr->setMaxMessageLength(500);
clientTransportAutoPtr->setMaxMessageLength(1000*10);
try
{
RcfClient<I_Echo>( clientTransportAutoPtr->clone() ).putString(makeString(500));
RCF_CHECK_FAIL();
}
catch(RCF::RemoteException &e)
{
RCF_CHECK_OK();
RCF_CHECK_EQ(e.getErrorId() , RCF::RcfError_ServerMessageLength );
}
catch(RCF::Exception &e)
{
if (typeid(*serverTransportPtr) == typeid(RCF::Win32NamedPipeServerTransport))
{
// TODO: named pipe server transport currently doesn't report
// message length errors.
}
else
{
// server did a hard close, we didn't get any error info
RCF_CHECK_FAIL();
}
}
}
// try to trigger server transport send error
{
serverTransportPtr->setMaxMessageLength(500);
clientTransportAutoPtr->setMaxMessageLength(1000*10);
RcfClient<I_Echo>( clientTransportAutoPtr->clone() ).getString(500);
RCF_CHECK_OK();
}
//************************************************
// serialization errors
serverTransportPtr->setMaxMessageLength(1000*10);
clientTransportAutoPtr->setMaxMessageLength(1000*10);
// no errors
A a;
RcfClient<I_Echo>( clientTransportAutoPtr->clone() ).putA(a);
a = RcfClient<I_Echo>( clientTransportAutoPtr->clone() ).getA(0);
// outbound client serialization error
try
{
RcfClient<I_Echo>( clientTransportAutoPtr->clone() ).putA( A(1) );
RCF_CHECK_FAIL();
}
catch(const RCF::SerializationException &e)
{
std::string msg = e.what();
RCF_CHECK_OK();
RCF_CHECK_EQ(e.getErrorId() , RCF::RcfError_Serialization);
}
// server deserialization error
try
{
RcfClient<I_Echo>( clientTransportAutoPtr->clone() ).putA( A(2) );
RCF_CHECK_FAIL();
}
catch(RCF::RemoteException &e)
{
std::string msg = e.what();
RCF_CHECK_OK();
RCF_CHECK_EQ(e.getErrorId() , RCF::SfError_DataFormat);
}
// server serialization error
try
{
RcfClient<I_Echo>( clientTransportAutoPtr->clone() ).getA(1);
RCF_CHECK_FAIL();
}
catch(RCF::RemoteException &e)
{
std::string msg = e.what();
RCF_CHECK_OK();
RCF_CHECK_EQ(e.getErrorId() , RCF::RcfError_Serialization);
}
// inbound client serialization error
try
{
RcfClient<I_Echo>( clientTransportAutoPtr->clone() ).getA(2);
RCF_CHECK_FAIL();
}
catch(const RCF::Exception &e)
{
std::string msg = e.what();
RCF_CHECK_OK();
RCF_CHECK_EQ(e.getErrorId() , RCF::SfError_DataFormat);
}
//************************************************
// returning non RCF error codes and strings, through RemoteException
int myErrorCode = 12345;
std::string myErrorString = "qwerty";
try
{
RcfClient<I_Echo>( clientTransportAutoPtr->clone() )
.throwRemoteException(myErrorCode, myErrorString);
RCF_CHECK_FAIL();
}
catch(const RCF::RemoteException &e)
{
std::string msg = e.what();
RCF_CHECK_OK();
RCF_CHECK_EQ(e.getErrorId() , myErrorCode);
//RCF_CHECK_EQ(e.what() , myErrorString);
RCF_CHECK( std::string(e.what()).find(myErrorString) != std::string::npos);
}
//************************************************
// throwing and catching RemoteException-derived exceptions across the wire
for(int protocol=1; protocol<10; ++protocol)
{
RCF::SerializationProtocol sp = RCF::SerializationProtocol(protocol);
if (RCF::isSerializationProtocolSupported(sp))
{
try
{
RcfClient<I_Echo> client( clientTransportAutoPtr->clone() );
client.getClientStub().setSerializationProtocol(sp);
client.throwMyRemoteException(myErrorCode, myErrorString);
RCF_CHECK_FAIL();
}
catch(const MyRemoteException &e)
{
std::string msg = e.what();
RCF_CHECK_OK();
RCF_CHECK_EQ(e.getErrorId() , myErrorCode);
RCF_CHECK_EQ(e.what() , myErrorString);
}
catch(const RCF::RemoteException &e)
{
std::string msg = e.what();
RCF_CHECK_FAIL()(sp);
RCF_CHECK_EQ(e.getErrorId() , myErrorCode)(sp);
RCF_CHECK_EQ(e.what() , myErrorString)(sp);
}
}
}
//************************************************
// catching non RemoteException-derived exception thrown on server
for(int protocol=1; protocol<10; ++protocol)
{
RCF::SerializationProtocol sp = RCF::SerializationProtocol(protocol);
if (RCF::isSerializationProtocolSupported(sp))
{
try
{
RcfClient<I_Echo> client( clientTransportAutoPtr->clone() );
client.throwStdException(myErrorString);
RCF_CHECK_FAIL();
}
catch(const RCF::RemoteException &e)
{
//std::string msg = e.what();
//RCF_CHECK_FAIL();
//RCF_CHECK_EQ(e.getErrorId() , myErrorCode);
//RCF_CHECK_EQ(e.what() , myErrorString);
RCF_CHECK_EQ(e.getErrorId() , RCF::RcfError_UserModeException);
std::string errorString = e.getErrorString();
RCF_CHECK( errorString.find(myErrorString) != errorString.npos );
}
}
}
//************************************************
// message header errors (eg corruption)
// TODO
//************************************************
// transport filter errors
// TODO
//************************************************
// payload filter errors
// TODO
}
return 0;
}
int test_main(int argc, char **argv)
{
printTestHeader(__FILE__);
RCF::RcfInitDeinit rcfInitDeinit;
using namespace Test_Polymorphic;
util::CommandLine::getSingleton().parse(argc, argv);
RCF_ASSERT( !RCF::getTransportFactories().empty() );
RCF::TransportFactoryPtr transportFactoryPtr = RCF::getTransportFactories()[0];
RCF::TransportPair transports = transportFactoryPtr->createTransports();
RCF::ServerTransportPtr serverTransportPtr( transports.first );
RCF::ClientTransportAutoPtr clientTransportAutoPtr( *transports.second );
std::cout << transportFactoryPtr->desc() << std::endl;
RCF::RcfServer server(serverTransportPtr);
X x;
Y y;
Z z;
server.bind( (I_X*) 0, x);
server.bind( (I_Y*) 0, y);
server.bind( (I_Z*) 0, z);
server.start();
for (int protocol=1; protocol<=2; ++protocol)
{
RCF::SerializationProtocol sp = RCF::SerializationProtocol(protocol);
if (RCF::isSerializationProtocolSupported(sp))
{
std::string protocolName = RCF::getSerializationProtocolName(protocol);
std::cout << "Testing serialization protocol: " << protocol << ": " << protocolName << std::endl;
std::string s;
RcfClient<I_X> xClient(clientTransportAutoPtr->clone());
RcfClient<I_Y> yClient(clientTransportAutoPtr->clone());
RcfClient<I_Z> zClient(clientTransportAutoPtr->clone());
xClient.getClientStub().setSerializationProtocol(sp);
yClient.getClientStub().setSerializationProtocol(sp);
zClient.getClientStub().setSerializationProtocol(sp);
{
boost::shared_ptr<A> pa(new A);
boost::shared_ptr<A> pb(new B);
boost::shared_ptr<A> pc(new C);
s = xClient.f1(pa.get()); RCF_CHECK_EQ(s , typeid(A).name() );
s = xClient.f1(pb.get()); RCF_CHECK_EQ(s , typeid(B).name() );
s = xClient.f1(pc.get()); RCF_CHECK_EQ(s , typeid(C).name() );
// Top level polymorphic serialization no longer supported as of
// runtime version 8 (RCF 1.3). But we're still fully backwards
// compatible.
int ver = yClient.getClientStub().getRuntimeVersion();
yClient.getClientStub().setRuntimeVersion(7);
s = yClient.f1(*pa); RCF_CHECK_EQ(s , typeid(A).name() );
s = yClient.f1(*pb); RCF_CHECK_EQ(s , typeid(B).name() );
s = yClient.f1(*pc); RCF_CHECK_EQ(s , typeid(C).name() );
yClient.getClientStub().setRuntimeVersion(7);
s = zClient.f1(pa); RCF_CHECK_EQ(s , typeid(A).name() );
s = zClient.f1(pb); RCF_CHECK_EQ(s , typeid(B).name() );
s = zClient.f1(pc); RCF_CHECK_EQ(s , typeid(C).name() );
}
{
boost::shared_ptr<A> spa;
spa = zClient.f2( typeid(B).name() ); RCF_CHECK( dynamic_cast<B *>(spa.get()) != NULL );
spa = zClient.f2( typeid(C).name() ); RCF_CHECK( dynamic_cast<C *>(spa.get()) != NULL );
}
{
A *pa = NULL;
//xClient.f3(typeid(B).name(), pa); RCF_CHECK( dynamic_cast<B *>(pa) != NULL );
//xClient.f3(typeid(C).name(), pa); RCF_CHECK( dynamic_cast<C *>(pa) != NULL );
boost::shared_ptr<A> spa;
zClient.f3(typeid(B).name(), spa); RCF_CHECK( dynamic_cast<B *>(spa.get()) != NULL );
zClient.f3(typeid(C).name(), spa); RCF_CHECK( dynamic_cast<C *>(spa.get()) != NULL );
}
}
}
return 0;
}
int test_main(int argc, char **argv)
{
printTestHeader(__FILE__);
RCF::RcfInitDeinit rcfInitDeinit;
using namespace Test_ClientInfo;
util::CommandLine::getSingleton().parse(argc, argv);
for (std::size_t i=0; i<RCF::getIpTransportFactories().size(); ++i)
{
RCF::TransportFactoryPtr transportFactoryPtr = RCF::getIpTransportFactories()[i];
RCF::TransportPair transports = transportFactoryPtr->createTransports();
RCF::ServerTransportPtr serverTransportPtr( transports.first );
RCF::ClientTransportAutoPtr clientTransportAutoPtr( *transports.second );
std::cout << transportFactoryPtr->desc() << std::endl;
GetMyAddress getMyAddress;
RCF::RcfServer server(serverTransportPtr);
server.bind( (I_GetMyAddress*) 0, getMyAddress);
server.start();
#if defined(_MSC_VER) && _MSC_VER < 1310
std::pair<std::string, int> myAddress = RcfClient<I_GetMyAddress>(clientTransportAutoPtr).getMyAddress(RCF::Twoway).get();
#else
std::pair<std::string, int> myAddress = RcfClient<I_GetMyAddress>(clientTransportAutoPtr).getMyAddress(RCF::Twoway);
#endif
RCF_CHECK(myAddress.first == "127.0.0.1" || myAddress.first == "::1");
RCF_CHECK_GT(myAddress.second, 0);
}
// Check that we can get native handles for the underlying I/O objects.
for (std::size_t i=0; i<RCF::getTransportFactories().size(); ++i)
{
RCF::TransportFactoryPtr transportFactoryPtr = RCF::getTransportFactories()[i];
RCF::TransportPair transports = transportFactoryPtr->createTransports();
RCF::ServerTransportPtr serverTransportPtr( transports.first );
RCF::ClientTransportAutoPtr clientTransportAutoPtr( *transports.second );
std::cout << transportFactoryPtr->desc() << std::endl;
GetMyAddress getMyAddress;
RCF::RcfServer server(serverTransportPtr);
server.bind( (I_GetMyAddress*) 0, getMyAddress);
server.start();
RcfClient<I_GetMyAddress> client(clientTransportAutoPtr);
// Check that we can get server side native handles.
client.checkServerHandle();
// Check that we can get client side native handles.
RCF::TcpClientTransport *pTcpClientTransport =
dynamic_cast<RCF::TcpClientTransport *>(
& client.getClientStub().getTransport() );
if (pTcpClientTransport)
{
int clientHandle = pTcpClientTransport->getNativeHandle();
RCF_CHECK(clientHandle != 0 && clientHandle != -1);
continue;
}
RCF::UdpClientTransport *pUdpClientTransport =
dynamic_cast<RCF::UdpClientTransport *>(
& client.getClientStub().getTransport() );
if (pUdpClientTransport)
{
int clientHandle = pUdpClientTransport->getNativeHandle();
RCF_CHECK(clientHandle != 0 && clientHandle != -1);
continue;
}
#ifdef BOOST_WINDOWS
RCF::Win32NamedPipeClientTransport *pWin32PipeClientTransport =
dynamic_cast<RCF::Win32NamedPipeClientTransport *>(
& client.getClientStub().getTransport() );
if (pWin32PipeClientTransport)
{
HANDLE clientHandle = pWin32PipeClientTransport->getNativeHandle();
RCF_CHECK(clientHandle != 0);
continue;
}
#endif
#if defined(RCF_USE_BOOST_ASIO) && defined(BOOST_ASIO_HAS_LOCAL_SOCKETS)
RCF::UnixLocalClientTransport *pUnixLocalClientTransport =
dynamic_cast<RCF::UnixLocalClientTransport *>(
& client.getClientStub().getTransport() );
if (pUnixLocalClientTransport)
{
int clientHandle = pUnixLocalClientTransport->getNativeHandle();
RCF_CHECK(clientHandle != 0 && clientHandle != -1);
continue;
}
#endif
RCF_CHECK_EQ(1 , 0);
}
return 0;
}
