libcouchbase 0.0.1

data/ext/libcouchbase/tests/mocksupport/server.h

@@ -0,0 +1,72 @@
+/* -*- 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.
+ */
+#ifndef LIBCOUCHBASE_TEST_SERVER_H
+#define LIBCOUCHBASE_TEST_SERVER_H 1
+#define LCB_TEST_REALCLUSTER_ENV "LCB_TEST_CLUSTER_CONF"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _WIN32
+#define in_port_t USHORT
+#ifndef usleep
+#define usleep(us) Sleep((us) / 1000)
+#endif
+#ifndef sleep
+#define sleep(s) Sleep( (s) * 1000)
+#endif
+
+#include <winsock2.h>
+#else
+#define closesocket close
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#endif
+#include <libcouchbase/couchbase.h>
+#include "procutil.h"
+
+    struct test_server_info {
+        child_process_t process;
+        char *http;
+        char *bucket;
+        char *username;
+        char *password;
+        in_port_t port;
+        struct sockaddr_storage storage;
+        int sock;
+        int client;
+        int is_mock;
+    };
+
+
+    const void *start_test_server(char **cmdline);
+    const char *get_mock_http_server(const void *);
+    void get_mock_std_creds(const void *handle, const char **userp, const char **passp);
+    int is_using_real_cluster(void);
+
+    void shutdown_mock_server(const void *);
+
+    struct lcb_io_opt_st *get_test_io_opts(void);
+    void setup_test_timeout_handler(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/libcouchbase/tests/mocksupport/timeout.c

@@ -0,0 +1,69 @@
+/* -*- 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 <stdio.h>
+/*
+ * The current test suite should not take more than 5 minutes to run.
+ * If you're testing on a really slow system you may set the
+ * environment variable LCB_MAX_TEST_DURATION to the maximum number of
+ * seconds you'd like the tests to take.
+ */
+const int max_duration = 300;
+
+#ifdef _WIN32
+static HANDLE hTimer;
+void CALLBACK test_timed_out(PVOID lpUnused, BOOLEAN bUnused)
+{
+    (void)lpUnused;
+    (void)bUnused;
+    fprintf(stderr, "Tests are taking too long to run. Aborting..\n");
+    abort();
+}
+#endif
+
+void setup_test_timeout_handler(void)
+{
+    char *ptr = getenv("LCB_MAX_TEST_DURATION");
+    int duration = 0;
+    if (ptr != NULL) {
+        duration = atoi(ptr);
+    }
+    if (duration == 0) {
+        duration = max_duration;
+    }
+
+#ifdef HAVE_SETITIMER
+    struct itimerval timer = { .it_value = { .tv_sec = duration } };
+    setitimer(ITIMER_REAL, &timer, NULL);
+#elif defined(HAVE_ALARM)
+    alarm(duration);
+#elif defined(_WIN32)
+    CreateTimerQueueTimer(
+        &hTimer,
+        NULL,
+        test_timed_out,
+        NULL,
+        duration * 1000,
+        0,
+        0);
+#else
+    /* print an error message so that we're using the duration variable
+     * and not generate a warning about unused variables ;) */
+    fprintf(stderr, "Tests may run longer than %d due to lack of an alarm\n",
+            duration);
+#endif
+}

data/ext/libcouchbase/tests/nonio_tests.cc

@@ -0,0 +1,23 @@
+/* -*- 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 <gtest/gtest.h>
+
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}

data/ext/libcouchbase/tests/rdb/rdbtest.h

@@ -0,0 +1,133 @@
+#define NOMINMAX // for win32, use std::min rather than min
+#include <gtest/gtest.h>
+#include <rdb/rope.h>
+#include <algorithm>
+
+class RdbAllocator
+{
+public:
+    rdb_ALLOCATOR *_inner;
+    rdb_ROPESEG *alloc(size_t n) {
+        return _inner->s_alloc(_inner, n);
+    }
+    rdb_ROPESEG *realloc(rdb_ROPESEG *prev, size_t n) {
+        return _inner->s_realloc(_inner, prev, n);
+    }
+    void reserve(rdb_ROPEBUF *buf, size_t cap) {
+        _inner->r_reserve(_inner, buf, cap);
+    }
+    void free(rdb_ROPESEG *seg) {
+        _inner->s_release(_inner, seg);
+    }
+    void release() {
+        _inner->a_release(_inner);
+    }
+
+    RdbAllocator(rdb_ALLOCATOR *inner) {
+        _inner = inner;
+    }
+};
+
+struct IORope : public rdb_IOROPE {
+    IORope(rdb_ALLOCATOR *allocator) {
+        rdb_init(this, allocator);
+        rdsize = 256;
+    }
+
+    IORope() {
+        rdb_init(this, rdb_bigalloc_new());
+        rdsize = 256;
+    }
+
+    ~IORope() {
+        rdb_cleanup(this);
+    }
+
+    IORope(const IORope&);
+
+    std::string stlstr(size_t n) {
+        char *buf = new char[n];
+        rdb_copyread(this, buf, n);
+        std::string rv(buf, n);
+        delete[] buf;
+        return rv;
+    }
+
+    size_t usedSize() const {
+        return recvd.nused;
+    }
+
+    void feed(const std::string &s) {
+        size_t n_fed = 0;
+        nb_IOV iov[32];
+
+        while (n_fed < s.size()) {
+            unsigned niov = rdb_rdstart(this, iov, 32);
+            unsigned cur_nfed = 0;
+
+            for (unsigned ii = 0; ii < niov && n_fed < s.size(); ii++) {
+                const char *frag = s.data() + n_fed;
+                nb_IOV *curiov = iov + ii;
+                // on win32 iov_len is not a size_t
+                unsigned to_copy = std::min(s.size() - n_fed, (size_t)curiov->iov_len);
+                memcpy(curiov->iov_base, frag, to_copy);
+                n_fed += to_copy;
+                cur_nfed += to_copy;
+            }
+            rdb_rdend(this, cur_nfed);
+        }
+    }
+
+    void feed(const char *s) {
+        feed(std::string(s));
+    }
+};
+
+struct ReadPacket {
+    std::vector<rdb_ROPESEG*> segments;
+    std::vector<nb_IOV> iovs;
+
+    ReadPacket(nb_IOV *iov, rdb_ROPESEG **segs, unsigned n) {
+        segments.reserve(n);
+        iovs.reserve(n);
+
+        // Insert them.
+        segments.insert(segments.begin(), segs, segs + n);
+        iovs.insert(iovs.begin(), iov, iov + n);
+    }
+
+    ReadPacket(rdb_IOROPE *ior, unsigned nb) {
+        segments.resize(2);
+        iovs.resize(2);
+        unsigned niov;
+
+        while (true) {
+            niov = rdb_refread_ex(ior, &iovs[0], &segments[0], iovs.size(), nb);
+            if (niov != (unsigned)-1) {
+                iovs.resize(niov);
+                segments.resize(niov);
+                break;
+            }
+
+            iovs.resize(iovs.size() * 2);
+            segments.resize(segments.size() * 2);
+        }
+    }
+
+    void refSegment(unsigned ix) {
+        rdb_seg_ref(segments[ix]);
+    }
+
+    std::string asString() {
+        std::string s;
+        for (size_t ii = 0; ii < iovs.size(); ii++) {
+            nb_IOV *cur = &iovs[ii];
+            s.append((const char *)cur->iov_base, cur->iov_len);
+        }
+        return s;
+    }
+
+    void unrefSegment(unsigned ix) {
+        rdb_seg_unref(segments[ix]);
+    }
+};

data/ext/libcouchbase/tests/rdb/t_basic.cc

@@ -0,0 +1,128 @@
+#include "rdbtest.h"
+
+class RopeTest : public ::testing::Test {};
+using std::string;
+
+TEST_F(RopeTest, testBasic)
+{
+    IORope rope;
+    nb_IOV iovs;
+    unsigned niov = rdb_rdstart(&rope, &iovs, 1);
+    ASSERT_EQ(1, niov);
+    ASSERT_FALSE(iovs.iov_base == NULL);
+    ASSERT_GT(iovs.iov_len, 0U);
+
+    memset(iovs.iov_base, 0x66, iovs.iov_len);
+    rdb_rdend(&rope, iovs.iov_len);
+    ASSERT_EQ(iovs.iov_len, rope.usedSize());
+
+    for (unsigned ii = 0; ii < iovs.iov_len; ii++) {
+        unsigned char tmp;
+        rdb_copyread(&rope, &tmp, 1);
+        ASSERT_EQ(0x66, tmp);
+        rdb_consumed(&rope, 1);
+    }
+}
+
+TEST_F(RopeTest, testFragmented)
+{
+    IORope rope(rdb_chunkalloc_new(1));
+    nb_IOV iovs[32];
+    unsigned niov;
+    niov = rdb_rdstart(&rope, iovs, 32);
+    ASSERT_EQ(32, niov);
+
+    string hello("Hello World!");
+    for (unsigned ii = 0; ii < hello.size(); ii++) {
+        memcpy(iovs[ii].iov_base, &hello[ii], 1);
+    }
+
+    rdb_rdend(&rope, hello.size());
+    ASSERT_EQ(hello.size(), rope.usedSize());
+
+    // Now we should be able to extract it properly
+    char tmpbuf[32] = { 0 };
+    rdb_copyread(&rope, tmpbuf, hello.size());
+    ASSERT_STREQ(tmpbuf, hello.c_str());
+
+    /** Can we read contiguously? */
+    nb_IOV iovs2[32];
+    rdb_ROPESEG *backs[32];
+    int nitems;
+
+    nitems = rdb_refread_ex(&rope, iovs2, backs, 32, hello.size());
+    ASSERT_EQ(hello.size(), nitems);
+    for (unsigned ii = 0; ii < hello.size(); ii++) {
+        nb_IOV *cur = iovs2 + ii;
+        ASSERT_EQ(*(char *)cur->iov_base, hello.at(ii));
+        ASSERT_EQ(1, cur->iov_len);
+    }
+
+    // Solidify them?
+    rdb_consolidate(&rope, 5);
+    memset(tmpbuf, 0, sizeof(tmpbuf));
+    ASSERT_EQ(hello.size(), rope.usedSize());
+    rdb_copyread(&rope, tmpbuf, hello.size());
+    ASSERT_STREQ(tmpbuf, hello.c_str());
+
+    nitems = rdb_refread_ex(&rope, iovs2, backs, 32, hello.size());
+    ASSERT_EQ(hello.size()-4, nitems);
+}
+
+// This tests the functionality where we want _subsequent_ reads to be
+// consolidated into a single buffer.
+TEST_F(RopeTest, testConsolidatedReadAhead)
+{
+    IORope ior(rdb_chunkalloc_new(1));
+    ior.rdsize = 256;
+
+    nb_IOV iovs[32];
+    rdb_ROPESEG *segs[32];
+    unsigned niov;
+
+    // Feed 4 bytes into the buffer
+    ior.feed("1234");
+
+    // Make the next 6 bytes consolidated
+    rdb_consolidate(&ior, 6);
+    ior.feed("5678");
+    niov = rdb_refread_ex(&ior, iovs, segs, 3, 8);
+
+    ASSERT_EQ(3, niov);
+    ASSERT_EQ(6, iovs[0].iov_len);
+    ASSERT_EQ(0, memcmp(iovs[0].iov_base, "123456", 6));
+    ASSERT_EQ(*(char *)iovs[1].iov_base, '7');
+    ASSERT_EQ(*(char *)iovs[2].iov_base, '8');
+}
+
+
+// When I was integrating this into LCBIO, I realized this scenario. Trying to
+// figure out what the intended outcome is.
+// Apparently this cannot work because we can't consume a buffer which is also
+// available for reading as this may result in the currently-being-read-into
+// buffer being released.
+TEST_F(RopeTest, DISABLED_testInterleavedReadConsume)
+{
+    IORope ior(rdb_bigalloc_new());
+    ior.rdsize = 256;
+    nb_IOV iov;
+    unsigned niov;
+
+    niov = rdb_rdstart(&ior, &iov, 1);
+    ASSERT_EQ(1, niov);
+    memset(iov.iov_base, '1', 29);
+
+    rdb_rdend(&ior, 29);
+    rdb_consumed(&ior, 24);
+    ASSERT_EQ(5, rdb_get_nused(&ior));
+
+    nb_IOV iov2;
+    niov = rdb_rdstart(&ior, &iov2, 1);
+    ASSERT_EQ(1, niov);
+    ASSERT_EQ(5, rdb_get_nused(&ior));
+
+    rdb_consumed(&ior, 5);
+    ASSERT_EQ(0, rdb_get_nused(&ior));
+
+    rdb_rdend(&ior, 100);
+}

data/ext/libcouchbase/tests/rdb/t_bigalloc.cc

@@ -0,0 +1,93 @@
+#include "rdbtest.h"
+#include <rdb/bigalloc.h>
+class BigallocTest : public ::testing::Test {};
+
+TEST_F(BigallocTest, testBasic)
+{
+    RdbAllocator a(rdb_bigalloc_new());
+    rdb_BIGALLOC *ba = (rdb_BIGALLOC *)a._inner;
+
+    ASSERT_EQ(0, LCB_CLIST_SIZE(&ba->bufs));
+    ASSERT_EQ(0, ba->n_requests);
+    ASSERT_EQ(0, ba->n_toobig);
+    ASSERT_EQ(0, ba->n_toosmall);
+    ASSERT_EQ(RDB_BIGALLOC_ALLOCSZ_MAX, ba->max_blk_alloc);
+    ASSERT_EQ(RDB_BIGALLOC_ALLOCSZ_MIN, ba->min_blk_alloc);
+    ASSERT_EQ(RDB_BIGALLOC_BLKCNT_MAX, ba->max_blk_count);
+    a.release();
+}
+
+TEST_F(BigallocTest, testTooSmall)
+{
+    RdbAllocator a(rdb_bigalloc_new());
+    rdb_BIGALLOC *ba = (rdb_BIGALLOC *)a._inner;
+
+    size_t first_size = RDB_BIGALLOC_ALLOCSZ_MIN * 2;
+    rdb_ROPESEG *seg = a.alloc(first_size);
+    a.free(seg);
+
+    ASSERT_EQ(1, LCB_CLIST_SIZE(&ba->bufs));
+    ASSERT_EQ(1, ba->n_requests);
+    ASSERT_EQ(0, ba->n_toobig);
+    ASSERT_EQ(0, ba->n_toosmall);
+
+    rdb_ROPESEG *newseg = a.alloc(first_size);
+    ASSERT_EQ(seg, newseg);
+    a.free(newseg);
+
+    size_t smallsize = RDB_BIGALLOC_ALLOCSZ_MIN / 2;
+    while (ba->n_requests < RDB_BIGALLOC_RECHECK_RATE-1) {
+        newseg = a.alloc(smallsize);
+        a.free(newseg);
+        ASSERT_EQ(seg, newseg); // same pooled one
+        ASSERT_EQ(0, seg->nused);
+        ASSERT_EQ(0, seg->start);
+        memset(seg->root, '*', seg->nalloc);
+        seg->start = seg->nalloc;
+    }
+
+    size_t oldmin = ba->min_blk_alloc, oldmax = ba->max_blk_alloc;
+    // Get one more:
+    newseg = a.alloc(smallsize);
+    ASSERT_EQ(oldmin/2, ba->min_blk_alloc);
+    ASSERT_EQ(oldmax/2, ba->max_blk_alloc);
+    a.free(newseg);
+
+    rdb_bigalloc_dump(ba, stdout);
+    a.release();
+}
+
+TEST_F(BigallocTest, testPooled)
+{
+    RdbAllocator a(rdb_bigalloc_new());
+    rdb_BIGALLOC *ba = (rdb_BIGALLOC *)a._inner;
+    std::vector<rdb_ROPESEG *> segs;
+    size_t allocsize = 1;
+
+    for (unsigned ii = 0; ii < (ba->max_blk_count * 2); ii++) {
+        rdb_ROPESEG *seg = a.alloc(allocsize);
+        segs.push_back(seg);
+    }
+    rdb_bigalloc_dump(ba, stdout);
+
+    for (unsigned ii = 0; ii < segs.size(); ii++) {
+        a.free(segs[ii]);
+    }
+
+    segs.clear();
+    rdb_bigalloc_dump(ba, stdout);
+    ASSERT_EQ(RDB_BIGALLOC_BLKCNT_MAX, LCB_CLIST_SIZE(&ba->bufs));
+    a.release();
+}
+
+TEST_F(BigallocTest, testRealloc)
+{
+    RdbAllocator a(rdb_bigalloc_new());
+    rdb_ROPESEG *seg = a.alloc(5);
+    // well, we'll see what we have here
+    size_t cursize = seg->nalloc;
+    seg = a.realloc(seg, cursize+1);
+    ASSERT_GT(seg->nalloc, cursize);
+    a.free(seg);
+    a.release();
+}