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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
|
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef BLIMP_NET_TEST_COMMON_H_
#define BLIMP_NET_TEST_COMMON_H_
#include <string>
#include "base/memory/scoped_ptr.h"
#include "blimp/common/proto/blimp_message.pb.h"
#include "blimp/net/blimp_message_processor.h"
#include "blimp/net/blimp_transport.h"
#include "blimp/net/connection_error_observer.h"
#include "blimp/net/connection_handler.h"
#include "blimp/net/packet_reader.h"
#include "blimp/net/packet_writer.h"
#include "net/socket/stream_socket.h"
#include "testing/gmock/include/gmock/gmock.h"
namespace net {
class GrowableIOBuffer;
} // namespace net
namespace blimp {
// Checks if the contents of a buffer are an exact match with std::string.
// Using this matcher for inequality checks will result in undefined behavior,
// due to IOBuffer's lack of a size field.
//
// arg (type: IOBuffer*) The buffer to check.
// data (type: std::string) The string to compare with |arg|.
MATCHER_P(BufferEquals, expected, "") {
return expected == std::string(arg->data(), expected.size());
}
// Checks if two proto messages are the same.
// TODO(kmarshall): promote to a shared testing library.
MATCHER_P(EqualsProto, message, "") {
std::string expected_serialized;
std::string actual_serialized;
message.SerializeToString(&expected_serialized);
arg.SerializeToString(&actual_serialized);
return expected_serialized == actual_serialized;
}
// Checks if the contents of a buffer are an exact match with BlimpMessage.
// arg (type: net::DrainableIOBuffer*) The buffer to check.
// message (type: BlimpMessage) The message to compare with |arg|.
MATCHER_P(BufferEqualsProto, message, "") {
BlimpMessage actual_message;
actual_message.ParseFromArray(arg->data(), arg->BytesRemaining());
std::string expected_serialized;
std::string actual_serialized;
message.SerializeToString(&expected_serialized);
actual_message.SerializeToString(&actual_serialized);
return expected_serialized == actual_serialized;
}
// GMock action that writes data from a string to an IOBuffer.
//
// buf_idx (template parameter 0): 0-based index of the IOBuffer arg.
// str: the string containing data to be written to the IOBuffer.
ACTION_TEMPLATE(FillBufferFromString,
HAS_1_TEMPLATE_PARAMS(int, buf_idx),
AND_1_VALUE_PARAMS(str)) {
memcpy(testing::get<buf_idx>(args)->data(), str.data(), str.size());
}
// Returns true if |buf| has a prefix of |str|.
// Behavior is undefined if len(buf) < len(str).
bool BufferStartsWith(net::GrowableIOBuffer* buf, const std::string& str);
// GMock action that writes data from a blimp message to an IOBuffer .
//
// buf_idx (template parameter 0): 0-based index of the IOBuffer arg.
// message: the blimp message containing data to be written to the IOBuffer
ACTION_TEMPLATE(FillBufferFromMessage,
HAS_1_TEMPLATE_PARAMS(int, buf_idx),
AND_1_VALUE_PARAMS(message)) {
message->SerializeToArray(testing::get<buf_idx>(args)->data(),
message->ByteSize());
}
// Formats a string-based representation of a BlimpMessage header.
std::string EncodeHeader(size_t size);
class MockStreamSocket : public net::StreamSocket {
public:
MockStreamSocket();
virtual ~MockStreamSocket();
MOCK_METHOD3(Read, int(net::IOBuffer*, int, const net::CompletionCallback&));
MOCK_METHOD3(Write, int(net::IOBuffer*, int, const net::CompletionCallback&));
MOCK_METHOD1(SetReceiveBufferSize, int(int32));
MOCK_METHOD1(SetSendBufferSize, int(int32));
MOCK_METHOD1(Connect, int(const net::CompletionCallback&));
MOCK_METHOD0(Disconnect, void());
MOCK_CONST_METHOD0(IsConnected, bool());
MOCK_CONST_METHOD0(IsConnectedAndIdle, bool());
MOCK_CONST_METHOD1(GetPeerAddress, int(net::IPEndPoint*));
MOCK_CONST_METHOD1(GetLocalAddress, int(net::IPEndPoint*));
MOCK_CONST_METHOD0(NetLog, const net::BoundNetLog&());
MOCK_METHOD0(SetSubresourceSpeculation, void());
MOCK_METHOD0(SetOmniboxSpeculation, void());
MOCK_CONST_METHOD0(WasEverUsed, bool());
MOCK_CONST_METHOD0(UsingTCPFastOpen, bool());
MOCK_CONST_METHOD0(NumBytesRead, int64());
MOCK_CONST_METHOD0(GetConnectTimeMicros, base::TimeDelta());
MOCK_CONST_METHOD0(WasNpnNegotiated, bool());
MOCK_CONST_METHOD0(GetNegotiatedProtocol, net::NextProto());
MOCK_METHOD1(GetSSLInfo, bool(net::SSLInfo*));
MOCK_CONST_METHOD1(GetConnectionAttempts, void(net::ConnectionAttempts*));
MOCK_METHOD0(ClearConnectionAttempts, void());
MOCK_METHOD1(AddConnectionAttempts, void(const net::ConnectionAttempts&));
MOCK_CONST_METHOD0(GetTotalReceivedBytes, int64_t());
};
class MockTransport : public BlimpTransport {
public:
MockTransport();
~MockTransport() override;
MOCK_METHOD1(Connect, void(const net::CompletionCallback& callback));
MOCK_METHOD0(TakeConnectionPtr, BlimpConnection*());
scoped_ptr<BlimpConnection> TakeConnection() override;
const std::string GetName() const override;
};
class MockConnectionHandler : public ConnectionHandler {
public:
MockConnectionHandler();
~MockConnectionHandler() override;
MOCK_METHOD1(HandleConnectionPtr, void(BlimpConnection* connection));
void HandleConnection(scoped_ptr<BlimpConnection> connection) override;
};
class MockPacketReader : public PacketReader {
public:
MockPacketReader();
~MockPacketReader() override;
MOCK_METHOD2(ReadPacket,
int(const scoped_refptr<net::GrowableIOBuffer>&,
const net::CompletionCallback&));
};
class MockPacketWriter : public PacketWriter {
public:
MockPacketWriter();
~MockPacketWriter() override;
MOCK_METHOD2(WritePacket,
int(scoped_refptr<net::DrainableIOBuffer>,
const net::CompletionCallback&));
};
class MockConnectionErrorObserver : public ConnectionErrorObserver {
public:
MockConnectionErrorObserver();
~MockConnectionErrorObserver() override;
MOCK_METHOD1(OnConnectionError, void(int error));
};
class MockBlimpMessageProcessor : public BlimpMessageProcessor {
public:
MockBlimpMessageProcessor();
~MockBlimpMessageProcessor() override;
// Adapts calls from ProcessMessage to MockableProcessMessage by
// unboxing the |message| scoped_ptr for GMock compatibility.
void ProcessMessage(scoped_ptr<BlimpMessage> message,
const net::CompletionCallback& callback) override;
MOCK_METHOD2(MockableProcessMessage,
void(const BlimpMessage& message,
const net::CompletionCallback& callback));
};
} // namespace blimp
#endif // BLIMP_NET_TEST_COMMON_H_
|
