OLD | NEW |
---|---|
(Empty) | |
1 // Copyright (c) 2017 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 "platform/image-decoders/SegmentStream.h" | |
6 | |
7 #include <memory> | |
8 #include "platform/SharedBuffer.h" | |
9 #include "platform/wtf/PtrUtil.h" | |
10 #include "testing/gtest/include/gtest/gtest.h" | |
11 | |
12 // SegmentStream has 4 accessors which do not alter state: | |
13 // - isCleared() | |
14 // - isAtEnd() | |
15 // - getPosition() | |
16 // - getLength() | |
17 // | |
18 // For every operation which changes state we can test: | |
19 // - the operation completed as expected, | |
20 // - the accessors did not change, and/or | |
21 // - the accessors changed in the way we expected. | |
22 // | |
23 // There are actually 2 more accessors: | |
24 // - hasPosition() | |
25 // - hasLength() | |
26 // but these should always return true to indicate that we can call getLength() | |
27 // for example. So let's not add them to every state changing operation and add | |
28 // needless complexity. | |
29 | |
30 namespace { | |
31 | |
32 constexpr size_t kBufferAllocationSize = 20; | |
33 constexpr size_t kInsideBufferPosition = 10; | |
34 constexpr size_t kPastEndOfBufferPosition = 30; | |
35 | |
36 testing::AssertionResult IsCleared(const blink::SegmentStream&); | |
37 testing::AssertionResult IsAtEnd(const blink::SegmentStream&); | |
38 testing::AssertionResult PositionIsZero(const blink::SegmentStream&); | |
39 testing::AssertionResult PositionIsInsideBuffer(const blink::SegmentStream&); | |
40 testing::AssertionResult PositionIsAtEndOfBuffer(const blink::SegmentStream&); | |
41 testing::AssertionResult LengthIsZero(const blink::SegmentStream&); | |
42 testing::AssertionResult LengthIsAllocationSize(const blink::SegmentStream&); | |
43 | |
44 // Many of these tests require a SegmentStream that can be read from. | |
45 // This means the stream must have a buffer and contents. | |
46 // | |
47 // This function creates a buffer of size |kBufferAllocationSize| | |
48 // and prepares a SegmentStream with that buffer. | |
49 blink::SegmentStream CreatePopulatedSegmentStreamReadable(); | |
cblume
2017/04/26 21:48:12
Oops. This wasn't supposed to end in ___Readable()
| |
50 RefPtr<blink::SegmentReader> CreateSegmentReader(); | |
51 | |
52 } // namespace | |
53 | |
54 namespace blink { | |
55 | |
56 TEST(SegmentStreamTest, DefaultConstructorShouldSetIsCleared) { | |
57 SegmentStream segment_stream; | |
58 | |
59 ASSERT_TRUE(IsCleared(segment_stream)); | |
60 } | |
61 | |
62 TEST(SegmentStreamTest, DefaultConstructorShouldSetIsAtEnd) { | |
63 SegmentStream segment_stream; | |
64 | |
65 ASSERT_TRUE(IsAtEnd(segment_stream)); | |
66 } | |
67 | |
68 TEST(SegmentStreamTest, DefaultContructorShouldClearPosition) { | |
69 SegmentStream segment_stream; | |
70 | |
71 ASSERT_TRUE(PositionIsZero(segment_stream)); | |
72 } | |
73 | |
74 TEST(SegmentStreamTest, DefaultConstructorShouldHaveZeroLength) { | |
75 SegmentStream segment_stream; | |
76 | |
77 ASSERT_TRUE(LengthIsZero(segment_stream)); | |
78 } | |
79 | |
80 TEST(SegmentStreamTest, MoveConstructorShouldSetIsClearedWhenRhsIsCleared) { | |
81 SegmentStream cleared_segment_stream; | |
82 ASSERT_TRUE(IsCleared(cleared_segment_stream)); | |
83 | |
84 SegmentStream move_constructed_segment_stream( | |
85 std::move(cleared_segment_stream)); | |
86 | |
87 ASSERT_TRUE(IsCleared(move_constructed_segment_stream)); | |
88 } | |
89 | |
90 TEST(SegmentStreamTest, | |
91 MoveConstructorShouldUnsetIsClearedWhenRhsIsNotCleared) { | |
92 SegmentStream uncleared_segment_stream = | |
93 CreatePopulatedSegmentStreamReadable(); | |
94 ASSERT_FALSE(IsCleared(uncleared_segment_stream)); | |
95 | |
96 SegmentStream move_constructed_segment_stream = | |
97 std::move(uncleared_segment_stream); | |
98 | |
99 ASSERT_FALSE(IsCleared(move_constructed_segment_stream)); | |
100 } | |
101 | |
102 TEST(SegmentStreamTest, MoveConstructorShouldSetIsAtEndWhenRhsIsAtEnd) { | |
103 SegmentStream at_end_segment_stream; | |
104 ASSERT_TRUE(IsAtEnd(at_end_segment_stream)); | |
105 | |
106 SegmentStream move_constructed_segment_stream = | |
107 std::move(at_end_segment_stream); | |
108 | |
109 ASSERT_TRUE(IsAtEnd(move_constructed_segment_stream)); | |
110 } | |
111 | |
112 TEST(SegmentStreamTest, MoveConstructorShouldUnsetIsAtEndWhenRhsIsNotAtEnd) { | |
113 SegmentStream not_at_end_segment_stream = | |
114 CreatePopulatedSegmentStreamReadable(); | |
115 ASSERT_FALSE(IsAtEnd(not_at_end_segment_stream)); | |
116 | |
117 SegmentStream move_constructed_segment_stream = | |
118 std::move(not_at_end_segment_stream); | |
119 | |
120 ASSERT_FALSE(IsAtEnd(move_constructed_segment_stream)); | |
121 } | |
122 | |
123 TEST(SegmentStreamTest, MoveContructorShouldCopyRhsPosition) { | |
124 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
125 segment_stream.seek(kInsideBufferPosition); | |
126 ASSERT_EQ(kInsideBufferPosition, segment_stream.getPosition()); | |
127 | |
128 SegmentStream move_constructed_segment_stream = std::move(segment_stream); | |
129 | |
130 ASSERT_EQ(kInsideBufferPosition, | |
131 move_constructed_segment_stream.getPosition()); | |
132 } | |
133 | |
134 TEST(SegmentStreamTest, MoveConstructorShouldCopyRhsLength) { | |
135 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
136 ASSERT_EQ(kBufferAllocationSize, segment_stream.getLength()); | |
137 | |
138 SegmentStream move_constructed_segment_stream = std::move(segment_stream); | |
139 | |
140 ASSERT_EQ(kBufferAllocationSize, move_constructed_segment_stream.getLength()); | |
141 } | |
142 | |
143 TEST(SegmentStreamTest, SetReaderShouldUnsetIsCleared) { | |
144 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
145 | |
146 ASSERT_FALSE(IsCleared(segment_stream)); | |
147 } | |
148 | |
149 TEST(SegmentStreamTest, SetReaderShouldUnsetIsAtEnd) { | |
150 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
151 | |
152 ASSERT_FALSE(IsAtEnd(segment_stream)); | |
153 } | |
154 | |
155 TEST(SegmentStreamTest, SetReaderShouldNotChangePosition) { | |
156 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
157 | |
158 ASSERT_TRUE(PositionIsZero(segment_stream)); | |
159 } | |
160 | |
161 TEST(SegmentStreamTest, SetReaderShouldUpdateLength) { | |
162 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
163 | |
164 ASSERT_TRUE(LengthIsAllocationSize(segment_stream)); | |
165 } | |
166 | |
167 TEST(SegmentStreamTest, SetReaderShouldSetIsClearedWhenSetToNull) { | |
168 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
169 ASSERT_FALSE(IsCleared(segment_stream)); | |
170 | |
171 segment_stream.SetReader(nullptr); | |
172 ASSERT_TRUE(IsCleared(segment_stream)); | |
173 } | |
174 | |
175 TEST(SegmentStreamTest, SetReaderShouldSetIsClearedWhenReaderSizeNotBigEnough) { | |
176 SegmentStream segment_stream; | |
177 segment_stream.seek(kPastEndOfBufferPosition); | |
178 RefPtr<blink::SegmentReader> segment_reader = CreateSegmentReader(); | |
179 | |
180 segment_stream.SetReader(segment_reader); | |
181 | |
182 ASSERT_TRUE(IsCleared(segment_stream)); | |
183 } | |
184 | |
185 TEST(SegmentStreamTest, SetReaderShouldSetIsAtEndWhenReaderSizeNotBigEnough) { | |
186 SegmentStream segment_stream; | |
187 segment_stream.seek(kPastEndOfBufferPosition); | |
188 RefPtr<blink::SegmentReader> segment_reader = CreateSegmentReader(); | |
189 | |
190 segment_stream.SetReader(segment_reader); | |
191 | |
192 ASSERT_TRUE(IsAtEnd(segment_stream)); | |
193 } | |
194 | |
195 TEST(SegmentStreamTest, | |
196 SetReaderShouldNotChangePositionWhenReaderSizeNotBigEnough) { | |
197 SegmentStream segment_stream; | |
198 segment_stream.seek(kPastEndOfBufferPosition); | |
199 RefPtr<blink::SegmentReader> segment_reader = CreateSegmentReader(); | |
200 | |
201 segment_stream.SetReader(segment_reader); | |
202 | |
203 ASSERT_EQ(kPastEndOfBufferPosition, segment_stream.getPosition()); | |
204 } | |
205 | |
206 TEST(SegmentStreamTest, SetReaderShouldChangeLengthWhenReaderSizeNotBigEnough) { | |
207 SegmentStream segment_stream; | |
208 segment_stream.seek(kPastEndOfBufferPosition); | |
209 RefPtr<blink::SegmentReader> segment_reader = CreateSegmentReader(); | |
210 | |
211 segment_stream.SetReader(segment_reader); | |
212 | |
213 ASSERT_TRUE(LengthIsAllocationSize(segment_stream)); | |
214 } | |
215 | |
216 TEST(SegmentStreamTest, SetReaderShouldSetIsAtEndWhenSetToNull) { | |
217 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
218 ASSERT_FALSE(IsAtEnd(segment_stream)); | |
219 | |
220 segment_stream.SetReader(nullptr); | |
221 ASSERT_TRUE(IsAtEnd(segment_stream)); | |
222 } | |
223 | |
224 TEST(SegmentStreamTest, SetReaderShouldNotChangePositionWhenSetToNull) { | |
225 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
226 | |
227 std::array<char, kInsideBufferPosition> read_buffer; | |
228 const size_t amount_read = | |
229 segment_stream.read(read_buffer.data(), kInsideBufferPosition); | |
230 ASSERT_EQ(kInsideBufferPosition, amount_read); | |
231 const size_t pre_nulled_position = segment_stream.getPosition(); | |
232 ASSERT_EQ(amount_read, pre_nulled_position); | |
233 | |
234 segment_stream.SetReader(nullptr); | |
235 ASSERT_EQ(pre_nulled_position, segment_stream.getPosition()); | |
236 } | |
237 | |
238 TEST(SegmentStreamTest, SetReaderShouldClearLengthWhenSetToNull) { | |
239 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
240 | |
241 segment_stream.SetReader(nullptr); | |
242 ASSERT_TRUE(LengthIsZero(segment_stream)); | |
243 } | |
244 | |
245 TEST(SegmentStreamTest, ReadShouldConsumeBuffer) { | |
246 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
247 | |
248 std::array<char, kInsideBufferPosition> read_buffer; | |
249 const size_t amount_read = | |
250 segment_stream.read(read_buffer.data(), kInsideBufferPosition); | |
251 ASSERT_EQ(kInsideBufferPosition, amount_read); | |
252 } | |
253 | |
254 TEST(SegmentStreamTest, ReadShouldNotClear) { | |
255 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
256 | |
257 std::array<char, kInsideBufferPosition> read_buffer; | |
258 segment_stream.read(read_buffer.data(), kInsideBufferPosition); | |
259 ASSERT_FALSE(IsCleared(segment_stream)); | |
260 } | |
261 | |
262 TEST(SegmentStreamTest, ReadShouldUpdateIsAtEnd) { | |
263 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
264 ASSERT_FALSE(IsAtEnd(segment_stream)); | |
265 | |
266 std::array<char, kBufferAllocationSize> read_buffer; | |
267 const size_t amount_read = | |
268 segment_stream.read(read_buffer.data(), kBufferAllocationSize); | |
269 ASSERT_EQ(kBufferAllocationSize, amount_read); | |
270 ASSERT_TRUE(IsAtEnd(segment_stream)); | |
271 } | |
272 | |
273 TEST(SegmentStreamTest, ReadShouldUpdatePosition) { | |
274 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
275 ASSERT_TRUE(PositionIsZero(segment_stream)); | |
276 | |
277 std::array<char, kInsideBufferPosition> read_buffer; | |
278 const size_t amount_read = | |
279 segment_stream.read(read_buffer.data(), kInsideBufferPosition); | |
280 ASSERT_EQ(amount_read, segment_stream.getPosition()); | |
281 ASSERT_TRUE(PositionIsInsideBuffer(segment_stream)); | |
282 } | |
283 | |
284 TEST(SegmentStreamTest, ReadShouldNotChangeLength) { | |
285 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
286 | |
287 const size_t length = segment_stream.getLength(); | |
288 std::array<char, kInsideBufferPosition> read_buffer; | |
289 segment_stream.read(read_buffer.data(), kInsideBufferPosition); | |
290 ASSERT_EQ(segment_stream.getLength(), length); | |
291 } | |
292 | |
293 TEST(SegmentStreamTest, ReadShouldNotConsumeBufferWhenCleared) { | |
294 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
295 | |
296 std::array<char, kInsideBufferPosition> read_buffer; | |
297 const auto read_buffer_as_void_ptr = | |
298 reinterpret_cast<void*>(read_buffer.data()); | |
299 | |
300 segment_stream.SetReader(nullptr); | |
301 ASSERT_TRUE(IsCleared(segment_stream)); | |
302 | |
303 ASSERT_EQ( | |
304 0u, segment_stream.read(read_buffer_as_void_ptr, kInsideBufferPosition)); | |
305 } | |
306 | |
307 TEST(SegmentStreamTest, ReadShouldConsumeBufferWithoutGoingPastTheEnd) { | |
308 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
309 | |
310 std::array<char, kPastEndOfBufferPosition> read_buffer; | |
311 const size_t amount_read = | |
312 segment_stream.read(read_buffer.data(), kPastEndOfBufferPosition); | |
313 ASSERT_EQ(amount_read, segment_stream.getLength()); | |
314 } | |
315 | |
316 TEST(SegmentStreamTest, ReadShouldSetIsAtEndWhenPastEnd) { | |
317 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
318 ASSERT_FALSE(IsAtEnd(segment_stream)); | |
319 | |
320 std::array<char, kPastEndOfBufferPosition> read_buffer; | |
321 segment_stream.read(read_buffer.data(), kPastEndOfBufferPosition); | |
322 ASSERT_TRUE(IsAtEnd(segment_stream)); | |
323 } | |
324 | |
325 TEST(SegmentStreamTest, ReadShouldTruncatePositionWhenPastEnd) { | |
326 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
327 ASSERT_TRUE(PositionIsZero(segment_stream)); | |
328 | |
329 std::array<char, kPastEndOfBufferPosition> read_buffer; | |
330 const size_t amount_read = | |
331 segment_stream.read(read_buffer.data(), kPastEndOfBufferPosition); | |
332 ASSERT_EQ(amount_read, segment_stream.getPosition()); | |
333 ASSERT_TRUE(PositionIsAtEndOfBuffer(segment_stream)); | |
334 } | |
335 | |
336 TEST(SegmentStreamTest, PeekShouldConsumeBuffer) { | |
337 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
338 | |
339 std::array<char, kInsideBufferPosition> peek_buffer; | |
340 const size_t amount_peeked = | |
341 segment_stream.peek(peek_buffer.data(), kInsideBufferPosition); | |
342 ASSERT_EQ(kInsideBufferPosition, amount_peeked); | |
343 } | |
344 | |
345 TEST(SegmentStreamTest, PeekShouldNotClear) { | |
346 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
347 | |
348 std::array<char, kInsideBufferPosition> peek_buffer; | |
349 segment_stream.peek(peek_buffer.data(), kInsideBufferPosition); | |
350 ASSERT_FALSE(IsCleared(segment_stream)); | |
351 } | |
352 | |
353 TEST(SegmentStreamTest, PeekShouldNotUpdateIsAtEnd) { | |
354 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
355 ASSERT_FALSE(IsAtEnd(segment_stream)); | |
356 | |
357 std::array<char, kBufferAllocationSize> peek_buffer; | |
358 const size_t amount_peeked = | |
359 segment_stream.peek(peek_buffer.data(), kBufferAllocationSize); | |
360 ASSERT_EQ(kBufferAllocationSize, amount_peeked); | |
361 ASSERT_FALSE(IsAtEnd(segment_stream)); | |
362 } | |
363 | |
364 TEST(SegmentStreamTest, PeekShouldNotUpdatePosition) { | |
365 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
366 ASSERT_TRUE(PositionIsZero(segment_stream)); | |
367 | |
368 std::array<char, kInsideBufferPosition> peek_buffer; | |
369 segment_stream.peek(peek_buffer.data(), kInsideBufferPosition); | |
370 ASSERT_TRUE(PositionIsZero(segment_stream)); | |
371 } | |
372 | |
373 TEST(SegmentStreamTest, PeekShouldNotChangeLength) { | |
374 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
375 | |
376 const size_t length = segment_stream.getLength(); | |
377 std::array<char, kInsideBufferPosition> peek_buffer; | |
378 segment_stream.peek(peek_buffer.data(), kInsideBufferPosition); | |
379 ASSERT_EQ(length, segment_stream.getLength()); | |
380 } | |
381 | |
382 TEST(SegmentStreamTest, PeekShouldNotConsumeBufferWhenCleared) { | |
383 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
384 | |
385 std::array<char, kInsideBufferPosition> peek_buffer; | |
386 const auto peek_buffer_as_void_ptr = | |
387 reinterpret_cast<void*>(peek_buffer.data()); | |
388 | |
389 segment_stream.SetReader(nullptr); | |
390 ASSERT_TRUE(IsCleared(segment_stream)); | |
391 | |
392 ASSERT_EQ( | |
393 0u, segment_stream.peek(peek_buffer_as_void_ptr, kInsideBufferPosition)); | |
394 } | |
395 | |
396 TEST(SegmentStreamTest, PeekShouldConsumeBufferWithoutGoingPastTheEnd) { | |
397 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
398 | |
399 std::array<char, kPastEndOfBufferPosition> peek_buffer; | |
400 const size_t amount_peeked = | |
401 segment_stream.peek(peek_buffer.data(), kPastEndOfBufferPosition); | |
402 ASSERT_EQ(amount_peeked, segment_stream.getLength()); | |
403 } | |
404 | |
405 TEST(SegmentStreamTest, PeekShouldNotSetIsAtEndWhenPastEnd) { | |
406 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
407 ASSERT_FALSE(IsAtEnd(segment_stream)); | |
408 | |
409 std::array<char, kPastEndOfBufferPosition> peek_buffer; | |
410 segment_stream.peek(peek_buffer.data(), kPastEndOfBufferPosition); | |
411 ASSERT_FALSE(IsAtEnd(segment_stream)); | |
412 } | |
413 | |
414 TEST(SegmentStreamTest, PeekShouldNotTruncatePositionWhenPastEnd) { | |
415 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
416 ASSERT_TRUE(PositionIsZero(segment_stream)); | |
417 | |
418 std::array<char, kPastEndOfBufferPosition> peek_buffer; | |
419 segment_stream.peek(peek_buffer.data(), kPastEndOfBufferPosition); | |
420 ASSERT_TRUE(PositionIsZero(segment_stream)); | |
421 } | |
422 | |
423 TEST(SegmentStreamTest, RewindShouldNotClear) { | |
424 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
425 | |
426 std::array<char, kInsideBufferPosition> read_buffer; | |
427 segment_stream.read(read_buffer.data(), kInsideBufferPosition); | |
428 ASSERT_FALSE(IsCleared(segment_stream)); | |
429 | |
430 segment_stream.rewind(); | |
431 ASSERT_FALSE(IsCleared(segment_stream)); | |
432 } | |
433 | |
434 TEST(SegmentStreamTest, RewindShouldNotSetAtEnd) { | |
435 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
436 | |
437 std::array<char, kInsideBufferPosition> read_buffer; | |
438 segment_stream.read(read_buffer.data(), kInsideBufferPosition); | |
439 ASSERT_FALSE(IsAtEnd(segment_stream)); | |
440 | |
441 segment_stream.rewind(); | |
442 ASSERT_FALSE(IsAtEnd(segment_stream)); | |
443 } | |
444 | |
445 TEST(SegmentStreamTest, RewindShouldResetPosition) { | |
446 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
447 | |
448 std::array<char, kInsideBufferPosition> read_buffer; | |
449 segment_stream.read(read_buffer.data(), kInsideBufferPosition); | |
450 ASSERT_TRUE(PositionIsInsideBuffer(segment_stream)); | |
451 | |
452 segment_stream.rewind(); | |
453 ASSERT_TRUE(PositionIsZero(segment_stream)); | |
454 } | |
455 | |
456 TEST(SegmentStreamTest, RewindShouldNotChangeLength) { | |
457 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
458 | |
459 std::array<char, kInsideBufferPosition> read_buffer; | |
460 segment_stream.read(read_buffer.data(), kInsideBufferPosition); | |
461 const size_t pre_rewind_length = segment_stream.getLength(); | |
462 | |
463 segment_stream.rewind(); | |
464 ASSERT_EQ(pre_rewind_length, segment_stream.getLength()); | |
465 } | |
466 | |
467 TEST(SegmentStreamTest, HasPositionShouldBeSupported) { | |
468 blink::SegmentStream segment_stream; | |
469 ASSERT_TRUE(segment_stream.hasPosition()); | |
470 } | |
471 | |
472 TEST(SegmentStreamTest, SeekShouldNotSetIsCleared) { | |
473 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
474 ASSERT_FALSE(IsCleared(segment_stream)); | |
475 | |
476 segment_stream.seek(kInsideBufferPosition); | |
477 ASSERT_FALSE(IsCleared(segment_stream)); | |
478 } | |
479 | |
480 TEST(SegmentStreamTest, SeekShouldNotSetIsAtEndWhenSeekingInsideTheBuffer) { | |
481 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
482 ASSERT_FALSE(IsAtEnd(segment_stream)); | |
483 | |
484 segment_stream.seek(kInsideBufferPosition); | |
485 ASSERT_FALSE(IsAtEnd(segment_stream)); | |
486 } | |
487 | |
488 TEST(SegmentStreamTest, SeekShouldSetIsAtEndWhenSeekingToTheEndOfTheBuffer) { | |
489 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
490 ASSERT_FALSE(IsAtEnd(segment_stream)); | |
491 | |
492 segment_stream.seek(kBufferAllocationSize); | |
493 ASSERT_TRUE(IsAtEnd(segment_stream)); | |
494 } | |
495 | |
496 TEST(SegmentStreamTest, SeekShouldUpdatePosition) { | |
497 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
498 ASSERT_TRUE(PositionIsZero(segment_stream)); | |
499 | |
500 segment_stream.seek(kInsideBufferPosition); | |
501 ASSERT_EQ(kInsideBufferPosition, segment_stream.getPosition()); | |
502 } | |
503 | |
504 TEST(SegmentStreamTest, SeekShouldNotTruncatePositionWhenPastEnd) { | |
505 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
506 ASSERT_TRUE(PositionIsZero(segment_stream)); | |
507 | |
508 segment_stream.seek(kPastEndOfBufferPosition); | |
509 ASSERT_EQ(kPastEndOfBufferPosition, segment_stream.getPosition()); | |
510 } | |
511 | |
512 TEST(SegmentStreamTest, SeekShouldNotUpdateLength) { | |
513 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
514 | |
515 segment_stream.seek(kInsideBufferPosition); | |
516 ASSERT_EQ(kBufferAllocationSize, segment_stream.getLength()); | |
517 } | |
518 | |
519 TEST(SegmentStreamTest, MoveShouldNotSetCleared) { | |
520 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
521 | |
522 segment_stream.move(kInsideBufferPosition); | |
523 ASSERT_FALSE(IsCleared(segment_stream)); | |
524 } | |
525 | |
526 TEST(SegmentStreamTest, MoveShouldUpdatePosition) { | |
527 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
528 | |
529 segment_stream.move(kInsideBufferPosition); | |
530 ASSERT_EQ(kInsideBufferPosition, segment_stream.getPosition()); | |
531 } | |
532 | |
533 TEST(SegmentStreamTest, MoveShouldNotTruncatePositionWhenPastEnd) { | |
534 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
535 | |
536 segment_stream.move(kPastEndOfBufferPosition); | |
537 ASSERT_EQ(kPastEndOfBufferPosition, segment_stream.getPosition()); | |
538 } | |
539 | |
540 TEST(SegmentStreamTest, MoveShouldClampPositionToZeroWhenGoingNegative) { | |
541 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
542 | |
543 // Move the position off of 0 | |
544 std::array<char, 1> read_buffer; | |
545 segment_stream.read(read_buffer.data(), 1); | |
546 ASSERT_FALSE(PositionIsZero(segment_stream)); | |
547 | |
548 segment_stream.move(-2); | |
549 ASSERT_TRUE(PositionIsZero(segment_stream)); | |
550 } | |
551 | |
552 TEST(SegmentStreamTest, MoveShouldNotChangeLength) { | |
553 SegmentStream segment_stream = CreatePopulatedSegmentStreamReadable(); | |
554 ASSERT_TRUE(LengthIsAllocationSize(segment_stream)); | |
555 | |
556 segment_stream.move(kInsideBufferPosition); | |
557 ASSERT_TRUE(LengthIsAllocationSize(segment_stream)); | |
558 } | |
559 | |
560 TEST(SegmentStreamTest, HasLengthShouldBeSupported) { | |
561 blink::SegmentStream segment_stream; | |
562 ASSERT_TRUE(segment_stream.hasLength()); | |
563 } | |
564 | |
565 } // namespace blink | |
566 | |
567 namespace { | |
568 | |
569 testing::AssertionResult IsCleared(const blink::SegmentStream& segment_stream) { | |
570 if (segment_stream.IsCleared()) | |
571 return testing::AssertionSuccess(); | |
572 | |
573 return testing::AssertionFailure() << "SegmentStream is not clear"; | |
574 } | |
575 | |
576 testing::AssertionResult IsAtEnd(const blink::SegmentStream& segment_stream) { | |
577 if (segment_stream.isAtEnd()) | |
578 return testing::AssertionSuccess(); | |
579 | |
580 return testing::AssertionFailure() << "SegmentStream is not at the end"; | |
581 } | |
582 | |
583 testing::AssertionResult PositionIsZero( | |
584 const blink::SegmentStream& segment_stream) { | |
585 if (segment_stream.getPosition() == 0ul) | |
586 return testing::AssertionSuccess(); | |
587 | |
588 return testing::AssertionFailure() << "SegmentStream position is not 0"; | |
589 } | |
590 | |
591 testing::AssertionResult PositionIsInsideBuffer( | |
592 const blink::SegmentStream& segment_stream) { | |
593 if (segment_stream.getPosition() == kInsideBufferPosition) | |
594 return testing::AssertionSuccess(); | |
595 | |
596 return testing::AssertionFailure() | |
597 << "SegmentStream position is not inside the buffer"; | |
598 } | |
599 | |
600 testing::AssertionResult PositionIsAtEndOfBuffer( | |
601 const blink::SegmentStream& segment_stream) { | |
602 if (segment_stream.getPosition() == kBufferAllocationSize) | |
603 return testing::AssertionSuccess(); | |
604 | |
605 return testing::AssertionFailure() | |
606 << "SegmentStream position is not at the end of the buffer"; | |
607 } | |
608 | |
609 testing::AssertionResult LengthIsZero( | |
610 const blink::SegmentStream& segment_stream) { | |
611 if (segment_stream.getLength() == 0ul) | |
612 return testing::AssertionSuccess(); | |
613 | |
614 return testing::AssertionFailure() << "SegmentStream length is not 0"; | |
615 } | |
616 | |
617 testing::AssertionResult LengthIsAllocationSize( | |
618 const blink::SegmentStream& segment_stream) { | |
619 if (segment_stream.getLength() == kBufferAllocationSize) | |
620 return testing::AssertionSuccess(); | |
621 | |
622 return testing::AssertionFailure() | |
623 << "SegmentStream length is not the allocation size"; | |
624 } | |
625 | |
626 blink::SegmentStream CreatePopulatedSegmentStreamReadable() { | |
627 blink::SegmentStream segment_stream; | |
628 segment_stream.SetReader(CreateSegmentReader()); | |
629 return segment_stream; | |
630 } | |
631 | |
632 RefPtr<blink::SegmentReader> CreateSegmentReader() { | |
633 std::array<char, kBufferAllocationSize> raw_buffer; | |
634 | |
635 RefPtr<blink::SharedBuffer> shared_buffer = | |
636 blink::SharedBuffer::Create(raw_buffer.data(), kBufferAllocationSize); | |
637 | |
638 RefPtr<blink::SegmentReader> segment_reader = | |
639 blink::SegmentReader::CreateFromSharedBuffer(std::move(shared_buffer)); | |
640 | |
641 return segment_reader; | |
642 } | |
643 | |
644 } // namespace | |
OLD | NEW |