libcouchbase 0.0.7 → 0.0.8

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,59 @@ struct Context {
         meta.clear();
         rows.clear();
     }
-};
-
-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_row(const Row& row) {
+        rows.push_back(iov2s(row.row));
     }
-
-    ~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;
-    }
-
-    lcbjsp_PARSER *getInner() {
-        return inner;
+    void JSPARSE_on_error(const std::string&) {
+        rc = LCB_PROTOCOL_ERROR;
+        received_done = true;
     }
-
-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_packet.cc

@@ -135,23 +135,22 @@ TEST_F(Packet, testParseBasic)
     pkt.getq(value, 0);
     pkt.rbWrite(&ior);
 
-    packet_info pi;
+    lcb::MemcachedResponse pi;
     memset(&pi, 0, sizeof(pi));
     unsigned wanted;
-    int rv = lcb_pktinfo_ior_get(&pi, &ior, &wanted);
-    ASSERT_EQ(rv, 1);
-
-    ASSERT_EQ(0, PACKET_STATUS(&pi));
-    ASSERT_EQ(PROTOCOL_BINARY_CMD_GETQ, PACKET_OPCODE(&pi));
-    ASSERT_EQ(0, PACKET_OPAQUE(&pi));
-    ASSERT_EQ(7, PACKET_NBODY(&pi));
-    ASSERT_EQ(3, PACKET_NVALUE(&pi));
-    ASSERT_EQ(0, PACKET_NKEY(&pi));
-    ASSERT_EQ(4, PACKET_EXTLEN(&pi));
-    ASSERT_EQ(PACKET_NBODY(&pi), rdb_get_nused(&ior));
-    ASSERT_EQ(0, strncmp(value.c_str(), PACKET_VALUE(&pi), 3));
-
-    lcb_pktinfo_ior_done(&pi, &ior);
+    ASSERT_TRUE(pi.load(&ior, &wanted));
+
+    ASSERT_EQ(0, pi.status());
+    ASSERT_EQ(PROTOCOL_BINARY_CMD_GETQ, pi.opcode());
+    ASSERT_EQ(0, pi.opaque());
+    ASSERT_EQ(7, pi.bodylen());
+    ASSERT_EQ(3, pi.vallen());
+    ASSERT_EQ(0, pi.keylen());
+    ASSERT_EQ(4, pi.extlen());
+    ASSERT_EQ(pi.bodylen(), rdb_get_nused(&ior));
+    ASSERT_EQ(0, strncmp(value.c_str(), pi.value(), 3));
+
+    pi.release(&ior);
     ASSERT_EQ(0, rdb_get_nused(&ior));
     rdb_cleanup(&ior);
 }
@@ -165,26 +164,22 @@ TEST_F(Packet, testParsePartial)
     std::string value;
     value.insert(0, 1024, '*');
 
-    packet_info pi;
-    int rv;
+    lcb::MemcachedResponse pi;
 
     // Test where we're missing just one byte
     pkt.writeGenericHeader(10, &ior);
     unsigned wanted;
-    rv = lcb_pktinfo_ior_get(&pi, &ior, &wanted);
-    ASSERT_EQ(0, rv);
+    ASSERT_FALSE(pi.load(&ior, &wanted));
 
     for (int ii = 0; ii < 9; ii++) {
         char c = 'O';
         rdb_copywrite(&ior, &c, 1);
-        rv = lcb_pktinfo_ior_get(&pi, &ior, &wanted);
-        ASSERT_EQ(0, rv);
+        ASSERT_FALSE(pi.load(&ior, &wanted));
     }
     char tmp = 'O';
     rdb_copywrite(&ior, &tmp, 1);
-    rv = lcb_pktinfo_ior_get(&pi, &ior, &wanted);
-    ASSERT_EQ(1, rv);
-    lcb_pktinfo_ior_done(&pi, &ior);
+    ASSERT_TRUE(pi.load(&ior, &wanted));
+    pi.release(&ior);
     rdb_cleanup(&ior);
 }
 
@@ -199,24 +194,22 @@ TEST_F(Packet, testKeys)
     pkt.get(key, value, 1000, PROTOCOL_BINARY_RESPONSE_ETMPFAIL, 0xdeadbeef, 50);
     pkt.rbWrite(&ior);
 
-    packet_info pi;
-    memset(&pi, 0, sizeof(pi));
+    lcb::MemcachedResponse pi;
     unsigned wanted;
-    int rv = lcb_pktinfo_ior_get(&pi, &ior, &wanted);
-    ASSERT_EQ(1, rv);
-
-    ASSERT_EQ(key.size(), PACKET_NKEY(&pi));
-    ASSERT_EQ(0, memcmp(key.c_str(), PACKET_KEY(&pi), PACKET_NKEY(&pi)));
-    ASSERT_EQ(value.size(), PACKET_NVALUE(&pi));
-    ASSERT_EQ(0, memcmp(value.c_str(), PACKET_VALUE(&pi), PACKET_NVALUE(&pi)));
-    ASSERT_EQ(0xdeadbeef, PACKET_CAS(&pi));
-    ASSERT_EQ(PROTOCOL_BINARY_RESPONSE_ETMPFAIL, PACKET_STATUS(&pi));
-    ASSERT_EQ(PROTOCOL_BINARY_CMD_GET, PACKET_OPCODE(&pi));
-    ASSERT_EQ(4, PACKET_EXTLEN(&pi));
-    ASSERT_EQ(4 + key.size() + value.size(), PACKET_NBODY(&pi));
-    ASSERT_NE(pi.payload, PACKET_VALUE(&pi));
-    ASSERT_EQ(4 + key.size(), PACKET_VALUE(&pi) - (char *)pi.payload);
-
-    lcb_pktinfo_ior_done(&pi, &ior);
+    ASSERT_TRUE(pi.load(&ior, &wanted));
+
+    ASSERT_EQ(key.size(), pi.keylen());
+    ASSERT_EQ(0, memcmp(key.c_str(), pi.key(), pi.keylen()));
+    ASSERT_EQ(value.size(), pi.vallen());
+    ASSERT_EQ(0, memcmp(value.c_str(), pi.value(), pi.vallen()));
+    ASSERT_EQ(0xdeadbeef, pi.cas());
+    ASSERT_EQ(PROTOCOL_BINARY_RESPONSE_ETMPFAIL, pi.status());
+    ASSERT_EQ(PROTOCOL_BINARY_CMD_GET, pi.opcode());
+    ASSERT_EQ(4, pi.extlen());
+    ASSERT_EQ(4 + key.size() + value.size(), pi.bodylen());
+    ASSERT_NE(pi.body<const char*>(), pi.value());
+    ASSERT_EQ(4 + key.size(), pi.value() - pi.body<const char*>());
+
+    pi.release(&ior);
     rdb_cleanup(&ior);
 }

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);
 }