// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40284755): Remove this and spanify to fix the errors.
#pragma allow_unsafe_buffers
#endif

#include "base/files/file_path.h"

#include <stddef.h>

#include <array>
#include <sstream>
#include <string_view>

#include "base/features.h"
#include "base/files/safe_base_name.h"
#include "base/strings/utf_ostream_operators.h"
#include "base/strings/utf_string_conversions.h"
#include "base/test/gtest_util.h"
#include "base/test/scoped_feature_list.h"
#include "build/build_config.h"
#include "build/buildflag.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/platform_test.h"
#include "third_party/perfetto/include/perfetto/test/traced_value_test_support.h"

#if BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
#include "base/test/scoped_locale.h"
#endif

// This macro helps test `FILE_PATH_LITERAL` macro expansion.
#define TEST_FILE "TestFile"

// This macro helps avoid wrapped lines in the test structs.
#define FPL(x) FILE_PATH_LITERAL(x)

// This macro constructs strings which can contain NULs.
#define FPS(x) FilePath::StringType(FPL(x), std::size(FPL(x)) - 1)

namespace base {

struct UnaryTestData {
  FilePath::StringViewType input;
  FilePath::StringViewType expected;
};

struct UnaryBooleanTestData {
  FilePath::StringViewType input;
  bool expected;
};

struct BinaryTestData {
  FilePath::StringViewType inputs[2];
  FilePath::StringViewType expected;
};

struct BinaryBooleanTestData {
  FilePath::StringViewType inputs[2];
  bool expected;
};

struct BinaryIntTestData {
  FilePath::StringViewType inputs[2];
  int expected;
};

struct UTF8TestData {
  FilePath::StringViewType native;
  std::string_view utf8;
};

// file_util winds up using autoreleased objects on the Mac, so this needs
// to be a PlatformTest
using FilePathTest = PlatformTest;

TEST_F(FilePathTest, DirName) {
  const auto cases = std::to_array<UnaryTestData>({
      {FPL(""), FPL(".")},
      {FPL("aa"), FPL(".")},
      {FPL("/aa/bb"), FPL("/aa")},
      {FPL("/aa/bb/"), FPL("/aa")},
      {FPL("/aa/bb//"), FPL("/aa")},
      {FPL("/aa/bb/ccc"), FPL("/aa/bb")},
      {FPL("/aa"), FPL("/")},
      {FPL("/aa/"), FPL("/")},
      {FPL("/"), FPL("/")},
      {FPL("//"), FPL("//")},
      {FPL("///"), FPL("/")},
      {FPL("aa/"), FPL(".")},
      {FPL("aa/bb"), FPL("aa")},
      {FPL("aa/bb/"), FPL("aa")},
      {FPL("aa/bb//"), FPL("aa")},
      {FPL("aa//bb//"), FPL("aa")},
      {FPL("aa//bb/"), FPL("aa")},
      {FPL("aa//bb"), FPL("aa")},
      {FPL("//aa/bb"), FPL("//aa")},
      {FPL("//aa/"), FPL("//")},
      {FPL("//aa"), FPL("//")},
      {FPL("///aa/"), FPL("/")},
      {FPL("///aa"), FPL("/")},
      {FPL("///"), FPL("/")},
      {FPL("0:"), FPL(".")},
      {FPL("@:"), FPL(".")},
      {FPL("[:"), FPL(".")},
      {FPL("`:"), FPL(".")},
      {FPL("{:"), FPL(".")},
      {FPL("\xB3:"), FPL(".")},
      {FPL("\xC5:"), FPL(".")},
      {FPL("/aa/../bb/cc"), FPL("/aa/../bb")},
#if BUILDFLAG(IS_WIN)
      {FPL("\x0143:"), FPL(".")},
#endif  // BUILDFLAG(IS_WIN)
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
      {FPL("c:"), FPL("c:")},
      {FPL("C:"), FPL("C:")},
      {FPL("A:"), FPL("A:")},
      {FPL("Z:"), FPL("Z:")},
      {FPL("a:"), FPL("a:")},
      {FPL("z:"), FPL("z:")},
      {FPL("c:aa"), FPL("c:")},
      {FPL("c:/"), FPL("c:/")},
      {FPL("c://"), FPL("c://")},
      {FPL("c:///"), FPL("c:/")},
      {FPL("c:/aa"), FPL("c:/")},
      {FPL("c:/aa/"), FPL("c:/")},
      {FPL("c:/aa/bb"), FPL("c:/aa")},
      {FPL("c:aa/bb"), FPL("c:aa")},
#endif  // FILE_PATH_USES_DRIVE_LETTERS
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
      {FPL("\\aa\\bb"), FPL("\\aa")},
      {FPL("\\aa\\bb\\"), FPL("\\aa")},
      {FPL("\\aa\\bb\\\\"), FPL("\\aa")},
      {FPL("\\aa\\bb\\ccc"), FPL("\\aa\\bb")},
      {FPL("\\aa"), FPL("\\")},
      {FPL("\\aa\\"), FPL("\\")},
      {FPL("\\"), FPL("\\")},
      {FPL("\\\\"), FPL("\\\\")},
      {FPL("\\\\\\"), FPL("\\")},
      {FPL("aa\\"), FPL(".")},
      {FPL("aa\\bb"), FPL("aa")},
      {FPL("aa\\bb\\"), FPL("aa")},
      {FPL("aa\\bb\\\\"), FPL("aa")},
      {FPL("aa\\\\bb\\\\"), FPL("aa")},
      {FPL("aa\\\\bb\\"), FPL("aa")},
      {FPL("aa\\\\bb"), FPL("aa")},
      {FPL("\\\\aa\\bb"), FPL("\\\\aa")},
      {FPL("\\\\aa\\"), FPL("\\\\")},
      {FPL("\\\\aa"), FPL("\\\\")},
      {FPL("aa\\..\\bb\\c"), FPL("aa\\..\\bb")},
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
      {FPL("c:\\"), FPL("c:\\")},
      {FPL("c:\\\\"), FPL("c:\\\\")},
      {FPL("c:\\\\\\"), FPL("c:\\")},
      {FPL("c:\\\\aa"), FPL("c:\\\\")},
      {FPL("c:\\\\\\aa"), FPL("c:\\")},
      {FPL("c:\\aa"), FPL("c:\\")},
      {FPL("c:\\aa\\"), FPL("c:\\")},
      {FPL("c:\\aa\\bb"), FPL("c:\\aa")},
      {FPL("c:aa\\bb"), FPL("c:aa")},
#endif  // FILE_PATH_USES_DRIVE_LETTERS
#endif  // FILE_PATH_USES_WIN_SEPARATORS
  });

  for (size_t i = 0; i < std::size(cases); ++i) {
    FilePath input(cases[i].input);
    FilePath observed = input.DirName();
    EXPECT_EQ(FilePath::StringType(cases[i].expected), observed.value())
        << "i: " << i << ", input: " << input.value();
  }
}

TEST_F(FilePathTest, BaseName) {
  const auto cases = std::to_array<UnaryTestData>({
      {FPL(""), FPL("")},
      {FPL("aa"), FPL("aa")},
      {FPL("/aa/bb"), FPL("bb")},
      {FPL("/aa/bb/"), FPL("bb")},
      {FPL("/aa/bb//"), FPL("bb")},
      {FPL("/aa/bb/ccc"), FPL("ccc")},
      {FPL("/aa"), FPL("aa")},
      {FPL("/"), FPL("/")},
      {FPL("//"), FPL("//")},
      {FPL("///"), FPL("/")},
      {FPL("aa/"), FPL("aa")},
      {FPL("aa/bb"), FPL("bb")},
      {FPL("aa/bb/"), FPL("bb")},
      {FPL("aa/bb//"), FPL("bb")},
      {FPL("aa//bb//"), FPL("bb")},
      {FPL("aa//bb/"), FPL("bb")},
      {FPL("aa//bb"), FPL("bb")},
      {FPL("//aa/bb"), FPL("bb")},
      {FPL("//aa/"), FPL("aa")},
      {FPL("//aa"), FPL("aa")},
      {FPL("0:"), FPL("0:")},
      {FPL("@:"), FPL("@:")},
      {FPL("[:"), FPL("[:")},
      {FPL("`:"), FPL("`:")},
      {FPL("{:"), FPL("{:")},
      {FPL("\xB3:"), FPL("\xB3:")},
      {FPL("\xC5:"), FPL("\xC5:")},
#if BUILDFLAG(IS_WIN)
      {FPL("\x0143:"), FPL("\x0143:")},
#endif  // BUILDFLAG(IS_WIN)
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
      {FPL("c:"), FPL("")},
      {FPL("C:"), FPL("")},
      {FPL("A:"), FPL("")},
      {FPL("Z:"), FPL("")},
      {FPL("a:"), FPL("")},
      {FPL("z:"), FPL("")},
      {FPL("c:aa"), FPL("aa")},
      {FPL("c:/"), FPL("/")},
      {FPL("c://"), FPL("//")},
      {FPL("c:///"), FPL("/")},
      {FPL("c:/aa"), FPL("aa")},
      {FPL("c:/aa/"), FPL("aa")},
      {FPL("c:/aa/bb"), FPL("bb")},
      {FPL("c:aa/bb"), FPL("bb")},
#endif  // FILE_PATH_USES_DRIVE_LETTERS
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
      {FPL("\\aa\\bb"), FPL("bb")},
      {FPL("\\aa\\bb\\"), FPL("bb")},
      {FPL("\\aa\\bb\\\\"), FPL("bb")},
      {FPL("\\aa\\bb\\ccc"), FPL("ccc")},
      {FPL("\\aa"), FPL("aa")},
      {FPL("\\"), FPL("\\")},
      {FPL("\\\\"), FPL("\\\\")},
      {FPL("\\\\\\"), FPL("\\")},
      {FPL("aa\\"), FPL("aa")},
      {FPL("aa\\bb"), FPL("bb")},
      {FPL("aa\\bb\\"), FPL("bb")},
      {FPL("aa\\bb\\\\"), FPL("bb")},
      {FPL("aa\\\\bb\\\\"), FPL("bb")},
      {FPL("aa\\\\bb\\"), FPL("bb")},
      {FPL("aa\\\\bb"), FPL("bb")},
      {FPL("\\\\aa\\bb"), FPL("bb")},
      {FPL("\\\\aa\\"), FPL("aa")},
      {FPL("\\\\aa"), FPL("aa")},
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
      {FPL("c:\\"), FPL("\\")},
      {FPL("c:\\\\"), FPL("\\\\")},
      {FPL("c:\\\\\\"), FPL("\\")},
      {FPL("c:\\aa"), FPL("aa")},
      {FPL("c:\\aa\\"), FPL("aa")},
      {FPL("c:\\aa\\bb"), FPL("bb")},
      {FPL("c:aa\\bb"), FPL("bb")},
#endif  // FILE_PATH_USES_DRIVE_LETTERS
#endif  // FILE_PATH_USES_WIN_SEPARATORS
  });

  for (size_t i = 0; i < std::size(cases); ++i) {
    FilePath input(cases[i].input);
    FilePath observed = input.BaseName();
    EXPECT_EQ(FilePath::StringType(cases[i].expected), observed.value())
        << "i: " << i << ", input: " << input.value();
  }
}

TEST_F(FilePathTest, Append) {
  const auto cases = std::to_array<BinaryTestData>({
      {{FPL(""), FPL("cc")}, FPL("cc")},
      {{FPL("."), FPL("ff")}, FPL("ff")},
      {{FPL("."), FPL("")}, FPL(".")},
      {{FPL("/"), FPL("cc")}, FPL("/cc")},
      {{FPL("/aa"), FPL("")}, FPL("/aa")},
      {{FPL("/aa/"), FPL("")}, FPL("/aa")},
      {{FPL("//aa"), FPL("")}, FPL("//aa")},
      {{FPL("//aa/"), FPL("")}, FPL("//aa")},
      {{FPL("//"), FPL("aa")}, FPL("//aa")},
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
      {{FPL("c:"), FPL("a")}, FPL("c:a")},
      {{FPL("c:"), FPL("")}, FPL("c:")},
      {{FPL("c:/"), FPL("a")}, FPL("c:/a")},
      {{FPL("c://"), FPL("a")}, FPL("c://a")},
      {{FPL("c:///"), FPL("a")}, FPL("c:/a")},
#endif  // FILE_PATH_USES_DRIVE_LETTERS
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
      // Append introduces the default separator character, so these test cases
      // need to be defined with different expected results on platforms that
      // use different default separator characters.
      {{FPL("\\"), FPL("cc")}, FPL("\\cc")},
      {{FPL("\\aa"), FPL("")}, FPL("\\aa")},
      {{FPL("\\aa\\"), FPL("")}, FPL("\\aa")},
      {{FPL("\\\\aa"), FPL("")}, FPL("\\\\aa")},
      {{FPL("\\\\aa\\"), FPL("")}, FPL("\\\\aa")},
      {{FPL("\\\\"), FPL("aa")}, FPL("\\\\aa")},
      {{FPL("/aa/bb"), FPL("cc")}, FPL("/aa/bb\\cc")},
      {{FPL("/aa/bb/"), FPL("cc")}, FPL("/aa/bb\\cc")},
      {{FPL("aa/bb/"), FPL("cc")}, FPL("aa/bb\\cc")},
      {{FPL("aa/bb"), FPL("cc")}, FPL("aa/bb\\cc")},
      {{FPL("a/b"), FPL("c")}, FPL("a/b\\c")},
      {{FPL("a/b/"), FPL("c")}, FPL("a/b\\c")},
      {{FPL("//aa"), FPL("bb")}, FPL("//aa\\bb")},
      {{FPL("//aa/"), FPL("bb")}, FPL("//aa\\bb")},
      {{FPL("\\aa\\bb"), FPL("cc")}, FPL("\\aa\\bb\\cc")},
      {{FPL("\\aa\\bb\\"), FPL("cc")}, FPL("\\aa\\bb\\cc")},
      {{FPL("aa\\bb\\"), FPL("cc")}, FPL("aa\\bb\\cc")},
      {{FPL("aa\\bb"), FPL("cc")}, FPL("aa\\bb\\cc")},
      {{FPL("a\\b"), FPL("c")}, FPL("a\\b\\c")},
      {{FPL("a\\b\\"), FPL("c")}, FPL("a\\b\\c")},
      {{FPL("\\\\aa"), FPL("bb")}, FPL("\\\\aa\\bb")},
      {{FPL("\\\\aa\\"), FPL("bb")}, FPL("\\\\aa\\bb")},
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
      {{FPL("c:\\"), FPL("a")}, FPL("c:\\a")},
      {{FPL("c:\\\\"), FPL("a")}, FPL("c:\\\\a")},
      {{FPL("c:\\\\\\"), FPL("a")}, FPL("c:\\a")},
      {{FPL("c:\\"), FPL("")}, FPL("c:\\")},
      {{FPL("c:\\a"), FPL("b")}, FPL("c:\\a\\b")},
      {{FPL("c:\\a\\"), FPL("b")}, FPL("c:\\a\\b")},
#endif  // FILE_PATH_USES_DRIVE_LETTERS
#else   // FILE_PATH_USES_WIN_SEPARATORS
      {{FPL("/aa/bb"), FPL("cc")}, FPL("/aa/bb/cc")},
      {{FPL("/aa/bb/"), FPL("cc")}, FPL("/aa/bb/cc")},
      {{FPL("aa/bb/"), FPL("cc")}, FPL("aa/bb/cc")},
      {{FPL("aa/bb"), FPL("cc")}, FPL("aa/bb/cc")},
      {{FPL("a/b"), FPL("c")}, FPL("a/b/c")},
      {{FPL("a/b/"), FPL("c")}, FPL("a/b/c")},
      {{FPL("//aa"), FPL("bb")}, FPL("//aa/bb")},
      {{FPL("//aa/"), FPL("bb")}, FPL("//aa/bb")},
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
      {{FPL("c:/"), FPL("a")}, FPL("c:/a")},
      {{FPL("c:/"), FPL("")}, FPL("c:/")},
      {{FPL("c:/a"), FPL("b")}, FPL("c:/a/b")},
      {{FPL("c:/a/"), FPL("b")}, FPL("c:/a/b")},
#endif  // FILE_PATH_USES_DRIVE_LETTERS
#endif  // FILE_PATH_USES_WIN_SEPARATORS
  });

  for (size_t i = 0; i < std::size(cases); ++i) {
    FilePath root(cases[i].inputs[0]);
    FilePath::StringType leaf(cases[i].inputs[1]);
    FilePath observed_str = root.Append(leaf);
    EXPECT_EQ(FilePath::StringType(cases[i].expected), observed_str.value())
        << "i: " << i << ", root: " << root.value() << ", leaf: " << leaf;
    FilePath observed_path = root.Append(FilePath(leaf));
    EXPECT_EQ(FilePath::StringType(cases[i].expected), observed_path.value())
        << "i: " << i << ", root: " << root.value() << ", leaf: " << leaf;

    // TODO(erikkay): It would be nice to have a unicode test append value to
    // handle the case when AppendASCII is passed UTF8
#if BUILDFLAG(IS_WIN)
    std::string ascii = WideToUTF8(leaf);
#elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
    std::string ascii = leaf;
#endif
    observed_str = root.AppendASCII(ascii);
    EXPECT_EQ(FilePath::StringType(cases[i].expected), observed_str.value())
        << "i: " << i << ", root: " << root.value() << ", leaf: " << leaf;
  }
}

// Test UTF8 values within a file path.
class FilePathUTF8Test : public ::testing::TestWithParam<FilePath::StringType> {
 protected:
  FilePath::StringType testcase() const { return GetParam(); }
};

INSTANTIATE_TEST_SUITE_P(
    FilePathUTF8TestCases,
    FilePathUTF8Test,
    ::testing::Values(FPL("خطأ في عملية التحقق من التحديث 5555"),
                      FPL("अपडेट जांच में यह गड़बड़ी है 5555"),
                      FPL("更新確認エラー 5555。")));

TEST_P(FilePathUTF8Test, Test) {
  FilePath root(FPL(""));
  FilePath::StringType leaf(testcase());
  FilePath observed_str = root.Append(leaf);
  EXPECT_EQ(FilePath::StringType(testcase()), observed_str.value());
  FilePath observed_path = root.Append(FilePath(leaf));
  EXPECT_EQ(FilePath::StringType(testcase()), observed_path.value());

#if BUILDFLAG(IS_WIN)
  std::string utf8 = WideToUTF8(leaf);
#else
  std::string utf8 = leaf;
#endif
  EXPECT_DCHECK_DEATH({ observed_str = root.AppendASCII(utf8); });
  EXPECT_DCHECK_DEATH(
      { observed_str = root.InsertBeforeExtensionASCII(utf8); });
  EXPECT_DCHECK_DEATH({ observed_str = root.AddExtensionASCII(utf8); });

  observed_str = root.AppendUTF8(utf8);
  EXPECT_EQ(FilePath::StringType(testcase()), observed_str.value());

  observed_str = root.InsertBeforeExtensionUTF8(utf8);
  EXPECT_TRUE(observed_str.empty());

  observed_str = root.AddExtensionUTF8(utf8);
  EXPECT_TRUE(observed_str.empty());
}

class FilePathUTF8InvalidTest : public ::testing::TestWithParam<std::string> {
 protected:
  std::string invalid_utf8_value() const { return GetParam(); }
};

INSTANTIATE_TEST_SUITE_P(
    FilePathUTF8InvalidTestCases,
    FilePathUTF8InvalidTest,
    ::testing::Values(
        // Invalid encoding of U+1FFFE (0x8F instead of 0x9F)
        "\xF0\x8F\xBF\xBE",

        // Surrogate code points
        "\xED\xA0\x80\xED\xBF\xBF",
        "\xED\xA0\x8F",
        "\xED\xBF\xBF",

        // Overlong sequences
        "\xC0\x80",                  // U+0000
        "\xC1\x80\xC1\x81",          // "AB"
        "\xE0\x80\x80",              // U+0000
        "\xE0\x82\x80",              // U+0080
        "\xE0\x9F\xBF",              // U+07FF
        "\xF0\x80\x80\x8D",          // U+000D
        "\xF0\x80\x82\x91",          // U+0091
        "\xF0\x80\xA0\x80",          // U+0800
        "\xF0\x8F\xBB\xBF",          // U+FEFF (BOM)
        "\xF8\x80\x80\x80\xBF",      // U+003F
        "\xFC\x80\x80\x80\xA0\xA5",  // U+00A5

        // Beyond U+10FFFF (the upper limit of Unicode codespace)
        "\xF4\x90\x80\x80",          // U+110000
        "\xF8\xA0\xBF\x80\xBF",      // 5 bytes
        "\xFC\x9C\xBF\x80\xBF\x80",  // 6 bytes

        // BOM in UTF-16(BE|LE)
        "\xFE\xFF",
        "\xFF\xFE",

        // Strings in legacy encodings. We can certainly make up strings
        // in a legacy encoding that are valid in UTF-8, but in real data,
        // most of them are invalid as UTF-8.

        // cafe with U+00E9 in ISO-8859-1
        "caf\xE9",
        // U+AC00, U+AC001 in EUC-KR
        "\xB0\xA1\xB0\xA2",
        // U+4F60 U+597D in Big5
        "\xA7\x41\xA6\x6E",
        // "abc" with U+201[CD] in windows-125[0-8]
        // clang-format off
        "\x93" "abc\x94",
        // clang-format on
        // U+0639 U+064E U+0644 U+064E in ISO-8859-6
        "\xD9\xEE\xE4\xEE",
        // U+03B3 U+03B5 U+03B9 U+03AC in ISO-8859-7
        "\xE3\xE5\xE9\xDC"));

TEST_P(FilePathUTF8InvalidTest, Test) {
  FilePath root(FPL(""));
  FilePath observed_str;
  EXPECT_DCHECK_DEATH(
      { observed_str = root.AppendASCII(invalid_utf8_value()); });
  EXPECT_DCHECK_DEATH({
    observed_str = root.InsertBeforeExtensionASCII(invalid_utf8_value());
  });
  EXPECT_DCHECK_DEATH(
      { observed_str = root.AddExtensionASCII(invalid_utf8_value()); });

  EXPECT_DCHECK_DEATH(
      { observed_str = root.AppendUTF8(invalid_utf8_value()); });
  EXPECT_DCHECK_DEATH(
      { observed_str = root.InsertBeforeExtensionUTF8(invalid_utf8_value()); });
  EXPECT_DCHECK_DEATH(
      { observed_str = root.AddExtensionUTF8(invalid_utf8_value()); });
}

TEST_F(FilePathTest, StripTrailingSeparators) {
  const auto cases = std::to_array<UnaryTestData>({
      {FPL(""), FPL("")},
      {FPL("/"), FPL("/")},
      {FPL("//"), FPL("//")},
      {FPL("///"), FPL("/")},
      {FPL("////"), FPL("/")},
      {FPL("a/"), FPL("a")},
      {FPL("a//"), FPL("a")},
      {FPL("a///"), FPL("a")},
      {FPL("a////"), FPL("a")},
      {FPL("/a"), FPL("/a")},
      {FPL("/a/"), FPL("/a")},
      {FPL("/a//"), FPL("/a")},
      {FPL("/a///"), FPL("/a")},
      {FPL("/a////"), FPL("/a")},
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
      {FPL("c:"), FPL("c:")},
      {FPL("c:/"), FPL("c:/")},
      {FPL("c://"), FPL("c://")},
      {FPL("c:///"), FPL("c:/")},
      {FPL("c:////"), FPL("c:/")},
      {FPL("c:/a"), FPL("c:/a")},
      {FPL("c:/a/"), FPL("c:/a")},
      {FPL("c:/a//"), FPL("c:/a")},
      {FPL("c:/a///"), FPL("c:/a")},
      {FPL("c:/a////"), FPL("c:/a")},
#endif  // FILE_PATH_USES_DRIVE_LETTERS
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
      {FPL("\\"), FPL("\\")},
      {FPL("\\\\"), FPL("\\\\")},
      {FPL("\\\\\\"), FPL("\\")},
      {FPL("\\\\\\\\"), FPL("\\")},
      {FPL("a\\"), FPL("a")},
      {FPL("a\\\\"), FPL("a")},
      {FPL("a\\\\\\"), FPL("a")},
      {FPL("a\\\\\\\\"), FPL("a")},
      {FPL("\\a"), FPL("\\a")},
      {FPL("\\a\\"), FPL("\\a")},
      {FPL("\\a\\\\"), FPL("\\a")},
      {FPL("\\a\\\\\\"), FPL("\\a")},
      {FPL("\\a\\\\\\\\"), FPL("\\a")},
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
      {FPL("c:\\"), FPL("c:\\")},
      {FPL("c:\\\\"), FPL("c:\\\\")},
      {FPL("c:\\\\\\"), FPL("c:\\")},
      {FPL("c:\\\\\\\\"), FPL("c:\\")},
      {FPL("c:\\a"), FPL("c:\\a")},
      {FPL("c:\\a\\"), FPL("c:\\a")},
      {FPL("c:\\a\\\\"), FPL("c:\\a")},
      {FPL("c:\\a\\\\\\"), FPL("c:\\a")},
      {FPL("c:\\a\\\\\\\\"), FPL("c:\\a")},
#endif  // FILE_PATH_USES_DRIVE_LETTERS
#endif  // FILE_PATH_USES_WIN_SEPARATORS
  });

  for (size_t i = 0; i < std::size(cases); ++i) {
    FilePath input(cases[i].input);
    FilePath observed = input.StripTrailingSeparators();
    EXPECT_EQ(FilePath::StringType(cases[i].expected), observed.value())
        << "i: " << i << ", input: " << input.value();
  }
}

TEST_F(FilePathTest, IsAbsoluteOrNetwork) {
  struct Cases {
    FilePath::StringViewType input;
    bool expected_is_absolute;
    bool expected_is_network;
  };
  const auto cases = std::to_array<Cases>({
      {FPL(""), false, false},       {FPL("a"), false, false},
      {FPL("c:"), false, false},     {FPL("c:a"), false, false},
      {FPL("a/b"), false, false},    {FPL("//"), true, true},
      {FPL("//a"), true, true},      {FPL("c:a/b"), false, false},
      {FPL("?:/a"), false, false},
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
      {FPL("/"), false, false},      {FPL("/a"), false, false},
      {FPL("/."), false, false},     {FPL("/.."), false, false},
      {FPL("c:/"), true, false},     {FPL("c:/a"), true, false},
      {FPL("c:/."), true, false},    {FPL("c:/.."), true, false},
      {FPL("C:/a"), true, false},    {FPL("d:/a"), true, false},
#else  // FILE_PATH_USES_DRIVE_LETTERS
      {FPL("/"), true, false},
      {FPL("/a"), true, false},
      {FPL("/."), true, false},
      {FPL("/.."), true, false},
      {FPL("c:/"), false, false},
#endif  // FILE_PATH_USES_DRIVE_LETTERS
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
      {FPL("a\\b"), false, false},   {FPL("\\\\"), true, true},
      {FPL("\\\\a"), true, true},    {FPL("a\\b"), false, false},
      {FPL("\\\\"), true, true},     {FPL("//a"), true, true},
      {FPL("c:a\\b"), false, false}, {FPL("?:\\a"), false, false},
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
      {FPL("\\"), false, false},     {FPL("\\a"), false, false},
      {FPL("\\."), false, false},    {FPL("\\.."), false, false},
      {FPL("c:\\"), true, false},    {FPL("c:\\"), true, false},
      {FPL("c:\\a"), true, false},   {FPL("c:\\."), true, false},
      {FPL("c:\\.."), true, false},  {FPL("C:\\a"), true, false},
      {FPL("d:\\a"), true, false},
#else  // FILE_PATH_USES_DRIVE_LETTERS
      {FPL("\\"), true, false},      {FPL("\\a"), true, false},
      {FPL("\\."), true, false},     {FPL("\\.."), true, false},
      {FPL("c:\\"), false, false},
#endif  // FILE_PATH_USES_DRIVE_LETTERS
#endif  // FILE_PATH_USES_WIN_SEPARATORS
  });

  for (size_t i = 0; i < std::size(cases); ++i) {
    FilePath input(cases[i].input);
    bool observed_is_absolute = input.IsAbsolute();
    EXPECT_EQ(cases[i].expected_is_absolute, observed_is_absolute)
        << "i: " << i << ", input: " << input.value();
    bool observed_is_network = input.IsNetwork();
    EXPECT_EQ(cases[i].expected_is_network, observed_is_network)
        << "i: " << i << ", input: " << input.value();
  }
}

TEST_F(FilePathTest, PathComponentsTest) {
  const auto cases = std::to_array<UnaryTestData>({
      {FPL("//foo/bar/baz/"), FPL("|//|foo|bar|baz")},
      {FPL("///"), FPL("|/")},
      {FPL("///foo//bar/baz"), FPL("|/|foo|bar|baz")},
      {FPL("/foo//bar//baz/"), FPL("|/|foo|bar|baz")},
      {FPL("/foo/bar/baz/"), FPL("|/|foo|bar|baz")},
      {FPL("/foo/bar/baz//"), FPL("|/|foo|bar|baz")},
      {FPL("/foo/bar/baz///"), FPL("|/|foo|bar|baz")},
      {FPL("/foo/bar/baz"), FPL("|/|foo|bar|baz")},
      {FPL("/foo/bar.bot/baz.txt"), FPL("|/|foo|bar.bot|baz.txt")},
      {FPL("//foo//bar/baz"), FPL("|//|foo|bar|baz")},
      {FPL("/"), FPL("|/")},
      {FPL("foo"), FPL("|foo")},
      {FPL(""), FPL("")},
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
      {FPL("e:/foo"), FPL("|e:|/|foo")},
      {FPL("e:/"), FPL("|e:|/")},
      {FPL("e:foo"), FPL("|e:|foo")},
      {FPL("e:"), FPL("|e:")},
      {FPL("e://foo"), FPL("|e:|//|foo")},
      {FPL("e://"), FPL("|e:|//")},
      {FPL("e:///foo"), FPL("|e:|/|foo")},
      {FPL("e:///"), FPL("|e:|/")},
#endif  // FILE_PATH_USES_DRIVE_LETTERS
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
      {FPL("../foo"), FPL("|..|foo")},
      {FPL("./foo"), FPL("|foo")},
      {FPL("../foo/bar/"), FPL("|..|foo|bar")},
      {FPL("\\\\foo\\bar\\baz\\"), FPL("|\\\\|foo|bar|baz")},
      {FPL("\\\\\\"), FPL("|\\")},
      {FPL("\\foo\\\\bar\\\\baz\\"), FPL("|\\|foo|bar|baz")},
      {FPL("\\foo\\bar\\baz\\"), FPL("|\\|foo|bar|baz")},
      {FPL("\\foo\\bar\\baz\\\\"), FPL("|\\|foo|bar|baz")},
      {FPL("\\foo\\bar\\baz\\\\\\"), FPL("|\\|foo|bar|baz")},
      {FPL("\\foo\\bar\\baz"), FPL("|\\|foo|bar|baz")},
      {FPL("\\foo\\bar/baz\\\\\\"), FPL("|\\|foo|bar|baz")},
      {FPL("/foo\\bar\\baz"), FPL("|/|foo|bar|baz")},
      {FPL("\\foo\\bar.bot\\baz.txt"), FPL("|\\|foo|bar.bot|baz.txt")},
      {FPL("\\\\foo\\\\bar\\baz"), FPL("|\\\\|foo|bar|baz")},
      {FPL("\\"), FPL("|\\")},
#endif  // FILE_PATH_USES_WIN_SEPARATORS
  });

  for (size_t i = 0; i < std::size(cases); ++i) {
    FilePath input(cases[i].input);
    std::vector<FilePath::StringType> comps = input.GetComponents();

    FilePath::StringType observed;
    for (const auto& j : comps) {
      observed.append(FILE_PATH_LITERAL("|"), 1);
      observed.append(j);
    }
    EXPECT_EQ(FilePath::StringType(cases[i].expected), observed)
        << "i: " << i << ", input: " << input.value();
  }
}

void IsParentTest(bool is_fast) {
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
  auto swap_separators = [](const FilePath& path) {
    FilePath::StringType new_path(path.value());
    for (auto& character : new_path) {
      if (character == '/') {
        character = '\\';
      } else if (character == '\\') {
        character = '/';
      }
    }
    return new_path;
  };
#endif  // defined(FILE_PATH_USES_WIN_SEPARATORS)

  const auto cases = std::to_array<BinaryBooleanTestData>({
      {{FPL(""), FPL("")}, false},
      {{FPL(""), FPL(".")}, false},
      {{FPL(""), FPL("foo")}, false},
      {{FPL("."), FPL("")}, false},
      {{FPL("."), FPL(".")}, false},
      // While the 2 cases below are incorrect, they verify that an old behavior
      // of IsParent() is preserved. We should consider modifying the code so
      // that the result is `true` for the 2 cases below.
      {{FPL("."), FPL("./foo")}, false},
      {{FPL("./"), FPL("./foo")}, false},
      {{FPL("./"), FPL("/")}, false},
      {{FPL("./"), FPL("//")}, false},
      {{FPL("./"), FPL("/foo")}, false},
      {{FPL("./"), FPL("//foo")}, false},
      {{FPL("./foo"), FPL("foo/bar")}, true},
      {{FPL("./foo"), FPL("./foo/bar")}, true},
      {{FPL("./foo"), FPL("/foo/bar")}, false},
      {{FPL("./foo"), FPL("//foo/bar")}, false},
      {{FPL("/"), FPL("/")}, false},
      {{FPL("/"), FPL("//foo")}, false},
      {{FPL("/"), FPL("///foo")}, true},
      {{FPL("/"), FPL("/foo/bar/baz")}, true},
      {{FPL("//////host/bar/"), FPL("//////HOST/bar/baz")}, true},
      {{FPL("//host/bar/"), FPL("//host/bar/baz")}, true},
      {{FPL("//host/bar/"), FPL("//host2/bar/baz")}, false},
      {{FPL("//host/bar/"), FPL("/HOST/bar/baz")}, false},
      {{FPL("//host/bar/"), FPL("/host/bar/baz")}, false},
      {{FPL("//HOST/foo"), FPL("//host/foo/bar")}, true},
      {{FPL("/foo"), FPL("/foo/bar/baz")}, true},
      {{FPL("/foo/bar.txt"), FPL("/foo/bar/baz")}, false},
      {{FPL("/foo/bar"), FPL("/foo//bar/baz")}, true},
      {{FPL("/foo/bar"), FPL("/FOO//bar/baz/")}, false},
      {{FPL("/foo/bar"), FPL("/foo//bar/baz/")}, true},
      {{FPL("/foo/bar"), FPL("/foo/bar")}, false},
      {{FPL("/foo/bar"), FPL("/foo/bar/baz")}, true},
      {{FPL("/foo/bar"), FPL("/foo/bar2/baz")}, false},
      {{FPL("/foo/bar"), FPL("/foo2/bar/baz")}, false},
      {{FPL("/foo/bar/"), FPL("/foo/bar/baz")}, true},
      {{FPL("/foo/bar/baz"), FPL("/foo/bar")}, false},
      {{FPL("foo"), FPL("./foo/bar/baz")}, true},
      {{FPL("foo"), FPL("")}, false},
      {{FPL("foo"), FPL(".")}, false},
      {{FPL("foo"), FPL(".")}, false},
      {{FPL("foo"), FPL("boo/bar/baz")}, false},
      {{FPL("foo"), FPL("foo/bar/baz")}, true},
      {{FPL("foo/b:"), FPL("foo/B:/baz")}, false},
      {{FPL("foo/bar"), FPL("/foo/bar/baz")}, false},
      {{FPL("foo/bar"), FPL("foo/bar/baz")}, true},
      {{FPL("foo/bar"), FPL("foo/bar2/baz")}, false},
      {{FPL("foo/bar"), FPL("foo2/bar/baz")}, false},
      {{FPL("foo/bar/../baz"), FPL("foo/baz/aaa")}, false},
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
      {{FPL("./c:"), FPL("C:foo")}, true},
      {{FPL("c:"), FPL("*:/foo/bar/baz")}, false},
      {{FPL("c:"), FPL("C:/foo")}, true},
      {{FPL("c:"), FPL("c:/foo/bar/baz")}, true},
      {{FPL("c:"), FPL("C:foo")}, true},
      {{FPL("c:/"), FPL("C:/foo")}, true},
      {{FPL("c:/"), FPL("c:/foo/bar/baz")}, true},
      // IsParentSlow() splits "c:/" -> ["c:", "/"], "C:foo" -> ["C:", "foo"].
      // Since the components of "c:/" aren't a prefix of the components of
      // "C:foo", it concludes that it isn't a parent.
      {{FPL("c:/"), FPL("C:foo")}, false},
      {{FPL("c:/foo"), FPL("C:foo/bar")}, false},
      {{FPL("c:/foo/bar"), FPL("c:///foo/bar/baz")}, true},
      {{FPL("c:/foo/bar"), FPL("c://foo/bar/baz")}, false},
      {{FPL("c:/foo/bar"), FPL("c:/foo/bar/baz")}, true},
      {{FPL("c:/foo/bar"), FPL("c:/foo/bar2/baz")}, false},
      {{FPL("c:/foo/bar"), FPL("c:/foo2/bar/baz")}, false},
      {{FPL("c:/foo/bar"), FPL("d:/foo/bar/baz")}, false},
      {{FPL("c:/foo/bar"), FPL("D:/foo/bar/baz")}, false},
      {{FPL("C:/foo/bar"), FPL("d:/foo/bar/baz")}, false},
      {{FPL("c:foo"), FPL("C:/foo/bar")}, false},
      {{FPL("c:foo"), FPL("C:foo/bar")}, true},
      {{FPL("c:foo/bar"), FPL("C:foo/bar/baz")}, true},
      {{FPL("E:/Foo/bar"), FPL("e:/foo/bar/baz")}, false},
      {{FPL("E:/foo/bar"), FPL("e:/foo/bar/baz")}, true},
      {{FPL("e:/foo/bar"), FPL("E:/foo2/bar/baz")}, false},
      {{FPL("f:/foo/bar"), FPL("F:/foo/Bar/baz")}, false},
      {{FPL("f:/foo/bar"), FPL("F:/foo/bar/baz")}, true},
      {{FPL("F:/foo/bar"), FPL("f:/foo2/bar/baz")}, false},
#endif  // FILE_PATH_USES_DRIVE_LETTERS
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
      // Mix different types of separators in the same test case.
      {{FPL("\\foo/bar"), FPL("\\foo/bar/baz")}, true},
      {{FPL("\\foo/bar"), FPL("\\foo\\bar/baz")}, true},
      {{FPL("\\foo/bar"), FPL("\\foo\\/\\/bar/baz")}, true},
#endif  // FILE_PATH_USES_WIN_SEPARATORS
  });

  for (size_t i = 0; i < std::size(cases); ++i) {
    FilePath parent(cases[i].inputs[0]);
    FilePath child(cases[i].inputs[1]);

    EXPECT_EQ(parent.IsParent(child), cases[i].expected)
        << "i: " << i << ", parent: " << parent.value()
        << ", child: " << child.value();

#if defined(FILE_PATH_USES_WIN_SEPARATORS)
    // Using different separators should not affect the result.
    FilePath parent_swapped(swap_separators(parent));
    FilePath child_swapped(swap_separators(child));

    EXPECT_EQ(parent_swapped.IsParent(child_swapped), cases[i].expected)
        << "i (swapped): " << i << ", parent: " << parent_swapped.value()
        << ", child: " << child_swapped.value();
#endif  // defined(FILE_PATH_USES_WIN_SEPARATORS)
  }
}

TEST_F(FilePathTest, IsParentFastTest) {
  {
    test::ScopedFeatureList feature_list;
    feature_list.InitAndEnableFeature(features::kFastFilePathIsParent);
    FilePath::InitializeFeatures();
    IsParentTest(/*is_fast=*/true);
  }
  // Reset feature state.
  FilePath::InitializeFeatures();
}

TEST_F(FilePathTest, IsParentSlowTest) {
  {
    test::ScopedFeatureList feature_list;
    feature_list.InitAndDisableFeature(features::kFastFilePathIsParent);
    FilePath::InitializeFeatures();
    IsParentTest(/*is_fast=*/false);
  }
  // Reset feature state.
  FilePath::InitializeFeatures();
}

TEST_F(FilePathTest, AppendRelativePathTest) {
  const auto cases = std::to_array<BinaryTestData>({
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
      {{FPL("/"), FPL("/foo/bar/baz")}, FPL("foo\\bar\\baz")},
#else   // FILE_PATH_USES_WIN_SEPARATORS
      {{FPL("/"), FPL("/foo/bar/baz")}, FPL("foo/bar/baz")},
#endif  // FILE_PATH_USES_WIN_SEPARATORS
      {{FPL("/foo/bar"), FPL("/foo/bar/baz")}, FPL("baz")},
      {{FPL("/foo/bar/"), FPL("/foo/bar/baz")}, FPL("baz")},
      {{FPL("//foo/bar/"), FPL("//foo/bar/baz")}, FPL("baz")},
      {{FPL("/foo/bar"), FPL("/foo2/bar/baz")}, FPL("")},
      {{FPL("/foo/bar.txt"), FPL("/foo/bar/baz")}, FPL("")},
      {{FPL("/foo/bar"), FPL("/foo/bar2/baz")}, FPL("")},
      {{FPL("/foo/bar"), FPL("/foo/bar")}, FPL("")},
      {{FPL("/foo/bar/baz"), FPL("/foo/bar")}, FPL("")},
      {{FPL("foo/bar"), FPL("foo/bar/baz")}, FPL("baz")},
      {{FPL("foo/bar"), FPL("foo2/bar/baz")}, FPL("")},
      {{FPL("foo/bar"), FPL("foo/bar2/baz")}, FPL("")},
      {{FPL(""), FPL("foo")}, FPL("")},
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
      {{FPL("c:/foo/bar"), FPL("c:/foo/bar/baz")}, FPL("baz")},
      {{FPL("E:/foo/bar"), FPL("e:/foo/bar/baz")}, FPL("baz")},
      {{FPL("f:/foo/bar"), FPL("F:/foo/bar/baz")}, FPL("baz")},
      {{FPL("E:/Foo/bar"), FPL("e:/foo/bar/baz")}, FPL("")},
      {{FPL("f:/foo/bar"), FPL("F:/foo/Bar/baz")}, FPL("")},
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
      {{FPL("c:/"), FPL("c:/foo/bar/baz")}, FPL("foo\\bar\\baz")},
  // TODO(akalin): Figure out how to handle the corner case in the
  // commented-out test case below.  Appending to an empty path gives
  // /foo\bar\baz but appending to a nonempty path "blah" gives
  // blah\foo\bar\baz.
  // { { FPL("c:"),            FPL("c:/foo/bar/baz") }, FPL("foo\\bar\\baz")},
#endif  // FILE_PATH_USES_WIN_SEPARATORS
      {{FPL("c:/foo/bar"), FPL("d:/foo/bar/baz")}, FPL("")},
      {{FPL("c:/foo/bar"), FPL("D:/foo/bar/baz")}, FPL("")},
      {{FPL("C:/foo/bar"), FPL("d:/foo/bar/baz")}, FPL("")},
      {{FPL("c:/foo/bar"), FPL("c:/foo2/bar/baz")}, FPL("")},
      {{FPL("e:/foo/bar"), FPL("E:/foo2/bar/baz")}, FPL("")},
      {{FPL("F:/foo/bar"), FPL("f:/foo2/bar/baz")}, FPL("")},
      {{FPL("c:/foo/bar"), FPL("c:/foo/bar2/baz")}, FPL("")},
#endif  // FILE_PATH_USES_DRIVE_LETTERS
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
      {{FPL("\\foo\\bar"), FPL("\\foo\\bar\\baz")}, FPL("baz")},
      {{FPL("\\foo/bar"), FPL("\\foo\\bar\\baz")}, FPL("baz")},
      {{FPL("\\foo/bar"), FPL("\\foo/bar/baz")}, FPL("baz")},
      {{FPL("\\"), FPL("\\foo\\bar\\baz")}, FPL("foo\\bar\\baz")},
      {{FPL(""), FPL("\\foo\\bar\\baz")}, FPL("")},
      {{FPL("\\foo\\bar"), FPL("\\foo2\\bar\\baz")}, FPL("")},
      {{FPL("\\foo\\bar"), FPL("\\foo\\bar2\\baz")}, FPL("")},
#endif  // FILE_PATH_USES_WIN_SEPARATORS

      // For network paths, the hosts are compared ignoring case, while the rest
      // of the path is compared using case.
      {{FPL("//FOO/bar/"), FPL("//foo/bar/baz")}, FPL("baz")},
      {{FPL("//foo/BAR/"), FPL("//foo/bar/baz")}, FPL("")},
      // For non-network paths, the first component is not a host and should be
      // compared using case.
      {{FPL("/FOO/bar/"), FPL("/foo/bar/baz")}, FPL("")},
      // Degenerate case when parent has no hostname.
      {{FPL("//"), FPL("//foo")}, FPL("foo")},
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
      // Network path tests but using Windows path separators.
      {{FPL("\\\\FOO\\bar"), FPL("\\\\foo\\bar\\baz")}, FPL("baz")},
      {{FPL("\\\\fOO\\Bar"), FPL("\\\\foo\\bar\\baz")}, FPL("")},
      {{FPL("\\FOO\\bar"), FPL("\\foo\\bar\\baz")}, FPL("")},
      {{FPL("\\\\"), FPL("\\\\foo")}, FPL("foo")},
#endif  // FILE_PATH_USES_WIN_SEPARATORS

  });

  const FilePath base(FPL("blah"));

  for (size_t i = 0; i < std::size(cases); ++i) {
    FilePath parent(cases[i].inputs[0]);
    FilePath child(cases[i].inputs[1]);
    {
      FilePath result;
      bool success = parent.AppendRelativePath(child, &result);
      EXPECT_EQ(!cases[i].expected.empty(), success)
          << "i: " << i << ", parent: " << parent.value()
          << ", child: " << child.value();
      EXPECT_EQ(cases[i].expected, result.value())
          << "i: " << i << ", parent: " << parent.value()
          << ", child: " << child.value();
    }
    {
      FilePath result(base);
      bool success = parent.AppendRelativePath(child, &result);
      EXPECT_EQ(!cases[i].expected.empty(), success)
          << "i: " << i << ", parent: " << parent.value()
          << ", child: " << child.value();
      EXPECT_EQ(base.Append(cases[i].expected).value(), result.value())
          << "i: " << i << ", parent: " << parent.value()
          << ", child: " << child.value();
    }
  }
}

TEST_F(FilePathTest, EqualityTest) {
  const auto cases = std::to_array<BinaryBooleanTestData>({
      {{FPL("/foo/bar/baz"), FPL("/foo/bar/baz")}, true},
      {{FPL("/foo/bar"), FPL("/foo/bar/baz")}, false},
      {{FPL("/foo/bar/baz"), FPL("/foo/bar")}, false},
      {{FPL("//foo/bar/"), FPL("//foo/bar/")}, true},
      {{FPL("/foo/bar"), FPL("/foo2/bar")}, false},
      {{FPL("/foo/bar.txt"), FPL("/foo/bar")}, false},
      {{FPL("foo/bar"), FPL("foo/bar")}, true},
      {{FPL("foo/bar"), FPL("foo/bar/baz")}, false},
      {{FPL(""), FPL("foo")}, false},
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
      {{FPL("c:/foo/bar"), FPL("c:/foo/bar")}, true},
      {{FPL("E:/foo/bar"), FPL("e:/foo/bar")}, true},
      {{FPL("f:/foo/bar"), FPL("F:/foo/bar")}, true},
      {{FPL("E:/Foo/bar"), FPL("e:/foo/bar")}, false},
      {{FPL("f:/foo/bar"), FPL("F:/foo/Bar")}, false},
      {{FPL("c:/"), FPL("c:/")}, true},
      {{FPL("c:"), FPL("c:")}, true},
      {{FPL("c:/foo/bar"), FPL("d:/foo/bar")}, false},
      {{FPL("c:/foo/bar"), FPL("D:/foo/bar")}, false},
      {{FPL("C:/foo/bar"), FPL("d:/foo/bar")}, false},
      {{FPL("c:/foo/bar"), FPL("c:/foo2/bar")}, false},
#endif  // FILE_PATH_USES_DRIVE_LETTERS
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
      {{FPL("\\foo\\bar"), FPL("\\foo\\bar")}, true},
      {{FPL("\\foo/bar"), FPL("\\foo/bar")}, true},
      {{FPL("\\foo/bar"), FPL("\\foo\\bar")}, false},
      {{FPL("\\"), FPL("\\")}, true},
      {{FPL("\\"), FPL("/")}, false},
      {{FPL(""), FPL("\\")}, false},
      {{FPL("\\foo\\bar"), FPL("\\foo2\\bar")}, false},
      {{FPL("\\foo\\bar"), FPL("\\foo\\bar2")}, false},
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
      {{FPL("c:\\foo\\bar"), FPL("c:\\foo\\bar")}, true},
      {{FPL("E:\\foo\\bar"), FPL("e:\\foo\\bar")}, true},
      {{FPL("f:\\foo\\bar"), FPL("F:\\foo/bar")}, false},
#endif  // FILE_PATH_USES_DRIVE_LETTERS
#endif  // FILE_PATH_USES_WIN_SEPARATORS
  });

  for (size_t i = 0; i < std::size(cases); ++i) {
    FilePath a(cases[i].inputs[0]);
    FilePath b(cases[i].inputs[1]);

    EXPECT_EQ(a == b, cases[i].expected)
        << "equality i: " << i << ", a: " << a.value() << ", b: " << b.value();
  }

  for (size_t i = 0; i < std::size(cases); ++i) {
    FilePath a(cases[i].inputs[0]);
    FilePath b(cases[i].inputs[1]);

    EXPECT_EQ(a != b, !cases[i].expected)
        << "inequality i: " << i << ", a: " << a.value()
        << ", b: " << b.value();
  }
}

TEST_F(FilePathTest, MacroExpansion) {
  EXPECT_EQ(FILE_PATH_LITERAL(TEST_FILE), FILE_PATH_LITERAL("TestFile"));
}

TEST_F(FilePathTest, Extension) {
  FilePath base_dir(FILE_PATH_LITERAL("base_dir"));

  FilePath jpg = base_dir.Append(FILE_PATH_LITERAL("foo.jpg"));
  EXPECT_EQ(FILE_PATH_LITERAL(".jpg"), jpg.Extension());
  EXPECT_EQ(FILE_PATH_LITERAL(".jpg"), jpg.FinalExtension());

  FilePath base = jpg.BaseName().RemoveExtension();
  EXPECT_EQ(FILE_PATH_LITERAL("foo"), base.value());

  FilePath path_no_ext = base_dir.Append(base);
  EXPECT_EQ(path_no_ext.value(), jpg.RemoveExtension().value());

  EXPECT_EQ(path_no_ext.value(), path_no_ext.RemoveExtension().value());
  EXPECT_EQ(FILE_PATH_LITERAL(""), path_no_ext.Extension());
  EXPECT_EQ(FILE_PATH_LITERAL(""), path_no_ext.FinalExtension());
}

TEST_F(FilePathTest, Extension2) {
  // clang-format off
  const auto cases = std::to_array<UnaryTestData>({
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
    { FPL("C:\\a\\b\\c.ext"),        FPL(".ext") },
    { FPL("C:\\a\\b\\c."),           FPL(".") },
    { FPL("C:\\a\\b\\c"),            FPL("") },
    { FPL("C:\\a\\b\\"),             FPL("") },
    { FPL("C:\\a\\b.\\"),            FPL(".") },
    { FPL("C:\\a\\b\\c.ext1.ext2"),  FPL(".ext2") },
    { FPL("C:\\foo.bar\\\\\\"),      FPL(".bar") },
    { FPL("C:\\foo.bar\\.."),        FPL("") },
    { FPL("C:\\foo.bar\\..\\\\"),    FPL("") },
#endif
    { FPL("/foo/bar/baz.EXT"),       FPL(".EXT") },
    { FPL("/foo/bar/baz.Ext"),       FPL(".Ext") },
    { FPL("/foo/bar/baz.ext"),       FPL(".ext") },
    { FPL("/foo/bar/baz."),          FPL(".") },
    { FPL("/foo/bar/baz.."),         FPL(".") },
    { FPL("/foo/bar/baz"),           FPL("") },
    { FPL("/foo/bar/"),              FPL("") },
    { FPL("/foo/bar./"),             FPL(".") },
    { FPL("/foo/bar/baz.ext1.ext2"), FPL(".ext2") },
    { FPL("/subversion-1.6.12.zip"), FPL(".zip") },
    { FPL("/foo.12345.gz"),          FPL(".gz") },
    { FPL("/foo..gz"),               FPL(".gz") },
    { FPL("."),                      FPL("") },
    { FPL(".."),                     FPL("") },
    { FPL("./foo"),                  FPL("") },
    { FPL("./foo.ext"),              FPL(".ext") },
    { FPL("/foo.ext1/bar.ext2"),     FPL(".ext2") },
    { FPL("/foo.bar////"),           FPL(".bar") },
    { FPL("/foo.bar/.."),            FPL("") },
    { FPL("/foo.bar/..////"),        FPL("") },
    { FPL("/foo.1234.luser.js"),     FPL(".js") },
    { FPL("/user.js"),               FPL(".js") },
  });
  const auto double_extension_cases = std::to_array<UnaryTestData>({
    // `kCommonDoubleExtensionSuffixes` cases. Blah is not on that allow-list.
    // Membership is (ASCII) case-insensitive: both ".Z" and ".z" match.
    { FPL("/foo.TAR.bz2"),           FPL(".TAR.bz2") },
    { FPL("/foo.tar.Z"),             FPL(".tar.Z") },
    { FPL("/foo.tar.blah"),          FPL(".blah") },
    { FPL("/foo.tar.bz"),            FPL(".tar.bz") },
    { FPL("/foo.tar.bz2"),           FPL(".tar.bz2") },
    { FPL("/foo.tar.gz"),            FPL(".tar.gz") },
    { FPL("/foo.tar.lz"),            FPL(".tar.lz") },
    { FPL("/foo.tar.lzma"),          FPL(".tar.lzma") },
    { FPL("/foo.tar.lzo"),           FPL(".tar.lzo") },
    { FPL("/foo.tar.xz"),            FPL(".tar.xz") },
    { FPL("/foo.tar.z"),             FPL(".tar.z") },
    { FPL("/foo.tar.zst"),           FPL(".tar.zst") },
    // `kCommonDoubleExtensions` cases.
    { FPL("/foo.1234.user.js"),      FPL(".user.js") },
    { FPL("foo.user.js"),            FPL(".user.js") },
    // Other cases.
    { FPL("/foo.1234.gz"),           FPL(".1234.gz") },
    { FPL("/foo.1234.gz."),          FPL(".") },
    { FPL("/foo.1234.tar.gz"),       FPL(".tar.gz") },
    { FPL("/foo.tar.tar.gz"),        FPL(".tar.gz") },
    { FPL("/foo.tar.gz.gz"),         FPL(".gz.gz") },
  });
  // clang-format on

  for (size_t i = 0; i < std::size(cases); ++i) {
    FilePath path(cases[i].input);
    FilePath::StringType extension = path.Extension();
    FilePath::StringType final_extension = path.FinalExtension();
    EXPECT_EQ(cases[i].expected, extension)
        << "i: " << i << ", path: " << path.value();
    EXPECT_EQ(cases[i].expected, final_extension)
        << "i: " << i << ", path: " << path.value();
  }

  for (size_t i = 0; i < std::size(double_extension_cases); ++i) {
    FilePath path(double_extension_cases[i].input);
    FilePath::StringType extension = path.Extension();
    EXPECT_EQ(double_extension_cases[i].expected, extension)
        << "i: " << i << ", path: " << path.value();
  }
}

TEST_F(FilePathTest, InsertBeforeExtension) {
  const auto cases = std::to_array<BinaryTestData>({
      {{FPL(""), FPL("")}, FPL("")},
      {{FPL(""), FPL("txt")}, FPL("")},
      {{FPL("."), FPL("txt")}, FPL("")},
      {{FPL(".."), FPL("txt")}, FPL("")},
      {{FPL("foo.dll"), FPL("txt")}, FPL("footxt.dll")},
      {{FPL("."), FPL("")}, FPL(".")},
      {{FPL("foo.dll"), FPL(".txt")}, FPL("foo.txt.dll")},
      {{FPL("foo"), FPL("txt")}, FPL("footxt")},
      {{FPL("foo"), FPL(".txt")}, FPL("foo.txt")},
      {{FPL("foo.baz.dll"), FPL("txt")}, FPL("foo.baztxt.dll")},
      {{FPL("foo.baz.dll"), FPL(".txt")}, FPL("foo.baz.txt.dll")},
      {{FPL("foo.dll"), FPL("")}, FPL("foo.dll")},
      {{FPL("foo.dll"), FPL(".")}, FPL("foo..dll")},
      {{FPL("foo"), FPL("")}, FPL("foo")},
      {{FPL("foo"), FPL(".")}, FPL("foo.")},
      {{FPL("foo.baz.dll"), FPL("")}, FPL("foo.baz.dll")},
      {{FPL("foo.baz.dll"), FPL(".")}, FPL("foo.baz..dll")},
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
      {{FPL("\\"), FPL("")}, FPL("\\")},
      {{FPL("\\"), FPL("txt")}, FPL("\\txt")},
      {{FPL("\\."), FPL("txt")}, FPL("")},
      {{FPL("\\.."), FPL("txt")}, FPL("")},
      {{FPL("\\."), FPL("")}, FPL("\\.")},
      {{FPL("C:\\bar\\foo.dll"), FPL("txt")}, FPL("C:\\bar\\footxt.dll")},
      {{FPL("C:\\bar.baz\\foodll"), FPL("txt")}, FPL("C:\\bar.baz\\foodlltxt")},
      {{FPL("C:\\bar.baz\\foo.dll"), FPL("txt")},
       FPL("C:\\bar.baz\\footxt.dll")},
      {{FPL("C:\\bar.baz\\foo.dll.exe"), FPL("txt")},
       FPL("C:\\bar.baz\\foo.dlltxt.exe")},
      {{FPL("C:\\bar.baz\\foo"), FPL("")}, FPL("C:\\bar.baz\\foo")},
      {{FPL("C:\\bar.baz\\foo.exe"), FPL("")}, FPL("C:\\bar.baz\\foo.exe")},
      {{FPL("C:\\bar.baz\\foo.dll.exe"), FPL("")},
       FPL("C:\\bar.baz\\foo.dll.exe")},
      {{FPL("C:\\bar\\baz\\foo.exe"), FPL(" (1)")},
       FPL("C:\\bar\\baz\\foo (1).exe")},
      {{FPL("C:\\foo.baz\\\\"), FPL(" (1)")}, FPL("C:\\foo (1).baz")},
      {{FPL("C:\\foo.baz\\..\\"), FPL(" (1)")}, FPL("")},
#endif
      {{FPL("/"), FPL("")}, FPL("/")},
      {{FPL("/"), FPL("txt")}, FPL("/txt")},
      {{FPL("/."), FPL("txt")}, FPL("")},
      {{FPL("/.."), FPL("txt")}, FPL("")},
      {{FPL("/."), FPL("")}, FPL("/.")},
      {{FPL("/bar/foo.dll"), FPL("txt")}, FPL("/bar/footxt.dll")},
      {{FPL("/bar.baz/foodll"), FPL("txt")}, FPL("/bar.baz/foodlltxt")},
      {{FPL("/bar.baz/foo.dll"), FPL("txt")}, FPL("/bar.baz/footxt.dll")},
      {{FPL("/bar.baz/foo.dll.exe"), FPL("txt")},
       FPL("/bar.baz/foo.dlltxt.exe")},
      {{FPL("/bar.baz/foo"), FPL("")}, FPL("/bar.baz/foo")},
      {{FPL("/bar.baz/foo.exe"), FPL("")}, FPL("/bar.baz/foo.exe")},
      {{FPL("/bar.baz/foo.dll.exe"), FPL("")}, FPL("/bar.baz/foo.dll.exe")},
      {{FPL("/bar/baz/foo.exe"), FPL(" (1)")}, FPL("/bar/baz/foo (1).exe")},
      {{FPL("/bar/baz/..////"), FPL(" (1)")}, FPL("")},
  });
  for (unsigned int i = 0; i < std::size(cases); ++i) {
    FilePath path(cases[i].inputs[0]);
    FilePath result = path.InsertBeforeExtension(cases[i].inputs[1]);
    EXPECT_EQ(cases[i].expected, result.value())
        << "i: " << i << ", path: " << path.value()
        << ", insert: " << cases[i].inputs[1];
  }
}

TEST_F(FilePathTest, RemoveExtension) {
  const auto cases = std::to_array<UnaryTestData>({
      {FPL(""), FPL("")},
      {FPL("."), FPL(".")},
      {FPL(".."), FPL("..")},
      {FPL("foo.dll"), FPL("foo")},
      {FPL("./foo.dll"), FPL("./foo")},
      {FPL("foo..dll"), FPL("foo.")},
      {FPL("foo"), FPL("foo")},
      {FPL("foo."), FPL("foo")},
      {FPL("foo.."), FPL("foo.")},
      {FPL("foo.baz.dll"), FPL("foo.baz")},
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
      {FPL("C:\\foo.bar\\foo"), FPL("C:\\foo.bar\\foo")},
      {FPL("C:\\foo.bar\\..\\\\"), FPL("C:\\foo.bar\\..\\\\")},
#endif
      {FPL("/foo.bar/foo"), FPL("/foo.bar/foo")},
      {FPL("/foo.bar/..////"), FPL("/foo.bar/..////")},
  });
  for (size_t i = 0; i < std::size(cases); ++i) {
    FilePath path(cases[i].input);
    FilePath removed = path.RemoveExtension();
    FilePath removed_final = path.RemoveFinalExtension();
    EXPECT_EQ(cases[i].expected, removed.value())
        << "i: " << i << ", path: " << path.value();
    EXPECT_EQ(cases[i].expected, removed_final.value())
        << "i: " << i << ", path: " << path.value();
  }

  const FilePath::StringViewType tarballs[] = {
      FPL("foo.tar.gz"), FPL("foo.tar.xz"), FPL("foo.tar.bz2"),
      FPL("foo.tar.Z"), FPL("foo.tar.bz")};
  for (size_t i = 0; i < std::size(tarballs); ++i) {
    FilePath path(FPL("foo.tar.gz"));
    FilePath removed = path.RemoveExtension();
    FilePath removed_final = path.RemoveFinalExtension();
    EXPECT_EQ(FPL("foo"), removed.value())
        << "i: " << i << ", path: " << path.value();
    EXPECT_EQ(FPL("foo.tar"), removed_final.value())
        << "i: " << i << ", path: " << path.value();
  }
}

TEST_F(FilePathTest, ReplaceExtension) {
  const auto cases = std::to_array<BinaryTestData>({
      {{FPL(""), FPL("")}, FPL("")},
      {{FPL(""), FPL("txt")}, FPL("")},
      {{FPL("."), FPL("txt")}, FPL("")},
      {{FPL(".."), FPL("txt")}, FPL("")},
      {{FPL("."), FPL("")}, FPL("")},
      {{FPL("foo.dll"), FPL("txt")}, FPL("foo.txt")},
      {{FPL("./foo.dll"), FPL("txt")}, FPL("./foo.txt")},
      {{FPL("foo..dll"), FPL("txt")}, FPL("foo..txt")},
      {{FPL("foo.dll"), FPL(".txt")}, FPL("foo.txt")},
      {{FPL("foo"), FPL("txt")}, FPL("foo.txt")},
      {{FPL("foo."), FPL("txt")}, FPL("foo.txt")},
      {{FPL("foo.."), FPL("txt")}, FPL("foo..txt")},
      {{FPL("foo"), FPL(".txt")}, FPL("foo.txt")},
      {{FPL("foo.baz.dll"), FPL("txt")}, FPL("foo.baz.txt")},
      {{FPL("foo.baz.dll"), FPL(".txt")}, FPL("foo.baz.txt")},
      {{FPL("foo.dll"), FPL("")}, FPL("foo")},
      {{FPL("foo.dll"), FPL(".")}, FPL("foo")},
      {{FPL("foo"), FPL("")}, FPL("foo")},
      {{FPL("foo"), FPL(".")}, FPL("foo")},
      {{FPL("foo.baz.dll"), FPL("")}, FPL("foo.baz")},
      {{FPL("foo.baz.dll"), FPL(".")}, FPL("foo.baz")},
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
      {{FPL("C:\\foo.bar\\foo"), FPL("baz")}, FPL("C:\\foo.bar\\foo.baz")},
      {{FPL("C:\\foo.bar\\..\\\\"), FPL("baz")}, FPL("")},
#endif
      {{FPL("/foo.bar/foo"), FPL("baz")}, FPL("/foo.bar/foo.baz")},
      {{FPL("/foo.bar/..////"), FPL("baz")}, FPL("")},
  });
  for (unsigned int i = 0; i < std::size(cases); ++i) {
    FilePath path(cases[i].inputs[0]);
    FilePath replaced = path.ReplaceExtension(cases[i].inputs[1]);
    EXPECT_EQ(cases[i].expected, replaced.value())
        << "i: " << i << ", path: " << path.value()
        << ", replace: " << cases[i].inputs[1];
  }
}

TEST_F(FilePathTest, AddExtension) {
  const auto cases = std::to_array<BinaryTestData>({
      {{FPL(""), FPL("")}, FPL("")},
      {{FPL(""), FPL("txt")}, FPL("")},
      {{FPL("."), FPL("txt")}, FPL("")},
      {{FPL(".."), FPL("txt")}, FPL("")},
      {{FPL("."), FPL("")}, FPL("")},
      {{FPL("foo.dll"), FPL("txt")}, FPL("foo.dll.txt")},
      {{FPL("./foo.dll"), FPL("txt")}, FPL("./foo.dll.txt")},
      {{FPL("foo..dll"), FPL("txt")}, FPL("foo..dll.txt")},
      {{FPL("foo.dll"), FPL(".txt")}, FPL("foo.dll.txt")},
      {{FPL("foo"), FPL("txt")}, FPL("foo.txt")},
      {{FPL("foo."), FPL("txt")}, FPL("foo.txt")},
      {{FPL("foo.."), FPL("txt")}, FPL("foo..txt")},
      {{FPL("foo"), FPL(".txt")}, FPL("foo.txt")},
      {{FPL("foo.baz.dll"), FPL("txt")}, FPL("foo.baz.dll.txt")},
      {{FPL("foo.baz.dll"), FPL(".txt")}, FPL("foo.baz.dll.txt")},
      {{FPL("foo.dll"), FPL("")}, FPL("foo.dll")},
      {{FPL("foo.dll"), FPL(".")}, FPL("foo.dll")},
      {{FPL("foo"), FPL("")}, FPL("foo")},
      {{FPL("foo"), FPL(".")}, FPL("foo")},
      {{FPL("foo.baz.dll"), FPL("")}, FPL("foo.baz.dll")},
      {{FPL("foo.baz.dll"), FPL(".")}, FPL("foo.baz.dll")},
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
      {{FPL("C:\\foo.bar\\foo"), FPL("baz")}, FPL("C:\\foo.bar\\foo.baz")},
      {{FPL("C:\\foo.bar\\..\\\\"), FPL("baz")}, FPL("")},
#endif
      {{FPL("/foo.bar/foo"), FPL("baz")}, FPL("/foo.bar/foo.baz")},
      {{FPL("/foo.bar/..////"), FPL("baz")}, FPL("")},
  });
  for (unsigned int i = 0; i < std::size(cases); ++i) {
    FilePath path(cases[i].inputs[0]);
    FilePath added = path.AddExtension(cases[i].inputs[1]);
    EXPECT_EQ(cases[i].expected, added.value())
        << "i: " << i << ", path: " << path.value()
        << ", add: " << cases[i].inputs[1];
  }
}

TEST_F(FilePathTest, MatchesExtension) {
  const auto cases = std::to_array<BinaryBooleanTestData>({
      {{FPL("foo"), FPL("")}, true},
      {{FPL("foo"), FPL(".")}, false},
      {{FPL("foo."), FPL("")}, false},
      {{FPL("foo."), FPL(".")}, true},
      {{FPL("foo.txt"), FPL(".dll")}, false},
      {{FPL("foo.txt"), FPL(".txt")}, true},
      {{FPL("foo.txt.dll"), FPL(".txt")}, false},
      {{FPL("foo.txt.dll"), FPL(".dll")}, true},
      {{FPL("foo.tar.gz"), FPL(".gz")}, false},
      {{FPL("foo.tar.lzma"), FPL(".tar.lzma")}, true},
      {{FPL("foo.TXT"), FPL(".txt")}, true},
      {{FPL("foo.txt"), FPL(".TXT")}, true},
      {{FPL("foo.tXt"), FPL(".txt")}, true},
      {{FPL("foo.txt"), FPL(".tXt")}, true},
      {{FPL("foo.tXt"), FPL(".TXT")}, true},
      {{FPL("foo.tXt"), FPL(".tXt")}, true},
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
      {{FPL("c:/foo.txt.dll"), FPL(".txt")}, false},
      {{FPL("c:/foo.txt"), FPL(".txt")}, true},
#endif  // FILE_PATH_USES_DRIVE_LETTERS
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
      {{FPL("c:\\bar\\foo.txt.dll"), FPL(".txt")}, false},
      {{FPL("c:\\bar\\foo.txt"), FPL(".txt")}, true},
#endif  // FILE_PATH_USES_DRIVE_LETTERS
      {{FPL("/bar/foo.txt.dll"), FPL(".txt")}, false},
      {{FPL("/bar/foo.txt"), FPL(".txt")}, true},
#if BUILDFLAG(IS_WIN) || BUILDFLAG(IS_APPLE)
      // Umlauts A, O, U: direct comparison, and upper case vs. lower case
      {{FPL("foo.\u00E4\u00F6\u00FC"), FPL(".\u00E4\u00F6\u00FC")}, true},
      {{FPL("foo.\u00C4\u00D6\u00DC"), FPL(".\u00E4\u00F6\u00FC")}, true},
      // C with circumflex: direct comparison, and upper case vs. lower case
      {{FPL("foo.\u0109"), FPL(".\u0109")}, true},
      {{FPL("foo.\u0108"), FPL(".\u0109")}, true},
#endif
  });

  for (size_t i = 0; i < std::size(cases); ++i) {
    FilePath path(cases[i].inputs[0]);
    FilePath::StringType ext(cases[i].inputs[1]);

    EXPECT_EQ(cases[i].expected, path.MatchesExtension(ext))
        << "i: " << i << ", path: " << path.value() << ", ext: " << ext;
  }
}

TEST_F(FilePathTest, MatchesFinalExtension) {
  const auto cases = std::to_array<BinaryBooleanTestData>({
      {{FPL("foo"), FPL("")}, true},
      {{FPL("foo"), FPL(".")}, false},
      {{FPL("foo."), FPL("")}, false},
      {{FPL("foo."), FPL(".")}, true},
      {{FPL("foo.txt"), FPL(".dll")}, false},
      {{FPL("foo.txt"), FPL(".txt")}, true},
      {{FPL("foo.txt.dll"), FPL(".txt")}, false},
      {{FPL("foo.txt.dll"), FPL(".dll")}, true},
      {{FPL("foo.tar.gz"), FPL(".gz")}, true},
      {{FPL("foo.tar.lzma"), FPL(".lzma")}, true},
      {{FPL("foo.tar.lzma"), FPL(".tar.lzma")}, false},
      {{FPL("foo.tlzma"), FPL(".tlzma")}, true},
      {{FPL("foo.TXT"), FPL(".txt")}, true},
      {{FPL("foo.txt"), FPL(".TXT")}, true},
      {{FPL("foo.tXt"), FPL(".txt")}, true},
      {{FPL("foo.txt"), FPL(".tXt")}, true},
      {{FPL("foo.tXt"), FPL(".TXT")}, true},
      {{FPL("foo.tXt"), FPL(".tXt")}, true},
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
      {{FPL("c:/foo.txt.dll"), FPL(".txt")}, false},
      {{FPL("c:/foo.txt"), FPL(".txt")}, true},
#endif  // FILE_PATH_USES_DRIVE_LETTERS
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
      {{FPL("c:\\bar\\foo.txt.dll"), FPL(".txt")}, false},
      {{FPL("c:\\bar\\foo.txt"), FPL(".txt")}, true},
#endif  // FILE_PATH_USES_DRIVE_LETTERS
      {{FPL("/bar/foo.txt.dll"), FPL(".txt")}, false},
      {{FPL("/bar/foo.txt"), FPL(".txt")}, true},
#if BUILDFLAG(IS_WIN) || BUILDFLAG(IS_APPLE)
      // Umlauts A, O, U: direct comparison, and upper case vs. lower case
      {{FPL("foo.\u00E4\u00F6\u00FC"), FPL(".\u00E4\u00F6\u00FC")}, true},
      {{FPL("foo.\u00C4\u00D6\u00DC"), FPL(".\u00E4\u00F6\u00FC")}, true},
      // C with circumflex: direct comparison, and upper case vs. lower case
      {{FPL("foo.\u0109"), FPL(".\u0109")}, true},
      {{FPL("foo.\u0108"), FPL(".\u0109")}, true},
#endif
  });

  for (size_t i = 0; i < std::size(cases); ++i) {
    FilePath path(cases[i].inputs[0]);
    FilePath::StringType ext(cases[i].inputs[1]);

    EXPECT_EQ(cases[i].expected, path.MatchesFinalExtension(ext))
        << "i: " << i << ", path: " << path.value() << ", ext: " << ext;
  }
}

TEST_F(FilePathTest, CompareIgnoreCase) {
  const auto cases = std::to_array<BinaryIntTestData>({
      {{FPL("foo"), FPL("foo")}, 0},
      {{FPL("FOO"), FPL("foo")}, 0},
      {{FPL("foo.ext"), FPL("foo.ext")}, 0},
      {{FPL("FOO.EXT"), FPL("foo.ext")}, 0},
      {{FPL("Foo.Ext"), FPL("foo.ext")}, 0},
      {{FPL("foO"), FPL("foo")}, 0},
      {{FPL("foo"), FPL("foO")}, 0},
      {{FPL("fOo"), FPL("foo")}, 0},
      {{FPL("foo"), FPL("fOo")}, 0},
      {{FPL("bar"), FPL("foo")}, -1},
      {{FPL("foo"), FPL("bar")}, 1},
      {{FPL("BAR"), FPL("foo")}, -1},
      {{FPL("FOO"), FPL("bar")}, 1},
      {{FPL("bar"), FPL("FOO")}, -1},
      {{FPL("foo"), FPL("BAR")}, 1},
      {{FPL("BAR"), FPL("FOO")}, -1},
      {{FPL("FOO"), FPL("BAR")}, 1},
      // German "Eszett" (lower case and the new-fangled upper case)
      // Note that uc(<lowercase eszett>) => "SS", NOT <uppercase eszett>!
      // However, neither Windows nor Mac OSX converts these.
      // (or even have glyphs for <uppercase eszett>)
      {{FPL("\u00DF"), FPL("\u00DF")}, 0},
      {{FPL("\u1E9E"), FPL("\u1E9E")}, 0},
      {{FPL("\u00DF"), FPL("\u1E9E")}, -1},
      {{FPL("SS"), FPL("\u00DF")}, -1},
      {{FPL("SS"), FPL("\u1E9E")}, -1},
#if BUILDFLAG(IS_WIN) || BUILDFLAG(IS_APPLE)
      // Umlauts A, O, U: direct comparison, and upper case vs. lower case
      {{FPL("\u00E4\u00F6\u00FC"), FPL("\u00E4\u00F6\u00FC")}, 0},
      {{FPL("\u00C4\u00D6\u00DC"), FPL("\u00E4\u00F6\u00FC")}, 0},
      // C with circumflex: direct comparison, and upper case vs. lower case
      {{FPL("\u0109"), FPL("\u0109")}, 0},
      {{FPL("\u0108"), FPL("\u0109")}, 0},
      // Cyrillic letter SHA: direct comparison, and upper case vs. lower case
      {{FPL("\u0428"), FPL("\u0428")}, 0},
      {{FPL("\u0428"), FPL("\u0448")}, 0},
      // Greek letter DELTA: direct comparison, and upper case vs. lower case
      {{FPL("\u0394"), FPL("\u0394")}, 0},
      {{FPL("\u0394"), FPL("\u03B4")}, 0},
      // Japanese full-width A: direct comparison, and upper case vs. lower case
      // Note that full-width and standard characters are considered different.
      {{FPL("\uFF21"), FPL("\uFF21")}, 0},
      {{FPL("\uFF21"), FPL("\uFF41")}, 0},
      {{FPL("A"), FPL("\uFF21")}, -1},
      {{FPL("A"), FPL("\uFF41")}, -1},
      {{FPL("a"), FPL("\uFF21")}, -1},
      {{FPL("a"), FPL("\uFF41")}, -1},
#endif
#if BUILDFLAG(IS_APPLE)
      // Codepoints > 0x1000
      // Georgian letter DON: direct comparison, and upper case vs. lower case
      {{FPL("\u10A3"), FPL("\u10A3")}, 0},
      {{FPL("\u10A3"), FPL("\u10D3")}, 0},
      // Combining characters vs. pre-composed characters, upper and lower case
      {{FPL("k\u0301u\u032Do\u0304\u0301n"), FPL("\u1E31\u1E77\u1E53n")}, 0},
      {{FPL("k\u0301u\u032Do\u0304\u0301n"), FPL("kuon")}, 1},
      {{FPL("kuon"), FPL("k\u0301u\u032Do\u0304\u0301n")}, -1},
      {{FPL("K\u0301U\u032DO\u0304\u0301N"), FPL("KUON")}, 1},
      {{FPL("KUON"), FPL("K\u0301U\u032DO\u0304\u0301N")}, -1},
      {{FPL("k\u0301u\u032Do\u0304\u0301n"), FPL("KUON")}, 1},
      {{FPL("K\u0301U\u032DO\u0304\u0301N"), FPL("\u1E31\u1E77\u1E53n")}, 0},
      {{FPL("k\u0301u\u032Do\u0304\u0301n"), FPL("\u1E30\u1E76\u1E52n")}, 0},
      {{FPL("k\u0301u\u032Do\u0304\u0302n"), FPL("\u1E30\u1E76\u1E52n")}, 1},

      // Codepoints > 0xFFFF
      // Here, we compare the `Adlam Letter Shu` in its capital and small
      // version.
      {{FPL("\U0001E921"), FPL("\U0001E943")}, -1},
      {{FPL("\U0001E943"), FPL("\U0001E921")}, 1},
      {{FPL("\U0001E921"), FPL("\U0001E921")}, 0},
      {{FPL("\U0001E943"), FPL("\U0001E943")}, 0},
#endif
  });

  for (size_t i = 0; i < std::size(cases); ++i) {
    FilePath::StringType s1(cases[i].inputs[0]);
    FilePath::StringType s2(cases[i].inputs[1]);
    int result = FilePath::CompareIgnoreCase(s1, s2);
    EXPECT_EQ(cases[i].expected, result)
        << "i: " << i << ", s1: " << s1 << ", s2: " << s2;
  }
}

TEST_F(FilePathTest, ReferencesParent) {
  // clang-format off
  const auto cases = std::to_array<UnaryBooleanTestData>({
    { FPL("."),        false },
    { FPL(".."),       true },
#if BUILDFLAG(IS_WIN)
    { FPL(".. "),      true },
    { FPL(" .."),      true },
    { FPL("..."),      true },
#else
    { FPL(".. "),      false },
    { FPL(" .."),      false },
    { FPL("..."),      false },
#endif
    { FPL("a.."),      false },
    { FPL("..a"),      false },
    { FPL("../"),      true },
    { FPL("/.."),      true },
    { FPL("/../"),     true },
    { FPL("/a../"),    false },
    { FPL("/..a/"),    false },
    { FPL("//.."),     true },
    { FPL("..//"),     true },
    { FPL("//..//"),   true },
    { FPL("a//..//c"), true },
    { FPL("../b/c"),   true },
    { FPL("/../b/c"),  true },
    { FPL("a/b/.."),   true },
    { FPL("a/b/../"),  true },
    { FPL("a/../c"),   true },
    { FPL("a/b/c"),    false },
  });
  // clang-format on

  for (size_t i = 0; i < std::size(cases); ++i) {
    FilePath input(cases[i].input);
    bool observed = input.ReferencesParent();
    EXPECT_EQ(cases[i].expected, observed)
        << "i: " << i << ", input: " << input.value();
  }
}

TEST_F(FilePathTest, FromASCII) {
  const auto cases = std::to_array<UTF8TestData>({
      {FPL("foo.txt"), "foo.txt"},
      {FPL("!#$%&'()"), "!#$%&'()"},
  });

  for (size_t i = 0; i < std::size(cases); ++i) {
    FilePath from_ascii = FilePath::FromASCII(cases[i].utf8);
    EXPECT_EQ(FilePath::StringType(cases[i].native), from_ascii.value())
        << "i: " << i << ", input: " << cases[i].utf8;
  }
}

TEST_F(FilePathTest, FromUTF8Unsafe_And_AsUTF8Unsafe) {
  const auto cases = std::to_array<UTF8TestData>({
      {FPL("foo.txt"), "foo.txt"},
      // "aeo" with accents. Use http://0xcc.net/jsescape/ to decode them.
      {FPL("\u00E0\u00E8\u00F2.txt"), "\xC3\xA0\xC3\xA8\xC3\xB2.txt"},
      // Full-width "ABC".
      {FPL("\uFF21\uFF22\uFF23.txt"),
       "\xEF\xBC\xA1\xEF\xBC\xA2\xEF\xBC\xA3.txt"},
  });

#if !defined(SYSTEM_NATIVE_UTF8) && \
    (BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS))
  ScopedLocale locale("en_US.UTF-8");
#endif

  for (size_t i = 0; i < std::size(cases); ++i) {
    // Test FromUTF8Unsafe() works.
    FilePath from_utf8 = FilePath::FromUTF8Unsafe(cases[i].utf8);
    EXPECT_EQ(cases[i].native, from_utf8.value())
        << "i: " << i << ", input: " << cases[i].native;
    // Test AsUTF8Unsafe() works.
    FilePath from_native = FilePath(cases[i].native);
    EXPECT_EQ(cases[i].utf8, from_native.AsUTF8Unsafe())
        << "i: " << i << ", input: " << cases[i].native;
    // Test the two file paths are identical.
    EXPECT_EQ(from_utf8.value(), from_native.value());
  }
}

TEST_F(FilePathTest, ConstructWithNUL) {
  // Assert FPS() works.
  ASSERT_EQ(3U, FPS("a\0b").length());

  // Test constructor strips '\0'
  FilePath path(FPS("a\0b"));
  EXPECT_EQ(1U, path.value().length());
  EXPECT_EQ(FPL("a"), path.value());
}

TEST_F(FilePathTest, AppendWithNUL) {
  // Assert FPS() works.
  ASSERT_EQ(3U, FPS("b\0b").length());

  // Test Append() strips '\0'
  FilePath path(FPL("a"));
  path = path.Append(FPS("b\0b"));
  EXPECT_EQ(3U, path.value().length());
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
  EXPECT_EQ(FPL("a\\b"), path.value());
#else
  EXPECT_EQ(FPL("a/b"), path.value());
#endif
}

TEST_F(FilePathTest, AppendBaseName) {
  FilePath dir(FPL("foo"));
  auto file(SafeBaseName::Create(FPL("bar.txt")));
  EXPECT_TRUE(file);

#if defined(FILE_PATH_USES_WIN_SEPARATORS)
  EXPECT_EQ(dir.Append(*file), FilePath(FPL("foo\\bar.txt")));
#else
  EXPECT_EQ(dir.Append(*file), FilePath(FPL("foo/bar.txt")));
#endif
}

TEST_F(FilePathTest, ReferencesParentWithNUL) {
  // Assert FPS() works.
  ASSERT_EQ(3U, FPS("..\0").length());

  // Test ReferencesParent() doesn't break with "..\0"
  FilePath path(FPS("..\0"));
  EXPECT_TRUE(path.ReferencesParent());
}

#if defined(FILE_PATH_USES_WIN_SEPARATORS)
TEST_F(FilePathTest, NormalizePathSeparators) {
  const struct UnaryTestData cases[] = {
      {FPL("foo/bar"), FPL("foo\\bar")},
      {FPL("foo/bar\\betz"), FPL("foo\\bar\\betz")},
      {FPL("foo\\bar"), FPL("foo\\bar")},
      {FPL("foo\\bar/betz"), FPL("foo\\bar\\betz")},
      {FPL("foo"), FPL("foo")},
      // Trailing slashes don't automatically get stripped.  That's what
      // StripTrailingSeparators() is for.
      {FPL("foo\\"), FPL("foo\\")},
      {FPL("foo/"), FPL("foo\\")},
      {FPL("foo/bar\\"), FPL("foo\\bar\\")},
      {FPL("foo\\bar/"), FPL("foo\\bar\\")},
      {FPL("foo/bar/"), FPL("foo\\bar\\")},
      {FPL("foo\\bar\\"), FPL("foo\\bar\\")},
      {FPL("\\foo/bar"), FPL("\\foo\\bar")},
      {FPL("/foo\\bar"), FPL("\\foo\\bar")},
      {FPL("c:/foo/bar/"), FPL("c:\\foo\\bar\\")},
      {FPL("/foo/bar/"), FPL("\\foo\\bar\\")},
      {FPL("\\foo\\bar\\"), FPL("\\foo\\bar\\")},
      {FPL("c:\\foo/bar"), FPL("c:\\foo\\bar")},
      {FPL("//foo\\bar\\"), FPL("\\\\foo\\bar\\")},
      {FPL("\\\\foo\\bar\\"), FPL("\\\\foo\\bar\\")},
      {FPL("//foo\\bar\\"), FPL("\\\\foo\\bar\\")},
      // This method does not normalize the number of path separators.
      {FPL("foo\\\\bar"), FPL("foo\\\\bar")},
      {FPL("foo//bar"), FPL("foo\\\\bar")},
      {FPL("foo/\\bar"), FPL("foo\\\\bar")},
      {FPL("foo\\/bar"), FPL("foo\\\\bar")},
      {FPL("///foo\\\\bar"), FPL("\\\\\\foo\\\\bar")},
      {FPL("foo//bar///"), FPL("foo\\\\bar\\\\\\")},
      {FPL("foo/\\bar/\\"), FPL("foo\\\\bar\\\\")},
      {FPL("/\\foo\\/bar"), FPL("\\\\foo\\\\bar")},
  };
  for (size_t i = 0; i < std::size(cases); ++i) {
    FilePath input(cases[i].input);
    FilePath observed = input.NormalizePathSeparators();
    EXPECT_EQ(FilePath::StringType(cases[i].expected), observed.value())
        << "i: " << i << ", input: " << input.value();
  }
}
#endif

TEST_F(FilePathTest, EndsWithSeparator) {
  const UnaryBooleanTestData cases[] = {
      {FPL(""), false},    {FPL("/"), true},         {FPL("foo/"), true},
      {FPL("bar"), false}, {FPL("/foo/bar"), false},
  };
  for (const auto& i : cases) {
    FilePath input = FilePath(i.input).NormalizePathSeparators();
    EXPECT_EQ(i.expected, input.EndsWithSeparator());
  }
}

TEST_F(FilePathTest, AsEndingWithSeparator) {
  const UnaryTestData cases[] = {{FPL(""), FPL("")},
                                 {FPL("/"), FPL("/")},
                                 {FPL("foo"), FPL("foo/")},
                                 {FPL("foo/"), FPL("foo/")}};
  for (const auto& i : cases) {
    FilePath input = FilePath(i.input).NormalizePathSeparators();
    FilePath expected = FilePath(i.expected).NormalizePathSeparators();
    EXPECT_EQ(expected.value(), input.AsEndingWithSeparator().value());
  }
}

#if BUILDFLAG(IS_ANDROID)
TEST_F(FilePathTest, ContentUriTest) {
  const struct UnaryBooleanTestData cases[] = {
      {FPL("content://foo.bar"), true},
      {FPL("content://foo.bar/"), true},
      {FPL("content://foo/bar"), true},
      {FPL("CoNTenT://foo.bar"), true},
      {FPL("content://"), true},
      {FPL("content:///foo.bar"), true},
      {FPL("content://3foo/bar"), true},
      {FPL("content://_foo/bar"), true},
      {FPL(".. "), false},
      {FPL("foo.bar"), false},
      {FPL("content:foo.bar"), false},
      {FPL("content:/foo.ba"), false},
      {FPL("content:/dir/foo.bar"), false},
      {FPL("content: //foo.bar"), false},
      {FPL("content%2a%2f%2f"), false},
  };

  for (size_t i = 0; i < std::size(cases); ++i) {
    FilePath input(cases[i].input);
    bool observed = input.IsContentUri();
    EXPECT_EQ(cases[i].expected, observed)
        << "i: " << i << ", input: " << input.value();
  }
}
#endif

// Test the operator<<(ostream, FilePath).
TEST_F(FilePathTest, PrintToOstream) {
  std::stringstream ss;
  FilePath fp(FPL("foo"));
  ss << fp;
  EXPECT_EQ("foo", ss.str());
}

TEST_F(FilePathTest, TracedValueSupport) {
  EXPECT_EQ(perfetto::TracedValueToString(FilePath(FPL("foo"))), "foo");
}

TEST_F(FilePathTest, IsSeparator) {
  EXPECT_FALSE(FilePath::IsSeparator(FILE_PATH_LITERAL('x')));
  EXPECT_FALSE(FilePath::IsSeparator(FILE_PATH_LITERAL('\0')));
  EXPECT_TRUE(FilePath::IsSeparator(FILE_PATH_LITERAL('/')));
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
  EXPECT_TRUE(FilePath::IsSeparator(FILE_PATH_LITERAL('\\')));
#else
  EXPECT_FALSE(FilePath::IsSeparator(FILE_PATH_LITERAL('\\')));
#endif
}

// Test GetHFSDecomposedForm should return empty result for invalid UTF-8
// strings.
#if BUILDFLAG(IS_APPLE)
TEST_F(FilePathTest, GetHFSDecomposedFormWithInvalidInput) {
  const FilePath::CharType* cases[] = {
      FPL("\xc3\x28"),         FPL("\xe2\x82\x28"),     FPL("\xe2\x28\xa1"),
      FPL("\xf0\x28\x8c\xbc"), FPL("\xf0\x28\x8c\x28"),
  };
  for (auto* invalid_input : cases) {
    FilePath::StringType observed =
        FilePath::GetHFSDecomposedForm(invalid_input);
    EXPECT_TRUE(observed.empty());
  }
}

TEST_F(FilePathTest, CompareIgnoreCaseWithInvalidInput) {
  const FilePath::CharType* cases[] = {
      FPL("\xc3\x28"),         FPL("\xe2\x82\x28"),     FPL("\xe2\x28\xa1"),
      FPL("\xf0\x28\x8c\xbc"), FPL("\xf0\x28\x8c\x28"),
  };
  for (auto* invalid_input : cases) {
    // All example inputs will be greater than the string "fixed".
    EXPECT_EQ(FilePath::CompareIgnoreCase(invalid_input, FPL("fixed")), 1);
  }
}
#endif

}  // namespace base