#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));
}