6 files changed, 31 insertions, 33 deletions
diff --git a/Swiften/Network/UnitTest/BOSHConnectionPoolTest.cpp b/Swiften/Network/UnitTest/BOSHConnectionPoolTest.cpp
index 8dbd09e..5d6fedd 100644
--- a/Swiften/Network/UnitTest/BOSHConnectionPoolTest.cpp
+++ b/Swiften/Network/UnitTest/BOSHConnectionPoolTest.cpp
@@ -42,61 +42,61 @@ class BOSHConnectionPoolTest : public CppUnit::TestFixture {
     CPPUNIT_TEST(testSession);
     CPPUNIT_TEST(testWrite_Empty);
     CPPUNIT_TEST_SUITE_END();
 
     public:
         void setUp() {
             to = "wonderland.lit";
             path = "/http-bind";
             port = "5280";
             sid = "MyShinySID";
             initial = "<body wait='60' "
                     "inactivity='30' "
                     "polling='5' "
                     "requests='2' "
                     "hold='1' "
                     "maxpause='120' "
                     "sid='" + sid + "' "
                     "ver='1.6' "
                     "from='wonderland.lit' "
                     "xmlns='http://jabber.org/protocol/httpbind'/>";
             eventLoop = new DummyEventLoop();
             connectionFactory = new MockConnectionFactory(eventLoop);
             boshURL = URL("http", to, 5280, path);
             sessionTerminated = 0;
             sessionStarted = 0;
             initialRID = 2349876;
             xmppDataRead.clear();
             boshDataRead.clear();
             boshDataWritten.clear();
             resolver = new StaticDomainNameResolver(eventLoop);
-            resolver->addAddress(to, HostAddress("127.0.0.1"));
+            resolver->addAddress(to, HostAddress::fromString("127.0.0.1").get());
             timerFactory = new DummyTimerFactory();
         }
 
         void tearDown() {
             eventLoop->processEvents();
             delete connectionFactory;
             delete resolver;
             delete timerFactory;
             delete eventLoop;
         }
 
         void testConnectionCount_OneWrite() {
             PoolRef testling = createTestling();
             CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());
             eventLoop->processEvents();
             CPPUNIT_ASSERT_EQUAL(0, sessionStarted);
             readResponse(initial, connectionFactory->connections[0]);
             CPPUNIT_ASSERT_EQUAL(1, sessionStarted);
             CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());
             testling->write(createSafeByteArray("<blah/>"));
             eventLoop->processEvents();
             CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());
             CPPUNIT_ASSERT_EQUAL(1, sessionStarted);
         }
 
         void testConnectionCount_TwoWrites() {
             PoolRef testling = createTestling();
             CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());
             eventLoop->processEvents();
             readResponse(initial, connectionFactory->connections[0]);
@@ -207,61 +207,61 @@ class BOSHConnectionPoolTest : public CppUnit::TestFixture {
             CPPUNIT_ASSERT(c1->pending);
             CPPUNIT_ASSERT_EQUAL(st(4), boshDataWritten.size()); /* don't send empty in [0], still have [1] waiting */
             CPPUNIT_ASSERT_EQUAL(st(2), connectionFactory->connections.size());
 
             rid++;
             readResponse("<body xmlns='http://jabber.org/protocol/httpbind'><message><splatploing><blittlebarg/></splatploing></message></body>", c1);
             eventLoop->processEvents();
             CPPUNIT_ASSERT(!c1->pending);
             CPPUNIT_ASSERT(c0->pending);
             CPPUNIT_ASSERT_EQUAL(st(5), boshDataWritten.size()); /* empty to make room */
             CPPUNIT_ASSERT_EQUAL(st(2), connectionFactory->connections.size());
 
             rid++;
             testling->write(createSafeByteArray("<bleh/>"));
             eventLoop->processEvents();
             CPPUNIT_ASSERT(c0->pending);
             CPPUNIT_ASSERT(c1->pending);
             CPPUNIT_ASSERT_EQUAL(st(6), boshDataWritten.size()); /* data */
 
             rid++;
             testling->write(createSafeByteArray("<bluh/>"));
             CPPUNIT_ASSERT(c0->pending);
             CPPUNIT_ASSERT(c1->pending);
             CPPUNIT_ASSERT_EQUAL(st(6), boshDataWritten.size()); /* Don't send data, no room */
             eventLoop->processEvents();
             CPPUNIT_ASSERT_EQUAL(st(2), connectionFactory->connections.size());
         }
 
         void testSession() {
             to = "prosody.doomsong.co.uk";
-            resolver->addAddress("prosody.doomsong.co.uk", HostAddress("127.0.0.1"));
+            resolver->addAddress("prosody.doomsong.co.uk", HostAddress::fromString("127.0.0.1").get());
             path = "/http-bind/";
             boshURL = URL("http", to, 5280, path);
 
             PoolRef testling = createTestling();
             CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());
             eventLoop->processEvents();
             CPPUNIT_ASSERT_EQUAL(st(1), boshDataWritten.size()); /* header*/
             CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());
 
             std::string response = "<body authid='743da605-4c2e-4de1-afac-ac040dd4a940' xmpp:version='1.0' xmlns:stream='http://etherx.jabber.org/streams' xmlns:xmpp='urn:xmpp:xbosh' inactivity='60' wait='60' polling='5' secure='true' hold='1' from='prosody.doomsong.co.uk' ver='1.6' sid='743da605-4c2e-4de1-afac-ac040dd4a940' requests='2' xmlns='http://jabber.org/protocol/httpbind'><stream:features><auth xmlns='http://jabber.org/features/iq-auth'/><mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'><mechanism>SCRAM-SHA-1</mechanism><mechanism>DIGEST-MD5</mechanism></mechanisms></stream:features></body>";
             readResponse(response, connectionFactory->connections[0]);
             eventLoop->processEvents();
             CPPUNIT_ASSERT_EQUAL(st(1), boshDataWritten.size());
             CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());
 
             std::string send = "<auth xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\" mechanism=\"SCRAM-SHA-1\">biwsbj1hZG1pbixyPWZhOWE5ZDhiLWZmMDctNGE4Yy04N2E3LTg4YWRiNDQxZGUwYg==</auth>";
             testling->write(createSafeByteArray(send));
             eventLoop->processEvents();
             CPPUNIT_ASSERT_EQUAL(st(2), boshDataWritten.size());
             CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());
 
             response = "<body xmlns='http://jabber.org/protocol/httpbind' sid='743da605-4c2e-4de1-afac-ac040dd4a940' xmlns:stream = 'http://etherx.jabber.org/streams'><challenge xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>cj1mYTlhOWQ4Yi1mZjA3LTRhOGMtODdhNy04OGFkYjQ0MWRlMGJhZmZlMWNhMy1mMDJkLTQ5NzEtYjkyNS0yM2NlNWQ2MDQyMjYscz1OVGd5WkdWaFptTXRaVE15WXkwMFpXUmhMV0ZqTURRdFpqYzRNbUppWmpGa1pqWXgsaT00MDk2</challenge></body>";
             readResponse(response, connectionFactory->connections[0]);
             eventLoop->processEvents();
             CPPUNIT_ASSERT_EQUAL(st(2), boshDataWritten.size());
             CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());
 
             send = "<response xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">Yz1iaXdzLHI9ZmE5YTlkOGItZmYwNy00YThjLTg3YTctODhhZGI0NDFkZTBiYWZmZTFjYTMtZjAyZC00OTcxLWI5MjUtMjNjZTVkNjA0MjI2LHA9aU11NWt3dDN2VWplU2RqL01Jb3VIRldkZjBnPQ==</response>";
             testling->write(createSafeByteArray(send));
             eventLoop->processEvents();
diff --git a/Swiften/Network/UnitTest/BOSHConnectionTest.cpp b/Swiften/Network/UnitTest/BOSHConnectionTest.cpp
index a791e96..99dd462 100644
--- a/Swiften/Network/UnitTest/BOSHConnectionTest.cpp
+++ b/Swiften/Network/UnitTest/BOSHConnectionTest.cpp
@@ -166,61 +166,61 @@ class BOSHConnectionTest : public CppUnit::TestFixture {
                 "</body>"));
             connection->onDataRead(data1);
             connection->onDataRead(data2);
             CPPUNIT_ASSERT(dataRead.empty());
             connection->onDataRead(data3);
             CPPUNIT_ASSERT_EQUAL(std::string("<blah/>"), byteArrayToString(dataRead));
         }
 
         void testHTTPRequest() {
             std::string data = "<blah/>";
             std::string sid = "wigglebloom";
             std::string fullBody = "<body xmlns='http://jabber.org/protocol/httpbind' sid='" + sid + "' rid='20'>" + data + "</body>";
             std::pair<SafeByteArray, size_t> http = BOSHConnection::createHTTPRequest(createSafeByteArray(data), false, false, 20, sid, URL());
             CPPUNIT_ASSERT_EQUAL(fullBody.size(), http.second);
         }
 
         void testHTTPRequest_Empty() {
             std::string data = "";
             std::string sid = "wigglebloomsickle";
             std::string fullBody = "<body rid='42' sid='" + sid + "' xmlns='http://jabber.org/protocol/httpbind'>" + data + "</body>";
             std::pair<SafeByteArray, size_t> http = BOSHConnection::createHTTPRequest(createSafeByteArray(data), false, false, 42, sid, URL());
             CPPUNIT_ASSERT_EQUAL(fullBody.size(), http.second);
             std::string response = safeByteArrayToString(http.first);
             size_t bodyPosition = response.find("\r\n\r\n");
             CPPUNIT_ASSERT_EQUAL(fullBody, response.substr(bodyPosition+4));
         }
 
     private:
 
         BOSHConnection::ref createTestling() {
-            resolver->addAddress("wonderland.lit", HostAddress("127.0.0.1"));
+            resolver->addAddress("wonderland.lit", HostAddress::fromString("127.0.0.1").get());
             Connector::ref connector = Connector::create("wonderland.lit", 5280, boost::optional<std::string>(), resolver, connectionFactory, timerFactory);
             BOSHConnection::ref c = BOSHConnection::create(URL("http", "wonderland.lit", 5280, "/http-bind"), connector, &parserFactory, tlsContextFactory, TLSOptions());
             c->onConnectFinished.connect(boost::bind(&BOSHConnectionTest::handleConnectFinished, this, _1));
             c->onDisconnected.connect(boost::bind(&BOSHConnectionTest::handleDisconnected, this, _1));
             c->onXMPPDataRead.connect(boost::bind(&BOSHConnectionTest::handleDataRead, this, _1));
             c->onSessionStarted.connect(boost::bind(&BOSHConnectionTest::handleSID, this, _1));
             c->setRID(42);
             return c;
         }
 
         void handleConnectFinished(bool error) {
             connectFinished = true;
             connectFinishedWithError = error;
         }
 
         void handleDisconnected(bool e) {
             disconnected = true;
             disconnectedError = e;
         }
 
         void handleDataRead(const SafeByteArray& d) {
             append(dataRead, d);
         }
 
         void handleSID(const std::string& s) {
             sid = s;
         }
 
         struct MockConnection : public Connection {
             public:
diff --git a/Swiften/Network/UnitTest/ChainedConnectorTest.cpp b/Swiften/Network/UnitTest/ChainedConnectorTest.cpp
index 3fad433..2d78cd7 100644
--- a/Swiften/Network/UnitTest/ChainedConnectorTest.cpp
+++ b/Swiften/Network/UnitTest/ChainedConnectorTest.cpp
@@ -7,61 +7,61 @@
 #include <memory>
 
 #include <boost/bind.hpp>
 
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
 #include <Swiften/EventLoop/DummyEventLoop.h>
 #include <Swiften/Network/ChainedConnector.h>
 #include <Swiften/Network/Connection.h>
 #include <Swiften/Network/ConnectionFactory.h>
 #include <Swiften/Network/DomainNameResolveError.h>
 #include <Swiften/Network/DummyTimerFactory.h>
 #include <Swiften/Network/HostAddressPort.h>
 #include <Swiften/Network/StaticDomainNameResolver.h>
 
 using namespace Swift;
 
 class ChainedConnectorTest : public CppUnit::TestFixture {
         CPPUNIT_TEST_SUITE(ChainedConnectorTest);
         CPPUNIT_TEST(testConnect_FirstConnectorSucceeds);
         CPPUNIT_TEST(testConnect_SecondConnectorSucceeds);
         CPPUNIT_TEST(testConnect_NoConnectorSucceeds);
         CPPUNIT_TEST(testConnect_NoDNS);
         CPPUNIT_TEST(testStop);
         CPPUNIT_TEST_SUITE_END();
 
     public:
         void setUp() {
             error.reset();
-            host = HostAddressPort(HostAddress("1.1.1.1"), 1234);
+            host = HostAddressPort(HostAddress::fromString("1.1.1.1").get(), 1234);
             eventLoop = new DummyEventLoop();
             resolver = new StaticDomainNameResolver(eventLoop);
             resolver->addXMPPClientService("foo.com", host);
             connectionFactory1 = new MockConnectionFactory(eventLoop, 1);
             connectionFactory2 = new MockConnectionFactory(eventLoop, 2);
             timerFactory = new DummyTimerFactory();
         }
 
         void tearDown() {
             delete timerFactory;
             delete connectionFactory2;
             delete connectionFactory1;
             delete resolver;
             delete eventLoop;
         }
 
         void testConnect_FirstConnectorSucceeds() {
             std::shared_ptr<ChainedConnector> testling(createConnector());
             connectionFactory1->connects = true;
             connectionFactory2->connects = false;
 
             testling->start();
             eventLoop->processEvents();
 
             CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));
             CPPUNIT_ASSERT(connections[0]);
             CPPUNIT_ASSERT_EQUAL(1, std::dynamic_pointer_cast<MockConnection>(connections[0])->id);
             CPPUNIT_ASSERT(!std::dynamic_pointer_cast<DomainNameResolveError>(error));
         }
 
diff --git a/Swiften/Network/UnitTest/ConnectorTest.cpp b/Swiften/Network/UnitTest/ConnectorTest.cpp
index 20ad68d..8524439 100644
--- a/Swiften/Network/UnitTest/ConnectorTest.cpp
+++ b/Swiften/Network/UnitTest/ConnectorTest.cpp
@@ -16,63 +16,63 @@
 #include <Swiften/Network/Connector.h>
 #include <Swiften/Network/DomainNameAddressQuery.h>
 #include <Swiften/Network/DummyTimerFactory.h>
 #include <Swiften/Network/HostAddressPort.h>
 #include <Swiften/Network/StaticDomainNameResolver.h>
 
 using namespace Swift;
 
 class ConnectorTest : public CppUnit::TestFixture {
         CPPUNIT_TEST_SUITE(ConnectorTest);
         CPPUNIT_TEST(testConnect);
         CPPUNIT_TEST(testConnect_NoServiceLookups);
         CPPUNIT_TEST(testConnect_NoServiceLookups_DefaultPort);
         CPPUNIT_TEST(testConnect_FirstAddressHostFails);
         CPPUNIT_TEST(testConnect_NoSRVHost);
         CPPUNIT_TEST(testConnect_NoHosts);
         CPPUNIT_TEST(testConnect_FirstSRVHostFails);
         CPPUNIT_TEST(testConnect_AllSRVHostsFailWithoutFallbackHost);
         CPPUNIT_TEST(testConnect_AllSRVHostsFailWithFallbackHost);
         CPPUNIT_TEST(testConnect_SRVAndFallbackHostsFail);
         //CPPUNIT_TEST(testConnect_TimeoutDuringResolve);
         CPPUNIT_TEST(testConnect_TimeoutDuringConnectToOnlyCandidate);
         CPPUNIT_TEST(testConnect_TimeoutDuringConnectToCandidateFallsBack);
         CPPUNIT_TEST(testConnect_NoTimeout);
         CPPUNIT_TEST(testStop_DuringSRVQuery);
         CPPUNIT_TEST(testStop_Timeout);
         CPPUNIT_TEST_SUITE_END();
 
     public:
         void setUp() {
-            host1 = HostAddressPort(HostAddress("1.1.1.1"), 1234);
-            host2 = HostAddressPort(HostAddress("2.2.2.2"), 2345);
-            host3 = HostAddressPort(HostAddress("3.3.3.3"), 5222);
+            host1 = HostAddressPort(HostAddress::fromString("1.1.1.1").get(), 1234);
+            host2 = HostAddressPort(HostAddress::fromString("2.2.2.2").get(), 2345);
+            host3 = HostAddressPort(HostAddress::fromString("3.3.3.3").get(), 5222);
             eventLoop = new DummyEventLoop();
             resolver = new StaticDomainNameResolver(eventLoop);
             connectionFactory = new MockConnectionFactory(eventLoop);
             timerFactory = new DummyTimerFactory();
         }
 
         void tearDown() {
             delete timerFactory;
             delete connectionFactory;
             delete resolver;
             delete eventLoop;
         }
 
         void testConnect() {
             Connector::ref testling(createConnector());
             resolver->addXMPPClientService("foo.com", host1);
             resolver->addXMPPClientService("foo.com", host2);
             resolver->addAddress("foo.com", host3.getAddress());
 
             testling->start();
             eventLoop->processEvents();
 
             CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));
             CPPUNIT_ASSERT(connections[0]);
             CPPUNIT_ASSERT(host1 == *(connections[0]->hostAddressPort));
             CPPUNIT_ASSERT(!std::dynamic_pointer_cast<DomainNameResolveError>(error));
         }
 
         void testConnect_NoServiceLookups() {
             Connector::ref testling(createConnector(4321, boost::optional<std::string>()));
@@ -95,62 +95,62 @@ class ConnectorTest : public CppUnit::TestFixture {
             resolver->addXMPPClientService("foo.com", host1);
             resolver->addXMPPClientService("foo.com", host2);
             resolver->addAddress("foo.com", host3.getAddress());
 
             testling->start();
             eventLoop->processEvents();
 
             CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));
             CPPUNIT_ASSERT(connections[0]);
             CPPUNIT_ASSERT(host3.getAddress() == (*(connections[0]->hostAddressPort)).getAddress());
             CPPUNIT_ASSERT_EQUAL(5222, (*(connections[0]->hostAddressPort)).getPort());
             CPPUNIT_ASSERT(!std::dynamic_pointer_cast<DomainNameResolveError>(error));
         }
 
         void testConnect_NoSRVHost() {
             Connector::ref testling(createConnector());
             resolver->addAddress("foo.com", host3.getAddress());
 
             testling->start();
             eventLoop->processEvents();
 
             CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));
             CPPUNIT_ASSERT(connections[0]);
             CPPUNIT_ASSERT(host3 == *(connections[0]->hostAddressPort));
             CPPUNIT_ASSERT(!std::dynamic_pointer_cast<DomainNameResolveError>(error));
         }
 
         void testConnect_FirstAddressHostFails() {
             Connector::ref testling(createConnector());
 
-            HostAddress address1("1.1.1.1");
-            HostAddress address2("2.2.2.2");
+            auto address1 = HostAddress::fromString("1.1.1.1").get();
+            auto address2 = HostAddress::fromString("2.2.2.2").get();
             resolver->addXMPPClientService("foo.com", "host-foo.com", 1234);
             resolver->addAddress("host-foo.com", address1);
             resolver->addAddress("host-foo.com", address2);
             connectionFactory->failingPorts.push_back(HostAddressPort(address1, 1234));
 
             testling->start();
             eventLoop->processEvents();
 
             CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));
             CPPUNIT_ASSERT(connections[0]);
             CPPUNIT_ASSERT(HostAddressPort(address2, 1234) == *(connections[0]->hostAddressPort));
             CPPUNIT_ASSERT(!std::dynamic_pointer_cast<DomainNameResolveError>(error));
         }
 
         void testConnect_NoHosts() {
             Connector::ref testling(createConnector());
 
             testling->start();
             eventLoop->processEvents();
 
             CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));
             CPPUNIT_ASSERT(!connections[0]);
             CPPUNIT_ASSERT(std::dynamic_pointer_cast<DomainNameResolveError>(error));
         }
 
         void testConnect_FirstSRVHostFails() {
             Connector::ref testling(createConnector());
             resolver->addXMPPClientService("foo.com", host1);
             resolver->addXMPPClientService("foo.com", host2);
             connectionFactory->failingPorts.push_back(host1);
@@ -218,64 +218,64 @@ class ConnectorTest : public CppUnit::TestFixture {
             testling->start();
             eventLoop->processEvents();
             timerFactory->setTime(10);
             eventLoop->processEvents();
 
             CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));
             CPPUNIT_ASSERT(std::dynamic_pointer_cast<DomainNameResolveError>(error));
             CPPUNIT_ASSERT(!connections[0]);
         }*/
 
         void testConnect_TimeoutDuringConnectToOnlyCandidate() {
             Connector::ref testling(createConnector());
             testling->setTimeoutMilliseconds(10);
             resolver->addXMPPClientService("foo.com", host1);
             connectionFactory->isResponsive = false;
 
             testling->start();
             eventLoop->processEvents();
             timerFactory->setTime(10);
             eventLoop->processEvents();
 
             CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));
             CPPUNIT_ASSERT(!connections[0]);
             CPPUNIT_ASSERT(!std::dynamic_pointer_cast<DomainNameResolveError>(error));
         }
 
         void testConnect_TimeoutDuringConnectToCandidateFallsBack() {
             Connector::ref testling(createConnector());
             testling->setTimeoutMilliseconds(10);
 
+            auto address2 = HostAddress::fromString("2.2.2.2").get();
+
             resolver->addXMPPClientService("foo.com", "host-foo.com", 1234);
-            HostAddress address1("1.1.1.1");
-            resolver->addAddress("host-foo.com", address1);
-            HostAddress address2("2.2.2.2");
+            resolver->addAddress("host-foo.com", HostAddress::fromString("1.1.1.1").get());
             resolver->addAddress("host-foo.com", address2);
 
             connectionFactory->isResponsive = false;
             testling->start();
             eventLoop->processEvents();
             connectionFactory->isResponsive = true;
             timerFactory->setTime(10);
             eventLoop->processEvents();
 
             CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));
             CPPUNIT_ASSERT(connections[0]);
             CPPUNIT_ASSERT(HostAddressPort(address2, 1234) == *(connections[0]->hostAddressPort));
             CPPUNIT_ASSERT(!std::dynamic_pointer_cast<DomainNameResolveError>(error));
         }
 
 
         void testConnect_NoTimeout() {
             Connector::ref testling(createConnector());
             testling->setTimeoutMilliseconds(10);
             resolver->addXMPPClientService("foo.com", host1);
 
             testling->start();
             eventLoop->processEvents();
             timerFactory->setTime(10);
             eventLoop->processEvents();
 
             CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));
             CPPUNIT_ASSERT(connections[0]);
             CPPUNIT_ASSERT(!std::dynamic_pointer_cast<DomainNameResolveError>(error));
         }
diff --git a/Swiften/Network/UnitTest/HTTPConnectProxiedConnectionTest.cpp b/Swiften/Network/UnitTest/HTTPConnectProxiedConnectionTest.cpp
index 232847b..1a160b7 100644
--- a/Swiften/Network/UnitTest/HTTPConnectProxiedConnectionTest.cpp
+++ b/Swiften/Network/UnitTest/HTTPConnectProxiedConnectionTest.cpp
@@ -1,331 +1,329 @@
 /*
  * Copyright (c) 2010-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <memory>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/bind.hpp>
 #include <boost/lexical_cast.hpp>
 #include <boost/optional.hpp>
 
 #include <QA/Checker/IO.h>
 
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
 #include <Swiften/Base/Algorithm.h>
 #include <Swiften/Base/Log.h>
-#include <Swiften/Base/foreach.h>
 #include <Swiften/EventLoop/DummyEventLoop.h>
 #include <Swiften/Network/Connection.h>
 #include <Swiften/Network/ConnectionFactory.h>
 #include <Swiften/Network/DummyTimerFactory.h>
 #include <Swiften/Network/HTTPConnectProxiedConnection.h>
 #include <Swiften/Network/HTTPTrafficFilter.h>
 #include <Swiften/Network/HostAddressPort.h>
 #include <Swiften/Network/StaticDomainNameResolver.h>
 
 using namespace Swift;
 
 namespace {
     class ExampleHTTPTrafficFilter : public HTTPTrafficFilter {
         public:
             ExampleHTTPTrafficFilter() {}
             virtual ~ExampleHTTPTrafficFilter() {}
 
             virtual std::vector<std::pair<std::string, std::string> > filterHTTPResponseHeader(const std::string& /* statusLine */, const std::vector<std::pair<std::string, std::string> >& response) {
                 filterResponses.push_back(response);
                 SWIFT_LOG(debug) << std::endl;
                 return filterResponseReturn;
             }
 
             std::vector<std::vector<std::pair<std::string, std::string> > > filterResponses;
 
             std::vector<std::pair<std::string, std::string> > filterResponseReturn;
     };
 
     class ProxyAuthenticationHTTPTrafficFilter : public HTTPTrafficFilter {
             static std::string to_lower(const std::string& str) {
                 std::string lower = str;
                 boost::algorithm::to_lower(lower);
                 return lower;
             }
 
         public:
             ProxyAuthenticationHTTPTrafficFilter() {}
             virtual ~ProxyAuthenticationHTTPTrafficFilter() {}
 
             virtual std::vector<std::pair<std::string, std::string> > filterHTTPResponseHeader(const std::string& statusLine, const std::vector<std::pair<std::string, std::string> >& response) {
                 std::vector<std::pair<std::string, std::string> > filterResponseReturn;
                 std::vector<std::string> statusLineFields;
                 boost::split(statusLineFields, statusLine, boost::is_any_of(" "), boost::token_compress_on);
 
                 int statusCode = boost::lexical_cast<int>(statusLineFields[1]);
                 if (statusCode == 407) {
-                    typedef std::pair<std::string, std::string> StrPair;
-                    foreach (const StrPair& field, response) {
+                    for (const auto& field : response) {
                         if (to_lower(field.first) == to_lower("Proxy-Authenticate")) {
                             if (field.second.size() >= 6 && field.second.substr(0, 6) == " NTLM ") {
                                 filterResponseReturn.push_back(std::pair<std::string, std::string>("Proxy-Authorization", "NTLM TlRMTVNTUAADAAAAGAAYAHIAAAAYABgAigAAABIAEgBIAAAABgAGAFoAAAASABIVNTUAADAAYAAAABAAEACiAAAANYKI4gUBKAoAAAAPTABBAEIAUwBNAE8ASwBFADMAXwBxAGEATABBAEIAUwBNAE8ASwBFADMA0NKq8HYYhj8AAAAAAAAAAAAAAAAAAAAAOIiih3mR+AkyM4r99sy1mdFonCu2ILODro1WTTrJ4b4JcXEzUBA2Ig=="));
                                 return filterResponseReturn;
                             }
                             else if (field.second.size() >= 5 && field.second.substr(0, 5) == " NTLM") {
                                 filterResponseReturn.push_back(std::pair<std::string, std::string>("Proxy-Authorization", "NTLM TlRMTVNTUAABAAAAt7II4gkACQAxAAAACQAJACgAAAVNTUAADAAFASgKAAAAD0xBQlNNT0tFM1dPUktHUk9VUA=="));
                                 return filterResponseReturn;
                             }
                         }
                     }
 
                     return filterResponseReturn;
                 }
                 else {
                     return std::vector<std::pair<std::string, std::string> >();
                 }
             }
     };
 }
 
 class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture {
         CPPUNIT_TEST_SUITE(HTTPConnectProxiedConnectionTest);
         CPPUNIT_TEST(testConnect_CreatesConnectionToProxy);
         CPPUNIT_TEST(testConnect_SendsConnectRequest);
         CPPUNIT_TEST(testConnect_ReceiveConnectResponse);
         CPPUNIT_TEST(testConnect_ReceiveConnectChunkedResponse);
         CPPUNIT_TEST(testConnect_ReceiveMalformedConnectResponse);
         CPPUNIT_TEST(testConnect_ReceiveErrorConnectResponse);
         CPPUNIT_TEST(testConnect_ReceiveDataAfterConnect);
         CPPUNIT_TEST(testWrite_AfterConnect);
         CPPUNIT_TEST(testDisconnect_AfterConnectRequest);
         CPPUNIT_TEST(testDisconnect_AfterConnect);
         CPPUNIT_TEST(testTrafficFilter);
         CPPUNIT_TEST(testTrafficFilterNoConnectionReuse);
         CPPUNIT_TEST_SUITE_END();
 
     public:
         void setUp() {
             proxyHost = "doo.bah";
             proxyPort = 1234;
-            proxyHostAddress = HostAddressPort(HostAddress("1.1.1.1"), proxyPort);
-            host = HostAddressPort(HostAddress("2.2.2.2"), 2345);
+            proxyHostAddress = HostAddressPort(HostAddress::fromString("1.1.1.1").get(), proxyPort);
+            host = HostAddressPort(HostAddress::fromString("2.2.2.2").get(), 2345);
             eventLoop = new DummyEventLoop();
             resolver = new StaticDomainNameResolver(eventLoop);
             resolver->addAddress(proxyHost, proxyHostAddress.getAddress());
             timerFactory = new DummyTimerFactory();
             connectionFactory = new MockConnectionFactory(eventLoop);
             connectFinished = false;
             connectFinishedWithError = false;
             disconnected = false;
         }
 
         void tearDown() {
             delete timerFactory;
             delete connectionFactory;
             delete resolver;
             delete eventLoop;
         }
 
         void connect(HTTPConnectProxiedConnection::ref connection, const HostAddressPort& to) {
             connection->connect(to);
             eventLoop->processEvents();
             eventLoop->processEvents();
             eventLoop->processEvents();
         }
 
         void testConnect_CreatesConnectionToProxy() {
             HTTPConnectProxiedConnection::ref testling(createTestling());
 
             connect(testling, host);
 
             CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connectionFactory->connections.size()));
             CPPUNIT_ASSERT(connectionFactory->connections[0]->hostAddressPort);
             CPPUNIT_ASSERT(proxyHostAddress == *connectionFactory->connections[0]->hostAddressPort);
             CPPUNIT_ASSERT(!connectFinished);
         }
 
         void testConnect_SendsConnectRequest() {
             HTTPConnectProxiedConnection::ref testling(createTestling());
 
-            connect(testling, HostAddressPort(HostAddress("2.2.2.2"), 2345));
+            connect(testling, HostAddressPort(HostAddress::fromString("2.2.2.2").get(), 2345));
 
             CPPUNIT_ASSERT_EQUAL(createByteArray("CONNECT 2.2.2.2:2345 HTTP/1.1\r\n\r\n"), connectionFactory->connections[0]->dataWritten);
         }
 
         void testConnect_ReceiveConnectResponse() {
             HTTPConnectProxiedConnection::ref testling(createTestling());
-            connect(testling, HostAddressPort(HostAddress("2.2.2.2"), 2345));
+            connect(testling, HostAddressPort(HostAddress::fromString("2.2.2.2").get(), 2345));
 
             connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 200 Connection established\r\n\r\n"));
             eventLoop->processEvents();
 
             CPPUNIT_ASSERT(connectFinished);
             CPPUNIT_ASSERT(!connectFinishedWithError);
             CPPUNIT_ASSERT(dataRead.empty());
         }
 
         void testConnect_ReceiveConnectChunkedResponse() {
             HTTPConnectProxiedConnection::ref testling(createTestling());
-            connect(testling, HostAddressPort(HostAddress("2.2.2.2"), 2345));
+            connect(testling, HostAddressPort(HostAddress::fromString("2.2.2.2").get(), 2345));
 
             connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 "));
             eventLoop->processEvents();
             connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("200 Connection established\r\n\r\n"));
             eventLoop->processEvents();
 
             CPPUNIT_ASSERT(connectFinished);
             CPPUNIT_ASSERT(!connectFinishedWithError);
             CPPUNIT_ASSERT(dataRead.empty());
         }
 
 
         void testConnect_ReceiveMalformedConnectResponse() {
             HTTPConnectProxiedConnection::ref testling(createTestling());
-            connect(testling, HostAddressPort(HostAddress("2.2.2.2"), 2345));
+            connect(testling, HostAddressPort(HostAddress::fromString("2.2.2.2").get(), 2345));
 
             connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("FLOOP"));
             eventLoop->processEvents();
 
             CPPUNIT_ASSERT(connectFinished);
             CPPUNIT_ASSERT(connectFinishedWithError);
             CPPUNIT_ASSERT(connectionFactory->connections[0]->disconnected);
         }
 
         void testConnect_ReceiveErrorConnectResponse() {
             HTTPConnectProxiedConnection::ref testling(createTestling());
-            connect(testling, HostAddressPort(HostAddress("2.2.2.2"), 2345));
+            connect(testling, HostAddressPort(HostAddress::fromString("2.2.2.2").get(), 2345));
 
             connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 401 Unauthorized\r\n\r\n"));
             eventLoop->processEvents();
 
             CPPUNIT_ASSERT(connectFinished);
             CPPUNIT_ASSERT(connectFinishedWithError);
             CPPUNIT_ASSERT(connectionFactory->connections[0]->disconnected);
         }
 
         void testConnect_ReceiveDataAfterConnect() {
             HTTPConnectProxiedConnection::ref testling(createTestling());
-            connect(testling, HostAddressPort(HostAddress("2.2.2.2"), 2345));
+            connect(testling, HostAddressPort(HostAddress::fromString("2.2.2.2").get(), 2345));
             connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 200 Connection established\r\n\r\n"));
             eventLoop->processEvents();
 
             connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("abcdef"));
 
             CPPUNIT_ASSERT_EQUAL(createByteArray("abcdef"), dataRead);
         }
 
         void testWrite_AfterConnect() {
             HTTPConnectProxiedConnection::ref testling(createTestling());
-            connect(testling, HostAddressPort(HostAddress("2.2.2.2"), 2345));
+            connect(testling, HostAddressPort(HostAddress::fromString("2.2.2.2").get(), 2345));
             connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 200 Connection established\r\n\r\n"));
             eventLoop->processEvents();
             connectionFactory->connections[0]->dataWritten.clear();
 
             testling->write(createSafeByteArray("abcdef"));
 
             CPPUNIT_ASSERT_EQUAL(createByteArray("abcdef"), connectionFactory->connections[0]->dataWritten);
         }
 
         void testDisconnect_AfterConnectRequest() {
             HTTPConnectProxiedConnection::ref testling(createTestling());
-            connect(testling, HostAddressPort(HostAddress("2.2.2.2"), 2345));
+            connect(testling, HostAddressPort(HostAddress::fromString("2.2.2.2").get(), 2345));
 
             testling->disconnect();
 
             CPPUNIT_ASSERT(connectionFactory->connections[0]->disconnected);
             CPPUNIT_ASSERT(disconnected);
             CPPUNIT_ASSERT(!disconnectedError);
         }
 
         void testDisconnect_AfterConnect() {
             HTTPConnectProxiedConnection::ref testling(createTestling());
-            connect(testling, HostAddressPort(HostAddress("2.2.2.2"), 2345));
+            connect(testling, HostAddressPort(HostAddress::fromString("2.2.2.2").get(), 2345));
             connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 200 Connection established\r\n\r\n"));
             eventLoop->processEvents();
 
             testling->disconnect();
 
             CPPUNIT_ASSERT(connectionFactory->connections[0]->disconnected);
             CPPUNIT_ASSERT(disconnected);
             CPPUNIT_ASSERT(!disconnectedError);
         }
 
         void testTrafficFilter() {
             HTTPConnectProxiedConnection::ref testling(createTestling());
 
             std::shared_ptr<ExampleHTTPTrafficFilter> httpTrafficFilter = std::make_shared<ExampleHTTPTrafficFilter>();
 
             testling->setHTTPTrafficFilter(httpTrafficFilter);
-            connect(testling, HostAddressPort(HostAddress("2.2.2.2"), 2345));
+            connect(testling, HostAddressPort(HostAddress::fromString("2.2.2.2").get(), 2345));
 
             // set a default response so the server response is answered by the traffic filter
             httpTrafficFilter->filterResponseReturn.clear();
             httpTrafficFilter->filterResponseReturn.push_back(std::pair<std::string, std::string>("Authorization", "Negotiate a87421000492aa874209af8bc028"));
 
             connectionFactory->connections[0]->dataWritten.clear();
 
             // test chunked response
             connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef(
                 "HTTP/1.0 401 Unauthorized\r\n"));
             eventLoop->processEvents();
             connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef(
                 "WWW-Authenticate: Negotiate\r\n"
                 "\r\n"));
             eventLoop->processEvents();
 
 
             // verify that the traffic filter got called and answered with its response
             CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(1), httpTrafficFilter->filterResponses.size());
             CPPUNIT_ASSERT_EQUAL(std::string("WWW-Authenticate"), httpTrafficFilter->filterResponses[0][0].first);
 
             // remove the default response from the traffic filter
             httpTrafficFilter->filterResponseReturn.clear();
             eventLoop->processEvents();
 
             // verify that the traffic filter answer is send over the wire
             CPPUNIT_ASSERT_EQUAL(createByteArray("CONNECT 2.2.2.2:2345 HTTP/1.1\r\nAuthorization: Negotiate a87421000492aa874209af8bc028\r\n\r\n"), connectionFactory->connections[1]->dataWritten);
 
             // verify that after without the default response, the traffic filter is skipped, authentication proceeds and traffic goes right through
             connectionFactory->connections[1]->dataWritten.clear();
             testling->write(createSafeByteArray("abcdef"));
             CPPUNIT_ASSERT_EQUAL(createByteArray("abcdef"), connectionFactory->connections[1]->dataWritten);
         }
 
         void testTrafficFilterNoConnectionReuse() {
             HTTPConnectProxiedConnection::ref testling = createTestling();
 
             std::shared_ptr<ProxyAuthenticationHTTPTrafficFilter> httpTrafficFilter = std::make_shared<ProxyAuthenticationHTTPTrafficFilter>();
             testling->setHTTPTrafficFilter(httpTrafficFilter);
 
-            connect(testling, HostAddressPort(HostAddress("2.2.2.2"), 2345));
+            connect(testling, HostAddressPort(HostAddress::fromString("2.2.2.2").get(), 2345));
 
             // First HTTP CONNECT request assumes the proxy will work.
             CPPUNIT_ASSERT_EQUAL(createByteArray("CONNECT 2.2.2.2:2345 HTTP/1.1\r\n"
                                                 "\r\n"), connectionFactory->connections[0]->dataWritten);
 
             // First reply presents initiator with authentication options.
             connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef(
                 "HTTP/1.0 407 ProxyAuthentication Required\r\n"
                 "proxy-Authenticate: Negotiate\r\n"
                 "Proxy-Authenticate: Kerberos\r\n"
                 "proxy-Authenticate: NTLM\r\n"
                 "\r\n"));
             eventLoop->processEvents();
             CPPUNIT_ASSERT_EQUAL(false, connectFinished);
             CPPUNIT_ASSERT_EQUAL(false, connectFinishedWithError);
 
             // The HTTP proxy responds with code 407, so the traffic filter should inject the authentication response on a new connection.
             CPPUNIT_ASSERT_EQUAL(createByteArray("CONNECT 2.2.2.2:2345 HTTP/1.1\r\n"
                                                 "Proxy-Authorization: NTLM TlRMTVNTUAABAAAAt7II4gkACQAxAAAACQAJACgAAAVNTUAADAAFASgKAAAAD0xBQlNNT0tFM1dPUktHUk9VUA==\r\n"
                                                 "\r\n"), connectionFactory->connections[1]->dataWritten);
 
             // The proxy responds with another authentication step.
             connectionFactory->connections[1]->onDataRead(createSafeByteArrayRef(
                 "HTTP/1.0 407 ProxyAuthentication Required\r\n"
                 "Proxy-Authenticate: NTLM TlRMTVNTUAACAAAAEAAQADgAAAA1goriluCDYHcYI/sAAAAAAAAAAFQAVABIAAAABQLODgAAAA9TAFAASQBSAEkAVAAxAEIAAgAQAFMAUABJAFIASQBUADEAQgABABAAUwBQAEkAUgBJAFQAMQBCAAQAEABzAHAAaQByAGkAdAAxAGIAAwAQAHMAcABpAHIAaQB0ADEAYgAAAAAA\r\n"
                 "\r\n"));
             eventLoop->processEvents();
             CPPUNIT_ASSERT_EQUAL(false, connectFinished);
             CPPUNIT_ASSERT_EQUAL(false, connectFinishedWithError);
 
diff --git a/Swiften/Network/UnitTest/HostAddressTest.cpp b/Swiften/Network/UnitTest/HostAddressTest.cpp
index aceb9be..226346b 100644
--- a/Swiften/Network/UnitTest/HostAddressTest.cpp
+++ b/Swiften/Network/UnitTest/HostAddressTest.cpp
@@ -1,67 +1,67 @@
 /*
  * Copyright (c) 2010-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <string>
 
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
 #include <Swiften/Network/HostAddress.h>
 
 using namespace Swift;
 
 class HostAddressTest : public CppUnit::TestFixture {
         CPPUNIT_TEST_SUITE(HostAddressTest);
         CPPUNIT_TEST(testConstructor);
         CPPUNIT_TEST(testConstructor_Invalid);
         CPPUNIT_TEST(testConstructor_InvalidString);
         CPPUNIT_TEST(testToString);
         CPPUNIT_TEST(testToString_IPv6);
         CPPUNIT_TEST(testToString_Invalid);
         CPPUNIT_TEST_SUITE_END();
 
     public:
         void testConstructor() {
-            HostAddress testling("192.168.1.254");
+            auto testling = HostAddress::fromString("192.168.1.254");
 
-            CPPUNIT_ASSERT_EQUAL(std::string("192.168.1.254"), testling.toString());
-            CPPUNIT_ASSERT(testling.isValid());
+            CPPUNIT_ASSERT_EQUAL(std::string("192.168.1.254"), testling->toString());
+            CPPUNIT_ASSERT(testling->isValid());
         }
 
         void testConstructor_Invalid() {
             HostAddress testling;
 
             CPPUNIT_ASSERT(!testling.isValid());
         }
 
         void testConstructor_InvalidString() {
-            HostAddress testling("invalid");
+            auto testling = HostAddress::fromString("invalid");
 
-            CPPUNIT_ASSERT(!testling.isValid());
+            CPPUNIT_ASSERT(!testling);
         }
 
         void testToString() {
             unsigned char address[4] = {10, 0, 1, 253};
             HostAddress testling(address, 4);
 
             CPPUNIT_ASSERT_EQUAL(std::string("10.0.1.253"), testling.toString());
         }
 
         void testToString_IPv6() {
             unsigned char address[16] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17};
             HostAddress testling(address, 16);
 
             CPPUNIT_ASSERT_EQUAL(std::string("102:304:506:708:90a:b0c:d0e:f11"), testling.toString());
         }
 
         void testToString_Invalid() {
             HostAddress testling;
 
             CPPUNIT_ASSERT_EQUAL(std::string("0.0.0.0"), testling.toString());
         }
 };
 
 CPPUNIT_TEST_SUITE_REGISTRATION(HostAddressTest);