libcouchbase 0.3.3 → 1.0.0

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

@@ -8,8 +8,13 @@
 class JsonParseTest : public ::testing::Test {
 };
 
+using namespace lcb::jsparse;
 
-struct Context {
+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 {
     lcb_error_t rc;
     bool received_done;
     std::string meta;
@@ -23,115 +28,55 @@ struct Context {
         meta.clear();
         rows.clear();
     }
-};
-
-class Parser {
-public:
-    Parser(int mode_) : mode(mode_), inner(NULL) {
-        reset();
+    void JSPARSE_on_row(const Row& row) {
+        rows.push_back(iov2s(row.row));
     }
-
-    void reset() {
-        if (inner != NULL) {
-            lcbjsp_free(inner);
-        }
-        inner = lcbjsp_create(mode);
-    }
-
-    ~Parser() {
-        if (inner != NULL) {
-            lcbjsp_free(inner);
-        }
+    void JSPARSE_on_complete(const std::string& s) {
+        meta.assign(s);
+        received_done = true;
     }
-
-    operator lcbjsp_PARSER* () {
-        return inner;
+    void JSPARSE_on_error(const std::string&) {
+        rc = LCB_PROTOCOL_ERROR;
+        received_done = true;
     }
-
-    lcbjsp_PARSER *getInner() {
-        return inner;
-    }
-
-private:
-    int mode;
-    lcbjsp_PARSER *inner;
-    Parser(Parser&);
 };
 
-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)
+static bool validateJsonRows(const char *txt, size_t ntxt, Parser::Mode mode)
 {
-    Parser parser(mode);
-    EXPECT_TRUE(parser != NULL);
-    if (parser == NULL) {
-        return false;
-    }
-
-    // Feed it once
     Context cx;
-    parser.getInner()->callback = rowCallback;
-    parser.getInner()->data = &cx;
+    Parser parser(mode, &cx);
 
     for (size_t ii = 0; ii < ntxt; ii++) {
-        lcbjsp_feed(parser, txt + ii, 1);
+        parser.feed(txt + ii, 1);
     }
     EXPECT_EQ(LCB_SUCCESS, cx.rc);
 
     lcb_IOV out;
-    lcbjsp_get_postmortem(parser, &out);
+    parser.get_postmortem(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, int mode)
+static bool validateBadParse(const char *txt, size_t ntxt, Parser::Mode mode)
 {
-    Parser p(mode);
     Context cx;
-    p.getInner()->callback = rowCallback;
-    p.getInner()->data = &cx;
-    lcbjsp_feed(p, JSON_fts_bad, sizeof(JSON_fts_bad));
+    Parser p(mode, &cx);
+    p.feed(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), 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));
+    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));
 }
 
 TEST_F(JsonParseTest, testN1QL) {
-    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));
+    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));
 }

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

@@ -20,5 +20,5 @@ TEST_F(MiscTests, testGetTmpdir)
     ASSERT_STRNE("", tmpdir);
 }
 TEST_F(MiscTests, testVersionG) {
-    ASSERT_GT(lcb_version_g, 0);
+    ASSERT_GT(lcb_version_g, (lcb_U32)0);
 }

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

@@ -8,7 +8,6 @@ class N1qLStringTests : public ::testing::Test {
 
 TEST_F(N1qLStringTests, testParseTimeout)
 {
-    lcb_U32 value;
     ASSERT_EQ(1500000, lcb_n1qlreq_parsetmo("1.5s"));
     ASSERT_EQ(1500000, lcb_n1qlreq_parsetmo("1500ms"));
     ASSERT_EQ(1500000, lcb_n1qlreq_parsetmo("1500000us"));

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

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

data/ext/libcouchbase/tests/ioserver/connection.cc

@@ -37,7 +37,7 @@ TestConnection::sendData()
         void *outbuf;
 #endif
         size_t n = f_send->getBuf((void**)&outbuf);
-        size_t nw = datasock->send(outbuf, n);
+        ssize_t nw = datasock->send(outbuf, n);
         if (nw < 0) {
             f_send->bail();
         } else {

data/ext/libcouchbase/tests/ioserver/ioserver.cc

@@ -16,17 +16,30 @@ server_runfunc(void *arg)
 void
 TestServer::run()
 {
+    if (closed) {
+        return;
+    }
+
+    fd_set fds;
+    struct timeval tmout = { 1, 0 };
+
+    FD_ZERO(&fds);
+    FD_SET(*lsn, &fds);
+
     while (!closed) {
         struct sockaddr_in newaddr;
         socklen_t naddr = sizeof(newaddr);
-        int newsock = accept(*lsn, (struct sockaddr *)&newaddr, &naddr);
 
-        if (newsock == -1) {
-            break;
-        }
+        if (select(*lsn + 1, &fds, NULL, NULL, &tmout) == 1) {
+            int newsock = accept(*lsn, (struct sockaddr *)&newaddr, &naddr);
 
-        TestConnection *newconn = new TestConnection(this, factory(newsock));
-        startConnection(newconn);
+            if (newsock == -1) {
+                break;
+            }
+
+            TestConnection *newconn = new TestConnection(this, factory(newsock));
+            startConnection(newconn);
+        }
     }
 }