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 char* data = new char[str.size()]; | |
michaeln
2015/06/17 03:17:55
Is the extra heap allocation needed? Does WebThrea
dmurph
2015/06/17 18:29:51
Ah, yeah, you're right. This was from a previous
| |
18 memcpy(data, str.c_str(), str.size()); | |
19 return blink::WebThreadSafeData(data, str.size()); | |
20 } | |
21 | |
22 TEST(BlobConsolidationTest, TestSegmentation) { | |
23 BlobConsolidation consolidation; | |
24 consolidation.AddDataItem(CreateData("12345")); | |
25 EXPECT_EQ(5lu, consolidation.total_memory()); | |
26 | |
27 const auto& items = consolidation.consolidated_items(); | |
28 EXPECT_EQ(1lu, items.size()); | |
29 EXPECT_EQ(5lu, items[0].length); | |
30 EXPECT_EQ(DataElement::TYPE_BYTES, items[0].type); | |
31 EXPECT_EQ(0lu, items[0].offset); | |
32 | |
33 char memory[] = {'E'}; | |
34 EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 0, 1, memory)); | |
35 EXPECT_EQ('1', memory[0]); | |
36 EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 1, 1, memory)); | |
37 EXPECT_EQ('2', memory[0]); | |
38 EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 2, 1, memory)); | |
39 EXPECT_EQ('3', memory[0]); | |
40 EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 3, 1, memory)); | |
41 EXPECT_EQ('4', memory[0]); | |
42 EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 4, 1, memory)); | |
43 EXPECT_EQ('5', memory[0]); | |
44 } | |
45 | |
46 TEST(BlobConsolidationTest, TestConsolidation) { | |
47 BlobConsolidation consolidation; | |
48 consolidation.AddDataItem(CreateData("1")); | |
49 consolidation.AddDataItem(CreateData("23")); | |
50 consolidation.AddDataItem(CreateData("4")); | |
51 EXPECT_EQ(4lu, consolidation.total_memory()); | |
52 | |
53 const auto& items = consolidation.consolidated_items(); | |
54 EXPECT_EQ(1lu, items.size()); | |
55 EXPECT_EQ(4lu, items[0].length); | |
56 EXPECT_EQ(DataElement::TYPE_BYTES, items[0].type); | |
57 EXPECT_EQ(0lu, items[0].offset); | |
58 | |
59 char memory[4]; | |
60 EXPECT_EQ(ReadStatus::ERROR_OUT_OF_BOUNDS, | |
61 consolidation.ReadMemory(0, 0, 5, memory)); | |
62 EXPECT_EQ(ReadStatus::ERROR_OUT_OF_BOUNDS, | |
63 consolidation.ReadMemory(1, 0, 4, memory)); | |
64 EXPECT_EQ(ReadStatus::ERROR_OUT_OF_BOUNDS, | |
65 consolidation.ReadMemory(0, 1, 4, memory)); | |
66 EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 0, 4, memory)); | |
67 | |
68 char expected_memory[] = {'1', '2', '3', '4'}; | |
69 EXPECT_THAT(memory, testing::ElementsAreArray(expected_memory)); | |
70 } | |
71 | |
72 TEST(BlobConsolidationTest, TestAccounting) { | |
73 BlobConsolidation consolidation; | |
74 consolidation.AddDataItem(CreateData("1")); | |
75 consolidation.AddDataItem(CreateData("23")); | |
76 consolidation.AddFileItem("testPath", 1, 10, 5.0); | |
77 consolidation.AddDataItem(CreateData("4")); | |
78 EXPECT_EQ(4lu, consolidation.total_memory()); | |
79 | |
80 EXPECT_EQ(ReadStatus::ERROR, consolidation.RecordMemoryRead(0, 5)); | |
81 EXPECT_EQ(ReadStatus::ERROR_WRONG_TYPE, consolidation.RecordMemoryRead(1, 4)); | |
82 EXPECT_EQ(ReadStatus::ERROR_OUT_OF_BOUNDS, | |
83 consolidation.RecordMemoryRead(3, 4)); | |
84 EXPECT_EQ(ReadStatus::BLOB_BYTES_PENDING, | |
85 consolidation.RecordMemoryRead(0, 3)); | |
86 EXPECT_EQ(ReadStatus::DONE, consolidation.RecordMemoryRead(2, 1)); | |
87 EXPECT_EQ(ReadStatus::ERROR, consolidation.RecordMemoryRead(2, 1)); | |
88 } | |
89 | |
90 TEST(BlobConsolidationTest, TestMassiveConsolidation) { | |
91 BlobConsolidation consolidation; | |
92 static const size_t NUM_PARTS = 300; | |
michaeln
2015/06/17 03:17:55
I think our style guide prefer we name constants l
dmurph
2015/06/17 18:29:51
no value, they're global constants, so why not?
| |
93 static const size_t PART_SIZE = 5; | |
94 static const size_t TOTAL_MEMORY = NUM_PARTS * PART_SIZE; | |
95 static const size_t SEGMENT_SIZE = 6; // Must be factor of TOTAL_MEMORY | |
96 static const size_t NUM_SEGMENTS = TOTAL_MEMORY / SEGMENT_SIZE; | |
michaeln
2015/06/17 03:17:55
maybe move these kSegmentSize and kNumSegments dow
dmurph
2015/06/17 18:29:51
do you mind if I keep all of the constants in one
| |
97 | |
98 char current_value = 0; | |
99 for (size_t i = 0; i < NUM_PARTS; i++) { | |
100 char* data = new char[PART_SIZE]; | |
michaeln
2015/06/17 03:17:55
looks like |data| is leaked here too
dmurph
2015/06/17 18:29:51
thanks, fixed.
| |
101 for (size_t j = 0; j < PART_SIZE; j++) { | |
102 data[j] = current_value; | |
103 ++current_value; | |
104 } | |
105 consolidation.AddDataItem(blink::WebThreadSafeData(data, PART_SIZE)); | |
106 } | |
107 EXPECT_EQ(TOTAL_MEMORY, consolidation.total_memory()); | |
108 | |
109 const auto& items = consolidation.consolidated_items(); | |
110 EXPECT_EQ(1lu, items.size()); | |
111 EXPECT_EQ(TOTAL_MEMORY, items[0].length); | |
112 | |
113 char expected_value = 0; | |
114 char read_buffer[SEGMENT_SIZE]; | |
115 for (size_t i = 0; i < NUM_SEGMENTS; i++) { | |
116 EXPECT_EQ(ReadStatus::DONE, | |
117 consolidation.ReadMemory(0, i * SEGMENT_SIZE, SEGMENT_SIZE, | |
118 read_buffer)); | |
119 ReadStatus expected_status = i == NUM_SEGMENTS - 1 | |
120 ? ReadStatus::DONE | |
121 : ReadStatus::BLOB_BYTES_PENDING; | |
122 EXPECT_EQ(expected_status, consolidation.RecordMemoryRead(0, SEGMENT_SIZE)); | |
123 for (size_t j = 0; j < SEGMENT_SIZE; j++) { | |
124 EXPECT_EQ(expected_value, read_buffer[j]); | |
125 ++expected_value; | |
126 } | |
127 } | |
128 } | |
129 | |
130 TEST(BlobConsolidationTest, TestPartialRead) { | |
131 BlobConsolidation consolidation; | |
132 consolidation.AddDataItem(CreateData("1")); | |
133 consolidation.AddDataItem(CreateData("23")); | |
134 consolidation.AddDataItem(CreateData("45")); | |
135 EXPECT_EQ(5lu, consolidation.total_memory()); | |
136 | |
137 const auto& items = consolidation.consolidated_items(); | |
138 EXPECT_EQ(1lu, items.size()); | |
139 EXPECT_EQ(5lu, items[0].length); | |
140 EXPECT_EQ(0lu, items[0].offset); | |
141 | |
142 char memory_part1[] = {'X', 'X'}; | |
143 EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 0, 2, memory_part1)); | |
144 char expected_memory_part1[] = {'1', '2'}; | |
145 EXPECT_THAT(memory_part1, testing::ElementsAreArray(expected_memory_part1)); | |
146 EXPECT_EQ(ReadStatus::BLOB_BYTES_PENDING, | |
147 consolidation.RecordMemoryRead(0, 2)); | |
148 | |
149 EXPECT_EQ(ReadStatus::ERROR, consolidation.RecordMemoryRead(0, 5)); | |
150 | |
151 char memory_part2[] = {'X', 'X'}; | |
152 EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 2, 2, memory_part2)); | |
153 char expected_memory_part2[] = {'3', '4'}; | |
154 EXPECT_THAT(memory_part2, testing::ElementsAreArray(expected_memory_part2)); | |
155 EXPECT_EQ(ReadStatus::BLOB_BYTES_PENDING, | |
156 consolidation.RecordMemoryRead(0, 2)); | |
157 | |
158 char memory_part3[] = {'X'}; | |
159 EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 4, 1, memory_part3)); | |
160 char expected_memory_part3[] = {'5'}; | |
161 EXPECT_THAT(memory_part3, testing::ElementsAreArray(expected_memory_part3)); | |
162 EXPECT_EQ(ReadStatus::DONE, consolidation.RecordMemoryRead(0, 1)); | |
163 } | |
164 | |
165 TEST(BlobConsolidationTest, TestBoundaries) { | |
166 BlobConsolidation consolidation; | |
167 consolidation.AddDataItem(CreateData("1")); | |
168 consolidation.AddFileItem("testPath", 1, 10, 5.0); | |
169 consolidation.AddDataItem(CreateData("2")); | |
170 consolidation.AddDataItem(CreateData("3")); | |
171 consolidation.AddBlobItem("testUUID", 1, 2); | |
172 consolidation.AddDataItem(CreateData("45")); | |
173 EXPECT_EQ(5lu, consolidation.total_memory()); | |
174 | |
175 const auto& items = consolidation.consolidated_items(); | |
176 EXPECT_EQ(5lu, items.size()); | |
177 | |
178 EXPECT_EQ(1lu, items[0].length); | |
179 EXPECT_EQ(DataElement::TYPE_BYTES, items[0].type); | |
180 | |
181 EXPECT_EQ(10lu, items[1].length); | |
182 EXPECT_EQ(DataElement::TYPE_FILE, items[1].type); | |
183 | |
184 EXPECT_EQ(2lu, items[2].length); | |
185 EXPECT_EQ(DataElement::TYPE_BYTES, items[2].type); | |
186 | |
187 EXPECT_EQ(2lu, items[3].length); | |
188 EXPECT_EQ(DataElement::TYPE_BLOB, items[3].type); | |
189 | |
190 EXPECT_EQ(2lu, items[4].length); | |
191 EXPECT_EQ(DataElement::TYPE_BYTES, items[4].type); | |
192 | |
193 char test_memory[5]; | |
194 EXPECT_EQ(ReadStatus::ERROR_WRONG_TYPE, | |
195 consolidation.ReadMemory(1, 0, 1, test_memory)); | |
196 EXPECT_EQ(ReadStatus::ERROR_WRONG_TYPE, | |
197 consolidation.ReadMemory(3, 0, 1, test_memory)); | |
198 | |
199 char memory_part1[1]; | |
200 EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 0, 1, memory_part1)); | |
201 char expected_memory_part1[] = {'1'}; | |
202 EXPECT_THAT(memory_part1, testing::ElementsAreArray(expected_memory_part1)); | |
203 | |
204 char memory_part2[2]; | |
205 EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(2, 0, 2, memory_part2)); | |
206 char expected_memory_part2[] = {'2', '3'}; | |
207 EXPECT_THAT(memory_part2, testing::ElementsAreArray(expected_memory_part2)); | |
208 | |
209 char memory_part3[2]; | |
210 EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(4, 0, 2, memory_part3)); | |
211 char expected_memory_part3[] = {'4', '5'}; | |
212 EXPECT_THAT(memory_part3, testing::ElementsAreArray(expected_memory_part3)); | |
213 } | |
214 | |
215 } // namespace | |
216 } // namespace content | |
OLD | NEW |