mt-libcouchbase 1.4.0

data/ext/libcouchbase/src/views/viewreq.h

@@ -0,0 +1,87 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2014-2018 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 <libcouchbase/couchbase.h>
+#include <libcouchbase/views.h>
+#include <libcouchbase/pktfwd.h>
+#include <jsparse/parser.h>
+#include <string>
+#include "docreq.h"
+
+namespace lcb {
+namespace views {
+
+struct ViewRequest;
+struct VRDocRequest : docreq::DocRequest {
+    ViewRequest *parent;
+    lcb_IOV key;
+    lcb_IOV value;
+    lcb_IOV geo;
+    std::string rowbuf;
+};
+
+struct ViewRequest : lcb::jsparse::Parser::Actions {
+    ViewRequest(lcb_t, const void*, const lcb_CMDVIEWQUERY*);
+    ~ViewRequest();
+    void invoke_last(lcb_error_t err);
+    void invoke_last() { invoke_last(lasterr); }
+    void invoke_row(lcb_RESPVIEWQUERY*);
+    void unref() {if(!--refcount){delete this;}}
+    void ref() {refcount++;}
+    void cancel();
+
+    /**
+     * Perform the actual HTTP request
+     * @param cmd User's command
+     */
+    inline lcb_error_t request_http(const lcb_CMDVIEWQUERY* cmd);
+
+    bool is_include_docs() const {
+        return cmdflags & LCB_CMDVIEWQUERY_F_INCLUDE_DOCS;
+    }
+    bool is_no_rowparse() const {
+        return cmdflags & LCB_CMDVIEWQUERY_F_NOROWPARSE;
+    }
+    bool is_spatial() const {
+        return cmdflags & LCB_CMDVIEWQUERY_F_SPATIAL;
+    }
+
+    void JSPARSE_on_row(const lcb::jsparse::Row&);
+    void JSPARSE_on_error(const std::string&);
+    void JSPARSE_on_complete(const std::string&);
+
+    /** Current HTTP response to provide in callbacks */
+    const lcb_RESPHTTP *cur_htresp;
+    /** HTTP request object, in case we need to cancel prematurely */
+    struct lcb_http_request_st *htreq;
+    lcb::jsparse::Parser *parser;
+    const void *cookie;
+    docreq::Queue *docq;
+    lcb_VIEWQUERYCALLBACK callback;
+    lcb_t instance;
+
+    unsigned refcount;
+    uint32_t cmdflags;
+    lcb_error_t lasterr;
+#ifdef LCB_TRACING
+    lcbtrace_SPAN *span;
+#endif
+
+};
+
+}
+}

data/ext/libcouchbase/src/wait.cc

@@ -0,0 +1,156 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2010-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 "internal.h"
+#include <lcbio/iotable.h>
+#include <lcbio/timer-ng.h>
+
+static bool
+has_pending(lcb_t instance)
+{
+
+    if (!instance->retryq->empty(!LCBT_SETTING(instance, wait_for_config))) {
+        return true;
+    }
+
+    if (lcb_aspend_pending(&instance->pendops)) {
+        return true;
+    }
+
+    for (size_t ii = 0; ii < LCBT_NSERVERS(instance); ii++) {
+        if (instance->get_server(ii)->has_pending()) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static void
+maybe_reset_timeouts(lcb_t instance)
+{
+
+    if (!LCBT_SETTING(instance, readj_ts_wait)) {
+        return;
+    }
+
+    uint64_t now = lcb_nstime();
+    for (size_t ii = 0; ii < LCBT_NSERVERS(instance); ++ii) {
+        mcreq_reset_timeouts(instance->get_server(ii), now);
+    }
+    instance->retryq->reset_timeouts(now);
+}
+
+void
+lcb_maybe_breakout(lcb_t instance)
+{
+    if (!instance->wait) {
+        return;
+    }
+    if (has_pending(instance)) {
+        return;
+    }
+
+    instance->wait = 0;
+    instance->iotable->loop.stop(IOT_ARG(instance->iotable));
+}
+
+/**
+ * Returns non zero if the event loop is running now
+ *
+ * @param instance the instance to run the event loop for.
+ */
+LIBCOUCHBASE_API
+int lcb_is_waiting(lcb_t instance)
+{
+    return instance->wait != 0;
+}
+
+/**
+ * Run the event loop until we've got a response for all of our spooled
+ * commands. You should not call this function from within your callbacks.
+ *
+ * @param instance the instance to run the event loop for.
+ *
+ * @author Trond Norbye
+ */
+LIBCOUCHBASE_API
+lcb_error_t lcb_wait(lcb_t instance)
+{
+    if (instance->wait != 0) {
+        return instance->last_error;
+    }
+
+    if (!has_pending(instance)) {
+        return LCB_SUCCESS;
+    }
+
+    maybe_reset_timeouts(instance);
+    instance->last_error = LCB_SUCCESS;
+    instance->wait = 1;
+    IOT_START(instance->iotable);
+    instance->wait = 0;
+
+    if (LCBT_VBCONFIG(instance)) {
+        return LCB_SUCCESS;
+    }
+
+    return instance->last_error;
+}
+
+LIBCOUCHBASE_API
+lcb_error_t lcb_tick_nowait(lcb_t instance)
+{
+    lcb_io_tick_fn tick = instance->iotable->loop.tick;
+    if (!tick) {
+        return LCB_CLIENT_FEATURE_UNAVAILABLE;
+    } else {
+        maybe_reset_timeouts(instance);
+        tick(IOT_ARG(instance->iotable));
+        return LCB_SUCCESS;
+    }
+}
+
+LIBCOUCHBASE_API
+void lcb_wait3(lcb_t instance, lcb_WAITFLAGS flags)
+{
+    if (flags == LCB_WAIT_DEFAULT) {
+        if (instance->wait) {
+            return;
+        }
+        if (has_pending(instance)) {
+            return;
+        }
+    }
+
+    maybe_reset_timeouts(instance);
+    instance->wait = 1;
+    IOT_START(instance->iotable);
+    instance->wait = 0;
+}
+
+/**
+ * Stop event loop
+ *
+ * @param instance the instance to run the event loop for.
+ */
+LIBCOUCHBASE_API
+void lcb_breakout(lcb_t instance)
+{
+    if (instance->wait) {
+        IOT_STOP(instance->iotable);
+        instance->wait = 0;
+    }
+}

data/ext/libcouchbase/tests/CMakeLists.txt

@@ -0,0 +1,149 @@
+# For Windows+GCC we need to link statically
+IF (NOT (WIN32 AND CMAKE_COMPILER_IS_GNUCC))
+    SET(gtest_force_shared_crt ON CACHE BOOL "" )
+    SET(BUILD_SHARED_LIBS ON)
+ENDIF()
+ADD_SUBDIRECTORY(${PROJECT_SOURCE_DIR}/contrib/gtest-1.7.0 gtest)
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
+
+ADD_EXECUTABLE(check-all EXCLUDE_FROM_ALL
+    check-all.cc $<TARGET_OBJECTS:cliopts> mocksupport/procutil.c)
+
+SET_PROPERTY(TARGET check-all
+    APPEND PROPERTY INCLUDE_DIRECTORIES
+    ${lcb_plat_includes}
+    ${SOURCE_ROOT})
+TARGET_LINK_LIBRARIES(check-all couchbaseS)
+
+
+FILE(GLOB T_BASIC_SRC basic/*.cc)
+FILE(GLOB T_MC_SRC mc/*.cc)
+FILE(GLOB T_RDB_SRC rdb/*.cc)
+FILE(GLOB T_SOCK_SRC socktests/*.cc)
+FILE(GLOB T_IOSERVER_SRC ioserver/*.cc)
+FILE(GLOB T_MOCKSUPPORT_SRC mocksupport/*.c mocksupport/*.cc)
+FILE(GLOB T_VBTEST_SRC vbucket/*.cc)
+
+ADD_LIBRARY(ioserver OBJECT EXCLUDE_FROM_ALL ${T_IOSERVER_SRC})
+IF(NOT LCB_NO_SSL)
+    GET_TARGET_PROPERTY(_ioserver_includes ioserver INCLUDE_DIRECTORIES)
+    SET_TARGET_PROPERTIES(ioserver PROPERTIES INCLUDE_DIRECTORIES "${_ioserver_includes};${OPENSSL_INCLUDE_DIR}")
+ENDIF()
+
+
+ADD_EXECUTABLE(nonio-tests EXCLUDE_FROM_ALL nonio_tests.cc ${T_BASIC_SRC})
+
+ADD_EXECUTABLE(mc-tests EXCLUDE_FROM_ALL nonio_tests.cc ${T_MC_SRC}
+    $<TARGET_OBJECTS:mcreq> $<TARGET_OBJECTS:mcreq-cxx> $<TARGET_OBJECTS:netbuf> $<TARGET_OBJECTS:vbucket-lcb>)
+
+ADD_EXECUTABLE(mc-malloc-tests EXCLUDE_FROM_ALL nonio_tests.cc ${T_MC_SRC}
+    $<TARGET_OBJECTS:mcreq> $<TARGET_OBJECTS:mcreq-cxx> $<TARGET_OBJECTS:netbuf-malloc> $<TARGET_OBJECTS:vbucket-lcb>)
+
+ADD_EXECUTABLE(netbuf-tests
+    EXCLUDE_FROM_ALL nonio_tests.cc basic/t_netbuf.cc $<TARGET_OBJECTS:netbuf>)
+
+ADD_EXECUTABLE(rdb-tests EXCLUDE_FROM_ALL nonio_tests.cc
+    ${T_RDB_SRC} $<TARGET_OBJECTS:rdb> ${SOURCE_ROOT}/src/list.c)
+
+ADD_EXECUTABLE(sock-tests EXCLUDE_FROM_ALL nonio_tests.cc
+    ${T_SOCK_SRC} $<TARGET_OBJECTS:ioserver>)
+
+ADD_EXECUTABLE(vbucket-tests EXCLUDE_FROM_ALL nonio_tests.cc ${T_VBTEST_SRC})
+ADD_EXECUTABLE(htparse-tests EXCLUDE_FROM_ALL nonio_tests.cc htparse/t_basic.cc)
+
+FILE(GLOB T_IO_SRC iotests/*.cc)
+IF(LCB_NO_MOCK)
+    ADD_EXECUTABLE(unit-tests EXCLUDE_FROM_ALL unit_tests.cc)
+    SET_TARGET_PROPERTIES(unit-tests PROPERTIES COMPILE_DEFINITIONS NO_COUCHBASEMOCK)
+ELSE()
+    ADD_LIBRARY(mocksupport OBJECT EXCLUDE_FROM_ALL ${T_MOCKSUPPORT_SRC})
+    ADD_EXECUTABLE(unit-tests EXCLUDE_FROM_ALL ${T_IO_SRC} unit_tests.cc $<TARGET_OBJECTS:mocksupport>)
+ENDIF()
+
+IF(CMAKE_COMPILER_IS_GNUCXX)
+    SET_TARGET_PROPERTIES(unit-tests
+        PROPERTIES
+        COMPILE_FLAGS "-Wno-sign-compare -Wno-missing-field-initializers")
+ENDIF(CMAKE_COMPILER_IS_GNUCXX)
+
+IF(NOT LCB_NO_MOCK)
+    IF(NOT EXISTS ${PROJECT_SOURCE_DIR}/tests/CouchbaseMock.jar)
+        DOWNLOAD_LCB_DEP("${COUCHBASE_MOCK_URL}" "${PROJECT_SOURCE_DIR}/tests/CouchbaseMock.jar")
+    ENDIF()
+    FIND_PROGRAM(JAVA java)
+    EXECUTE_PROCESS(COMMAND "${JAVA}" -jar "${PROJECT_SOURCE_DIR}/tests/CouchbaseMock.jar" --version
+                    RESULT_VARIABLE RET OUTPUT_VARIABLE VER OUTPUT_STRIP_TRAILING_WHITESPACE)
+    IF(RET EQUAL 0)
+        MESSAGE(STATUS "Using ${VER}")
+    ELSE()
+        MESSAGE(FATAL_ERROR "Unable to use ${PROJECT_SOURCE_DIR}/tests/CouchbaseMock.jar as CouchbaseMock")
+    ENDIF()
+ENDIF()
+
+# We're a library using the shared CRT. Don't use the static one
+INCLUDE_DIRECTORIES(${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR})
+TARGET_LINK_LIBRARIES(unit-tests couchbaseS gtest)
+TARGET_LINK_LIBRARIES(nonio-tests couchbaseS gtest)
+TARGET_LINK_LIBRARIES(mc-tests couchbaseS gtest)
+TARGET_LINK_LIBRARIES(mc-malloc-tests couchbaseS gtest)
+TARGET_LINK_LIBRARIES(netbuf-tests gtest)
+TARGET_LINK_LIBRARIES(rdb-tests gtest)
+TARGET_LINK_LIBRARIES(sock-tests couchbaseS gtest)
+TARGET_LINK_LIBRARIES(vbucket-tests gtest couchbaseS)
+TARGET_LINK_LIBRARIES(htparse-tests gtest couchbaseS)
+
+IF(WIN32)
+    TARGET_LINK_LIBRARIES(mc-tests ws2_32.lib)
+    TARGET_LINK_LIBRARIES(mc-malloc-tests ws2_32.lib)
+ENDIF()
+
+ADD_CUSTOM_TARGET(alltests DEPENDS check-all unit-tests nonio-tests
+    rdb-tests sock-tests vbucket-tests mc-tests htparse-tests)
+
+
+ADD_TEST(NAME BUILD-TESTS COMMAND ${CMAKE_COMMAND} --build "${PROJECT_BINARY_DIR}" --target alltests)
+
+MACRO(DEFINE_MOCKTEST plugin test)
+    ADD_TEST(
+        NAME
+            check-${plugin}-${test}
+        COMMAND
+            $<TARGET_FILE:check-all>
+            --srcdir "${PROJECT_SOURCE_DIR}"
+            --testdir "$<TARGET_FILE_DIR:check-all>"
+            --libdir "$<TARGET_FILE_DIR:couchbase>"
+            --plugins ${plugin}
+            --tests ${test}
+            --verbose
+            --
+            --gtest_print_time=1
+            --gtest_output=xml:"${PROJECT_BINARY_DIR}/REPORT_${plugin}_${test}.xml")
+ENDMACRO()
+
+# Since we need a plugin name, we'll use 'select'. However none of these
+# actually do any I/O
+DEFINE_MOCKTEST("select" "nonio-tests")
+DEFINE_MOCKTEST("select" "rdb-tests")
+DEFINE_MOCKTEST("select" "vbucket-tests")
+DEFINE_MOCKTEST("select" "mc-tests")
+DEFINE_MOCKTEST("select" "htparse-tests")
+
+
+DEFINE_MOCKTEST("select" "unit-tests")
+DEFINE_MOCKTEST("select" "sock-tests")
+IF(WIN32)
+    DEFINE_MOCKTEST("iocp" "unit-tests")
+    DEFINE_MOCKTEST("iocp" "sock-tests")
+ENDIF()
+IF(HAVE_LIBEVENT AND LCB_BUILD_LIBEVENT)
+    DEFINE_MOCKTEST("libevent" "unit-tests")
+    DEFINE_MOCKTEST("libevent" "sock-tests")
+ENDIF()
+IF(HAVE_LIBEV AND LCB_BUILD_LIBEV)
+    DEFINE_MOCKTEST("libev" "unit-tests")
+    DEFINE_MOCKTEST("libev" "sock-tests")
+ENDIF()
+IF(HAVE_LIBUV AND LCB_BUILD_LIBUV)
+    DEFINE_MOCKTEST("libuv" "unit-tests")
+    DEFINE_MOCKTEST("libuv" "sock-tests")
+ENDIF()

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

@@ -0,0 +1,109 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2011-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>
+
+extern "C" {
+extern int lcb_base64_encode(const char *src, size_t nsrc, char *dst, size_t ndst);
+extern int lcb_base64_decode(const char *src, size_t nsrc, char *dst, size_t ndst);
+
+extern int lcb_base64_encode2(const char *src, size_t nsrc, char **dst, size_t *ndst);
+extern int lcb_base64_decode2(const char *src, size_t nsrc, char **dst, size_t *ndst);
+}
+
+class Base64 : public ::testing::Test
+{
+  protected:
+    void validate(const char *src, const char *result)
+    {
+        char dest[1024];
+        ASSERT_GE(lcb_base64_encode(src, strlen(src), dest, sizeof(dest)), 0);
+        EXPECT_STREQ(result, dest);
+        memset(dest, 0, sizeof(dest));
+        ASSERT_GE(lcb_base64_decode(result, strlen(result), dest, sizeof(dest)), 0);
+        EXPECT_STREQ(src, dest);
+
+        char *tmp = NULL;
+        size_t ntmp = 0;
+        ASSERT_GE(lcb_base64_encode2(src, strlen(src), &tmp, &ntmp), 0);
+        EXPECT_STREQ(result, tmp);
+        free(tmp);
+        tmp = NULL;
+        ntmp = 0;
+        ASSERT_GE(lcb_base64_decode2(result, strlen(result), &tmp, &ntmp), 0);
+        EXPECT_STREQ(src, tmp);
+        free(tmp);
+    }
+};
+
+TEST_F(Base64, testRFC4648)
+{
+    validate("", "");
+    validate("f", "Zg==");
+    validate("fo", "Zm8=");
+    validate("foo", "Zm9v");
+    validate("foob", "Zm9vYg==");
+    validate("fooba", "Zm9vYmE=");
+    validate("foobar", "Zm9vYmFy");
+}
+
+TEST_F(Base64, testWikipediaExample)
+{
+    /* Examples from http://en.wikipedia.org/wiki/Base64 */
+    validate("Man is distinguished, not only by his reason, but by this singular "
+             "passion from other animals, which is a lust of the mind, that by a "
+             "perseverance of delight in the continued and indefatigable generation"
+             " of knowledge, exceeds the short vehemence of any carnal pleasure.",
+             "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlz"
+             "IHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2Yg"
+             "dGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGlu"
+             "dWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRo"
+             "ZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=");
+    validate("pleasure.", "cGxlYXN1cmUu");
+    validate("leasure.", "bGVhc3VyZS4=");
+    validate("easure.", "ZWFzdXJlLg==");
+    validate("asure.", "YXN1cmUu");
+    validate("sure.", "c3VyZS4=");
+}
+
+TEST_F(Base64, testStuff)
+{
+    // Dummy test data. It looks like the "base64" command line
+    // utility from gnu coreutils adds the "\n" to the encoded data...
+    validate("Administrator:password", "QWRtaW5pc3RyYXRvcjpwYXNzd29yZA==");
+    validate("@", "QA==");
+    validate("@\n", "QAo=");
+    validate("@@", "QEA=");
+    validate("@@\n", "QEAK");
+    validate("@@@", "QEBA");
+    validate("@@@\n", "QEBACg==");
+    validate("@@@@", "QEBAQA==");
+    validate("@@@@\n", "QEBAQAo=");
+    validate("blahblah:bla@@h", "YmxhaGJsYWg6YmxhQEBo");
+    validate("blahblah:bla@@h\n", "YmxhaGJsYWg6YmxhQEBoCg==");
+}
+
+TEST_F(Base64, testTooSmallOutputBuffer)
+{
+    const char *plain = "foobar";
+    const char *base64 = "Zm9vYmFy";
+
+    char dest[2];
+
+    ASSERT_EQ(lcb_base64_encode(plain, strlen(plain), dest, sizeof(dest)), -1);
+    ASSERT_EQ(lcb_base64_decode(base64, strlen(base64), dest, sizeof(dest)), -1);
+}

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

@@ -0,0 +1,95 @@
+/* -*- 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 "list.h"
+
+
+class CCBC_103 : public ::testing::Test
+{
+};
+
+typedef struct {
+    lcb_list_t list;
+} event_t;
+
+typedef struct {
+    event_t events;
+} io_cookie;
+
+TEST_F(CCBC_103, lists)
+{
+    io_cookie instance;
+    event_t e1, e2, e3, e4;
+
+    lcb_list_init(&instance.events.list);
+    lcb_list_append(&instance.events.list, &e1.list);
+    ASSERT_EQ(&e1.list, instance.events.list.prev);
+
+    lcb_list_append(&instance.events.list, &e2.list);
+    ASSERT_EQ(&e2.list, instance.events.list.prev);
+
+    lcb_list_append(&instance.events.list, &e3.list);
+    ASSERT_EQ(&e3.list, instance.events.list.prev);
+
+    lcb_list_append(&instance.events.list, &e4.list);
+    ASSERT_EQ(&e4.list, instance.events.list.prev);
+
+    ASSERT_EQ(1, lcb_list_contains(&instance.events.list, &e1.list));
+    ASSERT_EQ(1, lcb_list_contains(&instance.events.list, &e2.list));
+    ASSERT_EQ(1, lcb_list_contains(&instance.events.list, &e3.list));
+    ASSERT_EQ(1, lcb_list_contains(&instance.events.list, &e4.list));
+
+    // Try to unlink the one in the middle
+    lcb_list_delete(&e2.list);
+    ASSERT_EQ(1, lcb_list_contains(&instance.events.list, &e1.list));
+    ASSERT_EQ(0, lcb_list_contains(&instance.events.list, &e2.list));
+    ASSERT_EQ(1, lcb_list_contains(&instance.events.list, &e3.list));
+    ASSERT_EQ(1, lcb_list_contains(&instance.events.list, &e4.list));
+
+    // Try to unlink the last one
+    lcb_list_delete(&e1.list);
+    ASSERT_EQ(0, lcb_list_contains(&instance.events.list, &e1.list));
+    ASSERT_EQ(0, lcb_list_contains(&instance.events.list, &e2.list));
+    ASSERT_EQ(1, lcb_list_contains(&instance.events.list, &e3.list));
+    ASSERT_EQ(1, lcb_list_contains(&instance.events.list, &e4.list));
+
+    // try to unlink the current head
+    lcb_list_delete(&e4.list);
+    ASSERT_EQ(0, lcb_list_contains(&instance.events.list, &e1.list));
+    ASSERT_EQ(0, lcb_list_contains(&instance.events.list, &e2.list));
+    ASSERT_EQ(1, lcb_list_contains(&instance.events.list, &e3.list));
+    ASSERT_EQ(0, lcb_list_contains(&instance.events.list, &e4.list));
+
+    // try to unlink the last one
+    lcb_list_delete(&e3.list);
+    ASSERT_EQ(0, lcb_list_contains(&instance.events.list, &e1.list));
+    ASSERT_EQ(0, lcb_list_contains(&instance.events.list, &e2.list));
+    ASSERT_EQ(0, lcb_list_contains(&instance.events.list, &e3.list));
+    ASSERT_EQ(0, lcb_list_contains(&instance.events.list, &e4.list));
+
+    // And we should be able to add all back
+    lcb_list_append(&instance.events.list, &e1.list);
+    lcb_list_append(&instance.events.list, &e2.list);
+    lcb_list_append(&instance.events.list, &e3.list);
+    lcb_list_append(&instance.events.list, &e4.list);
+    ASSERT_EQ(1, lcb_list_contains(&instance.events.list, &e1.list));
+    ASSERT_EQ(1, lcb_list_contains(&instance.events.list, &e2.list));
+    ASSERT_EQ(1, lcb_list_contains(&instance.events.list, &e3.list));
+    ASSERT_EQ(1, lcb_list_contains(&instance.events.list, &e4.list));
+}