void Button::rect(const Rect& r) { View::rect(r); Rect svr(0,0,r.width, r.height); imageView->rect(svr); titleLabel->rect(svr); }
TEST(Socket, SimpleReadWrite) { std::thread server([&]() { fp::TCPSocketServer svr("localhost", "6969"); ASSERT_TRUE(svr.connect()); std::shared_ptr<fp::Socket> connection = svr.acceptPendingConnection(); char buffer[16]; int counter = 0; ssize_t size = 0; while(true) { fp::Socket::ReadResult result = connection->read(buffer, 16, size); if (result == fp::Socket::MoreData) { EXPECT_EQ(4, size); EXPECT_STREQ(buffer, "tom"); break; } else if (result == fp::Socket::NoData) { std::this_thread::sleep_for(std::chrono::microseconds(10)); if (counter++ > 1000) { break; } } else if (result == fp::Socket::Closed) { DEBUG_LOG("Socket closed"); break; } } }); std::this_thread::sleep_for(std::chrono::seconds(1)); fp::TCPSocketClient client("localhost", "6969"); ASSERT_TRUE(client.connect()); EXPECT_TRUE(client.send("tom", 4)); // send 4bytes (including \0) server.join(); }
void Button::rect(f32 x, f32 y, f32 w, f32 h) { View::rect(x,y,w,h); Rect svr(0,0,w,h); imageView->rect(svr); titleLabel->rect(svr); }
int main(int argc, char **argv) { member_list_obj_t mlobj; friends_obj_t friends; //msg_list_t msgl_obj; net::SockInit(); objects_t::Init(&mlobj, &friends); net::SockConfig conf = { 11111, 0, "", "" }; svr_t svr(1024, conf); try{ while (true) svr.Run(); } catch (std::exception &e){ cout << e.what() << endl; } net::SockUninit(); return 0; }
void ServiceBrowserPrivate::gotNewService(int,int,const QString& name, const QString& type, const QString& domain, uint) { m_timer.start(TIMEOUT_LAST_SERVICE); RemoteService::Ptr svr(new RemoteService(name, type,domain)); if (m_autoResolve) { connect(svr.data(),SIGNAL(resolved(bool)),this,SLOT(serviceResolved(bool))); m_duringResolve+=svr; svr->resolveAsync(); } else {
int main(int argc, char* argv[]) { try { char const* port = argc > 1 ? argv[1] : "10001"; server svr("127.0.0.1", std::atoi(port)); client cln("127.0.0.1", port); } catch (std::exception& ex) { std::cerr << ex.what() << std::endl; } return 0; }
void PopularUrls::save() { KConfigGroup svr(krConfig, "Private"); // prepare the string list containing urls and int list with ranks QStringList urlList; QList<int> rankList; UrlNodeP p = head; while (p) { urlList << p->url.toDisplayString(); rankList << p->rank; p = p->next; } svr.writeEntry("PopularUrls", urlList); svr.writeEntry("PopularUrlsRank", rankList); }
int main(int argc, char *argv[]) { if (argc < 2) { usage(argv[0]); } if (0 == strncmp("svr", argv[1], strlen(argv[1]))) svr(argc - 1, &argv[1]); else if (0 == strncmp("cli", argv[1], strlen(argv[1]))) cli(argc - 1, &argv[1]); else { usage(argv[0]); } exit(EXIT_SUCCESS); }
int main() { Singleton<ConfigParser>::instance()->parser_file("./svr.conf"); Singleton<ConfigParser>::instance()->scan(); const Section & NetSec = Singleton<ConfigParser>::instance()->get("AppSvr"); Log::init("./run.log"); Log::set_level(1); Log::NOTICE("LOG INIT SUCCES"); AppReactor svr(NetSec); svr.init(); svr.run(); return 0; }
void PopularUrls::load() { KConfigGroup svr(krConfig, "Private"); QStringList urlList = svr.readEntry("PopularUrls", QStringList()); QList<int> rankList = svr.readEntry("PopularUrlsRank", QList<int>()); if (urlList.count() != rankList.count()) { KMessageBox::error(krMainWindow, i18n("The saved 'Popular URLs' are invalid. The list will be cleared.")); return; } clearList(); count = 0; // iterate through both lists and QStringList::Iterator uit; QList<int>::Iterator rit; for (uit = urlList.begin(), rit = rankList.begin(); uit != urlList.end() && rit != rankList.end(); ++uit, ++rit) { UrlNodeP node = new UrlNode; node->url = QUrl(*uit); node->rank = *rit; appendNode(node); ranks.insert(*uit, node); } }
TEST(Socket, NonBlockingReadWrite) { bool callbackFired = false; LOG_LEVEL(tf::logger::info); fp::Session::initialise(); std::thread server([&]() { DEBUG_LOG("Started server thread"); fp::TCPSocketServer svr("localhost", "6967"); ASSERT_TRUE(svr.connect()); std::shared_ptr<fp::Socket> connection = svr.acceptPendingConnection(); DEBUG_LOG("Accepted connection"); char buffer[16]; int counter = 0; ssize_t size = 0; while(true) { fp::Socket::ReadResult result = connection->read(buffer, 16, size); if (result == fp::Socket::MoreData) { DEBUG_LOG("Server received data"); EXPECT_EQ(6, size); EXPECT_STREQ(buffer, "hello"); break; } else if (result == fp::Socket::NoData) { std::this_thread::sleep_for(std::chrono::microseconds(10)); if (counter++ > 1000) { break; } } else if (result == fp::Socket::Closed) { DEBUG_LOG("Socket closed"); break; } } DEBUG_LOG("Server sending data"); EXPECT_TRUE(connection->send("goodbye", 8)); std::this_thread::sleep_for(std::chrono::milliseconds(100)); }); std::this_thread::sleep_for(std::chrono::milliseconds(100)); fp::TCPSocketClient client("localhost", "6967"); fp::BusySpinQueue queue; DEBUG_LOG("Client attempting to connect"); ASSERT_TRUE(client.connect(fp::SocketOptionsDisableSigPipe)); EXPECT_NE(-1, client.getSocket()); DEBUG_LOG("Client connected"); /*fp::IOEvent *handler = */queue.registerEvent(client.getSocket(), fp::EventType::READ, [&](const fp::DataEvent *event, fp::EventType eventType) { EXPECT_EQ(fp::EventType::READ, eventType); DEBUG_LOG("Client received data"); callbackFired = true; int counter = 0; char buffer[16]; ssize_t size = 0; while(true) { fp::Socket::ReadResult result = client.read(buffer, 16, size); if (result == fp::Socket::MoreData) { EXPECT_EQ(8, size); EXPECT_STREQ(buffer, "goodbye"); break; } else if (result == fp::Socket::NoData) { std::this_thread::sleep_for(std::chrono::microseconds(10)); if (counter++ > 1000) { break; } } else if (result == fp::Socket::Closed) { DEBUG_LOG("Socket closed"); break; } } }); DEBUG_LOG("Client sending data"); EXPECT_TRUE(client.send("hello", 6)); queue.dispatch(std::chrono::seconds(5)); EXPECT_TRUE(callbackFired); server.join(); fp::Session::destroy(); }
TEST(Socket, NonBlockingServerReadWrite) { bool callbackFired = false; LOG_LEVEL(tf::logger::info); fp::Session::initialise(); std::thread server([&]() { fp::TCPSocketServer svr("localhost", "6966"); ASSERT_TRUE(svr.connect(fp::SocketOptionsNonBlocking)); ASSERT_NE(-1, svr.getSocket()); std::shared_ptr<fp::Socket> connection; bool finished = false; fp::BusySpinQueue queue; auto client = [&](const fp::DataEvent *event, int eventType) { EXPECT_EQ(fp::EventType::READ, eventType); char buffer[16]; int counter = 0; ssize_t size = 0; while (true) { fp::Socket::ReadResult result = connection->read(buffer, 16, size); DEBUG_LOG("got stuff"); if (result == fp::Socket::MoreData) { EXPECT_EQ(6, size); EXPECT_STREQ(buffer, "hello"); break; } else if (result == fp::Socket::NoData) { std::this_thread::sleep_for(std::chrono::microseconds(10)); if (counter++ > 1000) { break; } } else if (result == fp::Socket::Closed) { DEBUG_LOG("Server Socket closed"); break; } } EXPECT_TRUE(connection->send("goodbye", 8)); finished = true; }; fp::DataEvent *clientHandler = nullptr; fp::DataEvent *handler = queue.registerEvent(svr.getSocket(), fp::EventType::READ, [&](const fp::DataEvent *event, int eventType) { EXPECT_EQ(fp::EventType::READ, eventType); DEBUG_LOG("entering accept"); connection = svr.acceptPendingConnection(); if (connection != nullptr) { DEBUG_LOG("out of accept"); clientHandler = queue.registerEvent(connection->getSocket(), fp::EventType::READ, client); DEBUG_LOG("registered new client"); } }); for (int i = 0; !finished && i < 15; i++) { DEBUG_LOG("wait..."); queue.dispatch(std::chrono::milliseconds(1000)); DEBUG_LOG("...serviced event"); } queue.unregisterEvent(handler); queue.unregisterEvent(clientHandler); }); fp::BusySpinQueue queue; std::this_thread::sleep_for(std::chrono::microseconds(100)); fp::TCPSocketClient client("localhost", "6966"); ASSERT_TRUE(client.connect(fp::SocketOptionsDisableSigPipe)); EXPECT_NE(-1, client.getSocket()); /*fp::DataEvent *handler = */queue.registerEvent(client.getSocket(), fp::EventType::READ, [&](const fp::DataEvent *event, int eventType) { EXPECT_EQ(fp::EventType::READ, eventType); callbackFired = true; int counter = 0; char buffer[16]; ssize_t size = 0; while(true) { fp::Socket::ReadResult result = client.read(buffer, 16, size); if (result == fp::Socket::MoreData) { EXPECT_EQ(8, size); EXPECT_STREQ(buffer, "goodbye"); break; } else if (result == fp::Socket::NoData) { std::this_thread::sleep_for(std::chrono::microseconds(10)); if (counter++ > 1000) { break; } } else if (result == fp::Socket::Closed) { DEBUG_LOG("Client Socket closed"); break; } } }); EXPECT_TRUE(client.send("hello", 6)); queue.dispatch(std::chrono::seconds(5)); EXPECT_TRUE(callbackFired); server.join(); fp::Session::destroy(); }