blame: source/misc/embedded_libs/fmt-8.1.1/test/gtest/gmock-gtest-all.cc

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

//

// Google C++ Testing and Mocking Framework (Google Test)

//

// Sometimes it's desirable to build Google Test by compiling a single file.

// This file serves this purpose.

// This line ensures that gtest.h can be compiled on its own, even

// when it's fused.

#include "gtest/gtest.h"

// The following lines pull in the real gtest *.cc files.

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

//

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

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

//

// Utilities for testing Google Test itself and code that uses Google Test

// (e.g. frameworks built on top of Google Test).

// GOOGLETEST_CM0004 DO NOT DELETE

#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_

#define GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_

GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \

/* class A needs to have dll-interface to be used by clients of class B */)

namespace testing {

// This helper class can be used to mock out Google Test failure reporting

// so that we can test Google Test or code that builds on Google Test.

//

// An object of this class appends a TestPartResult object to the

// TestPartResultArray object given in the constructor whenever a Google Test

// failure is reported. It can either intercept only failures that are

// generated in the same thread that created this object or it can intercept

// all generated failures. The scope of this mock object can be controlled with

// the second argument to the two arguments constructor.

class GTEST_API_ ScopedFakeTestPartResultReporter

    : public TestPartResultReporterInterface {

 public:

  // The two possible mocking modes of this object.

  enum InterceptMode {

    INTERCEPT_ONLY_CURRENT_THREAD,  // Intercepts only thread local failures.

    INTERCEPT_ALL_THREADS           // Intercepts all failures.

  };

  // The c'tor sets this object as the test part result reporter used

  // by Google Test.  The 'result' parameter specifies where to report the

  // results. This reporter will only catch failures generated in the current

  // thread. DEPRECATED

  explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result);

  // Same as above, but you can choose the interception scope of this object.

  ScopedFakeTestPartResultReporter(InterceptMode intercept_mode,

                                   TestPartResultArray* result);

  // The d'tor restores the previous test part result reporter.

  ~ScopedFakeTestPartResultReporter() override;

  // Appends the TestPartResult object to the TestPartResultArray

  // received in the constructor.

  //

  // This method is from the TestPartResultReporterInterface

  // interface.

  void ReportTestPartResult(const TestPartResult& result) override;

 private:

  void Init();

  const InterceptMode intercept_mode_;

  TestPartResultReporterInterface* old_reporter_;

  TestPartResultArray* const result_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);

};

namespace internal {

// A helper class for implementing EXPECT_FATAL_FAILURE() and

// EXPECT_NONFATAL_FAILURE().  Its destructor verifies that the given

// TestPartResultArray contains exactly one failure that has the given

// type and contains the given substring.  If that's not the case, a

// non-fatal failure will be generated.

class GTEST_API_ SingleFailureChecker {

 public:

  // The constructor remembers the arguments.

  SingleFailureChecker(const TestPartResultArray* results,

                       TestPartResult::Type type, const std::string& substr);

  ~SingleFailureChecker();

 private:

  const TestPartResultArray* const results_;

  const TestPartResult::Type type_;

  const std::string substr_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);

};

}  // namespace internal

}  // namespace testing

GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251

// A set of macros for testing Google Test assertions or code that's expected

// to generate Google Test fatal failures.  It verifies that the given

// statement will cause exactly one fatal Google Test failure with 'substr'

// being part of the failure message.

//

// There are two different versions of this macro. EXPECT_FATAL_FAILURE only

// affects and considers failures generated in the current thread and

// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.

//

// The verification of the assertion is done correctly even when the statement

// throws an exception or aborts the current function.

//

// Known restrictions:

//   - 'statement' cannot reference local non-static variables or

//     non-static members of the current object.

//   - 'statement' cannot return a value.

//   - You cannot stream a failure message to this macro.

//

// Note that even though the implementations of the following two

// macros are much alike, we cannot refactor them to use a common

// helper macro, due to some peculiarity in how the preprocessor

// works.  The AcceptsMacroThatExpandsToUnprotectedComma test in

// gtest_unittest.cc will fail to compile if we do that.

#define EXPECT_FATAL_FAILURE(statement, substr) \

  do { \

    class GTestExpectFatalFailureHelper {\

     public:\

      static void Execute() { statement; }\

    };\

    ::testing::TestPartResultArray gtest_failures;\

    ::testing::internal::SingleFailureChecker gtest_checker(\

        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\

    {\

      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\

          ::testing::ScopedFakeTestPartResultReporter:: \

          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\

      GTestExpectFatalFailureHelper::Execute();\

    }\

  } while (::testing::internal::AlwaysFalse())

#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \

  do { \

    class GTestExpectFatalFailureHelper {\

     public:\

      static void Execute() { statement; }\

    };\

    ::testing::TestPartResultArray gtest_failures;\

    ::testing::internal::SingleFailureChecker gtest_checker(\

        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\

    {\

      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\

          ::testing::ScopedFakeTestPartResultReporter:: \

          INTERCEPT_ALL_THREADS, &gtest_failures);\

      GTestExpectFatalFailureHelper::Execute();\

    }\

  } while (::testing::internal::AlwaysFalse())

// A macro for testing Google Test assertions or code that's expected to

// generate Google Test non-fatal failures.  It asserts that the given

// statement will cause exactly one non-fatal Google Test failure with 'substr'

// being part of the failure message.

//

// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only

// affects and considers failures generated in the current thread and

// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.

//

// 'statement' is allowed to reference local variables and members of

// the current object.

//

// The verification of the assertion is done correctly even when the statement

// throws an exception or aborts the current function.

//

// Known restrictions:

//   - You cannot stream a failure message to this macro.

//

// Note that even though the implementations of the following two

// macros are much alike, we cannot refactor them to use a common

// helper macro, due to some peculiarity in how the preprocessor

// works.  If we do that, the code won't compile when the user gives

// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that

// expands to code containing an unprotected comma.  The

// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc

// catches that.

//

// For the same reason, we have to write

//   if (::testing::internal::AlwaysTrue()) { statement; }

// instead of

//   GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)

// to avoid an MSVC warning on unreachable code.

#define EXPECT_NONFATAL_FAILURE(statement, substr) \

  do {\

    ::testing::TestPartResultArray gtest_failures;\

    ::testing::internal::SingleFailureChecker gtest_checker(\

        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \

        (substr));\

    {\

      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\

          ::testing::ScopedFakeTestPartResultReporter:: \

          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\

      if (::testing::internal::AlwaysTrue()) { statement; }\

    }\

  } while (::testing::internal::AlwaysFalse())

#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \

  do {\

    ::testing::TestPartResultArray gtest_failures;\

    ::testing::internal::SingleFailureChecker gtest_checker(\

        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \

        (substr));\

    {\

      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\

          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \

          &gtest_failures);\

      if (::testing::internal::AlwaysTrue()) { statement; }\

    }\

  } while (::testing::internal::AlwaysFalse())

#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_

#include <ctype.h>

#include <stdarg.h>

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#include <wchar.h>

#include <wctype.h>

#include <algorithm>

#include <chrono>  // NOLINT

#include <cmath>

#include <cstdint>

#include <iomanip>

#include <limits>

#include <list>

#include <map>

#include <ostream>  // NOLINT

#include <sstream>

#include <vector>

#if GTEST_OS_LINUX

# 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_ZOS

# 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

# undef min

#elif GTEST_OS_WINDOWS  // We are on Windows proper.

# include <windows.h>  // NOLINT

# undef min

#ifdef _MSC_VER

# include <crtdbg.h>  // NOLINT

#endif

# include <io.h>  // NOLINT

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

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

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

# if GTEST_OS_WINDOWS_MINGW

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

# endif  // GTEST_OS_WINDOWS_MINGW

#else

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

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

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

#endif

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

// Utility functions and classes used by the Google C++ testing framework.//

// This file contains purely Google Test's internal implementation.  Please

// DO NOT #INCLUDE IT IN A USER PROGRAM.

#ifndef GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_

#define GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_

#ifndef _WIN32_WCE

# include <errno.h>

#endif  // !_WIN32_WCE

#include <stddef.h>

#include <stdlib.h>  // For strtoll/_strtoul64/malloc/free.

#include <string.h>  // For memmove.

#include <algorithm>

#include <cstdint>

#include <memory>

#include <string>

#include <vector>

#if GTEST_CAN_STREAM_RESULTS_

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

# include <netdb.h>  // NOLINT

#endif

#if GTEST_OS_WINDOWS

# include <windows.h>  // NOLINT

#endif  // GTEST_OS_WINDOWS

GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \

/* class A needs to have dll-interface to be used by clients of class B */)

namespace testing {

// Declares the flags.

//

// We don't want the users to modify this flag in the code, but want

// Google Test's own unit tests to be able to access it. Therefore we

// declare it here as opposed to in gtest.h.

GTEST_DECLARE_bool_(death_test_use_fork);

namespace internal {

// The value of GetTestTypeId() as seen from within the Google Test

// library.  This is solely for testing GetTestTypeId().

GTEST_API_ extern const TypeId kTestTypeIdInGoogleTest;

// Names of the flags (needed for parsing Google Test flags).

const char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests";

const char kBreakOnFailureFlag[] = "break_on_failure";

const char kCatchExceptionsFlag[] = "catch_exceptions";

const char kColorFlag[] = "color";

const char kFailFast[] = "fail_fast";

const char kFilterFlag[] = "filter";

const char kListTestsFlag[] = "list_tests";

const char kOutputFlag[] = "output";

const char kBriefFlag[] = "brief";

const char kPrintTimeFlag[] = "print_time";

const char kPrintUTF8Flag[] = "print_utf8";

const char kRandomSeedFlag[] = "random_seed";

const char kRepeatFlag[] = "repeat";

const char kShuffleFlag[] = "shuffle";

const char kStackTraceDepthFlag[] = "stack_trace_depth";

const char kStreamResultToFlag[] = "stream_result_to";

const char kThrowOnFailureFlag[] = "throw_on_failure";

const char kFlagfileFlag[] = "flagfile";

// A valid random seed must be in [1, kMaxRandomSeed].

const int kMaxRandomSeed = 99999;

// g_help_flag is true if and only if the --help flag or an equivalent form

// is specified on the command line.

GTEST_API_ extern bool g_help_flag;

// Returns the current time in milliseconds.

GTEST_API_ TimeInMillis GetTimeInMillis();

// Returns true if and only if Google Test should use colors in the output.

GTEST_API_ bool ShouldUseColor(bool stdout_is_tty);

// Formats the given time in milliseconds as seconds.

GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms);

// Converts the given time in milliseconds to a date string in the ISO 8601

// format, without the timezone information.  N.B.: due to the use the

// non-reentrant localtime() function, this function is not thread safe.  Do

// not use it in any code that can be called from multiple threads.

GTEST_API_ std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms);

// Parses a string for an Int32 flag, in the form of "--flag=value".

//

// On success, stores the value of the flag in *value, and returns

// true.  On failure, returns false without changing *value.

GTEST_API_ bool ParseInt32Flag(

    const char* str, const char* flag, int32_t* value);

// Returns a random seed in range [1, kMaxRandomSeed] based on the

// given --gtest_random_seed flag value.

inline int GetRandomSeedFromFlag(int32_t random_seed_flag) {

  const unsigned int raw_seed = (random_seed_flag == 0) ?

      static_cast<unsigned int>(GetTimeInMillis()) :

      static_cast<unsigned int>(random_seed_flag);

  // Normalizes the actual seed to range [1, kMaxRandomSeed] such that

  // it's easy to type.

  const int normalized_seed =

      static_cast<int>((raw_seed - 1U) %

                       static_cast<unsigned int>(kMaxRandomSeed)) + 1;

  return normalized_seed;

}

// Returns the first valid random seed after 'seed'.  The behavior is

// undefined if 'seed' is invalid.  The seed after kMaxRandomSeed is

// considered to be 1.

inline int GetNextRandomSeed(int seed) {

  GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)

      << "Invalid random seed " << seed << " - must be in [1, "

      << kMaxRandomSeed << "].";

  const int next_seed = seed + 1;

  return (next_seed > kMaxRandomSeed) ? 1 : next_seed;

}

// This class saves the values of all Google Test flags in its c'tor, and

// restores them in its d'tor.

class GTestFlagSaver {

 public:

  // The c'tor.

  GTestFlagSaver() {

    also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests);

    break_on_failure_ = GTEST_FLAG(break_on_failure);

    catch_exceptions_ = GTEST_FLAG(catch_exceptions);

    color_ = GTEST_FLAG(color);

    death_test_style_ = GTEST_FLAG(death_test_style);

    death_test_use_fork_ = GTEST_FLAG(death_test_use_fork);

    fail_fast_ = GTEST_FLAG(fail_fast);

    filter_ = GTEST_FLAG(filter);

    internal_run_death_test_ = GTEST_FLAG(internal_run_death_test);

    list_tests_ = GTEST_FLAG(list_tests);

    output_ = GTEST_FLAG(output);

    brief_ = GTEST_FLAG(brief);

    print_time_ = GTEST_FLAG(print_time);

    print_utf8_ = GTEST_FLAG(print_utf8);

    random_seed_ = GTEST_FLAG(random_seed);

    repeat_ = GTEST_FLAG(repeat);

    shuffle_ = GTEST_FLAG(shuffle);

    stack_trace_depth_ = GTEST_FLAG(stack_trace_depth);

    stream_result_to_ = GTEST_FLAG(stream_result_to);

    throw_on_failure_ = GTEST_FLAG(throw_on_failure);

  }

  // The d'tor is not virtual.  DO NOT INHERIT FROM THIS CLASS.

  ~GTestFlagSaver() {

    GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_;

    GTEST_FLAG(break_on_failure) = break_on_failure_;

    GTEST_FLAG(catch_exceptions) = catch_exceptions_;

    GTEST_FLAG(color) = color_;

    GTEST_FLAG(death_test_style) = death_test_style_;

    GTEST_FLAG(death_test_use_fork) = death_test_use_fork_;

    GTEST_FLAG(filter) = filter_;

    GTEST_FLAG(fail_fast) = fail_fast_;

    GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;

    GTEST_FLAG(list_tests) = list_tests_;

    GTEST_FLAG(output) = output_;

    GTEST_FLAG(brief) = brief_;

    GTEST_FLAG(print_time) = print_time_;

    GTEST_FLAG(print_utf8) = print_utf8_;

    GTEST_FLAG(random_seed) = random_seed_;

    GTEST_FLAG(repeat) = repeat_;

    GTEST_FLAG(shuffle) = shuffle_;

    GTEST_FLAG(stack_trace_depth) = stack_trace_depth_;

    GTEST_FLAG(stream_result_to) = stream_result_to_;

    GTEST_FLAG(throw_on_failure) = throw_on_failure_;

  }

 private:

  // Fields for saving the original values of flags.

  bool also_run_disabled_tests_;

  bool break_on_failure_;

  bool catch_exceptions_;

  std::string color_;

  std::string death_test_style_;

  bool death_test_use_fork_;

  bool fail_fast_;

  std::string filter_;

  std::string internal_run_death_test_;

  bool list_tests_;

  std::string output_;

  bool brief_;

  bool print_time_;

  bool print_utf8_;

  int32_t random_seed_;

  int32_t repeat_;

  bool shuffle_;

  int32_t stack_trace_depth_;

  std::string stream_result_to_;

  bool throw_on_failure_;

} GTEST_ATTRIBUTE_UNUSED_;

// Converts a Unicode code point to a narrow string in UTF-8 encoding.

// code_point parameter is of type UInt32 because wchar_t may not be

// wide enough to contain a code point.

// If the code_point is not a valid Unicode code point

// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted

// to "(Invalid Unicode 0xXXXXXXXX)".

GTEST_API_ std::string CodePointToUtf8(uint32_t code_point);

// Converts a wide string to a narrow string in UTF-8 encoding.

// The wide string is assumed to have the following encoding:

//   UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin)

//   UTF-32 if sizeof(wchar_t) == 4 (on Linux)

// Parameter str points to a null-terminated wide string.

// Parameter num_chars may additionally limit the number

// of wchar_t characters processed. -1 is used when the entire string

// should be processed.

// If the string contains code points that are not valid Unicode code points

// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output

// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding

// and contains invalid UTF-16 surrogate pairs, values in those pairs

// will be encoded as individual Unicode characters from Basic Normal Plane.

GTEST_API_ std::string WideStringToUtf8(const wchar_t* str, int num_chars);

// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file

// if the variable is present. If a file already exists at this location, this

// function will write over it. If the variable is present, but the file cannot

// be created, prints an error and exits.

void WriteToShardStatusFileIfNeeded();

// Checks whether sharding is enabled by examining the relevant

// environment variable values. If the variables are present,

// but inconsistent (e.g., shard_index >= total_shards), prints

// an error and exits. If in_subprocess_for_death_test, sharding is

// disabled because it must only be applied to the original test

// process. Otherwise, we could filter out death tests we intended to execute.

GTEST_API_ bool ShouldShard(const char* total_shards_str,

                            const char* shard_index_str,

                            bool in_subprocess_for_death_test);

// Parses the environment variable var as a 32-bit integer. If it is unset,

// returns default_val. If it is not a 32-bit integer, prints an error and

// and aborts.

GTEST_API_ int32_t Int32FromEnvOrDie(const char* env_var, int32_t default_val);

// Given the total number of shards, the shard index, and the test id,

// returns true if and only if the test should be run on this shard. The test id

// is some arbitrary but unique non-negative integer assigned to each test

// method. Assumes that 0 <= shard_index < total_shards.

GTEST_API_ bool ShouldRunTestOnShard(

    int total_shards, int shard_index, int test_id);

// STL container utilities.

// Returns the number of elements in the given container that satisfy

// the given predicate.

template <class Container, typename Predicate>

inline int CountIf(const Container& c, Predicate predicate) {

  // Implemented as an explicit loop since std::count_if() in libCstd on

  // Solaris has a non-standard signature.

  int count = 0;

  for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) {

    if (predicate(*it))

      ++count;

  }

  return count;

}

// Applies a function/functor to each element in the container.

template <class Container, typename Functor>

void ForEach(const Container& c, Functor functor) {

  std::for_each(c.begin(), c.end(), functor);

}

// Returns the i-th element of the vector, or default_value if i is not

// in range [0, v.size()).

template <typename E>

inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {

  return (i < 0 || i >= static_cast<int>(v.size())) ? default_value

                                                    : v[static_cast<size_t>(i)];

}

// Performs an in-place shuffle of a range of the vector's elements.

// 'begin' and 'end' are element indices as an STL-style range;

// i.e. [begin, end) are shuffled, where 'end' == size() means to

// shuffle to the end of the vector.

template <typename E>

void ShuffleRange(internal::Random* random, int begin, int end,

                  std::vector<E>* v) {

  const int size = static_cast<int>(v->size());

  GTEST_CHECK_(0 <= begin && begin <= size)

      << "Invalid shuffle range start " << begin << ": must be in range [0, "

      << size << "].";

  GTEST_CHECK_(begin <= end && end <= size)

      << "Invalid shuffle range finish " << end << ": must be in range ["

      << begin << ", " << size << "].";

  // Fisher-Yates shuffle, from

  // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle

  for (int range_width = end - begin; range_width >= 2; range_width--) {

    const int last_in_range = begin + range_width - 1;

    const int selected =

        begin +

        static_cast<int>(random->Generate(static_cast<uint32_t>(range_width)));

    std::swap((*v)[static_cast<size_t>(selected)],

              (*v)[static_cast<size_t>(last_in_range)]);

  }

}

// Performs an in-place shuffle of the vector's elements.

template <typename E>

inline void Shuffle(internal::Random* random, std::vector<E>* v) {

  ShuffleRange(random, 0, static_cast<int>(v->size()), v);

}

// A function for deleting an object.  Handy for being used as a

// functor.

template <typename T>

static void Delete(T* x) {

  delete x;

}

// A predicate that checks the key of a TestProperty against a known key.

//

// TestPropertyKeyIs is copyable.

class TestPropertyKeyIs {

 public:

  // Constructor.

  //

  // TestPropertyKeyIs has NO default constructor.

  explicit TestPropertyKeyIs(const std::string& key) : key_(key) {}

  // Returns true if and only if the test name of test property matches on key_.

  bool operator()(const TestProperty& test_property) const {

    return test_property.key() == key_;

  }

 private:

  std::string key_;

};

// Class UnitTestOptions.

//

// This class contains functions for processing options the user

// specifies when running the tests.  It has only static members.

//

// In most cases, the user can specify an option using either an

// environment variable or a command line flag.  E.g. you can set the

// test filter using either GTEST_FILTER or --gtest_filter.  If both

// the variable and the flag are present, the latter overrides the

// former.

class GTEST_API_ UnitTestOptions {

 public:

  // Functions for processing the gtest_output flag.

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

  static std::string GetOutputFormat();

  // Returns the absolute path of the requested output file, or the

  // default (test_detail.xml in the original working directory) if

  // none was explicitly specified.

  static std::string GetAbsolutePathToOutputFile();

  // Functions for processing the gtest_filter flag.

  // Returns true if and only if the user-specified filter matches the test

  // suite name and the test name.

  static bool FilterMatchesTest(const std::string& test_suite_name,

                                const std::string& test_name);

#if GTEST_OS_WINDOWS

  // Function for supporting the gtest_catch_exception flag.

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

  static int GTestShouldProcessSEH(DWORD exception_code);

#endif  // GTEST_OS_WINDOWS

  // Returns true if "name" matches the ':' separated list of glob-style

  // filters in "filter".

  static bool MatchesFilter(const std::string& name, const char* filter);

};

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

// is present.  Used by UnitTestOptions::GetOutputFile.

GTEST_API_ FilePath GetCurrentExecutableName();

// The role interface for getting the OS stack trace as a string.

class OsStackTraceGetterInterface {

 public:

  OsStackTraceGetterInterface() {}

  virtual ~OsStackTraceGetterInterface() {}

  // Returns the current OS stack trace as an std::string.  Parameters:

  //

  //   max_depth  - the maximum number of stack frames to be included

  //                in the trace.

  //   skip_count - the number of top frames to be skipped; doesn't count

  //                against max_depth.

  virtual std::string CurrentStackTrace(int max_depth, int skip_count) = 0;

  // UponLeavingGTest() should be called immediately before Google Test calls

  // user code. It saves some information about the current stack that

  // CurrentStackTrace() will use to find and hide Google Test stack frames.

  virtual void UponLeavingGTest() = 0;

  // This string is inserted in place of stack frames that are part of

  // Google Test's implementation.

  static const char* const kElidedFramesMarker;

 private:

  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface);

};

// A working implementation of the OsStackTraceGetterInterface interface.

class OsStackTraceGetter : public OsStackTraceGetterInterface {

 public:

  OsStackTraceGetter() {}

  std::string CurrentStackTrace(int max_depth, int skip_count) override;

  void UponLeavingGTest() override;

 private:

#if GTEST_HAS_ABSL

  Mutex mutex_;  // Protects all internal state.

  // We save the stack frame below the frame that calls user code.

  // We do this because the address of the frame immediately below

  // the user code changes between the call to UponLeavingGTest()

  // and any calls to the stack trace code from within the user code.

  void* caller_frame_ = nullptr;

#endif  // GTEST_HAS_ABSL

  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter);

};

// Information about a Google Test trace point.

struct TraceInfo {

  const char* file;

  int line;

  std::string message;

};

// This is the default global test part result reporter used in UnitTestImpl.

// This class should only be used by UnitTestImpl.

class DefaultGlobalTestPartResultReporter

  : public TestPartResultReporterInterface {

 public:

  explicit DefaultGlobalTestPartResultReporter(UnitTestImpl* unit_test);

  // Implements the TestPartResultReporterInterface. Reports the test part

  // result in the current test.

  void ReportTestPartResult(const TestPartResult& result) override;

 private:

  UnitTestImpl* const unit_test_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter);

};

// This is the default per thread test part result reporter used in

// UnitTestImpl. This class should only be used by UnitTestImpl.

class DefaultPerThreadTestPartResultReporter

    : public TestPartResultReporterInterface {

 public:

  explicit DefaultPerThreadTestPartResultReporter(UnitTestImpl* unit_test);

  // Implements the TestPartResultReporterInterface. The implementation just

  // delegates to the current global test part result reporter of *unit_test_.

  void ReportTestPartResult(const TestPartResult& result) override;