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