libcouchbase 0.0.1

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

@@ -0,0 +1,262 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2012 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "config.h"
+#include <libcouchbase/couchbase.h>
+#include "hashset.h"
+#include <gtest/gtest.h>
+#include <vector>
+
+#ifdef _MSC_VER
+/* We get a ton of these warnings inside the file */
+#pragma message( __FILE__ ": Disabling C4800 (cast-to-bool performance)" )
+#pragma warning( disable : 4800 )
+#endif /* _MSC_VER */
+
+class Hashset : public ::testing::Test
+{
+public:
+    virtual void SetUp(void) {
+        set = hashset_create();
+        ASSERT_NE((hashset_t)NULL, set);
+    }
+
+    virtual void TearDown(void) {
+        hashset_destroy(set);
+    }
+
+protected:
+    hashset_t set;
+};
+
+TEST_F(Hashset, trivial)
+{
+    char *missing = (char *)"missing";
+    char *items[] = {(char *)"zero", (char *)"one",
+                     (char *)"two", (char *)"three", NULL
+                    };
+    char *foo = (char *)"foo";
+    size_t ii, nitems = 4;
+
+    for (ii = 0; ii < nitems; ++ii) {
+        hashset_add(set, items[ii]);
+    }
+
+    for (ii = 0; ii < nitems; ++ii) {
+        assert(hashset_is_member(set, items[ii]));
+    }
+
+    EXPECT_EQ(0, hashset_is_member(set, missing));
+    EXPECT_EQ(1, hashset_remove(set, items[1]));
+    EXPECT_EQ(3, hashset_num_items(set));
+    EXPECT_EQ(0, hashset_remove(set, items[1]));
+
+    EXPECT_EQ(1, hashset_add(set, foo));
+    EXPECT_EQ(0, hashset_add(set, foo));
+}
+
+TEST_F(Hashset, testGaps)
+{
+    /* fill the hashset */
+    EXPECT_NE(0, hashset_add(set, (void *)0xbabe));
+    EXPECT_NE(0, hashset_add(set, (void *)0xbeef));
+    EXPECT_NE(0, hashset_add(set, (void *)0xbad));
+    EXPECT_NE(0, hashset_add(set, (void *)0xf00d));
+    /* 0xf00d (nil) (nil) (nil) (nil) 0xbad 0xbabe 0xbeef */
+
+    /* make a gap */
+    EXPECT_NE(0, hashset_remove(set, (void *)0xbeef));
+    /* 0xf00d (nil) (nil) (nil) (nil) 0xbad 0xbabe 0x1 */
+
+    /* check that 0xf00d is still reachable */
+    EXPECT_TRUE(hashset_is_member(set, (void *)0xf00d));
+
+    /* add 0xbeef back */
+    EXPECT_NE(0, hashset_add(set, (void *)0xbeef));
+    /* 0xf00d (nil) (nil) (nil) (nil) 0xbad 0xbabe 0xbeef */
+
+    /* verify */
+    EXPECT_TRUE(hashset_is_member(set, (void *)0xbeef));
+    EXPECT_TRUE(hashset_is_member(set, (void *)0xf00d));
+}
+
+TEST_F(Hashset, testExceptions)
+{
+    EXPECT_EQ(-1, hashset_add(set, (void *)0));
+    EXPECT_EQ(-1, hashset_add(set, (void *)1));
+}
+
+TEST_F(Hashset, testRehashingItemsPlacedBeyondNumItems)
+{
+    EXPECT_TRUE(hashset_add(set, (void *)20644128));
+    EXPECT_TRUE(hashset_add(set, (void *)21747760));
+    EXPECT_TRUE(hashset_add(set, (void *)17204864));
+    EXPECT_TRUE(hashset_add(set, (void *)22937440));
+    EXPECT_TRUE(hashset_add(set, (void *)14734272));
+    EXPECT_TRUE(hashset_add(set, (void *)13948320));
+    EXPECT_TRUE(hashset_add(set, (void *)18116496));
+    EXPECT_TRUE(hashset_add(set, (void *)18229952));
+    EXPECT_TRUE(hashset_add(set, (void *)20390128));
+    EXPECT_TRUE(hashset_add(set, (void *)23523264));
+    EXPECT_TRUE(hashset_add(set, (void *)22866784));
+    EXPECT_TRUE(hashset_add(set, (void *)17501248));
+    EXPECT_TRUE(hashset_add(set, (void *)17168832));
+    EXPECT_TRUE(hashset_add(set, (void *)13389824));
+    EXPECT_TRUE(hashset_add(set, (void *)15795136));
+    EXPECT_TRUE(hashset_add(set, (void *)15154464));
+    EXPECT_TRUE(hashset_add(set, (void *)22507840));
+    EXPECT_TRUE(hashset_add(set, (void *)22977920));
+    EXPECT_TRUE(hashset_add(set, (void *)20527584));
+    EXPECT_TRUE(hashset_add(set, (void *)21557872));
+    EXPECT_TRUE(hashset_add(set, (void *)23089952));
+    EXPECT_TRUE(hashset_add(set, (void *)21606240));
+    EXPECT_TRUE(hashset_add(set, (void *)25168704));
+    EXPECT_TRUE(hashset_add(set, (void *)25198096));
+    EXPECT_TRUE(hashset_add(set, (void *)25248000));
+    EXPECT_TRUE(hashset_add(set, (void *)25260976));
+    EXPECT_TRUE(hashset_add(set, (void *)25905520));
+    EXPECT_TRUE(hashset_add(set, (void *)25934608));
+    EXPECT_TRUE(hashset_add(set, (void *)26015264));
+    EXPECT_TRUE(hashset_add(set, (void *)26044352));
+    EXPECT_TRUE(hashset_add(set, (void *)24784800));
+    EXPECT_TRUE(hashset_add(set, (void *)24813888));
+    EXPECT_TRUE(hashset_add(set, (void *)24663936));
+    EXPECT_TRUE(hashset_add(set, (void *)24693536));
+    EXPECT_TRUE(hashset_add(set, (void *)24743792));
+    EXPECT_TRUE(hashset_add(set, (void *)24756480));
+
+    EXPECT_TRUE(hashset_is_member(set, (void *)20644128));
+    EXPECT_TRUE(hashset_is_member(set, (void *)21747760));
+    EXPECT_TRUE(hashset_is_member(set, (void *)17204864));
+    EXPECT_TRUE(hashset_is_member(set, (void *)22937440));
+    EXPECT_TRUE(hashset_is_member(set, (void *)14734272));
+    EXPECT_TRUE(hashset_is_member(set, (void *)13948320));
+    EXPECT_TRUE(hashset_is_member(set, (void *)18116496));
+    EXPECT_TRUE(hashset_is_member(set, (void *)18229952));
+    EXPECT_TRUE(hashset_is_member(set, (void *)20390128));
+    EXPECT_TRUE(hashset_is_member(set, (void *)23523264));
+    EXPECT_TRUE(hashset_is_member(set, (void *)22866784));
+    EXPECT_TRUE(hashset_is_member(set, (void *)17501248));
+    EXPECT_TRUE(hashset_is_member(set, (void *)17168832));
+    EXPECT_TRUE(hashset_is_member(set, (void *)13389824));
+    EXPECT_TRUE(hashset_is_member(set, (void *)15795136));
+    EXPECT_TRUE(hashset_is_member(set, (void *)15154464));
+    EXPECT_TRUE(hashset_is_member(set, (void *)22507840));
+    EXPECT_TRUE(hashset_is_member(set, (void *)22977920));
+    EXPECT_TRUE(hashset_is_member(set, (void *)20527584));
+    EXPECT_TRUE(hashset_is_member(set, (void *)21557872));
+    EXPECT_TRUE(hashset_is_member(set, (void *)23089952));
+    EXPECT_TRUE(hashset_is_member(set, (void *)21606240));
+    EXPECT_TRUE(hashset_is_member(set, (void *)25168704));
+    EXPECT_TRUE(hashset_is_member(set, (void *)25198096));
+    EXPECT_TRUE(hashset_is_member(set, (void *)25248000));
+    EXPECT_TRUE(hashset_is_member(set, (void *)25260976));
+    EXPECT_TRUE(hashset_is_member(set, (void *)25905520));
+    EXPECT_TRUE(hashset_is_member(set, (void *)25934608));
+    EXPECT_TRUE(hashset_is_member(set, (void *)26015264));
+    EXPECT_TRUE(hashset_is_member(set, (void *)26044352));
+    EXPECT_TRUE(hashset_is_member(set, (void *)24784800));
+    EXPECT_TRUE(hashset_is_member(set, (void *)24813888));
+    EXPECT_TRUE(hashset_is_member(set, (void *)24663936));
+    EXPECT_TRUE(hashset_is_member(set, (void *)24693536));
+    EXPECT_TRUE(hashset_is_member(set, (void *)24743792));
+    EXPECT_TRUE(hashset_is_member(set, (void *)24756480));
+}
+
+static void hsXref(hashset_t hs,
+                   void **itemarry,
+                   const std::set<size_t> &src)
+{
+    // Cross-reference stuff here
+    std::set<size_t> got;
+
+    size_t n_items = hashset_num_items(hs);
+    ASSERT_EQ(n_items, src.size());
+
+    for (unsigned ii = 0; ii < n_items; ii++) {
+
+        size_t cur = (size_t) itemarry[ii];
+
+        ASSERT_TRUE(hashset_is_member(hs, (void *)cur));
+        ASSERT_TRUE(src.find(cur) != src.end());
+
+        got.insert(cur);
+    }
+
+    ASSERT_EQ(src.size(), got.size());
+
+    for (std::set<size_t>::const_iterator iter = src.begin();
+            iter != src.end();
+            iter++) {
+
+        ASSERT_TRUE(got.find(*iter) != got.end());
+    }
+}
+
+TEST_F(Hashset, testGetAll)
+{
+    std::set<size_t> items, items_base;
+    items_base.insert(0xdeadbeef);
+    items_base.insert(0xbeef);
+    items_base.insert(0xcafe);
+    items_base.insert(0xbabe);
+    items_base.insert(0xf00d);
+    items_base.insert(0xfab);
+    items_base.insert(0xbad);
+
+    // Fill it up
+    for (std::set<size_t>::iterator iter = items_base.begin();
+            iter != items_base.end();
+            iter++) {
+
+        size_t cur = *iter;
+        items.insert(cur);
+        items.insert(cur * cur);
+        items.insert(cur + cur);
+        items.insert(cur * 3);
+    }
+
+    for (std::set<size_t>::iterator iter = items.begin();
+            iter != items.end();
+            iter++) {
+
+        hashset_add(set, (void *)*iter);
+    }
+
+    void **list_hsalloc = hashset_get_items(set, NULL);
+    ASSERT_TRUE(list_hsalloc != NULL);
+    hsXref(set, list_hsalloc, items);
+    free(list_hsalloc);
+
+    void **list_myalloc = (void **)malloc(
+                              sizeof(void *) * hashset_num_items(set));
+
+    void **ret = hashset_get_items(set, list_myalloc);
+
+    ASSERT_TRUE(ret == list_myalloc);
+    hsXref(set, list_myalloc, items);
+    free(list_myalloc);
+
+    for (std::set<size_t>::iterator iter = items.begin();
+            iter != items.end();
+            iter++) {
+        hashset_remove(set, (void *)*iter);
+    }
+
+    ASSERT_EQ(0, hashset_num_items(set));
+    ASSERT_TRUE(NULL == hashset_get_items(set, NULL));
+}

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

@@ -0,0 +1,198 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2013 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+#include "config.h"
+#include <gtest/gtest.h>
+#include <libcouchbase/couchbase.h>
+#include "hostlist.h"
+
+class Hostlist : public ::testing::Test
+{
+};
+
+static bool hostEquals(const lcb_host_t &host, const char *addr, const char *port)
+{
+    return strcmp(host.host, addr) == 0 && strcmp(host.port, port) == 0;
+}
+
+TEST_F(Hostlist, testParseBasic)
+{
+    lcb_host_t curhost;
+    lcb_error_t err;
+
+    err = lcb_host_parsez(&curhost, "1.2.3.4", 8091);
+    ASSERT_EQ(LCB_SUCCESS, err);
+    ASSERT_TRUE(hostEquals(curhost, "1.2.3.4", "8091"));
+
+    err = lcb_host_parsez(&curhost, "1.2.3.4:9000", 8091);
+    ASSERT_EQ(LCB_SUCCESS, err);
+    ASSERT_TRUE(hostEquals(curhost, "1.2.3.4", "9000"));
+
+    err = lcb_host_parsez(&curhost, "http://1.2.3.4:900/pools/default", 8091);
+    ASSERT_EQ(LCB_SUCCESS, err);
+    ASSERT_TRUE(hostEquals(curhost, "1.2.3.4", "900"));
+
+    err = lcb_host_parsez(&curhost, "", 1000);
+    ASSERT_EQ(LCB_INVALID_HOST_FORMAT, err);
+
+    err = lcb_host_parsez(&curhost, "foo.com", -1);
+    ASSERT_EQ(LCB_INVALID_HOST_FORMAT, err);
+
+    err = lcb_host_parsez(&curhost, "foo.com:", 100);
+    ASSERT_EQ(LCB_INVALID_HOST_FORMAT, err);
+
+    err = lcb_host_parsez(&curhost, "localhost/foo", 100);
+    ASSERT_EQ(LCB_SUCCESS, err);
+
+    err = lcb_host_parsez(&curhost, "localhost:1111111111111111111111111111", 100);
+    ASSERT_EQ(LCB_INVALID_HOST_FORMAT, err);
+}
+
+
+TEST_F(Hostlist, testEquals)
+{
+    lcb_host_t host_a, host_b;
+    strcpy(host_a.host, "foo.com");
+    strcpy(host_a.port, "1234");
+    strcpy(host_b.host, "foo.com");
+    strcpy(host_b.port, "1234");
+    ASSERT_NE(0, lcb_host_equals(&host_a, &host_b));
+
+    strcpy(host_a.host, "bar.com");
+    ASSERT_EQ(0, lcb_host_equals(&host_a, &host_b));
+
+
+    strcpy(host_a.host, "foo.com");
+    strcpy(host_a.port, "44444");
+    ASSERT_EQ(0, lcb_host_equals(&host_a, &host_b));
+}
+
+TEST_F(Hostlist, testParseList)
+{
+    hostlist_t hosts = hostlist_create();
+    ASSERT_FALSE(NULL == hosts);
+
+    lcb_error_t err;
+    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"));
+
+
+    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"));
+
+    hostlist_clear(hosts);
+    err = hostlist_add_stringz(hosts, ";",  8091);
+    ASSERT_EQ(LCB_SUCCESS, err);
+    ASSERT_EQ(0, hosts->size());
+
+    hostlist_clear(hosts);
+    err = hostlist_add_stringz(hosts, ";;;;",  8091);
+    ASSERT_EQ(LCB_SUCCESS, err);
+    ASSERT_EQ(0, hosts->size());
+
+    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"));
+
+
+    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"));
+
+    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"));
+
+
+    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"));
+
+    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)
+{
+    hostlist_t hosts = hostlist_create();
+    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();
+
+    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 = 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 = hostlist_shift_next(hosts, 1);
+    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);
+    ASSERT_TRUE(hostEquals(*curhost, "2.2.2.2", "8091"));
+    ASSERT_TRUE(hostlist_shift_next(hosts, 0) == NULL);
+
+    curhost = hostlist_shift_next(hosts, 1);
+    ASSERT_TRUE(hostEquals(*curhost, "1.1.1.1", "8091"));
+    curhost = hostlist_shift_next(hosts, 0);
+    ASSERT_TRUE(hostEquals(*curhost, "2.2.2.2", "8091"));
+
+    hostlist_clear(hosts);
+    ASSERT_TRUE(hostlist_shift_next(hosts, 1) == NULL);
+    hostlist_destroy(hosts);
+}