Global Metrics

Spaces Data

Minimal test - lines (179, 200)

Code

TEST(SeekableStreamWrapper, Interfaces)
{
  nsCOMPtr reader;
  nsCOMPtr writer;

  NewSeekablePipe(getter_AddRefs(reader), getter_AddRefs(writer));

  nsCOMPtr readerType1 = do_QueryInterface(reader);
  EXPECT_TRUE(readerType1);

  nsCOMPtr readerType2 = do_QueryInterface(reader);
  EXPECT_TRUE(readerType2);

  nsCOMPtr readerType3 = do_QueryInterface(reader);
  EXPECT_TRUE(readerType3);

  nsCOMPtr readerType4 = do_QueryInterface(reader);
  EXPECT_TRUE(readerType4);

  nsCOMPtr readerType5 = do_QueryInterface(reader);
  EXPECT_TRUE(readerType5);
}

Minimal test - lines (13, 32)

Code

static void NewSeekablePipe(nsIInputStream** aReader,
                            nsIOutputStream** aWriter) {
  nsCOMPtr reader;
  nsCOMPtr writer;

  nsresult rv =
      NS_NewPipe2(getter_AddRefs(reader), getter_AddRefs(writer), true, true);
  ASSERT_TRUE(NS_SUCCEEDED(rv));

  nsCOMPtr seekable = do_QueryInterface(reader);
  EXPECT_FALSE(seekable);

  nsCOMPtr wrapped;
  rv = mozilla::SeekableStreamWrapper::MaybeWrap(do_AddRef(reader),
                                                 getter_AddRefs(wrapped));
  ASSERT_TRUE(NS_SUCCEEDED(rv));

  wrapped.forget(aReader);
  writer.forget(aWriter);
}

Minimal test - lines (54, 177)

Code

TEST(SeekableStreamWrapper, WrapPipe)
{
  nsCOMPtr reader;
  nsCOMPtr writer;

  NewSeekablePipe(getter_AddRefs(reader), getter_AddRefs(writer));

  nsTArray inputData;
  testing::CreateData(1024, inputData);

  uint32_t numWritten = 0;
  nsresult rv =
      writer->Write(inputData.Elements(), inputData.Length(), &numWritten);
  EXPECT_TRUE(NS_SUCCEEDED(rv));
  EXPECT_EQ(numWritten, 1024u);

  nsCOMPtr seekable = do_QueryInterface(reader);
  ASSERT_TRUE(seekable);

  nsCOMPtr cloneable = do_QueryInterface(reader);
  ASSERT_TRUE(cloneable);
  ASSERT_TRUE(cloneable->GetCloneable());

  nsCOMPtr clone1;
  rv = cloneable->Clone(getter_AddRefs(clone1));
  ASSERT_TRUE(NS_SUCCEEDED(rv));
  ASSERT_TRUE(clone1);

  // Check that we can read the first 512 bytes.
  {
    char buf[512];
    uint32_t numRead = 0;
    rv = reader->Read(buf, 512, &numRead);
    EXPECT_TRUE(NS_SUCCEEDED(rv));
    EXPECT_EQ(numRead, 512u);
    EXPECT_EQ(mozilla::Span(inputData).First(512), mozilla::Span(buf));
  }

  // Check that we can read the second 512 bytes.
  {
    char buf[512];
    uint32_t numRead = 0;
    rv = reader->Read(buf, 512, &numRead);
    EXPECT_TRUE(NS_SUCCEEDED(rv));
    EXPECT_EQ(numRead, 512u);
    EXPECT_EQ(mozilla::Span(inputData).Last(512), mozilla::Span(buf));
  }

  // Should be at the end of the pipe
  {
    char buf[1];
    uint32_t numRead = 0;
    rv = reader->Read(buf, 1, &numRead);
    EXPECT_EQ(rv, NS_BASE_STREAM_WOULD_BLOCK);
  }

  // Re-read the second 512 bytes by seeking back.
  {
    rv = seekable->Seek(nsISeekableStream::NS_SEEK_CUR, -512);
    EXPECT_TRUE(NS_SUCCEEDED(rv));

    char buf[512];
    uint32_t numRead = 0;
    rv = reader->Read(buf, 512, &numRead);
    EXPECT_TRUE(NS_SUCCEEDED(rv));
    EXPECT_EQ(numRead, 512u);
    EXPECT_EQ(mozilla::Span(inputData).Last(512), mozilla::Span(buf));
  }

  // Re-read the last 256 bytes by seeking absolutely
  {
    rv = seekable->Seek(nsISeekableStream::NS_SEEK_SET, 768);
    EXPECT_TRUE(NS_SUCCEEDED(rv));

    char buf[256];
    uint32_t numRead = 0;
    rv = reader->Read(buf, 256, &numRead);
    EXPECT_TRUE(NS_SUCCEEDED(rv));
    EXPECT_EQ(numRead, 256u);
    EXPECT_EQ(mozilla::Span(inputData).Last(256), mozilla::Span(buf));
  }

  // Double-check that we haven't impacted our clone
  {
    char buf[1024];
    uint32_t numRead = 0;
    rv = clone1->Read(buf, 1024, &numRead);
    EXPECT_TRUE(NS_SUCCEEDED(rv));
    EXPECT_EQ(numRead, 1024u);
    EXPECT_EQ(mozilla::Span(inputData), mozilla::Span(buf));
  }

  // The clone should no longer be seekable once closed.
  rv = clone1->Close();
  EXPECT_TRUE(NS_SUCCEEDED(rv));
  nsCOMPtr clone1Seekable(do_QueryInterface(clone1));
  rv = clone1Seekable->Seek(nsISeekableStream::NS_SEEK_SET, 0);
  EXPECT_TRUE(NS_FAILED(rv));

  // Should still be open
  {
    uint64_t available = 0;
    rv = reader->Available(&available);
    EXPECT_TRUE(NS_SUCCEEDED(rv));
    EXPECT_EQ(available, uint64_t(0));
  }

  // Close the original output stream
  rv = writer->Close();
  EXPECT_TRUE(NS_SUCCEEDED(rv));

  // Should be closed
  {
    uint64_t available = 0;
    rv = reader->Available(&available);
    EXPECT_EQ(rv, NS_BASE_STREAM_CLOSED);
  }

  // Seeing back to the beginning should re-open the stream which had reached
  // the end.
  rv = seekable->Seek(nsISeekableStream::NS_SEEK_SET, 0);
  EXPECT_TRUE(NS_SUCCEEDED(rv));
  testing::ConsumeAndValidateStream(reader, inputData);
}

Minimal test - lines (34, 52)

Code

TEST(SeekableStreamWrapper, NoWrap)
{
  nsTArray inputData;
  testing::CreateData(4096, inputData);
  nsDependentCSubstring inputString(inputData.Elements(), inputData.Length());

  nsCOMPtr stream;
  nsresult rv = NS_NewCStringInputStream(getter_AddRefs(stream), inputString);
  ASSERT_TRUE(NS_SUCCEEDED(rv));

  nsCOMPtr wrapped;
  rv = mozilla::SeekableStreamWrapper::MaybeWrap(do_AddRef(stream),
                                                 getter_AddRefs(wrapped));
  ASSERT_TRUE(NS_SUCCEEDED(rv));

  EXPECT_EQ(stream, wrapped);

  testing::ConsumeAndValidateStream(wrapped, inputString);
}