// Copyright 2005, 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.

//

// Author: wan@google.com (Zhanyong Wan)

//

// The Google C++ Testing Framework (Google Test)

#include "gtest/gtest.h"

#include "gtest/gtest-spi.h"

#include <ctype.h>

#include <math.h>

#include <stdarg.h>

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#include <wchar.h>

#include <wctype.h>

#include <algorithm>

#include <iomanip>

#include <limits>

#include <ostream>  // NOLINT

#include <sstream>

#include <vector>

#if defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140

#pragma error_messages(off, SEC_NULL_PTR_DEREF)

#endif

#if GTEST_OS_LINUX

// TODO(kenton@google.com): Use autoconf to detect availability of

// gettimeofday().

# define GTEST_HAS_GETTIMEOFDAY_ 1

# include <fcntl.h>  // NOLINT

# include <limits.h>  // NOLINT

# include <sched.h>  // NOLINT

// Declares vsnprintf().  This header is not available on Windows.

# include <strings.h>  // NOLINT

# include <sys/mman.h>  // NOLINT

# include <sys/time.h>  // NOLINT

# include <unistd.h>  // NOLINT

# include <string>

#elif GTEST_OS_SYMBIAN

# define GTEST_HAS_GETTIMEOFDAY_ 1

# include <sys/time.h>  // NOLINT

#elif GTEST_OS_ZOS

# define GTEST_HAS_GETTIMEOFDAY_ 1

# include <sys/time.h>  // NOLINT

// On z/OS we additionally need strings.h for strcasecmp.

# include <strings.h>  // NOLINT

#elif GTEST_OS_WINDOWS_MOBILE  // We are on Windows CE.

# include <windows.h>  // NOLINT

#elif GTEST_OS_WINDOWS  // We are on Windows proper.

# include <io.h>  // NOLINT

# include <sys/timeb.h>  // NOLINT

# include <sys/types.h>  // NOLINT

# include <sys/stat.h>  // NOLINT

# if GTEST_OS_WINDOWS_MINGW

// MinGW has gettimeofday() but not _ftime64().

// TODO(kenton@google.com): Use autoconf to detect availability of

//   gettimeofday().

// TODO(kenton@google.com): There are other ways to get the time on

//   Windows, like GetTickCount() or GetSystemTimeAsFileTime().  MinGW

//   supports these.  consider using them instead.

#  define GTEST_HAS_GETTIMEOFDAY_ 1

#  include <sys/time.h>  // NOLINT

# endif  // GTEST_OS_WINDOWS_MINGW

// cpplint thinks that the header is already included, so we want to

// silence it.

# include <windows.h>  // NOLINT

#else

// Assume other platforms have gettimeofday().

// TODO(kenton@google.com): Use autoconf to detect availability of

//   gettimeofday().

# define GTEST_HAS_GETTIMEOFDAY_ 1

// cpplint thinks that the header is already included, so we want to

// silence it.

# include <sys/time.h>  // NOLINT

# include <unistd.h>  // NOLINT

#endif  // GTEST_OS_LINUX

#if GTEST_HAS_EXCEPTIONS

# include <stdexcept>

#endif

#if GTEST_CAN_STREAM_RESULTS_

# include <arpa/inet.h>  // NOLINT

# include <netdb.h>  // NOLINT

#endif

// 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_

#if GTEST_OS_WINDOWS

# define vsnprintf _vsnprintf

#endif  // GTEST_OS_WINDOWS

namespace testing {

using internal::CountIf;

using internal::ForEach;

using internal::GetElementOr;

using internal::Shuffle;

// Constants.

// A test whose test case name or test name matches this filter is

// disabled and not run.

static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*";

// A test case whose name matches this filter is considered a death

// test case and will be run before test cases whose name doesn't

// match this filter.

static const char kDeathTestCaseFilter[] = "*DeathTest:*DeathTest/*";

// A test filter that matches everything.

static const char kUniversalFilter[] = "*";

// The default output file for XML output.

static const char kDefaultOutputFile[] = "test_detail.xml";

// The environment variable name for the test shard index.

static const char kTestShardIndex[] = "GTEST_SHARD_INDEX";

// The environment variable name for the total number of test shards.

static const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS";

// The environment variable name for the test shard status file.

static const char kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE";

namespace internal {

// The text used in failure messages to indicate the start of the

// stack trace.

const char kStackTraceMarker[] = "\nStack trace:\n";

// g_help_flag is true iff the --help flag or an equivalent form is

// specified on the command line.

bool g_help_flag = false;

}  // namespace internal

static const char* GetDefaultFilter() {

  return kUniversalFilter;

}

GTEST_DEFINE_bool_(

    also_run_disabled_tests,

    internal::BoolFromGTestEnv("also_run_disabled_tests", false),

    "Run disabled tests too, in addition to the tests normally being run.");

GTEST_DEFINE_bool_(

    break_on_failure,

    internal::BoolFromGTestEnv("break_on_failure", false),

    "True iff a failed assertion should be a debugger break-point.");

GTEST_DEFINE_bool_(

    catch_exceptions,

    internal::BoolFromGTestEnv("catch_exceptions", true),

    "True iff " GTEST_NAME_

    " should catch exceptions and treat them as test failures.");

GTEST_DEFINE_string_(

    color,

    internal::StringFromGTestEnv("color", "auto"),

    "Whether to use colors in the output.  Valid values: yes, no, "

    "and auto.  'auto' means to use colors if the output is "

    "being sent to a terminal and the TERM environment variable "

    "is set to a terminal type that supports colors.");

GTEST_DEFINE_string_(

    filter,

    internal::StringFromGTestEnv("filter", GetDefaultFilter()),

    "A colon-separated list of glob (not regex) patterns "

    "for filtering the tests to run, optionally followed by a "

    "'-' and a : separated list of negative patterns (tests to "

    "exclude).  A test is run if it matches one of the positive "

    "patterns and does not match any of the negative patterns.");

GTEST_DEFINE_bool_(list_tests, false,

                   "List all tests without running them.");

GTEST_DEFINE_string_(

    output,

    internal::StringFromGTestEnv("output", ""),

    "A format (currently must be \"xml\"), optionally followed "

    "by a colon and an output file name or directory. A directory "

    "is indicated by a trailing pathname separator. "

    "Examples: \"xml:filename.xml\", \"xml::directoryname/\". "

    "If a directory is specified, output files will be created "

    "within that directory, with file-names based on the test "

    "executable's name and, if necessary, made unique by adding "

    "digits.");

GTEST_DEFINE_bool_(

    print_time,

    internal::BoolFromGTestEnv("print_time", true),

    "True iff " GTEST_NAME_

    " should display elapsed time in text output.");

GTEST_DEFINE_int32_(

    random_seed,

    internal::Int32FromGTestEnv("random_seed", 0),

    "Random number seed to use when shuffling test orders.  Must be in range "

    "[1, 99999], or 0 to use a seed based on the current time.");

GTEST_DEFINE_int32_(

    repeat,

    internal::Int32FromGTestEnv("repeat", 1),

    "How many times to repeat each test.  Specify a negative number "

    "for repeating forever.  Useful for shaking out flaky tests.");

GTEST_DEFINE_bool_(

    show_internal_stack_frames, false,

    "True iff " GTEST_NAME_ " should include internal stack frames when "

    "printing test failure stack traces.");

GTEST_DEFINE_bool_(

    shuffle,

    internal::BoolFromGTestEnv("shuffle", false),

    "True iff " GTEST_NAME_

    " should randomize tests' order on every run.");

GTEST_DEFINE_int32_(

    stack_trace_depth,

    internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth),

    "The maximum number of stack frames to print when an "

    "assertion fails.  The valid range is 0 through 100, inclusive.");

GTEST_DEFINE_string_(

    stream_result_to,

    internal::StringFromGTestEnv("stream_result_to", ""),

    "This flag specifies the host name and the port number on which to stream "

    "test results. Example: \"localhost:555\". The flag is effective only on "

    "Linux.");

GTEST_DEFINE_bool_(

    throw_on_failure,

    internal::BoolFromGTestEnv("throw_on_failure", false),

    "When this flag is specified, a failed assertion will throw an exception "

    "if exceptions are enabled or exit the program with a non-zero code "

    "otherwise.");

namespace internal {

// Generates a random number from [0, range), using a Linear

// Congruential Generator (LCG).  Crashes if 'range' is 0 or greater

// than kMaxRange.

UInt32 Random::Generate(UInt32 range) {

  // These constants are the same as are used in glibc's rand(3).

  state_ = (1103515245U*state_ + 12345U) % kMaxRange;

  GTEST_CHECK_(range > 0)

      << "Cannot generate a number in the range [0, 0).";

  GTEST_CHECK_(range <= kMaxRange)

      << "Generation of a number in [0, " << range << ") was requested, "

      << "but this can only generate numbers in [0, " << kMaxRange << ").";

  // Converting via modulus introduces a bit of downward bias, but

  // it's simple, and a linear congruential generator isn't too good

  // to begin with.

  return state_ % range;

}

// GTestIsInitialized() returns true iff the user has initialized

// Google Test.  Useful for catching the user mistake of not initializing

// Google Test before calling RUN_ALL_TESTS().

//

// A user must call testing::InitGoogleTest() to initialize Google

// Test.  g_init_gtest_count is set to the number of times

// InitGoogleTest() has been called.  We don't protect this variable

// under a mutex as it is only accessed in the main thread.

GTEST_API_ int g_init_gtest_count = 0;

static bool GTestIsInitialized() { return g_init_gtest_count != 0; }

// Iterates over a vector of TestCases, keeping a running sum of the

// results of calling a given int-returning method on each.

// Returns the sum.

static int SumOverTestCaseList(const std::vector<TestCase*>& case_list,

                               int (TestCase::*method)() const) {

  int sum = 0;

  for (size_t i = 0; i < case_list.size(); i++) {

    sum += (case_list[i]->*method)();

  }

  return sum;

}

// Returns true iff the test case passed.

static bool TestCasePassed(const TestCase* test_case) {

  return test_case->should_run() && test_case->Passed();

}

// Returns true iff the test case failed.

static bool TestCaseFailed(const TestCase* test_case) {

  return test_case->should_run() && test_case->Failed();

}

// Returns true iff test_case contains at least one test that should

// run.

static bool ShouldRunTestCase(const TestCase* test_case) {

  return test_case->should_run();

}

// AssertHelper constructor.

AssertHelper::AssertHelper(TestPartResult::Type type,

                           const char* file,

                           int line,

                           const char* message)

    : data_(new AssertHelperData(type, file, line, message)) {

}

AssertHelper::~AssertHelper() {

  delete data_;

}

// Message assignment, for assertion streaming support.

void AssertHelper::operator=(const Message& message) const {

  UnitTest::GetInstance()->

    AddTestPartResult(data_->type, data_->file, data_->line,

                      AppendUserMessage(data_->message, message),

                      UnitTest::GetInstance()->impl()

                      ->CurrentOsStackTraceExceptTop(1)

                      // Skips the stack frame for this function itself.

                      );  // NOLINT

}

// Mutex for linked pointers.

GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_linked_ptr_mutex);

// Application pathname gotten in InitGoogleTest.

std::string g_executable_path;

// Returns the current application's name, removing directory path if that

// is present.

FilePath GetCurrentExecutableName() {

  FilePath result;

#if GTEST_OS_WINDOWS

  result.Set(FilePath(g_executable_path).RemoveExtension("exe"));

#else

  result.Set(FilePath(g_executable_path));

#endif  // GTEST_OS_WINDOWS

  return result.RemoveDirectoryName();

}

// Functions for processing the gtest_output flag.

// Returns the output format, or "" for normal printed output.

std::string UnitTestOptions::GetOutputFormat() {

  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();

  if (gtest_output_flag == NULL) return std::string("");

  const char* const colon = strchr(gtest_output_flag, ':');

  return (colon == NULL) ?

      std::string(gtest_output_flag) :

      std::string(gtest_output_flag, colon - gtest_output_flag);

}

// Returns the name of the requested output file, or the default if none

// was explicitly specified.

std::string UnitTestOptions::GetAbsolutePathToOutputFile() {

  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();

  if (gtest_output_flag == NULL)

    return "";

  const char* const colon = strchr(gtest_output_flag, ':');

  if (colon == NULL)

    return internal::FilePath::ConcatPaths(

        internal::FilePath(

            UnitTest::GetInstance()->original_working_dir()),

        internal::FilePath(kDefaultOutputFile)).string();

  internal::FilePath output_name(colon + 1);

  if (!output_name.IsAbsolutePath())

    // TODO(wan@google.com): on Windows \some\path is not an absolute

    // path (as its meaning depends on the current drive), yet the

    // following logic for turning it into an absolute path is wrong.

    // Fix it.

    output_name = internal::FilePath::ConcatPaths(

        internal::FilePath(UnitTest::GetInstance()->original_working_dir()),

        internal::FilePath(colon + 1));

  if (!output_name.IsDirectory())

    return output_name.string();

  internal::FilePath result(internal::FilePath::GenerateUniqueFileName(

      output_name, internal::GetCurrentExecutableName(),

      GetOutputFormat().c_str()));

  return result.string();

}

// Returns true iff the wildcard pattern matches the string.  The

// first ':' or '\0' character in pattern marks the end of it.

//

// This recursive algorithm isn't very efficient, but is clear and

// works well enough for matching test names, which are short.

bool UnitTestOptions::PatternMatchesString(const char *pattern,

                                           const char *str) {

  switch (*pattern) {

    case '\0':

    case ':':  // Either ':' or '\0' marks the end of the pattern.

      return *str == '\0';

    case '?':  // Matches any single character.

      return *str != '\0' && PatternMatchesString(pattern + 1, str + 1);

    case '*':  // Matches any string (possibly empty) of characters.

      return (*str != '\0' && PatternMatchesString(pattern, str + 1)) ||

          PatternMatchesString(pattern + 1, str);

    default:  // Non-special character.  Matches itself.

      return *pattern == *str &&

          PatternMatchesString(pattern + 1, str + 1);

  }

}

bool UnitTestOptions::MatchesFilter(

    const std::string& name, const char* filter) {

  const char *cur_pattern = filter;

  for (;;) {

    if (PatternMatchesString(cur_pattern, name.c_str())) {

      return true;

    }

    // Finds the next pattern in the filter.

    cur_pattern = strchr(cur_pattern, ':');

    // Returns if no more pattern can be found.

    if (cur_pattern == NULL) {

      return false;

    }

    // Skips the pattern separater (the ':' character).

    cur_pattern++;

  }

}

// Returns true iff the user-specified filter matches the test case

// name and the test name.

bool UnitTestOptions::FilterMatchesTest(const std::string &test_case_name,

                                        const std::string &test_name) {

  const std::string& full_name = test_case_name + "." + test_name.c_str();

  // Split --gtest_filter at '-', if there is one, to separate into

  // positive filter and negative filter portions

  const char* const p = GTEST_FLAG(filter).c_str();

  const char* const dash = strchr(p, '-');

  std::string positive;

  std::string negative;

  if (dash == NULL) {

    positive = GTEST_FLAG(filter).c_str();  // Whole string is a positive filter

    negative = "";

  } else {

    positive = std::string(p, dash);   // Everything up to the dash

    negative = std::string(dash + 1);  // Everything after the dash

    if (positive.empty()) {

      // Treat '-test1' as the same as '*-test1'

      positive = kUniversalFilter;

    }

  }

  // A filter is a colon-separated list of patterns.  It matches a

  // test if any pattern in it matches the test.

  return (MatchesFilter(full_name, positive.c_str()) &&

          !MatchesFilter(full_name, negative.c_str()));

}

#if GTEST_HAS_SEH

// Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the

// given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.

// This function is useful as an __except condition.

int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) {

  // Google Test should handle a SEH exception if:

  //   1. the user wants it to, AND

  //   2. this is not a breakpoint exception, AND

  //   3. this is not a C++ exception (VC++ implements them via SEH,

  //      apparently).

  //

  // SEH exception code for C++ exceptions.

  // (see http://support.microsoft.com/kb/185294 for more information).

  const DWORD kCxxExceptionCode = 0xe06d7363;

  bool should_handle = true;

  if (!GTEST_FLAG(catch_exceptions))