| |
1 |
1 |
#include "stdafx.h" |
| |
2 |
2 |
#include "gtest/gtest.h" |
| |
3 |
3 |
#include "gmock/gmock.h" |
| |
4 |
4 |
#include "../TOverlappedDataBuffer.h" |
| |
5 |
5 |
#include "../TCoreException.h" |
| |
6 |
6 |
#include "../TOverlappedDataBufferQueue.h" |
| |
7 |
7 |
|
| |
8 |
8 |
using namespace chcore; |
| |
9 |
9 |
|
| |
10 |
10 |
TEST(TOverlappedDataBufferTests, Constructor_InvalidInput) |
| |
11 |
11 |
{ |
| |
12 |
12 |
EXPECT_THROW(TOverlappedDataBuffer(0, nullptr), TCoreException); |
| |
13 |
13 |
} |
| |
14 |
14 |
|
| |
15 |
15 |
TEST(TOverlappedDataBufferTests, Constructor_SanityTest) |
| |
16 |
16 |
{ |
| |
17 |
|
TOverlappedDataBufferQueue queue; |
| |
|
17 |
logger::TLogFileDataPtr spLogData(std::make_shared<logger::TLogFileData>()); |
| |
|
18 |
|
| |
|
19 |
TOverlappedDataBufferQueue queue(spLogData); |
| |
18 |
20 |
TOverlappedDataBuffer buffer(32768, &queue); |
| |
19 |
21 |
|
| |
20 |
22 |
EXPECT_EQ(0, buffer.GetBufferOrder()); |
| |
21 |
23 |
EXPECT_NE(nullptr, buffer.GetBufferPtr()); |
| |
22 |
24 |
EXPECT_EQ(32768, buffer.GetBufferSize()); |
| |
23 |
25 |
EXPECT_EQ(0, buffer.GetBytesTransferred()); |
| |
24 |
26 |
EXPECT_EQ(0, buffer.GetErrorCode()); |
| |
25 |
27 |
EXPECT_EQ(0, buffer.GetFilePosition()); |
| |
26 |
28 |
EXPECT_EQ(0, buffer.GetRealDataSize()); |
| |
27 |
29 |
EXPECT_EQ(0, buffer.GetRequestedDataSize()); |
| |
28 |
30 |
EXPECT_EQ(0, buffer.GetStatusCode()); |
| |
29 |
31 |
EXPECT_FALSE(buffer.IsLastPart()); |
| |
30 |
32 |
} |
| |
31 |
33 |
|
| |
32 |
34 |
TEST(TOverlappedDataBufferTests, ReinitializeBuffer_ReduceSize) |
| |
33 |
35 |
{ |
| |
34 |
|
TOverlappedDataBufferQueue queue; |
| |
|
36 |
logger::TLogFileDataPtr spLogData(std::make_shared<logger::TLogFileData>()); |
| |
|
37 |
|
| |
|
38 |
TOverlappedDataBufferQueue queue(spLogData); |
| |
35 |
39 |
TOverlappedDataBuffer buffer(32768, &queue); |
| |
36 |
40 |
|
| |
37 |
41 |
buffer.ReinitializeBuffer(16384); |
| |
38 |
42 |
|
| |
39 |
43 |
EXPECT_NE(nullptr, buffer.GetBufferPtr()); |
| |
40 |
44 |
EXPECT_EQ(16384, buffer.GetBufferSize()); |
| |
41 |
45 |
} |
| |
42 |
46 |
|
| |
43 |
47 |
TEST(TOverlappedDataBufferTests, ReinitializeBuffer_IncreaseSize) |
| |
44 |
48 |
{ |
| |
45 |
|
TOverlappedDataBufferQueue queue; |
| |
|
49 |
logger::TLogFileDataPtr spLogData(std::make_shared<logger::TLogFileData>()); |
| |
|
50 |
|
| |
|
51 |
TOverlappedDataBufferQueue queue(spLogData); |
| |
46 |
52 |
TOverlappedDataBuffer buffer(16384, &queue); |
| |
47 |
53 |
|
| |
48 |
54 |
buffer.ReinitializeBuffer(32768); |
| |
49 |
55 |
|
| |
50 |
56 |
EXPECT_NE(nullptr, buffer.GetBufferPtr()); |
| |
51 |
57 |
EXPECT_EQ(32768, buffer.GetBufferSize()); |
| |
52 |
58 |
} |
| |
53 |
59 |
|
| |
54 |
60 |
TEST(TOverlappedDataBufferTests, SetRequestedDataSize_GetRequestedDataSize) |
| |
55 |
61 |
{ |
| |
56 |
|
TOverlappedDataBufferQueue queue; |
| |
|
62 |
logger::TLogFileDataPtr spLogData(std::make_shared<logger::TLogFileData>()); |
| |
|
63 |
|
| |
|
64 |
TOverlappedDataBufferQueue queue(spLogData); |
| |
57 |
65 |
TOverlappedDataBuffer buffer(16384, &queue); |
| |
58 |
66 |
|
| |
59 |
67 |
buffer.SetRequestedDataSize(123); |
| |
60 |
68 |
|
| |
61 |
69 |
EXPECT_EQ(123, buffer.GetRequestedDataSize()); |
| |
62 |
70 |
} |
| |
63 |
71 |
|
| |
64 |
72 |
TEST(TOverlappedDataBufferTests, SetRealDataSize_GetRealDataSize) |
| |
65 |
73 |
{ |
| |
66 |
|
TOverlappedDataBufferQueue queue; |
| |
|
74 |
logger::TLogFileDataPtr spLogData(std::make_shared<logger::TLogFileData>()); |
| |
|
75 |
|
| |
|
76 |
TOverlappedDataBufferQueue queue(spLogData); |
| |
67 |
77 |
TOverlappedDataBuffer buffer(16384, &queue); |
| |
68 |
78 |
|
| |
69 |
79 |
buffer.SetRealDataSize(123); |
| |
70 |
80 |
|
| |
71 |
81 |
EXPECT_EQ(123, buffer.GetRealDataSize()); |
| |
72 |
82 |
} |
| |
73 |
83 |
|
| |
74 |
84 |
TEST(TOverlappedDataBufferTests, SetLastPart_IsLastPart) |
| |
75 |
85 |
{ |
| |
76 |
|
TOverlappedDataBufferQueue queue; |
| |
|
86 |
logger::TLogFileDataPtr spLogData(std::make_shared<logger::TLogFileData>()); |
| |
|
87 |
|
| |
|
88 |
TOverlappedDataBufferQueue queue(spLogData); |
| |
77 |
89 |
TOverlappedDataBuffer buffer(16384, &queue); |
| |
78 |
90 |
|
| |
79 |
91 |
buffer.SetLastPart(true); |
| |
80 |
92 |
|
| |
81 |
93 |
EXPECT_TRUE(buffer.IsLastPart()); |
| |
82 |
94 |
} |
| |
83 |
95 |
|
| |
84 |
96 |
TEST(TOverlappedDataBufferTests, SetBufferOrder_GetBufferOrder) |
| |
85 |
97 |
{ |
| |
86 |
|
TOverlappedDataBufferQueue queue; |
| |
|
98 |
logger::TLogFileDataPtr spLogData(std::make_shared<logger::TLogFileData>()); |
| |
|
99 |
|
| |
|
100 |
TOverlappedDataBufferQueue queue(spLogData); |
| |
87 |
101 |
TOverlappedDataBuffer buffer(16384, &queue); |
| |
88 |
102 |
|
| |
89 |
103 |
buffer.SetBufferOrder(123); |
| |
90 |
104 |
|
| |
91 |
105 |
EXPECT_EQ(123, buffer.GetBufferOrder()); |
| |
92 |
106 |
} |
| |
93 |
107 |
|
| |
94 |
108 |
TEST(TOverlappedDataBufferTests, SetErrorCode_GetErrorCode) |
| |
95 |
109 |
{ |
| |
96 |
|
TOverlappedDataBufferQueue queue; |
| |
|
110 |
logger::TLogFileDataPtr spLogData(std::make_shared<logger::TLogFileData>()); |
| |
|
111 |
|
| |
|
112 |
TOverlappedDataBufferQueue queue(spLogData); |
| |
97 |
113 |
TOverlappedDataBuffer buffer(16384, &queue); |
| |
98 |
114 |
|
| |
99 |
115 |
buffer.SetErrorCode(123); |
| |
100 |
116 |
|
| |
101 |
117 |
EXPECT_EQ(123, buffer.GetErrorCode()); |
| |
102 |
118 |
} |
| |
103 |
119 |
|
| |
104 |
120 |
TEST(TOverlappedDataBufferTests, SetStatusCode_GetStatusCode) |
| |
105 |
121 |
{ |
| |
106 |
|
TOverlappedDataBufferQueue queue; |
| |
|
122 |
logger::TLogFileDataPtr spLogData(std::make_shared<logger::TLogFileData>()); |
| |
|
123 |
|
| |
|
124 |
TOverlappedDataBufferQueue queue(spLogData); |
| |
107 |
125 |
TOverlappedDataBuffer buffer(16384, &queue); |
| |
108 |
126 |
|
| |
109 |
127 |
buffer.SetStatusCode(123); |
| |
110 |
128 |
|
| |
111 |
129 |
EXPECT_EQ(123, buffer.GetStatusCode()); |
| |
112 |
130 |
} |
| |
113 |
131 |
|
| |
114 |
132 |
TEST(TOverlappedDataBufferTests, SetBytesTransferred_GetBytesTransferred) |
| |
115 |
133 |
{ |
| |
116 |
|
TOverlappedDataBufferQueue queue; |
| |
|
134 |
logger::TLogFileDataPtr spLogData(std::make_shared<logger::TLogFileData>()); |
| |
|
135 |
|
| |
|
136 |
TOverlappedDataBufferQueue queue(spLogData); |
| |
117 |
137 |
TOverlappedDataBuffer buffer(16384, &queue); |
| |
118 |
138 |
|
| |
119 |
139 |
buffer.SetBytesTransferred(123); |
| |
120 |
140 |
|
| |
121 |
141 |
EXPECT_EQ(123, buffer.GetBytesTransferred()); |
| |
122 |
142 |
} |
| |
123 |
143 |
|
| |
124 |
144 |
TEST(TOverlappedDataBufferTests, GetFilePosition_SetFilePosition) |
| |
125 |
145 |
{ |
| |
126 |
|
TOverlappedDataBufferQueue queue; |
| |
|
146 |
logger::TLogFileDataPtr spLogData(std::make_shared<logger::TLogFileData>()); |
| |
|
147 |
|
| |
|
148 |
TOverlappedDataBufferQueue queue(spLogData); |
| |
127 |
149 |
TOverlappedDataBuffer buffer(16384, &queue); |
| |
128 |
150 |
|
| |
129 |
151 |
buffer.SetFilePosition(123); |
| |
130 |
152 |
|
| |
131 |
153 |
EXPECT_EQ(123, buffer.GetFilePosition()); |
| |
132 |
154 |
} |
| |
133 |
155 |
|
| |
134 |
156 |
|
| |
135 |
157 |
TEST(TOverlappedDataBufferTests, InitForRead) |
| |
136 |
158 |
{ |
| |
137 |
|
TOverlappedDataBufferQueue queue; |
| |
|
159 |
logger::TLogFileDataPtr spLogData(std::make_shared<logger::TLogFileData>()); |
| |
|
160 |
|
| |
|
161 |
TOverlappedDataBufferQueue queue(spLogData); |
| |
138 |
162 |
TOverlappedDataBuffer buffer(16384, &queue); |
| |
139 |
163 |
|
| |
140 |
164 |
buffer.SetRequestedDataSize(123); |
| |
141 |
165 |
buffer.SetFilePosition(1); |
| |
142 |
166 |
buffer.SetRealDataSize(120); |
| |
143 |
167 |
buffer.SetLastPart(true); |
| |
144 |
168 |
buffer.SetErrorCode(54); |
| |
145 |
169 |
buffer.SetStatusCode(3); |
| |
146 |
170 |
buffer.SetBytesTransferred(12); |
| |
147 |
171 |
|
| |
148 |
172 |
buffer.InitForRead(320, 600); |
| |
149 |
173 |
|
| |
150 |
174 |
EXPECT_EQ(600, buffer.GetRequestedDataSize()); |
| |
151 |
175 |
EXPECT_EQ(320, buffer.GetFilePosition()); |
| |
152 |
176 |
EXPECT_EQ(0, buffer.GetRealDataSize()); |
| |
153 |
177 |
EXPECT_EQ(false, buffer.IsLastPart()); |
| |
154 |
178 |
EXPECT_EQ(0, buffer.GetErrorCode()); |
| |
155 |
179 |
EXPECT_EQ(0, buffer.GetStatusCode()); |
| |
156 |
180 |
EXPECT_EQ(0, buffer.GetBytesTransferred()); |
| |
157 |
181 |
} |
| |
158 |
182 |
|
| |
159 |
183 |
TEST(TOverlappedDataBufferTests, InitForWrite) |
| |
160 |
184 |
{ |
| |
161 |
|
TOverlappedDataBufferQueue queue; |
| |
|
185 |
logger::TLogFileDataPtr spLogData(std::make_shared<logger::TLogFileData>()); |
| |
|
186 |
|
| |
|
187 |
TOverlappedDataBufferQueue queue(spLogData); |
| |
162 |
188 |
TOverlappedDataBuffer buffer(16384, &queue); |
| |
163 |
189 |
|
| |
164 |
190 |
buffer.SetRequestedDataSize(123); |
| |
165 |
191 |
buffer.SetFilePosition(1); |
| |
166 |
192 |
buffer.SetRealDataSize(120); |
| |
167 |
193 |
buffer.SetLastPart(true); |
| |
168 |
194 |
buffer.SetErrorCode(54); |
| |
169 |
195 |
buffer.SetStatusCode(3); |
| |
170 |
196 |
buffer.SetBytesTransferred(12); |
| |
171 |
197 |
|
| |
172 |
198 |
buffer.InitForWrite(); |
| |
173 |
199 |
|
| |
174 |
200 |
EXPECT_EQ(0, buffer.GetErrorCode()); |
| |
175 |
201 |
EXPECT_EQ(0, buffer.GetStatusCode()); |
| |
176 |
202 |
EXPECT_EQ(0, buffer.GetBytesTransferred()); |
| |
177 |
203 |
} |
| |
178 |
204 |
|
| |
179 |
205 |
TEST(TOverlappedDataBufferTests, Reset) |
| |
180 |
206 |
{ |
| |
181 |
|
TOverlappedDataBufferQueue queue; |
| |
|
207 |
logger::TLogFileDataPtr spLogData(std::make_shared<logger::TLogFileData>()); |
| |
|
208 |
|
| |
|
209 |
TOverlappedDataBufferQueue queue(spLogData); |
| |
182 |
210 |
TOverlappedDataBuffer buffer(16384, &queue); |
| |
183 |
211 |
|
| |
184 |
212 |
buffer.SetRequestedDataSize(123); |
| |
185 |
213 |
buffer.SetFilePosition(1); |
| |
186 |
214 |
buffer.SetRealDataSize(120); |
| |
187 |
215 |
buffer.SetLastPart(true); |
| |
188 |
216 |
buffer.SetErrorCode(54); |
| |
189 |
217 |
buffer.SetStatusCode(3); |
| |
190 |
218 |
buffer.SetBytesTransferred(12); |
| |
191 |
219 |
|
| |
192 |
220 |
buffer.Reset(); |
| |
193 |
221 |
|
| |
194 |
222 |
EXPECT_EQ(0, buffer.GetRequestedDataSize()); |
| |
195 |
223 |
EXPECT_EQ(0, buffer.GetFilePosition()); |
| |
196 |
224 |
EXPECT_EQ(0, buffer.GetRealDataSize()); |
| |
197 |
225 |
EXPECT_EQ(false, buffer.IsLastPart()); |
| |
198 |
226 |
EXPECT_EQ(0, buffer.GetErrorCode()); |
| |
199 |
227 |
EXPECT_EQ(0, buffer.GetStatusCode()); |
| |
200 |
228 |
EXPECT_EQ(0, buffer.GetBytesTransferred()); |
| |
201 |
229 |
} |
| |
202 |
230 |
|
| |
203 |
231 |
|
| |
204 |
232 |
TEST(TOverlappedDataBufferTests, RequeueAsEmpty) |
| |
205 |
233 |
{ |
| |
206 |
|
TOverlappedDataBufferQueue queue; |
| |
|
234 |
logger::TLogFileDataPtr spLogData(std::make_shared<logger::TLogFileData>()); |
| |
|
235 |
|
| |
|
236 |
TOverlappedDataBufferQueue queue(spLogData); |
| |
207 |
237 |
TOverlappedDataBuffer buffer(16384, &queue); |
| |
208 |
238 |
|
| |
209 |
239 |
buffer.RequeueAsEmpty(); |
| |
210 |
240 |
|
| |
211 |
241 |
EXPECT_EQ(queue.GetEmptyBuffer(), &buffer); |
| |
212 |
242 |
} |
| |
213 |
243 |
|
| |
214 |
244 |
TEST(TOverlappedDataBufferTests, RequeueAsFull) |
| |
215 |
245 |
{ |
| |
216 |
|
TOverlappedDataBufferQueue queue; |
| |
|
246 |
logger::TLogFileDataPtr spLogData(std::make_shared<logger::TLogFileData>()); |
| |
|
247 |
|
| |
|
248 |
TOverlappedDataBufferQueue queue(spLogData); |
| |
217 |
249 |
TOverlappedDataBuffer buffer(16384, &queue); |
| |
218 |
250 |
|
| |
219 |
251 |
buffer.RequeueAsFull(); |
| |
220 |
252 |
|
| |
221 |
253 |
EXPECT_EQ(queue.GetFullBuffer(), &buffer); |
| |
222 |
254 |
} |
| |
223 |
255 |
|
| |
224 |
256 |
TEST(TOverlappedDataBufferTests, RequeueAsFinished) |
| |
225 |
257 |
{ |
| |
226 |
|
TOverlappedDataBufferQueue queue; |
| |
|
258 |
logger::TLogFileDataPtr spLogData(std::make_shared<logger::TLogFileData>()); |
| |
|
259 |
|
| |
|
260 |
TOverlappedDataBufferQueue queue(spLogData); |
| |
227 |
261 |
TOverlappedDataBuffer buffer(16384, &queue); |
| |
228 |
262 |
|
| |
229 |
263 |
buffer.RequeueAsFinished(); |
| |
230 |
264 |
|
| |
231 |
265 |
EXPECT_EQ(queue.GetFinishedBuffer(), &buffer); |
| |
232 |
266 |
} |
| |
233 |
267 |
|
| |
234 |
268 |
TEST(TOverlappedDataBufferTests, OverlappedReadCompleted_Success) |
| |
235 |
269 |
{ |
| |
236 |
|
TOverlappedDataBufferQueue queue; |
| |
|
270 |
logger::TLogFileDataPtr spLogData(std::make_shared<logger::TLogFileData>()); |
| |
|
271 |
|
| |
|
272 |
TOverlappedDataBufferQueue queue(spLogData); |
| |
237 |
273 |
TOverlappedDataBuffer buffer(16384, &queue); |
| |
238 |
274 |
|
| |
239 |
275 |
buffer.InitForRead(0, 1024); |
| |
240 |
276 |
buffer.SetStatusCode(0); |
| |
241 |
277 |
buffer.SetBytesTransferred(234); |
| |
242 |
278 |
|
| |
243 |
279 |
OverlappedReadCompleted(ERROR_SUCCESS, 234, &buffer); |
| |
244 |
280 |
|
| |
245 |
281 |
EXPECT_TRUE(buffer.IsLastPart()); |
| |
246 |
282 |
EXPECT_EQ(ERROR_SUCCESS, buffer.GetErrorCode()); |
| |
247 |
283 |
EXPECT_EQ(234, buffer.GetRealDataSize()); |
| |
248 |
284 |
|
| |
249 |
285 |
EXPECT_EQ(queue.GetFullBuffer(), &buffer); |
| |
250 |
286 |
} |
| |
251 |
287 |
|
| |
252 |
288 |
TEST(TOverlappedDataBufferTests, OverlappedReadCompleted_Failure) |
| |
253 |
289 |
{ |
| |
254 |
|
TOverlappedDataBufferQueue queue; |
| |
|
290 |
logger::TLogFileDataPtr spLogData(std::make_shared<logger::TLogFileData>()); |
| |
|
291 |
|
| |
|
292 |
TOverlappedDataBufferQueue queue(spLogData); |
| |
255 |
293 |
TOverlappedDataBuffer buffer(16384, &queue); |
| |
256 |
294 |
|
| |
257 |
295 |
buffer.InitForRead(0, 1024); |
| |
258 |
296 |
buffer.SetStatusCode(0); |
| |
259 |
297 |
buffer.SetBytesTransferred(0); |
| |
260 |
298 |
|
| |
261 |
299 |
OverlappedReadCompleted(ERROR_ACCESS_DENIED, 0, &buffer); |
| |
262 |
300 |
|
| |
263 |
301 |
EXPECT_FALSE(buffer.IsLastPart()); |
| |
264 |
302 |
EXPECT_EQ(ERROR_ACCESS_DENIED, buffer.GetErrorCode()); |
| |
265 |
303 |
EXPECT_EQ(0, buffer.GetRealDataSize()); |
| |
266 |
304 |
|
| |
267 |
305 |
EXPECT_EQ(queue.GetFullBuffer(), &buffer); |
| |
268 |
306 |
} |
| |
269 |
307 |
|
| |
270 |
308 |
TEST(TOverlappedDataBufferTests, OverlappedWriteCompleted_Success) |
| |
271 |
309 |
{ |
| |
272 |
|
TOverlappedDataBufferQueue queue; |
| |
|
310 |
logger::TLogFileDataPtr spLogData(std::make_shared<logger::TLogFileData>()); |
| |
|
311 |
|
| |
|
312 |
TOverlappedDataBufferQueue queue(spLogData); |
| |
273 |
313 |
TOverlappedDataBuffer buffer(16384, &queue); |
| |
274 |
314 |
|
| |
275 |
315 |
buffer.InitForRead(0, 1024); |
| |
276 |
316 |
buffer.SetStatusCode(0); |
| |
277 |
317 |
buffer.SetBytesTransferred(234); |
| |
278 |
318 |
buffer.SetLastPart(true); |
| |
279 |
319 |
buffer.SetRealDataSize(234); |
| |
280 |
320 |
|
| |
281 |
321 |
OverlappedWriteCompleted(ERROR_SUCCESS, 234, &buffer); |
| |
282 |
322 |
|
| |
283 |
323 |
EXPECT_EQ(ERROR_SUCCESS, buffer.GetErrorCode()); |
| |
284 |
324 |
EXPECT_EQ(queue.GetFinishedBuffer(), &buffer); |
| |
285 |
325 |
} |