// Copyright 2024 Google LLC. All Rights Reserved. This file and proprietary
// source code may only be used and distributed under the Widevine License
// Agreement.
#include "string_utils.h"

#include <string>
#include <vector>

#include <gtest/gtest.h>

namespace wvutil {

// std::vector<std::string> StringSplit(const std::string& s, char delim);

TEST(StringUtilsTest, StringSplit_CharDelim_EmptyText) {
  const std::vector<std::string> kEmptyVec;
  const std::string kEmptyString;
  constexpr char kDelimiter = ',';
  EXPECT_EQ(StringSplit(kEmptyString, kDelimiter), kEmptyVec);
}

TEST(StringUtilsTest, StringSplit_CharDelim_SingleCharacterText_NoMatch) {
  const std::string kText = "a";
  constexpr char kDelimiter = ',';
  const std::vector<std::string> kExpected = {"a"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CharDelim_SingleCharacterText_Match) {
  const std::string kText = "a";
  constexpr char kDelimiter = 'a';
  const std::vector<std::string> kExpected = {"", ""};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CharDelim_LongText_NoMatch) {
  const std::string kText = "abcdefg";
  constexpr char kDelimiter = ',';
  const std::vector<std::string> kExpected = {"abcdefg"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CharDelim_LongText_SingleMidMatch) {
  const std::string kText = "abcdefg";
  constexpr char kDelimiter = 'd';
  const std::vector<std::string> kExpected = {"abc", "efg"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CharDelim_LongText_SingleFrontMatch) {
  const std::string kText = "abcdefg";
  constexpr char kDelimiter = 'a';
  const std::vector<std::string> kExpected = {"", "bcdefg"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CharDelim_LongText_SingleBackMatch) {
  const std::string kText = "abcdefg";
  constexpr char kDelimiter = 'g';
  const std::vector<std::string> kExpected = {"abcdef", ""};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CharDelim_LongText_MultiInnerMatch) {
  const std::string kText = "123.456.789";
  constexpr char kDelimiter = '.';
  const std::vector<std::string> kExpected = {"123", "456", "789"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CharDelim_LongText_MultiEndsMatch) {
  const std::string kText = ".123..456..789.";
  constexpr char kDelimiter = '.';
  const std::vector<std::string> kExpected = {"", "123", "", "456",
                                              "", "789", ""};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CharDelim_LongText_AllMatch) {
  const std::string kText = "aaaaa";
  constexpr char kDelimiter = 'a';
  const std::vector<std::string> kExpected = {"", "", "", "", "", ""};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CharDelim_NullByte) {
  using namespace std::string_literals;
  // Ensure that split can handle null bytes within C++ strings.
  const std::string kText = "Hello\0World!"s;
  constexpr char kDelimiter = '\0';
  const std::vector<std::string> kExpected = {"Hello", "World!"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

// std::vector<std::string> StringSplit(const std::string& s,
//                                      const std::string& delim);

TEST(StringUtilsTest, StringSplit_StringDelim_EmptyText_EmptyDelim) {
  const std::string kEmptyString;
  const std::vector<std::string> kExpected = {};
  EXPECT_EQ(StringSplit(kEmptyString, kEmptyString), kExpected);
}

TEST(StringUtilsTest, StringSplit_StringDelim_EmptyText_NoMatch) {
  const std::string kText = "";
  const std::string kDelimiter = "a";
  const std::vector<std::string> kExpected = {};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_StringDelim_SingleCharText_EmptyDelim) {
  const std::string kText = "a";
  const std::string kDelimiter = "";
  const std::vector<std::string> kExpected = {"a"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_StringDelim_SingleCharText_NoMatch) {
  const std::string kText = "a";
  const std::string kDelimiter = ",";
  const std::vector<std::string> kExpected = {"a"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_StringDelim_SingleCharText_NoMatch2) {
  const std::string kText = "a";
  const std::string kDelimiter = "bcd";
  const std::vector<std::string> kExpected = {"a"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_StringDelim_SingleCharText_Match) {
  const std::string kText = "a";
  const std::string kDelimiter = "a";
  const std::vector<std::string> kExpected = {"", ""};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_StringDelim_LongText_EmptyDelim) {
  const std::string kText = "abcdefg";
  const std::string kDelimiter = "";
  const std::vector<std::string> kExpected = {"a", "b", "c", "d",
                                              "e", "f", "g"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_StringDelim_LongText_NoMatch) {
  const std::string kText = "abcdefg";
  const std::string kDelimiter = "edc";
  const std::vector<std::string> kExpected = {kText};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_StringDelim_LongText_SingleMidMatch) {
  const std::string kText = "abcdefg";
  const std::string kDelimiter = "d";
  const std::vector<std::string> kExpected = {"abc", "efg"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_StringDelim_LongText_SingleMidMatch2) {
  const std::string kText = "abcdefg";
  const std::string kDelimiter = "cde";
  const std::vector<std::string> kExpected = {"ab", "fg"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_StringDelim_LongText_SingleFrontMatch) {
  const std::string kText = "abcdefg";
  const std::string kDelimiter = "a";
  const std::vector<std::string> kExpected = {"", "bcdefg"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_StringDelim_LongText_SingleFrontMatch2) {
  const std::string kText = "abcdefg";
  const std::string kDelimiter = "abc";
  const std::vector<std::string> kExpected = {"", "defg"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_StringDelim_LongText_SingleBackMatch) {
  const std::string kText = "abcdefg";
  const std::string kDelimiter = "g";
  const std::vector<std::string> kExpected = {"abcdef", ""};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_StringDelim_LongText_SingleBackMatch2) {
  const std::string kText = "abcdefg";
  const std::string kDelimiter = "efg";
  const std::vector<std::string> kExpected = {"abcd", ""};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_StringDelim_LongText_MultiInnerMatch) {
  const std::string kText = "123.456.789";
  const std::string kDelimiter = ".";
  const std::vector<std::string> kExpected = {"123", "456", "789"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_StringDelim_LongText_MultiInnerMatch2) {
  const std::string kText = "123, 456, 789";
  const std::string kDelimiter = ", ";
  const std::vector<std::string> kExpected = {"123", "456", "789"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_StringDelim_LongText_MultiEndsMatch) {
  const std::string kText = ".123.456..789.";
  const std::string kDelimiter = ".";
  const std::vector<std::string> kExpected = {"", "123", "456", "", "789", ""};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_StringDelim_LongText_MultiEndsMatch2) {
  const std::string kText = ", 123, 456, 789, ";
  const std::string kDelimiter = ", ";
  const std::vector<std::string> kExpected = {"", "123", "456", "789", ""};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_StringDelim_LongText_AllMatch) {
  const std::string kText = "aaaaa";
  const std::string kDelimiter = "a";
  const std::vector<std::string> kExpected = {"", "", "", "", "", ""};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_StringDelim_LongText_AllMatch2) {
  const std::string kText = "123123123";
  const std::string kDelimiter = "123";
  const std::vector<std::string> kExpected = {"", "", "", ""};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

// std::vector<std::string> StringSplit(const std::string& s,
//                                      const char* delim);

TEST(StringUtilsTest, StringSplit_CStringDelim_NullDelim) {
  const std::string kText = "a";
  const std::vector<std::string> kExpected = {};
  EXPECT_EQ(StringSplit(kText, nullptr), kExpected);
}

TEST(StringUtilsTest, StringSplit_CStringDelim_EmptyText_EmptyDelim) {
  const std::string kText;
  constexpr char kDelimiter[] = "";
  const std::vector<std::string> kExpected = {};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CStringDelim_EmptyText_NoMatch) {
  const std::string kText = "";
  constexpr char kDelimiter[] = "a";
  const std::vector<std::string> kExpected = {};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CStringDelim_SingleCharText_EmptyDelim) {
  const std::string kText = "a";
  constexpr char kDelimiter[] = "";
  const std::vector<std::string> kExpected = {"a"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CStringDelim_SingleCharText_NoMatch) {
  const std::string kText = "a";
  constexpr char kDelimiter[] = ",";
  const std::vector<std::string> kExpected = {"a"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CStringDelim_SingleCharText_NoMatch2) {
  const std::string kText = "a";
  constexpr char kDelimiter[] = "bcd";
  const std::vector<std::string> kExpected = {"a"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CStringDelim_SingleCharText_Match) {
  const std::string kText = "a";
  constexpr char kDelimiter[] = "a";
  const std::vector<std::string> kExpected = {"", ""};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CStringDelim_LongText_EmptyDelim) {
  const std::string kText = "abcdefg";
  constexpr char kDelimiter[] = "";
  const std::vector<std::string> kExpected = {"a", "b", "c", "d",
                                              "e", "f", "g"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CStringDelim_LongText_NoMatch) {
  const std::string kText = "abcdefg";
  constexpr char kDelimiter[] = "edc";
  const std::vector<std::string> kExpected = {kText};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CStringDelim_LongText_SingleMidMatch) {
  const std::string kText = "abcdefg";
  constexpr char kDelimiter[] = "d";
  const std::vector<std::string> kExpected = {"abc", "efg"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CStringDelim_LongText_SingleMidMatch2) {
  const std::string kText = "abcdefg";
  constexpr char kDelimiter[] = "cde";
  const std::vector<std::string> kExpected = {"ab", "fg"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CStringDelim_LongText_SingleFrontMatch) {
  const std::string kText = "abcdefg";
  constexpr char kDelimiter[] = "a";
  const std::vector<std::string> kExpected = {"", "bcdefg"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CStringDelim_LongText_SingleFrontMatch2) {
  const std::string kText = "abcdefg";
  constexpr char kDelimiter[] = "abc";
  const std::vector<std::string> kExpected = {"", "defg"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CStringDelim_LongText_SingleBackMatch) {
  const std::string kText = "abcdefg";
  constexpr char kDelimiter[] = "g";
  const std::vector<std::string> kExpected = {"abcdef", ""};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CStringDelim_LongText_SingleBackMatch2) {
  const std::string kText = "abcdefg";
  constexpr char kDelimiter[] = "efg";
  const std::vector<std::string> kExpected = {"abcd", ""};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CStringDelim_LongText_MultiInnerMatch) {
  const std::string kText = "123.456.789";
  constexpr char kDelimiter[] = ".";
  const std::vector<std::string> kExpected = {"123", "456", "789"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CStringDelim_LongText_MultiInnerMatch2) {
  const std::string kText = "123, 456, 789";
  constexpr char kDelimiter[] = ", ";
  const std::vector<std::string> kExpected = {"123", "456", "789"};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CStringDelim_LongText_MultiEndsMatch) {
  const std::string kText = ".123.456..789.";
  constexpr char kDelimiter[] = ".";
  const std::vector<std::string> kExpected = {"", "123", "456", "", "789", ""};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CStringDelim_LongText_MultiEndsMatch2) {
  const std::string kText = ", 123, 456, 789, ";
  constexpr char kDelimiter[] = ", ";
  const std::vector<std::string> kExpected = {"", "123", "456", "789", ""};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CStringDelim_LongText_AllMatch) {
  const std::string kText = "aaaaa";
  constexpr char kDelimiter[] = "a";
  const std::vector<std::string> kExpected = {"", "", "", "", "", ""};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

TEST(StringUtilsTest, StringSplit_CStringDelim_LongText_AllMatch2) {
  const std::string kText = "123123123";
  constexpr char kDelimiter[] = "123";
  const std::vector<std::string> kExpected = {"", "", "", ""};
  EXPECT_EQ(StringSplit(kText, kDelimiter), kExpected);
}

// std::string StringJoin(const std::vector<std::string>& tokens, char glue);

TEST(StringUtilsTest, StringJoin_CharGlue_NoTokens) {
  const std::vector<std::string> kTokens = {};
  constexpr char kGlue = ',';
  const std::string kExpected = "";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CharGlue_SingleEmptyToken) {
  const std::vector<std::string> kTokens = {""};
  constexpr char kGlue = ',';
  const std::string kExpected = "";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CharGlue_SingleToken) {
  const std::vector<std::string> kTokens = {"a"};
  constexpr char kGlue = ',';
  const std::string kExpected = "a";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CharGlue_SingleToken2) {
  const std::vector<std::string> kTokens = {"abcdefg"};
  constexpr char kGlue = ',';
  const std::string kExpected = "abcdefg";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CharGlue_ManyEmptyTokens) {
  const std::vector<std::string> kTokens = {"", "", ""};
  constexpr char kGlue = ',';
  const std::string kExpected = ",,";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CharGlue_ManyTokens) {
  const std::vector<std::string> kTokens = {"a", "bcd", "", "efg"};
  constexpr char kGlue = ',';
  const std::string kExpected = "a,bcd,,efg";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

// std::string StringJoin(const std::vector<std::string>& tokens,
//                        const std::string& glue = "");

TEST(StringUtilsTest, StringJoin_StringGlue_NoTokens_EmptyGlue) {
  const std::vector<std::string> kTokens = {};
  const std::string kGlue = "";
  const std::string kExpected = "";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_StringGlue_SingleEmptyToken_EmptyGlue) {
  const std::vector<std::string> kTokens = {""};
  const std::string kGlue = "";
  const std::string kExpected = "";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_StringGlue_SingleToken_EmptyGlue) {
  const std::vector<std::string> kTokens = {"a"};
  const std::string kGlue = "";
  const std::string kExpected = "a";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_StringGlue_SingleToken2_EmptyGlue) {
  const std::vector<std::string> kTokens = {"abcdefg"};
  const std::string kGlue = "";
  const std::string kExpected = "abcdefg";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_StringGlue_ManyEmptyTokens_EmptyGlue) {
  const std::vector<std::string> kTokens = {"", "", ""};
  const std::string kGlue = "";
  const std::string kExpected = "";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_StringGlue_ManyTokens_EmptyGlue) {
  const std::vector<std::string> kTokens = {"a", "bcd", "", "efg"};
  const std::string kGlue = "";
  const std::string kExpected = "abcdefg";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_StringGlue_NoTokens_SingleCharGlue) {
  const std::vector<std::string> kTokens = {};
  const std::string kGlue = ",";
  const std::string kExpected = "";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_StringGlue_SingleEmptyToken_SingleCharGlue) {
  const std::vector<std::string> kTokens = {""};
  const std::string kGlue = ",";
  const std::string kExpected = "";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_StringGlue_SingleToken_SingleCharGlue) {
  const std::vector<std::string> kTokens = {"a"};
  const std::string kGlue = ",";
  const std::string kExpected = "a";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_StringGlue_SingleToken2_SingleCharGlue) {
  const std::vector<std::string> kTokens = {"abcdefg"};
  const std::string kGlue = ",";
  const std::string kExpected = "abcdefg";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_StringGlue_ManyEmptyTokens_SingleCharGlue) {
  const std::vector<std::string> kTokens = {"", "", ""};
  const std::string kGlue = ",";
  const std::string kExpected = ",,";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_StringGlue_ManyTokens_SingleCharGlue) {
  const std::vector<std::string> kTokens = {"a", "bcd", "", "efg"};
  const std::string kGlue = ",";
  const std::string kExpected = "a,bcd,,efg";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_StringGlue_NoTokens_MultiCharGlue) {
  const std::vector<std::string> kTokens = {};
  const std::string kGlue = ", ";
  const std::string kExpected = "";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_StringGlue_SingleEmptyToken_MultiCharGlue) {
  const std::vector<std::string> kTokens = {""};
  const std::string kGlue = ", ";
  const std::string kExpected = "";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_StringGlue_SingleToken_MultiCharGlue) {
  const std::vector<std::string> kTokens = {"a"};
  const std::string kGlue = ", ";
  const std::string kExpected = "a";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_StringGlue_SingleToken2_MultiCharGlue) {
  const std::vector<std::string> kTokens = {"abcdefg"};
  const std::string kGlue = ", ";
  const std::string kExpected = "abcdefg";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_StringGlue_ManyEmptyTokens_MultiCharGlue) {
  const std::vector<std::string> kTokens = {"", "", ""};
  const std::string kGlue = ", ";
  const std::string kExpected = ", , ";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_StringGlue_ManyTokens_MultiCharGlue) {
  const std::vector<std::string> kTokens = {"a", "bcd", "", "efg"};
  const std::string kGlue = ", ";
  const std::string kExpected = "a, bcd, , efg";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

// std::string StringJoin(const std::vector<std::string>& tokens,
//                        const char* glue);

TEST(StringUtilsTest, StringJoin_CStringGlue_NullGlue) {
  const std::vector<std::string> kTokens = {"123", "456"};
  const std::string kExpected = "";
  EXPECT_EQ(StringJoin(kTokens, nullptr), kExpected);
}

TEST(StringUtilsTest, StringJoin_CStringGlue_NoTokens_EmptyGlue) {
  const std::vector<std::string> kTokens = {};
  constexpr char kGlue[] = "";
  const std::string kExpected = "";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CStringGlue_SingleEmptyToken_EmptyGlue) {
  const std::vector<std::string> kTokens = {""};
  constexpr char kGlue[] = "";
  const std::string kExpected = "";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CStringGlue_SingleToken_EmptyGlue) {
  const std::vector<std::string> kTokens = {"a"};
  constexpr char kGlue[] = "";
  const std::string kExpected = "a";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CStringGlue_SingleToken2_EmptyGlue) {
  const std::vector<std::string> kTokens = {"abcdefg"};
  constexpr char kGlue[] = "";
  const std::string kExpected = "abcdefg";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CStringGlue_ManyEmptyTokens_EmptyGlue) {
  const std::vector<std::string> kTokens = {"", "", ""};
  constexpr char kGlue[] = "";
  const std::string kExpected = "";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CStringGlue_ManyTokens_EmptyGlue) {
  const std::vector<std::string> kTokens = {"a", "bcd", "", "efg"};
  constexpr char kGlue[] = "";
  const std::string kExpected = "abcdefg";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CStringGlue_NoTokens_SingleCharGlue) {
  const std::vector<std::string> kTokens = {};
  constexpr char kGlue[] = ",";
  const std::string kExpected = "";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CStringGlue_SingleEmptyToken_SingleCharGlue) {
  const std::vector<std::string> kTokens = {""};
  constexpr char kGlue[] = ",";
  const std::string kExpected = "";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CStringGlue_SingleToken_SingleCharGlue) {
  const std::vector<std::string> kTokens = {"a"};
  constexpr char kGlue[] = ",";
  const std::string kExpected = "a";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CStringGlue_SingleToken2_SingleCharGlue) {
  const std::vector<std::string> kTokens = {"abcdefg"};
  constexpr char kGlue[] = ",";
  const std::string kExpected = "abcdefg";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CStringGlue_ManyEmptyTokens_SingleCharGlue) {
  const std::vector<std::string> kTokens = {"", "", ""};
  constexpr char kGlue[] = ",";
  const std::string kExpected = ",,";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CStringGlue_ManyTokens_SingleCharGlue) {
  const std::vector<std::string> kTokens = {"a", "bcd", "", "efg"};
  constexpr char kGlue[] = ",";
  const std::string kExpected = "a,bcd,,efg";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CStringGlue_NoTokens_MultiCharGlue) {
  const std::vector<std::string> kTokens = {};
  constexpr char kGlue[] = ", ";
  const std::string kExpected = "";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CStringGlue_SingleEmptyToken_MultiCharGlue) {
  const std::vector<std::string> kTokens = {""};
  constexpr char kGlue[] = ", ";
  const std::string kExpected = "";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CStringGlue_SingleToken_MultiCharGlue) {
  const std::vector<std::string> kTokens = {"a"};
  constexpr char kGlue[] = ", ";
  const std::string kExpected = "a";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CStringGlue_SingleToken2_MultiCharGlue) {
  const std::vector<std::string> kTokens = {"abcdefg"};
  constexpr char kGlue[] = ", ";
  const std::string kExpected = "abcdefg";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CStringGlue_ManyEmptyTokens_MultiCharGlue) {
  const std::vector<std::string> kTokens = {"", "", ""};
  constexpr char kGlue[] = ", ";
  const std::string kExpected = ", , ";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

TEST(StringUtilsTest, StringJoin_CStringGlue_ManyTokens_MultiCharGlue) {
  const std::vector<std::string> kTokens = {"a", "bcd", "", "efg"};
  constexpr char kGlue[] = ", ";
  const std::string kExpected = "a, bcd, , efg";
  EXPECT_EQ(StringJoin(kTokens, kGlue), kExpected);
}

// size_t StringCount(const std::string& haystack, char needle);

TEST(StringUtilsTest, StringCount_CharNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  constexpr char kNeedle = '.';
  constexpr size_t kExpected = 0;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest, StringCount_CharNeedle_SingleCharHaystack_NoMatch) {
  const std::string kHaystack = "a";
  constexpr char kNeedle = '.';
  constexpr size_t kExpected = 0;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest, StringCount_CharNeedle_SingleCharHaystack_Match) {
  const std::string kHaystack = "a";
  constexpr char kNeedle = 'a';
  constexpr size_t kExpected = 1;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest, StringCount_CharNeedle_LongHaystack_NoMatch) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle = '.';
  constexpr size_t kExpected = 0;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest, StringCount_CharNeedle_LongHaystack_SingleMatch) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle = 'd';
  constexpr size_t kExpected = 1;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest, StringCount_CharNeedle_LongHaystack_ManyMatch) {
  const std::string kHaystack = "123.456.789";
  constexpr char kNeedle = '.';
  constexpr size_t kExpected = 2;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest, StringCount_CharNeedle_LongHaystack_AllMatch) {
  const std::string kHaystack = "aaaaa";
  constexpr char kNeedle = 'a';
  constexpr size_t kExpected = 5;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

// size_t StringCount(const std::string& haystack, const std::string& needle);

TEST(StringUtilsTest, StringCount_StringNeedle_EmptyNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  const std::string kNeedle = "";
  constexpr size_t kExpected = 1;  // Special case
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest, StringCount_StringNeedle_EmptyNeedle_SingleCharHaystack) {
  const std::string kHaystack = "a";
  const std::string kNeedle = "";
  constexpr size_t kExpected = 2;  // Special case
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest, StringCount_StringNeedle_EmptyNeedle_LongHaystack) {
  const std::string kHaystack = "1234567";
  const std::string kNeedle = "";
  constexpr size_t kExpected = 8;  // Special case
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest, StringCount_StringNeedle_SingleCharNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  const std::string kNeedle = ".";
  constexpr size_t kExpected = 0;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_StringNeedle_SingleCharNeedle_SingleCharHaystack_NoMatch) {
  const std::string kHaystack = "a";
  const std::string kNeedle = ".";
  constexpr size_t kExpected = 0;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_StringNeedle_SingleCharNeedle_SingleCharHaystack_Match) {
  const std::string kHaystack = "a";
  const std::string kNeedle = "a";
  constexpr size_t kExpected = 1;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_StringNeedle_SingleCharNeedle_LongHaystack_NoMatch) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = ".";
  constexpr size_t kExpected = 0;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_StringNeedle_SingleCharNeedle_LongHaystack_SingleMatch) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "d";
  constexpr size_t kExpected = 1;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_StringNeedle_SingleCharNeedle_LongHaystack_ManyMatch) {
  const std::string kHaystack = "123.456.789";
  const std::string kNeedle = ".";
  constexpr size_t kExpected = 2;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_StringNeedle_SingleCharNeedle_LongHaystack_AllMatch) {
  const std::string kHaystack = "aaaaa";
  const std::string kNeedle = "a";
  constexpr size_t kExpected = 5;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest, StringCount_StringNeedle_MultiCharNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  const std::string kNeedle = "123";
  constexpr size_t kExpected = 0;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_StringNeedle_MultiCharNeedle_SingleCharHaystack_NoMatch) {
  const std::string kHaystack = "a";
  const std::string kNeedle = "abc";
  constexpr size_t kExpected = 0;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_StringNeedle_MultiCharNeedle_LongHaystack_NoMatch) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "123";
  constexpr size_t kExpected = 0;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_StringNeedle_MultiCharNeedle_LongHaystack_Equal) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "abcdefg";
  constexpr size_t kExpected = 1;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_StringNeedle_MultiCharNeedle_LongHaystack_SingleMatch) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "cde";
  constexpr size_t kExpected = 1;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_StringNeedle_MultiCharNeedle_LongHaystack_ManyMatch) {
  const std::string kHaystack = "123.123.123";
  const std::string kNeedle = "123";
  constexpr size_t kExpected = 3;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_StringNeedle_MultiCharNeedle_LongHaystack_AllMatch) {
  const std::string kHaystack = "aaaaaa";
  const std::string kNeedle = "aa";
  constexpr size_t kExpected = 3;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

// size_t StringCount(const std::string& haystack, const char* needle);

TEST(StringUtilsTest, StringCount_CStringNeedle_NullNeedle) {
  const std::string kHaystack = "";
  constexpr size_t kExpected = 0;
  EXPECT_EQ(StringCount(kHaystack, nullptr), kExpected);
}

TEST(StringUtilsTest, StringCount_CStringNeedle_EmptyNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  constexpr char kNeedle[] = "";
  constexpr size_t kExpected = 1;  // Special case
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_CStringNeedle_EmptyNeedle_SingleCharHaystack) {
  const std::string kHaystack = "a";
  constexpr char kNeedle[] = "";
  constexpr size_t kExpected = 2;  // Special case
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest, StringCount_CStringNeedle_EmptyNeedle_LongHaystack) {
  const std::string kHaystack = "1234567";
  constexpr char kNeedle[] = "";
  constexpr size_t kExpected = 8;  // Special case
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_CStringNeedle_SingleCharNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  constexpr char kNeedle[] = ".";
  constexpr size_t kExpected = 0;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_CStringNeedle_SingleCharNeedle_SingleCharHaystack_NoMatch) {
  const std::string kHaystack = "a";
  constexpr char kNeedle[] = ".";
  constexpr size_t kExpected = 0;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_CStringNeedle_SingleCharNeedle_SingleCharHaystack_Match) {
  const std::string kHaystack = "a";
  constexpr char kNeedle[] = "a";
  constexpr size_t kExpected = 1;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_CStringNeedle_SingleCharNeedle_LongHaystack_NoMatch) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle[] = ".";
  constexpr size_t kExpected = 0;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_CStringNeedle_MultiCharNeedle_LongHaystack_Equal) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle[] = "abcdefg";
  constexpr size_t kExpected = 1;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_CStringNeedle_SingleCharNeedle_LongHaystack_SingleMatch) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle[] = "d";
  constexpr size_t kExpected = 1;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_CStringNeedle_SingleCharNeedle_LongHaystack_ManyMatch) {
  const std::string kHaystack = "123.456.789";
  constexpr char kNeedle[] = ".";
  constexpr size_t kExpected = 2;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_CStringNeedle_SingleCharNeedle_LongHaystack_AllMatch) {
  const std::string kHaystack = "aaaaa";
  constexpr char kNeedle[] = "a";
  constexpr size_t kExpected = 5;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest, StringCount_CStringNeedle_MultiCharNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  constexpr char kNeedle[] = "123";
  constexpr size_t kExpected = 0;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_CStringNeedle_MultiCharNeedle_SingleCharHaystack_NoMatch) {
  const std::string kHaystack = "a";
  constexpr char kNeedle[] = "abc";
  constexpr size_t kExpected = 0;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_CStringNeedle_MultiCharNeedle_LongHaystack_NoMatch) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle[] = "123";
  constexpr size_t kExpected = 0;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_CStringNeedle_MultiCharNeedle_LongHaystack_SingleMatch) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle[] = "cde";
  constexpr size_t kExpected = 1;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_CStringNeedle_MultiCharNeedle_LongHaystack_ManyMatch) {
  const std::string kHaystack = "123.123.123";
  constexpr char kNeedle[] = "123";
  constexpr size_t kExpected = 3;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

TEST(StringUtilsTest,
     StringCount_CStringNeedle_MultiCharNeedle_LongHaystack_AllMatch) {
  const std::string kHaystack = "aaaaaa";
  constexpr char kNeedle[] = "aa";
  constexpr size_t kExpected = 3;
  EXPECT_EQ(StringCount(kHaystack, kNeedle), kExpected);
}

// bool StringContains(const std::string& haystack, char needle);

TEST(StringUtilsTest, StringContains_CharNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  constexpr char kNeedle = '.';
  EXPECT_FALSE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringContains_CharNeedle_SingleCharHaystack_NotFound) {
  const std::string kHaystack = "a";
  constexpr char kNeedle = '.';
  EXPECT_FALSE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringContains_CharNeedle_SingleCharHaystack_Found) {
  const std::string kHaystack = "a";
  constexpr char kNeedle = 'a';
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringContains_CharNeedle_LongHaystack_NotFound) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle = '.';
  EXPECT_FALSE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringContains_CharNeedle_LongHaystack_FrontFound) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle = 'a';
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringContains_CharNeedle_LongHaystack_BackFound) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle = 'g';
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringContains_CharNeedle_LongHaystack_MidFound) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle = 'd';
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

// bool StringContains(const std::string& haystack, const std::string& needle);

TEST(StringUtilsTest, StringContains_StringNeedle_EmptyNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  const std::string kNeedle = "";  // Special case
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_StringNeedle_EmptyNeedle_SingleCharHaystack) {
  const std::string kHaystack = "a";
  const std::string kNeedle = "";  // Special case
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringContains_StringNeedle_EmptyNeedle_LongHaystack) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "";  // Special case
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_StringNeedle_SingleCharNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  const std::string kNeedle = ".";
  EXPECT_FALSE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_StringNeedle_SingleCharNeedle_SingleCharHaystack_NotFound) {
  const std::string kHaystack = "a";
  const std::string kNeedle = ".";
  EXPECT_FALSE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_StringNeedle_SingleCharNeedle_SingleCharHaystack_Equal) {
  const std::string kHaystack = "a";
  const std::string kNeedle = "a";
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_StringNeedle_SingleCharNeedle_LongHaystack_NotFound) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = ".";
  EXPECT_FALSE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_StringNeedle_SingleCharNeedle_LongHaystack_FrontFound) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "a";
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_StringNeedle_SingleCharNeedle_LongHaystack_BackFound) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "g";
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_StringNeedle_SingleCharNeedle_LongHaystack_MidFound) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "d";
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_StringNeedle_MultiCharNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  const std::string kNeedle = "123";
  EXPECT_FALSE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_StringNeedle_MultiCharNeedle_SingleCharHaystack_NotFound) {
  const std::string kHaystack = "a";
  const std::string kNeedle = "abc";
  EXPECT_FALSE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_StringNeedle_MultiCharNeedle_LongHaystack_NotFound) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "123";
  EXPECT_FALSE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_StringNeedle_MultiCharNeedle_LongHaystack_Equal) {
  const std::string kHaystack = "abc";
  const std::string kNeedle = "abc";
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_StringNeedle_MultiCharNeedle_LongHaystack_FrontFound) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "abc";
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_StringNeedle_MultiCharNeedle_LongHaystack_BackFound) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "efg";
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_StringNeedle_MultiCharNeedle_LongHaystack_MidFound) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "cde";
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

// bool StringContains(const std::string& haystack, const char* needle);

TEST(StringUtilsTest, StringContains_CStringNeedle_NullNeedle) {
  const std::string kHaystack = "abcdefg";
  EXPECT_FALSE(StringContains(kHaystack, nullptr));
}

TEST(StringUtilsTest, StringContains_CStringNeedle_EmptyNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  constexpr char kNeedle[] = "";  // Special case
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_CStringNeedle_EmptyNeedle_SingleCharHaystack) {
  const std::string kHaystack = "a";
  constexpr char kNeedle[] = "";  // Special case
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringContains_CStringNeedle_EmptyNeedle_LongHaystack) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle[] = "";  // Special case
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_CStringNeedle_SingleCharNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  constexpr char kNeedle[] = ".";
  EXPECT_FALSE(StringContains(kHaystack, kNeedle));
}

TEST(
    StringUtilsTest,
    StringContains_CStringNeedle_SingleCharNeedle_SingleCharHaystack_NotFound) {
  const std::string kHaystack = "a";
  constexpr char kNeedle[] = ".";
  EXPECT_FALSE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_CStringNeedle_SingleCharNeedle_SingleCharHaystack_Equal) {
  const std::string kHaystack = "a";
  constexpr char kNeedle[] = "a";
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_CStringNeedle_SingleCharNeedle_LongHaystack_NotFound) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle[] = ".";
  EXPECT_FALSE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_CStringNeedle_SingleCharNeedle_LongHaystack_FrontFound) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle[] = "a";
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_CStringNeedle_SingleCharNeedle_LongHaystack_BackFound) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle[] = "g";
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_CStringNeedle_SingleCharNeedle_LongHaystack_MidFound) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle[] = "d";
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_CStringNeedle_MultiCharNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  constexpr char kNeedle[] = "123";
  EXPECT_FALSE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_CStringNeedle_MultiCharNeedle_SingleCharHaystack_NotFound) {
  const std::string kHaystack = "a";
  constexpr char kNeedle[] = "abc";
  EXPECT_FALSE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_CStringNeedle_MultiCharNeedle_LongHaystack_NotFound) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle[] = "123";
  EXPECT_FALSE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_CStringNeedle_MultiCharNeedle_LongHaystack_Equal) {
  const std::string kHaystack = "abc";
  constexpr char kNeedle[] = "abc";
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_CStringNeedle_MultiCharNeedle_LongHaystack_FrontFound) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle[] = "abc";
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_CStringNeedle_MultiCharNeedle_LongHaystack_BackFound) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle[] = "efg";
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringContains_CStringNeedle_MultiCharNeedle_LongHaystack_MidFound) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle[] = "cde";
  EXPECT_TRUE(StringContains(kHaystack, kNeedle));
}

// bool StringStartsWith(const std::string& haystack, char needle);

TEST(StringUtilsTest, StringStartsWith_CharNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  constexpr char kNeedle = '.';
  EXPECT_FALSE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringStartsWith_CharNeedle_SingleCharHaystack_NotFound) {
  const std::string kHaystack = "a";
  constexpr char kNeedle = '.';
  EXPECT_FALSE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringStartsWith_CharNeedle_SingleCharHaystack_Found) {
  const std::string kHaystack = "a";
  constexpr char kNeedle = 'a';
  EXPECT_TRUE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringStartsWith_CharNeedle_LongHaystack_NotFound) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle = '.';
  EXPECT_FALSE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringStartsWith_CharNeedle_LongHaystack_NotFoundAtStart) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle = 'b';
  EXPECT_FALSE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringStartsWith_CharNeedle_LongHaystack_Found) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle = 'a';
  EXPECT_TRUE(StringStartsWith(kHaystack, kNeedle));
}

// bool StringStartsWith(const std::string& haystack,
//                       const std::string& needle);

TEST(StringUtilsTest, StringStartsWith_StringNeedle_EmptyNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  const std::string kNeedle = "";  // Special case
  EXPECT_TRUE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringStartsWith_StringNeedle_EmptyNeedle_SingleCharHaystack) {
  const std::string kHaystack = "a";
  const std::string kNeedle = "";  // Special case
  EXPECT_TRUE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringStartsWith_StringNeedle_EmptyNeedle_LongHaystack) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "";  // Special case
  EXPECT_TRUE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringStartsWith_StringNeedle_SingleCharNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  const std::string kNeedle = ".";
  EXPECT_FALSE(StringStartsWith(kHaystack, kNeedle));
}

TEST(
    StringUtilsTest,
    StringStartsWith_StringNeedle_SingleCharNeedle_SingleCharHaystack_NotFound) {
  const std::string kHaystack = "a";
  const std::string kNeedle = ".";
  EXPECT_FALSE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringStartsWith_StringNeedle_SingleCharNeedle_SingleCharHaystack_Found) {
  const std::string kHaystack = "a";
  const std::string kNeedle = "a";
  EXPECT_TRUE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringStartsWith_StringNeedle_SingleCharNeedle_LongHaystack_NotFound) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = ".";
  EXPECT_FALSE(StringStartsWith(kHaystack, kNeedle));
}

TEST(
    StringUtilsTest,
    StringStartsWith_StringNeedle_SingleCharNeedle_LongHaystack_NotFoundAtStart) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "b";
  EXPECT_FALSE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringStartsWith_StringNeedle_SingleCharNeedle_LongHaystack_Found) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "a";
  EXPECT_TRUE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringStartsWith_StringNeedle_MultiCharNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  const std::string kNeedle = "123";
  EXPECT_FALSE(StringStartsWith(kHaystack, kNeedle));
}

TEST(
    StringUtilsTest,
    StringStartsWith_StringNeedle_MultiCharNeedle_SingleCharHaystack_NotFound) {
  const std::string kHaystack = "a";
  const std::string kNeedle = "abc";
  EXPECT_FALSE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringStartsWith_StringNeedle_MultiCharNeedle_LongHaystack_NotFound) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "123";
  EXPECT_FALSE(StringStartsWith(kHaystack, kNeedle));
}

TEST(
    StringUtilsTest,
    StringStartsWith_StringNeedle_MultiCharNeedle_LongHaystack_NotFoundAtStart) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "bcd";
  EXPECT_FALSE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringStartsWith_StringNeedle_MultiCharNeedle_LongHaystack_Equal) {
  const std::string kHaystack = "abc";
  const std::string kNeedle = "abc";
  EXPECT_TRUE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringStartsWith_StringNeedle_MultiCharNeedle_LongHaystack_Found) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "abc";
  EXPECT_TRUE(StringStartsWith(kHaystack, kNeedle));
}

// bool StringStartsWith(const std::string& haystack, const char* needle);

TEST(StringUtilsTest, StringStartsWith_CStringNeedle_NullNeedle) {
  const std::string kHaystack = "abcdefg";
  EXPECT_FALSE(StringStartsWith(kHaystack, nullptr));
}

TEST(StringUtilsTest,
     StringStartsWith_CStringNeedle_EmptyNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  const char kNeedle[] = "";  // Special case
  EXPECT_TRUE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringStartsWith_CStringNeedle_EmptyNeedle_SingleCharHaystack) {
  const std::string kHaystack = "a";
  const char kNeedle[] = "";  // Special case
  EXPECT_TRUE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringStartsWith_CStringNeedle_EmptyNeedle_LongHaystack) {
  const std::string kHaystack = "abcdefg";
  const char kNeedle[] = "";  // Special case
  EXPECT_TRUE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringStartsWith_CStringNeedle_SingleCharNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  const char kNeedle[] = ".";
  EXPECT_FALSE(StringStartsWith(kHaystack, kNeedle));
}

TEST(
    StringUtilsTest,
    StringStartsWith_CStringNeedle_SingleCharNeedle_SingleCharHaystack_NotFound) {
  const std::string kHaystack = "a";
  const char kNeedle[] = ".";
  EXPECT_FALSE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringStartsWith_CStringNeedle_SingleCharNeedle_SingleCharHaystack_Found) {
  const std::string kHaystack = "a";
  const char kNeedle[] = "a";
  EXPECT_TRUE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringStartsWith_CStringNeedle_SingleCharNeedle_LongHaystack_NotFound) {
  const std::string kHaystack = "abcdefg";
  const char kNeedle[] = ".";
  EXPECT_FALSE(StringStartsWith(kHaystack, kNeedle));
}

TEST(
    StringUtilsTest,
    StringStartsWith_CStringNeedle_SingleCharNeedle_LongHaystack_NotFoundAtStart) {
  const std::string kHaystack = "abcdefg";
  const char kNeedle[] = "b";
  EXPECT_FALSE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringStartsWith_CStringNeedle_SingleCharNeedle_LongHaystack_Found) {
  const std::string kHaystack = "abcdefg";
  const char kNeedle[] = "a";
  EXPECT_TRUE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringStartsWith_CStringNeedle_MultiCharNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  const char kNeedle[] = "123";
  EXPECT_FALSE(StringStartsWith(kHaystack, kNeedle));
}

TEST(
    StringUtilsTest,
    StringStartsWith_CStringNeedle_MultiCharNeedle_SingleCharHaystack_NotFound) {
  const std::string kHaystack = "a";
  const char kNeedle[] = "abc";
  EXPECT_FALSE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringStartsWith_CStringNeedle_MultiCharNeedle_LongHaystack_NotFound) {
  const std::string kHaystack = "abcdefg";
  const char kNeedle[] = "123";
  EXPECT_FALSE(StringStartsWith(kHaystack, kNeedle));
}

TEST(
    StringUtilsTest,
    StringStartsWith_CStringNeedle_MultiCharNeedle_LongHaystack_NotFoundAtStart) {
  const std::string kHaystack = "abcdefg";
  const char kNeedle[] = "bcd";
  EXPECT_FALSE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringStartsWith_CStringNeedle_MultiCharNeedle_LongHaystack_Equal) {
  const std::string kHaystack = "abc";
  const char kNeedle[] = "abc";
  EXPECT_TRUE(StringStartsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringStartsWith_CStringNeedle_MultiCharNeedle_LongHaystack_Found) {
  const std::string kHaystack = "abcdefg";
  const char kNeedle[] = "abc";
  EXPECT_TRUE(StringStartsWith(kHaystack, kNeedle));
}

// bool StringEndsWith(const std::string& haystack, char needle);

TEST(StringUtilsTest, StringEndsWith_CharNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  constexpr char kNeedle = '.';
  EXPECT_FALSE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringEndsWith_CharNeedle_SingleCharHaystack_NotFound) {
  const std::string kHaystack = "a";
  constexpr char kNeedle = '.';
  EXPECT_FALSE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringEndsWith_CharNeedle_SingleCharHaystack_Found) {
  const std::string kHaystack = "a";
  constexpr char kNeedle = 'a';
  EXPECT_TRUE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringEndsWith_CharNeedle_LongHaystack_NotFound) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle = '.';
  EXPECT_FALSE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringEndsWith_CharNeedle_LongHaystack_NotFoundAtEnd) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle = 'f';
  EXPECT_FALSE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringEndsWith_CharNeedle_LongHaystack_Found) {
  const std::string kHaystack = "abcdefg";
  constexpr char kNeedle = 'g';
  EXPECT_TRUE(StringEndsWith(kHaystack, kNeedle));
}

// bool StringEndsWith(const std::string& haystack,
//                       const std::string& needle);

TEST(StringUtilsTest, StringEndsWith_StringNeedle_EmptyNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  const std::string kNeedle = "";  // Special case
  EXPECT_TRUE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_StringNeedle_EmptyNeedle_SingleCharHaystack) {
  const std::string kHaystack = "a";
  const std::string kNeedle = "";  // Special case
  EXPECT_TRUE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringEndsWith_StringNeedle_EmptyNeedle_LongHaystack) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "";  // Special case
  EXPECT_TRUE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_StringNeedle_SingleCharNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  const std::string kNeedle = ".";
  EXPECT_FALSE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_StringNeedle_SingleCharNeedle_SingleCharHaystack_NotFound) {
  const std::string kHaystack = "a";
  const std::string kNeedle = ".";
  EXPECT_FALSE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_StringNeedle_SingleCharNeedle_SingleCharHaystack_Found) {
  const std::string kHaystack = "a";
  const std::string kNeedle = "a";
  EXPECT_TRUE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_StringNeedle_SingleCharNeedle_LongHaystack_NotFound) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = ".";
  EXPECT_FALSE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_StringNeedle_SingleCharNeedle_LongHaystack_NotFoundAtEnd) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "f";
  EXPECT_FALSE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_StringNeedle_SingleCharNeedle_LongHaystack_Found) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "g";
  EXPECT_TRUE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_StringNeedle_MultiCharNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  const std::string kNeedle = "123";
  EXPECT_FALSE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_StringNeedle_MultiCharNeedle_SingleCharHaystack_NotFound) {
  const std::string kHaystack = "c";
  const std::string kNeedle = "abc";
  EXPECT_FALSE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_StringNeedle_MultiCharNeedle_LongHaystack_NotFound) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "123";
  EXPECT_FALSE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_StringNeedle_MultiCharNeedle_LongHaystack_NotFoundAtEnd) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "def";
  EXPECT_FALSE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_StringNeedle_MultiCharNeedle_LongHaystack_Equal) {
  const std::string kHaystack = "abc";
  const std::string kNeedle = "abc";
  EXPECT_TRUE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_StringNeedle_MultiCharNeedle_LongHaystack_Found) {
  const std::string kHaystack = "abcdefg";
  const std::string kNeedle = "efg";
  EXPECT_TRUE(StringEndsWith(kHaystack, kNeedle));
}

// bool StringEndsWith(const std::string& haystack, const char* needle);

TEST(StringUtilsTest, StringEndsWith_CStringNeedle_NullNeedle) {
  const std::string kHaystack = "abcdefg";
  EXPECT_FALSE(StringEndsWith(kHaystack, nullptr));
}

TEST(StringUtilsTest, StringEndsWith_CStringNeedle_EmptyNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  const char kNeedle[] = "";  // Special case
  EXPECT_TRUE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_CStringNeedle_EmptyNeedle_SingleCharHaystack) {
  const std::string kHaystack = "a";
  const char kNeedle[] = "";  // Special case
  EXPECT_TRUE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringEndsWith_CStringNeedle_EmptyNeedle_LongHaystack) {
  const std::string kHaystack = "abcdefg";
  const char kNeedle[] = "";  // Special case
  EXPECT_TRUE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_CStringNeedle_SingleCharNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  const char kNeedle[] = ".";
  EXPECT_FALSE(StringEndsWith(kHaystack, kNeedle));
}

TEST(
    StringUtilsTest,
    StringEndsWith_CStringNeedle_SingleCharNeedle_SingleCharHaystack_NotFound) {
  const std::string kHaystack = "a";
  const char kNeedle[] = ".";
  EXPECT_FALSE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_CStringNeedle_SingleCharNeedle_SingleCharHaystack_Found) {
  const std::string kHaystack = "a";
  const char kNeedle[] = "a";
  EXPECT_TRUE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_CStringNeedle_SingleCharNeedle_LongHaystack_NotFound) {
  const std::string kHaystack = "abcdefg";
  const char kNeedle[] = ".";
  EXPECT_FALSE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_CStringNeedle_SingleCharNeedle_LongHaystack_NotFoundAtEnd) {
  const std::string kHaystack = "abcdefg";
  const char kNeedle[] = "f";
  EXPECT_FALSE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_CStringNeedle_SingleCharNeedle_LongHaystack_Found) {
  const std::string kHaystack = "abcdefg";
  const char kNeedle[] = "g";
  EXPECT_TRUE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_CStringNeedle_MultiCharNeedle_EmptyHaystack) {
  const std::string kHaystack = "";
  const char kNeedle[] = "123";
  EXPECT_FALSE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_CStringNeedle_MultiCharNeedle_SingleCharHaystack_NotFound) {
  const std::string kHaystack = "a";
  const char kNeedle[] = "abc";
  EXPECT_FALSE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_CStringNeedle_MultiCharNeedle_LongHaystack_NotFound) {
  const std::string kHaystack = "abcdefg";
  const char kNeedle[] = "123";
  EXPECT_FALSE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_CStringNeedle_MultiCharNeedle_LongHaystack_NotFoundAtEnd) {
  const std::string kHaystack = "abcdefg";
  const char kNeedle[] = "def";
  EXPECT_FALSE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_CStringNeedle_MultiCharNeedle_LongHaystack_Equal) {
  const std::string kHaystack = "abc";
  const char kNeedle[] = "abc";
  EXPECT_TRUE(StringEndsWith(kHaystack, kNeedle));
}

TEST(StringUtilsTest,
     StringEndsWith_CStringNeedle_MultiCharNeedle_LongHaystack_Found) {
  const std::string kHaystack = "abcdefg";
  const char kNeedle[] = "efg";
  EXPECT_TRUE(StringEndsWith(kHaystack, kNeedle));
}

// std::string StringTrim(const std::string& s);

TEST(StringUtilsTest, StringTrim_Empty) { EXPECT_EQ(StringTrim(""), ""); }

TEST(StringUtilsTest, StringTrim_NoWhitespace) {
  EXPECT_EQ(StringTrim("abcdefg"), "abcdefg");
}

TEST(StringUtilsTest, StringTrim_LeadingWhitespace) {
  EXPECT_EQ(StringTrim("\t\n \rabcdefg"), "abcdefg");
}

TEST(StringUtilsTest, StringTrim_TrailingWhitespace) {
  EXPECT_EQ(StringTrim("abcdefg\t\n \r"), "abcdefg");
}

TEST(StringUtilsTest, StringTrim_LeadingAndTrailingWhitespace) {
  EXPECT_EQ(StringTrim("\t\n \rabcdefg\t\n \r"), "abcdefg");
}

TEST(StringUtilsTest, StringTrime_AllWhitespace) {
  EXPECT_EQ(StringTrim("\t\n \r"), "");
}

// bool StringVecContains(const std::vector<std::string>& haystack,
//                        const std::string& needle);

TEST(StringUtilsTest, StringVecContains_EmptyHaystack) {
  const std::vector<std::string> kHaystack = {};
  const std::string kNeedle = "123";
  EXPECT_FALSE(StringVecContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringVecContains_NotFound) {
  const std::vector<std::string> kHaystack = {"456", "789"};
  const std::string kNeedle = "123";
  EXPECT_FALSE(StringVecContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringVecContains_FoundAtFront) {
  const std::vector<std::string> kHaystack = {"123", "456", "789"};
  const std::string kNeedle = "123";
  EXPECT_TRUE(StringVecContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringVecContains_FoundAtBack) {
  const std::vector<std::string> kHaystack = {"123", "456", "789"};
  const std::string kNeedle = "789";
  EXPECT_TRUE(StringVecContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringVecContains_FoundAtMid) {
  const std::vector<std::string> kHaystack = {"123", "456", "789"};
  const std::string kNeedle = "456";
  EXPECT_TRUE(StringVecContains(kHaystack, kNeedle));
}

TEST(StringUtilsTest, StringVecContains_FoundEmpty) {
  const std::vector<std::string> kHaystack = {"123", "", "789"};
  const std::string kNeedle = "";
  EXPECT_TRUE(StringVecContains(kHaystack, kNeedle));
}
}  // namespace wvutil