libcouchbase 0.2.0 → 0.3.1

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

@@ -2,6 +2,14 @@
 #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();
 }
@@ -102,7 +110,7 @@ TEST_F(ConnstrTest, testParseBasic)
     ASSERT_EQ(LCB_CONFIG_HTTP_PORT, params.default_port());
 
     reinit();
-    err = params.parse("1.2.3.4:999", &errmsg);
+    err = lcb_connspec_parse("1.2.3.4:999", &params, &errmsg);
     ASSERT_EQ(1, countHosts(&params));
     tmphost = findHost(&params, "1.2.3.4");
     ASSERT_FALSE(tmphost == NULL);
@@ -114,7 +122,7 @@ TEST_F(ConnstrTest, testParseBasic)
 TEST_F(ConnstrTest, testParseHosts)
 {
     lcb_error_t err;
-    err = params.parse("couchbase://foo.com,bar.com,baz.com", &errmsg);
+    err = lcb_connspec_parse("couchbase://foo.com,bar.com,baz.com", &params, &errmsg);
     ASSERT_EQ(3, countHosts(&params));
     ASSERT_FALSE(NULL == findHost(&params, "foo.com"));
     ASSERT_FALSE(NULL == findHost(&params, "bar.com"));
@@ -122,7 +130,7 @@ TEST_F(ConnstrTest, testParseHosts)
 
     // Parse with 'legacy' format
     reinit();
-    err = params.parse("couchbase://foo.com:8091", &errmsg);
+    err = lcb_connspec_parse("couchbase://foo.com:8091", &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     const Spechost *dh = findHost(&params, "foo.com");
     ASSERT_FALSE(NULL == dh);
@@ -133,14 +141,14 @@ TEST_F(ConnstrTest, testParseHosts)
 
     // parse with invalid port, without specifying protocol
     reinit();
-    err = params.parse("couchbase://foo.com:4444", &errmsg);
+    err = lcb_connspec_parse("couchbase://foo.com:4444", &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     dh = findHost(&params, "foo.com");
     ASSERT_EQ(4444, dh->port);
     ASSERT_TRUE(dh->isMCD());
 
     reinit();
-    err = params.parse("couchbases://foo.com:4444", &errmsg);
+    err = lcb_connspec_parse("couchbases://foo.com:4444", &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     dh = findHost(&params, "foo.com");
     ASSERT_EQ(LCB_SSL_ENABLED, params.sslopts());
@@ -149,7 +157,7 @@ TEST_F(ConnstrTest, testParseHosts)
 
     // Parse with recognized format
     reinit();
-    err = params.parse("couchbase://foo.com:4444=mcd", &errmsg);
+    err = lcb_connspec_parse("couchbase://foo.com:4444=mcd", &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     dh = findHost(&params, "foo.com");
     ASSERT_EQ("foo.com", dh->hostname);
@@ -158,7 +166,8 @@ TEST_F(ConnstrTest, testParseHosts)
 
     //Parse multiple hosts with ports
     reinit();
-    err = params.parse("couchbase://foo.com:4444=mcd,bar.com:5555=mcd", &errmsg);
+    err = lcb_connspec_parse("couchbase://foo.com:4444=mcd,bar.com:5555=mcd",
+        &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
 
     dh = findHost(&params, "foo.com");
@@ -174,7 +183,7 @@ TEST_F(ConnstrTest, testParseHosts)
     ASSERT_TRUE(dh->isMCD());
 
     reinit();
-    err = params.parse("couchbase://foo.com,bar.com:4444", &errmsg);
+    err = lcb_connspec_parse("couchbase://foo.com,bar.com:4444", &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     dh = findHost(&params, "bar.com");
     ASSERT_EQ(4444, dh->port);
@@ -183,7 +192,7 @@ TEST_F(ConnstrTest, testParseHosts)
     ASSERT_TRUE(dh->isTypeless());
 
     reinit();
-    err = params.parse("couchbase://foo.com;bar.com;baz.com", &errmsg);
+    err = lcb_connspec_parse("couchbase://foo.com;bar.com;baz.com", &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "Can parse old-style semicolons";
     ASSERT_EQ(3, countHosts(&params));
     ASSERT_FALSE(NULL == findHost(&params, "foo.com"));
@@ -194,27 +203,27 @@ TEST_F(ConnstrTest, testParseHosts)
 TEST_F(ConnstrTest, testParseBucket)
 {
     lcb_error_t err;
-    err = params.parse("couchbase://foo.com/user", &errmsg);
+    err = lcb_connspec_parse("couchbase://foo.com/user", &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ("user", params.bucket()) << "Basic bucket parse";
 
     reinit();
-    err = params.parse("couchbase://foo.com/user/", &errmsg);
+    err = lcb_connspec_parse("couchbase://foo.com/user/", &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "Bucket can have a slash";
     // We can have a bucket using a slash
 
     reinit();
-    err = params.parse("couchbase:///default", &errmsg);
+    err = lcb_connspec_parse("couchbase:///default", &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "Bucket without host OK";
     ASSERT_EQ("default", params.bucket());
 
     reinit();
-    err = params.parse("couchbase:///default?", &errmsg);
+    err = lcb_connspec_parse("couchbase:///default?", &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ("default", params.bucket());
 
     reinit();
-    err = params.parse("couchbase:///%2FUsers%2F?", &errmsg);
+    err = lcb_connspec_parse("couchbase:///%2FUsers%2F?", &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ("/Users/", params.bucket());
 }
@@ -222,7 +231,7 @@ TEST_F(ConnstrTest, testParseBucket)
 TEST_F(ConnstrTest, testOptionsPassthrough)
 {
     lcb_error_t err;
-    err = params.parse("couchbase://?foo=bar", &errmsg);
+    err = lcb_connspec_parse("couchbase://?foo=bar", &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "Options only";
     ASSERT_FALSE(params.options().empty());
     ASSERT_NE(0, params.options().size());
@@ -232,19 +241,19 @@ TEST_F(ConnstrTest, testOptionsPassthrough)
     ASSERT_EQ("bar", op.value);
 
     reinit();
-    err = params.parse("couchbase://?foo=bar", &errmsg);
+    err = lcb_connspec_parse("couchbase://?foo=bar", &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_TRUE(findOption(&params, "foo", op));
     ASSERT_EQ("bar", op.value);
 
     reinit();
-    err = params.parse("couchbase://?foo", &errmsg);
+    err = lcb_connspec_parse("couchbase://?foo", &params, &errmsg);
     ASSERT_NE(LCB_SUCCESS, err) << "Option without value";
 
 
     // Multiple options
     reinit();
-    err = params.parse("couchbase://?foo=fooval&bar=barval", &errmsg);
+    err = lcb_connspec_parse("couchbase://?foo=fooval&bar=barval", &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_TRUE(findOption(&params, "foo", op));
     ASSERT_EQ("fooval", op.value);
@@ -253,18 +262,20 @@ TEST_F(ConnstrTest, testOptionsPassthrough)
     ASSERT_EQ("barval", op.value);
 
     reinit();
-    err = params.parse("couchbase:///protected?ssl=on&compression=off", &errmsg);
+    err = lcb_connspec_parse("couchbase:///protected?ssl=on&compression=off",
+        &params, &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 = params.parse("couchbase://?foo=foo&bar=bar&", &errmsg);
+    err = lcb_connspec_parse("couchbase://?foo=foo&bar=bar&", &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "Ok with trailing '&'";
 
     reinit();
-    err = params.parse("couchbase://?foo=foo&bootstrap_on=all&bar=bar", &errmsg);
+    err = lcb_connspec_parse("couchbase://?foo=foo&bootstrap_on=all&bar=bar",
+        &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err) << "Ok with non-passthrough option";
     ASSERT_TRUE(findOption(&params, "foo", op));
     ASSERT_TRUE(findOption(&params, "bar", op));
@@ -274,32 +285,32 @@ TEST_F(ConnstrTest, testOptionsPassthrough)
 TEST_F(ConnstrTest, testRecognizedOptions)
 {
     lcb_error_t err;
-    err = params.parse("couchbases://", &errmsg);
+    err = lcb_connspec_parse("couchbases://", &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ(LCB_SSL_ENABLED, params.sslopts());
 
     reinit();
-    err = params.parse("couchbase://?ssl=on", &errmsg);
+    err = lcb_connspec_parse("couchbase://?ssl=on", &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ(LCB_SSL_ENABLED, params.sslopts());
 
     reinit();
-    err = params.parse("couchbases://?ssl=no_verify", &errmsg);
+    err = lcb_connspec_parse("couchbases://?ssl=no_verify", &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ(LCB_SSL_ENABLED|LCB_SSL_NOVERIFY, params.sslopts());
 
     reinit();
-    err = params.parse("couchbases://?ssl=off", &errmsg);
+    err = lcb_connspec_parse("couchbases://?ssl=off", &params, &errmsg);
     ASSERT_NE(LCB_SUCCESS, err);
 
     // Loglevel
     reinit();
-    err = params.parse("couchbase://?console_log_level=5", &errmsg);
+    err = lcb_connspec_parse("couchbase://?console_log_level=5", &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ(5, params.loglevel());
 
     reinit();
-    err = params.parse("couchbase://?console_log_level=gah", &errmsg);
+    err = lcb_connspec_parse("couchbase://?console_log_level=gah", &params, &errmsg);
     ASSERT_NE(LCB_SUCCESS, err);
 
 }
@@ -307,30 +318,30 @@ TEST_F(ConnstrTest, testRecognizedOptions)
 TEST_F(ConnstrTest, testTransportOptions)
 {
     lcb_error_t err;
-    err = params.parse("couchbase://", &errmsg);
+    err = lcb_connspec_parse("couchbase://", &params, &errmsg);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_FALSE(params.is_bs_udef());
 
     reinit();
-    err = params.parse("couchbase://?bootstrap_on=cccp", &errmsg);
+    err = lcb_connspec_parse("couchbase://?bootstrap_on=cccp", &params, &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 = params.parse("couchbase://?bootstrap_on=http", &errmsg);
+    err = lcb_connspec_parse("couchbase://?bootstrap_on=http", &params, &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 = params.parse("couchbase://?bootstrap_on=all", &errmsg);
+    err = lcb_connspec_parse("couchbase://?bootstrap_on=all", &params, &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 = params.parse("couchbase://?bootstrap_on=bleh", &errmsg);
+    err = lcb_connspec_parse("couchbase://?bootstrap_on=bleh", &params, &errmsg);
     ASSERT_NE(LCB_SUCCESS, err) << "Error on bad bootstrap_on value";
 }
 
@@ -344,7 +355,7 @@ TEST_F(ConnstrTest, testCompatConversion)
     cropts.v.v0.host = "foo.com;bar.com;baz.com";
     cropts.v.v0.passwd = "secret";
 
-    err = params.load(cropts);
+    err = lcb_connspec_convert(&params, &cropts);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_FALSE(NULL == findHost(&params, "foo.com"));
     ASSERT_FALSE(NULL == findHost(&params, "bar.com"));
@@ -361,7 +372,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 = params.load(cropts);
+    err = lcb_connspec_convert(&params, &cropts);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ(6, countHosts(&params));
 
@@ -371,7 +382,7 @@ TEST_F(ConnstrTest, testCompatConversion)
     cropts.version = 3;
     cropts.v.v3.passwd = "secret";
     cropts.v.v3.connstr = "couchbase:///fluffle?password=bleh";
-    err = params.load(cropts);
+    err = lcb_connspec_convert(&params, &cropts);
     ASSERT_EQ(LCB_SUCCESS, err);
     ASSERT_EQ("fluffle", params.bucket());
     ASSERT_EQ(cropts.v.v3.passwd, params.password());
@@ -382,62 +393,12 @@ TEST_F(ConnstrTest, testCertificateWithoutSSL)
     // Ensure we get an invalid input error for certificate paths without
     // couchbases://
     lcb_error_t err;
-    err = params.parse(
-        "couchbase://1.2.3.4/default?certpath=/foo/bar/baz", &errmsg);
+    err = lcb_connspec_parse(
+        "couchbase://1.2.3.4/default?certpath=/foo/bar/baz", &params, &errmsg);
     ASSERT_NE(LCB_SUCCESS, err);
 
     reinit();
-    err = params.parse(
-        "couchbases://1.2.3.4/default?certpath=/foo/bar/baz", &errmsg);
+    err = lcb_connspec_parse(
+        "couchbases://1.2.3.4/default?certpath=/foo/bar/baz", &params, &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)
-{
-    lcb_error_t err;
-    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_host.cc

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