libcouchbase 0.3.3 → 1.0.0

data/ext/libcouchbase/tests/basic/t_connstr.cc

@@ -2,14 +2,6 @@
 #include "connspec.h"
 using namespace lcb;
 
-static lcb_error_t lcb_connspec_parse(const char *connstr, Connspec *spec, const char **errmsg)
-{
-    return spec->parse(connstr, errmsg);
-}
-static lcb_error_t lcb_connspec_convert(Connspec *spec, const lcb_create_st *cropts)
-{
-    return spec->load(*cropts);
-}
 static size_t countHosts(const Connspec *spec) {
     return spec->hosts().size();
 }
@@ -110,7 +102,7 @@ TEST_F(ConnstrTest, testParseBasic)
     ASSERT_EQ(LCB_CONFIG_HTTP_PORT, params.default_port());
 
     reinit();
-    err = lcb_connspec_parse("1.2.3.4:999", &params, &errmsg);
+    err = params.parse("1.2.3.4:999", &errmsg);
     ASSERT_EQ(1, countHosts(&params));
     tmphost = findHost(&params, "1.2.3.4");
     ASSERT_FALSE(tmphost == NULL);
@@ -122,7 +114,7 @@ TEST_F(ConnstrTest, testParseBasic)
 TEST_F(ConnstrTest, testParseHosts)
 {
     lcb_error_t err;
-    err = lcb_connspec_parse("couchbase://foo.com,bar.com,baz.com", &params, &errmsg);
+    err = params.parse("couchbase://foo.com,bar.com,baz.com", &errmsg);
     ASSERT_EQ(3, countHosts(&params));
     ASSERT_FALSE(NULL == findHost(&params, "foo.com"));
     ASSERT_FALSE(NULL == findHost(&params, "bar.com"));
@@ -130,7 +122,7 @@ TEST_F(ConnstrTest, testParseHosts)
 
     // Parse with 'legacy' format
     reinit();
-    err = lcb_connspec_parse("couchbase://foo.com:8091", &params, &errmsg);
+    err = params.parse("couchbase://foo.com:8091", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     const Spechost *dh = findHost(&params, "foo.com");
     ASSERT_FALSE(NULL == dh);
@@ -141,14 +133,14 @@ TEST_F(ConnstrTest, testParseHosts)
 
     // parse with invalid port, without specifying protocol
     reinit();
-    err = lcb_connspec_parse("couchbase://foo.com:4444", &params, &errmsg);
+    err = params.parse("couchbase://foo.com:4444", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     dh = findHost(&params, "foo.com");
     ASSERT_EQ(4444, dh->port);
     ASSERT_TRUE(dh->isMCD());
 
     reinit();
-    err = lcb_connspec_parse("couchbases://foo.com:4444", &params, &errmsg);
+    err = params.parse("couchbases://foo.com:4444", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     dh = findHost(&params, "foo.com");
     ASSERT_EQ(LCB_SSL_ENABLED, params.sslopts());
@@ -157,7 +149,7 @@ TEST_F(ConnstrTest, testParseHosts)
 
     // Parse with recognized format
     reinit();
-    err = lcb_connspec_parse("couchbase://foo.com:4444=mcd", &params, &errmsg);
+    err = params.parse("couchbase://foo.com:4444=mcd", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     dh = findHost(&params, "foo.com");
     ASSERT_EQ("foo.com", dh->hostname);
@@ -166,8 +158,7 @@ TEST_F(ConnstrTest, testParseHosts)
 
     //Parse multiple hosts with ports
     reinit();
-    err = lcb_connspec_parse("couchbase://foo.com:4444=mcd,bar.com:5555=mcd",
-        &params, &errmsg);
+    err = params.parse("couchbase://foo.com:4444=mcd,bar.com:5555=mcd", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
 
     dh = findHost(&params, "foo.com");
@@ -183,7 +174,7 @@ TEST_F(ConnstrTest, testParseHosts)
     ASSERT_TRUE(dh->isMCD());
 
     reinit();
-    err = lcb_connspec_parse("couchbase://foo.com,bar.com:4444", &params, &errmsg);
+    err = params.parse("couchbase://foo.com,bar.com:4444", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     dh = findHost(&params, "bar.com");
     ASSERT_EQ(4444, dh->port);
@@ -192,7 +183,7 @@ TEST_F(ConnstrTest, testParseHosts)
     ASSERT_TRUE(dh->isTypeless());
 
     reinit();
-    err = lcb_connspec_parse("couchbase://foo.com;bar.com;baz.com", &params, &errmsg);
+    err = params.parse("couchbase://foo.com;bar.com;baz.com", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "Can parse old-style semicolons";
     ASSERT_EQ(3, countHosts(&params));
     ASSERT_FALSE(NULL == findHost(&params, "foo.com"));
@@ -203,27 +194,27 @@ TEST_F(ConnstrTest, testParseHosts)
 TEST_F(ConnstrTest, testParseBucket)
 {
     lcb_error_t err;
-    err = lcb_connspec_parse("couchbase://foo.com/user", &params, &errmsg);
+    err = params.parse("couchbase://foo.com/user", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ("user", params.bucket()) << "Basic bucket parse";
 
     reinit();
-    err = lcb_connspec_parse("couchbase://foo.com/user/", &params, &errmsg);
+    err = params.parse("couchbase://foo.com/user/", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "Bucket can have a slash";
     // We can have a bucket using a slash
 
     reinit();
-    err = lcb_connspec_parse("couchbase:///default", &params, &errmsg);
+    err = params.parse("couchbase:///default", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "Bucket without host OK";
     ASSERT_EQ("default", params.bucket());
 
     reinit();
-    err = lcb_connspec_parse("couchbase:///default?", &params, &errmsg);
+    err = params.parse("couchbase:///default?", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ("default", params.bucket());
 
     reinit();
-    err = lcb_connspec_parse("couchbase:///%2FUsers%2F?", &params, &errmsg);
+    err = params.parse("couchbase:///%2FUsers%2F?", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ("/Users/", params.bucket());
 }
@@ -231,7 +222,7 @@ TEST_F(ConnstrTest, testParseBucket)
 TEST_F(ConnstrTest, testOptionsPassthrough)
 {
     lcb_error_t err;
-    err = lcb_connspec_parse("couchbase://?foo=bar", &params, &errmsg);
+    err = params.parse("couchbase://?foo=bar", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "Options only";
     ASSERT_FALSE(params.options().empty());
     ASSERT_NE(0, params.options().size());
@@ -241,19 +232,19 @@ TEST_F(ConnstrTest, testOptionsPassthrough)
     ASSERT_EQ("bar", op.value);
 
     reinit();
-    err = lcb_connspec_parse("couchbase://?foo=bar", &params, &errmsg);
+    err = params.parse("couchbase://?foo=bar", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_TRUE(findOption(&params, "foo", op));
     ASSERT_EQ("bar", op.value);
 
     reinit();
-    err = lcb_connspec_parse("couchbase://?foo", &params, &errmsg);
+    err = params.parse("couchbase://?foo", &errmsg);
     ASSERT_NE(LCB_SUCCESS, err) << "Option without value";
 
 
     // Multiple options
     reinit();
-    err = lcb_connspec_parse("couchbase://?foo=fooval&bar=barval", &params, &errmsg);
+    err = params.parse("couchbase://?foo=fooval&bar=barval", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_TRUE(findOption(&params, "foo", op));
     ASSERT_EQ("fooval", op.value);
@@ -262,20 +253,18 @@ TEST_F(ConnstrTest, testOptionsPassthrough)
     ASSERT_EQ("barval", op.value);
 
     reinit();
-    err = lcb_connspec_parse("couchbase:///protected?ssl=on&compression=off",
-        &params, &errmsg);
+    err = params.parse("couchbase:///protected?ssl=on&compression=off", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "Ok with bucket and no hosts";
     ASSERT_EQ(1, countHosts(&params));
     ASSERT_FALSE(NULL == findHost(&params, "localhost"));
     ASSERT_TRUE(findOption(&params, "compression", op));
 
     reinit();
-    err = lcb_connspec_parse("couchbase://?foo=foo&bar=bar&", &params, &errmsg);
+    err = params.parse("couchbase://?foo=foo&bar=bar&", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "Ok with trailing '&'";
 
     reinit();
-    err = lcb_connspec_parse("couchbase://?foo=foo&bootstrap_on=all&bar=bar",
-        &params, &errmsg);
+    err = params.parse("couchbase://?foo=foo&bootstrap_on=all&bar=bar", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "Ok with non-passthrough option";
     ASSERT_TRUE(findOption(&params, "foo", op));
     ASSERT_TRUE(findOption(&params, "bar", op));
@@ -285,32 +274,32 @@ TEST_F(ConnstrTest, testOptionsPassthrough)
 TEST_F(ConnstrTest, testRecognizedOptions)
 {
     lcb_error_t err;
-    err = lcb_connspec_parse("couchbases://", &params, &errmsg);
+    err = params.parse("couchbases://", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ(LCB_SSL_ENABLED, params.sslopts());
 
     reinit();
-    err = lcb_connspec_parse("couchbase://?ssl=on", &params, &errmsg);
+    err = params.parse("couchbase://?ssl=on", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ(LCB_SSL_ENABLED, params.sslopts());
 
     reinit();
-    err = lcb_connspec_parse("couchbases://?ssl=no_verify", &params, &errmsg);
+    err = params.parse("couchbases://?ssl=no_verify", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ(LCB_SSL_ENABLED|LCB_SSL_NOVERIFY, params.sslopts());
 
     reinit();
-    err = lcb_connspec_parse("couchbases://?ssl=off", &params, &errmsg);
+    err = params.parse("couchbases://?ssl=off", &errmsg);
     ASSERT_NE(LCB_SUCCESS, err);
 
     // Loglevel
     reinit();
-    err = lcb_connspec_parse("couchbase://?console_log_level=5", &params, &errmsg);
+    err = params.parse("couchbase://?console_log_level=5", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ(5, params.loglevel());
 
     reinit();
-    err = lcb_connspec_parse("couchbase://?console_log_level=gah", &params, &errmsg);
+    err = params.parse("couchbase://?console_log_level=gah", &errmsg);
     ASSERT_NE(LCB_SUCCESS, err);
 
 }
@@ -318,30 +307,30 @@ TEST_F(ConnstrTest, testRecognizedOptions)
 TEST_F(ConnstrTest, testTransportOptions)
 {
     lcb_error_t err;
-    err = lcb_connspec_parse("couchbase://", &params, &errmsg);
+    err = params.parse("couchbase://", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_FALSE(params.is_bs_udef());
 
     reinit();
-    err = lcb_connspec_parse("couchbase://?bootstrap_on=cccp", &params, &errmsg);
+    err = params.parse("couchbase://?bootstrap_on=cccp", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "bootstrap_on=cccp";
     ASSERT_TRUE(params.has_bsmode(LCB_CONFIG_TRANSPORT_CCCP));
     ASSERT_FALSE(params.has_bsmode(LCB_CONFIG_TRANSPORT_HTTP));
 
     reinit();
-    err = lcb_connspec_parse("couchbase://?bootstrap_on=http", &params, &errmsg);
+    err = params.parse("couchbase://?bootstrap_on=http", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "bootstrap_on=http";
     ASSERT_TRUE(params.has_bsmode(LCB_CONFIG_TRANSPORT_HTTP));
     ASSERT_FALSE(params.has_bsmode(LCB_CONFIG_TRANSPORT_CCCP));
 
     reinit();
-    err = lcb_connspec_parse("couchbase://?bootstrap_on=all", &params, &errmsg);
+    err = params.parse("couchbase://?bootstrap_on=all", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "bootstrap_on=all";
     ASSERT_TRUE(params.has_bsmode(LCB_CONFIG_TRANSPORT_CCCP));
     ASSERT_TRUE(params.has_bsmode(LCB_CONFIG_TRANSPORT_HTTP));
 
     reinit();
-    err = lcb_connspec_parse("couchbase://?bootstrap_on=bleh", &params, &errmsg);
+    err = params.parse("couchbase://?bootstrap_on=bleh", &errmsg);
     ASSERT_NE(LCB_SUCCESS, err) << "Error on bad bootstrap_on value";
 }
 
@@ -355,7 +344,7 @@ TEST_F(ConnstrTest, testCompatConversion)
     cropts.v.v0.host = "foo.com;bar.com;baz.com";
     cropts.v.v0.passwd = "secret";
 
-    err = lcb_connspec_convert(&params, &cropts);
+    err = params.load(cropts);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_FALSE(NULL == findHost(&params, "foo.com"));
     ASSERT_FALSE(NULL == findHost(&params, "bar.com"));
@@ -372,7 +361,7 @@ TEST_F(ConnstrTest, testCompatConversion)
     cropts.version = 2;
     cropts.v.v2.host = "foo.com:9030;bar.com:9040;baz.com:9050";
     cropts.v.v2.mchosts = "foo.com:7030;bar.com:7040;baz.com:7050";
-    err = lcb_connspec_convert(&params, &cropts);
+    err = params.load(cropts);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ(6, countHosts(&params));
 
@@ -382,7 +371,7 @@ TEST_F(ConnstrTest, testCompatConversion)
     cropts.version = 3;
     cropts.v.v3.passwd = "secret";
     cropts.v.v3.connstr = "couchbase:///fluffle?password=bleh";
-    err = lcb_connspec_convert(&params, &cropts);
+    err = params.load(cropts);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ("fluffle", params.bucket());
     ASSERT_EQ(cropts.v.v3.passwd, params.password());
@@ -393,12 +382,61 @@ TEST_F(ConnstrTest, testCertificateWithoutSSL)
     // Ensure we get an invalid input error for certificate paths without
     // couchbases://
     lcb_error_t err;
-    err = lcb_connspec_parse(
-        "couchbase://1.2.3.4/default?certpath=/foo/bar/baz", &params, &errmsg);
+    err = params.parse(
+        "couchbase://1.2.3.4/default?certpath=/foo/bar/baz", &errmsg);
     ASSERT_NE(LCB_SUCCESS, err);
 
     reinit();
-    err = lcb_connspec_parse(
-        "couchbases://1.2.3.4/default?certpath=/foo/bar/baz", &params, &errmsg);
+    err = params.parse(
+        "couchbases://1.2.3.4/default?certpath=/foo/bar/baz", &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
 }
+
+TEST_F(ConnstrTest, testDnsSrvExplicit)
+{
+    // Test various things relating to DNS SRV
+    lcb_error_t err;
+    err = params.parse("couchbase+dnssrv://1.1.1.1", &errmsg);
+    EXPECT_EQ(LCB_SUCCESS, err);
+    EXPECT_TRUE(params.can_dnssrv());
+    EXPECT_TRUE(params.is_explicit_dnssrv());
+
+    reinit();
+    err = params.parse("couchbase+dnssrv://1.1.1.1,2.2.2.2", &errmsg);
+    EXPECT_NE(LCB_SUCCESS, err);
+
+    reinit();
+    err = params.parse("couchbases+dnssrv://1.1.1.1", &errmsg);
+    EXPECT_EQ(LCB_SUCCESS, err);
+    EXPECT_NE(0, params.sslopts());
+    EXPECT_TRUE(params.can_dnssrv());
+    EXPECT_TRUE(params.is_explicit_dnssrv());
+}
+
+TEST_F(ConnstrTest, testDnsSrvImplicit)
+{
+    EXPECT_EQ(LCB_SUCCESS, params.parse("couchbase://"));
+    EXPECT_FALSE(params.can_dnssrv());
+    EXPECT_FALSE(params.is_explicit_dnssrv());
+
+    reinit();
+    EXPECT_EQ(LCB_SUCCESS, params.parse("couchbase://1.1.1.1"));
+    EXPECT_TRUE(params.can_dnssrv());
+    EXPECT_FALSE(params.is_explicit_dnssrv());
+
+    reinit();
+    EXPECT_EQ(LCB_SUCCESS, params.parse("couchbase://1.1.1.1,2.2.2.2"));
+    EXPECT_FALSE(params.can_dnssrv()) << "No implicit SRV on multiple hosts";
+
+    reinit();
+    EXPECT_EQ(LCB_SUCCESS, params.parse("couchbase://1.1.1.1:666"));
+    EXPECT_FALSE(params.can_dnssrv());
+
+    reinit();
+    EXPECT_EQ(LCB_SUCCESS, params.parse("couchbase://1.1.1.1:11210"));
+    EXPECT_TRUE(params.can_dnssrv());
+
+    reinit();
+    EXPECT_EQ(LCB_SUCCESS, params.parse("couchbases://1.1.1.1"));
+    EXPECT_TRUE(params.can_dnssrv());
+}

data/ext/libcouchbase/tests/basic/t_creds.cc

@@ -9,25 +9,67 @@ class CredsTest : public ::testing::Test
 {
 };
 
-TEST_F(CredsTest, testCreds)
+static lcb_t create(const char *connstr = NULL) {
+    lcb_create_st crst;
+    memset(&crst, 0, sizeof crst);
+    crst.version = 3;
+    crst.v.v3.connstr = connstr;
+    lcb_t ret;
+    lcb_error_t rc = lcb_create(&ret, &crst);
+    EXPECT_EQ(LCB_SUCCESS, rc);
+    return ret;
+}
+
+TEST_F(CredsTest, testLegacyCreds)
 {
     lcb_t instance;
-    lcb_BUCKETCRED cred;
     ASSERT_EQ(LCB_SUCCESS, lcb_create(&instance, NULL));
     lcb::Authenticator& auth = *instance->settings->auth;
-    ASSERT_FALSE(auth.username().empty());
-    ASSERT_EQ("default", auth.username());
+    ASSERT_TRUE(auth.username().empty());
+    ASSERT_EQ(LCBAUTH_MODE_CLASSIC, auth.mode());
 
     ASSERT_EQ(1, auth.buckets().size());
     ASSERT_TRUE(auth.buckets().find("default")->second.empty());
+    ASSERT_EQ("", auth.password_for("default"));
+    ASSERT_EQ("default", auth.username_for("default"));
 
     // Try to add another user/password:
     lcb_BUCKETCRED creds = { "user2", "pass2" };
     ASSERT_EQ(LCB_SUCCESS, lcb_cntl(instance, LCB_CNTL_SET, LCB_CNTL_BUCKET_CRED, creds));
     ASSERT_EQ(2, auth.buckets().size());
     ASSERT_EQ("pass2", auth.buckets().find("user2")->second);
-    ASSERT_EQ("default", auth.username());
+    ASSERT_EQ("user2", auth.username_for("user2"));
+    ASSERT_EQ("pass2", auth.password_for("user2"));
+
+    ASSERT_TRUE(auth.username().empty());
+    ASSERT_TRUE(auth.password().empty());
+    lcb_destroy(instance);
+}
+
+TEST_F(CredsTest, testRbacCreds) {
+    lcb_t instance = create("couchbase://localhost/default?username=mark");
+    lcb::Authenticator& auth = *instance->settings->auth;
+    ASSERT_EQ("mark", auth.username());
+    ASSERT_EQ(LCBAUTH_MODE_RBAC, auth.mode());
+    ASSERT_TRUE(auth.buckets().empty());
+    ASSERT_EQ("mark", auth.username_for("default"));
+    ASSERT_EQ("", auth.password_for("default"));
+    ASSERT_EQ("mark", auth.username_for("jane"));
+    ASSERT_EQ("", auth.password_for("jane"));
+
+    // Try adding a new bucket, it should fail
+    ASSERT_EQ(LCB_OPTIONS_CONFLICT, auth.add("users", "secret", LCBAUTH_F_BUCKET));
+
+    // Try using "old-style" auth. It should fail:
+    ASSERT_EQ(LCB_OPTIONS_CONFLICT, auth.add("users", "secret", LCBAUTH_F_BUCKET|LCBAUTH_F_CLUSTER));
+    // Username/password should remain unchanged:
+    ASSERT_EQ("mark", auth.username());
     ASSERT_EQ("", auth.password());
+
+    // Try *changing* the credentials
+    ASSERT_EQ(LCB_SUCCESS, auth.add("jane", "seekrit", LCBAUTH_F_CLUSTER));
+    ASSERT_EQ("jane", auth.username_for("default"));
+    ASSERT_EQ("seekrit", auth.password_for("default"));
     lcb_destroy(instance);
 }
 

data/ext/libcouchbase/tests/basic/t_host.cc

@@ -82,117 +82,109 @@ TEST_F(Hostlist, testEquals)
 
 TEST_F(Hostlist, testParseList)
 {
-    hostlist_t hosts = hostlist_create();
-    ASSERT_FALSE(NULL == hosts);
+    lcb::Hostlist hosts;
 
     lcb_error_t err;
-    err = hostlist_add_stringz(hosts, "1.1.1.1",  8091);
+    err = hosts.add("1.1.1.1",  8091);
     ASSERT_EQ(LCB_SUCCESS, err);
-    ASSERT_EQ(1, hosts->size());
-    ASSERT_TRUE(hosts->exists("1.1.1.1:8091"));
+    ASSERT_EQ(1, hosts.size());
+    ASSERT_TRUE(hosts.exists("1.1.1.1:8091"));
 
-
-    hostlist_clear(hosts);
-    err = hostlist_add_stringz(hosts, "1.1.1.1;",  8091);
+    hosts.clear();
+    err = hosts.add("1.1.1.1;",  8091);
     ASSERT_EQ(LCB_SUCCESS, err);
-    ASSERT_EQ(1, hosts->size());
-    ASSERT_TRUE(hosts->exists("1.1.1.1:8091"));
+    ASSERT_EQ(1, hosts.size());
+    ASSERT_TRUE(hosts.exists("1.1.1.1:8091"));
 
-    hostlist_clear(hosts);
-    err = hostlist_add_stringz(hosts, ";",  8091);
+    hosts.clear();
+    err = hosts.add(";",  8091);
     ASSERT_EQ(LCB_SUCCESS, err);
-    ASSERT_EQ(0, hosts->size());
+    ASSERT_EQ(0, hosts.size());
 
-    hostlist_clear(hosts);
-    err = hostlist_add_stringz(hosts, ";;;;",  8091);
+    hosts.clear();
+    err = hosts.add(";;;;",  8091);
     ASSERT_EQ(LCB_SUCCESS, err);
-    ASSERT_EQ(0, hosts->size());
+    ASSERT_EQ(0, hosts.size());
 
-    hostlist_clear(hosts);
-    err = hostlist_add_stringz(hosts, "1.1.1.1;2.2.2.2",  8091);
+    hosts.clear();
+    err = hosts.add("1.1.1.1;2.2.2.2",  8091);
     ASSERT_EQ(LCB_SUCCESS, err);
-    ASSERT_EQ(2, hosts->size());
-    ASSERT_TRUE(hosts->exists("1.1.1.1:8091"));
-    ASSERT_TRUE(hosts->exists("2.2.2.2:8091"));
-
+    ASSERT_EQ(2, hosts.size());
+    ASSERT_TRUE(hosts.exists("1.1.1.1:8091"));
+    ASSERT_TRUE(hosts.exists("2.2.2.2:8091"));
 
-    hostlist_clear(hosts);
-    err = hostlist_add_stringz(hosts, "1.1.1.1:1000;2.2.2.2:2000;3.3.3.3", 8091);
+    hosts.clear();
+    err = hosts.add("1.1.1.1:1000;2.2.2.2:2000;3.3.3.3", 8091);
     ASSERT_EQ(LCB_SUCCESS, err);
-    ASSERT_EQ(3, hosts->size());
-    ASSERT_TRUE(hosts->exists("1.1.1.1:1000"));
-    ASSERT_TRUE(hosts->exists("2.2.2.2:2000"));
-    ASSERT_TRUE(hosts->exists("3.3.3.3:8091"));
+    ASSERT_EQ(3, hosts.size());
+    ASSERT_TRUE(hosts.exists("1.1.1.1:1000"));
+    ASSERT_TRUE(hosts.exists("2.2.2.2:2000"));
+    ASSERT_TRUE(hosts.exists("3.3.3.3:8091"));
 
-    hostlist_clear(hosts);
-    err = hostlist_add_stringz(hosts, "1.1.1.1;1.1.1.1;1.1.1.1", 8091);
+    hosts.clear();
+    err = hosts.add("1.1.1.1;1.1.1.1;1.1.1.1", 8091);
     ASSERT_EQ(LCB_SUCCESS, err);
-    ASSERT_EQ(1, hosts->size());
-    ASSERT_TRUE(hosts->exists("1.1.1.1:8091"));
+    ASSERT_EQ(1, hosts.size());
+    ASSERT_TRUE(hosts.exists("1.1.1.1:8091"));
 
 
-    hostlist_clear(hosts);
-    err = hostlist_add_stringz(hosts, "1.1.1.1:9000;1.1.1.1:9001;1.1.1.1:9002",  8091);
+    hosts.clear();
+    err = hosts.add("1.1.1.1:9000;1.1.1.1:9001;1.1.1.1:9002",  8091);
     ASSERT_EQ(LCB_SUCCESS, err);
-    ASSERT_EQ(3, hosts->size());
-    ASSERT_TRUE(hosts->exists("1.1.1.1:9000"));
-    ASSERT_TRUE(hosts->exists("1.1.1.1:9001"));
-    ASSERT_TRUE(hosts->exists("1.1.1.1:9002"));
-
-    hostlist_clear(hosts);
-    ASSERT_EQ(LCB_SUCCESS, hostlist_add_stringz(hosts, "1.1.1.1", 8091));
-    ASSERT_EQ(LCB_SUCCESS, hostlist_add_stringz(hosts, "2.2.2.2", 8091));
-    ASSERT_EQ(LCB_SUCCESS, hostlist_add_stringz(hosts, "3.3.3.3", 8091));
-    ASSERT_EQ(3, hosts->size());
-
-    ASSERT_TRUE(hosts->exists("1.1.1.1:8091"));
-    ASSERT_TRUE(hosts->exists("2.2.2.2:8091"));
-    ASSERT_TRUE(hosts->exists("3.3.3.3:8091"));
-
-    hostlist_randomize(hosts);
-    hostlist_clear(hosts);
-    hostlist_randomize(hosts);
-
-    hostlist_destroy(hosts);
+    ASSERT_EQ(3, hosts.size());
+    ASSERT_TRUE(hosts.exists("1.1.1.1:9000"));
+    ASSERT_TRUE(hosts.exists("1.1.1.1:9001"));
+    ASSERT_TRUE(hosts.exists("1.1.1.1:9002"));
+
+    hosts.clear();
+    ASSERT_EQ(LCB_SUCCESS, hosts.add("1.1.1.1", 8091));
+    ASSERT_EQ(LCB_SUCCESS, hosts.add("2.2.2.2", 8091));
+    ASSERT_EQ(LCB_SUCCESS, hosts.add("3.3.3.3", 8091));
+    ASSERT_EQ(3, hosts.size());
+
+    ASSERT_TRUE(hosts.exists("1.1.1.1:8091"));
+    ASSERT_TRUE(hosts.exists("2.2.2.2:8091"));
+    ASSERT_TRUE(hosts.exists("3.3.3.3:8091"));
+
+    hosts.randomize();
+    hosts.clear();
+    hosts.randomize();
 }
 
 TEST_F(Hostlist, testCycle)
 {
-    hostlist_t hosts = hostlist_create();
+    lcb::Hostlist hosts;
     lcb_host_t *curhost;
 
-
     // Empty list
-    ASSERT_EQ(NULL, hostlist_shift_next(hosts, 0));
-    ASSERT_EQ(NULL, hostlist_shift_next(hosts, 1));
-    hostlist_destroy(hosts);
-    hosts = hostlist_create();
+    ASSERT_EQ(NULL, hosts.next(false));
+    ASSERT_EQ(NULL, hosts.next(true));
 
-    hostlist_add_stringz(hosts, "1.1.1.1", 8091);
-    curhost = hostlist_shift_next(hosts, 0);
+    hosts.clear();
+    hosts.add("1.1.1.1", 8091);
+    curhost = hosts.next(false);
     ASSERT_TRUE(curhost != NULL);
     ASSERT_TRUE(hostEquals(*curhost, "1.1.1.1", "8091"));
 
-    curhost = hostlist_shift_next(hosts, 0);
-    ASSERT_TRUE(hostlist_shift_next(hosts, 0) == NULL);
-    ASSERT_TRUE(hostlist_shift_next(hosts, 0) == NULL);
-    ASSERT_TRUE(hosts->ix == 1);
+    curhost = hosts.next(false);
+    ASSERT_TRUE(hosts.next(false) == NULL);
+    ASSERT_TRUE(hosts.next(false) == NULL);
+    ASSERT_TRUE(hosts.ix == 1);
 
-    curhost = hostlist_shift_next(hosts, 1);
+    curhost = hosts.next(true);
     ASSERT_TRUE(curhost != NULL);
     ASSERT_TRUE(hostEquals(*curhost, "1.1.1.1", "8091"));
 
-    hostlist_add_stringz(hosts, "2.2.2.2", 8091);
-    curhost = hostlist_shift_next(hosts, 0);
+    hosts.add("2.2.2.2", 8091);
+    curhost = hosts.next(false);
     ASSERT_TRUE(hostEquals(*curhost, "2.2.2.2", "8091"));
-    ASSERT_TRUE(hostlist_shift_next(hosts, 0) == NULL);
+    ASSERT_TRUE(hosts.next(false) == NULL);
 
-    curhost = hostlist_shift_next(hosts, 1);
+    curhost = hosts.next(true);
     ASSERT_TRUE(hostEquals(*curhost, "1.1.1.1", "8091"));
-    curhost = hostlist_shift_next(hosts, 0);
+    curhost = hosts.next(false);
     ASSERT_TRUE(hostEquals(*curhost, "2.2.2.2", "8091"));
 
-    hostlist_clear(hosts);
-    ASSERT_TRUE(hostlist_shift_next(hosts, 1) == NULL);
-    hostlist_destroy(hosts);
+    hosts.clear();
+    ASSERT_TRUE(hosts.next(true) == NULL);
 }