TestReadStreamToString.cpp

Enable keyboard shortcuts

#include "gtest/gtest.h"

#include "Helpers.h"

#include "nsCOMPtr.h"

#include "nsNetUtil.h"

#include "nsStringStream.h"

// Here we test the reading a pre-allocated size

TEST(TestReadStreamToString, SyncStreamPreAllocatedSize)

  nsCString buffer;

  buffer.AssignLiteral("Hello world!");

  nsCOMPtr<nsIInputStream> stream;

  ASSERT_EQ(NS_OK, NS_NewCStringInputStream(getter_AddRefs(stream), buffer));

  uint64_t written;

  nsAutoCString result;

  result.SetLength(5);

  void* ptr = result.BeginWriting();

  ASSERT_EQ(NS_OK, NS_ReadInputStreamToString(stream, result, 5, &written));

  ASSERT_EQ((uint64_t)5, written);

  ASSERT_TRUE(nsCString(buffer.get(), 5).Equals(result));

  // The pointer should be equal: no relocation.

  ASSERT_EQ(ptr, result.BeginWriting());

// Here we test the reading the full size of a sync stream

TEST(TestReadStreamToString, SyncStreamFullSize)

  nsCString buffer;

  buffer.AssignLiteral("Hello world!");

  nsCOMPtr<nsIInputStream> stream;

  ASSERT_EQ(NS_OK, NS_NewCStringInputStream(getter_AddRefs(stream), buffer));

  uint64_t written;

  nsAutoCString result;

  ASSERT_EQ(NS_OK, NS_ReadInputStreamToString(stream, result, buffer.Length(),

                                              &written));

  ASSERT_EQ(buffer.Length(), written);

  ASSERT_TRUE(buffer.Equals(result));

// Here we test the reading less than the full size of a sync stream

TEST(TestReadStreamToString, SyncStreamLessThan)

  nsCString buffer;

  buffer.AssignLiteral("Hello world!");

  nsCOMPtr<nsIInputStream> stream;

  ASSERT_EQ(NS_OK, NS_NewCStringInputStream(getter_AddRefs(stream), buffer));

  uint64_t written;

  nsAutoCString result;

  ASSERT_EQ(NS_OK, NS_ReadInputStreamToString(stream, result, 5, &written));

  ASSERT_EQ((uint64_t)5, written);

  ASSERT_TRUE(nsCString(buffer.get(), 5).Equals(result));

// Here we test the reading more than the full size of a sync stream

TEST(TestReadStreamToString, SyncStreamMoreThan)

  nsCString buffer;

  buffer.AssignLiteral("Hello world!");

  nsCOMPtr<nsIInputStream> stream;

  ASSERT_EQ(NS_OK, NS_NewCStringInputStream(getter_AddRefs(stream), buffer));

  uint64_t written;

  nsAutoCString result;

  // Reading more than the buffer size.

  ASSERT_EQ(NS_OK, NS_ReadInputStreamToString(stream, result,

                                              buffer.Length() + 5, &written));

  ASSERT_EQ(buffer.Length(), written);

  ASSERT_TRUE(buffer.Equals(result));

// Here we test the reading a sync stream without passing the size

TEST(TestReadStreamToString, SyncStreamUnknownSize)

  nsCString buffer;

  buffer.AssignLiteral("Hello world!");

  nsCOMPtr<nsIInputStream> stream;

  ASSERT_EQ(NS_OK, NS_NewCStringInputStream(getter_AddRefs(stream), buffer));

  uint64_t written;

  nsAutoCString result;

  // Reading all without passing the size

  ASSERT_EQ(NS_OK, NS_ReadInputStreamToString(stream, result, -1, &written));

  ASSERT_EQ(buffer.Length(), written);

  ASSERT_TRUE(buffer.Equals(result));

// Here we test the reading the full size of an async stream

TEST(TestReadStreamToString, AsyncStreamFullSize)

  nsCString buffer;

  buffer.AssignLiteral("Hello world!");

  nsCOMPtr<nsIInputStream> stream = new testing::AsyncStringStream(buffer);

  uint64_t written;

  nsAutoCString result;

  ASSERT_EQ(NS_OK, NS_ReadInputStreamToString(stream, result, buffer.Length(),

                                              &written));

  ASSERT_EQ(buffer.Length(), written);

  ASSERT_TRUE(buffer.Equals(result));

// Here we test the reading less than the full size of an async stream

TEST(TestReadStreamToString, AsyncStreamLessThan)

  nsCString buffer;

  buffer.AssignLiteral("Hello world!");

  nsCOMPtr<nsIInputStream> stream = new testing::AsyncStringStream(buffer);

  uint64_t written;

  nsAutoCString result;

  ASSERT_EQ(NS_OK, NS_ReadInputStreamToString(stream, result, 5, &written));

  ASSERT_EQ((uint64_t)5, written);

  ASSERT_TRUE(nsCString(buffer.get(), 5).Equals(result));

// Here we test the reading more than the full size of an async stream

TEST(TestReadStreamToString, AsyncStreamMoreThan)

  nsCString buffer;

  buffer.AssignLiteral("Hello world!");

  nsCOMPtr<nsIInputStream> stream = new testing::AsyncStringStream(buffer);

  uint64_t written;

  nsAutoCString result;

  // Reading more than the buffer size.

  ASSERT_EQ(NS_OK, NS_ReadInputStreamToString(stream, result,

                                              buffer.Length() + 5, &written));

  ASSERT_EQ(buffer.Length(), written);

  ASSERT_TRUE(buffer.Equals(result));

// Here we test the reading an async stream without passing the size

TEST(TestReadStreamToString, AsyncStreamUnknownSize)

  nsCString buffer;

  buffer.AssignLiteral("Hello world!");

  nsCOMPtr<nsIInputStream> stream = new testing::AsyncStringStream(buffer);

  uint64_t written;

  nsAutoCString result;

  // Reading all without passing the size

  ASSERT_EQ(NS_OK, NS_ReadInputStreamToString(stream, result, -1, &written));

  ASSERT_EQ(buffer.Length(), written);

  ASSERT_TRUE(buffer.Equals(result));

// Here we test the reading an async big stream without passing the size

TEST(TestReadStreamToString, AsyncStreamUnknownBigSize)

  nsCString buffer;

  buffer.SetLength(4096 * 2);

  for (uint32_t i = 0; i < 4096 * 2; ++i) {

    buffer.BeginWriting()[i] = i % 10;

  nsCOMPtr<nsIInputStream> stream = new testing::AsyncStringStream(buffer);

  uint64_t written;

  nsAutoCString result;

  // Reading all without passing the size

  ASSERT_EQ(NS_OK, NS_ReadInputStreamToString(stream, result, -1, &written));

  ASSERT_EQ(buffer.Length(), written);

  ASSERT_TRUE(buffer.Equals(result));