Lines Matching refs:entry
27 void InternalSyncIOBackground(disk_cache::Entry* entry);
28 void ExternalSyncIOBackground(disk_cache::Entry* entry);
59 SyncIOTask(DiskCacheEntryTest* test, disk_cache::Entry* entry)
60 : test_(test), entry_(entry) {}
64 disk_cache::Entry* entry_;
69 InternalSyncIOTask(DiskCacheEntryTest* test, disk_cache::Entry* entry)
70 : SyncIOTask(test, entry) {}
78 void DiskCacheEntryTest::InternalSyncIOBackground(disk_cache::Entry* entry) {
82 EXPECT_EQ(0, entry->ReadData(0, 0, buffer1, kSize1, NULL));
84 EXPECT_EQ(10, entry->WriteData(0, 0, buffer1, kSize1, NULL, false));
86 EXPECT_EQ(10, entry->ReadData(0, 0, buffer1, kSize1, NULL));
96 EXPECT_EQ(5000, entry->WriteData(1, 1500, buffer2, kSize2, NULL, false));
98 EXPECT_EQ(4989, entry->ReadData(1, 1511, buffer2, kSize2, NULL));
100 EXPECT_EQ(5000, entry->ReadData(1, 0, buffer2, kSize2, NULL));
102 EXPECT_EQ(1500, entry->ReadData(1, 5000, buffer2, kSize2, NULL));
104 EXPECT_EQ(0, entry->ReadData(1, 6500, buffer2, kSize2, NULL));
105 EXPECT_EQ(6500, entry->ReadData(1, 0, buffer3, kSize3, NULL));
106 EXPECT_EQ(8192, entry->WriteData(1, 0, buffer3, 8192, NULL, false));
107 EXPECT_EQ(8192, entry->ReadData(1, 0, buffer3, kSize3, NULL));
108 EXPECT_EQ(8192, entry->GetDataSize(1));
111 EXPECT_EQ(0, entry->WriteData(0, 0, NULL, 0, NULL, true));
112 EXPECT_EQ(0, entry->WriteData(1, 0, NULL, 0, NULL, true));
120 disk_cache::Entry* entry = NULL;
121 ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
122 ASSERT_TRUE(NULL != entry);
125 RunTaskForTest(new InternalSyncIOTask(this, entry));
127 entry->Doom();
128 entry->Close();
146 disk_cache::Entry* entry = NULL;
147 ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
148 ASSERT_TRUE(NULL != entry);
151 // the entry and close it so that we flush the internal buffer to disk. After
153 // the content, so just extending the entry is enough (all extensions zero-
155 EXPECT_EQ(0, WriteData(entry, 0, 15 * 1024, NULL, 0, false));
156 EXPECT_EQ(0, WriteData(entry, 1, 15 * 1024, NULL, 0, false));
157 entry->Close();
158 ASSERT_EQ(net::OK, OpenEntry("the first key", &entry));
190 EXPECT_EQ(0, entry->ReadData(0, 15 * 1024, buffer1, kSize1, &callback1));
193 int ret = entry->WriteData(0, 0, buffer1, kSize1, &callback2, false);
200 ret = entry->ReadData(0, 0, buffer2, kSize1, &callback3);
209 ret = entry->WriteData(1, 1500, buffer2, kSize2, &callback4, true);
216 ret = entry->ReadData(1, 1511, buffer3, kSize2, &callback5);
223 ret = entry->ReadData(1, 0, buffer2, kSize2, &callback6);
232 ret = entry->ReadData(1, 5000, buffer2, kSize2, &callback7);
237 ret = entry->ReadData(1, 0, buffer3, kSize3, &callback9);
242 ret = entry->WriteData(1, 0, buffer3, 8192, &callback10, true);
248 ret = entry->ReadData(1, 0, buffer3, kSize3, &callback11);
253 EXPECT_EQ(8192, entry->GetDataSize(1));
255 ret = entry->ReadData(0, 0, buffer1, kSize1, &callback12);
260 ret = entry->ReadData(1, 0, buffer2, kSize2, &callback13);
270 entry->Doom();
271 entry->Close();
290 ExternalSyncIOTask(DiskCacheEntryTest* test, disk_cache::Entry* entry)
291 : SyncIOTask(test, entry) {}
299 void DiskCacheEntryTest::ExternalSyncIOBackground(disk_cache::Entry* entry) {
307 EXPECT_EQ(17000, entry->WriteData(0, 0, buffer1, kSize1, NULL, false));
309 EXPECT_EQ(17000, entry->ReadData(0, 0, buffer1, kSize1, NULL));
313 EXPECT_EQ(25000, entry->WriteData(1, 10000, buffer2, kSize2, NULL, false));
315 EXPECT_EQ(24989, entry->ReadData(1, 10011, buffer2, kSize2, NULL));
317 EXPECT_EQ(25000, entry->ReadData(1, 0, buffer2, kSize2, NULL));
319 EXPECT_EQ(5000, entry->ReadData(1, 30000, buffer2, kSize2, NULL));
321 EXPECT_EQ(0, entry->ReadData(1, 35000, buffer2, kSize2, NULL));
322 EXPECT_EQ(17000, entry->ReadData(1, 0, buffer1, kSize1, NULL));
323 EXPECT_EQ(17000, entry->WriteData(1, 20000, buffer1, kSize1, NULL, false));
324 EXPECT_EQ(37000, entry->GetDataSize(1));
327 EXPECT_EQ(0, entry->WriteData(0, 0, NULL, 0, NULL, true));
328 EXPECT_EQ(0, entry->WriteData(1, 0, NULL, 0, NULL, true));
332 disk_cache::Entry* entry;
333 ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
336 RunTaskForTest(new ExternalSyncIOTask(this, entry));
338 entry->Doom();
339 entry->Close();
364 disk_cache::Entry* entry;
365 ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
394 int ret = entry->WriteData(0, 0, buffer1, kSize1, &callback1, false);
402 ret = entry->ReadData(0, 0, buffer2, kSize1, &callback2);
411 ret = entry->WriteData(1, 10000, buffer2, kSize2, &callback3, false);
419 ret = entry->ReadData(1, 10011, buffer3, kSize3, &callback4);
426 ret = entry->ReadData(1, 0, buffer2, kSize2, &callback5);
433 ret = entry->ReadData(1, 30000, buffer2, kSize2, &callback6);
438 EXPECT_EQ(0, entry->ReadData(1, 35000, buffer2, kSize2, &callback7));
439 ret = entry->ReadData(1, 0, buffer1, kSize1, &callback8);
443 ret = entry->WriteData(1, 20000, buffer1, kSize1, &callback9, false);
449 EXPECT_EQ(37000, entry->GetDataSize(1));
454 entry->Doom();
455 entry->Close();
480 disk_cache::Entry* entry = NULL;
481 ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
482 ASSERT_TRUE(NULL != entry);
491 EXPECT_EQ(kBufferSize, WriteData(entry, i, 0, buffer1, kBufferSize, false));
493 EXPECT_EQ(kBufferSize, ReadData(entry, i, 0, buffer2, kBufferSize));
498 ReadData(entry, kNumStreams, 0, buffer1, kBufferSize));
499 entry->Close();
515 disk_cache::Entry* entry;
516 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
517 EXPECT_EQ(key, entry->GetKey()) << "short key";
518 entry->Close();
528 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
529 EXPECT_TRUE(key == entry->GetKey()) << "1000 bytes key";
530 entry->Close();
535 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
536 EXPECT_TRUE(key == entry->GetKey()) << "medium size key";
537 entry->Close();
543 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
544 EXPECT_TRUE(key == entry->GetKey()) << "long key";
545 entry->Close();
561 disk_cache::Entry* entry;
564 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
565 EXPECT_TRUE(entry->GetLastModified() >= t1);
566 EXPECT_TRUE(entry->GetLastModified() == entry->GetLastUsed());
571 EXPECT_EQ(0, WriteData(entry, 0, 200, NULL, 0, false));
573 EXPECT_TRUE(entry->GetLastModified() < t2);
575 EXPECT_TRUE(entry->GetLastModified() >= t2);
577 EXPECT_TRUE(entry->GetLastModified() == entry->GetLastUsed());
584 EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer, kSize));
586 EXPECT_TRUE(entry->GetLastUsed() < t2);
587 EXPECT_TRUE(entry->GetLastModified() < t2);
589 EXPECT_TRUE(entry->GetLastUsed() >= t3);
590 EXPECT_TRUE(entry->GetLastModified() < t3);
592 entry->Close();
614 disk_cache::Entry* entry;
615 ASSERT_EQ(net::OK, CreateEntry(key1, &entry));
624 EXPECT_EQ(10, WriteData(entry, 0, 0, buffer1, 10, false));
625 EXPECT_EQ(10, ReadData(entry, 0, 0, buffer2, 10));
627 EXPECT_EQ(10, entry->GetDataSize(0));
629 EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1, 2000, false));
630 EXPECT_EQ(2000, entry->GetDataSize(0));
631 EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2, 2000));
634 EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1, kSize, false));
635 EXPECT_EQ(20000, entry->GetDataSize(0));
636 EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2, kSize));
638 entry->Close();
642 ASSERT_EQ(net::OK, CreateEntry(key2, &entry));
643 EXPECT_EQ(10, WriteData(entry, 0, 0, buffer1, 10, false));
644 EXPECT_EQ(10, entry->GetDataSize(0));
645 entry->Close();
648 ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
649 EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1, 2000, false));
650 EXPECT_EQ(2000, entry->GetDataSize(0));
651 EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2, 2000));
653 entry->Close();
657 ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
658 EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1, kSize, false));
659 EXPECT_EQ(20000, entry->GetDataSize(0));
660 EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2, kSize));
662 entry->Close();
665 ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
666 EXPECT_EQ(20000, entry->GetDataSize(0));
668 // Now extend the entry without actual data.
669 EXPECT_EQ(0, WriteData(entry, 0, 45500, buffer1, 0, false));
670 entry->Close();
673 ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
674 EXPECT_EQ(45500, entry->GetDataSize(0));
675 entry->Close();
698 disk_cache::Entry* entry;
699 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
710 EXPECT_EQ(200, WriteData(entry, 0, 0, buffer1, 200, false));
711 EXPECT_EQ(200, entry->GetDataSize(0));
712 EXPECT_EQ(100, WriteData(entry, 0, 0, buffer1, 100, false));
713 EXPECT_EQ(200, entry->GetDataSize(0));
714 EXPECT_EQ(100, WriteData(entry, 0, 0, buffer1, 100, true));
715 EXPECT_EQ(100, entry->GetDataSize(0));
716 EXPECT_EQ(0, WriteData(entry, 0, 50, buffer1, 0, true));
717 EXPECT_EQ(50, entry->GetDataSize(0));
718 EXPECT_EQ(0, WriteData(entry, 0, 0, buffer1, 0, true));
719 EXPECT_EQ(0, entry->GetDataSize(0));
720 entry->Close();
721 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
724 EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1, 20000, true));
725 EXPECT_EQ(20000, entry->GetDataSize(0));
726 EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2, 20000));
731 EXPECT_EQ(18000, WriteData(entry, 0, 0, buffer1, 18000, false));
732 EXPECT_EQ(20000, entry->GetDataSize(0));
733 EXPECT_EQ(18000, WriteData(entry, 0, 0, buffer1, 18000, true));
734 EXPECT_EQ(18000, entry->GetDataSize(0));
735 EXPECT_EQ(0, WriteData(entry, 0, 17500, buffer1, 0, true));
736 EXPECT_EQ(17500, entry->GetDataSize(0));
739 EXPECT_EQ(600, WriteData(entry, 0, 1000, buffer1, 600, true));
740 EXPECT_EQ(1600, entry->GetDataSize(0));
741 EXPECT_EQ(600, ReadData(entry, 0, 1000, buffer2, 600));
743 EXPECT_EQ(1000, ReadData(entry, 0, 0, buffer2, 1000));
748 EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1, 20000, true));
749 EXPECT_EQ(20000, entry->GetDataSize(0));
750 EXPECT_EQ(0, WriteData(entry, 0, 0, buffer1, 0, true));
751 EXPECT_EQ(0, entry->GetDataSize(0));
753 entry->Close();
776 disk_cache::Entry* entry;
777 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
779 EXPECT_EQ(0, ReadData(entry, 0, 0, NULL, 0));
780 EXPECT_EQ(0, WriteData(entry, 0, 0, NULL, 0, false));
782 // This write should extend the entry.
783 EXPECT_EQ(0, WriteData(entry, 0, 1000, NULL, 0, false));
784 EXPECT_EQ(0, ReadData(entry, 0, 500, NULL, 0));
785 EXPECT_EQ(0, ReadData(entry, 0, 2000, NULL, 0));
786 EXPECT_EQ(1000, entry->GetDataSize(0));
788 EXPECT_EQ(0, WriteData(entry, 0, 100000, NULL, 0, true));
789 EXPECT_EQ(0, ReadData(entry, 0, 50000, NULL, 0));
790 EXPECT_EQ(100000, entry->GetDataSize(0));
798 EXPECT_EQ(kSize, ReadData(entry, 0, 500, buffer, kSize));
802 EXPECT_EQ(kSize, ReadData(entry, 0, 5000, buffer, kSize));
806 EXPECT_EQ(kSize, ReadData(entry, 0, 50000, buffer, kSize));
809 entry->Close();
833 disk_cache::Entry* entry;
834 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
842 EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1, kSize, false));
843 entry->Close();
846 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
847 EXPECT_EQ(kSize, WriteData(entry, 1, 5000, buffer1, kSize, false));
848 EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2, kSize));
852 EXPECT_EQ(kSize, WriteData(entry, 1, 18000, buffer1, kSize, false));
853 entry->Close();
856 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
857 EXPECT_EQ(kSize, WriteData(entry, 1, 10000, buffer1, kSize, false));
859 EXPECT_EQ(kSize, ReadData(entry, 1, 5000, buffer2, kSize));
862 EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2, kSize));
865 EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2, kSize));
869 EXPECT_EQ(kSize, WriteData(entry, 1, 23000, buffer1, kSize, false));
870 entry->Close();
873 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
874 EXPECT_EQ(kSize, WriteData(entry, 1, 17000, buffer1, kSize, false));
877 EXPECT_EQ(kSize, WriteData(entry, 1, 19000, buffer1, kSize, false));
879 EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2, kSize));
882 EXPECT_EQ(kSize, ReadData(entry, 1, 17000, buffer2, kSize));
885 EXPECT_EQ(kSize, WriteData(entry, 1, 22900, buffer1, kSize, false));
887 EXPECT_EQ(100, ReadData(entry, 1, 23000, buffer2, kSize));
891 EXPECT_EQ(100, ReadData(entry, 1, 23100, buffer2, kSize));
894 // Extend the file again and read before without closing the entry.
895 EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1, kSize, false));
896 EXPECT_EQ(kSize, WriteData(entry, 1, 45000, buffer1, kSize, false));
898 EXPECT_EQ(kSize, ReadData(entry, 1, 25000, buffer2, kSize));
901 EXPECT_EQ(kSize, ReadData(entry, 1, 45000, buffer2, kSize));
904 entry->Close();
920 // the entry size.
923 disk_cache::Entry* entry;
924 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
933 EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1, kSize, true));
934 EXPECT_EQ(kSize, WriteData(entry, 1, 17000, buffer1, kSize, true));
935 EXPECT_EQ(kSize, WriteData(entry, 1, 23000, buffer1, kSize, true));
936 entry->Close();
939 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
940 EXPECT_EQ(23000 + kSize, entry->GetDataSize(1));
941 EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1, kSize, true));
942 EXPECT_EQ(25000 + kSize, entry->GetDataSize(1));
943 EXPECT_EQ(kSize, ReadData(entry, 1, 24000, buffer2, kSize));
947 EXPECT_EQ(kSize, ReadData(entry, 1, 23000 + kSize - 35, buffer2, kSize));
952 EXPECT_EQ(kSize, ReadData(entry, 1, 24900, buffer2, kSize));
956 entry a little more.
957 EXPECT_EQ(kSize, WriteData(entry, 1, 26000, buffer1, kSize, true));
958 EXPECT_EQ(26000 + kSize, entry->GetDataSize(1));
960 EXPECT_EQ(kSize, ReadData(entry, 1, 25900, buffer2, kSize));
965 EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1, kSize, true));
966 EXPECT_EQ(25000 + kSize, entry->GetDataSize(1));
967 EXPECT_EQ(28, ReadData(entry, 1, 25000 + kSize - 28, buffer2, kSize));
971 EXPECT_EQ(kSize, WriteData(entry, 1, 24000, buffer1, kSize, false));
972 EXPECT_EQ(25000 + kSize, entry->GetDataSize(1));
973 EXPECT_EQ(kSize, WriteData(entry, 1, 24500, buffer1, kSize, true));
974 EXPECT_EQ(24500 + kSize, entry->GetDataSize(1));
975 EXPECT_EQ(kSize, ReadData(entry, 1, 23900, buffer2, kSize));
980 EXPECT_EQ(kSize, WriteData(entry, 1, 19000, buffer1, kSize, true));
981 EXPECT_EQ(19000 + kSize, entry->GetDataSize(1));
982 EXPECT_EQ(kSize, ReadData(entry, 1, 18900, buffer2, kSize));
987 entry->Close();
988 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
989 EXPECT_EQ(19000 + kSize, entry->GetDataSize(1));
991 entry->Close();
1006 // Write more than the total cache capacity but to a single entry. |size| is the
1010 disk_cache::Entry* entry;
1011 ASSERT_EQ(net::OK, CreateEntry(key1, &entry));
1013 entry->Close();
1015 ASSERT_EQ(net::OK, CreateEntry(key2, &entry));
1021 EXPECT_EQ(0, WriteData(entry, 0, 0, buffer, 0, true));
1022 EXPECT_EQ(size, WriteData(entry, 0, 0, buffer, size, false));
1023 entry->Close();
1024 ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
1027 entry->Close();
1028 ASSERT_EQ(net::OK, OpenEntry(key1, &entry)) << "have not evicted this entry";
1029 entry->Close();
1065 disk_cache::Entry* entry;
1066 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1079 EXPECT_EQ(200, WriteData(entry, 0, 400, buffer1, 200, false));
1080 EXPECT_EQ(600, entry->GetDataSize(0));
1081 EXPECT_EQ(100, ReadData(entry, 0, 300, buffer3, 100));
1083 entry->Close();
1084 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1086 // The entry is now on disk. Load it and extend it.
1087 EXPECT_EQ(200, WriteData(entry, 0, 800, buffer1, 200, false));
1088 EXPECT_EQ(1000, entry->GetDataSize(0));
1089 EXPECT_EQ(100, ReadData(entry, 0, 700, buffer3, 100));
1091 entry->Close();
1092 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1095 EXPECT_EQ(200, WriteData(entry, 0, 1800, buffer1, 200, true));
1096 EXPECT_EQ(2000, entry->GetDataSize(0));
1097 EXPECT_EQ(100, ReadData(entry, 0, 1500, buffer3, 100));
1101 EXPECT_EQ(200, WriteData(entry, 0, 19800, buffer1, 200, false));
1102 EXPECT_EQ(20000, entry->GetDataSize(0));
1103 EXPECT_EQ(4000, ReadData(entry, 0, 14000, buffer3, 4000));
1107 EXPECT_EQ(600, WriteData(entry, 0, 1000, buffer1, 600, true));
1108 EXPECT_EQ(1600, entry->GetDataSize(0));
1109 EXPECT_EQ(600, ReadData(entry, 0, 1000, buffer3, 600));
1113 EXPECT_EQ(600, WriteData(entry, 0, 2000, buffer1, 600, false));
1114 EXPECT_EQ(2600, entry->GetDataSize(0));
1115 EXPECT_EQ(200, ReadData(entry, 0, 1800, buffer3, 200));
1119 EXPECT_EQ(600, WriteData(entry, 0, 3000, buffer1, 600, true));
1120 EXPECT_EQ(3600, entry->GetDataSize(0));
1121 EXPECT_EQ(200, ReadData(entry, 0, 2800, buffer3, 200));
1124 entry->Close();
1149 disk_cache::Entry* entry;
1150 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1158 entry->WriteData(0, 0, buffer, kSize, &cb, false));
1168 EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadData(0, 0, buffer, kSize, &cb));
1172 entry->Close();
1177 disk_cache::Entry* entry;
1178 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1179 entry->Doom();
1180 entry->Close();
1188 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1189 EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer, kSize, false));
1190 EXPECT_EQ(20000, WriteData(entry, 1, 0, buffer, kSize, false));
1191 entry->Doom();
1192 entry->Close();
1213 disk_cache::Entry* entry;
1214 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1215 entry->Doom();
1229 EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1, 2000, false));
1230 EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2, 2000));
1232 EXPECT_EQ(key, entry->GetKey());
1233 EXPECT_TRUE(initial < entry->GetLastModified());
1234 EXPECT_TRUE(initial < entry->GetLastUsed());
1236 entry->Close();
1262 disk_cache::Entry* parent_entry;
1265 // Writes to the parent entry.
1268 // This write creates a child entry and writes to it.
1275 disk_cache::Entry* entry = NULL;
1277 while (OpenNextEntry(&iter, &entry) == net::OK) {
1278 ASSERT_TRUE(entry != NULL);
1281 reinterpret_cast<disk_cache::MemEntryImpl*>(entry);
1289 void VerifySparseIO(disk_cache::Entry* entry, int64 offset,
1294 int ret = entry->ReadSparseData(offset, buf_2, size, &cb);
1297 ret = entry->WriteSparseData(offset, buf_1, size, &cb);
1300 ret = entry->ReadSparseData(offset, buf_2, size, &cb);
1306 // Reads |size| bytes from |entry| at |offset| and verifies that they are the
1308 void VerifyContentSparseIO(disk_cache::Entry* entry, int64 offset, char* buffer,
1314 int ret = entry->ReadSparseData(offset, buf_1, size, &cb);
1322 disk_cache::Entry* entry;
1323 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1331 VerifySparseIO(entry, 0, buf_1, kSize, buf_2);
1334 VerifySparseIO(entry, 0x400000, buf_1, kSize, buf_2);
1337 VerifySparseIO(entry, 0x800000000LL, buf_1, kSize, buf_2);
1339 entry->Close();
1342 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1343 VerifyContentSparseIO(entry, 0, buf_1->data(), kSize);
1344 VerifyContentSparseIO(entry, 0x400000, buf_1->data(), kSize);
1345 VerifyContentSparseIO(entry, 0x800000000LL, buf_1->data(), kSize);
1346 entry->Close();
1362 disk_cache::Entry* entry;
1363 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1372 VerifySparseIO(entry, 0x20F0000, buf_1, kSize, buf_2);
1373 entry->Close();
1376 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1377 VerifyContentSparseIO(entry, 0x20F0000, buf_1->data(), kSize);
1378 entry->Close();
1394 disk_cache::Entry* entry;
1395 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1402 EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf, kSize));
1403 EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F4400, buf, kSize));
1408 int rv = entry->GetAvailableRange(0x20F0000, kSize * 2, &start, &cb);
1413 rv = entry->GetAvailableRange(0, kSize, &start, &cb);
1415 rv = entry->GetAvailableRange(0x20F0000 - kSize, kSize, &start, &cb);
1417 rv = entry->GetAvailableRange(0, 0x2100000, &start, &cb);
1423 rv = entry->GetAvailableRange(0x2100000, kSize, &start, &cb);
1425 rv = entry->ReadSparseData(start, buf, kSize, &cb);
1429 rv = entry->GetAvailableRange(0x20F2000, kSize, &start, &cb);
1432 EXPECT_EQ(0x2000, ReadSparseData(entry, start, buf, kSize));
1436 rv = entry->GetAvailableRange(0x20F0001 - kSize, kSize, &start, &cb);
1440 entry->Close();
1456 disk_cache::Entry* entry;
1457 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1464 EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf, kSize));
1466 EXPECT_TRUE(entry->CouldBeSparse());
1467 entry->Close();
1469 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1470 EXPECT_TRUE(entry->CouldBeSparse());
1471 entry->Close();
1473 // Now verify a regular entry.
1475 entry));
1476 EXPECT_FALSE(entry->CouldBeSparse());
1478 EXPECT_EQ(kSize, WriteData(entry, 0, 0, buf, kSize, false));
1479 EXPECT_EQ(kSize, WriteData(entry, 1, 0, buf, kSize, false));
1480 EXPECT_EQ(kSize, WriteData(entry, 2, 0, buf, kSize, false));
1482 EXPECT_FALSE(entry->CouldBeSparse());
1483 entry->Close();
1485 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1486 EXPECT_FALSE(entry->CouldBeSparse());
1487 entry->Close();
1511 disk_cache::Entry* entry;
1512 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1518 VerifySparseIO(entry, i, buf_3, 1024, buf_2);
1519 VerifySparseIO(entry, 9000 + i, buf_3, 1024, buf_2);
1523 VerifyContentSparseIO(entry, 0, buf_1->data(), kSize);
1524 VerifyContentSparseIO(entry, 9000, buf_1->data(), kSize);
1527 VerifySparseIO(entry, 20481, buf_1, 8192, buf_2);
1529 entry->Close();
1540 disk_cache::Entry* entry;
1542 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1544 // Writes in the middle of an entry.
1545 EXPECT_EQ(1024, entry->WriteSparseData(0, buf, 1024, NULL));
1546 EXPECT_EQ(1024, entry->WriteSparseData(5120, buf, 1024, NULL));
1547 EXPECT_EQ(1024, entry->WriteSparseData(10000, buf, 1024, NULL));
1549 // Writes in the middle of an entry and spans 2 child entries.
1550 EXPECT_EQ(8192, entry->WriteSparseData(50000, buf, 8192, NULL));
1555 int rv = entry->GetAvailableRange(0, 10000, &start, &cb);
1561 rv = entry->GetAvailableRange(512, 10000, &start, &cb);
1566 rv = entry->GetAvailableRange(1024, 10000, &start, &cb);
1572 rv = entry->GetAvailableRange(5500, 512, &start, &cb);
1578 rv = entry->GetAvailableRange(5000, 620, &start, &cb);
1583 rv = entry->GetAvailableRange(40000, 20000, &start, &cb);
1587 entry->Close();
1592 disk_cache::Entry* entry1;
1608 disk_cache::Entry* entry2;
1637 disk_cache::Entry *entry1, *entry2;
1660 // Doom the first entry while it's still open.
1665 // Doom the second entry after it's fully saved.
1719 // deleting the sub-entries of a sparse entry.
1725 disk_cache::Entry* entry;
1726 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1735 EXPECT_EQ(kSize, entry->WriteSparseData(offset, buf, kSize, NULL));
1740 entry->Close();
1752 disk_cache::Entry* entry;
1753 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1756 // of a sparse entry, at least to write a big range without leaving holes.
1762 // The first write is just to extend the entry. The third write occupies
1765 EXPECT_EQ(kSize, WriteSparseData(entry, 20000, buf1, kSize));
1766 EXPECT_EQ(kSize, WriteSparseData(entry, 500, buf1, kSize));
1767 EXPECT_EQ(kSmallSize, WriteSparseData(entry, 1080321, buf1, kSmallSize));
1768 entry->Close();
1769 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1773 EXPECT_EQ(0, ReadSparseData(entry, 8000, buf2, kSize));
1775 EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2, kSize));
1777 EXPECT_EQ(0, ReadSparseData(entry, 0, buf2, kSize));
1780 EXPECT_EQ(96, ReadSparseData(entry, 24000, buf2, kSize));
1781 EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2, kSize));
1782 EXPECT_EQ(0, ReadSparseData(entry, 99, buf2, kSize));
1788 rv = entry->GetAvailableRange(0, 600, &start, &cb);
1792 rv = entry->GetAvailableRange(0, 2048, &start, &cb);
1796 rv = entry->GetAvailableRange(kSize, kSize, &start, &cb);
1799 rv = entry->GetAvailableRange(20 * 1024, 10000, &start, &cb);
1807 rv = entry->GetAvailableRange(19400, kSize, &start, &cb);
1811 rv = entry->GetAvailableRange(19400, kSize, &start, &cb);
1815 rv = entry->GetAvailableRange(3073, kSize, &start, &cb);
1818 rv = entry->GetAvailableRange(4600, kSize, &start, &cb);
1823 EXPECT_EQ(kSize, WriteSparseData(entry, 500 + kSize, buf1, kSize));
1824 rv = entry->GetAvailableRange(1024, 10000, &start, &cb);
1827 EXPECT_EQ(kSize, ReadSparseData(entry, kSize, buf2, kSize));
1831 entry->Close();
1849 disk_cache::Entry* entry;
1850 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1857 EXPECT_EQ(kSize, WriteSparseData(entry, 8192, buf1, kSize));
1858 EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 8192, buf1, kSize));
1859 EXPECT_EQ(kSize, WriteSparseData(entry, 2 * k1Meg + 8192, buf1, kSize));
1860 entry->Close();
1866 while (OpenNextEntry(&iter, &entry) == net::OK) {
1867 ASSERT_TRUE(entry != NULL);
1868 // Writing to an entry will alter the LRU list and invalidate the iterator.
1869 if (entry->GetKey() != key && count < 2)
1870 child_key[count++] = entry->GetKey();
1871 entry->Close();
1874 ASSERT_EQ(net::OK, OpenEntry(child_key[i], &entry));
1876 EXPECT_EQ(12, WriteData(entry, 2, 0, buf1, 12, false));
1877 entry->Close();
1881 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1884 EXPECT_EQ(0, ReadSparseData(entry, 2 * k1Meg + 8192, buf1, kSize));
1885 EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 16384, buf1, kSize));
1886 EXPECT_EQ(0, ReadSparseData(entry, k1Meg + 8192, buf1, kSize));
1889 EXPECT_EQ(kSize, ReadSparseData(entry, 8192, buf1, kSize));
1890 entry->Close();
1900 disk_cache::Entry* entry;
1901 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1909 int rv = entry->WriteSparseData(1024 * 1024 - 4096, buf, kSize, &cb1);
1913 rv = entry->GetAvailableRange(offset, kSize, &offset, &cb5);
1916 // We may or may not have finished writing to the entry. If we have not,
1922 entry->CancelSparseIO();
1923 EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(&cb2));
1924 EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(&cb3));
1925 entry->CancelSparseIO(); // Should be a no op at this point.
1926 EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(&cb4));
1930 entry->ReadSparseData(offset, buf, kSize, NULL));
1932 entry->WriteSparseData(offset, buf, kSize, NULL));
1943 rv = entry->GetAvailableRange(offset, kSize, &offset, &cb5);
1945 entry->Close();
1948 // Tests that we perform sanity checks on an entry's key. Note that there are
1954 disk_cache::Entry* entry;
1955 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1958 static_cast<disk_cache::EntryImpl*>(entry);
1959 disk_cache::EntryStore* store = entry_impl->entry()->Data();
1965 entry_impl->entry()->set_modified();
1966 entry->Close();
1968 // We have a corrupt entry. Now reload it. We should NOT read beyond the
1970 ASSERT_NE(net::OK, OpenEntry(key, &entry));
