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