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 "content/child/blob_storage/blob_consolidation.h" |
| 6 |
| 7 #include "base/files/file_path.h" |
| 8 #include "testing/gmock/include/gmock/gmock.h" |
| 9 #include "testing/gtest/include/gtest/gtest.h" |
| 10 |
| 11 using ReadStatus = content::BlobConsolidation::ReadStatus; |
| 12 using storage::DataElement; |
| 13 |
| 14 namespace content { |
| 15 namespace { |
| 16 |
| 17 static blink::WebThreadSafeData CreateData(const std::string& str) { |
| 18 return blink::WebThreadSafeData(str.c_str(), str.size()); |
| 19 } |
| 20 |
| 21 TEST(BlobConsolidationTest, TestSegmentation) { |
| 22 BlobConsolidation consolidation; |
| 23 consolidation.AddDataItem(CreateData("12345")); |
| 24 EXPECT_EQ(5lu, consolidation.total_memory()); |
| 25 |
| 26 const auto& items = consolidation.consolidated_items(); |
| 27 EXPECT_EQ(1u, items.size()); |
| 28 EXPECT_EQ(5lu, items[0].length); |
| 29 EXPECT_EQ(DataElement::TYPE_BYTES, items[0].type); |
| 30 EXPECT_EQ(0lu, items[0].offset); |
| 31 |
| 32 char memory[] = {'E'}; |
| 33 EXPECT_EQ(ReadStatus::OK, consolidation.ReadMemory(0, 0, 1, memory)); |
| 34 EXPECT_EQ('1', memory[0]); |
| 35 EXPECT_EQ(ReadStatus::OK, consolidation.ReadMemory(0, 1, 1, memory)); |
| 36 EXPECT_EQ('2', memory[0]); |
| 37 EXPECT_EQ(ReadStatus::OK, consolidation.ReadMemory(0, 2, 1, memory)); |
| 38 EXPECT_EQ('3', memory[0]); |
| 39 EXPECT_EQ(ReadStatus::OK, consolidation.ReadMemory(0, 3, 1, memory)); |
| 40 EXPECT_EQ('4', memory[0]); |
| 41 EXPECT_EQ(ReadStatus::OK, consolidation.ReadMemory(0, 4, 1, memory)); |
| 42 EXPECT_EQ('5', memory[0]); |
| 43 } |
| 44 |
| 45 TEST(BlobConsolidationTest, TestConsolidation) { |
| 46 BlobConsolidation consolidation; |
| 47 consolidation.AddDataItem(CreateData("1")); |
| 48 consolidation.AddDataItem(CreateData("23")); |
| 49 consolidation.AddDataItem(CreateData("4")); |
| 50 EXPECT_EQ(4u, consolidation.total_memory()); |
| 51 |
| 52 const auto& items = consolidation.consolidated_items(); |
| 53 EXPECT_EQ(1u, items.size()); |
| 54 EXPECT_EQ(4lu, items[0].length); |
| 55 EXPECT_EQ(DataElement::TYPE_BYTES, items[0].type); |
| 56 EXPECT_EQ(0lu, items[0].offset); |
| 57 |
| 58 char memory[4]; |
| 59 EXPECT_EQ(ReadStatus::ERROR_OUT_OF_BOUNDS, |
| 60 consolidation.ReadMemory(0, 0, 5, memory)); |
| 61 EXPECT_EQ(ReadStatus::ERROR_OUT_OF_BOUNDS, |
| 62 consolidation.ReadMemory(1, 0, 4, memory)); |
| 63 EXPECT_EQ(ReadStatus::ERROR_OUT_OF_BOUNDS, |
| 64 consolidation.ReadMemory(0, 1, 4, memory)); |
| 65 EXPECT_EQ(ReadStatus::OK, consolidation.ReadMemory(0, 0, 4, memory)); |
| 66 |
| 67 char expected_memory[] = {'1', '2', '3', '4'}; |
| 68 EXPECT_THAT(memory, testing::ElementsAreArray(expected_memory)); |
| 69 } |
| 70 |
| 71 TEST(BlobConsolidationTest, TestMassiveConsolidation) { |
| 72 BlobConsolidation consolidation; |
| 73 const size_t kNumParts = 300; |
| 74 const size_t kPartSize = 5; |
| 75 const size_t kTotalMemory = kNumParts * kPartSize; |
| 76 const size_t kReadSegmentSize = 6; // Must be factor of kTotalMemory |
| 77 const size_t kNumReadSegments = kTotalMemory / kReadSegmentSize; |
| 78 |
| 79 char current_value = 0; |
| 80 for (size_t i = 0; i < kNumParts; i++) { |
| 81 char data[kPartSize]; |
| 82 for (size_t j = 0; j < kPartSize; j++) { |
| 83 data[j] = current_value; |
| 84 ++current_value; |
| 85 } |
| 86 consolidation.AddDataItem(blink::WebThreadSafeData(data, kPartSize)); |
| 87 } |
| 88 EXPECT_EQ(kTotalMemory, consolidation.total_memory()); |
| 89 |
| 90 const auto& items = consolidation.consolidated_items(); |
| 91 EXPECT_EQ(1u, items.size()); |
| 92 EXPECT_EQ(kTotalMemory, items[0].length); |
| 93 |
| 94 char expected_value = 0; |
| 95 char read_buffer[kReadSegmentSize]; |
| 96 for (size_t i = 0; i < kNumReadSegments; i++) { |
| 97 EXPECT_EQ(ReadStatus::OK, |
| 98 consolidation.ReadMemory(0, i * kReadSegmentSize, |
| 99 kReadSegmentSize, read_buffer)); |
| 100 for (size_t j = 0; j < kReadSegmentSize; j++) { |
| 101 EXPECT_EQ(expected_value, read_buffer[j]); |
| 102 ++expected_value; |
| 103 } |
| 104 } |
| 105 } |
| 106 |
| 107 TEST(BlobConsolidationTest, TestPartialRead) { |
| 108 BlobConsolidation consolidation; |
| 109 consolidation.AddDataItem(CreateData("1")); |
| 110 consolidation.AddDataItem(CreateData("23")); |
| 111 consolidation.AddDataItem(CreateData("45")); |
| 112 EXPECT_EQ(5u, consolidation.total_memory()); |
| 113 |
| 114 const auto& items = consolidation.consolidated_items(); |
| 115 EXPECT_EQ(1u, items.size()); |
| 116 EXPECT_EQ(5lu, items[0].length); |
| 117 EXPECT_EQ(0lu, items[0].offset); |
| 118 |
| 119 char memory_part1[] = {'X', 'X'}; |
| 120 EXPECT_EQ(ReadStatus::OK, consolidation.ReadMemory(0, 0, 2, memory_part1)); |
| 121 char expected_memory_part1[] = {'1', '2'}; |
| 122 EXPECT_THAT(memory_part1, testing::ElementsAreArray(expected_memory_part1)); |
| 123 |
| 124 char memory_part2[] = {'X', 'X'}; |
| 125 EXPECT_EQ(ReadStatus::OK, consolidation.ReadMemory(0, 2, 2, memory_part2)); |
| 126 char expected_memory_part2[] = {'3', '4'}; |
| 127 EXPECT_THAT(memory_part2, testing::ElementsAreArray(expected_memory_part2)); |
| 128 |
| 129 char memory_part3[] = {'X'}; |
| 130 EXPECT_EQ(ReadStatus::OK, consolidation.ReadMemory(0, 4, 1, memory_part3)); |
| 131 char expected_memory_part3[] = {'5'}; |
| 132 EXPECT_THAT(memory_part3, testing::ElementsAreArray(expected_memory_part3)); |
| 133 } |
| 134 |
| 135 TEST(BlobConsolidationTest, TestBoundaries) { |
| 136 BlobConsolidation consolidation; |
| 137 consolidation.AddDataItem(CreateData("1")); |
| 138 consolidation.AddFileItem(base::FilePath(FILE_PATH_LITERAL("testPath")), 1, |
| 139 10, 5.0); |
| 140 consolidation.AddDataItem(CreateData("2")); |
| 141 consolidation.AddDataItem(CreateData("3")); |
| 142 consolidation.AddBlobItem("testUUID", 1, 2); |
| 143 consolidation.AddDataItem(CreateData("45")); |
| 144 EXPECT_EQ(5u, consolidation.total_memory()); |
| 145 |
| 146 const auto& items = consolidation.consolidated_items(); |
| 147 EXPECT_EQ(5u, items.size()); |
| 148 |
| 149 EXPECT_EQ(1lu, items[0].length); |
| 150 EXPECT_EQ(DataElement::TYPE_BYTES, items[0].type); |
| 151 |
| 152 EXPECT_EQ(10lu, items[1].length); |
| 153 EXPECT_EQ(DataElement::TYPE_FILE, items[1].type); |
| 154 |
| 155 EXPECT_EQ(2lu, items[2].length); |
| 156 EXPECT_EQ(DataElement::TYPE_BYTES, items[2].type); |
| 157 |
| 158 EXPECT_EQ(2lu, items[3].length); |
| 159 EXPECT_EQ(DataElement::TYPE_BLOB, items[3].type); |
| 160 |
| 161 EXPECT_EQ(2lu, items[4].length); |
| 162 EXPECT_EQ(DataElement::TYPE_BYTES, items[4].type); |
| 163 |
| 164 char test_memory[5]; |
| 165 EXPECT_EQ(ReadStatus::ERROR_WRONG_TYPE, |
| 166 consolidation.ReadMemory(1, 0, 1, test_memory)); |
| 167 EXPECT_EQ(ReadStatus::ERROR_WRONG_TYPE, |
| 168 consolidation.ReadMemory(3, 0, 1, test_memory)); |
| 169 |
| 170 char memory_part1[1]; |
| 171 EXPECT_EQ(ReadStatus::OK, consolidation.ReadMemory(0, 0, 1, memory_part1)); |
| 172 char expected_memory_part1[] = {'1'}; |
| 173 EXPECT_THAT(memory_part1, testing::ElementsAreArray(expected_memory_part1)); |
| 174 |
| 175 char memory_part2[2]; |
| 176 EXPECT_EQ(ReadStatus::OK, consolidation.ReadMemory(2, 0, 2, memory_part2)); |
| 177 char expected_memory_part2[] = {'2', '3'}; |
| 178 EXPECT_THAT(memory_part2, testing::ElementsAreArray(expected_memory_part2)); |
| 179 |
| 180 char memory_part3[2]; |
| 181 EXPECT_EQ(ReadStatus::OK, consolidation.ReadMemory(4, 0, 2, memory_part3)); |
| 182 char expected_memory_part3[] = {'4', '5'}; |
| 183 EXPECT_THAT(memory_part3, testing::ElementsAreArray(expected_memory_part3)); |
| 184 } |
| 185 |
| 186 } // namespace |
| 187 } // namespace content |
OLD | NEW |