void ConnectorTest::allocatorConstructorTest()
{
{
PoolAllocator pa(1, 8 * 1024, 21);
TestStorageHooks tsh(&pa);
Connector connector(GetConfig()["SocketConnectSuccessHost"]["ip"].AsString(), GetConfig()["SocketConnectSuccessHost"]["port"].AsLong(), 0L, String(), 0L, true);
Socket *socket = connector.MakeSocket();
if ( t_assert( socket != NULL ) && t_assertm(&pa == socket->fAllocator, "allocator should match") ) {
long socketfd = socket->GetFd();
t_assert( socketfd > 0 );
std::iostream *Ios = socket->GetStream();
t_assert( Ios != NULL);
}
delete socket;
}
{
TestStorageHooks tsh(coast::storage::Global());
Connector connector(GetConfig()["SocketConnectSuccessHost"]["ip"].AsString(), GetConfig()["SocketConnectSuccessHost"]["port"].AsLong(), false);
Socket *socket = connector.MakeSocket();
if ( t_assert( socket != NULL ) && t_assertm(coast::storage::Global() == socket->fAllocator, "allocator should match") ) {
long socketfd = socket->GetFd();
t_assert( socketfd > 0 );
std::iostream *Ios = socket->GetStream();
t_assert( Ios != NULL);
}
delete socket;
}
}
//----------------------------------------------------------------------------------
void tst_QTcpServer::waitForConnectionTest()
{
QFETCH_GLOBAL(bool, setProxy);
if (setProxy) {
QFETCH_GLOBAL(int, proxyType);
if (proxyType == QNetworkProxy::Socks5Proxy) {
QSKIP("Localhost servers don't work well with SOCKS5", SkipAll);
}
}
QTcpSocket findLocalIpSocket;
findLocalIpSocket.connectToHost(QtNetworkSettings::serverName(), 143);
QVERIFY(findLocalIpSocket.waitForConnected(5000));
QTcpServer server;
bool timeout = false;
QVERIFY(server.listen(findLocalIpSocket.localAddress()));
QVERIFY(!server.waitForNewConnection(1000, &timeout));
QCOMPARE(server.serverError(), QAbstractSocket::SocketTimeoutError);
QVERIFY(timeout);
ThreadConnector connector(findLocalIpSocket.localAddress(), server.serverPort());
connector.start();
#if defined(Q_OS_WINCE) || defined(Q_OS_SYMBIAN)
QVERIFY(server.waitForNewConnection(9000, &timeout));
#else
QVERIFY(server.waitForNewConnection(3000, &timeout));
#endif
QVERIFY(!timeout);
}
bool RobotClient::clientConnect(int qargc, char** qargv)
{
Aria::init();
//Aria::setDirectory(".\\RobotConfig.txt");
std::string configIp = "ARIAARGS= -host " + mRobotIp + " ";
putenv(configIp.c_str());
//putenv("ARIAARGS=-host 192.168.191.5");
std::string p=getenv("ARIAARGS");
ArArgumentParser parser(&qargc, qargv);
ArClientSimpleConnector connector(&parser);
parser.loadDefaultArguments();
connector.parseArgs(&parser);
//config robot ip
//char charIP[20]={'\0'};
//mRobotIp.copy(charIP,mRobotIp.length(),0);
//connector.myHost=charIP;
//pConnector->myHost = charIP;
//QMessageBox box;
//box.setText(QString(connector.myHost));
//box.exec();
//connect
bool ret = connector.connectClient(pClient.get());
bool ret1 = pClient->addHandler("getLaserRelatedPos", &myHandleLaserFeedbackDataCB);
return (ret);
}
void SessionImpl::open(const std::string& connect)
{
if (connect != connectionString())
{
if (isConnected())
throw InvalidAccessException("Session already connected");
if (!connect.empty())
setConnectionString(connect);
}
poco_assert_dbg (!connectionString().empty());
try
{
ActiveConnector connector(connectionString(), &_pDB);
ActiveResult<int> result = connector.connect();
if (!result.tryWait(getLoginTimeout() * 1000))
throw ConnectionFailedException("Timed out.");
int rc = result.data();
if (rc != 0)
{
close();
Utility::throwException(rc);
}
}
catch (SQLiteException& ex)
{
throw ConnectionFailedException(ex.displayText());
}
_connected = true;
}
bool
UnixSocketConsumer::ConnectSocket(UnixSocketConnector* aConnector,
const char* aAddress,
int aDelayMs)
{
MOZ_ASSERT(aConnector);
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<UnixSocketConnector> connector(aConnector);
if (mIO) {
NS_WARNING("Socket already connecting/connected!");
return false;
}
nsCString addr(aAddress);
MessageLoop* ioLoop = XRE_GetIOMessageLoop();
mIO = new UnixSocketConsumerIO(ioLoop, this, connector.forget(), addr);
SetConnectionStatus(SOCKET_CONNECTING);
if (aDelayMs > 0) {
DelayedConnectTask* connectTask = new DelayedConnectTask(mIO);
mIO->SetDelayedConnectTask(connectTask);
MessageLoop::current()->PostDelayedTask(FROM_HERE, connectTask, aDelayMs);
} else {
ioLoop->PostTask(FROM_HERE, new ConnectTask(mIO));
}
return true;
}
void SocketTest::httpClientTest() {
Connector connector(GetConfig()["HTTPReplyHost"]["ip"].AsString(), GetConfig()["HTTPReplyHost"]["port"].AsLong());
Socket *socket = connector.MakeSocket(); //lint !e578
assertEqual( GetConfig()["HTTPReplyHost"]["ip"].AsString(), connector.GetAddress());
assertEqual( GetConfig()["HTTPReplyHost"]["port"].AsLong(), connector.fPort);
assertEqual( (long)NULL, (long)connector.fSocket);
if (t_assertm( socket != NULL, (const char *)connector.GetAddress() )) { // fails without HTTP Server
long socketfd = socket->GetFd();
t_assert( socketfd > 0L);
// this one sets the connect timeout
socket->SetTimeout(GetConfig()["GetStreamTimeout"].AsLong(5000L));
std::iostream *Ios = socket->GetStream();
t_assert( Ios != NULL);
if (Ios) {
String query("GET / HTTP/1.0");
String reply;
long lRetCode;
if (t_assertm(socket->IsReadyForWriting(GetConfig()["ReadyForWritingTimeout"].AsLong(5000L), lRetCode), TString("expected no timeout for sending http request to [") << connector.GetAddress() << ':' << connector.fPort << "]")
&& t_assert(lRetCode > 0)) {
(*Ios) << query << std::endl << std::endl;
t_assert(!!(*Ios));
// make sure Ios is valid
if (t_assertm(socket->IsReadyForReading(GetConfig()["ReadyForReadingTimeout"].AsLong(5000L), lRetCode), TString("expected no timeout for reading HTTP reply [") << connector.GetAddress() << ':' << connector.fPort << "]")
&& t_assert(lRetCode > 0)) {
(*Ios) >> reply;
assertEqual( "HTTP", reply.SubString(0, 4));
// test first line of reply by http server
t_assert(!!(*Ios));
}
}
int main(int argc, char** argv)
{
ArGlobalFunctor sonarPrinterCB(&sonarPrinter);
Aria::init();
ArSimpleConnector connector(&argc, argv);
if(!connector.parseArgs())
{
connector.logOptions();
return 1;
}
robot = new ArRobot;
robot->addRangeDevice(&sonar);
if(!connector.connectRobot(robot))
{
printf("Could not connect to robot.\n");
return 2;
}
robot->comInt(ArCommands::SONAR, 1);
robot->comInt(ArCommands::SOUNDTOG, 0);
printf("Closest readings within quadrants:\n");
robot->addUserTask("Sonar printer", 50, &sonarPrinterCB);
robot->run(true);
Aria::shutdown();
}
void ConnectorTest::ConnectAndAssert(const char *host, long port, long timeout, bool threadLocal, bool shouldFail)
{
Connector connector(host, port, timeout, String(), 0L, threadLocal);
// assert the internal state of the connector
assertEqual( port, connector.fPort );
assertEqual( timeout, connector.fConnectTimeout );
assertEqual( (long)NULL, (long)connector.fSocket );
// assert the funtionality of the public api
String assertMsg(host);
assertMsg << ":" << port << " with timeout: " << timeout;
String realMsg(assertMsg);
realMsg << (( connector.Use() ) ? " has not failed" : " has failed");
if ( shouldFail ) {
assertMsg << " has failed";
assertEqual(assertMsg, realMsg);
t_assert( connector.Use() == NULL );
t_assert( connector.GetStream() == NULL );
} else {
assertMsg << " has not failed";
assertEqual(assertMsg, realMsg);
t_assert( connector.Use() != NULL );
t_assert( connector.GetStream() != NULL );
}
}
void CNetService::NullConnect( const char * remote_ip, int remote_port )
{
DXM_NDC("NetService::NullConnect");
int connect_fd = socket(PF_INET, SOCK_STREAM, 0);
if(connect_fd <= 0) {
DXM_COMPONENT_LOG( DXM_COMPONENT_LOG_LEVEL_ERROR, "request socket failed.(connector(%s:%d)", remote_ip, remote_port);
return;
}
// config address
struct sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = inet_addr(remote_ip);
sin.sin_port = htons(remote_port);
// create connector
int result = ::connect(connect_fd, (sockaddr*)&sin, sizeof(sin));
if(result == -1) {
DXM_COMPONENT_LOG( DXM_COMPONENT_LOG_LEVEL_ERROR, "connect failed. error code: %d.(connector(%s:%d)", result, remote_ip, remote_port);
return;
}
CConnector::Ptr connector(new CConnector(shared_from_this(), this));
if(connector->Init(connect_fd, 0, (struct sockaddr*)&sin)){
connector->Shutdown();
}
}
int main(int argc, char **argv)
{
ArRobot robot;
Aria::init();
ArSimpleConnector connector(&argc, argv);
if (!Aria::parseArgs())
{
Aria::logOptions();
Aria::shutdown();
return 1;
}
if (!connector.connectRobot(&robot))
{
ArLog::log(ArLog::Normal, "robotPacketHandlerTest: Could not connect to robot... exiting");
return 2;
}
ArLog::log(ArLog::Normal, "robotPacketHandlerTest: Connected.");
robot.addPacketHandler(new ArGlobalRetFunctor1<bool, ArRobotPacket*>(&testcb), ArListPos::FIRST);
robot.run(true);
return 0;
}
void ConnectorTest::makeSocketWithReuseTest()
{
// connect to http server on localhost
Connector connector(GetConfig()["SocketConnectSuccessHost"]["ip"].AsString(), GetConfig()["SocketConnectSuccessHost"]["port"].AsLong(), 0L, String(), 0L, true);
// assert the internal state
assertEqual( GetConfig()["SocketConnectSuccessHost"]["ip"].AsString(), connector.GetAddress() );
assertEqual( GetConfig()["SocketConnectSuccessHost"]["port"].AsLong(), connector.fPort );
assertEqual( (long)NULL, (long)connector.fSocket );
// check basic functionality
Socket *s1 = connector.MakeSocket(false);
Socket *s2 = connector.MakeSocket(false);
long sock1 = 0, sock2 = 0;
if (s1 != 0) {
sock1 = s1->GetFd();
t_assert( s1 != NULL );
if (s2 != 0) {
t_assert( s1 != s2 );
} // if
delete s1;
assertEqual( 0L, ::closeSocket(sock1));
}
if (s2 != 0) {
sock2 = s2->GetFd();
t_assert( s2 != NULL );
delete s2;
// should not result in an error because destructor has not closed socket
assertEqual( 0L, ::closeSocket(sock2));
}
} // makeSocketTest
/*!
* @brief profile(), id(), name(), setEndian(), isLittleEndian() メソッドのテスト
*
*/
void test_case0()
{
InPortMock inport("OutPortConnectorTest1", toTypename<RTC::TimedFloat>());
RTC::PortService_var port_ref1= inport.get_port_profile()->port_ref;
OutPortMock outport("OutPortConnectorTest2", toTypename<RTC::TimedFloat>());
RTC::PortService_var port_ref2= outport.get_port_profile()->port_ref;
RTC::PortAdmin portAdmin(m_pORB,m_pPOA);
portAdmin.registerPort(inport);
portAdmin.registerPort(outport);
RTC::ConnectorProfile cprof;
cprof.connector_id = "id";
cprof.name = CORBA::string_dup("OutPortConnectorTest");
CORBA_SeqUtil::push_back(cprof.properties,
NVUtil::newNV("dataport.interface_type",
"corba_cdr"));
CORBA_SeqUtil::push_back(cprof.properties,
NVUtil::newNV("dataport.dataflow_type",
"push"));
CORBA_SeqUtil::push_back(cprof.properties,
NVUtil::newNV("dataport.subscription_type",
"new"));
cprof.ports.length(2);
cprof.ports[0] = port_ref1;
cprof.ports[1] = port_ref2;
coil::Properties prop;
NVUtil::copyToProperties(prop, cprof.properties);
RTC::ConnectorInfo info(cprof.name, cprof.connector_id,
CORBA_SeqUtil::refToVstring(cprof.ports), prop);
OutPortConnectorMock connector(info);
CPPUNIT_ASSERT_EQUAL(std::string(cprof.connector_id), std::string(connector.id()));
CPPUNIT_ASSERT_EQUAL(std::string(cprof.name), std::string(connector.name()));
connector.setEndian(false);
CPPUNIT_ASSERT(!connector.isLittleEndian());
connector.setEndian(true);
CPPUNIT_ASSERT(connector.isLittleEndian());
RTC::ConnectorInfo info2 = connector.profile();
CPPUNIT_ASSERT_EQUAL(info.name,info2.name);
CPPUNIT_ASSERT_EQUAL(info.id,info2.id);
CPPUNIT_ASSERT(info.ports==info2.ports);
CPPUNIT_ASSERT_EQUAL(info.properties.size(),
info2.properties.size());
CPPUNIT_ASSERT_EQUAL(info.properties["dataport.interface_type"],
info2.properties["dataport.interface_type"]);
CPPUNIT_ASSERT_EQUAL(info.properties["dataport.dataflow_type"],
info2.properties["dataport.dataflow_type"]);
CPPUNIT_ASSERT_EQUAL(info.properties["dataport.subscription_type"],
info2.properties["dataport.subscription_type"]);
portAdmin.deletePort(inport);
portAdmin.deletePort(outport);
}
Exp * expression(Dictionary dict) {
/* Build (and return the root of) the tree for the expression beginning */
/* with the current token. At the end, the token is the first one not part */
/* of this expression. */
Exp * n;
if (is_equal(dict, L'(')) {
if (!advance(dict)) {
return NULL;
}
n = in_parens(dict);
if (!is_equal(dict, L')')) {
dict_error(dict, L"Expecting a \")\".");
return NULL;
}
if (!advance(dict)) {
return NULL;
}
} else if (is_equal(dict, L'{')) {
if (!advance(dict)) {
return NULL;
}
n = in_parens(dict);
if (!is_equal(dict, L'}')) {
dict_error(dict, L"Expecting a \"}\".");
return NULL;
}
if (!advance(dict)) {
return NULL;
}
n = make_optional_node(dict, n);
} else if (is_equal(dict, L'[')) {
if (!advance(dict)) {
return NULL;
}
n = in_parens(dict);
if (!is_equal(dict, L']')) {
dict_error(dict, L"Expecting a \"]\".");
return NULL;
}
if (!advance(dict)) {
return NULL;
}
n->cost += 1;
} else if (!dict->is_special) {
n = connector(dict);
if (n == NULL) {
return NULL;
}
} else if (is_equal(dict, L')') || is_equal(dict, L']')) {
/* allows "()" or "[]" */
n = make_zeroary_node(dict);
} else {
dict_error(dict, L"Connector, \"(\", \"[\", or \"{\" expected.");
return NULL;
}
return n;
}
int main(int argc, char* argv[]) {
if(argc < 8 || argc > 10) {
cout << "Usage: " << argv[0] << " <host> <port> <username> <password> <tableName> <startRowId> <stopRowId> <colFam> <colQual>\n";
return 1;
}
try {
Connector connector(argv[1], atoi(argv[2]), argv[3], argv[4]);
Authorizations auths("");
Scanner scanner = connector.createScanner(argv[5], auths);
Key ks, ke;
ks.row = argv[6]; ke.row = argv[7];
Range range;
range.start = ks;
range.stop = ke;
scanner.setRange(range);
if(argc > 8) {
if(argc == 9) {
scanner.fetchColumnFamily(argv[8]);
}
else if(argc == 10) {
scanner.fetchColumn(argv[8], argv[9]);
}
}
ScannerIterator itr = scanner.iterator();
while(itr.hasNext()) {
KeyValue kv = itr.next();
cout << kv.key.row << " " << kv.key.colFamily << ":"
<< kv.key.colQualifier << " [" << kv.key.colVisibility
<< "] " << kv.key.timestamp << "\t" << kv.value << "\n";
}
itr.close();
connector.close();
} catch(TableNotFoundException &e) {
cout << "The specified table was not found\n";
}
return 0;
}
/*
* Termination and deletion
*/
DFS::~DFS(void) {
Connector connector(opt().port);
std::cerr << "sending done...";
connector.connect();
connector.done();
connector.disconnect();
terminate();
heap.rfree(_worker);
}
/**
* Build (and return the root of) the tree for the expression beginning
* with the current token. At the end, the token is the first one not
* part of this expression.
*/
Exp * expression(Dictionary dict)
{
Exp * n;
if (is_equal(dict, '(')) {
if (!link_advance(dict)) {
return NULL;
}
n = in_parens(dict);
if (!is_equal(dict, ')')) {
dict_error(dict, "Expecting a \")\".");
return NULL;
}
if (!link_advance(dict)) {
return NULL;
}
} else if (is_equal(dict, '{')) {
if (!link_advance(dict)) {
return NULL;
}
n = in_parens(dict);
if (!is_equal(dict, '}')) {
dict_error(dict, "Expecting a \"}\".");
return NULL;
}
if (!link_advance(dict)) {
return NULL;
}
n = make_optional_node(dict, n);
} else if (is_equal(dict, '[')) {
if (!link_advance(dict)) {
return NULL;
}
n = in_parens(dict);
if (!is_equal(dict, ']')) {
dict_error(dict, "Expecting a \"]\".");
return NULL;
}
if (!link_advance(dict)) {
return NULL;
}
n->cost += 1.0f;
} else if (!dict->is_special) {
n = connector(dict);
if (n == NULL) {
return NULL;
}
} else if (is_equal(dict, ')') || is_equal(dict, ']')) {
/* allows "()" or "[]" */
n = make_zeroary_node(dict);
} else {
dict_error(dict, "Connector, \"(\", \"[\", or \"{\" expected.");
return NULL;
}
return n;
}
void ConnectorFactoryTest::cleanup_removes_points()
{
Connector connector(Point(42, 57));
RelativePosition pp(Point(0, 0));
connector.addPoint(&pp);
ConnectorFactory::cleanup(connector);
CPPUNIT_ASSERT_EQUAL(size_t(0), connector.getPoints().size());
CPPUNIT_ASSERT(&connector.getPosition() != pp.getAnchor());
}
void ConnectorTest::faultyConstructorTest()
{
Connector connector((const char *)NULL, -1);
assertEqual( "", connector.GetAddress() );
assertEqual( -1, connector.fPort );
assertEqual( (long)NULL, (long)connector.MakeSocket() );
assertEqual( (long)NULL, (long)connector.Use() );
assertEqual( (long)NULL, (long)connector.GetStream() );
} // faultyConstructorTest
int main() {
try {
boost::asio::io_service io_service;
Connector connector(io_service);
connector.connect("127.0.0.1", 6000);
io_service.run();
} catch (std::exception& e) {
std::cerr << e.what() << std::endl;
}
return 0;
}
void ConnectorTool::endRubberBanding(QMouseEvent *)
{
connector(view()->canvasWidget()->rect());
m_pStencil = 0;
m_mode = stmNone;
view()->canvasWidget()->guideLines().repaintAfterSnapping();
if(!m_permanent) {
view()->pluginManager()->activateDefaultTool();
}
}
void mgg::DRMModeResources::for_each_connector(std::function<void(DRMModeConnectorUPtr)> const& f) const
{
for (int i = 0; i < resources->count_connectors; i++)
{
auto connector_ptr = connector(resources->connectors[i]);
if (!connector_ptr)
continue;
f(std::move(connector_ptr));
}
}
void SocketTest::simpleConstructorTest() {
Connector connector(GetConfig()["SocketConnectSuccessHost"]["ip"].AsString(), GetConfig()["SocketConnectSuccessHost"]["port"].AsLong());
Socket *socket = connector.MakeSocket(); //lint !e578
if (t_assertm( socket != NULL, (const char *)connector.GetAddress() )) {
long socketfd = socket->GetFd();
t_assert( socketfd > 0);
std::iostream *Ios = socket->GetStream();
t_assert( Ios != NULL);
}
delete socket;
}
int _tmain(int argc, _TCHAR* argv[])
{
char host[20] = "127.1.1.1";
unsigned short port = 10080;
if( argc > 1 ) {
::wcstombs( host, argv[1], sizeof(host) );
}
if( argc > 2 ) {
try {
port = lexical_cast<unsigned short>( wstring(argv[2]) );
} catch( const bad_lexical_cast & ) {
cout << "input port illegal. expected unsigned short value, but ";
wcout << argv[2] << endl;
}
}
try {
io_service::work work(ios_);
run_service( ios_ );
shared_ptr<fastnetwork::io_connector> connector( new udp::udp_connector( ios_ ) );
connector->set_handler( session_created );
// connector->connect( ip::udp::endpoint( ip::address_v4::from_string(host), port ) );
// while using ip::address_v4::from_string(host), async_receive_from won't work
// I don't know why.
connector->connect( ip::udp::endpoint( ip::address_v4::from_string("127.0.0.1"), port ) );
while ( true ) {
if ( ! client ) {
::Sleep(1000);
} else {
read_send( client );
// break;
}
}
} catch (std::exception& e) {
std::cerr << e.what() << std::endl;
}
ios_.stop();
while( true ) {
::Sleep( 10000 );
}
return 0;
}
int main(int argc, char *argv[]) {
if(argc != 3) {
printf("usage: c10k <parallel-connections> <roundtrip-count>\n");
return 1;
}
long conns = atol(argv[1]);
long roundtrips = atol(argv[2]);
assert(conns >= 1);
tcpsock ls = tcplisten(iplocal("127.0.0.1", 5555, 0), 10);
assert(ls);
int i;
for(i = 0; i != conns - 1; ++i) {
go(connector());
tcpsock as = tcpaccept(ls, -1);
assert(as);
}
go(sender(roundtrips));
tcpsock as = tcpaccept(ls, -1);
assert(as);
int64_t start = now();
char buf[1];
size_t nbytes;
for(i = 0; i != roundtrips; ++i) {
nbytes = tcpsend(as, "A", 1, -1);
assert(errno == 0);
assert(nbytes == 1);
tcpflush(as, -1);
assert(errno == 0);
nbytes = tcprecv(as, buf, 1, -1);
assert(errno == 0);
assert(nbytes == 1);
assert(buf[0] == 'A');
}
int64_t stop = now();
long duration = (long)(stop - start);
long us = (duration * 1000) / roundtrips;
printf("done %ld roundtrips in %f seconds\n",
roundtrips, ((float)duration) / 1000);
printf("duration of a single roundtrip: %ld us\n", us);
printf("roundtrips per second: %ld\n",
(long)(roundtrips * 1000 / duration));
return 0;
}
void MasterMessageSender::send_message( const kvs::MessageBlock& message, bool change )
{
for ( size_t i = 0; i < m_addresses.size(); i++ )
{
kvs::Connector connector( m_addresses[i].ip(), m_addresses[i].port(), 1 );
connector.send( message );
}
if ( change )
{
m_mutex.lock();
kvs::tdw::Configuration::setIsRendering( true );
m_mutex.unlock();
}
}
void stream_socket::async_connect(endpoint const &ep,event_handler const &h)
{
if(!dont_block(h))
return;
system::error_code e;
connect(ep,e);
if(e && would_block(e)) {
async_connector::pointer connector(new async_connector(h,this));
on_writeable(connector);
}
else {
event_binder::pointer binder(new event_binder( h,e ));
get_io_service().post(binder);
}
}
void ConnectorTest::getStreamTest()
{
Connector connector(GetConfig()["SocketConnectSuccessHost"]["ip"].AsString(), GetConfig()["SocketConnectSuccessHost"]["port"].AsLong(), 0L, String(), 0L, true);
std::iostream *s1 = connector.GetStream();
std::iostream *s2 = connector.GetStream();
t_assert( s1 != NULL );
t_assert( s2 != NULL );
t_assert( s1 == s2 );
// don't delete s1 or s2
// connector is the owner of the
// object
// delete s1; // should result in SEGV
// delete s2; // should result in SEGV
} // useSocketTest
void SocketTest::allocatorConstructorTest() {
PoolAllocator pa(1, 8 * 1024, 21);
TestStorageHooks tsh(&pa);
Connector connector(GetConfig()["SocketConnectSuccessHost"]["ip"].AsString(), GetConfig()["SocketConnectSuccessHost"]["port"].AsLong());
connector.SetThreadLocal();
Socket *socket = connector.MakeSocket(); //lint !e578
if (t_assertm( socket != NULL, (const char *)connector.GetAddress() )) {
long socketfd = socket->GetFd();
t_assert( socketfd > 0);
std::iostream *Ios = socket->GetStream();
t_assert( Ios != NULL);
}
delete socket;
}
/**
* Input:
BATCH 0 DEPTH 0
a1 d1 g1
b1 e1 h1
c1 f1 i1
BATCH 0 DEPTH 1
a1' d1' g1'
b1' e1' h1'
c1' f1' i1'
BATCH 1 DEPTH 0
a2 d2 g2
b2 e2 h2
c2 f2 i2
BATCH 1 DEPTH 1
a2' d2' g2'
b2' e2' h2'
c2' f2' i2'
*
* Expect output with Kernel size 3x3:
*
BATCH 0 DEPTH 0
a1 d1 b1 e1 a1' d1' b1' e1'
d1 g1 e1 h1 d1' g1' e1' h1'
b1 e1 c1 f1 b1' e1' c1' f1'
e1 h1 f1 i1 e1' h1' f1' i1'
a2 d2 b2 e2 a2' d2' b2' e2'
d2 g2 e2 h2 d2' g2' e2' h2'
b2 e2 c2 f2 b2' e2' c2' f2'
e2 h2 f2 i2 e2' h2' f2' i2'
*
**/
void TEST_LOWERING(){
Cube<DataType_String, Layout_RCDB> cube1(3, 3, 2, 2);
Cube<DataType_String, Layout_RCDB> cube2(2*2*2, (3-2+1)*(3-2+1)*2, 1, 1);
LoweringConfig lconfig;
lconfig.kernel_size = 2;
Connector<DataType_String, Layout_RCDB, DataType_String, Layout_RCDB, Connector_Lowering_R1C1>
connector(&cube1, &cube2, &lconfig);
size_t ct = 0;
cube1.p_data[ct++] = "a1"; cube1.p_data[ct++] = "b1";
cube1.p_data[ct++] = "c1"; cube1.p_data[ct++] = "d1";
cube1.p_data[ct++] = "e1"; cube1.p_data[ct++] = "f1";
cube1.p_data[ct++] = "g1"; cube1.p_data[ct++] = "h1";
cube1.p_data[ct++] = "i1";
cube1.p_data[ct++] = "a2"; cube1.p_data[ct++] = "b2";
cube1.p_data[ct++] = "c2"; cube1.p_data[ct++] = "d2";
cube1.p_data[ct++] = "e2"; cube1.p_data[ct++] = "f2";
cube1.p_data[ct++] = "g2"; cube1.p_data[ct++] = "h2";
cube1.p_data[ct++] = "i2";
cube1.p_data[ct++] = "a1'"; cube1.p_data[ct++] = "b1'";
cube1.p_data[ct++] = "c1'"; cube1.p_data[ct++] = "d1'";
cube1.p_data[ct++] = "e1'"; cube1.p_data[ct++] = "f1'";
cube1.p_data[ct++] = "g1'"; cube1.p_data[ct++] = "h1'";
cube1.p_data[ct++] = "i1'";
cube1.p_data[ct++] = "a2'"; cube1.p_data[ct++] = "b2'";
cube1.p_data[ct++] = "c2'"; cube1.p_data[ct++] = "d2'";
cube1.p_data[ct++] = "e2'"; cube1.p_data[ct++] = "f2'";
cube1.p_data[ct++] = "g2'"; cube1.p_data[ct++] = "h2'";
cube1.p_data[ct++] = "i2'";
connector.transfer(&cube1, &cube2);
cube2.logical_print();
connector.report_last_transfer.print();
connector.report_history.print();
connector.transfer(&cube1, &cube2);
connector.report_last_transfer.print();
connector.report_history.print();
}
int main(int argc, char* argv[]) {
if(argc != 6) {
cout << "Usage: " << argv[0] << " <host> <port> <username> <password> <tableName>\n";
return 1;
}
try {
Connector connector(argv[1], atoi(argv[2]), argv[3], argv[4]);
connector.tableOperations().createTable(argv[5]);
connector.close();
return 0;
} catch(AccumuloSecurityException &e) {
cout << "There was a problem with your credentials\n";
}
}
