gauc 0.3.0

Couchbase Rust Adapter / CLI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

#include "socktest.h"
using namespace LCBTest;
using std::string;
using std::vector;
class SockWriteTest : public SockTest {};

/**
 * This file tests the ability of the sockets to write various pieces
 * of data.
 */
TEST_F(SockWriteTest, testMultiWrite)
{
    ESocket sock;
    loop->connect(&sock);

    string expected("Hello World!");
    RecvFuture rf(expected.size());
    FutureBreakCondition wbc(&rf);

    sock.put("Hello "); sock.schedule();
    sock.put("World"); sock.schedule();
    sock.put("!"); sock.schedule();
    sock.schedule();

    sock.conn->setRecv(&rf);

    loop->setBreakCondition(&wbc);
    loop->start();
    rf.wait();
    ASSERT_TRUE(rf.isOk());
    ASSERT_EQ(expected, rf.getString());
}


/**
 * Test with a very big write
 */
TEST_F(SockWriteTest, testBigWrite)
{
    ESocket sock;
    loop->connect(&sock);
    string expected(1024*1024*2, '*');
    RecvFuture rf(expected.size());
    sock.conn->setRecv(&rf);
    sock.put(expected);
    sock.schedule();

    FutureBreakCondition wbc(&rf);
    loop->setBreakCondition(&wbc);
    loop->start();
    rf.wait();
    ASSERT_TRUE(rf.isOk());
    ASSERT_EQ(expected, rf.getString());
}

/**
 * Write to a broken socket. Because close is not synchronous on both ends
 * of the connection (even though in this case they are on the same host)
 * we need to loop until we get an error.
 */
TEST_F(SockWriteTest, testBrokenFirstWrite)
{
    ESocket sock;
    loop->connect(&sock);

    while (sock.lasterr == LCB_SUCCESS) {
        CloseFuture cf(CloseFuture::BEFORE_IO);
        FlushedBreakCondition fbc(&sock);
        sock.conn->setClose(&cf);
        sock.put("This should fail");
        sock.schedule();
        loop->setBreakCondition(&fbc);
        loop->start();
        cf.wait();
    }
}

TEST_F(SockWriteTest, testBrokenMultiWrites)
{
    ESocket sock;
    loop->connect(&sock);
    while (sock.lasterr == LCB_SUCCESS) {
        CloseFuture cf(CloseFuture::BEFORE_IO);
        FlushedBreakCondition fbc(&sock);
        sock.conn->setClose(&cf);

        for (int ii = 0; ii < 100; ii++) {
            sock.put("This message should fail");
            sock.schedule();
        }
        loop->setBreakCondition(&fbc);
        loop->start();
        cf.wait();
    }
}