mt-libcouchbase 1.4.0

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

@@ -0,0 +1,429 @@
+#include <gtest/gtest.h>
+#include "sllist.h"
+#include "sllist-inl.h"
+#include <list>
+#include <stdexcept>
+
+#ifndef ASSERT_NZ
+#define ASSERT_NZ(e) ASSERT_NE(0, e)
+#endif
+
+#ifndef ASSERT_Z
+#define ASSERT_Z(e) ASSERT_EQ(0, e)
+#endif
+
+class SListTests : public ::testing::Test
+{
+};
+
+struct my_elem {
+    int value;
+    sllist_node slnode;
+};
+
+TEST_F(SListTests, testBasic)
+{
+    sllist_root sl;
+    memset(&sl, 0, sizeof(sl));
+
+    ASSERT_TRUE(SLLIST_IS_EMPTY(&sl));
+    my_elem elem1, elem2, elem3;
+
+    sllist_append(&sl, &elem1.slnode);
+    ASSERT_NZ(sllist_contains(&sl, &elem1.slnode));
+    ASSERT_FALSE(SLLIST_IS_EMPTY(&sl));
+
+    sllist_node *tmpnode = SLLIST_FIRST(&sl);
+    sllist_remove_head(&sl);
+    ASSERT_NE(tmpnode, SLLIST_FIRST(&sl));
+    ASSERT_EQ(tmpnode, &elem1.slnode);
+    ASSERT_EQ(&elem1, SLLIST_ITEM(tmpnode, struct my_elem, slnode));
+    ASSERT_TRUE(SLLIST_IS_EMPTY(&sl));
+
+    sllist_append(&sl, &elem1.slnode);
+    sllist_append(&sl, &elem2.slnode);
+    sllist_append(&sl, &elem3.slnode);
+    ASSERT_EQ(sl.last, &elem3.slnode);
+    ASSERT_EQ(SLLIST_FIRST(&sl), &elem1.slnode);
+
+    // Test prepend
+    my_elem elem4;
+    sllist_prepend(&sl, &elem4.slnode);
+    tmpnode = SLLIST_FIRST(&sl);
+    ASSERT_EQ(tmpnode, &elem4.slnode);
+    sllist_node *cur;
+    int itercount = 0;
+    SLLIST_ITERBASIC(&sl, cur) {
+        itercount++;
+    }
+    ASSERT_EQ(4, itercount);
+}
+
+#define BASIC_NELEM 3
+TEST_F(SListTests, testBasicIter)
+{
+    sllist_root sl;
+    my_elem elems[BASIC_NELEM];
+
+    memset(&sl, 0, sizeof(sl));
+    memset(elems, 0, sizeof(elems));
+
+    for (int ii = 0; ii < BASIC_NELEM; ii++) {
+        sllist_append(&sl, &elems[ii].slnode);
+    }
+
+    sllist_node *cur;
+    int itercount = 0;
+    SLLIST_ITERBASIC(&sl, cur) {
+        my_elem *elem = SLLIST_ITEM(cur, struct my_elem, slnode);
+        itercount++;
+        elem->value++;
+    }
+
+    ASSERT_EQ(BASIC_NELEM, itercount);
+    for (int ii = 0; ii < BASIC_NELEM; ii++) {
+        ASSERT_EQ(1, elems[ii].value);
+    }
+}
+
+
+static void fillDynamicSlist(sllist_root *root, my_elem **ptrs, int nptrs)
+{
+    sllist_iterator iter;
+    SLLIST_ITERFOR(root, &iter) {
+        sllist_iter_remove(root, &iter);
+    }
+
+    for (int ii = 0; ii < nptrs; ii++) {
+        free(ptrs[ii]);
+        ptrs[ii] = (my_elem *)calloc(1, sizeof(*ptrs[ii]));
+        sllist_append(root, &ptrs[ii]->slnode);
+    }
+}
+
+TEST_F(SListTests, testExtendedIter)
+{
+    sllist_root sl;
+    my_elem *elemp[BASIC_NELEM] = { NULL };
+    memset(&sl, 0, sizeof(sl));
+
+    fillDynamicSlist(&sl, elemp, BASIC_NELEM);
+
+    // Delete all elements from the list
+    sllist_iterator iter;
+    SLLIST_ITERFOR(&sl, &iter) {
+        my_elem *elem = SLLIST_ITEM(iter.cur, struct my_elem, slnode);
+        sllist_iter_remove(&sl, &iter);
+        memset(elem, 0xff, sizeof(*elem));
+        free(elem);
+    }
+
+    ASSERT_TRUE(SLLIST_IS_EMPTY(&sl));
+    memset(elemp, 0, sizeof(*elemp) * BASIC_NELEM);
+
+    // Delete only the first element of the list. Repopulate
+    fillDynamicSlist(&sl, elemp, BASIC_NELEM);
+    SLLIST_ITERFOR(&sl, &iter) {
+        my_elem *elem = SLLIST_ITEM(iter.cur, struct my_elem, slnode);
+        if (elem == elemp[0]) {
+            sllist_iter_remove(&sl, &iter);
+            memset(elem, 0xff, sizeof(*elem));
+            free(elem);
+            elemp[0] = NULL;
+        }
+    }
+
+    int itercount = 0;
+    SLLIST_ITERFOR(&sl, &iter) {
+        sllist_iter_remove(&sl, &iter);
+        itercount++;
+    }
+    ASSERT_EQ(BASIC_NELEM-1, itercount);
+    ASSERT_TRUE(SLLIST_IS_EMPTY(&sl));
+
+    // Delete only the middle element
+    fillDynamicSlist(&sl, elemp, BASIC_NELEM);
+    SLLIST_ITERFOR(&sl, &iter) {
+        my_elem *elem = SLLIST_ITEM(iter.cur, struct my_elem, slnode);
+        if (elem == elemp[1]) {
+            sllist_iter_remove(&sl, &iter);
+            memset(elem, 0xff, sizeof(*elem));
+            free(elem);
+            elemp[1] = NULL;
+        }
+    }
+    ASSERT_FALSE(SLLIST_IS_EMPTY(&sl));
+
+    // Delete only the last element
+    fillDynamicSlist(&sl, elemp, BASIC_NELEM);
+    SLLIST_ITERFOR(&sl, &iter) {
+        my_elem *elem = SLLIST_ITEM(iter.cur, struct my_elem, slnode);
+        if (elem == elemp[BASIC_NELEM-1]) {
+            sllist_iter_remove(&sl, &iter);
+            memset(elem, 0xff, sizeof(*elem));
+            free(elem);
+            elemp[BASIC_NELEM-1] = NULL;
+        }
+    }
+    ASSERT_FALSE(SLLIST_IS_EMPTY(&sl));
+    SLLIST_ITERFOR(&sl, &iter) {
+        my_elem *elem = SLLIST_ITEM(iter.cur, struct my_elem, slnode);
+        sllist_iter_remove(&sl, &iter);
+        free(elem);
+    }
+}
+
+struct NumberedItem {
+    sllist_node slnode;
+    int value;
+};
+static int
+ni_compare(sllist_node *a, sllist_node *b)
+{
+    NumberedItem *na = SLLIST_ITEM(a, NumberedItem, slnode);
+    NumberedItem *nb = SLLIST_ITEM(b, NumberedItem, slnode);
+    return na->value - nb->value;
+}
+TEST_F(SListTests, testSort)
+{
+    sllist_root l;
+    memset(&l, 0, sizeof(l));
+    NumberedItem items[10];
+    for (unsigned ii = 0; ii < 10; ii++) {
+        items[ii].value = ii;
+        sllist_insert_sorted(&l, &items[ii].slnode, ni_compare);
+    }
+
+    int last = -1;
+    sllist_node *cur;
+    SLLIST_FOREACH(&l, cur) {
+        NumberedItem *ni = SLLIST_ITEM(cur, NumberedItem, slnode);
+        ASSERT_EQ(last, ni->value-1);
+        last = ni->value;
+    }
+
+    /** Insert another item */
+    NumberedItem big1;
+    big1.value = 100;
+    sllist_insert_sorted(&l, &big1.slnode, ni_compare);
+    ASSERT_EQ(l.last, &big1.slnode);
+
+    NumberedItem small1;
+    small1.value = -100;
+    sllist_insert_sorted(&l, &small1.slnode, ni_compare);
+    ASSERT_EQ(SLLIST_FIRST(&l), &small1.slnode);
+
+    NumberedItem middle1;
+    middle1.value = 5;
+    sllist_insert_sorted(&l, &middle1.slnode, ni_compare);
+    NumberedItem *ni_next = SLLIST_ITEM(middle1.slnode.next, NumberedItem, slnode);
+    ASSERT_EQ(5, ni_next->value);
+
+    ni_next = SLLIST_ITEM(items[3].slnode.next, NumberedItem, slnode);
+    ASSERT_EQ(&middle1.slnode, ni_next->slnode.next);
+}
+
+template <typename T, sllist_node T::*m = &T::slnode>
+class SList : public sllist_root
+{
+public:
+    SList() {
+        clear();
+    };
+
+    void append(T& memb) {
+        sllist_append(this, getNode(memb));
+    }
+
+    void prepend(T& memb) {
+        sllist_prepend(this, getNode(memb));
+    }
+
+    void insert(T& memb, int (*compar)(sllist_node*,sllist_node*)) {
+        sllist_insert_sorted(this, getNode(memb), compar);
+    }
+
+    bool contains(T& memb) {
+        return sllist_contains(this, getNode(memb)) != 0;
+    }
+
+    size_t size() {
+        return sllist_get_size(this);
+    }
+
+    void remove(T& memb) {
+        sllist_remove(this, getNode(memb));
+    }
+
+    bool empty() {
+        return SLLIST_IS_EMPTY(this);
+    }
+
+    void clear() {
+        SLLIST_FIRST(this) = NULL;
+        last = NULL;
+    }
+
+    T& front() {
+        if (empty()) {
+            throw std::out_of_range("List is empty");
+        }
+        return *llToItem(SLLIST_FIRST(this));
+    }
+
+    T& back() {
+        if (empty()) {
+            throw std::out_of_range("List is empty");
+        }
+        return *llToItem(last);
+    }
+
+    T& operator[](int ix) {
+        int cur = 0;
+        sllist_node *ll;
+        SLLIST_FOREACH(this, ll) {
+            if (cur++ == ix) {
+                return *llToItem(ll);
+            }
+        }
+        throw std::out_of_range("No such index");
+    }
+
+private:
+    sllist_node * getNode(T& memb) const {
+        return &(memb.*m);
+    }
+
+    T* llToItem(sllist_node *node) {
+        // Get the offset
+        T *obj = 0;
+        sllist_node *offset = &(obj->*m);
+        char *diff = (char *) offset;
+        return (T *) (((char *) node) - diff);
+    }
+};
+
+TEST_F(SListTests, testSandwichSort)
+{
+    // moar sort tests
+    SList<NumberedItem> sl;
+    NumberedItem itm_1, itm_2, itm_3;
+    itm_1.value = 1;
+    itm_2.value = 2;
+    itm_3.value = 3;
+
+    // 1, 3, 2
+    sl.insert(itm_1, ni_compare);
+    ASSERT_TRUE(sl.contains(itm_1));
+    ASSERT_EQ(1, sl.size());
+    ASSERT_EQ(1, sl[0].value);
+
+    sl.insert(itm_3, ni_compare);
+    ASSERT_TRUE(sl.contains(itm_3));
+    ASSERT_EQ(1, sl[0].value);
+    ASSERT_EQ(3, sl[1].value);
+
+    sl.insert(itm_2, ni_compare);
+    ASSERT_TRUE(sl.contains(itm_2));
+    ASSERT_EQ(3, sl.size());
+    ASSERT_EQ(1, sl[0].value);
+    ASSERT_EQ(2, sl[1].value);
+    ASSERT_EQ(3, sl[2].value);
+
+    sl.clear();
+    // Insert 3,2,1
+    sl.insert(itm_3, ni_compare);
+    sl.insert(itm_2, ni_compare);
+    sl.insert(itm_1, ni_compare);
+    ASSERT_EQ(1, sl[0].value);
+    ASSERT_EQ(2, sl[1].value);
+    ASSERT_EQ(3, sl[2].value);
+}
+
+TEST_F(SListTests, testPrependSort)
+{
+    SList<NumberedItem> sl;
+    NumberedItem itm_1, itm_2, itm_3;
+    itm_1.value = 1;
+    itm_2.value = 2;
+    itm_3.value = 3;
+
+    // 2, 3, 1
+    sl.insert(itm_2, ni_compare);
+    sl.insert(itm_3, ni_compare);
+    ASSERT_EQ(2, sl.size());
+    ASSERT_EQ(2, sl[0].value);
+    ASSERT_EQ(3, sl[1].value);
+
+    // Prepend item 1
+    sl.insert(itm_1, ni_compare);
+    ASSERT_EQ(3, sl.size());
+    ASSERT_EQ(1, sl[0].value);
+    ASSERT_EQ(2, sl[1].value);
+    ASSERT_EQ(3, sl[2].value);
+}
+
+// Ensure removing the tail item inside an iterator does what we want it to
+TEST_F(SListTests, testRemoveTailIter)
+{
+    NumberedItem itm_1, itm_2, itm_3;
+    itm_1.value = 1;
+    itm_2.value = 2;
+    itm_3.value = 3;
+    SList<NumberedItem> sl;
+    sl.append(itm_1);
+    sl.append(itm_2);
+    sl.append(itm_3);
+
+    ASSERT_EQ(1, sl.front().value);
+    ASSERT_EQ(3, sl.back().value);
+
+    sllist_iterator iter;
+    bool removed = false;
+    SLLIST_ITERFOR(&sl, &iter) {
+        if (iter.cur == &itm_3.slnode) {
+            sllist_iter_remove(&sl, &iter);
+            removed = true;
+            break;
+        }
+    }
+
+    ASSERT_TRUE(removed);
+    ASSERT_EQ(2, sl.size());
+    ASSERT_EQ(1, sl.front().value);
+    ASSERT_EQ(2, sl.back().value);
+}
+
+TEST_F(SListTests, testRemoveEmptyTailIter)
+{
+    NumberedItem itm_1;
+    SList<NumberedItem> sl;
+    sl.append(itm_1);
+    sllist_iterator iter;
+    SLLIST_ITERFOR(&sl, &iter) {
+        sllist_iter_remove(&sl, &iter);
+    }
+    ASSERT_TRUE(sl.empty());
+}
+
+TEST_F(SListTests, testRemoveFirstIter)
+{
+    NumberedItem itm_1, itm_2, itm_3;
+    SList<NumberedItem> sl;
+    itm_1.value = 1;
+    itm_2.value = 2;
+    itm_3.value = 3;
+    sl.append(itm_1);
+    sl.append(itm_2);
+    sl.append(itm_3);
+    sllist_iterator iter;
+    SLLIST_ITERFOR(&sl, &iter) {
+        if (iter.cur == &itm_1.slnode) {
+            sllist_iter_remove(&sl, &iter);
+        }
+    }
+
+    ASSERT_EQ(2, sl.size());
+    ASSERT_EQ(2, sl.front().value);
+    ASSERT_EQ(3, sl.back().value);
+}

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

@@ -0,0 +1,64 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2010-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 <gtest/gtest.h>
+#define LIBCOUCHBASE_INTERNAL 1
+#include <libcouchbase/couchbase.h>
+
+class Strerror : public ::testing::Test
+{
+};
+
+TEST_F(Strerror, testNoCrash)
+{
+    for (int ii = -10; ii < 0xffff; ++ii) {
+        EXPECT_NE((const char *)NULL,
+                  lcb_strerror(NULL, (lcb_error_t)ii));
+    }
+}
+
+TEST_F(Strerror, allCodesDocumented)
+{
+    const char *generic = lcb_strerror(NULL, (lcb_error_t)( LCB_MAX_ERROR -1));
+    ASSERT_NE((const char *)NULL, generic);
+    for (int ii = 0; ii < LCB_MAX_ERROR_VAL; ++ii) {
+        EXPECT_STRNE(generic,
+                     lcb_strerror(NULL, (lcb_error_t)ii));
+    }
+
+    for (int ii = LCB_MAX_ERROR_VAL; ii < LCB_MAX_ERROR; ++ii) {
+        EXPECT_STREQ(generic,
+                     lcb_strerror(NULL, (lcb_error_t)ii));
+    }
+
+}
+
+TEST_F(Strerror, testErrTypes)
+{
+    for (int ii = 0; ii < LCB_MAX_ERROR_VAL; ii++) {
+        lcb_error_t err = (lcb_error_t)ii;
+        ASSERT_NE(-1, LCB_EIFDATA(err));
+        ASSERT_NE(-1, LCB_EIFFATAL(err));
+        ASSERT_NE(-1, LCB_EIFINPUT(err));
+        ASSERT_NE(-1, LCB_EIFNET(err));
+        ASSERT_NE(-1, LCB_EIFPLUGIN(err));
+        ASSERT_NE(-1, LCB_EIFTMP(err));
+    }
+
+    ASSERT_EQ(-1, lcb_get_errtype(LCB_MAX_ERROR_VAL));
+    ASSERT_EQ(-1, lcb_get_errtype((lcb_error_t)-1));
+}

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

@@ -0,0 +1,132 @@
+/* -*- 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 <gtest/gtest.h>
+#include <libcouchbase/couchbase.h>
+#include <strcodecs/strcodecs.h>
+
+class UrlEncoding : public ::testing::Test
+{
+};
+
+using lcb::strcodecs::urlencode;
+using lcb::strcodecs::urldecode;
+
+TEST_F(UrlEncoding, plainTextTests)
+{
+    std::string input("abcdef");
+    std::string exp("abcdef");
+    std::string out;
+    ASSERT_TRUE(urlencode(input.begin(), input.end(), out));
+    ASSERT_EQ(exp, out);
+}
+
+TEST_F(UrlEncoding, plainTextWithSlashTests)
+{
+    std::string input("a/b/c/d/e/f/g/h/i/j");
+    std::string out;
+    ASSERT_TRUE(urlencode(input.begin(), input.end(), out));
+    ASSERT_EQ(input, out);
+}
+
+TEST_F(UrlEncoding, plainTextWithSpaceTests)
+{
+    std::string out;
+    std::string input("a b c d e f g");
+    std::string exp("a%20b%20c%20d%20e%20f%20g");
+    ASSERT_TRUE(urlencode(input.begin(), input.end(), out));
+    ASSERT_EQ(exp, out);
+}
+
+TEST_F(UrlEncoding, encodedTextWithPlusAsApaceTests)
+{
+    std::string input("a+b+c+d+e+g+h");
+    std::string out;
+    ASSERT_TRUE(urlencode(input.begin(), input.end(), out));
+    ASSERT_EQ(input, out);
+}
+
+TEST_F(UrlEncoding, encodedTextWithPlusAndHexAsApaceTests)
+{
+    std::string input("a+b%20c%20d+e+g+h");
+    std::string out;
+    ASSERT_TRUE(urlencode(input.begin(), input.end(), out));
+    ASSERT_EQ(input, out);
+}
+
+TEST_F(UrlEncoding, mixedLegalTextTests)
+{
+    std::string input("a/b/c/d/e f g+32%20");
+    std::string exp("a/b/c/d/e%20f%20g+32%20");
+    std::string out;
+
+    ASSERT_TRUE(urlencode(input.begin(), input.end(), out));
+    ASSERT_EQ(exp, out);
+}
+
+TEST_F(UrlEncoding, mixedIllegalEncodingTextTests)
+{
+    std::string input("a+ ");
+    std::string out;
+    ASSERT_FALSE(urlencode(input.begin(), input.end(), out));
+}
+
+TEST_F(UrlEncoding, internationalTest)
+{
+    std::string input("_design/beer/_view/all?startkey=\"\xc3\xb8l\"");
+    std::string exp("_design/beer/_view/all?startkey=%22%C3%B8l%22");
+    std::string out;
+    ASSERT_TRUE(urlencode(input.begin(), input.end(), out));
+    ASSERT_EQ(exp, out);
+}
+
+TEST_F(UrlEncoding, internationalEncodedTest)
+{
+    std::string input("_design/beer/_view/all?startkey=%22%C3%B8l%22");
+    std::string exp("_design/beer/_view/all?startkey=%22%C3%B8l%22");
+    std::string out;
+    ASSERT_TRUE(urlencode(input.begin(), input.end(), out));
+    ASSERT_EQ(exp, out);
+}
+
+TEST_F(UrlEncoding, testDecode)
+{
+    char obuf[4096];
+
+    ASSERT_TRUE(urldecode("%22", obuf)) << "Single character";
+    ASSERT_STREQ("\x22", obuf);
+
+    ASSERT_TRUE(urldecode("Hello World", obuf)) << "No pct encode";
+    ASSERT_STREQ("Hello World", obuf);
+
+    ASSERT_TRUE(urldecode("Hello%20World", obuf));
+    ASSERT_STREQ("Hello World", obuf);
+
+    ASSERT_TRUE(urldecode("%2Ffoo%2Fbar%2Fbaz%2F", obuf));
+    ASSERT_STREQ("/foo/bar/baz/", obuf);
+
+    ASSERT_TRUE(urldecode("%01%02%03%04", obuf)) << "Multiple octets";
+    ASSERT_STREQ("\x01\x02\x03\x04", obuf);
+
+    ASSERT_TRUE(urldecode("%FFFF", obuf)) << "Recognize only first two hex digits";
+    // Split the hex literal so we don't confuse the preprocessor
+    ASSERT_STREQ("\xff" "FF", obuf);
+
+    // Error tests
+    ASSERT_FALSE(urldecode("%", obuf));
+    ASSERT_FALSE(urldecode("%RR", obuf)) << "Invalid hex digits";
+}