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()); | |
michaeln
2015/06/22 23:20:21
(in the not that it matters bucket) I think in man
| |
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(1lu, 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::DONE, consolidation.ReadMemory(0, 0, 1, memory)); | |
33 EXPECT_EQ('1', memory[0]); | |
34 EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 1, 1, memory)); | |
35 EXPECT_EQ('2', memory[0]); | |
36 EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 2, 1, memory)); | |
37 EXPECT_EQ('3', memory[0]); | |
38 EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 3, 1, memory)); | |
39 EXPECT_EQ('4', memory[0]); | |
40 EXPECT_EQ(ReadStatus::DONE, 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(4lu, consolidation.total_memory()); | |
50 | |
51 const auto& items = consolidation.consolidated_items(); | |
52 EXPECT_EQ(1lu, 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::DONE, 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, TestAccounting) { | |
71 BlobConsolidation consolidation; | |
72 consolidation.AddDataItem(CreateData("1")); | |
73 consolidation.AddDataItem(CreateData("23")); | |
74 consolidation.AddFileItem("testPath", 1, 10, 5.0); | |
75 consolidation.AddDataItem(CreateData("4")); | |
76 EXPECT_EQ(4lu, consolidation.total_memory()); | |
77 | |
78 EXPECT_EQ(ReadStatus::ERROR, consolidation.RecordMemoryRead(0, 5)); | |
79 EXPECT_EQ(ReadStatus::ERROR_WRONG_TYPE, consolidation.RecordMemoryRead(1, 4)); | |
80 EXPECT_EQ(ReadStatus::ERROR_OUT_OF_BOUNDS, | |
81 consolidation.RecordMemoryRead(3, 4)); | |
82 EXPECT_EQ(ReadStatus::BLOB_BYTES_PENDING, | |
83 consolidation.RecordMemoryRead(0, 3)); | |
84 EXPECT_EQ(ReadStatus::DONE, consolidation.RecordMemoryRead(2, 1)); | |
85 EXPECT_EQ(ReadStatus::ERROR, consolidation.RecordMemoryRead(2, 1)); | |
86 } | |
87 | |
88 TEST(BlobConsolidationTest, TestMassiveConsolidation) { | |
89 BlobConsolidation consolidation; | |
90 static const size_t kNumParts = 300; | |
91 static const size_t kPartSize = 5; | |
92 static const size_t kTotalMemory = kNumParts * kPartSize; | |
93 static const size_t kReadSegmentSize = 6; // Must be factor of kTotalMemory | |
94 static const size_t kNumReadSegments = kTotalMemory / kReadSegmentSize; | |
michaeln
2015/06/18 00:10:48
thnx, new names helped a lot
doesn't really matte
dmurph
2015/06/19 21:42:05
I didn't know this kind of stuff polluted a global
michaeln
2015/06/22 23:20:21
idk, maybe it doesn't in this case because nothing
| |
95 | |
96 char current_value = 0; | |
97 for (size_t i = 0; i < kNumParts; i++) { | |
98 char data[kPartSize]; | |
99 for (size_t j = 0; j < kPartSize; j++) { | |
100 data[j] = current_value; | |
101 ++current_value; | |
102 } | |
103 consolidation.AddDataItem(blink::WebThreadSafeData(data, kPartSize)); | |
104 } | |
105 EXPECT_EQ(kTotalMemory, consolidation.total_memory()); | |
106 | |
107 const auto& items = consolidation.consolidated_items(); | |
108 EXPECT_EQ(1lu, items.size()); | |
109 EXPECT_EQ(kTotalMemory, items[0].length); | |
110 | |
111 char expected_value = 0; | |
112 char read_buffer[kReadSegmentSize]; | |
113 for (size_t i = 0; i < kNumReadSegments; i++) { | |
114 EXPECT_EQ(ReadStatus::DONE, | |
115 consolidation.ReadMemory(0, i * kReadSegmentSize, | |
116 kReadSegmentSize, read_buffer)); | |
117 ReadStatus expected_status = i == kNumReadSegments - 1 | |
118 ? ReadStatus::DONE | |
119 : ReadStatus::BLOB_BYTES_PENDING; | |
120 EXPECT_EQ(expected_status, | |
121 consolidation.RecordMemoryRead(0, kReadSegmentSize)); | |
122 for (size_t j = 0; j < kReadSegmentSize; j++) { | |
123 EXPECT_EQ(expected_value, read_buffer[j]); | |
124 ++expected_value; | |
125 } | |
126 } | |
127 } | |
128 | |
129 TEST(BlobConsolidationTest, TestPartialRead) { | |
130 BlobConsolidation consolidation; | |
131 consolidation.AddDataItem(CreateData("1")); | |
132 consolidation.AddDataItem(CreateData("23")); | |
133 consolidation.AddDataItem(CreateData("45")); | |
134 EXPECT_EQ(5lu, consolidation.total_memory()); | |
135 | |
136 const auto& items = consolidation.consolidated_items(); | |
137 EXPECT_EQ(1lu, items.size()); | |
138 EXPECT_EQ(5lu, items[0].length); | |
139 EXPECT_EQ(0lu, items[0].offset); | |
140 | |
141 char memory_part1[] = {'X', 'X'}; | |
142 EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 0, 2, memory_part1)); | |
143 char expected_memory_part1[] = {'1', '2'}; | |
144 EXPECT_THAT(memory_part1, testing::ElementsAreArray(expected_memory_part1)); | |
145 EXPECT_EQ(ReadStatus::BLOB_BYTES_PENDING, | |
146 consolidation.RecordMemoryRead(0, 2)); | |
147 | |
148 EXPECT_EQ(ReadStatus::ERROR, consolidation.RecordMemoryRead(0, 5)); | |
149 | |
150 char memory_part2[] = {'X', 'X'}; | |
151 EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 2, 2, memory_part2)); | |
152 char expected_memory_part2[] = {'3', '4'}; | |
153 EXPECT_THAT(memory_part2, testing::ElementsAreArray(expected_memory_part2)); | |
154 EXPECT_EQ(ReadStatus::BLOB_BYTES_PENDING, | |
155 consolidation.RecordMemoryRead(0, 2)); | |
156 | |
157 char memory_part3[] = {'X'}; | |
158 EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 4, 1, memory_part3)); | |
159 char expected_memory_part3[] = {'5'}; | |
160 EXPECT_THAT(memory_part3, testing::ElementsAreArray(expected_memory_part3)); | |
161 EXPECT_EQ(ReadStatus::DONE, consolidation.RecordMemoryRead(0, 1)); | |
162 } | |
163 | |
164 TEST(BlobConsolidationTest, TestBoundaries) { | |
165 BlobConsolidation consolidation; | |
166 consolidation.AddDataItem(CreateData("1")); | |
167 consolidation.AddFileItem("testPath", 1, 10, 5.0); | |
168 consolidation.AddDataItem(CreateData("2")); | |
169 consolidation.AddDataItem(CreateData("3")); | |
170 consolidation.AddBlobItem("testUUID", 1, 2); | |
171 consolidation.AddDataItem(CreateData("45")); | |
172 EXPECT_EQ(5lu, consolidation.total_memory()); | |
173 | |
174 const auto& items = consolidation.consolidated_items(); | |
175 EXPECT_EQ(5lu, items.size()); | |
176 | |
177 EXPECT_EQ(1lu, items[0].length); | |
178 EXPECT_EQ(DataElement::TYPE_BYTES, items[0].type); | |
179 | |
180 EXPECT_EQ(10lu, items[1].length); | |
181 EXPECT_EQ(DataElement::TYPE_FILE, items[1].type); | |
182 | |
183 EXPECT_EQ(2lu, items[2].length); | |
184 EXPECT_EQ(DataElement::TYPE_BYTES, items[2].type); | |
185 | |
186 EXPECT_EQ(2lu, items[3].length); | |
187 EXPECT_EQ(DataElement::TYPE_BLOB, items[3].type); | |
188 | |
189 EXPECT_EQ(2lu, items[4].length); | |
190 EXPECT_EQ(DataElement::TYPE_BYTES, items[4].type); | |
191 | |
192 char test_memory[5]; | |
193 EXPECT_EQ(ReadStatus::ERROR_WRONG_TYPE, | |
194 consolidation.ReadMemory(1, 0, 1, test_memory)); | |
195 EXPECT_EQ(ReadStatus::ERROR_WRONG_TYPE, | |
196 consolidation.ReadMemory(3, 0, 1, test_memory)); | |
197 | |
198 char memory_part1[1]; | |
199 EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 0, 1, memory_part1)); | |
200 char expected_memory_part1[] = {'1'}; | |
201 EXPECT_THAT(memory_part1, testing::ElementsAreArray(expected_memory_part1)); | |
202 | |
203 char memory_part2[2]; | |
204 EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(2, 0, 2, memory_part2)); | |
205 char expected_memory_part2[] = {'2', '3'}; | |
206 EXPECT_THAT(memory_part2, testing::ElementsAreArray(expected_memory_part2)); | |
207 | |
208 char memory_part3[2]; | |
209 EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(4, 0, 2, memory_part3)); | |
210 char expected_memory_part3[] = {'4', '5'}; | |
211 EXPECT_THAT(memory_part3, testing::ElementsAreArray(expected_memory_part3)); | |
212 } | |
213 | |
214 } // namespace | |
215 } // namespace content | |
OLD | NEW |