Clone
ixen
committed
on 22 Oct 20
Re-introducing upgrade to InnoSetup 6 (CH-351)
/Tests/TOverlappedDataBufferTests.cpp (+63 -23)
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 }