// Copyright 2018 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Tests for the Windows implementation of the test wrapper.

#include <windows.h>

#include <algorithm>
#include <vector>

#include "gtest/gtest.h"
#include "src/main/cpp/util/path_platform.h"
#include "src/main/native/windows/file.h"
#include "src/main/native/windows/util.h"
#include "src/test/cpp/util/windows_test_util.h"
#include "third_party/ijar/common.h"
#include "third_party/ijar/zip.h"
#include "tools/test/windows/tw.h"

#if !defined(_WIN32) && !defined(__CYGWIN__)
#error("This test should only be run on Windows")
#endif  // !defined(_WIN32) && !defined(__CYGWIN__)

namespace {

using bazel::tools::test_wrapper::FileInfo;
using bazel::tools::test_wrapper::IFStream;
using bazel::tools::test_wrapper::ZipEntryPaths;
using bazel::tools::test_wrapper::testing::TestOnly_AsMixedPath;
using bazel::tools::test_wrapper::testing::TestOnly_CdataEncode;
using bazel::tools::test_wrapper::testing::TestOnly_CreateIFStream;
using bazel::tools::test_wrapper::testing::TestOnly_CreateTee;
using bazel::tools::test_wrapper::testing::
    TestOnly_CreateUndeclaredOutputsAnnotations;
using bazel::tools::test_wrapper::testing::
    TestOnly_CreateUndeclaredOutputsManifest;
using bazel::tools::test_wrapper::testing::TestOnly_CreateZip;
using bazel::tools::test_wrapper::testing::TestOnly_GetEnv;
using bazel::tools::test_wrapper::testing::TestOnly_GetFileListRelativeTo;
using bazel::tools::test_wrapper::testing::TestOnly_GetMimeType;
using bazel::tools::test_wrapper::testing::TestOnly_ToZipEntryPaths;

class TestWrapperWindowsTest : public ::testing::Test {
 public:
  void TearDown() override {
    blaze_util::DeleteAllUnder(blaze_util::GetTestTmpDirW());
  }
};

void GetTestTmpdir(std::wstring* result, int line) {
  EXPECT_TRUE(TestOnly_GetEnv(L"TEST_TMPDIR", result))
      << __FILE__ << "(" << line << "): assertion failed here";
  ASSERT_GT(result->size(), 0)
      << __FILE__ << "(" << line << "): assertion failed here";
  std::replace(result->begin(), result->end(), L'/', L'\\');
  if (!bazel::windows::HasUncPrefix(result->c_str())) {
    *result = L"\\\\?\\" + *result;
  }
}

void CreateJunction(const std::wstring& name, const std::wstring& target,
                    int line) {
  std::wstring wname;
  std::wstring wtarget;
  EXPECT_TRUE(blaze_util::AsWindowsPath(name, &wname, nullptr))
      << __FILE__ << "(" << line << "): assertion failed here";
  EXPECT_TRUE(blaze_util::AsWindowsPath(target, &wtarget, nullptr))
      << __FILE__ << "(" << line << "): assertion failed here";
  EXPECT_EQ(bazel::windows::CreateJunction(wname, wtarget, nullptr),
            bazel::windows::CreateJunctionResult::kSuccess)
      << __FILE__ << "(" << line << "): assertion failed here";
}

void CompareFileInfos(std::vector<FileInfo> actual,
                      std::vector<FileInfo> expected, int line) {
  ASSERT_EQ(actual.size(), expected.size())
      << __FILE__ << "(" << line << "): assertion failed here";
  std::sort(actual.begin(), actual.end(),
            [](const FileInfo& a, const FileInfo& b) {
              return a.RelativePath() > b.RelativePath();
            });
  std::sort(expected.begin(), expected.end(),
            [](const FileInfo& a, const FileInfo& b) {
              return a.RelativePath() > b.RelativePath();
            });
  for (std::vector<FileInfo>::size_type i = 0; i < actual.size(); ++i) {
    ASSERT_EQ(actual[i].RelativePath(), expected[i].RelativePath())
        << __FILE__ << "(" << line << "): assertion failed here; index: " << i;
    ASSERT_EQ(actual[i].Size(), expected[i].Size())
        << __FILE__ << "(" << line << "): assertion failed here; index: " << i;
    ASSERT_EQ(actual[i].IsDirectory(), expected[i].IsDirectory())
        << __FILE__ << "(" << line << "): assertion failed here; index: " << i;
  }
}

// According to this StackOverflow post [1] `const` modifies what's on its
// *left*, and "const char" is equivalent to "char const".
// `ZipBuilder::EstimateSize`'s argument type is "char const* const*" meaning a
// mutable array (right *) of const pointers (left *) to const data (char).
//
// [1] https://stackoverflow.com/a/8091846/7778502
void CompareZipEntryPaths(char const* const* actual,
                          std::vector<const char*> expected, int line) {
  for (int i = 0; i < expected.size(); ++i) {
    EXPECT_NE(actual[i], nullptr)
        << __FILE__ << "(" << line << "): assertion failed here";
    EXPECT_EQ(std::string(actual[i]), std::string(expected[i]))
        << __FILE__ << "(" << line << "): assertion failed here";
  }
  EXPECT_EQ(actual[expected.size()], nullptr)
      << __FILE__ << "(" << line << "): assertion failed here; value was ("
      << actual[expected.size()] << ")";
}

#define GET_TEST_TMPDIR(result) GetTestTmpdir(result, __LINE__)
#define CREATE_JUNCTION(name, target) CreateJunction(name, target, __LINE__)
#define COMPARE_FILE_INFOS(actual, expected) \
  CompareFileInfos(actual, expected, __LINE__)
#define COMPARE_ZIP_ENTRY_PATHS(actual, expected) \
  CompareZipEntryPaths(actual, expected, __LINE__)

#define TOSTRING1(x) #x
#define TOSTRING(x) TOSTRING1(x)
#define TOWSTRING1(x) L##x
#define TOWSTRING(x) TOWSTRING1(x)
#define WLINE TOWSTRING(TOSTRING(__LINE__))

HANDLE FopenRead(const std::wstring& unc_path) {
  return CreateFileW(unc_path.c_str(), GENERIC_READ,
                     FILE_SHARE_READ | FILE_SHARE_DELETE, nullptr,
                     OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
}

HANDLE FopenContents(const wchar_t* wline, const char* contents, DWORD size) {
  std::wstring tmpdir;
  GET_TEST_TMPDIR(&tmpdir);
  std::wstring filename = tmpdir + L"\\tmp" + wline;
  EXPECT_TRUE(blaze_util::CreateDummyFile(filename, contents, size));
  return FopenRead(filename);
}

HANDLE FopenContents(const wchar_t* wline, const char* contents) {
  return FopenContents(wline, contents, strlen(contents));
}

TEST_F(TestWrapperWindowsTest, TestGetFileListRelativeTo) {
  std::wstring tmpdir;
  GET_TEST_TMPDIR(&tmpdir);

  // Create a directory structure to parse.
  std::wstring root = tmpdir + L"\\tmp" + WLINE;
  EXPECT_TRUE(CreateDirectoryW(root.c_str(), nullptr));
  EXPECT_TRUE(CreateDirectoryW((root + L"\\foo").c_str(), nullptr));
  EXPECT_TRUE(CreateDirectoryW((root + L"\\foo\\sub").c_str(), nullptr));
  EXPECT_TRUE(blaze_util::CreateDummyFile(root + L"\\foo\\sub\\file1", ""));
  EXPECT_TRUE(
      blaze_util::CreateDummyFile(root + L"\\foo\\sub\\file2", "hello"));
  EXPECT_TRUE(blaze_util::CreateDummyFile(root + L"\\foo\\file1", "foo"));
  EXPECT_TRUE(blaze_util::CreateDummyFile(root + L"\\foo\\file2", "foobar"));
  CREATE_JUNCTION(root + L"\\foo\\junc", root + L"\\foo\\sub");

  // Assert traversal of "root" -- should include all files, and also traverse
  // the junction.
  std::vector<FileInfo> actual;
  ASSERT_TRUE(TestOnly_GetFileListRelativeTo(root, &actual));

  std::vector<FileInfo> expected = {FileInfo(L"foo"),
                                    FileInfo(L"foo\\sub"),
                                    FileInfo(L"foo\\sub\\file1", 0),
                                    FileInfo(L"foo\\sub\\file2", 5),
                                    FileInfo(L"foo\\file1", 3),
                                    FileInfo(L"foo\\file2", 6),
                                    FileInfo(L"foo\\junc"),
                                    FileInfo(L"foo\\junc\\file1", 0),
                                    FileInfo(L"foo\\junc\\file2", 5)};
  COMPARE_FILE_INFOS(actual, expected);

  // Assert traversal of "foo" -- should include all files, but now with paths
  // relative to "foo".
  actual.clear();
  ASSERT_TRUE(
      TestOnly_GetFileListRelativeTo((root + L"\\foo").c_str(), &actual));

  expected = {FileInfo(L"sub"),
              FileInfo(L"sub\\file1", 0),
              FileInfo(L"sub\\file2", 5),
              FileInfo(L"file1", 3),
              FileInfo(L"file2", 6),
              FileInfo(L"junc"),
              FileInfo(L"junc\\file1", 0),
              FileInfo(L"junc\\file2", 5)};
  COMPARE_FILE_INFOS(actual, expected);

  // Assert traversal limited to the current directory (depth of 0).
  actual.clear();
  ASSERT_TRUE(TestOnly_GetFileListRelativeTo(root, &actual, 0));
  expected = {FileInfo(L"foo")};
  COMPARE_FILE_INFOS(actual, expected);

  // Assert traversal limited to depth of 1.
  actual.clear();
  ASSERT_TRUE(TestOnly_GetFileListRelativeTo(root, &actual, 1));
  expected = {FileInfo(L"foo"), FileInfo(L"foo\\sub"),
              FileInfo(L"foo\\file1", 3), FileInfo(L"foo\\file2", 6),
              FileInfo(L"foo\\junc")};
  COMPARE_FILE_INFOS(actual, expected);
}

TEST_F(TestWrapperWindowsTest, TestToZipEntryPaths) {
  // Pretend we already acquired a file list. The files don't have to exist.
  std::wstring root = L"c:\\nul\\root";
  std::vector<FileInfo> files = {FileInfo(L"foo"),
                                 FileInfo(L"foo\\sub"),
                                 FileInfo(L"foo\\sub\\file1", 0),
                                 FileInfo(L"foo\\sub\\file2", 5),
                                 FileInfo(L"foo\\file1", 3),
                                 FileInfo(L"foo\\file2", 6),
                                 FileInfo(L"foo\\junc"),
                                 FileInfo(L"foo\\junc\\file1", 0),
                                 FileInfo(L"foo\\junc\\file2", 5)};

  ZipEntryPaths actual;
  ASSERT_TRUE(TestOnly_ToZipEntryPaths(root, files, &actual));
  ASSERT_EQ(actual.Size(), 9);

  std::vector<const char*> expected_abs_paths = {
      "c:/nul/root/foo/",          "c:/nul/root/foo/sub/",
      "c:/nul/root/foo/sub/file1", "c:/nul/root/foo/sub/file2",
      "c:/nul/root/foo/file1",     "c:/nul/root/foo/file2",
      "c:/nul/root/foo/junc/",     "c:/nul/root/foo/junc/file1",
      "c:/nul/root/foo/junc/file2"};
  COMPARE_ZIP_ENTRY_PATHS(actual.AbsPathPtrs(), expected_abs_paths);

  std::vector<const char*> expected_entry_paths = {
      "foo/",      "foo/sub/",  "foo/sub/file1",  "foo/sub/file2", "foo/file1",
      "foo/file2", "foo/junc/", "foo/junc/file1", "foo/junc/file2"};
  COMPARE_ZIP_ENTRY_PATHS(actual.EntryPathPtrs(), expected_entry_paths);
}

TEST_F(TestWrapperWindowsTest, TestToZipEntryPathsLongPathRoot) {
  // Pretend we already acquired a file list. The files don't have to exist.
  // Assert that the root is allowed to have the `\\?\` prefix, but the zip
  // entry paths won't have it.
  std::wstring root = L"\\\\?\\c:\\nul\\unc";
  std::vector<FileInfo> files = {FileInfo(L"foo"),
                                 FileInfo(L"foo\\sub"),
                                 FileInfo(L"foo\\sub\\file1", 0),
                                 FileInfo(L"foo\\sub\\file2", 5),
                                 FileInfo(L"foo\\file1", 3),
                                 FileInfo(L"foo\\file2", 6),
                                 FileInfo(L"foo\\junc"),
                                 FileInfo(L"foo\\junc\\file1", 0),
                                 FileInfo(L"foo\\junc\\file2", 5)};

  ZipEntryPaths actual;
  ASSERT_TRUE(TestOnly_ToZipEntryPaths(root, files, &actual));
  ASSERT_EQ(actual.Size(), 9);

  std::vector<const char*> expected_abs_paths = {
      "c:/nul/unc/foo/",          "c:/nul/unc/foo/sub/",
      "c:/nul/unc/foo/sub/file1", "c:/nul/unc/foo/sub/file2",
      "c:/nul/unc/foo/file1",     "c:/nul/unc/foo/file2",
      "c:/nul/unc/foo/junc/",     "c:/nul/unc/foo/junc/file1",
      "c:/nul/unc/foo/junc/file2"};
  COMPARE_ZIP_ENTRY_PATHS(actual.AbsPathPtrs(), expected_abs_paths);

  std::vector<const char*> expected_entry_paths = {
      "foo/",      "foo/sub/",  "foo/sub/file1",  "foo/sub/file2", "foo/file1",
      "foo/file2", "foo/junc/", "foo/junc/file1", "foo/junc/file2"};
  COMPARE_ZIP_ENTRY_PATHS(actual.EntryPathPtrs(), expected_entry_paths);
}

class InMemoryExtractor : public devtools_ijar::ZipExtractorProcessor {
 public:
  struct ExtractedFile {
    std::string path;
    std::unique_ptr<devtools_ijar::u1[]> data;
    size_t size;
  };

  InMemoryExtractor(std::vector<ExtractedFile>* extracted)
      : extracted_(extracted) {}

  bool Accept(const char* filename, const devtools_ijar::u4 attr) override {
    return true;
  }

  void Process(const char* filename, const devtools_ijar::u4 attr,
               const devtools_ijar::u1* data, const size_t size) override {
    extracted_->push_back({});
    extracted_->back().path = filename;
    if (size > 0) {
      extracted_->back().data.reset(new devtools_ijar::u1[size]);
      memcpy(extracted_->back().data.get(), data, size);
    }
    extracted_->back().size = size;
  }

 private:
  std::vector<ExtractedFile>* extracted_;
};

TEST_F(TestWrapperWindowsTest, TestCreateZip) {
  std::wstring tmpdir;
  GET_TEST_TMPDIR(&tmpdir);

  // Create a directory structure to archive.
  std::wstring root = tmpdir + L"\\tmp" + WLINE;
  EXPECT_TRUE(CreateDirectoryW(root.c_str(), nullptr));
  EXPECT_TRUE(CreateDirectoryW((root + L"\\foo").c_str(), nullptr));
  EXPECT_TRUE(CreateDirectoryW((root + L"\\foo\\sub").c_str(), nullptr));
  EXPECT_TRUE(blaze_util::CreateDummyFile(root + L"\\foo\\sub\\file1", ""));
  EXPECT_TRUE(
      blaze_util::CreateDummyFile(root + L"\\foo\\sub\\file2", "hello"));
  EXPECT_TRUE(blaze_util::CreateDummyFile(root + L"\\foo\\file1", "foo"));
  EXPECT_TRUE(blaze_util::CreateDummyFile(root + L"\\foo\\file2", "foobar"));
  CREATE_JUNCTION(root + L"\\foo\\junc", root + L"\\foo\\sub");

  std::vector<FileInfo> file_list = {FileInfo(L"foo"),
                                     FileInfo(L"foo\\sub"),
                                     FileInfo(L"foo\\sub\\file1", 0),
                                     FileInfo(L"foo\\sub\\file2", 5),
                                     FileInfo(L"foo\\file1", 3),
                                     FileInfo(L"foo\\file2", 6),
                                     FileInfo(L"foo\\junc"),
                                     FileInfo(L"foo\\junc\\file1", 0),
                                     FileInfo(L"foo\\junc\\file2", 5)};

  ASSERT_TRUE(TestOnly_CreateZip(root, file_list, root + L"\\x.zip"));

  std::string zip_path;
  EXPECT_TRUE(TestOnly_AsMixedPath(root + L"\\x.zip", &zip_path));

  // Extract the zip file into memory to verify its contents.
  std::vector<InMemoryExtractor::ExtractedFile> extracted;
  InMemoryExtractor extractor(&extracted);
  std::unique_ptr<devtools_ijar::ZipExtractor> zip(
      devtools_ijar::ZipExtractor::Create(zip_path.c_str(), &extractor));
  EXPECT_NE(zip.get(), nullptr);
  EXPECT_EQ(zip->ProcessAll(), 0);

  EXPECT_EQ(extracted.size(), 9);

  EXPECT_EQ(extracted[0].path, std::string("foo/"));
  EXPECT_EQ(extracted[1].path, std::string("foo/sub/"));
  EXPECT_EQ(extracted[2].path, std::string("foo/sub/file1"));
  EXPECT_EQ(extracted[3].path, std::string("foo/sub/file2"));
  EXPECT_EQ(extracted[4].path, std::string("foo/file1"));
  EXPECT_EQ(extracted[5].path, std::string("foo/file2"));
  EXPECT_EQ(extracted[6].path, std::string("foo/junc/"));
  EXPECT_EQ(extracted[7].path, std::string("foo/junc/file1"));
  EXPECT_EQ(extracted[8].path, std::string("foo/junc/file2"));

  EXPECT_EQ(extracted[0].size, 0);
  EXPECT_EQ(extracted[1].size, 0);
  EXPECT_EQ(extracted[2].size, 0);
  EXPECT_EQ(extracted[3].size, 5);
  EXPECT_EQ(extracted[4].size, 3);
  EXPECT_EQ(extracted[5].size, 6);
  EXPECT_EQ(extracted[6].size, 0);
  EXPECT_EQ(extracted[7].size, 0);
  EXPECT_EQ(extracted[8].size, 5);

  EXPECT_EQ(memcmp(extracted[3].data.get(), "hello", 5), 0);
  EXPECT_EQ(memcmp(extracted[4].data.get(), "foo", 3), 0);
  EXPECT_EQ(memcmp(extracted[5].data.get(), "foobar", 6), 0);
  EXPECT_EQ(memcmp(extracted[8].data.get(), "hello", 5), 0);
}

TEST_F(TestWrapperWindowsTest, TestGetMimeType) {
  // As of 2018-11-08, TestOnly_GetMimeType looks up the MIME type from the
  // registry under `HKCR\<extension>\Content Type`, e.g.
  // 'HKCR\.bmp\Content Type`.
  // Bazel's CI machines run Windows Server 2016 Core, whose registry contains
  // the Content Type for .ico and .bmp but not for common types such as .txt,
  // hence the file types we choose to test for.
  EXPECT_EQ(TestOnly_GetMimeType("foo.ico"), std::string("image/x-icon"));
  EXPECT_EQ(TestOnly_GetMimeType("foo.bmp"), std::string("image/bmp"));
  EXPECT_EQ(TestOnly_GetMimeType("foo"),
            std::string("application/octet-stream"));
}

TEST_F(TestWrapperWindowsTest, TestUndeclaredOutputsManifest) {
  // Pretend we already acquired a file list. The files don't have to exist.
  // Assert that the root is allowed to have the `\\?\` prefix, but the zip
  // entry paths won't have it.
  std::vector<FileInfo> files = {FileInfo(L"foo"),
                                 FileInfo(L"foo\\sub"),
                                 FileInfo(L"foo\\sub\\file1.ico", 0),
                                 FileInfo(L"foo\\sub\\file2.bmp", 5),
                                 FileInfo(L"foo\\file2", 6)};

  std::string content;
  ASSERT_TRUE(TestOnly_CreateUndeclaredOutputsManifest(files, &content));
  ASSERT_EQ(content, std::string("foo/sub/file1.ico\t0\timage/x-icon\n"
                                 "foo/sub/file2.bmp\t5\timage/bmp\n"
                                 "foo/file2\t6\tapplication/octet-stream\n"));
}

TEST_F(TestWrapperWindowsTest, TestCreateUndeclaredOutputsAnnotations) {
  std::wstring tmpdir;
  GET_TEST_TMPDIR(&tmpdir);

  // Create a directory structure to parse.
  std::wstring root = tmpdir + L"\\tmp" + WLINE;
  EXPECT_TRUE(CreateDirectoryW(root.c_str(), nullptr));
  EXPECT_TRUE(CreateDirectoryW((root + L"\\foo").c_str(), nullptr));
  EXPECT_TRUE(CreateDirectoryW((root + L"\\bar.part").c_str(), nullptr));
  EXPECT_TRUE(blaze_util::CreateDummyFile(root + L"\\a.part", "Hello a"));
  EXPECT_TRUE(blaze_util::CreateDummyFile(root + L"\\b.txt", "Hello b"));
  EXPECT_TRUE(blaze_util::CreateDummyFile(root + L"\\c.part", "Hello c"));
  EXPECT_TRUE(blaze_util::CreateDummyFile(root + L"\\foo\\d.part", "Hello d"));
  EXPECT_TRUE(
      blaze_util::CreateDummyFile(root + L"\\bar.part\\e.part", "Hello e"));

  std::wstring annot = root + L"\\x.annot";
  ASSERT_TRUE(TestOnly_CreateUndeclaredOutputsAnnotations(root, annot));

  HANDLE h = FopenRead(annot);
  ASSERT_NE(h, INVALID_HANDLE_VALUE);
  char content[100];
  DWORD read;
  bool success = ReadFile(h, content, 100, &read, nullptr) != FALSE;
  CloseHandle(h);
  EXPECT_TRUE(success);
  ASSERT_EQ(std::string(content, read), std::string("Hello aHello c"));
}

TEST_F(TestWrapperWindowsTest, TestTee) {
  HANDLE read1_h, write1_h;
  EXPECT_TRUE(CreatePipe(&read1_h, &write1_h, nullptr, 0));
  bazel::windows::AutoHandle read1(read1_h), write1(write1_h);
  HANDLE read2_h, write2_h;
  EXPECT_TRUE(CreatePipe(&read2_h, &write2_h, nullptr, 0));
  bazel::windows::AutoHandle read2(read2_h), write2(write2_h);
  HANDLE read3_h, write3_h;
  EXPECT_TRUE(CreatePipe(&read3_h, &write3_h, nullptr, 0));
  bazel::windows::AutoHandle read3(read3_h), write3(write3_h);

  std::unique_ptr<bazel::tools::test_wrapper::Tee> tee;
  EXPECT_TRUE(TestOnly_CreateTee(&read1, &write2, &write3, &tee));

  DWORD written, read;
  char content[100];

  EXPECT_TRUE(WriteFile(write1, "hello", 5, &written, nullptr));
  EXPECT_EQ(written, 5);
  EXPECT_TRUE(ReadFile(read2, content, 100, &read, nullptr));
  EXPECT_EQ(read, 5);
  EXPECT_EQ(std::string(content, read), "hello");
  EXPECT_TRUE(ReadFile(read3, content, 100, &read, nullptr));
  EXPECT_EQ(read, 5);
  EXPECT_EQ(std::string(content, read), "hello");

  EXPECT_TRUE(WriteFile(write1, "foo", 3, &written, nullptr));
  EXPECT_EQ(written, 3);
  EXPECT_TRUE(ReadFile(read2, content, 100, &read, nullptr));
  EXPECT_EQ(read, 3);
  EXPECT_EQ(std::string(content, read), "foo");
  EXPECT_TRUE(ReadFile(read3, content, 100, &read, nullptr));
  EXPECT_EQ(read, 3);
  EXPECT_EQ(std::string(content, read), "foo");

  write1 = INVALID_HANDLE_VALUE;  // closes handle so the Tee thread can exit
}

void AssertCdataEncodeBuffer(const wchar_t* wline, const char* input,
                             DWORD size, const char* expected_output) {
  bazel::windows::AutoHandle h(FopenContents(wline, input, size));
  std::unique_ptr<IFStream> istm(TestOnly_CreateIFStream(h, /* page_size */ 4));
  std::stringstream out_stm;
  ASSERT_TRUE(TestOnly_CdataEncode(istm.get(), &out_stm));
  ASSERT_EQ(expected_output, out_stm.str());
}

void AssertCdataEncodeBuffer(const wchar_t* wline, const char* input,
                             const char* expected_output) {
  AssertCdataEncodeBuffer(wline, input, strlen(input), expected_output);
}

TEST_F(TestWrapperWindowsTest, TestCdataEscapeNullTerminator) {
  AssertCdataEncodeBuffer(WLINE, "x\0y", 3, "x?y");
}

TEST_F(TestWrapperWindowsTest, TestCdataEscapeCdataEndings) {
  AssertCdataEncodeBuffer(
      WLINE,
      // === Input ===
      // CDATA end sequence, followed by some arbitrary octet.
      "]]>x"
      // CDATA end sequence twice.
      "]]>]]>x"
      // CDATA end sequence at the end of the string.
      "]]>",

      // === Expected output ===
      "]]>]]<![CDATA[>x"
      "]]>]]<![CDATA[>]]>]]<![CDATA[>x"
      "]]>]]<![CDATA[>");
}

TEST_F(TestWrapperWindowsTest, TestCdataEscapeSingleOctets) {
  AssertCdataEncodeBuffer(WLINE,
                          // === Input ===
                          // Legal single-octets.
                          "AB\x9\xA\xD\x20\x7F"
                          // Illegal single-octets.
                          "\x8\xB\xC\x1F\x80\xFF"
                          "x",

                          // === Expected output ===
                          // Legal single-octets.
                          "AB\x9\xA\xD\x20\x7F"
                          // Illegal single-octets.
                          "??????"
                          "x");
}

TEST_F(TestWrapperWindowsTest, TestCdataEscapeDoubleOctets) {
  // Legal range: [\xc0-\xdf][\x80-\xbf]
  AssertCdataEncodeBuffer(
      WLINE,
      "x"
      // Legal double-octet sequences.
      "\xC0\x80"
      "\xDE\xB0"
      "\xDF\xBF"
      // Illegal double-octet sequences, first octet is bad, second is good.
      "\xBF\x80"  // each are matched as single bad octets
      "\xE0\x80"
      // Illegal double-octet sequences, first octet is good, second is bad.
      "\xC0\x7F"  // 0x7F is legal as a single-octet, retained
      "\xDF\xC0"  // 0xC0 starts a legal two-octet sequence...
      // Illegal double-octet sequences, both octets bad.
      "\xBF\xFF"  // ...and 0xBF finishes that sequence
      "x",

      // === Expected output ===
      "x"
      // Legal double-octet sequences.
      "\xC0\x80"
      "\xDE\xB0"
      "\xDF\xBF"
      // Illegal double-octet sequences, first octet is bad, second is good.
      "??"
      "??"
      // Illegal double-octet sequences, first octet is good, second is bad.
      "?\x7F"  // 0x7F is legal as a single-octet, retained
      "?\xC0"  // 0xC0 starts a legal two-octet sequence...
      // Illegal double-octet sequences, both octets bad.
      "\xBF?"  // ...and 0xBF finishes that sequence
      "x");
}

TEST_F(TestWrapperWindowsTest, TestCdataEscapeAndAppend) {
  std::wstring tmpdir;
  GET_TEST_TMPDIR(&tmpdir);

  AssertCdataEncodeBuffer(WLINE,
                          // === Input ===
                          "AB\xA\xC\xD"
                          "]]>"
                          "]]]>"
                          "\xC0\x80"
                          "a"
                          "\xED\x9F\xBF"
                          "b"
                          "\xEF\xBF\xB0"
                          "c"
                          "\xF7\xB0\x80\x81"
                          "d"
                          "]]>",

                          // === Output ===
                          "AB\xA?\xD"
                          "]]>]]<![CDATA[>"
                          "]]]>]]<![CDATA[>"
                          "\xC0\x80"
                          "a"
                          "\xED\x9F\xBF"
                          "b"
                          "\xEF\xBF\xB0"
                          "c"
                          "\xF7\xB0\x80\x81"
                          "d"
                          "]]>]]<![CDATA[>");
}

TEST_F(TestWrapperWindowsTest, TestIFStreamNoData) {
  bazel::windows::AutoHandle h(FopenContents(WLINE, ""));
  std::unique_ptr<IFStream> s(TestOnly_CreateIFStream(h, 6));
  uint8_t buf[3] = {0, 0, 0};

  ASSERT_EQ(s->Get(), IFStream::kIFStreamErrorEOF);
  ASSERT_EQ(s->Peek(0, buf), 0);
  ASSERT_EQ(s->Peek(1, buf), 0);
  ASSERT_EQ(s->Peek(2, buf), 0);
  ASSERT_EQ(s->Peek(100, buf), 0);
}

TEST_F(TestWrapperWindowsTest, TestIFStreamLessDataThanPageSize) {
  // The data is "abc" (3 bytes), page size is 6 bytes.
  bazel::windows::AutoHandle h(FopenContents(WLINE, "abc"));
  std::unique_ptr<IFStream> s(TestOnly_CreateIFStream(h, 6));
  uint8_t buf[3] = {0, 0, 0};

  // Read position is at "a".
  ASSERT_EQ(s->Get(), 'a');
  ASSERT_EQ(s->Peek(1, buf), 1);
  ASSERT_EQ(buf[0], 'b');
  ASSERT_EQ(s->Peek(2, buf), 2);
  ASSERT_EQ(buf[0], 'b');
  ASSERT_EQ(buf[1], 'c');
  ASSERT_EQ(s->Peek(100, buf), 2);
  ASSERT_EQ(buf[0], 'b');
  ASSERT_EQ(buf[1], 'c');

  // Read position is at "b".
  ASSERT_EQ(s->Get(), 'b');
  ASSERT_EQ(s->Peek(1, buf), 1);
  ASSERT_EQ(buf[0], 'c');
  ASSERT_EQ(s->Peek(2, buf), 1);
  ASSERT_EQ(buf[0], 'c');
  ASSERT_EQ(s->Peek(100, buf), 1);
  ASSERT_EQ(buf[0], 'c');

  // Read position is at "c".
  ASSERT_EQ(s->Get(), 'c');
  ASSERT_EQ(s->Peek(1, buf), 0);
  ASSERT_EQ(s->Peek(2, buf), 0);
  ASSERT_EQ(s->Peek(100, buf), 0);
}

TEST_F(TestWrapperWindowsTest, TestIFStreamExactlySinglePageSize) {
  // The data is "abcdef" (6 bytes), page size is 6 bytes.
  bazel::windows::AutoHandle h(FopenContents(WLINE, "abcdef"));
  std::unique_ptr<IFStream> s(TestOnly_CreateIFStream(h, 6));
  uint8_t buf[6] = {0, 0, 0};

  // Read position is at "a".
  ASSERT_EQ(s->Get(), 'a');
  ASSERT_EQ(s->Peek(1, buf), 1);
  ASSERT_EQ(buf[0], 'b');
  ASSERT_EQ(s->Peek(5, buf), 5);
  ASSERT_EQ(buf[0], 'b');
  ASSERT_EQ(buf[1], 'c');
  ASSERT_EQ(buf[2], 'd');
  ASSERT_EQ(buf[3], 'e');
  ASSERT_EQ(buf[4], 'f');

  ASSERT_EQ(s->Get(), 'b');
  ASSERT_EQ(s->Get(), 'c');
  ASSERT_EQ(s->Get(), 'd');
  ASSERT_EQ(s->Get(), 'e');
  ASSERT_EQ(s->Peek(1, buf), 1);
  ASSERT_EQ(buf[0], 'f');
  ASSERT_EQ(s->Peek(5, buf), 1);

  // Read position is at "f". No more peeking or moving.
  ASSERT_EQ(s->Get(), 'f');
  ASSERT_EQ(s->Peek(1, buf), 0);
}

TEST_F(TestWrapperWindowsTest, TestIFStreamLessDataThanDoublePageSize) {
  bazel::windows::AutoHandle h(FopenContents(WLINE, "abcdefghi"));
  std::unique_ptr<IFStream> s(TestOnly_CreateIFStream(h, 6));
  uint8_t buf[3] = {0, 0, 0};

  // Move near the page boundary.
  for (int c = s->Get(); c != 'e'; c = s->Get()) {
  }

  // Read position is at "e". Peek2 and Peek3 will need to read from next page.
  ASSERT_EQ(s->Peek(1, buf), 1);
  ASSERT_EQ(buf[0], 'f');
  ASSERT_EQ(s->Peek(2, buf), 2);
  ASSERT_EQ(buf[0], 'f');
  ASSERT_EQ(buf[1], 'g');
  ASSERT_EQ(s->Peek(3, buf), 3);
  ASSERT_EQ(buf[0], 'f');
  ASSERT_EQ(buf[1], 'g');
  ASSERT_EQ(buf[2], 'h');

  for (int c = s->Get(); c != 'h'; c = s->Get()) {
  }
  ASSERT_EQ(s->Peek(1, buf), 1);
  ASSERT_EQ(buf[0], 'i');
  ASSERT_EQ(s->Peek(5, buf), 1);
  ASSERT_EQ(buf[0], 'i');
}

TEST_F(TestWrapperWindowsTest, TestIFStreamLessDataThanTriplePageSize) {
  // Data is 15 bytes, page size is 6 bytes, we'll cross 2 page boundaries.
  bazel::windows::AutoHandle h(FopenContents(WLINE, "abcdefghijklmno"));
  std::unique_ptr<IFStream> s(TestOnly_CreateIFStream(h, 6));
  uint8_t buf[12];

  // Move near the first page boundary.
  for (int c = s->Get(); c != 'e'; c = s->Get()) {
  }
  ASSERT_EQ(s->Peek(100, buf), 7);
  ASSERT_EQ(buf[0], 'f');
  ASSERT_EQ(buf[1], 'g');
  ASSERT_EQ(buf[2], 'h');
  ASSERT_EQ(buf[3], 'i');
  ASSERT_EQ(buf[4], 'j');
  ASSERT_EQ(buf[5], 'k');
  ASSERT_EQ(buf[6], 'l');

  // Last read character is "k".
  // Peek(2) and Peek(3) will need to read from last page.
  for (int c = s->Get(); c != 'k'; c = s->Get()) {
  }
  ASSERT_EQ(s->Peek(1, buf), 1);
  ASSERT_EQ(buf[0], 'l');
  ASSERT_EQ(s->Peek(100, buf), 4);
  ASSERT_EQ(buf[0], 'l');
  ASSERT_EQ(buf[1], 'm');
  ASSERT_EQ(buf[2], 'n');
  ASSERT_EQ(buf[3], 'o');

  // Move near the end of the last page.
  for (int c = s->Get(); c != 'm'; c = s->Get()) {
  }
  ASSERT_EQ(s->Peek(1, buf), 1);
  ASSERT_EQ(buf[0], 'n');
  ASSERT_EQ(s->Peek(100, buf), 2);
  ASSERT_EQ(buf[0], 'n');
  ASSERT_EQ(buf[1], 'o');
}

}  // namespace