OLD | NEW |
1 // Copyright (c) 2006-2009 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2006-2010 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/basictypes.h" | 5 #include "base/basictypes.h" |
6 #include "base/platform_thread.h" | 6 #include "base/platform_thread.h" |
7 #include "base/timer.h" | 7 #include "base/timer.h" |
8 #include "base/string_util.h" | 8 #include "base/string_util.h" |
9 #include "net/base/io_buffer.h" | 9 #include "net/base/io_buffer.h" |
10 #include "net/base/net_errors.h" | 10 #include "net/base/net_errors.h" |
11 #include "net/base/test_completion_callback.h" | 11 #include "net/base/test_completion_callback.h" |
(...skipping 15 matching lines...) Expand all Loading... |
27 void InternalAsyncIO(); | 27 void InternalAsyncIO(); |
28 void ExternalSyncIO(); | 28 void ExternalSyncIO(); |
29 void ExternalAsyncIO(); | 29 void ExternalAsyncIO(); |
30 void StreamAccess(); | 30 void StreamAccess(); |
31 void GetKey(); | 31 void GetKey(); |
32 void GrowData(); | 32 void GrowData(); |
33 void TruncateData(); | 33 void TruncateData(); |
34 void ZeroLengthIO(); | 34 void ZeroLengthIO(); |
35 void ReuseEntry(int size); | 35 void ReuseEntry(int size); |
36 void InvalidData(); | 36 void InvalidData(); |
37 void DoomEntry(); | 37 void DoomNormalEntry(); |
38 void DoomedEntry(); | 38 void DoomedEntry(); |
39 void BasicSparseIO(bool async); | 39 void BasicSparseIO(bool async); |
40 void HugeSparseIO(bool async); | 40 void HugeSparseIO(bool async); |
41 void GetAvailableRange(); | 41 void GetAvailableRange(); |
42 void DoomSparseEntry(); | 42 void DoomSparseEntry(); |
43 void PartialSparseEntry(); | 43 void PartialSparseEntry(); |
44 }; | 44 }; |
45 | 45 |
46 void DiskCacheEntryTest::InternalSyncIO() { | 46 void DiskCacheEntryTest::InternalSyncIO() { |
47 disk_cache::Entry *entry1 = NULL; | 47 disk_cache::Entry *entry1 = NULL; |
48 ASSERT_TRUE(cache_->CreateEntry("the first key", &entry1)); | 48 ASSERT_EQ(net::OK, CreateEntry("the first key", &entry1)); |
49 ASSERT_TRUE(NULL != entry1); | 49 ASSERT_TRUE(NULL != entry1); |
50 | 50 |
51 const int kSize1 = 10; | 51 const int kSize1 = 10; |
52 scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1); | 52 scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1); |
53 CacheTestFillBuffer(buffer1->data(), kSize1, false); | 53 CacheTestFillBuffer(buffer1->data(), kSize1, false); |
54 EXPECT_EQ(0, entry1->ReadData(0, 0, buffer1, kSize1, NULL)); | 54 EXPECT_EQ(0, entry1->ReadData(0, 0, buffer1, kSize1, NULL)); |
55 base::strlcpy(buffer1->data(), "the data", kSize1); | 55 base::strlcpy(buffer1->data(), "the data", kSize1); |
56 EXPECT_EQ(10, entry1->WriteData(0, 0, buffer1, kSize1, NULL, false)); | 56 EXPECT_EQ(10, entry1->WriteData(0, 0, buffer1, kSize1, NULL, false)); |
57 memset(buffer1->data(), 0, kSize1); | 57 memset(buffer1->data(), 0, kSize1); |
58 EXPECT_EQ(10, entry1->ReadData(0, 0, buffer1, kSize1, NULL)); | 58 EXPECT_EQ(10, entry1->ReadData(0, 0, buffer1, kSize1, NULL)); |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
90 } | 90 } |
91 | 91 |
92 TEST_F(DiskCacheEntryTest, MemoryOnlyInternalSyncIO) { | 92 TEST_F(DiskCacheEntryTest, MemoryOnlyInternalSyncIO) { |
93 SetMemoryOnlyMode(); | 93 SetMemoryOnlyMode(); |
94 InitCache(); | 94 InitCache(); |
95 InternalSyncIO(); | 95 InternalSyncIO(); |
96 } | 96 } |
97 | 97 |
98 void DiskCacheEntryTest::InternalAsyncIO() { | 98 void DiskCacheEntryTest::InternalAsyncIO() { |
99 disk_cache::Entry *entry1 = NULL; | 99 disk_cache::Entry *entry1 = NULL; |
100 ASSERT_TRUE(cache_->CreateEntry("the first key", &entry1)); | 100 ASSERT_EQ(net::OK, CreateEntry("the first key", &entry1)); |
101 ASSERT_TRUE(NULL != entry1); | 101 ASSERT_TRUE(NULL != entry1); |
102 | 102 |
103 // Avoid using internal buffers for the test. We have to write something to | 103 // Avoid using internal buffers for the test. We have to write something to |
104 // the entry and close it so that we flush the internal buffer to disk. After | 104 // the entry and close it so that we flush the internal buffer to disk. After |
105 // that, IO operations will be really hitting the disk. We don't care about | 105 // that, IO operations will be really hitting the disk. We don't care about |
106 // the content, so just extending the entry is enough (all extensions zero- | 106 // the content, so just extending the entry is enough (all extensions zero- |
107 // fill any holes). | 107 // fill any holes). |
108 EXPECT_EQ(0, entry1->WriteData(0, 15 * 1024, NULL, 0, NULL, false)); | 108 EXPECT_EQ(0, entry1->WriteData(0, 15 * 1024, NULL, 0, NULL, false)); |
109 EXPECT_EQ(0, entry1->WriteData(1, 15 * 1024, NULL, 0, NULL, false)); | 109 EXPECT_EQ(0, entry1->WriteData(1, 15 * 1024, NULL, 0, NULL, false)); |
110 entry1->Close(); | 110 entry1->Close(); |
111 ASSERT_TRUE(cache_->OpenEntry("the first key", &entry1)); | 111 ASSERT_EQ(net::OK, OpenEntry("the first key", &entry1)); |
112 | 112 |
113 // Let's verify that each IO goes to the right callback object. | 113 // Let's verify that each IO goes to the right callback object. |
114 CallbackTest callback1(false); | 114 CallbackTest callback1(false); |
115 CallbackTest callback2(false); | 115 CallbackTest callback2(false); |
116 CallbackTest callback3(false); | 116 CallbackTest callback3(false); |
117 CallbackTest callback4(false); | 117 CallbackTest callback4(false); |
118 CallbackTest callback5(false); | 118 CallbackTest callback5(false); |
119 CallbackTest callback6(false); | 119 CallbackTest callback6(false); |
120 CallbackTest callback7(false); | 120 CallbackTest callback7(false); |
121 CallbackTest callback8(false); | 121 CallbackTest callback8(false); |
(...skipping 109 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
231 } | 231 } |
232 | 232 |
233 TEST_F(DiskCacheEntryTest, MemoryOnlyInternalAsyncIO) { | 233 TEST_F(DiskCacheEntryTest, MemoryOnlyInternalAsyncIO) { |
234 SetMemoryOnlyMode(); | 234 SetMemoryOnlyMode(); |
235 InitCache(); | 235 InitCache(); |
236 InternalAsyncIO(); | 236 InternalAsyncIO(); |
237 } | 237 } |
238 | 238 |
239 void DiskCacheEntryTest::ExternalSyncIO() { | 239 void DiskCacheEntryTest::ExternalSyncIO() { |
240 disk_cache::Entry *entry1; | 240 disk_cache::Entry *entry1; |
241 ASSERT_TRUE(cache_->CreateEntry("the first key", &entry1)); | 241 ASSERT_EQ(net::OK, CreateEntry("the first key", &entry1)); |
242 | 242 |
243 const int kSize1 = 17000; | 243 const int kSize1 = 17000; |
244 const int kSize2 = 25000; | 244 const int kSize2 = 25000; |
245 scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1); | 245 scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1); |
246 scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize2); | 246 scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize2); |
247 CacheTestFillBuffer(buffer1->data(), kSize1, false); | 247 CacheTestFillBuffer(buffer1->data(), kSize1, false); |
248 CacheTestFillBuffer(buffer2->data(), kSize2, false); | 248 CacheTestFillBuffer(buffer2->data(), kSize2, false); |
249 base::strlcpy(buffer1->data(), "the data", kSize1); | 249 base::strlcpy(buffer1->data(), "the data", kSize1); |
250 EXPECT_EQ(17000, entry1->WriteData(0, 0, buffer1, kSize1, NULL, false)); | 250 EXPECT_EQ(17000, entry1->WriteData(0, 0, buffer1, kSize1, NULL, false)); |
251 memset(buffer1->data(), 0, kSize1); | 251 memset(buffer1->data(), 0, kSize1); |
(...skipping 25 matching lines...) Expand all Loading... |
277 } | 277 } |
278 | 278 |
279 TEST_F(DiskCacheEntryTest, MemoryOnlyExternalSyncIO) { | 279 TEST_F(DiskCacheEntryTest, MemoryOnlyExternalSyncIO) { |
280 SetMemoryOnlyMode(); | 280 SetMemoryOnlyMode(); |
281 InitCache(); | 281 InitCache(); |
282 ExternalSyncIO(); | 282 ExternalSyncIO(); |
283 } | 283 } |
284 | 284 |
285 void DiskCacheEntryTest::ExternalAsyncIO() { | 285 void DiskCacheEntryTest::ExternalAsyncIO() { |
286 disk_cache::Entry *entry1; | 286 disk_cache::Entry *entry1; |
287 ASSERT_TRUE(cache_->CreateEntry("the first key", &entry1)); | 287 ASSERT_EQ(net::OK, CreateEntry("the first key", &entry1)); |
288 | 288 |
289 // Let's verify that each IO goes to the right callback object. | 289 // Let's verify that each IO goes to the right callback object. |
290 CallbackTest callback1(false); | 290 CallbackTest callback1(false); |
291 CallbackTest callback2(false); | 291 CallbackTest callback2(false); |
292 CallbackTest callback3(false); | 292 CallbackTest callback3(false); |
293 CallbackTest callback4(false); | 293 CallbackTest callback4(false); |
294 CallbackTest callback5(false); | 294 CallbackTest callback5(false); |
295 CallbackTest callback6(false); | 295 CallbackTest callback6(false); |
296 CallbackTest callback7(false); | 296 CallbackTest callback7(false); |
297 CallbackTest callback8(false); | 297 CallbackTest callback8(false); |
(...skipping 86 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
384 } | 384 } |
385 | 385 |
386 TEST_F(DiskCacheEntryTest, MemoryOnlyExternalAsyncIO) { | 386 TEST_F(DiskCacheEntryTest, MemoryOnlyExternalAsyncIO) { |
387 SetMemoryOnlyMode(); | 387 SetMemoryOnlyMode(); |
388 InitCache(); | 388 InitCache(); |
389 ExternalAsyncIO(); | 389 ExternalAsyncIO(); |
390 } | 390 } |
391 | 391 |
392 void DiskCacheEntryTest::StreamAccess() { | 392 void DiskCacheEntryTest::StreamAccess() { |
393 disk_cache::Entry *entry = NULL; | 393 disk_cache::Entry *entry = NULL; |
394 ASSERT_TRUE(cache_->CreateEntry("the first key", &entry)); | 394 ASSERT_EQ(net::OK, CreateEntry("the first key", &entry)); |
395 ASSERT_TRUE(NULL != entry); | 395 ASSERT_TRUE(NULL != entry); |
396 | 396 |
397 const int kBufferSize = 1024; | 397 const int kBufferSize = 1024; |
398 scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kBufferSize); | 398 scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kBufferSize); |
399 scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kBufferSize); | 399 scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kBufferSize); |
400 | 400 |
401 const int kNumStreams = 3; | 401 const int kNumStreams = 3; |
402 for (int i = 0; i < kNumStreams; i++) { | 402 for (int i = 0; i < kNumStreams; i++) { |
403 CacheTestFillBuffer(buffer1->data(), kBufferSize, false); | 403 CacheTestFillBuffer(buffer1->data(), kBufferSize, false); |
404 EXPECT_EQ(kBufferSize, entry->WriteData(i, 0, buffer1, kBufferSize, NULL, | 404 EXPECT_EQ(kBufferSize, entry->WriteData(i, 0, buffer1, kBufferSize, NULL, |
(...skipping 15 matching lines...) Expand all Loading... |
420 | 420 |
421 TEST_F(DiskCacheEntryTest, MemoryOnlyStreamAccess) { | 421 TEST_F(DiskCacheEntryTest, MemoryOnlyStreamAccess) { |
422 SetMemoryOnlyMode(); | 422 SetMemoryOnlyMode(); |
423 InitCache(); | 423 InitCache(); |
424 StreamAccess(); | 424 StreamAccess(); |
425 } | 425 } |
426 | 426 |
427 void DiskCacheEntryTest::GetKey() { | 427 void DiskCacheEntryTest::GetKey() { |
428 std::string key1("the first key"); | 428 std::string key1("the first key"); |
429 disk_cache::Entry *entry1; | 429 disk_cache::Entry *entry1; |
430 ASSERT_TRUE(cache_->CreateEntry(key1, &entry1)); | 430 ASSERT_EQ(net::OK, CreateEntry(key1, &entry1)); |
431 EXPECT_EQ(key1, entry1->GetKey()) << "short key"; | 431 EXPECT_EQ(key1, entry1->GetKey()) << "short key"; |
432 entry1->Close(); | 432 entry1->Close(); |
433 | 433 |
434 int seed = static_cast<int>(Time::Now().ToInternalValue()); | 434 int seed = static_cast<int>(Time::Now().ToInternalValue()); |
435 srand(seed); | 435 srand(seed); |
436 char key_buffer[20000]; | 436 char key_buffer[20000]; |
437 | 437 |
438 CacheTestFillBuffer(key_buffer, 3000, true); | 438 CacheTestFillBuffer(key_buffer, 3000, true); |
439 key_buffer[1000] = '\0'; | 439 key_buffer[1000] = '\0'; |
440 | 440 |
441 key1 = key_buffer; | 441 key1 = key_buffer; |
442 ASSERT_TRUE(cache_->CreateEntry(key1, &entry1)); | 442 ASSERT_EQ(net::OK, CreateEntry(key1, &entry1)); |
443 EXPECT_TRUE(key1 == entry1->GetKey()) << "1000 bytes key"; | 443 EXPECT_TRUE(key1 == entry1->GetKey()) << "1000 bytes key"; |
444 entry1->Close(); | 444 entry1->Close(); |
445 | 445 |
446 key_buffer[1000] = 'p'; | 446 key_buffer[1000] = 'p'; |
447 key_buffer[3000] = '\0'; | 447 key_buffer[3000] = '\0'; |
448 key1 = key_buffer; | 448 key1 = key_buffer; |
449 ASSERT_TRUE(cache_->CreateEntry(key1, &entry1)); | 449 ASSERT_EQ(net::OK, CreateEntry(key1, &entry1)); |
450 EXPECT_TRUE(key1 == entry1->GetKey()) << "medium size key"; | 450 EXPECT_TRUE(key1 == entry1->GetKey()) << "medium size key"; |
451 entry1->Close(); | 451 entry1->Close(); |
452 | 452 |
453 CacheTestFillBuffer(key_buffer, sizeof(key_buffer), true); | 453 CacheTestFillBuffer(key_buffer, sizeof(key_buffer), true); |
454 key_buffer[19999] = '\0'; | 454 key_buffer[19999] = '\0'; |
455 | 455 |
456 key1 = key_buffer; | 456 key1 = key_buffer; |
457 ASSERT_TRUE(cache_->CreateEntry(key1, &entry1)); | 457 ASSERT_EQ(net::OK, CreateEntry(key1, &entry1)); |
458 EXPECT_TRUE(key1 == entry1->GetKey()) << "long key"; | 458 EXPECT_TRUE(key1 == entry1->GetKey()) << "long key"; |
459 entry1->Close(); | 459 entry1->Close(); |
460 } | 460 } |
461 | 461 |
462 TEST_F(DiskCacheEntryTest, GetKey) { | 462 TEST_F(DiskCacheEntryTest, GetKey) { |
463 InitCache(); | 463 InitCache(); |
464 GetKey(); | 464 GetKey(); |
465 } | 465 } |
466 | 466 |
467 TEST_F(DiskCacheEntryTest, MemoryOnlyGetKey) { | 467 TEST_F(DiskCacheEntryTest, MemoryOnlyGetKey) { |
468 SetMemoryOnlyMode(); | 468 SetMemoryOnlyMode(); |
469 InitCache(); | 469 InitCache(); |
470 GetKey(); | 470 GetKey(); |
471 } | 471 } |
472 | 472 |
473 void DiskCacheEntryTest::GrowData() { | 473 void DiskCacheEntryTest::GrowData() { |
474 std::string key1("the first key"); | 474 std::string key1("the first key"); |
475 disk_cache::Entry *entry1, *entry2; | 475 disk_cache::Entry *entry1, *entry2; |
476 ASSERT_TRUE(cache_->CreateEntry(key1, &entry1)); | 476 ASSERT_EQ(net::OK, CreateEntry(key1, &entry1)); |
477 | 477 |
478 const int kSize = 20000; | 478 const int kSize = 20000; |
479 scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize); | 479 scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize); |
480 scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize); | 480 scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize); |
481 CacheTestFillBuffer(buffer1->data(), kSize, false); | 481 CacheTestFillBuffer(buffer1->data(), kSize, false); |
482 memset(buffer2->data(), 0, kSize); | 482 memset(buffer2->data(), 0, kSize); |
483 | 483 |
484 base::strlcpy(buffer1->data(), "the data", kSize); | 484 base::strlcpy(buffer1->data(), "the data", kSize); |
485 EXPECT_EQ(10, entry1->WriteData(0, 0, buffer1, 10, NULL, false)); | 485 EXPECT_EQ(10, entry1->WriteData(0, 0, buffer1, 10, NULL, false)); |
486 EXPECT_EQ(10, entry1->ReadData(0, 0, buffer2, 10, NULL)); | 486 EXPECT_EQ(10, entry1->ReadData(0, 0, buffer2, 10, NULL)); |
487 EXPECT_STREQ("the data", buffer2->data()); | 487 EXPECT_STREQ("the data", buffer2->data()); |
488 EXPECT_EQ(10, entry1->GetDataSize(0)); | 488 EXPECT_EQ(10, entry1->GetDataSize(0)); |
489 | 489 |
490 EXPECT_EQ(2000, entry1->WriteData(0, 0, buffer1, 2000, NULL, false)); | 490 EXPECT_EQ(2000, entry1->WriteData(0, 0, buffer1, 2000, NULL, false)); |
491 EXPECT_EQ(2000, entry1->GetDataSize(0)); | 491 EXPECT_EQ(2000, entry1->GetDataSize(0)); |
492 EXPECT_EQ(2000, entry1->ReadData(0, 0, buffer2, 2000, NULL)); | 492 EXPECT_EQ(2000, entry1->ReadData(0, 0, buffer2, 2000, NULL)); |
493 EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 2000)); | 493 EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 2000)); |
494 | 494 |
495 EXPECT_EQ(20000, entry1->WriteData(0, 0, buffer1, kSize, NULL, false)); | 495 EXPECT_EQ(20000, entry1->WriteData(0, 0, buffer1, kSize, NULL, false)); |
496 EXPECT_EQ(20000, entry1->GetDataSize(0)); | 496 EXPECT_EQ(20000, entry1->GetDataSize(0)); |
497 EXPECT_EQ(20000, entry1->ReadData(0, 0, buffer2, kSize, NULL)); | 497 EXPECT_EQ(20000, entry1->ReadData(0, 0, buffer2, kSize, NULL)); |
498 EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize)); | 498 EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize)); |
499 entry1->Close(); | 499 entry1->Close(); |
500 | 500 |
501 memset(buffer2->data(), 0, kSize); | 501 memset(buffer2->data(), 0, kSize); |
502 ASSERT_TRUE(cache_->CreateEntry("Second key", &entry2)); | 502 ASSERT_EQ(net::OK, CreateEntry("Second key", &entry2)); |
503 EXPECT_EQ(10, entry2->WriteData(0, 0, buffer1, 10, NULL, false)); | 503 EXPECT_EQ(10, entry2->WriteData(0, 0, buffer1, 10, NULL, false)); |
504 EXPECT_EQ(10, entry2->GetDataSize(0)); | 504 EXPECT_EQ(10, entry2->GetDataSize(0)); |
505 entry2->Close(); | 505 entry2->Close(); |
506 | 506 |
507 // Go from an internal address to a bigger block size. | 507 // Go from an internal address to a bigger block size. |
508 ASSERT_TRUE(cache_->OpenEntry("Second key", &entry2)); | 508 ASSERT_EQ(net::OK, OpenEntry("Second key", &entry2)); |
509 EXPECT_EQ(2000, entry2->WriteData(0, 0, buffer1, 2000, NULL, false)); | 509 EXPECT_EQ(2000, entry2->WriteData(0, 0, buffer1, 2000, NULL, false)); |
510 EXPECT_EQ(2000, entry2->GetDataSize(0)); | 510 EXPECT_EQ(2000, entry2->GetDataSize(0)); |
511 EXPECT_EQ(2000, entry2->ReadData(0, 0, buffer2, 2000, NULL)); | 511 EXPECT_EQ(2000, entry2->ReadData(0, 0, buffer2, 2000, NULL)); |
512 EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 2000)); | 512 EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 2000)); |
513 entry2->Close(); | 513 entry2->Close(); |
514 memset(buffer2->data(), 0, kSize); | 514 memset(buffer2->data(), 0, kSize); |
515 | 515 |
516 // Go from an internal address to an external one. | 516 // Go from an internal address to an external one. |
517 ASSERT_TRUE(cache_->OpenEntry("Second key", &entry2)); | 517 ASSERT_EQ(net::OK, OpenEntry("Second key", &entry2)); |
518 EXPECT_EQ(20000, entry2->WriteData(0, 0, buffer1, kSize, NULL, false)); | 518 EXPECT_EQ(20000, entry2->WriteData(0, 0, buffer1, kSize, NULL, false)); |
519 EXPECT_EQ(20000, entry2->GetDataSize(0)); | 519 EXPECT_EQ(20000, entry2->GetDataSize(0)); |
520 EXPECT_EQ(20000, entry2->ReadData(0, 0, buffer2, kSize, NULL)); | 520 EXPECT_EQ(20000, entry2->ReadData(0, 0, buffer2, kSize, NULL)); |
521 EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize)); | 521 EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize)); |
522 entry2->Close(); | 522 entry2->Close(); |
523 } | 523 } |
524 | 524 |
525 TEST_F(DiskCacheEntryTest, GrowData) { | 525 TEST_F(DiskCacheEntryTest, GrowData) { |
526 InitCache(); | 526 InitCache(); |
527 GrowData(); | 527 GrowData(); |
528 } | 528 } |
529 | 529 |
530 TEST_F(DiskCacheEntryTest, MemoryOnlyGrowData) { | 530 TEST_F(DiskCacheEntryTest, MemoryOnlyGrowData) { |
531 SetMemoryOnlyMode(); | 531 SetMemoryOnlyMode(); |
532 InitCache(); | 532 InitCache(); |
533 GrowData(); | 533 GrowData(); |
534 } | 534 } |
535 | 535 |
536 void DiskCacheEntryTest::TruncateData() { | 536 void DiskCacheEntryTest::TruncateData() { |
537 std::string key1("the first key"); | 537 std::string key1("the first key"); |
538 disk_cache::Entry *entry1; | 538 disk_cache::Entry *entry1; |
539 ASSERT_TRUE(cache_->CreateEntry(key1, &entry1)); | 539 ASSERT_EQ(net::OK, CreateEntry(key1, &entry1)); |
540 | 540 |
541 const int kSize1 = 20000; | 541 const int kSize1 = 20000; |
542 const int kSize2 = 20000; | 542 const int kSize2 = 20000; |
543 scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1); | 543 scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1); |
544 scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize2); | 544 scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize2); |
545 | 545 |
546 CacheTestFillBuffer(buffer1->data(), kSize1, false); | 546 CacheTestFillBuffer(buffer1->data(), kSize1, false); |
547 memset(buffer2->data(), 0, kSize2); | 547 memset(buffer2->data(), 0, kSize2); |
548 | 548 |
549 // Simple truncation: | 549 // Simple truncation: |
550 EXPECT_EQ(200, entry1->WriteData(0, 0, buffer1, 200, NULL, false)); | 550 EXPECT_EQ(200, entry1->WriteData(0, 0, buffer1, 200, NULL, false)); |
551 EXPECT_EQ(200, entry1->GetDataSize(0)); | 551 EXPECT_EQ(200, entry1->GetDataSize(0)); |
552 EXPECT_EQ(100, entry1->WriteData(0, 0, buffer1, 100, NULL, false)); | 552 EXPECT_EQ(100, entry1->WriteData(0, 0, buffer1, 100, NULL, false)); |
553 EXPECT_EQ(200, entry1->GetDataSize(0)); | 553 EXPECT_EQ(200, entry1->GetDataSize(0)); |
554 EXPECT_EQ(100, entry1->WriteData(0, 0, buffer1, 100, NULL, true)); | 554 EXPECT_EQ(100, entry1->WriteData(0, 0, buffer1, 100, NULL, true)); |
555 EXPECT_EQ(100, entry1->GetDataSize(0)); | 555 EXPECT_EQ(100, entry1->GetDataSize(0)); |
556 EXPECT_EQ(0, entry1->WriteData(0, 50, buffer1, 0, NULL, true)); | 556 EXPECT_EQ(0, entry1->WriteData(0, 50, buffer1, 0, NULL, true)); |
557 EXPECT_EQ(50, entry1->GetDataSize(0)); | 557 EXPECT_EQ(50, entry1->GetDataSize(0)); |
558 EXPECT_EQ(0, entry1->WriteData(0, 0, buffer1, 0, NULL, true)); | 558 EXPECT_EQ(0, entry1->WriteData(0, 0, buffer1, 0, NULL, true)); |
559 EXPECT_EQ(0, entry1->GetDataSize(0)); | 559 EXPECT_EQ(0, entry1->GetDataSize(0)); |
560 entry1->Close(); | 560 entry1->Close(); |
561 ASSERT_TRUE(cache_->OpenEntry(key1, &entry1)); | 561 ASSERT_EQ(net::OK, OpenEntry(key1, &entry1)); |
562 | 562 |
563 // Go to an external file. | 563 // Go to an external file. |
564 EXPECT_EQ(20000, entry1->WriteData(0, 0, buffer1, 20000, NULL, true)); | 564 EXPECT_EQ(20000, entry1->WriteData(0, 0, buffer1, 20000, NULL, true)); |
565 EXPECT_EQ(20000, entry1->GetDataSize(0)); | 565 EXPECT_EQ(20000, entry1->GetDataSize(0)); |
566 EXPECT_EQ(20000, entry1->ReadData(0, 0, buffer2, 20000, NULL)); | 566 EXPECT_EQ(20000, entry1->ReadData(0, 0, buffer2, 20000, NULL)); |
567 EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 20000)); | 567 EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 20000)); |
568 memset(buffer2->data(), 0, kSize2); | 568 memset(buffer2->data(), 0, kSize2); |
569 | 569 |
570 // External file truncation | 570 // External file truncation |
571 EXPECT_EQ(18000, entry1->WriteData(0, 0, buffer1, 18000, NULL, false)); | 571 EXPECT_EQ(18000, entry1->WriteData(0, 0, buffer1, 18000, NULL, false)); |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
605 | 605 |
606 TEST_F(DiskCacheEntryTest, MemoryOnlyTruncateData) { | 606 TEST_F(DiskCacheEntryTest, MemoryOnlyTruncateData) { |
607 SetMemoryOnlyMode(); | 607 SetMemoryOnlyMode(); |
608 InitCache(); | 608 InitCache(); |
609 TruncateData(); | 609 TruncateData(); |
610 } | 610 } |
611 | 611 |
612 void DiskCacheEntryTest::ZeroLengthIO() { | 612 void DiskCacheEntryTest::ZeroLengthIO() { |
613 std::string key1("the first key"); | 613 std::string key1("the first key"); |
614 disk_cache::Entry *entry1; | 614 disk_cache::Entry *entry1; |
615 ASSERT_TRUE(cache_->CreateEntry(key1, &entry1)); | 615 ASSERT_EQ(net::OK, CreateEntry(key1, &entry1)); |
616 | 616 |
617 EXPECT_EQ(0, entry1->ReadData(0, 0, NULL, 0, NULL)); | 617 EXPECT_EQ(0, entry1->ReadData(0, 0, NULL, 0, NULL)); |
618 EXPECT_EQ(0, entry1->WriteData(0, 0, NULL, 0, NULL, false)); | 618 EXPECT_EQ(0, entry1->WriteData(0, 0, NULL, 0, NULL, false)); |
619 | 619 |
620 // This write should extend the entry. | 620 // This write should extend the entry. |
621 EXPECT_EQ(0, entry1->WriteData(0, 1000, NULL, 0, NULL, false)); | 621 EXPECT_EQ(0, entry1->WriteData(0, 1000, NULL, 0, NULL, false)); |
622 EXPECT_EQ(0, entry1->ReadData(0, 500, NULL, 0, NULL)); | 622 EXPECT_EQ(0, entry1->ReadData(0, 500, NULL, 0, NULL)); |
623 EXPECT_EQ(0, entry1->ReadData(0, 2000, NULL, 0, NULL)); | 623 EXPECT_EQ(0, entry1->ReadData(0, 2000, NULL, 0, NULL)); |
624 EXPECT_EQ(1000, entry1->GetDataSize(0)); | 624 EXPECT_EQ(1000, entry1->GetDataSize(0)); |
625 entry1->Close(); | 625 entry1->Close(); |
626 } | 626 } |
627 | 627 |
628 TEST_F(DiskCacheEntryTest, ZeroLengthIO) { | 628 TEST_F(DiskCacheEntryTest, ZeroLengthIO) { |
629 InitCache(); | 629 InitCache(); |
630 ZeroLengthIO(); | 630 ZeroLengthIO(); |
631 } | 631 } |
632 | 632 |
633 TEST_F(DiskCacheEntryTest, MemoryOnlyZeroLengthIO) { | 633 TEST_F(DiskCacheEntryTest, MemoryOnlyZeroLengthIO) { |
634 SetMemoryOnlyMode(); | 634 SetMemoryOnlyMode(); |
635 InitCache(); | 635 InitCache(); |
636 ZeroLengthIO(); | 636 ZeroLengthIO(); |
637 } | 637 } |
638 | 638 |
639 // Write more than the total cache capacity but to a single entry. |size| is the | 639 // Write more than the total cache capacity but to a single entry. |size| is the |
640 // amount of bytes to write each time. | 640 // amount of bytes to write each time. |
641 void DiskCacheEntryTest::ReuseEntry(int size) { | 641 void DiskCacheEntryTest::ReuseEntry(int size) { |
642 std::string key1("the first key"); | 642 std::string key1("the first key"); |
643 disk_cache::Entry *entry; | 643 disk_cache::Entry *entry; |
644 ASSERT_TRUE(cache_->CreateEntry(key1, &entry)); | 644 ASSERT_EQ(net::OK, CreateEntry(key1, &entry)); |
645 | 645 |
646 entry->Close(); | 646 entry->Close(); |
647 std::string key2("the second key"); | 647 std::string key2("the second key"); |
648 ASSERT_TRUE(cache_->CreateEntry(key2, &entry)); | 648 ASSERT_EQ(net::OK, CreateEntry(key2, &entry)); |
649 | 649 |
650 scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(size); | 650 scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(size); |
651 CacheTestFillBuffer(buffer->data(), size, false); | 651 CacheTestFillBuffer(buffer->data(), size, false); |
652 | 652 |
653 for (int i = 0; i < 15; i++) { | 653 for (int i = 0; i < 15; i++) { |
654 EXPECT_EQ(0, entry->WriteData(0, 0, buffer, 0, NULL, true)); | 654 EXPECT_EQ(0, entry->WriteData(0, 0, buffer, 0, NULL, true)); |
655 EXPECT_EQ(size, entry->WriteData(0, 0, buffer, size, NULL, false)); | 655 EXPECT_EQ(size, entry->WriteData(0, 0, buffer, size, NULL, false)); |
656 entry->Close(); | 656 entry->Close(); |
657 ASSERT_TRUE(cache_->OpenEntry(key2, &entry)); | 657 ASSERT_EQ(net::OK, OpenEntry(key2, &entry)); |
658 } | 658 } |
659 | 659 |
660 entry->Close(); | 660 entry->Close(); |
661 ASSERT_TRUE(cache_->OpenEntry(key1, &entry)) << "have not evicted this entry"; | 661 ASSERT_EQ(net::OK, OpenEntry(key1, &entry)) << "have not evicted this entry"; |
662 entry->Close(); | 662 entry->Close(); |
663 } | 663 } |
664 | 664 |
665 TEST_F(DiskCacheEntryTest, ReuseExternalEntry) { | 665 TEST_F(DiskCacheEntryTest, ReuseExternalEntry) { |
666 SetDirectMode(); | 666 SetDirectMode(); |
667 SetMaxSize(200 * 1024); | 667 SetMaxSize(200 * 1024); |
668 InitCache(); | 668 InitCache(); |
669 ReuseEntry(20 * 1024); | 669 ReuseEntry(20 * 1024); |
670 } | 670 } |
671 | 671 |
(...skipping 17 matching lines...) Expand all Loading... |
689 SetMemoryOnlyMode(); | 689 SetMemoryOnlyMode(); |
690 SetMaxSize(100 * 1024); | 690 SetMaxSize(100 * 1024); |
691 InitCache(); | 691 InitCache(); |
692 ReuseEntry(10 * 1024); | 692 ReuseEntry(10 * 1024); |
693 } | 693 } |
694 | 694 |
695 // Reading somewhere that was not written should return zeros. | 695 // Reading somewhere that was not written should return zeros. |
696 void DiskCacheEntryTest::InvalidData() { | 696 void DiskCacheEntryTest::InvalidData() { |
697 std::string key1("the first key"); | 697 std::string key1("the first key"); |
698 disk_cache::Entry *entry1; | 698 disk_cache::Entry *entry1; |
699 ASSERT_TRUE(cache_->CreateEntry(key1, &entry1)); | 699 ASSERT_EQ(net::OK, CreateEntry(key1, &entry1)); |
700 | 700 |
701 const int kSize1 = 20000; | 701 const int kSize1 = 20000; |
702 const int kSize2 = 20000; | 702 const int kSize2 = 20000; |
703 const int kSize3 = 20000; | 703 const int kSize3 = 20000; |
704 scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1); | 704 scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1); |
705 scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize2); | 705 scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize2); |
706 scoped_refptr<net::IOBuffer> buffer3 = new net::IOBuffer(kSize3); | 706 scoped_refptr<net::IOBuffer> buffer3 = new net::IOBuffer(kSize3); |
707 | 707 |
708 CacheTestFillBuffer(buffer1->data(), kSize1, false); | 708 CacheTestFillBuffer(buffer1->data(), kSize1, false); |
709 memset(buffer2->data(), 0, kSize2); | 709 memset(buffer2->data(), 0, kSize2); |
710 | 710 |
711 // Simple data grow: | 711 // Simple data grow: |
712 EXPECT_EQ(200, entry1->WriteData(0, 400, buffer1, 200, NULL, false)); | 712 EXPECT_EQ(200, entry1->WriteData(0, 400, buffer1, 200, NULL, false)); |
713 EXPECT_EQ(600, entry1->GetDataSize(0)); | 713 EXPECT_EQ(600, entry1->GetDataSize(0)); |
714 EXPECT_EQ(100, entry1->ReadData(0, 300, buffer3, 100, NULL)); | 714 EXPECT_EQ(100, entry1->ReadData(0, 300, buffer3, 100, NULL)); |
715 EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100)); | 715 EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100)); |
716 entry1->Close(); | 716 entry1->Close(); |
717 ASSERT_TRUE(cache_->OpenEntry(key1, &entry1)); | 717 ASSERT_EQ(net::OK, OpenEntry(key1, &entry1)); |
718 | 718 |
719 // The entry is now on disk. Load it and extend it. | 719 // The entry is now on disk. Load it and extend it. |
720 EXPECT_EQ(200, entry1->WriteData(0, 800, buffer1, 200, NULL, false)); | 720 EXPECT_EQ(200, entry1->WriteData(0, 800, buffer1, 200, NULL, false)); |
721 EXPECT_EQ(1000, entry1->GetDataSize(0)); | 721 EXPECT_EQ(1000, entry1->GetDataSize(0)); |
722 EXPECT_EQ(100, entry1->ReadData(0, 700, buffer3, 100, NULL)); | 722 EXPECT_EQ(100, entry1->ReadData(0, 700, buffer3, 100, NULL)); |
723 EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100)); | 723 EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100)); |
724 entry1->Close(); | 724 entry1->Close(); |
725 ASSERT_TRUE(cache_->OpenEntry(key1, &entry1)); | 725 ASSERT_EQ(net::OK, OpenEntry(key1, &entry1)); |
726 | 726 |
727 // This time using truncate. | 727 // This time using truncate. |
728 EXPECT_EQ(200, entry1->WriteData(0, 1800, buffer1, 200, NULL, true)); | 728 EXPECT_EQ(200, entry1->WriteData(0, 1800, buffer1, 200, NULL, true)); |
729 EXPECT_EQ(2000, entry1->GetDataSize(0)); | 729 EXPECT_EQ(2000, entry1->GetDataSize(0)); |
730 EXPECT_EQ(100, entry1->ReadData(0, 1500, buffer3, 100, NULL)); | 730 EXPECT_EQ(100, entry1->ReadData(0, 1500, buffer3, 100, NULL)); |
731 EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100)); | 731 EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100)); |
732 | 732 |
733 // Go to an external file. | 733 // Go to an external file. |
734 EXPECT_EQ(200, entry1->WriteData(0, 19800, buffer1, 200, NULL, false)); | 734 EXPECT_EQ(200, entry1->WriteData(0, 19800, buffer1, 200, NULL, false)); |
735 EXPECT_EQ(20000, entry1->GetDataSize(0)); | 735 EXPECT_EQ(20000, entry1->GetDataSize(0)); |
(...skipping 25 matching lines...) Expand all Loading... |
761 InitCache(); | 761 InitCache(); |
762 InvalidData(); | 762 InvalidData(); |
763 } | 763 } |
764 | 764 |
765 TEST_F(DiskCacheEntryTest, MemoryOnlyInvalidData) { | 765 TEST_F(DiskCacheEntryTest, MemoryOnlyInvalidData) { |
766 SetMemoryOnlyMode(); | 766 SetMemoryOnlyMode(); |
767 InitCache(); | 767 InitCache(); |
768 InvalidData(); | 768 InvalidData(); |
769 } | 769 } |
770 | 770 |
771 void DiskCacheEntryTest::DoomEntry() { | 771 void DiskCacheEntryTest::DoomNormalEntry() { |
772 std::string key1("the first key"); | 772 std::string key1("the first key"); |
773 disk_cache::Entry *entry1; | 773 disk_cache::Entry *entry1; |
774 ASSERT_TRUE(cache_->CreateEntry(key1, &entry1)); | 774 ASSERT_EQ(net::OK, CreateEntry(key1, &entry1)); |
775 entry1->Doom(); | 775 entry1->Doom(); |
776 entry1->Close(); | 776 entry1->Close(); |
777 | 777 |
778 const int kSize = 20000; | 778 const int kSize = 20000; |
779 scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kSize); | 779 scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kSize); |
780 CacheTestFillBuffer(buffer->data(), kSize, true); | 780 CacheTestFillBuffer(buffer->data(), kSize, true); |
781 buffer->data()[19999] = '\0'; | 781 buffer->data()[19999] = '\0'; |
782 | 782 |
783 key1 = buffer->data(); | 783 key1 = buffer->data(); |
784 ASSERT_TRUE(cache_->CreateEntry(key1, &entry1)); | 784 ASSERT_EQ(net::OK, CreateEntry(key1, &entry1)); |
785 EXPECT_EQ(20000, entry1->WriteData(0, 0, buffer, kSize, NULL, false)); | 785 EXPECT_EQ(20000, entry1->WriteData(0, 0, buffer, kSize, NULL, false)); |
786 EXPECT_EQ(20000, entry1->WriteData(1, 0, buffer, kSize, NULL, false)); | 786 EXPECT_EQ(20000, entry1->WriteData(1, 0, buffer, kSize, NULL, false)); |
787 entry1->Doom(); | 787 entry1->Doom(); |
788 entry1->Close(); | 788 entry1->Close(); |
789 | 789 |
790 EXPECT_EQ(0, cache_->GetEntryCount()); | 790 EXPECT_EQ(0, cache_->GetEntryCount()); |
791 } | 791 } |
792 | 792 |
793 TEST_F(DiskCacheEntryTest, DoomEntry) { | 793 TEST_F(DiskCacheEntryTest, DoomEntry) { |
794 InitCache(); | 794 InitCache(); |
795 DoomEntry(); | 795 DoomNormalEntry(); |
796 } | 796 } |
797 | 797 |
798 TEST_F(DiskCacheEntryTest, MemoryOnlyDoomEntry) { | 798 TEST_F(DiskCacheEntryTest, MemoryOnlyDoomEntry) { |
799 SetMemoryOnlyMode(); | 799 SetMemoryOnlyMode(); |
800 InitCache(); | 800 InitCache(); |
801 DoomEntry(); | 801 DoomNormalEntry(); |
802 } | 802 } |
803 | 803 |
804 // Verify that basic operations work as expected with doomed entries. | 804 // Verify that basic operations work as expected with doomed entries. |
805 void DiskCacheEntryTest::DoomedEntry() { | 805 void DiskCacheEntryTest::DoomedEntry() { |
806 std::string key("the first key"); | 806 std::string key("the first key"); |
807 disk_cache::Entry *entry; | 807 disk_cache::Entry *entry; |
808 ASSERT_TRUE(cache_->CreateEntry(key, &entry)); | 808 ASSERT_EQ(net::OK, CreateEntry(key, &entry)); |
809 entry->Doom(); | 809 entry->Doom(); |
810 | 810 |
811 EXPECT_EQ(0, cache_->GetEntryCount()); | 811 EXPECT_EQ(0, cache_->GetEntryCount()); |
812 Time initial = Time::Now(); | 812 Time initial = Time::Now(); |
813 PlatformThread::Sleep(20); | 813 PlatformThread::Sleep(20); |
814 | 814 |
815 const int kSize1 = 2000; | 815 const int kSize1 = 2000; |
816 const int kSize2 = 2000; | 816 const int kSize2 = 2000; |
817 scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1); | 817 scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1); |
818 scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize2); | 818 scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize2); |
819 CacheTestFillBuffer(buffer1->data(), kSize1, false); | 819 CacheTestFillBuffer(buffer1->data(), kSize1, false); |
820 memset(buffer2->data(), 0, kSize2); | 820 memset(buffer2->data(), 0, kSize2); |
821 | 821 |
822 EXPECT_EQ(2000, entry->WriteData(0, 0, buffer1, 2000, NULL, false)); | 822 EXPECT_EQ(2000, entry->WriteData(0, 0, buffer1, 2000, NULL, false)); |
823 EXPECT_EQ(2000, entry->ReadData(0, 0, buffer2, 2000, NULL)); | 823 EXPECT_EQ(2000, entry->ReadData(0, 0, buffer2, 2000, NULL)); |
824 EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kSize1)); | 824 EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kSize1)); |
825 EXPECT_EQ(key, entry->GetKey()); | 825 EXPECT_EQ(key, entry->GetKey()); |
826 EXPECT_TRUE(initial < entry->GetLastModified()); | 826 EXPECT_TRUE(initial < entry->GetLastModified()); |
827 EXPECT_TRUE(initial < entry->GetLastUsed()); | 827 EXPECT_TRUE(initial < entry->GetLastUsed()); |
828 | 828 |
829 entry->Close(); | 829 entry->Close(); |
830 } | 830 } |
831 | 831 |
832 TEST_F(DiskCacheEntryTest, DoomedEntry) { | 832 TEST_F(DiskCacheEntryTest, DoomedEntry) { |
833 InitCache(); | 833 InitCache(); |
834 DoomEntry(); | 834 DoomedEntry(); |
835 } | 835 } |
836 | 836 |
837 TEST_F(DiskCacheEntryTest, MemoryOnlyDoomedEntry) { | 837 TEST_F(DiskCacheEntryTest, MemoryOnlyDoomedEntry) { |
838 SetMemoryOnlyMode(); | 838 SetMemoryOnlyMode(); |
839 InitCache(); | 839 InitCache(); |
840 DoomEntry(); | 840 DoomedEntry(); |
841 } | 841 } |
842 | 842 |
843 // Test that child entries in a memory cache backend are not visible from | 843 // Test that child entries in a memory cache backend are not visible from |
844 // enumerations. | 844 // enumerations. |
845 TEST_F(DiskCacheEntryTest, MemoryOnlyEnumerationWithSparseEntries) { | 845 TEST_F(DiskCacheEntryTest, MemoryOnlyEnumerationWithSparseEntries) { |
846 SetMemoryOnlyMode(); | 846 SetMemoryOnlyMode(); |
847 InitCache(); | 847 InitCache(); |
848 | 848 |
849 const int kSize = 4096; | 849 const int kSize = 4096; |
850 scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize); | 850 scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize); |
851 CacheTestFillBuffer(buf->data(), kSize, false); | 851 CacheTestFillBuffer(buf->data(), kSize, false); |
852 | 852 |
853 std::string key("the first key"); | 853 std::string key("the first key"); |
854 disk_cache::Entry* parent_entry; | 854 disk_cache::Entry* parent_entry; |
855 ASSERT_TRUE(cache_->CreateEntry(key, &parent_entry)); | 855 ASSERT_EQ(net::OK, CreateEntry(key, &parent_entry)); |
856 | 856 |
857 // Writes to the parent entry. | 857 // Writes to the parent entry. |
858 EXPECT_EQ(kSize, parent_entry->WriteSparseData(0, buf, kSize, NULL)); | 858 EXPECT_EQ(kSize, parent_entry->WriteSparseData(0, buf, kSize, NULL)); |
859 | 859 |
860 // This write creates a child entry and writes to it. | 860 // This write creates a child entry and writes to it. |
861 EXPECT_EQ(kSize, parent_entry->WriteSparseData(8192, buf, kSize, NULL)); | 861 EXPECT_EQ(kSize, parent_entry->WriteSparseData(8192, buf, kSize, NULL)); |
862 | 862 |
863 parent_entry->Close(); | 863 parent_entry->Close(); |
864 | 864 |
865 // Perform the enumerations. | 865 // Perform the enumerations. |
866 void* iter = NULL; | 866 void* iter = NULL; |
867 disk_cache::Entry* entry = NULL; | 867 disk_cache::Entry* entry = NULL; |
868 int count = 0; | 868 int count = 0; |
869 while (cache_->OpenNextEntry(&iter, &entry)) { | 869 while (OpenNextEntry(&iter, &entry) == net::OK) { |
870 ASSERT_TRUE(entry != NULL); | 870 ASSERT_TRUE(entry != NULL); |
871 ++count; | 871 ++count; |
872 disk_cache::MemEntryImpl* mem_entry = | 872 disk_cache::MemEntryImpl* mem_entry = |
873 reinterpret_cast<disk_cache::MemEntryImpl*>(entry); | 873 reinterpret_cast<disk_cache::MemEntryImpl*>(entry); |
874 EXPECT_EQ(disk_cache::MemEntryImpl::kParentEntry, mem_entry->type()); | 874 EXPECT_EQ(disk_cache::MemEntryImpl::kParentEntry, mem_entry->type()); |
875 mem_entry->Close(); | 875 mem_entry->Close(); |
876 } | 876 } |
877 EXPECT_EQ(1, count); | 877 EXPECT_EQ(1, count); |
878 } | 878 } |
879 | 879 |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
912 int ret = entry->ReadSparseData(offset, buf_1, size, cb); | 912 int ret = entry->ReadSparseData(offset, buf_1, size, cb); |
913 ret = callback.GetResult(ret); | 913 ret = callback.GetResult(ret); |
914 EXPECT_EQ(size, ret); | 914 EXPECT_EQ(size, ret); |
915 | 915 |
916 EXPECT_EQ(0, memcmp(buf_1->data(), buffer, size)); | 916 EXPECT_EQ(0, memcmp(buf_1->data(), buffer, size)); |
917 } | 917 } |
918 | 918 |
919 void DiskCacheEntryTest::BasicSparseIO(bool async) { | 919 void DiskCacheEntryTest::BasicSparseIO(bool async) { |
920 std::string key("the first key"); | 920 std::string key("the first key"); |
921 disk_cache::Entry* entry; | 921 disk_cache::Entry* entry; |
922 ASSERT_TRUE(cache_->CreateEntry(key, &entry)); | 922 ASSERT_EQ(net::OK, CreateEntry(key, &entry)); |
923 | 923 |
924 const int kSize = 2048; | 924 const int kSize = 2048; |
925 scoped_refptr<net::IOBuffer> buf_1 = new net::IOBuffer(kSize); | 925 scoped_refptr<net::IOBuffer> buf_1 = new net::IOBuffer(kSize); |
926 scoped_refptr<net::IOBuffer> buf_2 = new net::IOBuffer(kSize); | 926 scoped_refptr<net::IOBuffer> buf_2 = new net::IOBuffer(kSize); |
927 CacheTestFillBuffer(buf_1->data(), kSize, false); | 927 CacheTestFillBuffer(buf_1->data(), kSize, false); |
928 | 928 |
929 // Write at offset 0. | 929 // Write at offset 0. |
930 VerifySparseIO(entry, 0, buf_1, kSize, async, buf_2); | 930 VerifySparseIO(entry, 0, buf_1, kSize, async, buf_2); |
931 | 931 |
932 // Write at offset 0x400000 (4 MB). | 932 // Write at offset 0x400000 (4 MB). |
933 VerifySparseIO(entry, 0x400000, buf_1, kSize, async, buf_2); | 933 VerifySparseIO(entry, 0x400000, buf_1, kSize, async, buf_2); |
934 | 934 |
935 // Write at offset 0x800000000 (32 GB). | 935 // Write at offset 0x800000000 (32 GB). |
936 VerifySparseIO(entry, 0x800000000LL, buf_1, kSize, async, buf_2); | 936 VerifySparseIO(entry, 0x800000000LL, buf_1, kSize, async, buf_2); |
937 | 937 |
938 entry->Close(); | 938 entry->Close(); |
939 | 939 |
940 // Check everything again. | 940 // Check everything again. |
941 ASSERT_TRUE(cache_->OpenEntry(key, &entry)); | 941 ASSERT_EQ(net::OK, OpenEntry(key, &entry)); |
942 VerifyContentSparseIO(entry, 0, buf_1->data(), kSize, async); | 942 VerifyContentSparseIO(entry, 0, buf_1->data(), kSize, async); |
943 VerifyContentSparseIO(entry, 0x400000, buf_1->data(), kSize, async); | 943 VerifyContentSparseIO(entry, 0x400000, buf_1->data(), kSize, async); |
944 VerifyContentSparseIO(entry, 0x800000000LL, buf_1->data(), kSize, async); | 944 VerifyContentSparseIO(entry, 0x800000000LL, buf_1->data(), kSize, async); |
945 entry->Close(); | 945 entry->Close(); |
946 } | 946 } |
947 | 947 |
948 TEST_F(DiskCacheEntryTest, BasicSparseSyncIO) { | 948 TEST_F(DiskCacheEntryTest, BasicSparseSyncIO) { |
949 InitCache(); | 949 InitCache(); |
950 BasicSparseIO(false); | 950 BasicSparseIO(false); |
951 } | 951 } |
(...skipping 11 matching lines...) Expand all Loading... |
963 | 963 |
964 TEST_F(DiskCacheEntryTest, MemoryOnlyBasicSparseAsyncIO) { | 964 TEST_F(DiskCacheEntryTest, MemoryOnlyBasicSparseAsyncIO) { |
965 SetMemoryOnlyMode(); | 965 SetMemoryOnlyMode(); |
966 InitCache(); | 966 InitCache(); |
967 BasicSparseIO(true); | 967 BasicSparseIO(true); |
968 } | 968 } |
969 | 969 |
970 void DiskCacheEntryTest::HugeSparseIO(bool async) { | 970 void DiskCacheEntryTest::HugeSparseIO(bool async) { |
971 std::string key("the first key"); | 971 std::string key("the first key"); |
972 disk_cache::Entry* entry; | 972 disk_cache::Entry* entry; |
973 ASSERT_TRUE(cache_->CreateEntry(key, &entry)); | 973 ASSERT_EQ(net::OK, CreateEntry(key, &entry)); |
974 | 974 |
975 // Write 1.2 MB so that we cover multiple entries. | 975 // Write 1.2 MB so that we cover multiple entries. |
976 const int kSize = 1200 * 1024; | 976 const int kSize = 1200 * 1024; |
977 scoped_refptr<net::IOBuffer> buf_1 = new net::IOBuffer(kSize); | 977 scoped_refptr<net::IOBuffer> buf_1 = new net::IOBuffer(kSize); |
978 scoped_refptr<net::IOBuffer> buf_2 = new net::IOBuffer(kSize); | 978 scoped_refptr<net::IOBuffer> buf_2 = new net::IOBuffer(kSize); |
979 CacheTestFillBuffer(buf_1->data(), kSize, false); | 979 CacheTestFillBuffer(buf_1->data(), kSize, false); |
980 | 980 |
981 // Write at offset 0x20F0000 (33 MB - 64 KB). | 981 // Write at offset 0x20F0000 (33 MB - 64 KB). |
982 VerifySparseIO(entry, 0x20F0000, buf_1, kSize, async, buf_2); | 982 VerifySparseIO(entry, 0x20F0000, buf_1, kSize, async, buf_2); |
983 entry->Close(); | 983 entry->Close(); |
984 | 984 |
985 // Check it again. | 985 // Check it again. |
986 ASSERT_TRUE(cache_->OpenEntry(key, &entry)); | 986 ASSERT_EQ(net::OK, OpenEntry(key, &entry)); |
987 VerifyContentSparseIO(entry, 0x20F0000, buf_1->data(), kSize, async); | 987 VerifyContentSparseIO(entry, 0x20F0000, buf_1->data(), kSize, async); |
988 entry->Close(); | 988 entry->Close(); |
989 } | 989 } |
990 | 990 |
991 TEST_F(DiskCacheEntryTest, HugeSparseSyncIO) { | 991 TEST_F(DiskCacheEntryTest, HugeSparseSyncIO) { |
992 InitCache(); | 992 InitCache(); |
993 HugeSparseIO(false); | 993 HugeSparseIO(false); |
994 } | 994 } |
995 | 995 |
996 TEST_F(DiskCacheEntryTest, MemoryOnlyHugeSparseSyncIO) { | 996 TEST_F(DiskCacheEntryTest, MemoryOnlyHugeSparseSyncIO) { |
997 SetMemoryOnlyMode(); | 997 SetMemoryOnlyMode(); |
998 InitCache(); | 998 InitCache(); |
999 HugeSparseIO(false); | 999 HugeSparseIO(false); |
1000 } | 1000 } |
1001 | 1001 |
1002 TEST_F(DiskCacheEntryTest, HugeSparseAsyncIO) { | 1002 TEST_F(DiskCacheEntryTest, HugeSparseAsyncIO) { |
1003 InitCache(); | 1003 InitCache(); |
1004 HugeSparseIO(true); | 1004 HugeSparseIO(true); |
1005 } | 1005 } |
1006 | 1006 |
1007 TEST_F(DiskCacheEntryTest, MemoryOnlyHugeSparseAsyncIO) { | 1007 TEST_F(DiskCacheEntryTest, MemoryOnlyHugeSparseAsyncIO) { |
1008 SetMemoryOnlyMode(); | 1008 SetMemoryOnlyMode(); |
1009 InitCache(); | 1009 InitCache(); |
1010 HugeSparseIO(true); | 1010 HugeSparseIO(true); |
1011 } | 1011 } |
1012 | 1012 |
1013 void DiskCacheEntryTest::GetAvailableRange() { | 1013 void DiskCacheEntryTest::GetAvailableRange() { |
1014 std::string key("the first key"); | 1014 std::string key("the first key"); |
1015 disk_cache::Entry* entry; | 1015 disk_cache::Entry* entry; |
1016 ASSERT_TRUE(cache_->CreateEntry(key, &entry)); | 1016 ASSERT_EQ(net::OK, CreateEntry(key, &entry)); |
1017 | 1017 |
1018 const int kSize = 16 * 1024; | 1018 const int kSize = 16 * 1024; |
1019 scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize); | 1019 scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize); |
1020 CacheTestFillBuffer(buf->data(), kSize, false); | 1020 CacheTestFillBuffer(buf->data(), kSize, false); |
1021 | 1021 |
1022 // Write at offset 0x20F0000 (33 MB - 64 KB), and 0x20F4400 (33 MB - 47 KB). | 1022 // Write at offset 0x20F0000 (33 MB - 64 KB), and 0x20F4400 (33 MB - 47 KB). |
1023 EXPECT_EQ(kSize, entry->WriteSparseData(0x20F0000, buf, kSize, NULL)); | 1023 EXPECT_EQ(kSize, entry->WriteSparseData(0x20F0000, buf, kSize, NULL)); |
1024 EXPECT_EQ(kSize, entry->WriteSparseData(0x20F4400, buf, kSize, NULL)); | 1024 EXPECT_EQ(kSize, entry->WriteSparseData(0x20F4400, buf, kSize, NULL)); |
1025 | 1025 |
1026 // We stop at the first empty block. | 1026 // We stop at the first empty block. |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1067 SetMemoryOnlyMode(); | 1067 SetMemoryOnlyMode(); |
1068 InitCache(); | 1068 InitCache(); |
1069 | 1069 |
1070 const int kSize = 8192; | 1070 const int kSize = 8192; |
1071 scoped_refptr<net::IOBuffer> buf_1 = new net::IOBuffer(kSize); | 1071 scoped_refptr<net::IOBuffer> buf_1 = new net::IOBuffer(kSize); |
1072 scoped_refptr<net::IOBuffer> buf_2 = new net::IOBuffer(kSize); | 1072 scoped_refptr<net::IOBuffer> buf_2 = new net::IOBuffer(kSize); |
1073 CacheTestFillBuffer(buf_1->data(), kSize, false); | 1073 CacheTestFillBuffer(buf_1->data(), kSize, false); |
1074 | 1074 |
1075 std::string key("the first key"); | 1075 std::string key("the first key"); |
1076 disk_cache::Entry* entry; | 1076 disk_cache::Entry* entry; |
1077 ASSERT_TRUE(cache_->CreateEntry(key, &entry)); | 1077 ASSERT_EQ(net::OK, CreateEntry(key, &entry)); |
1078 | 1078 |
1079 // This loop writes back to back starting from offset 0 and 9000. | 1079 // This loop writes back to back starting from offset 0 and 9000. |
1080 for (int i = 0; i < kSize; i += 1024) { | 1080 for (int i = 0; i < kSize; i += 1024) { |
1081 scoped_refptr<net::WrappedIOBuffer> buf_3 = | 1081 scoped_refptr<net::WrappedIOBuffer> buf_3 = |
1082 new net::WrappedIOBuffer(buf_1->data() + i); | 1082 new net::WrappedIOBuffer(buf_1->data() + i); |
1083 VerifySparseIO(entry, i, buf_3, 1024, false, buf_2); | 1083 VerifySparseIO(entry, i, buf_3, 1024, false, buf_2); |
1084 VerifySparseIO(entry, 9000 + i, buf_3, 1024, false, buf_2); | 1084 VerifySparseIO(entry, 9000 + i, buf_3, 1024, false, buf_2); |
1085 } | 1085 } |
1086 | 1086 |
1087 // Make sure we have data written. | 1087 // Make sure we have data written. |
1088 VerifyContentSparseIO(entry, 0, buf_1->data(), kSize, false); | 1088 VerifyContentSparseIO(entry, 0, buf_1->data(), kSize, false); |
1089 VerifyContentSparseIO(entry, 9000, buf_1->data(), kSize, false); | 1089 VerifyContentSparseIO(entry, 9000, buf_1->data(), kSize, false); |
1090 | 1090 |
1091 // This tests a large write that spans 3 entries from a misaligned offset. | 1091 // This tests a large write that spans 3 entries from a misaligned offset. |
1092 VerifySparseIO(entry, 20481, buf_1, 8192, false, buf_2); | 1092 VerifySparseIO(entry, 20481, buf_1, 8192, false, buf_2); |
1093 | 1093 |
1094 entry->Close(); | 1094 entry->Close(); |
1095 } | 1095 } |
1096 | 1096 |
1097 TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedGetAvailableRange) { | 1097 TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedGetAvailableRange) { |
1098 SetMemoryOnlyMode(); | 1098 SetMemoryOnlyMode(); |
1099 InitCache(); | 1099 InitCache(); |
1100 | 1100 |
1101 const int kSize = 8192; | 1101 const int kSize = 8192; |
1102 scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize); | 1102 scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize); |
1103 CacheTestFillBuffer(buf->data(), kSize, false); | 1103 CacheTestFillBuffer(buf->data(), kSize, false); |
1104 | 1104 |
1105 disk_cache::Entry* entry; | 1105 disk_cache::Entry* entry; |
1106 std::string key("the first key"); | 1106 std::string key("the first key"); |
1107 ASSERT_TRUE(cache_->CreateEntry(key, &entry)); | 1107 ASSERT_EQ(net::OK, CreateEntry(key, &entry)); |
1108 | 1108 |
1109 // Writes in the middle of an entry. | 1109 // Writes in the middle of an entry. |
1110 EXPECT_EQ(1024, entry->WriteSparseData(0, buf, 1024, NULL)); | 1110 EXPECT_EQ(1024, entry->WriteSparseData(0, buf, 1024, NULL)); |
1111 EXPECT_EQ(1024, entry->WriteSparseData(5120, buf, 1024, NULL)); | 1111 EXPECT_EQ(1024, entry->WriteSparseData(5120, buf, 1024, NULL)); |
1112 EXPECT_EQ(1024, entry->WriteSparseData(10000, buf, 1024, NULL)); | 1112 EXPECT_EQ(1024, entry->WriteSparseData(10000, buf, 1024, NULL)); |
1113 | 1113 |
1114 // Writes in the middle of an entry and spans 2 child entries. | 1114 // Writes in the middle of an entry and spans 2 child entries. |
1115 EXPECT_EQ(8192, entry->WriteSparseData(50000, buf, 8192, NULL)); | 1115 EXPECT_EQ(8192, entry->WriteSparseData(50000, buf, 8192, NULL)); |
1116 | 1116 |
1117 int64 start; | 1117 int64 start; |
(...skipping 24 matching lines...) Expand all Loading... |
1142 EXPECT_EQ(8192, entry->GetAvailableRange(40000, 20000, &start)); | 1142 EXPECT_EQ(8192, entry->GetAvailableRange(40000, 20000, &start)); |
1143 EXPECT_EQ(50000, start); | 1143 EXPECT_EQ(50000, start); |
1144 | 1144 |
1145 entry->Close(); | 1145 entry->Close(); |
1146 } | 1146 } |
1147 | 1147 |
1148 void DiskCacheEntryTest::DoomSparseEntry() { | 1148 void DiskCacheEntryTest::DoomSparseEntry() { |
1149 std::string key1("the first key"); | 1149 std::string key1("the first key"); |
1150 std::string key2("the second key"); | 1150 std::string key2("the second key"); |
1151 disk_cache::Entry *entry1, *entry2; | 1151 disk_cache::Entry *entry1, *entry2; |
1152 ASSERT_TRUE(cache_->CreateEntry(key1, &entry1)); | 1152 ASSERT_EQ(net::OK, CreateEntry(key1, &entry1)); |
1153 ASSERT_TRUE(cache_->CreateEntry(key2, &entry2)); | 1153 ASSERT_EQ(net::OK, CreateEntry(key2, &entry2)); |
1154 | 1154 |
1155 const int kSize = 4 * 1024; | 1155 const int kSize = 4 * 1024; |
1156 scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize); | 1156 scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize); |
1157 CacheTestFillBuffer(buf->data(), kSize, false); | 1157 CacheTestFillBuffer(buf->data(), kSize, false); |
1158 | 1158 |
1159 int64 offset = 1024; | 1159 int64 offset = 1024; |
1160 // Write to a bunch of ranges. | 1160 // Write to a bunch of ranges. |
1161 for (int i = 0; i < 12; i++) { | 1161 for (int i = 0; i < 12; i++) { |
1162 EXPECT_EQ(kSize, entry1->WriteSparseData(offset, buf, kSize, NULL)); | 1162 EXPECT_EQ(kSize, entry1->WriteSparseData(offset, buf, kSize, NULL)); |
1163 // Keep the second map under the default size. | 1163 // Keep the second map under the default size. |
1164 if (i < 9) | 1164 if (i < 9) |
1165 EXPECT_EQ(kSize, entry2->WriteSparseData(offset, buf, kSize, NULL)); | 1165 EXPECT_EQ(kSize, entry2->WriteSparseData(offset, buf, kSize, NULL)); |
1166 offset *= 4; | 1166 offset *= 4; |
1167 } | 1167 } |
1168 | 1168 |
1169 if (memory_only_) | 1169 if (memory_only_) |
1170 EXPECT_EQ(2, cache_->GetEntryCount()); | 1170 EXPECT_EQ(2, cache_->GetEntryCount()); |
1171 else | 1171 else |
1172 EXPECT_EQ(15, cache_->GetEntryCount()); | 1172 EXPECT_EQ(15, cache_->GetEntryCount()); |
1173 | 1173 |
1174 // Doom the first entry while it's still open. | 1174 // Doom the first entry while it's still open. |
1175 entry1->Doom(); | 1175 entry1->Doom(); |
1176 entry1->Close(); | 1176 entry1->Close(); |
1177 entry2->Close(); | 1177 entry2->Close(); |
1178 | 1178 |
1179 // Doom the second entry after it's fully saved. | 1179 // Doom the second entry after it's fully saved. |
1180 EXPECT_TRUE(cache_->DoomEntry(key2)); | 1180 EXPECT_EQ(net::OK, DoomEntry(key2)); |
1181 | 1181 |
1182 // Make sure we do all needed work. This may fail for entry2 if between Close | 1182 // Make sure we do all needed work. This may fail for entry2 if between Close |
1183 // and DoomEntry the system decides to remove all traces of the file from the | 1183 // and DoomEntry the system decides to remove all traces of the file from the |
1184 // system cache so we don't see that there is pending IO. | 1184 // system cache so we don't see that there is pending IO. |
1185 MessageLoop::current()->RunAllPending(); | 1185 MessageLoop::current()->RunAllPending(); |
1186 | 1186 |
1187 if (memory_only_) { | 1187 if (memory_only_) { |
1188 EXPECT_EQ(0, cache_->GetEntryCount()); | 1188 EXPECT_EQ(0, cache_->GetEntryCount()); |
1189 } else { | 1189 } else { |
1190 if (5 == cache_->GetEntryCount()) { | 1190 if (5 == cache_->GetEntryCount()) { |
(...skipping 14 matching lines...) Expand all Loading... |
1205 | 1205 |
1206 TEST_F(DiskCacheEntryTest, MemoryOnlyDoomSparseEntry) { | 1206 TEST_F(DiskCacheEntryTest, MemoryOnlyDoomSparseEntry) { |
1207 SetMemoryOnlyMode(); | 1207 SetMemoryOnlyMode(); |
1208 InitCache(); | 1208 InitCache(); |
1209 DoomSparseEntry(); | 1209 DoomSparseEntry(); |
1210 } | 1210 } |
1211 | 1211 |
1212 void DiskCacheEntryTest::PartialSparseEntry() { | 1212 void DiskCacheEntryTest::PartialSparseEntry() { |
1213 std::string key("the first key"); | 1213 std::string key("the first key"); |
1214 disk_cache::Entry* entry; | 1214 disk_cache::Entry* entry; |
1215 ASSERT_TRUE(cache_->CreateEntry(key, &entry)); | 1215 ASSERT_EQ(net::OK, CreateEntry(key, &entry)); |
1216 | 1216 |
1217 // We should be able to deal with IO that is not aligned to the block size | 1217 // We should be able to deal with IO that is not aligned to the block size |
1218 // of a sparse entry, at least to write a big range without leaving holes. | 1218 // of a sparse entry, at least to write a big range without leaving holes. |
1219 const int kSize = 4 * 1024; | 1219 const int kSize = 4 * 1024; |
1220 const int kSmallSize = 128; | 1220 const int kSmallSize = 128; |
1221 scoped_refptr<net::IOBuffer> buf1 = new net::IOBuffer(kSize); | 1221 scoped_refptr<net::IOBuffer> buf1 = new net::IOBuffer(kSize); |
1222 CacheTestFillBuffer(buf1->data(), kSize, false); | 1222 CacheTestFillBuffer(buf1->data(), kSize, false); |
1223 | 1223 |
1224 // The first write is just to extend the entry. The third write occupies | 1224 // The first write is just to extend the entry. The third write occupies |
1225 // a 1KB block partially, it may not be written internally depending on the | 1225 // a 1KB block partially, it may not be written internally depending on the |
1226 // implementation. | 1226 // implementation. |
1227 EXPECT_EQ(kSize, entry->WriteSparseData(20000, buf1, kSize, NULL)); | 1227 EXPECT_EQ(kSize, entry->WriteSparseData(20000, buf1, kSize, NULL)); |
1228 EXPECT_EQ(kSize, entry->WriteSparseData(500, buf1, kSize, NULL)); | 1228 EXPECT_EQ(kSize, entry->WriteSparseData(500, buf1, kSize, NULL)); |
1229 EXPECT_EQ(kSmallSize, | 1229 EXPECT_EQ(kSmallSize, |
1230 entry->WriteSparseData(1080321, buf1, kSmallSize, NULL)); | 1230 entry->WriteSparseData(1080321, buf1, kSmallSize, NULL)); |
1231 entry->Close(); | 1231 entry->Close(); |
1232 ASSERT_TRUE(cache_->OpenEntry(key, &entry)); | 1232 ASSERT_EQ(net::OK, OpenEntry(key, &entry)); |
1233 | 1233 |
1234 scoped_refptr<net::IOBuffer> buf2 = new net::IOBuffer(kSize); | 1234 scoped_refptr<net::IOBuffer> buf2 = new net::IOBuffer(kSize); |
1235 memset(buf2->data(), 0, kSize); | 1235 memset(buf2->data(), 0, kSize); |
1236 EXPECT_EQ(0, entry->ReadSparseData(8000, buf2, kSize, NULL)); | 1236 EXPECT_EQ(0, entry->ReadSparseData(8000, buf2, kSize, NULL)); |
1237 | 1237 |
1238 EXPECT_EQ(500, entry->ReadSparseData(kSize, buf2, kSize, NULL)); | 1238 EXPECT_EQ(500, entry->ReadSparseData(kSize, buf2, kSize, NULL)); |
1239 EXPECT_EQ(0, memcmp(buf2->data(), buf1->data() + kSize - 500, 500)); | 1239 EXPECT_EQ(0, memcmp(buf2->data(), buf1->data() + kSize - 500, 500)); |
1240 EXPECT_EQ(0, entry->ReadSparseData(0, buf2, kSize, NULL)); | 1240 EXPECT_EQ(0, entry->ReadSparseData(0, buf2, kSize, NULL)); |
1241 | 1241 |
1242 // This read should not change anything. | 1242 // This read should not change anything. |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1287 InitCache(); | 1287 InitCache(); |
1288 PartialSparseEntry(); | 1288 PartialSparseEntry(); |
1289 } | 1289 } |
1290 | 1290 |
1291 TEST_F(DiskCacheEntryTest, MemoryPartialSparseEntry) { | 1291 TEST_F(DiskCacheEntryTest, MemoryPartialSparseEntry) { |
1292 SetMemoryOnlyMode(); | 1292 SetMemoryOnlyMode(); |
1293 InitCache(); | 1293 InitCache(); |
1294 PartialSparseEntry(); | 1294 PartialSparseEntry(); |
1295 } | 1295 } |
1296 | 1296 |
| 1297 // Tests that corrupt sparse children are removed automatically. |
1297 TEST_F(DiskCacheEntryTest, CleanupSparseEntry) { | 1298 TEST_F(DiskCacheEntryTest, CleanupSparseEntry) { |
1298 InitCache(); | 1299 InitCache(); |
1299 std::string key("the first key"); | 1300 std::string key("the first key"); |
1300 disk_cache::Entry* entry; | 1301 disk_cache::Entry* entry; |
1301 ASSERT_TRUE(cache_->CreateEntry(key, &entry)); | 1302 ASSERT_EQ(net::OK, CreateEntry(key, &entry)); |
1302 | 1303 |
1303 // Corrupt sparse children should be removed automatically. | |
1304 const int kSize = 4 * 1024; | 1304 const int kSize = 4 * 1024; |
1305 scoped_refptr<net::IOBuffer> buf1 = new net::IOBuffer(kSize); | 1305 scoped_refptr<net::IOBuffer> buf1 = new net::IOBuffer(kSize); |
1306 CacheTestFillBuffer(buf1->data(), kSize, false); | 1306 CacheTestFillBuffer(buf1->data(), kSize, false); |
1307 | 1307 |
1308 const int k1Meg = 1024 * 1024; | 1308 const int k1Meg = 1024 * 1024; |
1309 EXPECT_EQ(kSize, entry->WriteSparseData(8192, buf1, kSize, NULL)); | 1309 EXPECT_EQ(kSize, entry->WriteSparseData(8192, buf1, kSize, NULL)); |
1310 EXPECT_EQ(kSize, entry->WriteSparseData(k1Meg + 8192, buf1, kSize, NULL)); | 1310 EXPECT_EQ(kSize, entry->WriteSparseData(k1Meg + 8192, buf1, kSize, NULL)); |
1311 EXPECT_EQ(kSize, entry->WriteSparseData(2 * k1Meg + 8192, buf1, kSize, NULL)); | 1311 EXPECT_EQ(kSize, entry->WriteSparseData(2 * k1Meg + 8192, buf1, kSize, NULL)); |
1312 entry->Close(); | 1312 entry->Close(); |
1313 EXPECT_EQ(4, cache_->GetEntryCount()); | 1313 EXPECT_EQ(4, cache_->GetEntryCount()); |
1314 | 1314 |
1315 void* iter = NULL; | 1315 void* iter = NULL; |
1316 int count = 0; | 1316 int count = 0; |
1317 std::string child_key[2]; | 1317 std::string child_key[2]; |
1318 while (cache_->OpenNextEntry(&iter, &entry)) { | 1318 while (OpenNextEntry(&iter, &entry) == net::OK) { |
1319 ASSERT_TRUE(entry != NULL); | 1319 ASSERT_TRUE(entry != NULL); |
1320 // Writing to an entry will alter the LRU list and invalidate the iterator. | 1320 // Writing to an entry will alter the LRU list and invalidate the iterator. |
1321 if (entry->GetKey() != key && count < 2) | 1321 if (entry->GetKey() != key && count < 2) |
1322 child_key[count++] = entry->GetKey(); | 1322 child_key[count++] = entry->GetKey(); |
1323 entry->Close(); | 1323 entry->Close(); |
1324 } | 1324 } |
1325 for (int i = 0; i < 2; i++) { | 1325 for (int i = 0; i < 2; i++) { |
1326 ASSERT_TRUE(cache_->OpenEntry(child_key[i], &entry)); | 1326 ASSERT_EQ(net::OK, OpenEntry(child_key[i], &entry)); |
1327 // Overwrite the header's magic and signature. | 1327 // Overwrite the header's magic and signature. |
1328 EXPECT_EQ(12, entry->WriteData(2, 0, buf1, 12, NULL, false)); | 1328 EXPECT_EQ(12, entry->WriteData(2, 0, buf1, 12, NULL, false)); |
1329 entry->Close(); | 1329 entry->Close(); |
1330 } | 1330 } |
1331 | 1331 |
1332 EXPECT_EQ(4, cache_->GetEntryCount()); | 1332 EXPECT_EQ(4, cache_->GetEntryCount()); |
1333 ASSERT_TRUE(cache_->OpenEntry(key, &entry)); | 1333 ASSERT_EQ(net::OK, OpenEntry(key, &entry)); |
1334 | 1334 |
1335 // Two children should be gone. One while reading and one while writing. | 1335 // Two children should be gone. One while reading and one while writing. |
1336 EXPECT_EQ(0, entry->ReadSparseData(2 * k1Meg + 8192, buf1, kSize, NULL)); | 1336 EXPECT_EQ(0, entry->ReadSparseData(2 * k1Meg + 8192, buf1, kSize, NULL)); |
1337 EXPECT_EQ(kSize, entry->WriteSparseData(k1Meg + 16384, buf1, kSize, NULL)); | 1337 EXPECT_EQ(kSize, entry->WriteSparseData(k1Meg + 16384, buf1, kSize, NULL)); |
1338 EXPECT_EQ(0, entry->ReadSparseData(k1Meg + 8192, buf1, kSize, NULL)); | 1338 EXPECT_EQ(0, entry->ReadSparseData(k1Meg + 8192, buf1, kSize, NULL)); |
1339 | 1339 |
1340 // We never touched this one. | 1340 // We never touched this one. |
1341 EXPECT_EQ(kSize, entry->ReadSparseData(8192, buf1, kSize, NULL)); | 1341 EXPECT_EQ(kSize, entry->ReadSparseData(8192, buf1, kSize, NULL)); |
1342 entry->Close(); | 1342 entry->Close(); |
1343 | 1343 |
1344 // We re-created one of the corrupt children. | 1344 // We re-created one of the corrupt children. |
1345 EXPECT_EQ(3, cache_->GetEntryCount()); | 1345 EXPECT_EQ(3, cache_->GetEntryCount()); |
1346 } | 1346 } |
1347 | 1347 |
1348 TEST_F(DiskCacheEntryTest, CancelSparseIO) { | 1348 TEST_F(DiskCacheEntryTest, CancelSparseIO) { |
1349 InitCache(); | 1349 InitCache(); |
1350 std::string key("the first key"); | 1350 std::string key("the first key"); |
1351 disk_cache::Entry* entry; | 1351 disk_cache::Entry* entry; |
1352 ASSERT_TRUE(cache_->CreateEntry(key, &entry)); | 1352 ASSERT_EQ(net::OK, CreateEntry(key, &entry)); |
1353 | 1353 |
1354 const int kSize = 40 * 1024; | 1354 const int kSize = 40 * 1024; |
1355 scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize); | 1355 scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize); |
1356 CacheTestFillBuffer(buf->data(), kSize, false); | 1356 CacheTestFillBuffer(buf->data(), kSize, false); |
1357 | 1357 |
1358 TestCompletionCallback cb1, cb2, cb3, cb4; | 1358 TestCompletionCallback cb1, cb2, cb3, cb4; |
1359 int64 offset = 0; | 1359 int64 offset = 0; |
1360 int tries = 0; | 1360 int tries = 0; |
1361 const int maxtries = 100; // Avoid hang on infinitely fast disks | 1361 const int maxtries = 100; // Avoid hang on infinitely fast disks. |
1362 for (int ret = 0; ret != net::ERR_IO_PENDING; offset += kSize * 4) { | 1362 for (int ret = 0; ret != net::ERR_IO_PENDING; offset += kSize * 4) { |
1363 ret = entry->WriteSparseData(offset, buf, kSize, &cb1); | 1363 ret = entry->WriteSparseData(offset, buf, kSize, &cb1); |
1364 if (++tries > maxtries) { | 1364 if (++tries > maxtries) { |
1365 LOG(ERROR) << "Data writes never come back PENDING; skipping test"; | 1365 LOG(ERROR) << "Data writes never come back PENDING; skipping test"; |
1366 entry->Close(); | 1366 entry->Close(); |
1367 return; | 1367 return; |
1368 } | 1368 } |
1369 } | 1369 } |
1370 | 1370 |
1371 // Cannot use the entry at this point. | 1371 // Cannot use the entry at this point. |
(...skipping 20 matching lines...) Expand all Loading... |
1392 // Now see if we receive all notifications. | 1392 // Now see if we receive all notifications. |
1393 EXPECT_EQ(kSize, cb1.GetResult(net::ERR_IO_PENDING)); | 1393 EXPECT_EQ(kSize, cb1.GetResult(net::ERR_IO_PENDING)); |
1394 EXPECT_EQ(net::OK, cb2.GetResult(net::ERR_IO_PENDING)); | 1394 EXPECT_EQ(net::OK, cb2.GetResult(net::ERR_IO_PENDING)); |
1395 EXPECT_EQ(net::OK, cb3.GetResult(net::ERR_IO_PENDING)); | 1395 EXPECT_EQ(net::OK, cb3.GetResult(net::ERR_IO_PENDING)); |
1396 EXPECT_EQ(net::OK, cb4.GetResult(net::ERR_IO_PENDING)); | 1396 EXPECT_EQ(net::OK, cb4.GetResult(net::ERR_IO_PENDING)); |
1397 | 1397 |
1398 EXPECT_EQ(kSize, entry->GetAvailableRange(offset, kSize, &offset)); | 1398 EXPECT_EQ(kSize, entry->GetAvailableRange(offset, kSize, &offset)); |
1399 EXPECT_EQ(net::OK, entry->ReadyForSparseIO(&cb2)); | 1399 EXPECT_EQ(net::OK, entry->ReadyForSparseIO(&cb2)); |
1400 entry->Close(); | 1400 entry->Close(); |
1401 } | 1401 } |
OLD | NEW |