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