OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "storage/browser/blob/blob_async_transport_strategy.h" | |
6 | |
7 #include <string> | |
8 | |
9 #include "base/logging.h" | |
10 #include "testing/gtest/include/gtest/gtest.h" | |
11 | |
12 namespace storage { | |
13 namespace { | |
14 | |
15 const char kNewUUID[] = "newUUID"; | |
16 const base::FilePath kFuturePopulatingFilePath = base::FilePath::FromUTF8Unsafe( | |
17 std::string(BlobDataBuilder::kAppendFutureFileTemporaryFileName)); | |
18 const char kFakeBlobUUID[] = "fakeBlob"; | |
19 | |
20 void AddMemoryItem(size_t length, std::vector<DataElement>* out) { | |
21 DataElement bytes; | |
22 bytes.SetToBytesDescription(length); | |
23 out->push_back(bytes); | |
24 } | |
25 | |
26 void AddShortcutMemoryItem(size_t length, std::vector<DataElement>* out) { | |
27 DataElement bytes; | |
28 bytes.SetToAllocatedBytes(length); | |
29 for (size_t i = 0; i < length; i++) { | |
30 bytes.mutable_bytes()[i] = static_cast<char>(i); | |
31 } | |
32 out->push_back(bytes); | |
33 } | |
34 | |
35 void AddBlobItem(std::vector<DataElement>* out) { | |
36 DataElement blob; | |
37 blob.SetToBlob(kFakeBlobUUID); | |
38 out->push_back(blob); | |
39 } | |
40 | |
41 TEST(BlobAsyncTransportStrategyTest, TestNoMemoryItems) { | |
42 BlobAsyncTransportStrategy strategy; | |
43 std::vector<DataElement> infos; | |
44 | |
45 // Here we test our size > max_blob_in_memory_size (300), | |
46 // and we save to one file. (size < max_file_size) | |
kinuko
2015/11/26 04:58:17
Um, is this comment right? Also we no longer seem
dmurph
2015/11/30 21:33:28
Whoops, yes, thanks.
| |
47 AddBlobItem(&infos); | |
48 AddBlobItem(&infos); | |
49 AddBlobItem(&infos); | |
50 strategy.Initialize(100, // max_ipc_memory_size | |
51 200, // max_shared_memory_size | |
52 400, // max_file_size | |
53 5000, // disk_space_left | |
54 100, // memory_available | |
55 kNewUUID, infos); | |
56 | |
57 EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_NONE, strategy.error()); | |
58 | |
59 EXPECT_EQ(0u, strategy.file_handle_sizes().size()); | |
60 EXPECT_EQ(0u, strategy.requests().size()); | |
61 | |
62 BlobDataBuilder builder(kNewUUID); | |
63 builder.AppendBlob(kFakeBlobUUID); | |
64 builder.AppendBlob(kFakeBlobUUID); | |
65 builder.AppendBlob(kFakeBlobUUID); | |
66 EXPECT_EQ(builder, *strategy.blob_builder()); | |
67 } | |
68 | |
69 TEST(BlobAsyncTransportStrategyTest, TestLargeBlockToFile) { | |
70 BlobAsyncTransportStrategy strategy; | |
71 std::vector<DataElement> infos; | |
72 | |
73 // Here we test our size > max_blob_in_memory_size (300), | |
74 // and we save to one file. (size < max_file_size) | |
kinuko
2015/11/26 04:58:17
ditto, here and below. comment looks stale to me?
dmurph
2015/11/30 21:33:28
It was a little stale, thanks.
| |
75 AddMemoryItem(305, &infos); | |
76 strategy.Initialize(100, // max_ipc_memory_size | |
77 200, // max_shared_memory_size | |
78 400, // max_file_size | |
79 5000, // disk_space_left | |
80 100, // memory_available | |
81 kNewUUID, infos); | |
82 | |
83 EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_NONE, strategy.error()); | |
84 | |
85 EXPECT_EQ(1u, strategy.file_handle_sizes().size()); | |
86 EXPECT_EQ(305ul, strategy.file_handle_sizes().at(0)); | |
87 EXPECT_EQ(1u, strategy.requests().size()); | |
88 | |
89 auto& memory_item_request = strategy.requests().at(0); | |
90 EXPECT_EQ(0u, memory_item_request.browser_item_index); | |
91 EXPECT_EQ(0u, memory_item_request.browser_item_offset); | |
92 EXPECT_EQ( | |
93 BlobItemBytesRequest::CreateFileRequest(0u, 0u, 0ull, 305ull, 0u, 0ull), | |
94 memory_item_request.message); | |
95 | |
96 BlobDataBuilder builder(kNewUUID); | |
97 builder.AppendFile(kFuturePopulatingFilePath, 0, 305, | |
98 base::Time::FromDoubleT(0)); | |
99 EXPECT_EQ(builder, *strategy.blob_builder()); | |
100 } | |
101 | |
102 TEST(BlobAsyncTransportStrategyTest, TestLargeBlockToFiles) { | |
103 BlobAsyncTransportStrategy strategy; | |
104 std::vector<DataElement> infos; | |
105 | |
106 // Here we test our size > max_blob_in_memory_size (300), | |
107 // and we save 3 files. (size > max_file_size) | |
108 AddMemoryItem(1000, &infos); | |
109 strategy.Initialize(100, // max_ipc_memory_size | |
110 200, // max_shared_memory_size | |
111 400, // max_file_size | |
112 5000, // disk_space_left | |
113 100, // memory_available | |
114 kNewUUID, infos); | |
115 EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_NONE, strategy.error()); | |
116 | |
117 EXPECT_EQ(3u, strategy.file_handle_sizes().size()); | |
118 EXPECT_EQ(400ul, strategy.file_handle_sizes().at(0)); | |
119 EXPECT_EQ(400ul, strategy.file_handle_sizes().at(1)); | |
120 EXPECT_EQ(200ul, strategy.file_handle_sizes().at(2)); | |
121 EXPECT_EQ(3u, strategy.requests().size()); | |
122 | |
123 auto memory_item_request = strategy.requests().at(0); | |
124 EXPECT_EQ(0u, memory_item_request.browser_item_index); | |
125 EXPECT_EQ(0u, memory_item_request.browser_item_offset); | |
126 EXPECT_EQ( | |
127 BlobItemBytesRequest::CreateFileRequest(0u, 0u, 0ull, 400ull, 0u, 0ull), | |
128 memory_item_request.message); | |
129 | |
130 memory_item_request = strategy.requests().at(1); | |
131 EXPECT_EQ(1u, memory_item_request.browser_item_index); | |
132 EXPECT_EQ(0u, memory_item_request.browser_item_offset); | |
133 EXPECT_EQ( | |
134 BlobItemBytesRequest::CreateFileRequest(1u, 0u, 400ull, 400ull, 1u, 0ull), | |
135 memory_item_request.message); | |
136 | |
137 memory_item_request = strategy.requests().at(2); | |
138 EXPECT_EQ(2u, memory_item_request.browser_item_index); | |
139 EXPECT_EQ(0u, memory_item_request.browser_item_offset); | |
140 EXPECT_EQ( | |
141 BlobItemBytesRequest::CreateFileRequest(2u, 0u, 800ull, 200ull, 2u, 0ull), | |
142 memory_item_request.message); | |
143 | |
144 BlobDataBuilder builder(kNewUUID); | |
145 builder.AppendFile(kFuturePopulatingFilePath, 0, 400, | |
146 base::Time::FromDoubleT(0)); | |
147 builder.AppendFile(kFuturePopulatingFilePath, 0, 400, | |
148 base::Time::FromDoubleT(0)); | |
149 builder.AppendFile(kFuturePopulatingFilePath, 0, 200, | |
150 base::Time::FromDoubleT(0)); | |
151 EXPECT_EQ(builder, *strategy.blob_builder()); | |
152 } | |
153 | |
154 TEST(BlobAsyncTransportStrategyTest, TestLargeBlocksConsolidatingInFiles) { | |
155 BlobAsyncTransportStrategy strategy; | |
156 std::vector<DataElement> infos; | |
157 | |
158 // We should have 3 storage items for the memory, two files, 400 each. | |
159 // We end up with storage items: | |
160 // 1: File A, 300MB | |
161 // 2: Blob | |
162 // 3: File A, 100MB (300MB offset) | |
163 // 4: File B, 400MB | |
164 AddMemoryItem(300, &infos); | |
165 AddBlobItem(&infos); | |
166 AddMemoryItem(500, &infos); | |
167 | |
168 strategy.Initialize(100, // max_ipc_memory_size | |
169 200, // max_shared_memory_size | |
170 400, // max_file_size | |
171 5000, // disk_space_left | |
172 100, // memory_available | |
173 kNewUUID, infos); | |
174 EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_NONE, strategy.error()); | |
175 | |
176 EXPECT_EQ(2u, strategy.file_handle_sizes().size()); | |
177 EXPECT_EQ(400ul, strategy.file_handle_sizes().at(0)); | |
178 EXPECT_EQ(400ul, strategy.file_handle_sizes().at(1)); | |
179 EXPECT_EQ(3u, strategy.requests().size()); | |
180 | |
181 auto memory_item_request = strategy.requests().at(0); | |
182 EXPECT_EQ(0u, memory_item_request.browser_item_index); | |
183 EXPECT_EQ(0u, memory_item_request.browser_item_offset); | |
184 EXPECT_EQ( | |
185 BlobItemBytesRequest::CreateFileRequest(0u, 0u, 0ull, 300ull, 0u, 0ull), | |
186 memory_item_request.message); | |
187 | |
188 memory_item_request = strategy.requests().at(1); | |
189 EXPECT_EQ(2u, memory_item_request.browser_item_index); | |
190 EXPECT_EQ(0u, memory_item_request.browser_item_offset); | |
191 EXPECT_EQ( | |
192 BlobItemBytesRequest::CreateFileRequest(1u, 2u, 0ull, 100ull, 0u, 300ull), | |
193 memory_item_request.message); | |
194 | |
195 memory_item_request = strategy.requests().at(2); | |
196 EXPECT_EQ(3u, memory_item_request.browser_item_index); | |
197 EXPECT_EQ(0u, memory_item_request.browser_item_offset); | |
198 EXPECT_EQ( | |
199 BlobItemBytesRequest::CreateFileRequest(2u, 2u, 100ull, 400ull, 1u, 0ull), | |
200 memory_item_request.message); | |
201 } | |
202 | |
203 TEST(BlobAsyncTransportStrategyTest, TestSharedMemorySegmentation) { | |
204 BlobAsyncTransportStrategy strategy; | |
205 std::vector<DataElement> infos; | |
206 | |
207 // For transport we should have 3 shared memories, and then storage in 3 | |
208 // browser items. | |
209 // (size > max_shared_memory_size and size < max_blob_in_memory_size | |
210 AddMemoryItem(500, &infos); | |
211 strategy.Initialize(100, // max_ipc_memory_size | |
212 200, // max_shared_memory_size | |
213 300, // max_file_size | |
214 5000, // disk_space_left | |
215 500, // memory_available | |
216 kNewUUID, infos); | |
217 EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_NONE, strategy.error()); | |
218 | |
219 EXPECT_EQ(3u, strategy.shared_memory_handle_sizes().size()); | |
220 EXPECT_EQ(200u, strategy.shared_memory_handle_sizes().at(0)); | |
221 EXPECT_EQ(200u, strategy.shared_memory_handle_sizes().at(1)); | |
222 EXPECT_EQ(100u, strategy.shared_memory_handle_sizes().at(2)); | |
223 EXPECT_EQ(3u, strategy.requests().size()); | |
224 | |
225 auto memory_item_request = strategy.requests().at(0); | |
226 EXPECT_EQ(0u, memory_item_request.browser_item_index); | |
227 EXPECT_EQ(0u, memory_item_request.browser_item_offset); | |
228 EXPECT_EQ(BlobItemBytesRequest::CreateSharedMemoryRequest(0u, 0u, 0ull, | |
229 200ull, 0u, 0ull), | |
230 memory_item_request.message); | |
231 | |
232 memory_item_request = strategy.requests().at(1); | |
233 EXPECT_EQ(1u, memory_item_request.browser_item_index); | |
234 EXPECT_EQ(0u, memory_item_request.browser_item_offset); | |
235 EXPECT_EQ(BlobItemBytesRequest::CreateSharedMemoryRequest(1u, 0u, 200ull, | |
236 200ull, 1u, 0ull), | |
237 memory_item_request.message); | |
238 | |
239 memory_item_request = strategy.requests().at(2); | |
240 EXPECT_EQ(2u, memory_item_request.browser_item_index); | |
241 EXPECT_EQ(0u, memory_item_request.browser_item_offset); | |
242 EXPECT_EQ(BlobItemBytesRequest::CreateSharedMemoryRequest(2u, 0u, 400ull, | |
243 100ull, 2u, 0ull), | |
244 memory_item_request.message); | |
245 | |
246 BlobDataBuilder builder(kNewUUID); | |
247 builder.AppendFutureData(200); | |
248 builder.AppendFutureData(200); | |
249 builder.AppendFutureData(100); | |
250 | |
251 EXPECT_EQ(builder, *strategy.blob_builder()); | |
252 } | |
253 | |
254 TEST(BlobAsyncTransportStrategyTest, TestSharedMemorySegmentationAndStorage) { | |
255 BlobAsyncTransportStrategy strategy; | |
256 std::vector<DataElement> infos; | |
257 | |
258 // For transport, we should have 2 shared memories, where the first one | |
259 // have half 0 and half 3, and then the last one has half 3. | |
260 // | |
261 // For storage, we should have 3 browser items that match the pre-transport | |
262 // version: | |
263 // 1: Bytes 100MB | |
264 // 2: Blob | |
265 // 3: Bytes 200MB | |
266 AddShortcutMemoryItem(100, &infos); // should have no behavior change | |
267 AddBlobItem(&infos); | |
268 AddMemoryItem(200, &infos); | |
269 | |
270 strategy.Initialize(100, // max_ipc_memory_size | |
271 200, // max_shared_memory_size | |
272 300, // max_file_size | |
273 5000, // disk_space_left | |
274 300, // memory_available | |
275 kNewUUID, infos); | |
276 EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_NONE, strategy.error()); | |
277 | |
278 EXPECT_EQ(2u, strategy.shared_memory_handle_sizes().size()); | |
279 EXPECT_EQ(200u, strategy.shared_memory_handle_sizes().at(0)); | |
280 EXPECT_EQ(100u, strategy.shared_memory_handle_sizes().at(1)); | |
281 EXPECT_EQ(3u, strategy.requests().size()); | |
282 | |
283 auto memory_item_request = strategy.requests().at(0); | |
284 EXPECT_EQ(0u, memory_item_request.browser_item_index); | |
285 EXPECT_EQ(0u, memory_item_request.browser_item_offset); | |
286 EXPECT_EQ(BlobItemBytesRequest::CreateSharedMemoryRequest(0u, 0u, 0ull, | |
287 100ull, 0u, 0ull), | |
288 memory_item_request.message); | |
289 | |
290 memory_item_request = strategy.requests().at(1); | |
291 EXPECT_EQ(2u, memory_item_request.browser_item_index); | |
292 EXPECT_EQ(0u, memory_item_request.browser_item_offset); | |
293 EXPECT_EQ(BlobItemBytesRequest::CreateSharedMemoryRequest(1u, 2u, 0ull, | |
294 100ull, 0u, 100ull), | |
295 memory_item_request.message); | |
296 | |
297 memory_item_request = strategy.requests().at(2); | |
298 EXPECT_EQ(2u, memory_item_request.browser_item_index); | |
299 EXPECT_EQ(100u, memory_item_request.browser_item_offset); | |
300 EXPECT_EQ(BlobItemBytesRequest::CreateSharedMemoryRequest(2u, 2u, 100ull, | |
301 100ull, 1u, 0ull), | |
302 memory_item_request.message); | |
303 | |
304 BlobDataBuilder builder(kNewUUID); | |
305 builder.AppendFutureData(100); | |
306 builder.AppendBlob(kFakeBlobUUID); | |
307 builder.AppendFutureData(200); | |
308 | |
309 EXPECT_EQ(builder, *strategy.blob_builder()); | |
310 } | |
311 | |
312 TEST(BlobAsyncTransportStrategyTest, TestTooLarge) { | |
313 BlobAsyncTransportStrategy strategy; | |
314 std::vector<DataElement> infos; | |
315 | |
316 // Our item is too large for disk, so error out. | |
317 AddMemoryItem(5001, &infos); | |
318 | |
319 strategy.Initialize(100, // max_ipc_memory_size | |
320 200, // max_shared_memory_size | |
321 400, // max_file_size | |
322 5000, // disk_space_left | |
323 100, // memory_left | |
324 kNewUUID, infos); | |
325 | |
326 EXPECT_EQ(0u, strategy.file_handle_sizes().size()); | |
327 EXPECT_EQ(0u, strategy.shared_memory_handle_sizes().size()); | |
328 EXPECT_EQ(0u, strategy.requests().size()); | |
329 EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_TOO_LARGE, strategy.error()); | |
330 } | |
331 | |
332 TEST(BlobAsyncTransportStrategyTest, TestNoDisk) { | |
333 BlobAsyncTransportStrategy strategy; | |
334 std::vector<DataElement> infos; | |
335 | |
336 // Our item is too large for memory, and we are in no_disk mode (incognito) | |
337 AddMemoryItem(301, &infos); | |
338 | |
339 strategy.Initialize(100, // max_ipc_memory_size | |
340 200, // max_shared_memory_size | |
341 400, // max_file_size | |
342 0, // disk_space_left | |
343 300, // memory_available | |
344 kNewUUID, infos); | |
345 | |
346 EXPECT_EQ(0u, strategy.file_handle_sizes().size()); | |
347 EXPECT_EQ(0u, strategy.shared_memory_handle_sizes().size()); | |
348 EXPECT_EQ(0u, strategy.requests().size()); | |
349 EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_TOO_LARGE, strategy.error()); | |
350 } | |
351 | |
352 TEST(BlobAsyncTransportStrategyTest, TestNoDiskFits) { | |
353 BlobAsyncTransportStrategy strategy; | |
354 std::vector<DataElement> infos; | |
355 | |
356 // Test that we ignore the max_blob_in_memory_size param when we're in | |
357 // no-disk mode, as we can never hit disk anyways. | |
358 AddMemoryItem(301, &infos); | |
359 | |
360 strategy.Initialize(100, // max_ipc_memory_size | |
361 200, // max_shared_memory_size | |
362 400, // max_file_size | |
363 0, // disk_space_left | |
364 301, // memory_left | |
365 kNewUUID, infos); | |
366 | |
367 EXPECT_EQ(0u, strategy.file_handle_sizes().size()); | |
368 EXPECT_EQ(2u, strategy.shared_memory_handle_sizes().size()); | |
369 EXPECT_EQ(2u, strategy.requests().size()); | |
370 EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_NONE, strategy.error()); | |
371 } | |
372 | |
373 TEST(BlobAsyncTransportStrategyTest, TestSimpleIPC) { | |
374 // Test simple IPC strategy, where size < max_ipc_memory_size and we have | |
375 // just one item. | |
376 std::vector<DataElement> infos; | |
377 BlobAsyncTransportStrategy strategy; | |
378 AddMemoryItem(10, &infos); | |
379 AddBlobItem(&infos); | |
380 | |
381 strategy.Initialize(100, // max_ipc_memory_size | |
382 200, // max_shared_memory_size | |
383 400, // max_file_size | |
384 5000, // disk_space_left | |
385 100, // memory_left | |
386 kNewUUID, infos); | |
387 EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_NONE, strategy.error()); | |
388 | |
389 ASSERT_EQ(1u, strategy.requests().size()); | |
390 | |
391 auto memory_item_request = strategy.requests().at(0); | |
392 EXPECT_EQ(0u, memory_item_request.browser_item_index); | |
393 EXPECT_EQ(0u, memory_item_request.browser_item_offset); | |
394 EXPECT_EQ(BlobItemBytesRequest::CreateIPCRequest(0u, 0u, 0ull, 10ull), | |
395 memory_item_request.message); | |
396 } | |
397 | |
398 TEST(BlobAsyncTransportStrategyTest, TestMultipleIPC) { | |
399 // Same as above, but with 2 items and a blob in-between. | |
400 std::vector<DataElement> infos; | |
401 BlobAsyncTransportStrategy strategy; | |
402 infos.clear(); | |
403 AddShortcutMemoryItem(10, &infos); // should have no behavior change | |
404 AddBlobItem(&infos); | |
405 AddMemoryItem(80, &infos); | |
406 | |
407 strategy.Initialize(100, // max_ipc_memory_size | |
408 200, // max_shared_memory_size | |
409 400, // max_file_size | |
410 5000, // disk_space_left | |
411 100, // memory_left | |
412 kNewUUID, infos); | |
413 EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_NONE, strategy.error()); | |
414 | |
415 ASSERT_EQ(2u, strategy.requests().size()); | |
416 | |
417 auto memory_item_request = strategy.requests().at(0); | |
418 EXPECT_EQ(0u, memory_item_request.browser_item_index); | |
419 EXPECT_EQ(0u, memory_item_request.browser_item_offset); | |
420 EXPECT_EQ(BlobItemBytesRequest::CreateIPCRequest(0u, 0u, 0ull, 10ull), | |
421 memory_item_request.message); | |
422 | |
423 memory_item_request = strategy.requests().at(1); | |
424 EXPECT_EQ(2u, memory_item_request.browser_item_index); | |
425 EXPECT_EQ(0u, memory_item_request.browser_item_offset); | |
426 EXPECT_EQ(BlobItemBytesRequest::CreateIPCRequest(1u, 2u, 0ull, 80ull), | |
427 memory_item_request.message); | |
428 | |
429 // We still populate future data, as the strategy assumes we will be | |
430 // requesting the data. | |
431 BlobDataBuilder builder(kNewUUID); | |
432 builder.AppendFutureData(10); | |
433 builder.AppendBlob(kFakeBlobUUID); | |
434 builder.AppendFutureData(80); | |
435 | |
436 EXPECT_EQ(builder, *strategy.blob_builder()); | |
437 } | |
438 | |
439 TEST(BlobAsyncTransportStrategyTest, Shortcut) { | |
440 std::vector<DataElement> infos; | |
441 AddMemoryItem(100, &infos); | |
442 AddBlobItem(&infos); | |
443 EXPECT_FALSE(BlobAsyncTransportStrategy::ShouldBeShortcut(infos, 200)); | |
444 | |
445 infos.clear(); | |
446 AddShortcutMemoryItem(100, &infos); | |
447 AddBlobItem(&infos); | |
448 EXPECT_TRUE(BlobAsyncTransportStrategy::ShouldBeShortcut(infos, 200)); | |
449 | |
450 infos.clear(); | |
451 AddShortcutMemoryItem(100, &infos); | |
452 EXPECT_FALSE(BlobAsyncTransportStrategy::ShouldBeShortcut(infos, 99)); | |
453 } | |
454 | |
455 TEST(BlobAsyncTransportStrategyTest, TestInvalidParams) { | |
456 std::vector<DataElement> infos; | |
457 { | |
458 // Test uint64_t overflow. | |
459 BlobAsyncTransportStrategy strategy; | |
460 uint64_t iters = std::numeric_limits<uint64_t>::max() / | |
461 std::numeric_limits<size_t>::max(); | |
462 for (uint64_t i = 0; i <= iters; i++) { | |
463 AddMemoryItem(std::numeric_limits<size_t>::max(), &infos); | |
464 } | |
465 | |
466 strategy.Initialize(100, // max_ipc_memory_size | |
467 200, // max_shared_memory_size | |
468 400, // max_file_size | |
469 5000, // disk_space_left | |
470 100, // memory_left | |
471 kNewUUID, infos); | |
472 EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_INVALID_PARAMS, | |
473 strategy.error()); | |
474 } | |
475 { | |
476 // Test size_t overflow. | |
477 infos.clear(); | |
478 BlobAsyncTransportStrategy strategy; | |
479 AddMemoryItem(std::numeric_limits<size_t>::max(), &infos); | |
480 AddMemoryItem(1, &infos); | |
481 | |
482 strategy.Initialize(100, // max_ipc_memory_size | |
483 200, // max_shared_memory_size | |
484 400, // max_file_size | |
485 5000, // disk_space_left | |
486 100, // memory_left | |
487 kNewUUID, infos); | |
488 EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_INVALID_PARAMS, | |
489 strategy.error()); | |
490 } | |
491 } | |
492 | |
493 } // namespace | |
494 } // namespace storage | |
OLD | NEW |