// Copyright 2008, Google Inc.

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//     * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

// Authors: vladl@google.com (Vlad Losev), wan@google.com (Zhanyong Wan)

//

// This file tests the internal cross-platform support utilities.

#include "gtest/internal/gtest-port.h"

#include <stdio.h>

#if GTEST_OS_MAC

# include <time.h>

#endif  // GTEST_OS_MAC

#include <list>

#include <utility>  // For std::pair and std::make_pair.

#include <vector>

#include "gtest/gtest.h"

#include "gtest/gtest-spi.h"

// Indicates that this translation unit is part of Google Test's

// implementation.  It must come before gtest-internal-inl.h is

// included, or there will be a compiler error.  This trick is to

// prevent a user from accidentally including gtest-internal-inl.h in

// his code.

#define GTEST_IMPLEMENTATION_ 1

#include "src/gtest-internal-inl.h"

#undef GTEST_IMPLEMENTATION_

using std::make_pair;

using std::pair;

namespace testing {

namespace internal {

TEST(IsXDigitTest, WorksForNarrowAscii) {

  EXPECT_TRUE(IsXDigit('0'));

  EXPECT_TRUE(IsXDigit('9'));

  EXPECT_TRUE(IsXDigit('A'));

  EXPECT_TRUE(IsXDigit('F'));

  EXPECT_TRUE(IsXDigit('a'));

  EXPECT_TRUE(IsXDigit('f'));

  EXPECT_FALSE(IsXDigit('-'));

  EXPECT_FALSE(IsXDigit('g'));

  EXPECT_FALSE(IsXDigit('G'));

}

TEST(IsXDigitTest, ReturnsFalseForNarrowNonAscii) {

  EXPECT_FALSE(IsXDigit('\x80'));

  EXPECT_FALSE(IsXDigit(static_cast<char>('0' | '\x80')));

}

TEST(IsXDigitTest, WorksForWideAscii) {

  EXPECT_TRUE(IsXDigit(L'0'));

  EXPECT_TRUE(IsXDigit(L'9'));

  EXPECT_TRUE(IsXDigit(L'A'));

  EXPECT_TRUE(IsXDigit(L'F'));

  EXPECT_TRUE(IsXDigit(L'a'));

  EXPECT_TRUE(IsXDigit(L'f'));

  EXPECT_FALSE(IsXDigit(L'-'));

  EXPECT_FALSE(IsXDigit(L'g'));

  EXPECT_FALSE(IsXDigit(L'G'));

}

TEST(IsXDigitTest, ReturnsFalseForWideNonAscii) {

  EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(0x80)));

  EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(L'0' | 0x80)));

  EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(L'0' | 0x100)));

}

class Base {

 public:

  // Copy constructor and assignment operator do exactly what we need, so we

  // use them.

  Base() : member_(0) {}

  explicit Base(int n) : member_(n) {}

  virtual ~Base() {}

  int member() { return member_; }

 private:

  int member_;

};

class Derived : public Base {

 public:

  explicit Derived(int n) : Base(n) {}

};

TEST(ImplicitCastTest, ConvertsPointers) {

  Derived derived(0);

  EXPECT_TRUE(&derived == ::testing::internal::ImplicitCast_<Base*>(&derived));

}

TEST(ImplicitCastTest, CanUseInheritance) {

  Derived derived(1);

  Base base = ::testing::internal::ImplicitCast_<Base>(derived);

  EXPECT_EQ(derived.member(), base.member());

}

class Castable {

 public:

  explicit Castable(bool* converted) : converted_(converted) {}

  operator Base() {

    *converted_ = true;

    return Base();

  }

 private:

  bool* converted_;

};

TEST(ImplicitCastTest, CanUseNonConstCastOperator) {

  bool converted = false;

  Castable castable(&converted);

  Base base = ::testing::internal::ImplicitCast_<Base>(castable);

  EXPECT_TRUE(converted);

}

class ConstCastable {

 public:

  explicit ConstCastable(bool* converted) : converted_(converted) {}

  operator Base() const {

    *converted_ = true;

    return Base();

  }

 private:

  bool* converted_;

};

TEST(ImplicitCastTest, CanUseConstCastOperatorOnConstValues) {

  bool converted = false;

  const ConstCastable const_castable(&converted);

  Base base = ::testing::internal::ImplicitCast_<Base>(const_castable);

  EXPECT_TRUE(converted);

}

class ConstAndNonConstCastable {

 public:

  ConstAndNonConstCastable(bool* converted, bool* const_converted)

      : converted_(converted), const_converted_(const_converted) {}

  operator Base() {

    *converted_ = true;

    return Base();

  }

  operator Base() const {

    *const_converted_ = true;

    return Base();

  }

 private:

  bool* converted_;

  bool* const_converted_;

};

TEST(ImplicitCastTest, CanSelectBetweenConstAndNonConstCasrAppropriately) {

  bool converted = false;

  bool const_converted = false;

  ConstAndNonConstCastable castable(&converted, &const_converted);

  Base base = ::testing::internal::ImplicitCast_<Base>(castable);

  EXPECT_TRUE(converted);

  EXPECT_FALSE(const_converted);

  converted = false;

  const_converted = false;

  const ConstAndNonConstCastable const_castable(&converted, &const_converted);

  base = ::testing::internal::ImplicitCast_<Base>(const_castable);

  EXPECT_FALSE(converted);

  EXPECT_TRUE(const_converted);

}

class To {

 public:

  To(bool* converted) { *converted = true; }  // NOLINT

};

TEST(ImplicitCastTest, CanUseImplicitConstructor) {

  bool converted = false;

  To to = ::testing::internal::ImplicitCast_<To>(&converted);

  (void)to;

  EXPECT_TRUE(converted);

}

TEST(IteratorTraitsTest, WorksForSTLContainerIterators) {

  StaticAssertTypeEq

      IteratorTraits< ::std::vector<int>::const_iterator>::value_type>();

  StaticAssertTypeEq

      IteratorTraits< ::std::list<bool>::iterator>::value_type>();

}

TEST(IteratorTraitsTest, WorksForPointerToNonConst) {

  StaticAssertTypeEq<char, IteratorTraits<char*>::value_type>();

  StaticAssertTypeEq<const void*, IteratorTraits<const void**>::value_type>();

}

TEST(IteratorTraitsTest, WorksForPointerToConst) {

  StaticAssertTypeEq<char, IteratorTraits<const char*>::value_type>();

  StaticAssertTypeEq

      IteratorTraits<const void* const*>::value_type>();

}

// Tests that the element_type typedef is available in scoped_ptr and refers

// to the parameter type.

TEST(ScopedPtrTest, DefinesElementType) {

  StaticAssertTypeEq<int, ::testing::internal::scoped_ptr<int>::element_type>();

}

// TODO(vladl@google.com): Implement THE REST of scoped_ptr tests.

TEST(GtestCheckSyntaxTest, BehavesLikeASingleStatement) {

  if (AlwaysFalse())

    GTEST_CHECK_(false) << "This should never be executed; "

                           "It's a compilation test only.";

  if (AlwaysTrue())

    GTEST_CHECK_(true);

  else

    ;  // NOLINT

  if (AlwaysFalse())

    ;  // NOLINT

  else

    GTEST_CHECK_(true) << "";

}

TEST(GtestCheckSyntaxTest, WorksWithSwitch) {

  switch (0) {

    case 1:

      break;

    default:

      GTEST_CHECK_(true);

  }

  switch (0)

    case 0:

      GTEST_CHECK_(true) << "Check failed in switch case";

}

// Verifies behavior of FormatFileLocation.

TEST(FormatFileLocationTest, FormatsFileLocation) {

  EXPECT_PRED_FORMAT2(IsSubstring, "foo.cc", FormatFileLocation("foo.cc", 42));

  EXPECT_PRED_FORMAT2(IsSubstring, "42", FormatFileLocation("foo.cc", 42));

}

TEST(FormatFileLocationTest, FormatsUnknownFile) {

  EXPECT_PRED_FORMAT2(

      IsSubstring, "unknown file", FormatFileLocation(NULL, 42));

  EXPECT_PRED_FORMAT2(IsSubstring, "42", FormatFileLocation(NULL, 42));

}

TEST(FormatFileLocationTest, FormatsUknownLine) {

  EXPECT_EQ("foo.cc:", FormatFileLocation("foo.cc", -1));

}

TEST(FormatFileLocationTest, FormatsUknownFileAndLine) {

  EXPECT_EQ("unknown file:", FormatFileLocation(NULL, -1));

}

// Verifies behavior of FormatCompilerIndependentFileLocation.

TEST(FormatCompilerIndependentFileLocationTest, FormatsFileLocation) {

  EXPECT_EQ("foo.cc:42", FormatCompilerIndependentFileLocation("foo.cc", 42));

}

TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownFile) {

  EXPECT_EQ("unknown file:42",

            FormatCompilerIndependentFileLocation(NULL, 42));

}

TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownLine) {

  EXPECT_EQ("foo.cc", FormatCompilerIndependentFileLocation("foo.cc", -1));

}

TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownFileAndLine) {

  EXPECT_EQ("unknown file", FormatCompilerIndependentFileLocation(NULL, -1));

}

#if GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_QNX

void* ThreadFunc(void* data) {

  internal::Mutex* mutex = static_cast<internal::Mutex*>(data);

  mutex->Lock();

  mutex->Unlock();

  return NULL;

}

TEST(GetThreadCountTest, ReturnsCorrectValue) {

  const size_t starting_count = GetThreadCount();

  pthread_t       thread_id;

  internal::Mutex mutex;

  {

    internal::MutexLock lock(&mutex);

    pthread_attr_t  attr;

    ASSERT_EQ(0, pthread_attr_init(&attr));

    ASSERT_EQ(0, pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE));

    const int status = pthread_create(&thread_id, &attr, &ThreadFunc, &mutex);

    ASSERT_EQ(0, pthread_attr_destroy(&attr));

    ASSERT_EQ(0, status);

    EXPECT_EQ(starting_count + 1, GetThreadCount());

  }

  void* dummy;

  ASSERT_EQ(0, pthread_join(thread_id, &dummy));

  // The OS may not immediately report the updated thread count after

  // joining a thread, causing flakiness in this test. To counter that, we

  // wait for up to .5 seconds for the OS to report the correct value.

  for (int i = 0; i < 5; ++i) {

    if (GetThreadCount() == starting_count)

      break;

    SleepMilliseconds(100);

  }

  EXPECT_EQ(starting_count, GetThreadCount());

}

#else

TEST(GetThreadCountTest, ReturnsZeroWhenUnableToCountThreads) {

  EXPECT_EQ(0U, GetThreadCount());

}

#endif  // GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_QNX

TEST(GtestCheckDeathTest, DiesWithCorrectOutputOnFailure) {

  const bool a_false_condition = false;

  const char regex[] =

#ifdef _MSC_VER

     "gtest-port_test\\.cc\\(\\d+\\):"

#elif GTEST_USES_POSIX_RE

     "gtest-port_test\\.cc:[0-9]+"

#else

     "gtest-port_test\\.cc:\\d+"

#endif  // _MSC_VER

     ".*a_false_condition.*Extra info.*";

  EXPECT_DEATH_IF_SUPPORTED(GTEST_CHECK_(a_false_condition) << "Extra info",

                            regex);

}

#if GTEST_HAS_DEATH_TEST

TEST(GtestCheckDeathTest, LivesSilentlyOnSuccess) {

  EXPECT_EXIT({

      GTEST_CHECK_(true) << "Extra info";

      ::std::cerr << "Success\n";

      exit(0); },

      ::testing::ExitedWithCode(0), "Success");

}

#endif  // GTEST_HAS_DEATH_TEST

// Verifies that Google Test choose regular expression engine appropriate to

// the platform. The test will produce compiler errors in case of failure.

// For simplicity, we only cover the most important platforms here.

TEST(RegexEngineSelectionTest, SelectsCorrectRegexEngine) {

#if !GTEST_USES_PCRE

# if GTEST_HAS_POSIX_RE

  EXPECT_TRUE(GTEST_USES_POSIX_RE);

# else

  EXPECT_TRUE(GTEST_USES_SIMPLE_RE);

# endif

#endif  // !GTEST_USES_PCRE

}

#if GTEST_USES_POSIX_RE

# if GTEST_HAS_TYPED_TEST

template <typename Str>

class RETest : public ::testing::Test {};

// Defines StringTypes as the list of all string types that class RE

// supports.

typedef testing::Types<

    ::std::string,

#  if GTEST_HAS_GLOBAL_STRING

    ::string,

#  endif  // GTEST_HAS_GLOBAL_STRING

    const char*> StringTypes;

TYPED_TEST_CASE(RETest, StringTypes);

// Tests RE's implicit constructors.

TYPED_TEST(RETest, ImplicitConstructorWorks) {

  const RE empty(TypeParam(""));

  EXPECT_STREQ("", empty.pattern());

  const RE simple(TypeParam("hello"));

  EXPECT_STREQ("hello", simple.pattern());

  const RE normal(TypeParam(".*(\\w+)"));

  EXPECT_STREQ(".*(\\w+)", normal.pattern());

}

// Tests that RE's constructors reject invalid regular expressions.

TYPED_TEST(RETest, RejectsInvalidRegex) {

  EXPECT_NONFATAL_FAILURE({

    const RE invalid(TypeParam("?"));

  }, "\"?\" is not a valid POSIX Extended regular expression.");

}

// Tests RE::FullMatch().

TYPED_TEST(RETest, FullMatchWorks) {

  const RE empty(TypeParam(""));

  EXPECT_TRUE(RE::FullMatch(TypeParam(""), empty));

  EXPECT_FALSE(RE::FullMatch(TypeParam("a"), empty));

  const RE re(TypeParam("a.*z"));

  EXPECT_TRUE(RE::FullMatch(TypeParam("az"), re));

  EXPECT_TRUE(RE::FullMatch(TypeParam("axyz"), re));

  EXPECT_FALSE(RE::FullMatch(TypeParam("baz"), re));

  EXPECT_FALSE(RE::FullMatch(TypeParam("azy"), re));

}

// Tests RE::PartialMatch().

TYPED_TEST(RETest, PartialMatchWorks) {

  const RE empty(TypeParam(""));

  EXPECT_TRUE(RE::PartialMatch(TypeParam(""), empty));

  EXPECT_TRUE(RE::PartialMatch(TypeParam("a"), empty));

  const RE re(TypeParam("a.*z"));

  EXPECT_TRUE(RE::PartialMatch(TypeParam("az"), re));

  EXPECT_TRUE(RE::PartialMatch(TypeParam("axyz"), re));

  EXPECT_TRUE(RE::PartialMatch(TypeParam("baz"), re));

  EXPECT_TRUE(RE::PartialMatch(TypeParam("azy"), re));

  EXPECT_FALSE(RE::PartialMatch(TypeParam("zza"), re));

}

# endif  // GTEST_HAS_TYPED_TEST

#elif GTEST_USES_SIMPLE_RE

TEST(IsInSetTest, NulCharIsNotInAnySet) {

  EXPECT_FALSE(IsInSet('\0', ""));

  EXPECT_FALSE(IsInSet('\0', "\0"));

  EXPECT_FALSE(IsInSet('\0', "a"));

}

TEST(IsInSetTest, WorksForNonNulChars) {

  EXPECT_FALSE(IsInSet('a', "Ab"));

  EXPECT_FALSE(IsInSet('c', ""));

  EXPECT_TRUE(IsInSet('b', "bcd"));

  EXPECT_TRUE(IsInSet('b', "ab"));

}

TEST(IsAsciiDigitTest, IsFalseForNonDigit) {

  EXPECT_FALSE(IsAsciiDigit('\0'));

  EXPECT_FALSE(IsAsciiDigit(' '));

  EXPECT_FALSE(IsAsciiDigit('+'));

  EXPECT_FALSE(IsAsciiDigit('-'));

  EXPECT_FALSE(IsAsciiDigit('.'));

  EXPECT_FALSE(IsAsciiDigit('a'));

}

TEST(IsAsciiDigitTest, IsTrueForDigit) {

  EXPECT_TRUE(IsAsciiDigit('0'));

  EXPECT_TRUE(IsAsciiDigit('1'));

  EXPECT_TRUE(IsAsciiDigit('5'));

  EXPECT_TRUE(IsAsciiDigit('9'));

}

TEST(IsAsciiPunctTest, IsFalseForNonPunct) {

  EXPECT_FALSE(IsAsciiPunct('\0'));

  EXPECT_FALSE(IsAsciiPunct(' '));

  EXPECT_FALSE(IsAsciiPunct('\n'));

  EXPECT_FALSE(IsAsciiPunct('a'));

  EXPECT_FALSE(IsAsciiPunct('0'));

}

TEST(IsAsciiPunctTest, IsTrueForPunct) {

  for (const char* p = "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~"; *p; p++) {

    EXPECT_PRED1(IsAsciiPunct, *p);

  }

}

TEST(IsRepeatTest, IsFalseForNonRepeatChar) {

  EXPECT_FALSE(IsRepeat('\0'));

  EXPECT_FALSE(IsRepeat(' '));

  EXPECT_FALSE(IsRepeat('a'));

  EXPECT_FALSE(IsRepeat('1'));

  EXPECT_FALSE(IsRepeat('-'));

}

TEST(IsRepeatTest, IsTrueForRepeatChar) {

  EXPECT_TRUE(IsRepeat('?'));

  EXPECT_TRUE(IsRepeat('*'));

  EXPECT_TRUE(IsRepeat('+'));

}

TEST(IsAsciiWhiteSpaceTest, IsFalseForNonWhiteSpace) {

  EXPECT_FALSE(IsAsciiWhiteSpace('\0'));

  EXPECT_FALSE(IsAsciiWhiteSpace('a'));

  EXPECT_FALSE(IsAsciiWhiteSpace('1'));

  EXPECT_FALSE(IsAsciiWhiteSpace('+'));

  EXPECT_FALSE(IsAsciiWhiteSpace('_'));

}

TEST(IsAsciiWhiteSpaceTest, IsTrueForWhiteSpace) {

  EXPECT_TRUE(IsAsciiWhiteSpace(' '));

  EXPECT_TRUE(IsAsciiWhiteSpace('\n'));

  EXPECT_TRUE(IsAsciiWhiteSpace('\r'));

  EXPECT_TRUE(IsAsciiWhiteSpace('\t'));

  EXPECT_TRUE(IsAsciiWhiteSpace('\v'));

  EXPECT_TRUE(IsAsciiWhiteSpace('\f'));

}

TEST(IsAsciiWordCharTest, IsFalseForNonWordChar) {

  EXPECT_FALSE(IsAsciiWordChar('\0'));

  EXPECT_FALSE(IsAsciiWordChar('+'));

  EXPECT_FALSE(IsAsciiWordChar('.'));

  EXPECT_FALSE(IsAsciiWordChar(' '));

  EXPECT_FALSE(IsAsciiWordChar('\n'));

}

TEST(IsAsciiWordCharTest, IsTrueForLetter) {

  EXPECT_TRUE(IsAsciiWordChar('a'));

  EXPECT_TRUE(IsAsciiWordChar('b'));

  EXPECT_TRUE(IsAsciiWordChar('A'));

  EXPECT_TRUE(IsAsciiWordChar('Z'));

}

TEST(IsAsciiWordCharTest, IsTrueForDigit) {

  EXPECT_TRUE(IsAsciiWordChar('0'));

  EXPECT_TRUE(IsAsciiWordChar('1'));

  EXPECT_TRUE(IsAsciiWordChar('7'));

  EXPECT_TRUE(IsAsciiWordChar('9'));

}

TEST(IsAsciiWordCharTest, IsTrueForUnderscore) {

  EXPECT_TRUE(IsAsciiWordChar('_'));

}

TEST(IsValidEscapeTest, IsFalseForNonPrintable) {

  EXPECT_FALSE(IsValidEscape('\0'));

  EXPECT_FALSE(IsValidEscape('\007'));

}

TEST(IsValidEscapeTest, IsFalseForDigit) {

  EXPECT_FALSE(IsValidEscape('0'));

  EXPECT_FALSE(IsValidEscape('9'));

}

TEST(IsValidEscapeTest, IsFalseForWhiteSpace) {

  EXPECT_FALSE(IsValidEscape(' '));

  EXPECT_FALSE(IsValidEscape('\n'));

}

TEST(IsValidEscapeTest, IsFalseForSomeLetter) {

  EXPECT_FALSE(IsValidEscape('a'));

  EXPECT_FALSE(IsValidEscape('Z'));

}

TEST(IsValidEscapeTest, IsTrueForPunct) {

  EXPECT_TRUE(IsValidEscape('.'));

  EXPECT_TRUE(IsValidEscape('-'));

  EXPECT_TRUE(IsValidEscape('^'));

  EXPECT_TRUE(IsValidEscape('$'));

  EXPECT_TRUE(IsValidEscape('('));

  EXPECT_TRUE(IsValidEscape(']'));

  EXPECT_TRUE(IsValidEscape('{'));

  EXPECT_TRUE(IsValidEscape('|'));

}

TEST(IsValidEscapeTest, IsTrueForSomeLetter) {

  EXPECT_TRUE(IsValidEscape('d'));

  EXPECT_TRUE(IsValidEscape('D'));

  EXPECT_TRUE(IsValidEscape('s'));

  EXPECT_TRUE(IsValidEscape('S'));

  EXPECT_TRUE(IsValidEscape('w'));

  EXPECT_TRUE(IsValidEscape('W'));

}

TEST(AtomMatchesCharTest, EscapedPunct) {

  EXPECT_FALSE(AtomMatchesChar(true, '\\', '\0'));

  EXPECT_FALSE(AtomMatchesChar(true, '\\', ' '));

  EXPECT_FALSE(AtomMatchesChar(true, '_', '.'));

  EXPECT_FALSE(AtomMatchesChar(true, '.', 'a'));

  EXPECT_TRUE(AtomMatchesChar(true, '\\', '\\'));

  EXPECT_TRUE(AtomMatchesChar(true, '_', '_'));

  EXPECT_TRUE(AtomMatchesChar(true, '+', '+'));

  EXPECT_TRUE(AtomMatchesChar(true, '.', '.'));

}

TEST(AtomMatchesCharTest, Escaped_d) {

  EXPECT_FALSE(AtomMatchesChar(true, 'd', '\0'));

  EXPECT_FALSE(AtomMatchesChar(true, 'd', 'a'));

  EXPECT_FALSE(AtomMatchesChar(true, 'd', '.'));

  EXPECT_TRUE(AtomMatchesChar(true, 'd', '0'));

  EXPECT_TRUE(AtomMatchesChar(true, 'd', '9'));

}

TEST(AtomMatchesCharTest, Escaped_D) {

  EXPECT_FALSE(AtomMatchesChar(true, 'D', '0'));

  EXPECT_FALSE(AtomMatchesChar(true, 'D', '9'));

  EXPECT_TRUE(AtomMatchesChar(true, 'D', '\0'));

  EXPECT_TRUE(AtomMatchesChar(true, 'D', 'a'));

  EXPECT_TRUE(AtomMatchesChar(true, 'D', '-'));

}

TEST(AtomMatchesCharTest, Escaped_s) {

  EXPECT_FALSE(AtomMatchesChar(true, 's', '\0'));

  EXPECT_FALSE(AtomMatchesChar(true, 's', 'a'));

  EXPECT_FALSE(AtomMatchesChar(true, 's', '.'));

  EXPECT_FALSE(AtomMatchesChar(true, 's', '9'));

  EXPECT_TRUE(AtomMatchesChar(true, 's', ' '));

  EXPECT_TRUE(AtomMatchesChar(true, 's', '\n'));

  EXPECT_TRUE(AtomMatchesChar(true, 's', '\t'));

}

TEST(AtomMatchesCharTest, Escaped_S) {

  EXPECT_FALSE(AtomMatchesChar(true, 'S', ' '));

  EXPECT_FALSE(AtomMatchesChar(true, 'S', '\r'));

  EXPECT_TRUE(AtomMatchesChar(true, 'S', '\0'));

  EXPECT_TRUE(AtomMatchesChar(true, 'S', 'a'));

  EXPECT_TRUE(AtomMatchesChar(true, 'S', '9'));

}

TEST(AtomMatchesCharTest, Escaped_w) {

  EXPECT_FALSE(AtomMatchesChar(true, 'w', '\0'));

  EXPECT_FALSE(AtomMatchesChar(true, 'w', '+'));

  EXPECT_FALSE(AtomMatchesChar(true, 'w', ' '));

  EXPECT_FALSE(AtomMatchesChar(true, 'w', '\n'));

  EXPECT_TRUE(AtomMatchesChar(true, 'w', '0'));

  EXPECT_TRUE(AtomMatchesChar(true, 'w', 'b'));

  EXPECT_TRUE(AtomMatchesChar(true, 'w', 'C'));

  EXPECT_TRUE(AtomMatchesChar(true, 'w', '_'));

}

TEST(AtomMatchesCharTest, Escaped_W) {

  EXPECT_FALSE(AtomMatchesChar(true, 'W', 'A'));

  EXPECT_FALSE(AtomMatchesChar(true, 'W', 'b'));

  EXPECT_FALSE(AtomMatchesChar(true, 'W', '9'));

  EXPECT_FALSE(AtomMatchesChar(true, 'W', '_'));

  EXPECT_TRUE(AtomMatchesChar(true, 'W', '\0'));

  EXPECT_TRUE(AtomMatchesChar(true, 'W', '*'));

  EXPECT_TRUE(AtomMatchesChar(true, 'W', '\n'));

}

TEST(AtomMatchesCharTest, EscapedWhiteSpace) {

  EXPECT_FALSE(AtomMatchesChar(true, 'f', '\0'));

  EXPECT_FALSE(AtomMatchesChar(true, 'f', '\n'));

  EXPECT_FALSE(AtomMatchesChar(true, 'n', '\0'));

  EXPECT_FALSE(AtomMatchesChar(true, 'n', '\r'));

  EXPECT_FALSE(AtomMatchesChar(true, 'r', '\0'));

  EXPECT_FALSE(AtomMatchesChar(true, 'r', 'a'));

  EXPECT_FALSE(AtomMatchesChar(true, 't', '\0'));

  EXPECT_FALSE(AtomMatchesChar(true, 't', 't'));

  EXPECT_FALSE(AtomMatchesChar(true, 'v', '\0'));

  EXPECT_FALSE(AtomMatchesChar(true, 'v', '\f'));

  EXPECT_TRUE(AtomMatchesChar(true, 'f', '\f'));

  EXPECT_TRUE(AtomMatchesChar(true, 'n', '\n'));

  EXPECT_TRUE(AtomMatchesChar(true, 'r', '\r'));

  EXPECT_TRUE(AtomMatchesChar(true, 't', '\t'));

  EXPECT_TRUE(AtomMatchesChar(true, 'v', '\v'));

}

TEST(AtomMatchesCharTest, UnescapedDot) {

  EXPECT_FALSE(AtomMatchesChar(false, '.', '\n'));

  EXPECT_TRUE(AtomMatchesChar(false, '.', '\0'));

  EXPECT_TRUE(AtomMatchesChar(false, '.', '.'));

  EXPECT_TRUE(AtomMatchesChar(false, '.', 'a'));

  EXPECT_TRUE(AtomMatchesChar(false, '.', ' '));

}

TEST(AtomMatchesCharTest, UnescapedChar) {

  EXPECT_FALSE(AtomMatchesChar(false, 'a', '\0'));

  EXPECT_FALSE(AtomMatchesChar(false, 'a', 'b'));

  EXPECT_FALSE(AtomMatchesChar(false, '$', 'a'));

  EXPECT_TRUE(AtomMatchesChar(false, '$', '$'));

  EXPECT_TRUE(AtomMatchesChar(false, '5', '5'));

  EXPECT_TRUE(AtomMatchesChar(false, 'Z', 'Z'));

}

TEST(ValidateRegexTest, GeneratesFailureAndReturnsFalseForInvalid) {

  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex(NULL)),

                          "NULL is not a valid simple regular expression");

  EXPECT_NONFATAL_FAILURE(

      ASSERT_FALSE(ValidateRegex("a\\")),

      "Syntax error at index 1 in simple regular expression \"a\\\": ");

  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a\\")),

                          "'\\' cannot appear at the end");

  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("\\n\\")),

                          "'\\' cannot appear at the end");

  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("\\s\\hb")),

                          "invalid escape sequence \"\\h\"");

  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^^")),

                          "'^' can only appear at the beginning");

  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex(".*^b")),

                          "'^' can only appear at the beginning");

  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("$$")),

                          "'$' can only appear at the end");

  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^$a")),

                          "'$' can only appear at the end");

  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a(b")),

                          "'(' is unsupported");

  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("ab)")),

                          "')' is unsupported");

  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("[ab")),

                          "'[' is unsupported");

  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a{2")),

                          "'{' is unsupported");

  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("?")),

                          "'?' can only follow a repeatable token");

  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^*")),

                          "'*' can only follow a repeatable token");

  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("5*+")),

                          "'+' can only follow a repeatable token");

}

TEST(ValidateRegexTest, ReturnsTrueForValid) {

  EXPECT_TRUE(ValidateRegex(""));

  EXPECT_TRUE(ValidateRegex("a"));

  EXPECT_TRUE(ValidateRegex(".*"));

  EXPECT_TRUE(ValidateRegex("^a_+"));

  EXPECT_TRUE(ValidateRegex("^a\\t\\&?"));

  EXPECT_TRUE(ValidateRegex("09*$"));

  EXPECT_TRUE(ValidateRegex("^Z$"));

  EXPECT_TRUE(ValidateRegex("a\\^Z\\$\\(\\)\\|\\[\\]\\{\\}"));

}

TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrOne) {

  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "a", "ba"));

  // Repeating more than once.

  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "aab"));

  // Repeating zero times.

  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "ba"));

  // Repeating once.

  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "ab"));

  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '#', '?', ".", "##"));

}

TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrMany) {

  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '*', "a$", "baab"));

  // Repeating zero times.

  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '*', "b", "bc"));

  // Repeating once.

  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '*', "b", "abc"));

  // Repeating more than once.

  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(true, 'w', '*', "-", "ab_1-g"));

}

TEST(MatchRepetitionAndRegexAtHeadTest, WorksForOneOrMany) {

  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '+', "a$", "baab"));

  // Repeating zero times.

  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '+', "b", "bc"));

  // Repeating once.

  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '+', "b", "abc"));

  // Repeating more than once.

  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(true, 'w', '+', "-", "ab_1-g"));

}

TEST(MatchRegexAtHeadTest, ReturnsTrueForEmptyRegex) {

  EXPECT_TRUE(MatchRegexAtHead("", ""));

  EXPECT_TRUE(MatchRegexAtHead("", "ab"));

}

TEST(MatchRegexAtHeadTest, WorksWhenDollarIsInRegex) {

  EXPECT_FALSE(MatchRegexAtHead("$", "a"));

  EXPECT_TRUE(MatchRegexAtHead("$", ""));

  EXPECT_TRUE(MatchRegexAtHead("a$", "a"));

}

TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithEscapeSequence) {

  EXPECT_FALSE(MatchRegexAtHead("\\w", "+"));

  EXPECT_FALSE(MatchRegexAtHead("\\W", "ab"));

  EXPECT_TRUE(MatchRegexAtHead("\\sa", "\nab"));

  EXPECT_TRUE(MatchRegexAtHead("\\d", "1a"));

}

TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithRepetition) {

  EXPECT_FALSE(MatchRegexAtHead(".+a", "abc"));

  EXPECT_FALSE(MatchRegexAtHead("a?b", "aab"));

  EXPECT_TRUE(MatchRegexAtHead(".*a", "bc12-ab"));

  EXPECT_TRUE(MatchRegexAtHead("a?b", "b"));

  EXPECT_TRUE(MatchRegexAtHead("a?b", "ab"));

}

TEST(MatchRegexAtHeadTest,

     WorksWhenRegexStartsWithRepetionOfEscapeSequence) {

  EXPECT_FALSE(MatchRegexAtHead("\\.+a", "abc"));

  EXPECT_FALSE(MatchRegexAtHead("\\s?b", "  b"));

  EXPECT_TRUE(MatchRegexAtHead("\\(*a", "((((ab"));

  EXPECT_TRUE(MatchRegexAtHead("\\^?b", "^b"));

  EXPECT_TRUE(MatchRegexAtHead("\\\\?b", "b"));

  EXPECT_TRUE(MatchRegexAtHead("\\\\?b", "\\b"));

}

TEST(MatchRegexAtHeadTest, MatchesSequentially) {

  EXPECT_FALSE(MatchRegexAtHead("ab.*c", "acabc"));

  EXPECT_TRUE(MatchRegexAtHead("ab.*c", "ab-fsc"));

}

TEST(MatchRegexAnywhereTest, ReturnsFalseWhenStringIsNull) {

  EXPECT_FALSE(MatchRegexAnywhere("", NULL));

}

TEST(MatchRegexAnywhereTest, WorksWhenRegexStartsWithCaret) {

  EXPECT_FALSE(MatchRegexAnywhere("^a", "ba"));

  EXPECT_FALSE(MatchRegexAnywhere("^$", "a"));

  EXPECT_TRUE(MatchRegexAnywhere("^a", "ab"));

  EXPECT_TRUE(MatchRegexAnywhere("^", "ab"));

  EXPECT_TRUE(MatchRegexAnywhere("^$", ""));

}

TEST(MatchRegexAnywhereTest, ReturnsFalseWhenNoMatch) {

  EXPECT_FALSE(MatchRegexAnywhere("a", "bcde123"));

  EXPECT_FALSE(MatchRegexAnywhere("a.+a", "--aa88888888"));

}

TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingPrefix) {

  EXPECT_TRUE(MatchRegexAnywhere("\\w+", "ab1_ - 5"));

  EXPECT_TRUE(MatchRegexAnywhere(".*=", "="));

  EXPECT_TRUE(MatchRegexAnywhere("x.*ab?.*bc", "xaaabc"));

}

TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingNonPrefix) {

  EXPECT_TRUE(MatchRegexAnywhere("\\w+", "$$$ ab1_ - 5"));

  EXPECT_TRUE(MatchRegexAnywhere("\\.+=", "=  ...="));

}

// Tests RE's implicit constructors.

TEST(RETest, ImplicitConstructorWorks) {

  const RE empty("");

  EXPECT_STREQ("", empty.pattern());

  const RE simple("hello");

  EXPECT_STREQ("hello", simple.pattern());