1 files changed, 16 insertions, 5 deletions
diff --git a/Swiften/QA/NetworkTest/BoostConnectionTest.cpp b/Swiften/QA/NetworkTest/BoostConnectionTest.cpp
index 12c4a77..e0890bf 100755
--- a/Swiften/QA/NetworkTest/BoostConnectionTest.cpp
+++ b/Swiften/QA/NetworkTest/BoostConnectionTest.cpp
@@ -26,118 +26,129 @@ class BoostConnectionTest : public CppUnit::TestFixture {
         CPPUNIT_TEST_SUITE(BoostConnectionTest);
         CPPUNIT_TEST(testDestructor);
         CPPUNIT_TEST(testDestructor_PendingEvents);
         CPPUNIT_TEST(testWrite);
         CPPUNIT_TEST(testWriteMultipleSimultaniouslyQueuesWrites);
 #ifdef TEST_IPV6
         CPPUNIT_TEST(testWrite_IPv6);
 #endif
         CPPUNIT_TEST_SUITE_END();
 
     public:
         void setUp() {
             eventLoop_ = new DummyEventLoop();
             boostIOServiceThread_ = new BoostIOServiceThread();
             boostIOService_ = std::make_shared<boost::asio::io_service>();
             disconnected_ = false;
             connectFinished_ = false;
         }
 
         void tearDown() {
             delete boostIOServiceThread_;
             while (eventLoop_->hasEvents()) {
                 eventLoop_->processEvents();
             }
             delete eventLoop_;
         }
 
         void testDestructor() {
             {
                 BoostConnection::ref testling(BoostConnection::create(boostIOServiceThread_->getIOService(), eventLoop_));
-                testling->connect(HostAddressPort(HostAddress(getenv("SWIFT_NETWORK_TEST_IPV4")), 5222));
+                auto hostAddress = HostAddress::fromString(getenv("SWIFT_NETWORK_TEST_IPV4"));
+                CPPUNIT_ASSERT_EQUAL(true, hostAddress.is_initialized());
+                testling->connect(HostAddressPort(hostAddress.get(), 5222));
             }
         }
 
         void testDestructor_PendingEvents() {
             {
                 BoostConnection::ref testling(BoostConnection::create(boostIOServiceThread_->getIOService(), eventLoop_));
-                testling->connect(HostAddressPort(HostAddress(getenv("SWIFT_NETWORK_TEST_IPV4")), 5222));
+                auto hostAddress = HostAddress::fromString(getenv("SWIFT_NETWORK_TEST_IPV4"));
+                CPPUNIT_ASSERT_EQUAL(true, hostAddress.is_initialized());
+                testling->connect(HostAddressPort(hostAddress.get(), 5222));
                 while (!eventLoop_->hasEvents()) {
                     Swift::sleep(10);
                 }
             }
             eventLoop_->processEvents();
         }
 
         void testWrite() {
             using namespace boost::posix_time;
 
             BoostConnection::ref testling(BoostConnection::create(boostIOServiceThread_->getIOService(), eventLoop_));
             testling->onConnectFinished.connect(boost::bind(&BoostConnectionTest::doWrite, this, testling.get()));
             testling->onDataRead.connect(boost::bind(&BoostConnectionTest::handleDataRead, this, _1));
             testling->onDisconnected.connect(boost::bind(&BoostConnectionTest::handleDisconnected, this));
-            testling->connect(HostAddressPort(HostAddress(getenv("SWIFT_NETWORK_TEST_IPV4")), 5222));
+            auto hostAddress = HostAddress::fromString(getenv("SWIFT_NETWORK_TEST_IPV4"));
+            CPPUNIT_ASSERT_EQUAL(true, hostAddress.is_initialized());
+            testling->connect(HostAddressPort(hostAddress.get(), 5222));
 
             boost::posix_time::ptime start = second_clock::local_time();
             while (receivedData_.empty() && ((second_clock::local_time() - start) < seconds(60)))  {
                 Swift::sleep(10);
                 eventLoop_->processEvents();
             }
             CPPUNIT_ASSERT_EQUAL(false, receivedData_.empty());
             testling->disconnect();
         }
 
         void testWrite_IPv6() {
             using namespace boost::posix_time;
 
             BoostConnection::ref testling(BoostConnection::create(boostIOServiceThread_->getIOService(), eventLoop_));
             testling->onConnectFinished.connect(boost::bind(&BoostConnectionTest::doWrite, this, testling.get()));
             testling->onDataRead.connect(boost::bind(&BoostConnectionTest::handleDataRead, this, _1));
             testling->onDisconnected.connect(boost::bind(&BoostConnectionTest::handleDisconnected, this));
-            testling->connect(HostAddressPort(HostAddress(getenv("SWIFT_NETWORK_TEST_IPV6")), 5222));
+            auto hostAddress = HostAddress::fromString(getenv("SWIFT_NETWORK_TEST_IPV6"));
+            CPPUNIT_ASSERT_EQUAL(true, hostAddress.is_initialized());
+            testling->connect(HostAddressPort(hostAddress.get(), 5222));
 
             boost::posix_time::ptime start = second_clock::local_time();
             while (receivedData_.empty() && ((second_clock::local_time() - start) < seconds(60)))  {
                 Swift::sleep(10);
                 eventLoop_->processEvents();
             }
             CPPUNIT_ASSERT_EQUAL(false, receivedData_.empty());
             testling->disconnect();
         }
 
 
         void testWriteMultipleSimultaniouslyQueuesWrites() {
             BoostConnection::ref testling(BoostConnection::create(boostIOService_, eventLoop_));
             testling->onConnectFinished.connect(boost::bind(&BoostConnectionTest::handleConnectFinished, this));
             testling->onDataRead.connect(boost::bind(&BoostConnectionTest::handleDataRead, this, _1));
             testling->onDisconnected.connect(boost::bind(&BoostConnectionTest::handleDisconnected, this));
-            testling->connect(HostAddressPort(HostAddress(getenv("SWIFT_NETWORK_TEST_IPV4")), 5222));
+
+            auto hostAddress = HostAddress::fromString(getenv("SWIFT_NETWORK_TEST_IPV4"));
+            CPPUNIT_ASSERT_EQUAL(true, hostAddress.is_initialized());
+            testling->connect(HostAddressPort(hostAddress.get(), 5222));
             while (!connectFinished_) {
                 boostIOService_->run_one();
                 eventLoop_->processEvents();
             }
 
             testling->write(createSafeByteArray("<stream:strea"));
             testling->write(createSafeByteArray("m"));
             testling->write(createSafeByteArray(">"));
 
              // Check that we only did one write event, the others are queued
             /*int runHandlers = */boostIOService_->poll();
             // Disabling this test, because poll runns all handlers that are added during poll() as well, so
             // this test doesn't really work any more. We'll have to trust that things are queued.
             //CPPUNIT_ASSERT_EQUAL(1, runHandlers);
             // Process the other events
             while (receivedData_.empty()) {
                 boostIOService_->run_one();
                 eventLoop_->processEvents();
             }
 
             // Disconnect & clean up
             testling->disconnect();
             while (!disconnected_) {
                 boostIOService_->run_one();
                 eventLoop_->processEvents();
             }
         }
 
         void doWrite(BoostConnection* connection) {
             connection->write(createSafeByteArray("<stream:stream>"));