libcouchbase 0.2.0 → 0.3.1

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

@@ -8,13 +8,8 @@
 class JsonParseTest : public ::testing::Test {
 };
 
-using namespace lcb::jsparse;
 
-static std::string iov2s(const lcb_IOV& iov) {
-    return std::string(reinterpret_cast<const char*>(iov.iov_base), iov.iov_len);
-}
-
-struct Context : Parser::Actions {
+struct Context {
     lcb_error_t rc;
     bool received_done;
     std::string meta;
@@ -28,59 +23,115 @@ struct Context : Parser::Actions {
         meta.clear();
         rows.clear();
     }
-    void JSPARSE_on_row(const Row& row) {
-        rows.push_back(iov2s(row.row));
+};
+
+class Parser {
+public:
+    Parser(int mode_) : mode(mode_), inner(NULL) {
+        reset();
+    }
+
+    void reset() {
+        if (inner != NULL) {
+            lcbjsp_free(inner);
+        }
+        inner = lcbjsp_create(mode);
     }
-    void JSPARSE_on_complete(const std::string& s) {
-        meta.assign(s);
-        received_done = true;
+
+    ~Parser() {
+        if (inner != NULL) {
+            lcbjsp_free(inner);
+        }
     }
-    void JSPARSE_on_error(const std::string&) {
-        rc = LCB_PROTOCOL_ERROR;
-        received_done = true;
+
+    operator lcbjsp_PARSER* () {
+        return inner;
+    }
+
+    lcbjsp_PARSER *getInner() {
+        return inner;
     }
+
+private:
+    int mode;
+    lcbjsp_PARSER *inner;
+    Parser(Parser&);
 };
 
-static bool validateJsonRows(const char *txt, size_t ntxt, Parser::Mode mode)
+static std::string iov2s(const lcb_IOV& iov) {
+    return std::string(reinterpret_cast<const char*>(iov.iov_base), iov.iov_len);
+}
+
+extern "C" {
+static void rowCallback(lcbjsp_PARSER *parser, const lcbjsp_ROW *row) {
+    Context *ctx = reinterpret_cast<Context*>(parser->data);
+    if (row->type == LCBJSP_TYPE_ERROR) {
+        ctx->rc = LCB_PROTOCOL_ERROR;
+        ctx->received_done = true;
+    } else if (row->type == LCBJSP_TYPE_ROW) {
+        ctx->rows.push_back(iov2s(row->row));
+    } else if (row->type == LCBJSP_TYPE_COMPLETE) {
+        ctx->meta = iov2s(row->row);
+        ctx->received_done = true;
+    }
+}
+}
+
+static bool validateJsonRows(const char *txt, size_t ntxt, int mode)
 {
+    Parser parser(mode);
+    EXPECT_TRUE(parser != NULL);
+    if (parser == NULL) {
+        return false;
+    }
+
+    // Feed it once
     Context cx;
-    Parser parser(mode, &cx);
+    parser.getInner()->callback = rowCallback;
+    parser.getInner()->data = &cx;
 
     for (size_t ii = 0; ii < ntxt; ii++) {
-        parser.feed(txt + ii, 1);
+        lcbjsp_feed(parser, txt + ii, 1);
     }
     EXPECT_EQ(LCB_SUCCESS, cx.rc);
 
     lcb_IOV out;
-    parser.get_postmortem(out);
+    lcbjsp_get_postmortem(parser, &out);
     EXPECT_EQ(cx.meta, iov2s(out));
     Json::Value root;
     EXPECT_TRUE(Json::Reader().parse(cx.meta, root));
     return true;
 }
 
-static bool validateBadParse(const char *txt, size_t ntxt, Parser::Mode mode)
+static bool validateBadParse(const char *txt, size_t ntxt, int mode)
 {
+    Parser p(mode);
     Context cx;
-    Parser p(mode, &cx);
-    p.feed(JSON_fts_bad, sizeof(JSON_fts_bad));
+    p.getInner()->callback = rowCallback;
+    p.getInner()->data = &cx;
+    lcbjsp_feed(p, JSON_fts_bad, sizeof(JSON_fts_bad));
     EXPECT_EQ(LCB_PROTOCOL_ERROR, cx.rc);
 
     p.reset();
     cx.reset();
 
+    p.getInner()->callback = rowCallback;
+    p.getInner()->data = &cx;
+
+    for (size_t ii = 0; ii < ntxt; ++ii) {
+    }
     return true;
 }
 
 TEST_F(JsonParseTest, testFTS)
 {
-    ASSERT_TRUE(validateJsonRows(JSON_fts_good, sizeof(JSON_fts_good), Parser::MODE_FTS));
-    ASSERT_TRUE(validateBadParse(JSON_fts_bad, sizeof(JSON_fts_bad), Parser::MODE_FTS));
-    ASSERT_TRUE(validateBadParse(JSON_fts_bad2, sizeof(JSON_fts_bad2), Parser::MODE_FTS));
+    ASSERT_TRUE(validateJsonRows(JSON_fts_good, sizeof(JSON_fts_good), LCBJSP_MODE_FTS));
+    ASSERT_TRUE(validateBadParse(JSON_fts_bad, sizeof(JSON_fts_bad), LCBJSP_MODE_FTS));
+    ASSERT_TRUE(validateBadParse(JSON_fts_bad2, sizeof(JSON_fts_bad2), LCBJSP_MODE_FTS));
 }
 
 TEST_F(JsonParseTest, testN1QL) {
-    ASSERT_TRUE(validateJsonRows(JSON_n1ql_nonempty, sizeof(JSON_n1ql_nonempty), Parser::MODE_N1QL));
-    ASSERT_TRUE(validateJsonRows(JSON_n1ql_empty, sizeof(JSON_n1ql_empty), Parser::MODE_N1QL));
-    ASSERT_TRUE(validateBadParse(JSON_n1ql_bad, sizeof(JSON_n1ql_bad), Parser::MODE_N1QL));
+    ASSERT_TRUE(validateJsonRows(JSON_n1ql_nonempty, sizeof(JSON_n1ql_nonempty), LCBJSP_MODE_N1QL));
+    ASSERT_TRUE(validateJsonRows(JSON_n1ql_empty, sizeof(JSON_n1ql_empty), LCBJSP_MODE_N1QL));
+    ASSERT_TRUE(validateBadParse(JSON_n1ql_bad, sizeof(JSON_n1ql_bad), LCBJSP_MODE_N1QL));
 }

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

@@ -0,0 +1,112 @@
+/* -*- 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 "simplestring.h"
+
+class String : public ::testing::Test
+{
+};
+
+TEST_F(String, testBasic)
+{
+    int rv;
+    lcb_string str;
+    rv = lcb_string_init(&str);
+    ASSERT_EQ(0, rv);
+    ASSERT_EQ(NULL, str.base);
+    ASSERT_EQ(0, str.nalloc);
+    ASSERT_EQ(0, str.nused);
+
+    rv = lcb_string_append(&str, "Hello", 5);
+    ASSERT_EQ(0, rv);
+
+    rv = lcb_string_append(&str, "blah", -1);
+    ASSERT_EQ(-1, rv);
+
+    rv = lcb_string_appendz(&str, "blah");
+    ASSERT_EQ(0, rv);
+
+    ASSERT_EQ(0, strcmp("Helloblah", str.base));
+
+    lcb_string_erase_beginning(&str, 5);
+    ASSERT_EQ(0, strcmp("blah", str.base));
+
+    lcb_string_erase_end(&str, 4);
+    ASSERT_EQ(0, strcmp("", str.base));
+
+    lcb_string_clear(&str);
+    ASSERT_TRUE(str.base != NULL);
+
+    lcb_string_release(&str);
+    ASSERT_EQ(NULL, str.base);
+}
+
+TEST_F(String, testAdvance)
+{
+    int rv;
+    lcb_string str;
+    rv = lcb_string_init(&str);
+    ASSERT_EQ(0, rv);
+
+    rv = lcb_string_reserve(&str, 30);
+    ASSERT_EQ(0, rv);
+    ASSERT_TRUE(str.nalloc >= 30);
+    ASSERT_EQ(0, str.nused);
+
+    memcpy(lcb_string_tail(&str), "Hello", 5);
+    lcb_string_added(&str, 5);
+    ASSERT_EQ(5, str.nused);
+    ASSERT_EQ(0, strcmp(str.base, "Hello"));
+    lcb_string_release(&str);
+}
+
+
+TEST_F(String, testRbCopy)
+{
+    int rv;
+    ringbuffer_t rb;
+    rv = ringbuffer_initialize(&rb, 10);
+    ASSERT_TRUE(rv != 0);
+
+    lcb_string str;
+    rv = lcb_string_init(&str);
+    ASSERT_EQ(0, rv);
+
+    const char *txt = "The quick brown fox jumped over the lazy dog";
+    const int ntxt = strlen(txt);
+    ringbuffer_ensure_capacity(&rb, ntxt);
+
+    ASSERT_EQ(ntxt, ringbuffer_write(&rb, txt, ntxt));
+    ASSERT_EQ(ntxt, rb.nbytes);
+
+    rv = lcb_string_rbappend(&str, &rb, 0);
+    ASSERT_EQ(0, rv);
+
+    ASSERT_EQ(0, strcmp(txt, str.base));
+    ASSERT_EQ(ntxt, str.nused);
+
+    lcb_string_clear(&str);
+    lcb_string_rbappend(&str, &rb, 1);
+    ASSERT_EQ(0, rb.nbytes);
+    ASSERT_EQ(0, strcmp(txt, str.base));
+
+    ringbuffer_destruct(&rb);
+    lcb_string_release(&str);
+}

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

@@ -5,7 +5,6 @@
 #include "settings.h"
 
 using std::string;
-using namespace lcb::htparse;
 
 class HtparseTest : public ::testing::Test {
 };
@@ -14,51 +13,52 @@ TEST_F(HtparseTest, testBasic)
 {
     lcb_settings *settings = lcb_settings_new();
     // Allocate a parser
-    Parser *parser = new Parser(settings);
+    lcbht_pPARSER parser = lcbht_new(settings);
     ASSERT_FALSE(parser == NULL);
 
     // Feed the parser some stuff
-    unsigned state;
+    lcbht_RESPSTATE state;
 
     string buf;
     buf = "HTTP/1.0 200 OK\r\n";
 
-    state = parser->parse(buf.c_str(), buf.size());
+    state = lcbht_parse(parser, buf.c_str(), buf.size());
     ASSERT_EQ(0, state);
 
     buf = "Connec";
-    state = parser->parse(buf.c_str(), buf.size());
+    state = lcbht_parse(parser, buf.c_str(), buf.size());
     ASSERT_EQ(0, state);
     buf = "tion: Keep-Alive\r\n";
-    state = parser->parse(buf.c_str(), buf.size());
+    state = lcbht_parse(parser, buf.c_str(), buf.size());
     ASSERT_EQ(0, state);
     buf += "Content-Length: 5\r\n\r\n";
-    state = parser->parse(buf.c_str(), buf.size());
-    ASSERT_EQ(Parser::S_HEADER|Parser::S_HTSTATUS, state);
+    state = lcbht_parse(parser, buf.c_str(), buf.size());
+    ASSERT_EQ(LCBHT_S_HEADER|LCBHT_S_HTSTATUS, state);
 
-    Response& resp = parser->get_cur_response();
-    ASSERT_EQ(200, resp.status);
+    lcbht_RESPONSE *resp = lcbht_get_response(parser);
+    ASSERT_EQ(200, resp->status);
 
     // Add some data into the body
     buf = "H";
-    state = parser->parse(buf.c_str(), buf.size());
-    ASSERT_EQ(0, state & Parser::S_ERROR);
-    ASSERT_EQ("H", resp.body);
+    state = lcbht_parse(parser, buf.c_str(), buf.size());
+    ASSERT_EQ(0, state & LCBHT_S_ERROR);
+    ASSERT_STREQ("H", resp->body.base);
 
     buf = "ello";
-    state = parser->parse(buf.c_str(), buf.size());
-    ASSERT_NE(0, state & Parser::S_DONE);
-    ASSERT_EQ("Hello", resp.body);
+    state = lcbht_parse(parser, buf.c_str(), buf.size());
+    ASSERT_NE(0, state & LCBHT_S_DONE);
+    ASSERT_STREQ("Hello", resp->body.base);
 
     // Now find the header
-    delete parser;
+
+    lcbht_free(parser);
     lcb_settings_unref(settings);
 }
 
 TEST_F(HtparseTest, testHeaderFunctions)
 {
     lcb_settings *settings = lcb_settings_new();
-    Parser *parser = new Parser(settings);
+    lcbht_pPARSER parser = lcbht_new(settings);
 
     string buf = "HTTP/1.0 200 OK\r\n"
             "Connection: keep-alive\r\n"
@@ -66,28 +66,45 @@ TEST_F(HtparseTest, testHeaderFunctions)
             "Content-Type: application/json\r\n"
             "Content-Length: 0\r\n"
             "\r\n";
-    unsigned state;
-    state = parser->parse(buf.c_str(), buf.size());
-    ASSERT_NE(0, state & Parser::S_DONE);
+    lcbht_RESPSTATE state;
+    state = lcbht_parse(parser, buf.c_str(), buf.size());
+    ASSERT_NE(0, state & LCBHT_S_DONE);
 
-    Response &resp = parser->get_cur_response();
+    lcbht_RESPONSE *resp = lcbht_get_response(parser);
     // Now fine the header value stuff
-    ASSERT_STREQ("keep-alive", resp.get_header_value("Connection"));
-    ASSERT_STREQ("dummy/1.0", resp.get_header_value("X-Server"));
-    ASSERT_STREQ("application/json", resp.get_header_value("Content-Type"));
-    delete parser;
+    ASSERT_STREQ("keep-alive", lcbht_get_resphdr(resp, "Connection"));
+    ASSERT_STREQ("dummy/1.0", lcbht_get_resphdr(resp, "X-Server"));
+    ASSERT_STREQ("application/json", lcbht_get_resphdr(resp, "Content-Type"));
+
+    using std::map;
+    map<string,string> hdrmap;
+    char **hdrlist = lcbht_make_resphdrlist(resp);
+    for (char **cur = hdrlist; *cur != NULL; cur += 2) {
+        string k = cur[0];
+        string v = cur[1];
+        hdrmap[k] = v;
+        free(cur[0]);
+        free(cur[1]);
+    }
+    free(hdrlist);
+
+    ASSERT_EQ("keep-alive", hdrmap["Connection"]);
+    ASSERT_EQ("dummy/1.0", hdrmap["X-Server"]);
+    ASSERT_EQ("application/json", hdrmap["Content-Type"]);
+
+    lcbht_free(parser);
     lcb_settings_unref(settings);
 }
 
 TEST_F(HtparseTest, testParseErrors)
 {
     lcb_settings *settings = lcb_settings_new();
-    Parser *parser = new Parser(settings);
+    lcbht_pPARSER parser = lcbht_new(settings);
 
     string buf = "blahblahblah";
-    unsigned state = parser->parse(buf.c_str(), buf.size());
-    ASSERT_NE(0, state & Parser::S_ERROR);
-    delete parser;
+    lcbht_RESPSTATE state = lcbht_parse(parser, buf.c_str(), buf.size());
+    ASSERT_NE(0, state & LCBHT_S_ERROR);
+    lcbht_free(parser);
     lcb_settings_unref(settings);
 }
 
@@ -95,7 +112,8 @@ TEST_F(HtparseTest, testParseErrors)
 TEST_F(HtparseTest, testParseExtended)
 {
     lcb_settings *settings = lcb_settings_new();
-    Parser *parser = new Parser(settings);
+    lcbht_pPARSER parser = lcbht_new(settings);
+    lcbht_RESPONSE *resp;
 
     const char *body;
     unsigned nbody, nused;
@@ -104,18 +122,18 @@ TEST_F(HtparseTest, testParseExtended)
             "Connection: keep-alive\r\n"
             "Content-Length: 5\r\n";
 
-    unsigned state;
-    state = parser->parse_ex(buf.c_str(), buf.size(), &nused, &nbody, &body);
-    ASSERT_EQ(0, state & Parser::S_ERROR);
+    lcbht_RESPSTATE state;
+    state = lcbht_parse_ex(parser, buf.c_str(), buf.size(), &nused, &nbody, &body);
+    ASSERT_EQ(0, state & LCBHT_S_ERROR);
     ASSERT_EQ(NULL, body);
     ASSERT_EQ(buf.size(), nused);
     ASSERT_EQ(0, nbody);
 
-    Response& resp = parser->get_cur_response();
+    resp = lcbht_get_response(parser);
     buf = "\r\nHello";
     // Feed the buffer
-    state = parser->parse_ex(buf.c_str(), buf.size(), &nused, &nbody, &body);
-    ASSERT_EQ(0, state & Parser::S_DONE);
+    state = lcbht_parse_ex(parser, buf.c_str(), buf.size(), &nused, &nbody, &body);
+    ASSERT_EQ(0, state & LCBHT_S_DONE);
     ASSERT_EQ(5, nbody);
     ASSERT_FALSE(NULL == body);
     ASSERT_STREQ("Hello", body);
@@ -124,50 +142,52 @@ TEST_F(HtparseTest, testParseExtended)
     size_t off = nused;
 
     // Parse again
-    state = parser->parse_ex(buf.c_str()+off, buf.size()-off, &nused, &nbody, &body);
+    state = lcbht_parse_ex(parser, buf.c_str()+off, buf.size()-off, &nused, &nbody, &body);
     ASSERT_EQ(nused, buf.size()-off);
     ASSERT_TRUE(body == NULL);
     ASSERT_EQ(0, nbody);
-    ASSERT_NE(0, state & Parser::S_DONE);
-    ASSERT_EQ(0, state & Parser::S_ERROR);
-    ASSERT_EQ(0, resp.body.size());
-    delete parser;
+    ASSERT_NE(0, state & LCBHT_S_DONE);
+    ASSERT_EQ(0, state & LCBHT_S_ERROR);
+    ASSERT_EQ(0, resp->body.nused);
+
+    lcbht_free(parser);
     lcb_settings_unref(settings);
 }
 
 TEST_F(HtparseTest, testCanKeepalive)
 {
     lcb_settings *settings = lcb_settings_new();
-    Parser *parser = new Parser(settings);
+    lcbht_pPARSER parser = lcbht_new(settings);
     string buf = "HTTP/1.0 200 OK\r\n"
             "Content-Length: 0\r\n"
             "\r\n";
-    unsigned state = parser->parse(buf.c_str(), buf.size());
-    ASSERT_NE(0, state & Parser::S_DONE);
-    ASSERT_EQ(0, state & Parser::S_ERROR);
-    ASSERT_FALSE(parser->can_keepalive());
+    lcbht_RESPSTATE state;
+    state = lcbht_parse(parser, buf.c_str(), buf.size());
+    ASSERT_NE(0, state & LCBHT_S_DONE);
+    ASSERT_EQ(0, state & LCBHT_S_ERROR);
+    ASSERT_EQ(0, lcbht_can_keepalive(parser));
 
     // Use HTTP/1.1 with Connection: close
-    parser->reset();
+    lcbht_reset(parser);
     buf = "HTTP/1.1 200 OK\r\n"
             "Content-Length: 0\r\n"
             "Connection: close\r\n"
             "\r\n";
-    state = parser->parse(buf.c_str(), buf.size());
-    ASSERT_NE(0, state & Parser::S_DONE);
-    ASSERT_EQ(0, state & Parser::S_ERROR);
-    ASSERT_FALSE(parser->can_keepalive());
+    state = lcbht_parse(parser, buf.c_str(), buf.size());
+    ASSERT_NE(0, state & LCBHT_S_DONE);
+    ASSERT_EQ(0, state & LCBHT_S_ERROR);
+    ASSERT_EQ(0, lcbht_can_keepalive(parser));
 
-    parser->reset();
+    lcbht_reset(parser);
     // Default HTTP/1.1
     buf = "HTTP/1.1 200 OK\r\n"
             "Content-Length: 0\r\n"
             "\r\n";
-    state = parser->parse(buf.c_str(), buf.size());
-    ASSERT_NE(0, state & Parser::S_DONE);
-    ASSERT_EQ(0, state & Parser::S_ERROR);
-    ASSERT_TRUE(parser->can_keepalive());
+    state = lcbht_parse(parser, buf.c_str(), buf.size());
+    ASSERT_NE(0, state & LCBHT_S_DONE);
+    ASSERT_EQ(0, state & LCBHT_S_ERROR);
+    ASSERT_NE(0, lcbht_can_keepalive(parser));
 
-    delete parser;
+    lcbht_free(parser);
     lcb_settings_unref(settings);
 }