Move gif image decoder to SkCodec

third_party/WebKit/Source/platform/image-decoders/SegmentStreamTest.cpp

+// Copyright (c) 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "platform/image-decoders/SegmentStream.h"
+
+#include <memory>
+#include "platform/SharedBuffer.h"
+#include "platform/wtf/PtrUtil.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+// SegmentStream has 4 accessors which do not alter state:
+// - isCleared()
+// - isAtEnd()
+// - getPosition()
+// - getLength()
+//
+// For every operation which changes state we can test:
+// - the operation completed as expected,
+// - the accessors did not change, and/or
+// - the accessors changed in the way we expected.
+//
+// There are actually 2 more accessors:
+// - hasPosition()
+// - hasLength()
+// but these should always return true to indicate that we can call getLength()
+// for example. So let's not add them to every state changing operation and add
+// needless complexity.
+
+namespace {
+
+constexpr size_t kBufferAllocationSize = 20;
+constexpr size_t kInsideBufferPosition = 10;
+constexpr size_t kPastEndOfBufferPosition = 30;
+
+testing::AssertionResult IsCleared(const blink::SegmentStream&);
+testing::AssertionResult IsAtEnd(const blink::SegmentStream&);
+testing::AssertionResult PositionIsZero(const blink::SegmentStream&);
+testing::AssertionResult PositionIsInsideBuffer(const blink::SegmentStream&);
+testing::AssertionResult PositionIsAtEndOfBuffer(const blink::SegmentStream&);
+testing::AssertionResult LengthIsZero(const blink::SegmentStream&);
+testing::AssertionResult LengthIsAllocationSize(const blink::SegmentStream&);
+
+// Many of these tests require a SegmentStream that can be read from.
+// This means the stream must have a buffer and contents.
+//
+// This function creates a buffer of size |kBufferAllocationSize|
+// and prepares a SegmentStream with that buffer.
+void MakeSegmentStreamReadable(blink::SegmentStream* segment_stream) {

[scroggo_chromium, 2017/04/26 19:02:23]

I guess you named it this because it will make read() succeed? It sounds to me
like it changes it from opaque to readable, but really it populates it with data
(although really, it's uninitialized data, but I think that should be fine so
long as you don't try to do any comparisons?). What about something like:

- PrepareSegmentStream
- InitSegmentStream
- PopulateSegmentStream
- SupplySegmentReader

[cblume, 2017/04/26 19:16:06]

I just unblocked moving for SkNoncopyable types, which means I can now make this
even more simple: I can return the created SegmentStream.

But you are right, "readable" isn't quite right. I like "Populate".

This will become CreatePopulatedSegmentStream(), which I think will make things
much easier.

+  std::array<char, kBufferAllocationSize> raw_buffer;
+
+  RefPtr<blink::SharedBuffer> shared_buffer =
+      blink::SharedBuffer::Create(raw_buffer.data(), kBufferAllocationSize);
+
+  RefPtr<blink::SegmentReader> segment_reader =
+      blink::SegmentReader::CreateFromSharedBuffer(std::move(shared_buffer));
+
+  segment_stream->SetReader(segment_reader.Get());
+}
+
+}  // namespace
+
+namespace blink {
+
+TEST(SegmentStreamTest, DefaultConstructorShouldSetIsCleared) {
+  SegmentStream segment_stream;
+
+  ASSERT_TRUE(IsCleared(segment_stream));
+}
+
+TEST(SegmentStreamTest, DefaultConstructorShouldSetIsAtEnd) {
+  SegmentStream segment_stream;
+
+  ASSERT_TRUE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest, DefaultContructorShouldClearPosition) {
+  SegmentStream segment_stream;
+
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+}
+
+TEST(SegmentStreamTest, DefaultConstructorShouldHaveZeroLength) {
+  SegmentStream segment_stream;
+
+  ASSERT_TRUE(LengthIsZero(segment_stream));
+}
+
+TEST(SegmentStreamTest, SetReaderShouldUnsetIsCleared) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  ASSERT_FALSE(IsCleared(segment_stream));
+}
+
+TEST(SegmentStreamTest, SetReaderShouldUnsetIsAtEnd) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest, SetReaderShouldNotChangePosition) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+}
+
+TEST(SegmentStreamTest, SetReaderShouldUpdateLength) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  ASSERT_TRUE(LengthIsAllocationSize(segment_stream));
+}
+
+TEST(SegmentStreamTest, SetReaderShouldSetIsClearedWhenSetToNull) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+  ASSERT_FALSE(IsCleared(segment_stream));
+
+  segment_stream.SetReader(nullptr);
+  ASSERT_TRUE(IsCleared(segment_stream));
+}
+
+TEST(SegmentStreamTest, SetReaderShouldSetIsClearedWhenReaderSizeNotBigEnough) {
+  SegmentStream segment_stream;
+
+  segment_stream.seek(kPastEndOfBufferPosition);
+
+  MakeSegmentStreamReadable(&segment_stream);
+
+  ASSERT_TRUE(IsCleared(segment_stream));
+}
+
+TEST(SegmentStreamTest, SetReaderShouldSetIsAtEndWhenReaderSizeNotBigEnough) {
+  SegmentStream segment_stream;
+
+  segment_stream.seek(kPastEndOfBufferPosition);
+
+  MakeSegmentStreamReadable(&segment_stream);
+
+  ASSERT_TRUE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest,
+     SetReaderShouldNotChangePositionWhenReaderSizeNotBigEnough) {
+  SegmentStream segment_stream;
+
+  segment_stream.seek(kPastEndOfBufferPosition);
+
+  MakeSegmentStreamReadable(&segment_stream);
+
+  ASSERT_EQ(kPastEndOfBufferPosition, segment_stream.getPosition());
+}
+
+TEST(SegmentStreamTest, SetReaderShouldChangeLengthWhenReaderSizeNotBigEnough) {
+  SegmentStream segment_stream;
+
+  segment_stream.seek(kPastEndOfBufferPosition);
+
+  MakeSegmentStreamReadable(&segment_stream);
+
+  ASSERT_TRUE(LengthIsAllocationSize(segment_stream));
+}
+
+TEST(SegmentStreamTest, SetReaderShouldSetIsAtEndWhenSetToNull) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+
+  segment_stream.SetReader(nullptr);
+  ASSERT_TRUE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest, SetReaderShouldNotChangePositionWhenSetToNull) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  std::array<char, kInsideBufferPosition> read_buffer;
+  const size_t amount_read =
+      segment_stream.read(read_buffer.data(), kInsideBufferPosition);
+  ASSERT_EQ(kInsideBufferPosition, amount_read);
+  const size_t pre_nulled_position = segment_stream.getPosition();
+  ASSERT_EQ(amount_read, pre_nulled_position);
+
+  segment_stream.SetReader(nullptr);
+  ASSERT_EQ(pre_nulled_position, segment_stream.getPosition());
+}
+
+TEST(SegmentStreamTest, SetReaderShouldClearLengthWhenSetToNull) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  segment_stream.SetReader(nullptr);
+  ASSERT_TRUE(LengthIsZero(segment_stream));
+}
+
+TEST(SegmentStreamTest, ReadShouldConsumeBuffer) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  std::array<char, kInsideBufferPosition> read_buffer;
+  const size_t amount_read =
+      segment_stream.read(read_buffer.data(), kInsideBufferPosition);
+  ASSERT_EQ(kInsideBufferPosition, amount_read);
+}
+
+TEST(SegmentStreamTest, ReadShouldNotClear) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  std::array<char, kInsideBufferPosition> read_buffer;
+  segment_stream.read(read_buffer.data(), kInsideBufferPosition);
+  ASSERT_FALSE(IsCleared(segment_stream));
+}
+
+TEST(SegmentStreamTest, ReadShouldUpdateIsAtEnd) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+
+  std::array<char, kBufferAllocationSize> read_buffer;
+  const size_t amount_read =
+      segment_stream.read(read_buffer.data(), kBufferAllocationSize);
+  ASSERT_EQ(kBufferAllocationSize, amount_read);
+  ASSERT_TRUE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest, ReadShouldUpdatePosition) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+
+  std::array<char, kInsideBufferPosition> read_buffer;
+  const size_t amount_read =
+      segment_stream.read(read_buffer.data(), kInsideBufferPosition);
+  ASSERT_EQ(amount_read, segment_stream.getPosition());
+  ASSERT_TRUE(PositionIsInsideBuffer(segment_stream));
+}
+
+TEST(SegmentStreamTest, ReadShouldNotChangeLength) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  const size_t length = segment_stream.getLength();
+  std::array<char, kInsideBufferPosition> read_buffer;
+  segment_stream.read(read_buffer.data(), kInsideBufferPosition);
+  ASSERT_EQ(segment_stream.getLength(), length);
+}
+
+TEST(SegmentStreamTest, ReadShouldNotConsumeBufferWhenCleared) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  std::array<char, kInsideBufferPosition> read_buffer;
+  const auto read_buffer_as_void_ptr =
+      reinterpret_cast<void*>(read_buffer.data());
+
+  segment_stream.SetReader(nullptr);
+  ASSERT_TRUE(IsCleared(segment_stream));
+
+  ASSERT_EQ(
+      0u, segment_stream.read(read_buffer_as_void_ptr, kInsideBufferPosition));
+}
+
+TEST(SegmentStreamTest, ReadShouldConsumeBufferWithoutGoingPastTheEnd) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  std::array<char, kPastEndOfBufferPosition> read_buffer;
+  const size_t amount_read =
+      segment_stream.read(read_buffer.data(), kPastEndOfBufferPosition);
+  ASSERT_EQ(amount_read, segment_stream.getLength());
+}
+
+TEST(SegmentStreamTest, ReadShouldSetIsAtEndWhenPastEnd) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+
+  std::array<char, kPastEndOfBufferPosition> read_buffer;
+  segment_stream.read(read_buffer.data(), kPastEndOfBufferPosition);
+  ASSERT_TRUE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest, ReadShouldTruncatePositionWhenPastEnd) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+
+  std::array<char, kPastEndOfBufferPosition> read_buffer;
+  const size_t amount_read =
+      segment_stream.read(read_buffer.data(), kPastEndOfBufferPosition);
+  ASSERT_EQ(amount_read, segment_stream.getPosition());
+  ASSERT_TRUE(PositionIsAtEndOfBuffer(segment_stream));
+}
+
+TEST(SegmentStreamTest, PeekShouldConsumeBuffer) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  std::array<char, kInsideBufferPosition> peek_buffer;
+  const size_t amount_peeked =
+      segment_stream.peek(peek_buffer.data(), kInsideBufferPosition);
+  ASSERT_EQ(kInsideBufferPosition, amount_peeked);
+}
+
+TEST(SegmentStreamTest, PeekShouldNotClear) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  std::array<char, kInsideBufferPosition> peek_buffer;
+  segment_stream.peek(peek_buffer.data(), kInsideBufferPosition);
+  ASSERT_FALSE(IsCleared(segment_stream));
+}
+
+TEST(SegmentStreamTest, PeekShouldNotUpdateIsAtEnd) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+
+  std::array<char, kBufferAllocationSize> peek_buffer;
+  const size_t amount_peeked =
+      segment_stream.peek(peek_buffer.data(), kBufferAllocationSize);
+  ASSERT_EQ(kBufferAllocationSize, amount_peeked);
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest, PeekShouldNotUpdatePosition) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+
+  std::array<char, kInsideBufferPosition> peek_buffer;
+  segment_stream.peek(peek_buffer.data(), kInsideBufferPosition);
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+}
+
+TEST(SegmentStreamTest, PeekShouldNotChangeLength) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  const size_t length = segment_stream.getLength();
+  std::array<char, kInsideBufferPosition> peek_buffer;
+  segment_stream.peek(peek_buffer.data(), kInsideBufferPosition);
+  ASSERT_EQ(length, segment_stream.getLength());
+}
+
+TEST(SegmentStreamTest, PeekShouldNotConsumeBufferWhenCleared) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  std::array<char, kInsideBufferPosition> peek_buffer;
+  const auto peek_buffer_as_void_ptr =
+      reinterpret_cast<void*>(peek_buffer.data());
+
+  segment_stream.SetReader(nullptr);
+  ASSERT_TRUE(IsCleared(segment_stream));
+
+  ASSERT_EQ(
+      0u, segment_stream.peek(peek_buffer_as_void_ptr, kInsideBufferPosition));
+}
+
+TEST(SegmentStreamTest, PeekShouldConsumeBufferWithoutGoingPastTheEnd) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  std::array<char, kPastEndOfBufferPosition> peek_buffer;
+  const size_t amount_peeked =
+      segment_stream.peek(peek_buffer.data(), kPastEndOfBufferPosition);
+  ASSERT_EQ(amount_peeked, segment_stream.getLength());
+}
+
+TEST(SegmentStreamTest, PeekShouldNotSetIsAtEndWhenPastEnd) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+
+  std::array<char, kPastEndOfBufferPosition> peek_buffer;
+  segment_stream.peek(peek_buffer.data(), kPastEndOfBufferPosition);
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest, PeekShouldNotTruncatePositionWhenPastEnd) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+
+  std::array<char, kPastEndOfBufferPosition> peek_buffer;
+  segment_stream.peek(peek_buffer.data(), kPastEndOfBufferPosition);
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+}
+
+TEST(SegmentStreamTest, RewindShouldNotClear) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  std::array<char, kInsideBufferPosition> read_buffer;
+  segment_stream.read(read_buffer.data(), kInsideBufferPosition);
+  ASSERT_FALSE(IsCleared(segment_stream));
+
+  segment_stream.rewind();
+  ASSERT_FALSE(IsCleared(segment_stream));
+}
+
+TEST(SegmentStreamTest, RewindShouldNotSetAtEnd) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  std::array<char, kInsideBufferPosition> read_buffer;
+  segment_stream.read(read_buffer.data(), kInsideBufferPosition);
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+
+  segment_stream.rewind();
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest, RewindShouldResetPosition) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  std::array<char, kInsideBufferPosition> read_buffer;
+  segment_stream.read(read_buffer.data(), kInsideBufferPosition);
+  ASSERT_TRUE(PositionIsInsideBuffer(segment_stream));
+
+  segment_stream.rewind();
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+}
+
+TEST(SegmentStreamTest, RewindShouldNotChangeLength) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  std::array<char, kInsideBufferPosition> read_buffer;
+  segment_stream.read(read_buffer.data(), kInsideBufferPosition);
+  const size_t pre_rewind_length = segment_stream.getLength();
+
+  segment_stream.rewind();
+  ASSERT_EQ(pre_rewind_length, segment_stream.getLength());
+}
+
+TEST(SegmentStreamTest, HasPositionShouldBeSupported) {
+  blink::SegmentStream segment_stream;
+  ASSERT_TRUE(segment_stream.hasPosition());
+}
+
+TEST(SegmentStreamTest, SeekShouldNotSetIsCleared) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+  ASSERT_FALSE(IsCleared(segment_stream));
+
+  segment_stream.seek(kInsideBufferPosition);
+  ASSERT_FALSE(IsCleared(segment_stream));
+}
+
+TEST(SegmentStreamTest, SeekShouldNotSetIsAtEndWhenSeekingInsideTheBuffer) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+
+  segment_stream.seek(kInsideBufferPosition);
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest, SeekShouldSetIsAtEndWhenSeekingToTheEndOfTheBuffer) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+  ASSERT_FALSE(IsAtEnd(segment_stream));
+
+  segment_stream.seek(kBufferAllocationSize);
+  ASSERT_TRUE(IsAtEnd(segment_stream));
+}
+
+TEST(SegmentStreamTest, SeekShouldUpdatePosition) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+
+  segment_stream.seek(kInsideBufferPosition);
+  ASSERT_EQ(kInsideBufferPosition, segment_stream.getPosition());
+}
+
+TEST(SegmentStreamTest, SeekShouldNotTruncatePositionWhenPastEnd) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+
+  segment_stream.seek(kPastEndOfBufferPosition);
+  ASSERT_EQ(kPastEndOfBufferPosition, segment_stream.getPosition());
+}
+
+TEST(SegmentStreamTest, SeekShouldNotUpdateLength) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  segment_stream.seek(kInsideBufferPosition);
+  ASSERT_EQ(kBufferAllocationSize, segment_stream.getLength());
+}
+
+TEST(SegmentStreamTest, MoveShouldNotSetCleared) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  segment_stream.move(kInsideBufferPosition);
+  ASSERT_FALSE(IsCleared(segment_stream));
+}
+
+TEST(SegmentStreamTest, MoveShouldUpdatePosition) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  segment_stream.move(kInsideBufferPosition);
+  ASSERT_EQ(kInsideBufferPosition, segment_stream.getPosition());
+}
+
+TEST(SegmentStreamTest, MoveShouldNotTruncatePositionWhenPastEnd) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  segment_stream.move(kPastEndOfBufferPosition);
+  ASSERT_EQ(kPastEndOfBufferPosition, segment_stream.getPosition());
+}
+
+TEST(SegmentStreamTest, MoveShouldClampPositionToZeroWhenGoingNegative) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+
+  // Move the position off of 0
+  std::array<char, 1> read_buffer;
+  segment_stream.read(read_buffer.data(), 1);
+  ASSERT_FALSE(PositionIsZero(segment_stream));
+
+  segment_stream.move(-2);
+  ASSERT_TRUE(PositionIsZero(segment_stream));
+}
+
+TEST(SegmentStreamTest, MoveShouldNotChangeLength) {
+  SegmentStream segment_stream;
+  MakeSegmentStreamReadable(&segment_stream);
+  ASSERT_TRUE(LengthIsAllocationSize(segment_stream));
+
+  segment_stream.move(kInsideBufferPosition);
+  ASSERT_TRUE(LengthIsAllocationSize(segment_stream));
+}
+
+TEST(SegmentStreamTest, HasLengthShouldBeSupported) {
+  blink::SegmentStream segment_stream;
+  ASSERT_TRUE(segment_stream.hasLength());
+}
+
+}  // namespace blink
+
+namespace {
+
+testing::AssertionResult IsCleared(const blink::SegmentStream& segment_stream) {
+  if (segment_stream.IsCleared())
+    return testing::AssertionSuccess();
+
+  return testing::AssertionFailure() << "SegmentStream is not clear";
+}
+
+testing::AssertionResult IsAtEnd(const blink::SegmentStream& segment_stream) {
+  if (segment_stream.isAtEnd())
+    return testing::AssertionSuccess();
+
+  return testing::AssertionFailure() << "SegmentStream is not at the end";
+}
+
+testing::AssertionResult PositionIsZero(
+    const blink::SegmentStream& segment_stream) {
+  if (segment_stream.getPosition() == 0ul)
+    return testing::AssertionSuccess();
+
+  return testing::AssertionFailure() << "SegmentStream position is not 0";
+}
+
+testing::AssertionResult PositionIsInsideBuffer(
+    const blink::SegmentStream& segment_stream) {
+  if (segment_stream.getPosition() == kInsideBufferPosition)
+    return testing::AssertionSuccess();
+
+  return testing::AssertionFailure()
+         << "SegmentStream position is not inside the buffer";
+}
+
+testing::AssertionResult PositionIsAtEndOfBuffer(
+    const blink::SegmentStream& segment_stream) {
+  if (segment_stream.getPosition() == kBufferAllocationSize)
+    return testing::AssertionSuccess();
+
+  return testing::AssertionFailure()
+         << "SegmentStream position is not at the end of the buffer";
+}
+
+testing::AssertionResult LengthIsZero(
+    const blink::SegmentStream& segment_stream) {
+  if (segment_stream.getLength() == 0ul)
+    return testing::AssertionSuccess();
+
+  return testing::AssertionFailure() << "SegmentStream length is not 0";
+}
+
+testing::AssertionResult LengthIsAllocationSize(
+    const blink::SegmentStream& segment_stream) {
+  if (segment_stream.getLength() == kBufferAllocationSize)
+    return testing::AssertionSuccess();
+
+  return testing::AssertionFailure()
+         << "SegmentStream length is not the allocation size";
+}
+
+}  // namespace