From 35fd7edafeea893092047eff1ea424a06673529c Mon Sep 17 00:00:00 2001 From: AngryHedgehogg Date: Thu, 22 Feb 2018 17:39:36 +0300 Subject: [PATCH 01/10] rabota na pare --- SaryninS/lab 1/gtest/gtest-all.cc | 9592 +++++++++++++ SaryninS/lab 1/gtest/gtest.h | 20063 +++++++++++++++++++++++++++ SaryninS/lab 1/include/TLink.h.txt | 0 SaryninS/lab 1/sample/main.cpp.txt | 0 SaryninS/lab 1/src/TLink.cpp.txt | 0 SaryninS/lab 1/test/test_main.cpp | 7 + 6 files changed, 29662 insertions(+) create mode 100644 SaryninS/lab 1/gtest/gtest-all.cc create mode 100644 SaryninS/lab 1/gtest/gtest.h create mode 100644 SaryninS/lab 1/include/TLink.h.txt create mode 100644 SaryninS/lab 1/sample/main.cpp.txt create mode 100644 SaryninS/lab 1/src/TLink.cpp.txt create mode 100644 SaryninS/lab 1/test/test_main.cpp diff --git a/SaryninS/lab 1/gtest/gtest-all.cc b/SaryninS/lab 1/gtest/gtest-all.cc new file mode 100644 index 000000000..ff9e51235 --- /dev/null +++ b/SaryninS/lab 1/gtest/gtest-all.cc @@ -0,0 +1,9592 @@ +// 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. +// +// Author: mheule@google.com (Markus Heule) +// +// Google C++ Testing 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.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. +// +// Author: wan@google.com (Zhanyong Wan) +// +// The Google C++ Testing 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. +// +// Author: wan@google.com (Zhanyong Wan) +// +// Utilities for testing Google Test itself and code that uses Google Test +// (e.g. frameworks built on top of Google Test). + +#ifndef GTEST_INCLUDE_GTEST_GTEST_SPI_H_ +#define GTEST_INCLUDE_GTEST_GTEST_SPI_H_ + + +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. + virtual ~ScopedFakeTestPartResultReporter(); + + // Appends the TestPartResult object to the TestPartResultArray + // received in the constructor. + // + // This method is from the TestPartResultReporterInterface + // interface. + virtual void ReportTestPartResult(const TestPartResult& result); + 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 string& substr); + ~SingleFailureChecker(); + private: + const TestPartResultArray* const results_; + const TestPartResult::Type type_; + const string substr_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker); +}; + +} // namespace internal + +} // namespace testing + +// 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(\ + >est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\ + {\ + ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ + ::testing::ScopedFakeTestPartResultReporter:: \ + INTERCEPT_ONLY_CURRENT_THREAD, >est_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(\ + >est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\ + {\ + ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ + ::testing::ScopedFakeTestPartResultReporter:: \ + INTERCEPT_ALL_THREADS, >est_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(\ + >est_failures, ::testing::TestPartResult::kNonFatalFailure, \ + (substr));\ + {\ + ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ + ::testing::ScopedFakeTestPartResultReporter:: \ + INTERCEPT_ONLY_CURRENT_THREAD, >est_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(\ + >est_failures, ::testing::TestPartResult::kNonFatalFailure, \ + (substr));\ + {\ + ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ + ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \ + >est_failures);\ + if (::testing::internal::AlwaysTrue()) { statement; }\ + }\ + } while (::testing::internal::AlwaysFalse()) + +#endif // GTEST_INCLUDE_GTEST_GTEST_SPI_H_ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include // NOLINT +#include +#include + +#if GTEST_OS_LINUX + +// TODO(kenton@google.com): Use autoconf to detect availability of +// gettimeofday(). +# define GTEST_HAS_GETTIMEOFDAY_ 1 + +# include // NOLINT +# include // NOLINT +# include // NOLINT +// Declares vsnprintf(). This header is not available on Windows. +# include // NOLINT +# include // NOLINT +# include // NOLINT +# include // NOLINT +# include + +#elif GTEST_OS_SYMBIAN +# define GTEST_HAS_GETTIMEOFDAY_ 1 +# include // NOLINT + +#elif GTEST_OS_ZOS +# define GTEST_HAS_GETTIMEOFDAY_ 1 +# include // NOLINT + +// On z/OS we additionally need strings.h for strcasecmp. +# include // NOLINT + +#elif GTEST_OS_WINDOWS_MOBILE // We are on Windows CE. + +# include // NOLINT + +#elif GTEST_OS_WINDOWS // We are on Windows proper. + +# include // NOLINT +# include // NOLINT +# include // NOLINT +# include // 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 // NOLINT +# endif // GTEST_OS_WINDOWS_MINGW + +// cpplint thinks that the header is already included, so we want to +// silence it. +# include // 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 // NOLINT +# include // NOLINT + +#endif // GTEST_OS_LINUX + +#if GTEST_HAS_EXCEPTIONS +# include +#endif + +#if GTEST_CAN_STREAM_RESULTS_ +# include // NOLINT +# include // 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 +// 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. +// +// Author: wan@google.com (Zhanyong Wan) +// +// This file contains purely Google Test's internal implementation. Please +// DO NOT #INCLUDE IT IN A USER PROGRAM. + +#ifndef GTEST_SRC_GTEST_INTERNAL_INL_H_ +#define GTEST_SRC_GTEST_INTERNAL_INL_H_ + +// GTEST_IMPLEMENTATION_ is defined to 1 iff the current translation unit is +// part of Google Test's implementation; otherwise it's undefined. +#if !GTEST_IMPLEMENTATION_ +// A user is trying to include this from his code - just say no. +# error "gtest-internal-inl.h is part of Google Test's internal implementation." +# error "It must not be included except by Google Test itself." +#endif // GTEST_IMPLEMENTATION_ + +#ifndef _WIN32_WCE +# include +#endif // !_WIN32_WCE +#include +#include // For strtoll/_strtoul64/malloc/free. +#include // For memmove. + +#include +#include +#include + + +#if GTEST_CAN_STREAM_RESULTS_ +# include // NOLINT +# include // NOLINT +#endif + +#if GTEST_OS_WINDOWS +# include // NOLINT +#endif // GTEST_OS_WINDOWS + + +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 kFilterFlag[] = "filter"; +const char kListTestsFlag[] = "list_tests"; +const char kOutputFlag[] = "output"; +const char kPrintTimeFlag[] = "print_time"; +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"; + +// A valid random seed must be in [1, kMaxRandomSeed]. +const int kMaxRandomSeed = 99999; + +// g_help_flag is true iff 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 iff 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* value); + +// Returns a random seed in range [1, kMaxRandomSeed] based on the +// given --gtest_random_seed flag value. +inline int GetRandomSeedFromFlag(Int32 random_seed_flag) { + const unsigned int raw_seed = (random_seed_flag == 0) ? + static_cast(GetTimeInMillis()) : + static_cast(random_seed_flag); + + // Normalizes the actual seed to range [1, kMaxRandomSeed] such that + // it's easy to type. + const int normalized_seed = + static_cast((raw_seed - 1U) % + static_cast(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); + filter_ = GTEST_FLAG(filter); + internal_run_death_test_ = GTEST_FLAG(internal_run_death_test); + list_tests_ = GTEST_FLAG(list_tests); + output_ = GTEST_FLAG(output); + print_time_ = GTEST_FLAG(print_time); + 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(internal_run_death_test) = internal_run_death_test_; + GTEST_FLAG(list_tests) = list_tests_; + GTEST_FLAG(output) = output_; + GTEST_FLAG(print_time) = print_time_; + 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_; + std::string filter_; + std::string internal_run_death_test_; + bool list_tests_; + std::string output_; + bool print_time_; + internal::Int32 random_seed_; + internal::Int32 repeat_; + bool shuffle_; + internal::Int32 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 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, Symbian OS) +// 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 an Int32. If it is unset, +// returns default_val. If it is not an Int32, prints an error and +// and aborts. +GTEST_API_ Int32 Int32FromEnvOrDie(const char* env_var, Int32 default_val); + +// Given the total number of shards, the shard index, and the test id, +// returns true iff 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 +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 +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 +inline E GetElementOr(const std::vector& v, int i, E default_value) { + return (i < 0 || i >= static_cast(v.size())) ? default_value : v[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 +void ShuffleRange(internal::Random* random, int begin, int end, + std::vector* v) { + const int size = static_cast(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 + random->Generate(range_width); + std::swap((*v)[selected], (*v)[last_in_range]); + } +} + +// Performs an in-place shuffle of the vector's elements. +template +inline void Shuffle(internal::Random* random, std::vector* v) { + ShuffleRange(random, 0, static_cast(v->size()), v); +} + +// A function for deleting an object. Handy for being used as a +// functor. +template +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 iff 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 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. + static bool PatternMatchesString(const char *pattern, const char *str); + + // Returns true iff the user-specified filter matches the test case + // name and the test name. + static bool FilterMatchesTest(const std::string &test_case_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 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; + + private: + GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface); +}; + +// A working implementation of the OsStackTraceGetterInterface interface. +class OsStackTraceGetter : public OsStackTraceGetterInterface { + public: + OsStackTraceGetter() : caller_frame_(NULL) {} + + virtual string CurrentStackTrace(int max_depth, int skip_count) + GTEST_LOCK_EXCLUDED_(mutex_); + + virtual void UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_); + + // This string is inserted in place of stack frames that are part of + // Google Test's implementation. + static const char* const kElidedFramesMarker; + + private: + 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 CurrentStackTrace() from within the user code. + void* caller_frame_; + + 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. + virtual void ReportTestPartResult(const TestPartResult& result); + + 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_. + virtual void ReportTestPartResult(const TestPartResult& result); + + private: + UnitTestImpl* const unit_test_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter); +}; + +// The private implementation of the UnitTest class. We don't protect +// the methods under a mutex, as this class is not accessible by a +// user and the UnitTest class that delegates work to this class does +// proper locking. +class GTEST_API_ UnitTestImpl { + public: + explicit UnitTestImpl(UnitTest* parent); + virtual ~UnitTestImpl(); + + // There are two different ways to register your own TestPartResultReporter. + // You can register your own repoter to listen either only for test results + // from the current thread or for results from all threads. + // By default, each per-thread test result repoter just passes a new + // TestPartResult to the global test result reporter, which registers the + // test part result for the currently running test. + + // Returns the global test part result reporter. + TestPartResultReporterInterface* GetGlobalTestPartResultReporter(); + + // Sets the global test part result reporter. + void SetGlobalTestPartResultReporter( + TestPartResultReporterInterface* reporter); + + // Returns the test part result reporter for the current thread. + TestPartResultReporterInterface* GetTestPartResultReporterForCurrentThread(); + + // Sets the test part result reporter for the current thread. + void SetTestPartResultReporterForCurrentThread( + TestPartResultReporterInterface* reporter); + + // Gets the number of successful test cases. + int successful_test_case_count() const; + + // Gets the number of failed test cases. + int failed_test_case_count() const; + + // Gets the number of all test cases. + int total_test_case_count() const; + + // Gets the number of all test cases that contain at least one test + // that should run. + int test_case_to_run_count() const; + + // Gets the number of successful tests. + int successful_test_count() const; + + // Gets the number of failed tests. + int failed_test_count() const; + + // Gets the number of disabled tests that will be reported in the XML report. + int reportable_disabled_test_count() const; + + // Gets the number of disabled tests. + int disabled_test_count() const; + + // Gets the number of tests to be printed in the XML report. + int reportable_test_count() const; + + // Gets the number of all tests. + int total_test_count() const; + + // Gets the number of tests that should run. + int test_to_run_count() const; + + // Gets the time of the test program start, in ms from the start of the + // UNIX epoch. + TimeInMillis start_timestamp() const { return start_timestamp_; } + + // Gets the elapsed time, in milliseconds. + TimeInMillis elapsed_time() const { return elapsed_time_; } + + // Returns true iff the unit test passed (i.e. all test cases passed). + bool Passed() const { return !Failed(); } + + // Returns true iff the unit test failed (i.e. some test case failed + // or something outside of all tests failed). + bool Failed() const { + return failed_test_case_count() > 0 || ad_hoc_test_result()->Failed(); + } + + // Gets the i-th test case among all the test cases. i can range from 0 to + // total_test_case_count() - 1. If i is not in that range, returns NULL. + const TestCase* GetTestCase(int i) const { + const int index = GetElementOr(test_case_indices_, i, -1); + return index < 0 ? NULL : test_cases_[i]; + } + + // Gets the i-th test case among all the test cases. i can range from 0 to + // total_test_case_count() - 1. If i is not in that range, returns NULL. + TestCase* GetMutableTestCase(int i) { + const int index = GetElementOr(test_case_indices_, i, -1); + return index < 0 ? NULL : test_cases_[index]; + } + + // Provides access to the event listener list. + TestEventListeners* listeners() { return &listeners_; } + + // Returns the TestResult for the test that's currently running, or + // the TestResult for the ad hoc test if no test is running. + TestResult* current_test_result(); + + // Returns the TestResult for the ad hoc test. + const TestResult* ad_hoc_test_result() const { return &ad_hoc_test_result_; } + + // Sets the OS stack trace getter. + // + // Does nothing if the input and the current OS stack trace getter + // are the same; otherwise, deletes the old getter and makes the + // input the current getter. + void set_os_stack_trace_getter(OsStackTraceGetterInterface* getter); + + // Returns the current OS stack trace getter if it is not NULL; + // otherwise, creates an OsStackTraceGetter, makes it the current + // getter, and returns it. + OsStackTraceGetterInterface* os_stack_trace_getter(); + + // Returns the current OS stack trace as an std::string. + // + // The maximum number of stack frames to be included is specified by + // the gtest_stack_trace_depth flag. The skip_count parameter + // specifies the number of top frames to be skipped, which doesn't + // count against the number of frames to be included. + // + // For example, if Foo() calls Bar(), which in turn calls + // CurrentOsStackTraceExceptTop(1), Foo() will be included in the + // trace but Bar() and CurrentOsStackTraceExceptTop() won't. + std::string CurrentOsStackTraceExceptTop(int skip_count) GTEST_NO_INLINE_; + + // Finds and returns a TestCase with the given name. If one doesn't + // exist, creates one and returns it. + // + // Arguments: + // + // test_case_name: name of the test case + // type_param: the name of the test's type parameter, or NULL if + // this is not a typed or a type-parameterized test. + // set_up_tc: pointer to the function that sets up the test case + // tear_down_tc: pointer to the function that tears down the test case + TestCase* GetTestCase(const char* test_case_name, + const char* type_param, + Test::SetUpTestCaseFunc set_up_tc, + Test::TearDownTestCaseFunc tear_down_tc); + + // Adds a TestInfo to the unit test. + // + // Arguments: + // + // set_up_tc: pointer to the function that sets up the test case + // tear_down_tc: pointer to the function that tears down the test case + // test_info: the TestInfo object + void AddTestInfo(Test::SetUpTestCaseFunc set_up_tc, + Test::TearDownTestCaseFunc tear_down_tc, + TestInfo* test_info) { + // In order to support thread-safe death tests, we need to + // remember the original working directory when the test program + // was first invoked. We cannot do this in RUN_ALL_TESTS(), as + // the user may have changed the current directory before calling + // RUN_ALL_TESTS(). Therefore we capture the current directory in + // AddTestInfo(), which is called to register a TEST or TEST_F + // before main() is reached. + if (original_working_dir_.IsEmpty()) { + original_working_dir_.Set(FilePath::GetCurrentDir()); + GTEST_CHECK_(!original_working_dir_.IsEmpty()) + << "Failed to get the current working directory."; + } + + GetTestCase(test_info->test_case_name(), + test_info->type_param(), + set_up_tc, + tear_down_tc)->AddTestInfo(test_info); + } + +#if GTEST_HAS_PARAM_TEST + // Returns ParameterizedTestCaseRegistry object used to keep track of + // value-parameterized tests and instantiate and register them. + internal::ParameterizedTestCaseRegistry& parameterized_test_registry() { + return parameterized_test_registry_; + } +#endif // GTEST_HAS_PARAM_TEST + + // Sets the TestCase object for the test that's currently running. + void set_current_test_case(TestCase* a_current_test_case) { + current_test_case_ = a_current_test_case; + } + + // Sets the TestInfo object for the test that's currently running. If + // current_test_info is NULL, the assertion results will be stored in + // ad_hoc_test_result_. + void set_current_test_info(TestInfo* a_current_test_info) { + current_test_info_ = a_current_test_info; + } + + // Registers all parameterized tests defined using TEST_P and + // INSTANTIATE_TEST_CASE_P, creating regular tests for each test/parameter + // combination. This method can be called more then once; it has guards + // protecting from registering the tests more then once. If + // value-parameterized tests are disabled, RegisterParameterizedTests is + // present but does nothing. + void RegisterParameterizedTests(); + + // Runs all tests in this UnitTest object, prints the result, and + // returns true if all tests are successful. If any exception is + // thrown during a test, this test is considered to be failed, but + // the rest of the tests will still be run. + bool RunAllTests(); + + // Clears the results of all tests, except the ad hoc tests. + void ClearNonAdHocTestResult() { + ForEach(test_cases_, TestCase::ClearTestCaseResult); + } + + // Clears the results of ad-hoc test assertions. + void ClearAdHocTestResult() { + ad_hoc_test_result_.Clear(); + } + + // Adds a TestProperty to the current TestResult object when invoked in a + // context of a test or a test case, or to the global property set. If the + // result already contains a property with the same key, the value will be + // updated. + void RecordProperty(const TestProperty& test_property); + + enum ReactionToSharding { + HONOR_SHARDING_PROTOCOL, + IGNORE_SHARDING_PROTOCOL + }; + + // Matches the full name of each test against the user-specified + // filter to decide whether the test should run, then records the + // result in each TestCase and TestInfo object. + // If shard_tests == HONOR_SHARDING_PROTOCOL, further filters tests + // based on sharding variables in the environment. + // Returns the number of tests that should run. + int FilterTests(ReactionToSharding shard_tests); + + // Prints the names of the tests matching the user-specified filter flag. + void ListTestsMatchingFilter(); + + const TestCase* current_test_case() const { return current_test_case_; } + TestInfo* current_test_info() { return current_test_info_; } + const TestInfo* current_test_info() const { return current_test_info_; } + + // Returns the vector of environments that need to be set-up/torn-down + // before/after the tests are run. + std::vector& environments() { return environments_; } + + // Getters for the per-thread Google Test trace stack. + std::vector& gtest_trace_stack() { + return *(gtest_trace_stack_.pointer()); + } + const std::vector& gtest_trace_stack() const { + return gtest_trace_stack_.get(); + } + +#if GTEST_HAS_DEATH_TEST + void InitDeathTestSubprocessControlInfo() { + internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag()); + } + // Returns a pointer to the parsed --gtest_internal_run_death_test + // flag, or NULL if that flag was not specified. + // This information is useful only in a death test child process. + // Must not be called before a call to InitGoogleTest. + const InternalRunDeathTestFlag* internal_run_death_test_flag() const { + return internal_run_death_test_flag_.get(); + } + + // Returns a pointer to the current death test factory. + internal::DeathTestFactory* death_test_factory() { + return death_test_factory_.get(); + } + + void SuppressTestEventsIfInSubprocess(); + + friend class ReplaceDeathTestFactory; +#endif // GTEST_HAS_DEATH_TEST + + // Initializes the event listener performing XML output as specified by + // UnitTestOptions. Must not be called before InitGoogleTest. + void ConfigureXmlOutput(); + +#if GTEST_CAN_STREAM_RESULTS_ + // Initializes the event listener for streaming test results to a socket. + // Must not be called before InitGoogleTest. + void ConfigureStreamingOutput(); +#endif + + // Performs initialization dependent upon flag values obtained in + // ParseGoogleTestFlagsOnly. Is called from InitGoogleTest after the call to + // ParseGoogleTestFlagsOnly. In case a user neglects to call InitGoogleTest + // this function is also called from RunAllTests. Since this function can be + // called more than once, it has to be idempotent. + void PostFlagParsingInit(); + + // Gets the random seed used at the start of the current test iteration. + int random_seed() const { return random_seed_; } + + // Gets the random number generator. + internal::Random* random() { return &random_; } + + // Shuffles all test cases, and the tests within each test case, + // making sure that death tests are still run first. + void ShuffleTests(); + + // Restores the test cases and tests to their order before the first shuffle. + void UnshuffleTests(); + + // Returns the value of GTEST_FLAG(catch_exceptions) at the moment + // UnitTest::Run() starts. + bool catch_exceptions() const { return catch_exceptions_; } + + private: + friend class ::testing::UnitTest; + + // Used by UnitTest::Run() to capture the state of + // GTEST_FLAG(catch_exceptions) at the moment it starts. + void set_catch_exceptions(bool value) { catch_exceptions_ = value; } + + // The UnitTest object that owns this implementation object. + UnitTest* const parent_; + + // The working directory when the first TEST() or TEST_F() was + // executed. + internal::FilePath original_working_dir_; + + // The default test part result reporters. + DefaultGlobalTestPartResultReporter default_global_test_part_result_reporter_; + DefaultPerThreadTestPartResultReporter + default_per_thread_test_part_result_reporter_; + + // Points to (but doesn't own) the global test part result reporter. + TestPartResultReporterInterface* global_test_part_result_repoter_; + + // Protects read and write access to global_test_part_result_reporter_. + internal::Mutex global_test_part_result_reporter_mutex_; + + // Points to (but doesn't own) the per-thread test part result reporter. + internal::ThreadLocal + per_thread_test_part_result_reporter_; + + // The vector of environments that need to be set-up/torn-down + // before/after the tests are run. + std::vector environments_; + + // The vector of TestCases in their original order. It owns the + // elements in the vector. + std::vector test_cases_; + + // Provides a level of indirection for the test case list to allow + // easy shuffling and restoring the test case order. The i-th + // element of this vector is the index of the i-th test case in the + // shuffled order. + std::vector test_case_indices_; + +#if GTEST_HAS_PARAM_TEST + // ParameterizedTestRegistry object used to register value-parameterized + // tests. + internal::ParameterizedTestCaseRegistry parameterized_test_registry_; + + // Indicates whether RegisterParameterizedTests() has been called already. + bool parameterized_tests_registered_; +#endif // GTEST_HAS_PARAM_TEST + + // Index of the last death test case registered. Initially -1. + int last_death_test_case_; + + // This points to the TestCase for the currently running test. It + // changes as Google Test goes through one test case after another. + // When no test is running, this is set to NULL and Google Test + // stores assertion results in ad_hoc_test_result_. Initially NULL. + TestCase* current_test_case_; + + // This points to the TestInfo for the currently running test. It + // changes as Google Test goes through one test after another. When + // no test is running, this is set to NULL and Google Test stores + // assertion results in ad_hoc_test_result_. Initially NULL. + TestInfo* current_test_info_; + + // Normally, a user only writes assertions inside a TEST or TEST_F, + // or inside a function called by a TEST or TEST_F. Since Google + // Test keeps track of which test is current running, it can + // associate such an assertion with the test it belongs to. + // + // If an assertion is encountered when no TEST or TEST_F is running, + // Google Test attributes the assertion result to an imaginary "ad hoc" + // test, and records the result in ad_hoc_test_result_. + TestResult ad_hoc_test_result_; + + // The list of event listeners that can be used to track events inside + // Google Test. + TestEventListeners listeners_; + + // The OS stack trace getter. Will be deleted when the UnitTest + // object is destructed. By default, an OsStackTraceGetter is used, + // but the user can set this field to use a custom getter if that is + // desired. + OsStackTraceGetterInterface* os_stack_trace_getter_; + + // True iff PostFlagParsingInit() has been called. + bool post_flag_parse_init_performed_; + + // The random number seed used at the beginning of the test run. + int random_seed_; + + // Our random number generator. + internal::Random random_; + + // The time of the test program start, in ms from the start of the + // UNIX epoch. + TimeInMillis start_timestamp_; + + // How long the test took to run, in milliseconds. + TimeInMillis elapsed_time_; + +#if GTEST_HAS_DEATH_TEST + // The decomposed components of the gtest_internal_run_death_test flag, + // parsed when RUN_ALL_TESTS is called. + internal::scoped_ptr internal_run_death_test_flag_; + internal::scoped_ptr death_test_factory_; +#endif // GTEST_HAS_DEATH_TEST + + // A per-thread stack of traces created by the SCOPED_TRACE() macro. + internal::ThreadLocal > gtest_trace_stack_; + + // The value of GTEST_FLAG(catch_exceptions) at the moment RunAllTests() + // starts. + bool catch_exceptions_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl); +}; // class UnitTestImpl + +// Convenience function for accessing the global UnitTest +// implementation object. +inline UnitTestImpl* GetUnitTestImpl() { + return UnitTest::GetInstance()->impl(); +} + +#if GTEST_USES_SIMPLE_RE + +// Internal helper functions for implementing the simple regular +// expression matcher. +GTEST_API_ bool IsInSet(char ch, const char* str); +GTEST_API_ bool IsAsciiDigit(char ch); +GTEST_API_ bool IsAsciiPunct(char ch); +GTEST_API_ bool IsRepeat(char ch); +GTEST_API_ bool IsAsciiWhiteSpace(char ch); +GTEST_API_ bool IsAsciiWordChar(char ch); +GTEST_API_ bool IsValidEscape(char ch); +GTEST_API_ bool AtomMatchesChar(bool escaped, char pattern, char ch); +GTEST_API_ bool ValidateRegex(const char* regex); +GTEST_API_ bool MatchRegexAtHead(const char* regex, const char* str); +GTEST_API_ bool MatchRepetitionAndRegexAtHead( + bool escaped, char ch, char repeat, const char* regex, const char* str); +GTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str); + +#endif // GTEST_USES_SIMPLE_RE + +// Parses the command line for Google Test flags, without initializing +// other parts of Google Test. +GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, char** argv); +GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv); + +#if GTEST_HAS_DEATH_TEST + +// Returns the message describing the last system error, regardless of the +// platform. +GTEST_API_ std::string GetLastErrnoDescription(); + +# if GTEST_OS_WINDOWS +// Provides leak-safe Windows kernel handle ownership. +class AutoHandle { + public: + AutoHandle() : handle_(INVALID_HANDLE_VALUE) {} + explicit AutoHandle(HANDLE handle) : handle_(handle) {} + + ~AutoHandle() { Reset(); } + + HANDLE Get() const { return handle_; } + void Reset() { Reset(INVALID_HANDLE_VALUE); } + void Reset(HANDLE handle) { + if (handle != handle_) { + if (handle_ != INVALID_HANDLE_VALUE) + ::CloseHandle(handle_); + handle_ = handle; + } + } + + private: + HANDLE handle_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle); +}; +# endif // GTEST_OS_WINDOWS + +// Attempts to parse a string into a positive integer pointed to by the +// number parameter. Returns true if that is possible. +// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can use +// it here. +template +bool ParseNaturalNumber(const ::std::string& str, Integer* number) { + // Fail fast if the given string does not begin with a digit; + // this bypasses strtoXXX's "optional leading whitespace and plus + // or minus sign" semantics, which are undesirable here. + if (str.empty() || !IsDigit(str[0])) { + return false; + } + errno = 0; + + char* end; + // BiggestConvertible is the largest integer type that system-provided + // string-to-number conversion routines can return. + +# if GTEST_OS_WINDOWS && !defined(__GNUC__) + + // MSVC and C++ Builder define __int64 instead of the standard long long. + typedef unsigned __int64 BiggestConvertible; + const BiggestConvertible parsed = _strtoui64(str.c_str(), &end, 10); + +# else + + typedef unsigned long long BiggestConvertible; // NOLINT + const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10); + +# endif // GTEST_OS_WINDOWS && !defined(__GNUC__) + + const bool parse_success = *end == '\0' && errno == 0; + + // TODO(vladl@google.com): Convert this to compile time assertion when it is + // available. + GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed)); + + const Integer result = static_cast(parsed); + if (parse_success && static_cast(result) == parsed) { + *number = result; + return true; + } + return false; +} +#endif // GTEST_HAS_DEATH_TEST + +// TestResult contains some private methods that should be hidden from +// Google Test user but are required for testing. This class allow our tests +// to access them. +// +// This class is supplied only for the purpose of testing Google Test's own +// constructs. Do not use it in user tests, either directly or indirectly. +class TestResultAccessor { + public: + static void RecordProperty(TestResult* test_result, + const std::string& xml_element, + const TestProperty& property) { + test_result->RecordProperty(xml_element, property); + } + + static void ClearTestPartResults(TestResult* test_result) { + test_result->ClearTestPartResults(); + } + + static const std::vector& test_part_results( + const TestResult& test_result) { + return test_result.test_part_results(); + } +}; + +#if GTEST_CAN_STREAM_RESULTS_ + +// Streams test results to the given port on the given host machine. +class StreamingListener : public EmptyTestEventListener { + public: + // Abstract base class for writing strings to a socket. + class AbstractSocketWriter { + public: + virtual ~AbstractSocketWriter() {} + + // Sends a string to the socket. + virtual void Send(const string& message) = 0; + + // Closes the socket. + virtual void CloseConnection() {} + + // Sends a string and a newline to the socket. + void SendLn(const string& message) { + Send(message + "\n"); + } + }; + + // Concrete class for actually writing strings to a socket. + class SocketWriter : public AbstractSocketWriter { + public: + SocketWriter(const string& host, const string& port) + : sockfd_(-1), host_name_(host), port_num_(port) { + MakeConnection(); + } + + virtual ~SocketWriter() { + if (sockfd_ != -1) + CloseConnection(); + } + + // Sends a string to the socket. + virtual void Send(const string& message) { + GTEST_CHECK_(sockfd_ != -1) + << "Send() can be called only when there is a connection."; + + const int len = static_cast(message.length()); + if (write(sockfd_, message.c_str(), len) != len) { + GTEST_LOG_(WARNING) + << "stream_result_to: failed to stream to " + << host_name_ << ":" << port_num_; + } + } + + private: + // Creates a client socket and connects to the server. + void MakeConnection(); + + // Closes the socket. + void CloseConnection() { + GTEST_CHECK_(sockfd_ != -1) + << "CloseConnection() can be called only when there is a connection."; + + close(sockfd_); + sockfd_ = -1; + } + + int sockfd_; // socket file descriptor + const string host_name_; + const string port_num_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(SocketWriter); + }; // class SocketWriter + + // Escapes '=', '&', '%', and '\n' characters in str as "%xx". + static string UrlEncode(const char* str); + + StreamingListener(const string& host, const string& port) + : socket_writer_(new SocketWriter(host, port)) { Start(); } + + explicit StreamingListener(AbstractSocketWriter* socket_writer) + : socket_writer_(socket_writer) { Start(); } + + void OnTestProgramStart(const UnitTest& /* unit_test */) { + SendLn("event=TestProgramStart"); + } + + void OnTestProgramEnd(const UnitTest& unit_test) { + // Note that Google Test current only report elapsed time for each + // test iteration, not for the entire test program. + SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed())); + + // Notify the streaming server to stop. + socket_writer_->CloseConnection(); + } + + void OnTestIterationStart(const UnitTest& /* unit_test */, int iteration) { + SendLn("event=TestIterationStart&iteration=" + + StreamableToString(iteration)); + } + + void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration */) { + SendLn("event=TestIterationEnd&passed=" + + FormatBool(unit_test.Passed()) + "&elapsed_time=" + + StreamableToString(unit_test.elapsed_time()) + "ms"); + } + + void OnTestCaseStart(const TestCase& test_case) { + SendLn(std::string("event=TestCaseStart&name=") + test_case.name()); + } + + void OnTestCaseEnd(const TestCase& test_case) { + SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed()) + + "&elapsed_time=" + StreamableToString(test_case.elapsed_time()) + + "ms"); + } + + void OnTestStart(const TestInfo& test_info) { + SendLn(std::string("event=TestStart&name=") + test_info.name()); + } + + void OnTestEnd(const TestInfo& test_info) { + SendLn("event=TestEnd&passed=" + + FormatBool((test_info.result())->Passed()) + + "&elapsed_time=" + + StreamableToString((test_info.result())->elapsed_time()) + "ms"); + } + + void OnTestPartResult(const TestPartResult& test_part_result) { + const char* file_name = test_part_result.file_name(); + if (file_name == NULL) + file_name = ""; + SendLn("event=TestPartResult&file=" + UrlEncode(file_name) + + "&line=" + StreamableToString(test_part_result.line_number()) + + "&message=" + UrlEncode(test_part_result.message())); + } + + private: + // Sends the given message and a newline to the socket. + void SendLn(const string& message) { socket_writer_->SendLn(message); } + + // Called at the start of streaming to notify the receiver what + // protocol we are using. + void Start() { SendLn("gtest_streaming_protocol_version=1.0"); } + + string FormatBool(bool value) { return value ? "1" : "0"; } + + const scoped_ptr socket_writer_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener); +}; // class StreamingListener + +#endif // GTEST_CAN_STREAM_RESULTS_ + +} // namespace internal +} // namespace testing + +#endif // GTEST_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& 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)) + should_handle = false; + else if (exception_code == EXCEPTION_BREAKPOINT) + should_handle = false; + else if (exception_code == kCxxExceptionCode) + should_handle = false; + + return should_handle ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH; +} +#endif // GTEST_HAS_SEH + +} // namespace internal + +// 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. Intercepts only failures from the current thread. +ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter( + TestPartResultArray* result) + : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD), + result_(result) { + Init(); +} + +// 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. +ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter( + InterceptMode intercept_mode, TestPartResultArray* result) + : intercept_mode_(intercept_mode), + result_(result) { + Init(); +} + +void ScopedFakeTestPartResultReporter::Init() { + internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); + if (intercept_mode_ == INTERCEPT_ALL_THREADS) { + old_reporter_ = impl->GetGlobalTestPartResultReporter(); + impl->SetGlobalTestPartResultReporter(this); + } else { + old_reporter_ = impl->GetTestPartResultReporterForCurrentThread(); + impl->SetTestPartResultReporterForCurrentThread(this); + } +} + +// The d'tor restores the test part result reporter used by Google Test +// before. +ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() { + internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); + if (intercept_mode_ == INTERCEPT_ALL_THREADS) { + impl->SetGlobalTestPartResultReporter(old_reporter_); + } else { + impl->SetTestPartResultReporterForCurrentThread(old_reporter_); + } +} + +// Increments the test part result count and remembers the result. +// This method is from the TestPartResultReporterInterface interface. +void ScopedFakeTestPartResultReporter::ReportTestPartResult( + const TestPartResult& result) { + result_->Append(result); +} + +namespace internal { + +// Returns the type ID of ::testing::Test. We should always call this +// instead of GetTypeId< ::testing::Test>() to get the type ID of +// testing::Test. This is to work around a suspected linker bug when +// using Google Test as a framework on Mac OS X. The bug causes +// GetTypeId< ::testing::Test>() to return different values depending +// on whether the call is from the Google Test framework itself or +// from user test code. GetTestTypeId() is guaranteed to always +// return the same value, as it always calls GetTypeId<>() from the +// gtest.cc, which is within the Google Test framework. +TypeId GetTestTypeId() { + return GetTypeId(); +} + +// The value of GetTestTypeId() as seen from within the Google Test +// library. This is solely for testing GetTestTypeId(). +extern const TypeId kTestTypeIdInGoogleTest = GetTestTypeId(); + +// This predicate-formatter checks that 'results' contains a test part +// failure of the given type and that the failure message contains the +// given substring. +AssertionResult HasOneFailure(const char* /* results_expr */, + const char* /* type_expr */, + const char* /* substr_expr */, + const TestPartResultArray& results, + TestPartResult::Type type, + const string& substr) { + const std::string expected(type == TestPartResult::kFatalFailure ? + "1 fatal failure" : + "1 non-fatal failure"); + Message msg; + if (results.size() != 1) { + msg << "Expected: " << expected << "\n" + << " Actual: " << results.size() << " failures"; + for (int i = 0; i < results.size(); i++) { + msg << "\n" << results.GetTestPartResult(i); + } + return AssertionFailure() << msg; + } + + const TestPartResult& r = results.GetTestPartResult(0); + if (r.type() != type) { + return AssertionFailure() << "Expected: " << expected << "\n" + << " Actual:\n" + << r; + } + + if (strstr(r.message(), substr.c_str()) == NULL) { + return AssertionFailure() << "Expected: " << expected << " containing \"" + << substr << "\"\n" + << " Actual:\n" + << r; + } + + return AssertionSuccess(); +} + +// The constructor of SingleFailureChecker remembers where to look up +// test part results, what type of failure we expect, and what +// substring the failure message should contain. +SingleFailureChecker:: SingleFailureChecker( + const TestPartResultArray* results, + TestPartResult::Type type, + const string& substr) + : results_(results), + type_(type), + substr_(substr) {} + +// The destructor of SingleFailureChecker 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. +SingleFailureChecker::~SingleFailureChecker() { + EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_); +} + +DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter( + UnitTestImpl* unit_test) : unit_test_(unit_test) {} + +void DefaultGlobalTestPartResultReporter::ReportTestPartResult( + const TestPartResult& result) { + unit_test_->current_test_result()->AddTestPartResult(result); + unit_test_->listeners()->repeater()->OnTestPartResult(result); +} + +DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter( + UnitTestImpl* unit_test) : unit_test_(unit_test) {} + +void DefaultPerThreadTestPartResultReporter::ReportTestPartResult( + const TestPartResult& result) { + unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result); +} + +// Returns the global test part result reporter. +TestPartResultReporterInterface* +UnitTestImpl::GetGlobalTestPartResultReporter() { + internal::MutexLock lock(&global_test_part_result_reporter_mutex_); + return global_test_part_result_repoter_; +} + +// Sets the global test part result reporter. +void UnitTestImpl::SetGlobalTestPartResultReporter( + TestPartResultReporterInterface* reporter) { + internal::MutexLock lock(&global_test_part_result_reporter_mutex_); + global_test_part_result_repoter_ = reporter; +} + +// Returns the test part result reporter for the current thread. +TestPartResultReporterInterface* +UnitTestImpl::GetTestPartResultReporterForCurrentThread() { + return per_thread_test_part_result_reporter_.get(); +} + +// Sets the test part result reporter for the current thread. +void UnitTestImpl::SetTestPartResultReporterForCurrentThread( + TestPartResultReporterInterface* reporter) { + per_thread_test_part_result_reporter_.set(reporter); +} + +// Gets the number of successful test cases. +int UnitTestImpl::successful_test_case_count() const { + return CountIf(test_cases_, TestCasePassed); +} + +// Gets the number of failed test cases. +int UnitTestImpl::failed_test_case_count() const { + return CountIf(test_cases_, TestCaseFailed); +} + +// Gets the number of all test cases. +int UnitTestImpl::total_test_case_count() const { + return static_cast(test_cases_.size()); +} + +// Gets the number of all test cases that contain at least one test +// that should run. +int UnitTestImpl::test_case_to_run_count() const { + return CountIf(test_cases_, ShouldRunTestCase); +} + +// Gets the number of successful tests. +int UnitTestImpl::successful_test_count() const { + return SumOverTestCaseList(test_cases_, &TestCase::successful_test_count); +} + +// Gets the number of failed tests. +int UnitTestImpl::failed_test_count() const { + return SumOverTestCaseList(test_cases_, &TestCase::failed_test_count); +} + +// Gets the number of disabled tests that will be reported in the XML report. +int UnitTestImpl::reportable_disabled_test_count() const { + return SumOverTestCaseList(test_cases_, + &TestCase::reportable_disabled_test_count); +} + +// Gets the number of disabled tests. +int UnitTestImpl::disabled_test_count() const { + return SumOverTestCaseList(test_cases_, &TestCase::disabled_test_count); +} + +// Gets the number of tests to be printed in the XML report. +int UnitTestImpl::reportable_test_count() const { + return SumOverTestCaseList(test_cases_, &TestCase::reportable_test_count); +} + +// Gets the number of all tests. +int UnitTestImpl::total_test_count() const { + return SumOverTestCaseList(test_cases_, &TestCase::total_test_count); +} + +// Gets the number of tests that should run. +int UnitTestImpl::test_to_run_count() const { + return SumOverTestCaseList(test_cases_, &TestCase::test_to_run_count); +} + +// Returns the current OS stack trace as an std::string. +// +// The maximum number of stack frames to be included is specified by +// the gtest_stack_trace_depth flag. The skip_count parameter +// specifies the number of top frames to be skipped, which doesn't +// count against the number of frames to be included. +// +// For example, if Foo() calls Bar(), which in turn calls +// CurrentOsStackTraceExceptTop(1), Foo() will be included in the +// trace but Bar() and CurrentOsStackTraceExceptTop() won't. +std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) { + (void)skip_count; + return ""; +} + +// Returns the current time in milliseconds. +TimeInMillis GetTimeInMillis() { +#if GTEST_OS_WINDOWS_MOBILE || defined(__BORLANDC__) + // Difference between 1970-01-01 and 1601-01-01 in milliseconds. + // http://analogous.blogspot.com/2005/04/epoch.html + const TimeInMillis kJavaEpochToWinFileTimeDelta = + static_cast(116444736UL) * 100000UL; + const DWORD kTenthMicrosInMilliSecond = 10000; + + SYSTEMTIME now_systime; + FILETIME now_filetime; + ULARGE_INTEGER now_int64; + // TODO(kenton@google.com): Shouldn't this just use + // GetSystemTimeAsFileTime()? + GetSystemTime(&now_systime); + if (SystemTimeToFileTime(&now_systime, &now_filetime)) { + now_int64.LowPart = now_filetime.dwLowDateTime; + now_int64.HighPart = now_filetime.dwHighDateTime; + now_int64.QuadPart = (now_int64.QuadPart / kTenthMicrosInMilliSecond) - + kJavaEpochToWinFileTimeDelta; + return now_int64.QuadPart; + } + return 0; +#elif GTEST_OS_WINDOWS && !GTEST_HAS_GETTIMEOFDAY_ + __timeb64 now; + +# ifdef _MSC_VER + + // MSVC 8 deprecates _ftime64(), so we want to suppress warning 4996 + // (deprecated function) there. + // TODO(kenton@google.com): Use GetTickCount()? Or use + // SystemTimeToFileTime() +# pragma warning(push) // Saves the current warning state. +# pragma warning(disable:4996) // Temporarily disables warning 4996. + _ftime64(&now); +# pragma warning(pop) // Restores the warning state. +# else + + _ftime64(&now); + +# endif // _MSC_VER + + return static_cast(now.time) * 1000 + now.millitm; +#elif GTEST_HAS_GETTIMEOFDAY_ + struct timeval now; + gettimeofday(&now, NULL); + return static_cast(now.tv_sec) * 1000 + now.tv_usec / 1000; +#else +# error "Don't know how to get the current time on your system." +#endif +} + +// Utilities + +// class String. + +#if GTEST_OS_WINDOWS_MOBILE +// Creates a UTF-16 wide string from the given ANSI string, allocating +// memory using new. The caller is responsible for deleting the return +// value using delete[]. Returns the wide string, or NULL if the +// input is NULL. +LPCWSTR String::AnsiToUtf16(const char* ansi) { + if (!ansi) return NULL; + const int length = strlen(ansi); + const int unicode_length = + MultiByteToWideChar(CP_ACP, 0, ansi, length, + NULL, 0); + WCHAR* unicode = new WCHAR[unicode_length + 1]; + MultiByteToWideChar(CP_ACP, 0, ansi, length, + unicode, unicode_length); + unicode[unicode_length] = 0; + return unicode; +} + +// Creates an ANSI string from the given wide string, allocating +// memory using new. The caller is responsible for deleting the return +// value using delete[]. Returns the ANSI string, or NULL if the +// input is NULL. +const char* String::Utf16ToAnsi(LPCWSTR utf16_str) { + if (!utf16_str) return NULL; + const int ansi_length = + WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, + NULL, 0, NULL, NULL); + char* ansi = new char[ansi_length + 1]; + WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, + ansi, ansi_length, NULL, NULL); + ansi[ansi_length] = 0; + return ansi; +} + +#endif // GTEST_OS_WINDOWS_MOBILE + +// Compares two C strings. Returns true iff they have the same content. +// +// Unlike strcmp(), this function can handle NULL argument(s). A NULL +// C string is considered different to any non-NULL C string, +// including the empty string. +bool String::CStringEquals(const char * lhs, const char * rhs) { + if ( lhs == NULL ) return rhs == NULL; + + if ( rhs == NULL ) return false; + + return strcmp(lhs, rhs) == 0; +} + +#if GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING + +// Converts an array of wide chars to a narrow string using the UTF-8 +// encoding, and streams the result to the given Message object. +static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length, + Message* msg) { + for (size_t i = 0; i != length; ) { // NOLINT + if (wstr[i] != L'\0') { + *msg << WideStringToUtf8(wstr + i, static_cast(length - i)); + while (i != length && wstr[i] != L'\0') + i++; + } else { + *msg << '\0'; + i++; + } + } +} + +#endif // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING + +} // namespace internal + +// Constructs an empty Message. +// We allocate the stringstream separately because otherwise each use of +// ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's +// stack frame leading to huge stack frames in some cases; gcc does not reuse +// the stack space. +Message::Message() : ss_(new ::std::stringstream) { + // By default, we want there to be enough precision when printing + // a double to a Message. + *ss_ << std::setprecision(std::numeric_limits::digits10 + 2); +} + +// These two overloads allow streaming a wide C string to a Message +// using the UTF-8 encoding. +Message& Message::operator <<(const wchar_t* wide_c_str) { + return *this << internal::String::ShowWideCString(wide_c_str); +} +Message& Message::operator <<(wchar_t* wide_c_str) { + return *this << internal::String::ShowWideCString(wide_c_str); +} + +#if GTEST_HAS_STD_WSTRING +// Converts the given wide string to a narrow string using the UTF-8 +// encoding, and streams the result to this Message object. +Message& Message::operator <<(const ::std::wstring& wstr) { + internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this); + return *this; +} +#endif // GTEST_HAS_STD_WSTRING + +#if GTEST_HAS_GLOBAL_WSTRING +// Converts the given wide string to a narrow string using the UTF-8 +// encoding, and streams the result to this Message object. +Message& Message::operator <<(const ::wstring& wstr) { + internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this); + return *this; +} +#endif // GTEST_HAS_GLOBAL_WSTRING + +// Gets the text streamed to this object so far as an std::string. +// Each '\0' character in the buffer is replaced with "\\0". +std::string Message::GetString() const { + return internal::StringStreamToString(ss_.get()); +} + +// AssertionResult constructors. +// Used in EXPECT_TRUE/FALSE(assertion_result). +AssertionResult::AssertionResult(const AssertionResult& other) + : success_(other.success_), + message_(other.message_.get() != NULL ? + new ::std::string(*other.message_) : + static_cast< ::std::string*>(NULL)) { +} + +// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE. +AssertionResult AssertionResult::operator!() const { + AssertionResult negation(!success_); + if (message_.get() != NULL) + negation << *message_; + return negation; +} + +// Makes a successful assertion result. +AssertionResult AssertionSuccess() { + return AssertionResult(true); +} + +// Makes a failed assertion result. +AssertionResult AssertionFailure() { + return AssertionResult(false); +} + +// Makes a failed assertion result with the given failure message. +// Deprecated; use AssertionFailure() << message. +AssertionResult AssertionFailure(const Message& message) { + return AssertionFailure() << message; +} + +namespace internal { + +// Constructs and returns the message for an equality assertion +// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure. +// +// The first four parameters are the expressions used in the assertion +// and their values, as strings. For example, for ASSERT_EQ(foo, bar) +// where foo is 5 and bar is 6, we have: +// +// expected_expression: "foo" +// actual_expression: "bar" +// expected_value: "5" +// actual_value: "6" +// +// The ignoring_case parameter is true iff the assertion is a +// *_STRCASEEQ*. When it's true, the string " (ignoring case)" will +// be inserted into the message. +AssertionResult EqFailure(const char* expected_expression, + const char* actual_expression, + const std::string& expected_value, + const std::string& actual_value, + bool ignoring_case) { + Message msg; + msg << "Value of: " << actual_expression; + if (actual_value != actual_expression) { + msg << "\n Actual: " << actual_value; + } + + msg << "\nExpected: " << expected_expression; + if (ignoring_case) { + msg << " (ignoring case)"; + } + if (expected_value != expected_expression) { + msg << "\nWhich is: " << expected_value; + } + + return AssertionFailure() << msg; +} + +// Constructs a failure message for Boolean assertions such as EXPECT_TRUE. +std::string GetBoolAssertionFailureMessage( + const AssertionResult& assertion_result, + const char* expression_text, + const char* actual_predicate_value, + const char* expected_predicate_value) { + const char* actual_message = assertion_result.message(); + Message msg; + msg << "Value of: " << expression_text + << "\n Actual: " << actual_predicate_value; + if (actual_message[0] != '\0') + msg << " (" << actual_message << ")"; + msg << "\nExpected: " << expected_predicate_value; + return msg.GetString(); +} + +// Helper function for implementing ASSERT_NEAR. +AssertionResult DoubleNearPredFormat(const char* expr1, + const char* expr2, + const char* abs_error_expr, + double val1, + double val2, + double abs_error) { + const double diff = fabs(val1 - val2); + if (diff <= abs_error) return AssertionSuccess(); + + // TODO(wan): do not print the value of an expression if it's + // already a literal. + return AssertionFailure() + << "The difference between " << expr1 << " and " << expr2 + << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n" + << expr1 << " evaluates to " << val1 << ",\n" + << expr2 << " evaluates to " << val2 << ", and\n" + << abs_error_expr << " evaluates to " << abs_error << "."; +} + + +// Helper template for implementing FloatLE() and DoubleLE(). +template +AssertionResult FloatingPointLE(const char* expr1, + const char* expr2, + RawType val1, + RawType val2) { + // Returns success if val1 is less than val2, + if (val1 < val2) { + return AssertionSuccess(); + } + + // or if val1 is almost equal to val2. + const FloatingPoint lhs(val1), rhs(val2); + if (lhs.AlmostEquals(rhs)) { + return AssertionSuccess(); + } + + // Note that the above two checks will both fail if either val1 or + // val2 is NaN, as the IEEE floating-point standard requires that + // any predicate involving a NaN must return false. + + ::std::stringstream val1_ss; + val1_ss << std::setprecision(std::numeric_limits::digits10 + 2) + << val1; + + ::std::stringstream val2_ss; + val2_ss << std::setprecision(std::numeric_limits::digits10 + 2) + << val2; + + return AssertionFailure() + << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n" + << " Actual: " << StringStreamToString(&val1_ss) << " vs " + << StringStreamToString(&val2_ss); +} + +} // namespace internal + +// Asserts that val1 is less than, or almost equal to, val2. Fails +// otherwise. In particular, it fails if either val1 or val2 is NaN. +AssertionResult FloatLE(const char* expr1, const char* expr2, + float val1, float val2) { + return internal::FloatingPointLE(expr1, expr2, val1, val2); +} + +// Asserts that val1 is less than, or almost equal to, val2. Fails +// otherwise. In particular, it fails if either val1 or val2 is NaN. +AssertionResult DoubleLE(const char* expr1, const char* expr2, + double val1, double val2) { + return internal::FloatingPointLE(expr1, expr2, val1, val2); +} + +namespace internal { + +// The helper function for {ASSERT|EXPECT}_EQ with int or enum +// arguments. +AssertionResult CmpHelperEQ(const char* expected_expression, + const char* actual_expression, + BiggestInt expected, + BiggestInt actual) { + if (expected == actual) { + return AssertionSuccess(); + } + + return EqFailure(expected_expression, + actual_expression, + FormatForComparisonFailureMessage(expected, actual), + FormatForComparisonFailureMessage(actual, expected), + false); +} + +// A macro for implementing the helper functions needed to implement +// ASSERT_?? and EXPECT_?? with integer or enum arguments. It is here +// just to avoid copy-and-paste of similar code. +#define GTEST_IMPL_CMP_HELPER_(op_name, op)\ +AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ + BiggestInt val1, BiggestInt val2) {\ + if (val1 op val2) {\ + return AssertionSuccess();\ + } else {\ + return AssertionFailure() \ + << "Expected: (" << expr1 << ") " #op " (" << expr2\ + << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\ + << " vs " << FormatForComparisonFailureMessage(val2, val1);\ + }\ +} + +// Implements the helper function for {ASSERT|EXPECT}_NE with int or +// enum arguments. +GTEST_IMPL_CMP_HELPER_(NE, !=) +// Implements the helper function for {ASSERT|EXPECT}_LE with int or +// enum arguments. +GTEST_IMPL_CMP_HELPER_(LE, <=) +// Implements the helper function for {ASSERT|EXPECT}_LT with int or +// enum arguments. +GTEST_IMPL_CMP_HELPER_(LT, < ) +// Implements the helper function for {ASSERT|EXPECT}_GE with int or +// enum arguments. +GTEST_IMPL_CMP_HELPER_(GE, >=) +// Implements the helper function for {ASSERT|EXPECT}_GT with int or +// enum arguments. +GTEST_IMPL_CMP_HELPER_(GT, > ) + +#undef GTEST_IMPL_CMP_HELPER_ + +// The helper function for {ASSERT|EXPECT}_STREQ. +AssertionResult CmpHelperSTREQ(const char* expected_expression, + const char* actual_expression, + const char* expected, + const char* actual) { + if (String::CStringEquals(expected, actual)) { + return AssertionSuccess(); + } + + return EqFailure(expected_expression, + actual_expression, + PrintToString(expected), + PrintToString(actual), + false); +} + +// The helper function for {ASSERT|EXPECT}_STRCASEEQ. +AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression, + const char* actual_expression, + const char* expected, + const char* actual) { + if (String::CaseInsensitiveCStringEquals(expected, actual)) { + return AssertionSuccess(); + } + + return EqFailure(expected_expression, + actual_expression, + PrintToString(expected), + PrintToString(actual), + true); +} + +// The helper function for {ASSERT|EXPECT}_STRNE. +AssertionResult CmpHelperSTRNE(const char* s1_expression, + const char* s2_expression, + const char* s1, + const char* s2) { + if (!String::CStringEquals(s1, s2)) { + return AssertionSuccess(); + } else { + return AssertionFailure() << "Expected: (" << s1_expression << ") != (" + << s2_expression << "), actual: \"" + << s1 << "\" vs \"" << s2 << "\""; + } +} + +// The helper function for {ASSERT|EXPECT}_STRCASENE. +AssertionResult CmpHelperSTRCASENE(const char* s1_expression, + const char* s2_expression, + const char* s1, + const char* s2) { + if (!String::CaseInsensitiveCStringEquals(s1, s2)) { + return AssertionSuccess(); + } else { + return AssertionFailure() + << "Expected: (" << s1_expression << ") != (" + << s2_expression << ") (ignoring case), actual: \"" + << s1 << "\" vs \"" << s2 << "\""; + } +} + +} // namespace internal + +namespace { + +// Helper functions for implementing IsSubString() and IsNotSubstring(). + +// This group of overloaded functions return true iff needle is a +// substring of haystack. NULL is considered a substring of itself +// only. + +bool IsSubstringPred(const char* needle, const char* haystack) { + if (needle == NULL || haystack == NULL) + return needle == haystack; + + return strstr(haystack, needle) != NULL; +} + +bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) { + if (needle == NULL || haystack == NULL) + return needle == haystack; + + return wcsstr(haystack, needle) != NULL; +} + +// StringType here can be either ::std::string or ::std::wstring. +template +bool IsSubstringPred(const StringType& needle, + const StringType& haystack) { + return haystack.find(needle) != StringType::npos; +} + +// This function implements either IsSubstring() or IsNotSubstring(), +// depending on the value of the expected_to_be_substring parameter. +// StringType here can be const char*, const wchar_t*, ::std::string, +// or ::std::wstring. +template +AssertionResult IsSubstringImpl( + bool expected_to_be_substring, + const char* needle_expr, const char* haystack_expr, + const StringType& needle, const StringType& haystack) { + if (IsSubstringPred(needle, haystack) == expected_to_be_substring) + return AssertionSuccess(); + + const bool is_wide_string = sizeof(needle[0]) > 1; + const char* const begin_string_quote = is_wide_string ? "L\"" : "\""; + return AssertionFailure() + << "Value of: " << needle_expr << "\n" + << " Actual: " << begin_string_quote << needle << "\"\n" + << "Expected: " << (expected_to_be_substring ? "" : "not ") + << "a substring of " << haystack_expr << "\n" + << "Which is: " << begin_string_quote << haystack << "\""; +} + +} // namespace + +// IsSubstring() and IsNotSubstring() check whether needle is a +// substring of haystack (NULL is considered a substring of itself +// only), and return an appropriate error message when they fail. + +AssertionResult IsSubstring( + const char* needle_expr, const char* haystack_expr, + const char* needle, const char* haystack) { + return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); +} + +AssertionResult IsSubstring( + const char* needle_expr, const char* haystack_expr, + const wchar_t* needle, const wchar_t* haystack) { + return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); +} + +AssertionResult IsNotSubstring( + const char* needle_expr, const char* haystack_expr, + const char* needle, const char* haystack) { + return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); +} + +AssertionResult IsNotSubstring( + const char* needle_expr, const char* haystack_expr, + const wchar_t* needle, const wchar_t* haystack) { + return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); +} + +AssertionResult IsSubstring( + const char* needle_expr, const char* haystack_expr, + const ::std::string& needle, const ::std::string& haystack) { + return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); +} + +AssertionResult IsNotSubstring( + const char* needle_expr, const char* haystack_expr, + const ::std::string& needle, const ::std::string& haystack) { + return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); +} + +#if GTEST_HAS_STD_WSTRING +AssertionResult IsSubstring( + const char* needle_expr, const char* haystack_expr, + const ::std::wstring& needle, const ::std::wstring& haystack) { + return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); +} + +AssertionResult IsNotSubstring( + const char* needle_expr, const char* haystack_expr, + const ::std::wstring& needle, const ::std::wstring& haystack) { + return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); +} +#endif // GTEST_HAS_STD_WSTRING + +namespace internal { + +#if GTEST_OS_WINDOWS + +namespace { + +// Helper function for IsHRESULT{SuccessFailure} predicates +AssertionResult HRESULTFailureHelper(const char* expr, + const char* expected, + long hr) { // NOLINT +# if GTEST_OS_WINDOWS_MOBILE + + // Windows CE doesn't support FormatMessage. + const char error_text[] = ""; + +# else + + // Looks up the human-readable system message for the HRESULT code + // and since we're not passing any params to FormatMessage, we don't + // want inserts expanded. + const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS; + const DWORD kBufSize = 4096; + // Gets the system's human readable message string for this HRESULT. + char error_text[kBufSize] = { '\0' }; + DWORD message_length = ::FormatMessageA(kFlags, + 0, // no source, we're asking system + hr, // the error + 0, // no line width restrictions + error_text, // output buffer + kBufSize, // buf size + NULL); // no arguments for inserts + // Trims tailing white space (FormatMessage leaves a trailing CR-LF) + for (; message_length && IsSpace(error_text[message_length - 1]); + --message_length) { + error_text[message_length - 1] = '\0'; + } + +# endif // GTEST_OS_WINDOWS_MOBILE + + const std::string error_hex("0x" + String::FormatHexInt(hr)); + return ::testing::AssertionFailure() + << "Expected: " << expr << " " << expected << ".\n" + << " Actual: " << error_hex << " " << error_text << "\n"; +} + +} // namespace + +AssertionResult IsHRESULTSuccess(const char* expr, long hr) { // NOLINT + if (SUCCEEDED(hr)) { + return AssertionSuccess(); + } + return HRESULTFailureHelper(expr, "succeeds", hr); +} + +AssertionResult IsHRESULTFailure(const char* expr, long hr) { // NOLINT + if (FAILED(hr)) { + return AssertionSuccess(); + } + return HRESULTFailureHelper(expr, "fails", hr); +} + +#endif // GTEST_OS_WINDOWS + +// Utility functions for encoding Unicode text (wide strings) in +// UTF-8. + +// A Unicode code-point can have upto 21 bits, and is encoded in UTF-8 +// like this: +// +// Code-point length Encoding +// 0 - 7 bits 0xxxxxxx +// 8 - 11 bits 110xxxxx 10xxxxxx +// 12 - 16 bits 1110xxxx 10xxxxxx 10xxxxxx +// 17 - 21 bits 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx + +// The maximum code-point a one-byte UTF-8 sequence can represent. +const UInt32 kMaxCodePoint1 = (static_cast(1) << 7) - 1; + +// The maximum code-point a two-byte UTF-8 sequence can represent. +const UInt32 kMaxCodePoint2 = (static_cast(1) << (5 + 6)) - 1; + +// The maximum code-point a three-byte UTF-8 sequence can represent. +const UInt32 kMaxCodePoint3 = (static_cast(1) << (4 + 2*6)) - 1; + +// The maximum code-point a four-byte UTF-8 sequence can represent. +const UInt32 kMaxCodePoint4 = (static_cast(1) << (3 + 3*6)) - 1; + +// Chops off the n lowest bits from a bit pattern. Returns the n +// lowest bits. As a side effect, the original bit pattern will be +// shifted to the right by n bits. +inline UInt32 ChopLowBits(UInt32* bits, int n) { + const UInt32 low_bits = *bits & ((static_cast(1) << n) - 1); + *bits >>= n; + return low_bits; +} + +// 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)". +std::string CodePointToUtf8(UInt32 code_point) { + if (code_point > kMaxCodePoint4) { + return "(Invalid Unicode 0x" + String::FormatHexInt(code_point) + ")"; + } + + char str[5]; // Big enough for the largest valid code point. + if (code_point <= kMaxCodePoint1) { + str[1] = '\0'; + str[0] = static_cast(code_point); // 0xxxxxxx + } else if (code_point <= kMaxCodePoint2) { + str[2] = '\0'; + str[1] = static_cast(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx + str[0] = static_cast(0xC0 | code_point); // 110xxxxx + } else if (code_point <= kMaxCodePoint3) { + str[3] = '\0'; + str[2] = static_cast(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx + str[1] = static_cast(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx + str[0] = static_cast(0xE0 | code_point); // 1110xxxx + } else { // code_point <= kMaxCodePoint4 + str[4] = '\0'; + str[3] = static_cast(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx + str[2] = static_cast(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx + str[1] = static_cast(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx + str[0] = static_cast(0xF0 | code_point); // 11110xxx + } + return str; +} + +// The following two functions only make sense if the the system +// uses UTF-16 for wide string encoding. All supported systems +// with 16 bit wchar_t (Windows, Cygwin, Symbian OS) do use UTF-16. + +// Determines if the arguments constitute UTF-16 surrogate pair +// and thus should be combined into a single Unicode code point +// using CreateCodePointFromUtf16SurrogatePair. +inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) { + return sizeof(wchar_t) == 2 && + (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00; +} + +// Creates a Unicode code point from UTF16 surrogate pair. +inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first, + wchar_t second) { + const UInt32 mask = (1 << 10) - 1; + return (sizeof(wchar_t) == 2) ? + (((first & mask) << 10) | (second & mask)) + 0x10000 : + // This function should not be called when the condition is + // false, but we provide a sensible default in case it is. + static_cast(first); +} + +// 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, Symbian OS) +// 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. +std::string WideStringToUtf8(const wchar_t* str, int num_chars) { + if (num_chars == -1) + num_chars = static_cast(wcslen(str)); + + ::std::stringstream stream; + for (int i = 0; i < num_chars; ++i) { + UInt32 unicode_code_point; + + if (str[i] == L'\0') { + break; + } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) { + unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i], + str[i + 1]); + i++; + } else { + unicode_code_point = static_cast(str[i]); + } + + stream << CodePointToUtf8(unicode_code_point); + } + return StringStreamToString(&stream); +} + +// Converts a wide C string to an std::string using the UTF-8 encoding. +// NULL will be converted to "(null)". +std::string String::ShowWideCString(const wchar_t * wide_c_str) { + if (wide_c_str == NULL) return "(null)"; + + return internal::WideStringToUtf8(wide_c_str, -1); +} + +// Compares two wide C strings. Returns true iff they have the same +// content. +// +// Unlike wcscmp(), this function can handle NULL argument(s). A NULL +// C string is considered different to any non-NULL C string, +// including the empty string. +bool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) { + if (lhs == NULL) return rhs == NULL; + + if (rhs == NULL) return false; + + return wcscmp(lhs, rhs) == 0; +} + +// Helper function for *_STREQ on wide strings. +AssertionResult CmpHelperSTREQ(const char* expected_expression, + const char* actual_expression, + const wchar_t* expected, + const wchar_t* actual) { + if (String::WideCStringEquals(expected, actual)) { + return AssertionSuccess(); + } + + return EqFailure(expected_expression, + actual_expression, + PrintToString(expected), + PrintToString(actual), + false); +} + +// Helper function for *_STRNE on wide strings. +AssertionResult CmpHelperSTRNE(const char* s1_expression, + const char* s2_expression, + const wchar_t* s1, + const wchar_t* s2) { + if (!String::WideCStringEquals(s1, s2)) { + return AssertionSuccess(); + } + + return AssertionFailure() << "Expected: (" << s1_expression << ") != (" + << s2_expression << "), actual: " + << PrintToString(s1) + << " vs " << PrintToString(s2); +} + +// Compares two C strings, ignoring case. Returns true iff they have +// the same content. +// +// Unlike strcasecmp(), this function can handle NULL argument(s). A +// NULL C string is considered different to any non-NULL C string, +// including the empty string. +bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) { + if (lhs == NULL) + return rhs == NULL; + if (rhs == NULL) + return false; + return posix::StrCaseCmp(lhs, rhs) == 0; +} + + // Compares two wide C strings, ignoring case. Returns true iff they + // have the same content. + // + // Unlike wcscasecmp(), this function can handle NULL argument(s). + // A NULL C string is considered different to any non-NULL wide C string, + // including the empty string. + // NB: The implementations on different platforms slightly differ. + // On windows, this method uses _wcsicmp which compares according to LC_CTYPE + // environment variable. On GNU platform this method uses wcscasecmp + // which compares according to LC_CTYPE category of the current locale. + // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the + // current locale. +bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs, + const wchar_t* rhs) { + if (lhs == NULL) return rhs == NULL; + + if (rhs == NULL) return false; + +#if GTEST_OS_WINDOWS + return _wcsicmp(lhs, rhs) == 0; +#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID + return wcscasecmp(lhs, rhs) == 0; +#else + // Android, Mac OS X and Cygwin don't define wcscasecmp. + // Other unknown OSes may not define it either. + wint_t left, right; + do { + left = towlower(*lhs++); + right = towlower(*rhs++); + } while (left && left == right); + return left == right; +#endif // OS selector +} + +// Returns true iff str ends with the given suffix, ignoring case. +// Any string is considered to end with an empty suffix. +bool String::EndsWithCaseInsensitive( + const std::string& str, const std::string& suffix) { + const size_t str_len = str.length(); + const size_t suffix_len = suffix.length(); + return (str_len >= suffix_len) && + CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len, + suffix.c_str()); +} + +// Formats an int value as "%02d". +std::string String::FormatIntWidth2(int value) { + std::stringstream ss; + ss << std::setfill('0') << std::setw(2) << value; + return ss.str(); +} + +// Formats an int value as "%X". +std::string String::FormatHexInt(int value) { + std::stringstream ss; + ss << std::hex << std::uppercase << value; + return ss.str(); +} + +// Formats a byte as "%02X". +std::string String::FormatByte(unsigned char value) { + std::stringstream ss; + ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase + << static_cast(value); + return ss.str(); +} + +// Converts the buffer in a stringstream to an std::string, converting NUL +// bytes to "\\0" along the way. +std::string StringStreamToString(::std::stringstream* ss) { + const ::std::string& str = ss->str(); + const char* const start = str.c_str(); + const char* const end = start + str.length(); + + std::string result; + result.reserve(2 * (end - start)); + for (const char* ch = start; ch != end; ++ch) { + if (*ch == '\0') { + result += "\\0"; // Replaces NUL with "\\0"; + } else { + result += *ch; + } + } + + return result; +} + +// Appends the user-supplied message to the Google-Test-generated message. +std::string AppendUserMessage(const std::string& gtest_msg, + const Message& user_msg) { + // Appends the user message if it's non-empty. + const std::string user_msg_string = user_msg.GetString(); + if (user_msg_string.empty()) { + return gtest_msg; + } + + return gtest_msg + "\n" + user_msg_string; +} + +} // namespace internal + +// class TestResult + +// Creates an empty TestResult. +TestResult::TestResult() + : death_test_count_(0), + elapsed_time_(0) { +} + +// D'tor. +TestResult::~TestResult() { +} + +// Returns the i-th test part result among all the results. i can +// range from 0 to total_part_count() - 1. If i is not in that range, +// aborts the program. +const TestPartResult& TestResult::GetTestPartResult(int i) const { + if (i < 0 || i >= total_part_count()) + internal::posix::Abort(); + return test_part_results_.at(i); +} + +// Returns the i-th test property. i can range from 0 to +// test_property_count() - 1. If i is not in that range, aborts the +// program. +const TestProperty& TestResult::GetTestProperty(int i) const { + if (i < 0 || i >= test_property_count()) + internal::posix::Abort(); + return test_properties_.at(i); +} + +// Clears the test part results. +void TestResult::ClearTestPartResults() { + test_part_results_.clear(); +} + +// Adds a test part result to the list. +void TestResult::AddTestPartResult(const TestPartResult& test_part_result) { + test_part_results_.push_back(test_part_result); +} + +// Adds a test property to the list. If a property with the same key as the +// supplied property is already represented, the value of this test_property +// replaces the old value for that key. +void TestResult::RecordProperty(const std::string& xml_element, + const TestProperty& test_property) { + if (!ValidateTestProperty(xml_element, test_property)) { + return; + } + internal::MutexLock lock(&test_properites_mutex_); + const std::vector::iterator property_with_matching_key = + std::find_if(test_properties_.begin(), test_properties_.end(), + internal::TestPropertyKeyIs(test_property.key())); + if (property_with_matching_key == test_properties_.end()) { + test_properties_.push_back(test_property); + return; + } + property_with_matching_key->SetValue(test_property.value()); +} + +// The list of reserved attributes used in the element of XML +// output. +static const char* const kReservedTestSuitesAttributes[] = { + "disabled", + "errors", + "failures", + "name", + "random_seed", + "tests", + "time", + "timestamp" +}; + +// The list of reserved attributes used in the element of XML +// output. +static const char* const kReservedTestSuiteAttributes[] = { + "disabled", + "errors", + "failures", + "name", + "tests", + "time" +}; + +// The list of reserved attributes used in the element of XML output. +static const char* const kReservedTestCaseAttributes[] = { + "classname", + "name", + "status", + "time", + "type_param", + "value_param" +}; + +template +std::vector ArrayAsVector(const char* const (&array)[kSize]) { + return std::vector(array, array + kSize); +} + +static std::vector GetReservedAttributesForElement( + const std::string& xml_element) { + if (xml_element == "testsuites") { + return ArrayAsVector(kReservedTestSuitesAttributes); + } else if (xml_element == "testsuite") { + return ArrayAsVector(kReservedTestSuiteAttributes); + } else if (xml_element == "testcase") { + return ArrayAsVector(kReservedTestCaseAttributes); + } else { + GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element; + } + // This code is unreachable but some compilers may not realizes that. + return std::vector(); +} + +static std::string FormatWordList(const std::vector& words) { + Message word_list; + for (size_t i = 0; i < words.size(); ++i) { + if (i > 0 && words.size() > 2) { + word_list << ", "; + } + if (i == words.size() - 1) { + word_list << "and "; + } + word_list << "'" << words[i] << "'"; + } + return word_list.GetString(); +} + +bool ValidateTestPropertyName(const std::string& property_name, + const std::vector& reserved_names) { + if (std::find(reserved_names.begin(), reserved_names.end(), property_name) != + reserved_names.end()) { + ADD_FAILURE() << "Reserved key used in RecordProperty(): " << property_name + << " (" << FormatWordList(reserved_names) + << " are reserved by " << GTEST_NAME_ << ")"; + return false; + } + return true; +} + +// Adds a failure if the key is a reserved attribute of the element named +// xml_element. Returns true if the property is valid. +bool TestResult::ValidateTestProperty(const std::string& xml_element, + const TestProperty& test_property) { + return ValidateTestPropertyName(test_property.key(), + GetReservedAttributesForElement(xml_element)); +} + +// Clears the object. +void TestResult::Clear() { + test_part_results_.clear(); + test_properties_.clear(); + death_test_count_ = 0; + elapsed_time_ = 0; +} + +// Returns true iff the test failed. +bool TestResult::Failed() const { + for (int i = 0; i < total_part_count(); ++i) { + if (GetTestPartResult(i).failed()) + return true; + } + return false; +} + +// Returns true iff the test part fatally failed. +static bool TestPartFatallyFailed(const TestPartResult& result) { + return result.fatally_failed(); +} + +// Returns true iff the test fatally failed. +bool TestResult::HasFatalFailure() const { + return CountIf(test_part_results_, TestPartFatallyFailed) > 0; +} + +// Returns true iff the test part non-fatally failed. +static bool TestPartNonfatallyFailed(const TestPartResult& result) { + return result.nonfatally_failed(); +} + +// Returns true iff the test has a non-fatal failure. +bool TestResult::HasNonfatalFailure() const { + return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0; +} + +// Gets the number of all test parts. This is the sum of the number +// of successful test parts and the number of failed test parts. +int TestResult::total_part_count() const { + return static_cast(test_part_results_.size()); +} + +// Returns the number of the test properties. +int TestResult::test_property_count() const { + return static_cast(test_properties_.size()); +} + +// class Test + +// Creates a Test object. + +// The c'tor saves the values of all Google Test flags. +Test::Test() + : gtest_flag_saver_(new internal::GTestFlagSaver) { +} + +// The d'tor restores the values of all Google Test flags. +Test::~Test() { + delete gtest_flag_saver_; +} + +// Sets up the test fixture. +// +// A sub-class may override this. +void Test::SetUp() { +} + +// Tears down the test fixture. +// +// A sub-class may override this. +void Test::TearDown() { +} + +// Allows user supplied key value pairs to be recorded for later output. +void Test::RecordProperty(const std::string& key, const std::string& value) { + UnitTest::GetInstance()->RecordProperty(key, value); +} + +// Allows user supplied key value pairs to be recorded for later output. +void Test::RecordProperty(const std::string& key, int value) { + Message value_message; + value_message << value; + RecordProperty(key, value_message.GetString().c_str()); +} + +namespace internal { + +void ReportFailureInUnknownLocation(TestPartResult::Type result_type, + const std::string& message) { + // This function is a friend of UnitTest and as such has access to + // AddTestPartResult. + UnitTest::GetInstance()->AddTestPartResult( + result_type, + NULL, // No info about the source file where the exception occurred. + -1, // We have no info on which line caused the exception. + message, + ""); // No stack trace, either. +} + +} // namespace internal + +// Google Test requires all tests in the same test case to use the same test +// fixture class. This function checks if the current test has the +// same fixture class as the first test in the current test case. If +// yes, it returns true; otherwise it generates a Google Test failure and +// returns false. +bool Test::HasSameFixtureClass() { + internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); + const TestCase* const test_case = impl->current_test_case(); + + // Info about the first test in the current test case. + const TestInfo* const first_test_info = test_case->test_info_list()[0]; + const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_; + const char* const first_test_name = first_test_info->name(); + + // Info about the current test. + const TestInfo* const this_test_info = impl->current_test_info(); + const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_; + const char* const this_test_name = this_test_info->name(); + + if (this_fixture_id != first_fixture_id) { + // Is the first test defined using TEST? + const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId(); + // Is this test defined using TEST? + const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId(); + + if (first_is_TEST || this_is_TEST) { + // The user mixed TEST and TEST_F in this test case - we'll tell + // him/her how to fix it. + + // Gets the name of the TEST and the name of the TEST_F. Note + // that first_is_TEST and this_is_TEST cannot both be true, as + // the fixture IDs are different for the two tests. + const char* const TEST_name = + first_is_TEST ? first_test_name : this_test_name; + const char* const TEST_F_name = + first_is_TEST ? this_test_name : first_test_name; + + ADD_FAILURE() + << "All tests in the same test case must use the same test fixture\n" + << "class, so mixing TEST_F and TEST in the same test case is\n" + << "illegal. In test case " << this_test_info->test_case_name() + << ",\n" + << "test " << TEST_F_name << " is defined using TEST_F but\n" + << "test " << TEST_name << " is defined using TEST. You probably\n" + << "want to change the TEST to TEST_F or move it to another test\n" + << "case."; + } else { + // The user defined two fixture classes with the same name in + // two namespaces - we'll tell him/her how to fix it. + ADD_FAILURE() + << "All tests in the same test case must use the same test fixture\n" + << "class. However, in test case " + << this_test_info->test_case_name() << ",\n" + << "you defined test " << first_test_name + << " and test " << this_test_name << "\n" + << "using two different test fixture classes. This can happen if\n" + << "the two classes are from different namespaces or translation\n" + << "units and have the same name. You should probably rename one\n" + << "of the classes to put the tests into different test cases."; + } + return false; + } + + return true; +} + +#if GTEST_HAS_SEH + +// Adds an "exception thrown" fatal failure to the current test. This +// function returns its result via an output parameter pointer because VC++ +// prohibits creation of objects with destructors on stack in functions +// using __try (see error C2712). +static std::string* FormatSehExceptionMessage(DWORD exception_code, + const char* location) { + Message message; + message << "SEH exception with code 0x" << std::setbase(16) << + exception_code << std::setbase(10) << " thrown in " << location << "."; + + return new std::string(message.GetString()); +} + +#endif // GTEST_HAS_SEH + +namespace internal { + +#if GTEST_HAS_EXCEPTIONS + +// Adds an "exception thrown" fatal failure to the current test. +static std::string FormatCxxExceptionMessage(const char* description, + const char* location) { + Message message; + if (description != NULL) { + message << "C++ exception with description \"" << description << "\""; + } else { + message << "Unknown C++ exception"; + } + message << " thrown in " << location << "."; + + return message.GetString(); +} + +static std::string PrintTestPartResultToString( + const TestPartResult& test_part_result); + +GoogleTestFailureException::GoogleTestFailureException( + const TestPartResult& failure) + : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {} + +#endif // GTEST_HAS_EXCEPTIONS + +// We put these helper functions in the internal namespace as IBM's xlC +// compiler rejects the code if they were declared static. + +// Runs the given method and handles SEH exceptions it throws, when +// SEH is supported; returns the 0-value for type Result in case of an +// SEH exception. (Microsoft compilers cannot handle SEH and C++ +// exceptions in the same function. Therefore, we provide a separate +// wrapper function for handling SEH exceptions.) +template +Result HandleSehExceptionsInMethodIfSupported( + T* object, Result (T::*method)(), const char* location) { +#if GTEST_HAS_SEH + __try { + return (object->*method)(); + } __except (internal::UnitTestOptions::GTestShouldProcessSEH( // NOLINT + GetExceptionCode())) { + // We create the exception message on the heap because VC++ prohibits + // creation of objects with destructors on stack in functions using __try + // (see error C2712). + std::string* exception_message = FormatSehExceptionMessage( + GetExceptionCode(), location); + internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure, + *exception_message); + delete exception_message; + return static_cast(0); + } +#else + (void)location; + return (object->*method)(); +#endif // GTEST_HAS_SEH +} + +// Runs the given method and catches and reports C++ and/or SEH-style +// exceptions, if they are supported; returns the 0-value for type +// Result in case of an SEH exception. +template +Result HandleExceptionsInMethodIfSupported( + T* object, Result (T::*method)(), const char* location) { + // NOTE: The user code can affect the way in which Google Test handles + // exceptions by setting GTEST_FLAG(catch_exceptions), but only before + // RUN_ALL_TESTS() starts. It is technically possible to check the flag + // after the exception is caught and either report or re-throw the + // exception based on the flag's value: + // + // try { + // // Perform the test method. + // } catch (...) { + // if (GTEST_FLAG(catch_exceptions)) + // // Report the exception as failure. + // else + // throw; // Re-throws the original exception. + // } + // + // However, the purpose of this flag is to allow the program to drop into + // the debugger when the exception is thrown. On most platforms, once the + // control enters the catch block, the exception origin information is + // lost and the debugger will stop the program at the point of the + // re-throw in this function -- instead of at the point of the original + // throw statement in the code under test. For this reason, we perform + // the check early, sacrificing the ability to affect Google Test's + // exception handling in the method where the exception is thrown. + if (internal::GetUnitTestImpl()->catch_exceptions()) { +#if GTEST_HAS_EXCEPTIONS + try { + return HandleSehExceptionsInMethodIfSupported(object, method, location); + } catch (const internal::GoogleTestFailureException&) { // NOLINT + // This exception type can only be thrown by a failed Google + // Test assertion with the intention of letting another testing + // framework catch it. Therefore we just re-throw it. + throw; + } catch (const std::exception& e) { // NOLINT + internal::ReportFailureInUnknownLocation( + TestPartResult::kFatalFailure, + FormatCxxExceptionMessage(e.what(), location)); + } catch (...) { // NOLINT + internal::ReportFailureInUnknownLocation( + TestPartResult::kFatalFailure, + FormatCxxExceptionMessage(NULL, location)); + } + return static_cast(0); +#else + return HandleSehExceptionsInMethodIfSupported(object, method, location); +#endif // GTEST_HAS_EXCEPTIONS + } else { + return (object->*method)(); + } +} + +} // namespace internal + +// Runs the test and updates the test result. +void Test::Run() { + if (!HasSameFixtureClass()) return; + + internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); + impl->os_stack_trace_getter()->UponLeavingGTest(); + internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()"); + // We will run the test only if SetUp() was successful. + if (!HasFatalFailure()) { + impl->os_stack_trace_getter()->UponLeavingGTest(); + internal::HandleExceptionsInMethodIfSupported( + this, &Test::TestBody, "the test body"); + } + + // However, we want to clean up as much as possible. Hence we will + // always call TearDown(), even if SetUp() or the test body has + // failed. + impl->os_stack_trace_getter()->UponLeavingGTest(); + internal::HandleExceptionsInMethodIfSupported( + this, &Test::TearDown, "TearDown()"); +} + +// Returns true iff the current test has a fatal failure. +bool Test::HasFatalFailure() { + return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure(); +} + +// Returns true iff the current test has a non-fatal failure. +bool Test::HasNonfatalFailure() { + return internal::GetUnitTestImpl()->current_test_result()-> + HasNonfatalFailure(); +} + +// class TestInfo + +// Constructs a TestInfo object. It assumes ownership of the test factory +// object. +TestInfo::TestInfo(const std::string& a_test_case_name, + const std::string& a_name, + const char* a_type_param, + const char* a_value_param, + internal::TypeId fixture_class_id, + internal::TestFactoryBase* factory) + : test_case_name_(a_test_case_name), + name_(a_name), + type_param_(a_type_param ? new std::string(a_type_param) : NULL), + value_param_(a_value_param ? new std::string(a_value_param) : NULL), + fixture_class_id_(fixture_class_id), + should_run_(false), + is_disabled_(false), + matches_filter_(false), + factory_(factory), + result_() {} + +// Destructs a TestInfo object. +TestInfo::~TestInfo() { delete factory_; } + +namespace internal { + +// Creates a new TestInfo object and registers it with Google Test; +// returns the created object. +// +// Arguments: +// +// test_case_name: name of the test case +// name: name of the test +// type_param: the name of the test's type parameter, or NULL if +// this is not a typed or a type-parameterized test. +// value_param: text representation of the test's value parameter, +// or NULL if this is not a value-parameterized test. +// fixture_class_id: ID of the test fixture class +// set_up_tc: pointer to the function that sets up the test case +// tear_down_tc: pointer to the function that tears down the test case +// factory: pointer to the factory that creates a test object. +// The newly created TestInfo instance will assume +// ownership of the factory object. +TestInfo* MakeAndRegisterTestInfo( + const char* test_case_name, + const char* name, + const char* type_param, + const char* value_param, + TypeId fixture_class_id, + SetUpTestCaseFunc set_up_tc, + TearDownTestCaseFunc tear_down_tc, + TestFactoryBase* factory) { + TestInfo* const test_info = + new TestInfo(test_case_name, name, type_param, value_param, + fixture_class_id, factory); + GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info); + return test_info; +} + +#if GTEST_HAS_PARAM_TEST +void ReportInvalidTestCaseType(const char* test_case_name, + const char* file, int line) { + Message errors; + errors + << "Attempted redefinition of test case " << test_case_name << ".\n" + << "All tests in the same test case must use the same test fixture\n" + << "class. However, in test case " << test_case_name << ", you tried\n" + << "to define a test using a fixture class different from the one\n" + << "used earlier. This can happen if the two fixture classes are\n" + << "from different namespaces and have the same name. You should\n" + << "probably rename one of the classes to put the tests into different\n" + << "test cases."; + + fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(), + errors.GetString().c_str()); +} +#endif // GTEST_HAS_PARAM_TEST + +} // namespace internal + +namespace { + +// A predicate that checks the test name of a TestInfo against a known +// value. +// +// This is used for implementation of the TestCase class only. We put +// it in the anonymous namespace to prevent polluting the outer +// namespace. +// +// TestNameIs is copyable. +class TestNameIs { + public: + // Constructor. + // + // TestNameIs has NO default constructor. + explicit TestNameIs(const char* name) + : name_(name) {} + + // Returns true iff the test name of test_info matches name_. + bool operator()(const TestInfo * test_info) const { + return test_info && test_info->name() == name_; + } + + private: + std::string name_; +}; + +} // namespace + +namespace internal { + +// This method expands all parameterized tests registered with macros TEST_P +// and INSTANTIATE_TEST_CASE_P into regular tests and registers those. +// This will be done just once during the program runtime. +void UnitTestImpl::RegisterParameterizedTests() { +#if GTEST_HAS_PARAM_TEST + if (!parameterized_tests_registered_) { + parameterized_test_registry_.RegisterTests(); + parameterized_tests_registered_ = true; + } +#endif +} + +} // namespace internal + +// Creates the test object, runs it, records its result, and then +// deletes it. +void TestInfo::Run() { + if (!should_run_) return; + + // Tells UnitTest where to store test result. + internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); + impl->set_current_test_info(this); + + TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); + + // Notifies the unit test event listeners that a test is about to start. + repeater->OnTestStart(*this); + + const TimeInMillis start = internal::GetTimeInMillis(); + + impl->os_stack_trace_getter()->UponLeavingGTest(); + + // Creates the test object. + Test* const test = internal::HandleExceptionsInMethodIfSupported( + factory_, &internal::TestFactoryBase::CreateTest, + "the test fixture's constructor"); + + // Runs the test only if the test object was created and its + // constructor didn't generate a fatal failure. + if ((test != NULL) && !Test::HasFatalFailure()) { + // This doesn't throw as all user code that can throw are wrapped into + // exception handling code. + test->Run(); + } + + // Deletes the test object. + impl->os_stack_trace_getter()->UponLeavingGTest(); + internal::HandleExceptionsInMethodIfSupported( + test, &Test::DeleteSelf_, "the test fixture's destructor"); + + result_.set_elapsed_time(internal::GetTimeInMillis() - start); + + // Notifies the unit test event listener that a test has just finished. + repeater->OnTestEnd(*this); + + // Tells UnitTest to stop associating assertion results to this + // test. + impl->set_current_test_info(NULL); +} + +// class TestCase + +// Gets the number of successful tests in this test case. +int TestCase::successful_test_count() const { + return CountIf(test_info_list_, TestPassed); +} + +// Gets the number of failed tests in this test case. +int TestCase::failed_test_count() const { + return CountIf(test_info_list_, TestFailed); +} + +// Gets the number of disabled tests that will be reported in the XML report. +int TestCase::reportable_disabled_test_count() const { + return CountIf(test_info_list_, TestReportableDisabled); +} + +// Gets the number of disabled tests in this test case. +int TestCase::disabled_test_count() const { + return CountIf(test_info_list_, TestDisabled); +} + +// Gets the number of tests to be printed in the XML report. +int TestCase::reportable_test_count() const { + return CountIf(test_info_list_, TestReportable); +} + +// Get the number of tests in this test case that should run. +int TestCase::test_to_run_count() const { + return CountIf(test_info_list_, ShouldRunTest); +} + +// Gets the number of all tests. +int TestCase::total_test_count() const { + return static_cast(test_info_list_.size()); +} + +// Creates a TestCase with the given name. +// +// Arguments: +// +// name: name of the test case +// a_type_param: the name of the test case's type parameter, or NULL if +// this is not a typed or a type-parameterized test case. +// set_up_tc: pointer to the function that sets up the test case +// tear_down_tc: pointer to the function that tears down the test case +TestCase::TestCase(const char* a_name, const char* a_type_param, + Test::SetUpTestCaseFunc set_up_tc, + Test::TearDownTestCaseFunc tear_down_tc) + : name_(a_name), + type_param_(a_type_param ? new std::string(a_type_param) : NULL), + set_up_tc_(set_up_tc), + tear_down_tc_(tear_down_tc), + should_run_(false), + elapsed_time_(0) { +} + +// Destructor of TestCase. +TestCase::~TestCase() { + // Deletes every Test in the collection. + ForEach(test_info_list_, internal::Delete); +} + +// Returns the i-th test among all the tests. i can range from 0 to +// total_test_count() - 1. If i is not in that range, returns NULL. +const TestInfo* TestCase::GetTestInfo(int i) const { + const int index = GetElementOr(test_indices_, i, -1); + return index < 0 ? NULL : test_info_list_[index]; +} + +// Returns the i-th test among all the tests. i can range from 0 to +// total_test_count() - 1. If i is not in that range, returns NULL. +TestInfo* TestCase::GetMutableTestInfo(int i) { + const int index = GetElementOr(test_indices_, i, -1); + return index < 0 ? NULL : test_info_list_[index]; +} + +// Adds a test to this test case. Will delete the test upon +// destruction of the TestCase object. +void TestCase::AddTestInfo(TestInfo * test_info) { + test_info_list_.push_back(test_info); + test_indices_.push_back(static_cast(test_indices_.size())); +} + +// Runs every test in this TestCase. +void TestCase::Run() { + if (!should_run_) return; + + internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); + impl->set_current_test_case(this); + + TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); + + repeater->OnTestCaseStart(*this); + impl->os_stack_trace_getter()->UponLeavingGTest(); + internal::HandleExceptionsInMethodIfSupported( + this, &TestCase::RunSetUpTestCase, "SetUpTestCase()"); + + const internal::TimeInMillis start = internal::GetTimeInMillis(); + for (int i = 0; i < total_test_count(); i++) { + GetMutableTestInfo(i)->Run(); + } + elapsed_time_ = internal::GetTimeInMillis() - start; + + impl->os_stack_trace_getter()->UponLeavingGTest(); + internal::HandleExceptionsInMethodIfSupported( + this, &TestCase::RunTearDownTestCase, "TearDownTestCase()"); + + repeater->OnTestCaseEnd(*this); + impl->set_current_test_case(NULL); +} + +// Clears the results of all tests in this test case. +void TestCase::ClearResult() { + ad_hoc_test_result_.Clear(); + ForEach(test_info_list_, TestInfo::ClearTestResult); +} + +// Shuffles the tests in this test case. +void TestCase::ShuffleTests(internal::Random* random) { + Shuffle(random, &test_indices_); +} + +// Restores the test order to before the first shuffle. +void TestCase::UnshuffleTests() { + for (size_t i = 0; i < test_indices_.size(); i++) { + test_indices_[i] = static_cast(i); + } +} + +// Formats a countable noun. Depending on its quantity, either the +// singular form or the plural form is used. e.g. +// +// FormatCountableNoun(1, "formula", "formuli") returns "1 formula". +// FormatCountableNoun(5, "book", "books") returns "5 books". +static std::string FormatCountableNoun(int count, + const char * singular_form, + const char * plural_form) { + return internal::StreamableToString(count) + " " + + (count == 1 ? singular_form : plural_form); +} + +// Formats the count of tests. +static std::string FormatTestCount(int test_count) { + return FormatCountableNoun(test_count, "test", "tests"); +} + +// Formats the count of test cases. +static std::string FormatTestCaseCount(int test_case_count) { + return FormatCountableNoun(test_case_count, "test case", "test cases"); +} + +// Converts a TestPartResult::Type enum to human-friendly string +// representation. Both kNonFatalFailure and kFatalFailure are translated +// to "Failure", as the user usually doesn't care about the difference +// between the two when viewing the test result. +static const char * TestPartResultTypeToString(TestPartResult::Type type) { + switch (type) { + case TestPartResult::kSuccess: + return "Success"; + + case TestPartResult::kNonFatalFailure: + case TestPartResult::kFatalFailure: +#ifdef _MSC_VER + return "error: "; +#else + return "Failure\n"; +#endif + default: + return "Unknown result type"; + } +} + +namespace internal { + +// Prints a TestPartResult to an std::string. +static std::string PrintTestPartResultToString( + const TestPartResult& test_part_result) { + return (Message() + << internal::FormatFileLocation(test_part_result.file_name(), + test_part_result.line_number()) + << " " << TestPartResultTypeToString(test_part_result.type()) + << test_part_result.message()).GetString(); +} + +// Prints a TestPartResult. +static void PrintTestPartResult(const TestPartResult& test_part_result) { + const std::string& result = + PrintTestPartResultToString(test_part_result); + printf("%s\n", result.c_str()); + fflush(stdout); + // If the test program runs in Visual Studio or a debugger, the + // following statements add the test part result message to the Output + // window such that the user can double-click on it to jump to the + // corresponding source code location; otherwise they do nothing. +#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE + // We don't call OutputDebugString*() on Windows Mobile, as printing + // to stdout is done by OutputDebugString() there already - we don't + // want the same message printed twice. + ::OutputDebugStringA(result.c_str()); + ::OutputDebugStringA("\n"); +#endif +} + +// class PrettyUnitTestResultPrinter + +enum GTestColor { + COLOR_DEFAULT, + COLOR_RED, + COLOR_GREEN, + COLOR_YELLOW +}; + +#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE + +// Returns the character attribute for the given color. +WORD GetColorAttribute(GTestColor color) { + switch (color) { + case COLOR_RED: return FOREGROUND_RED; + case COLOR_GREEN: return FOREGROUND_GREEN; + case COLOR_YELLOW: return FOREGROUND_RED | FOREGROUND_GREEN; + default: return 0; + } +} + +#else + +// Returns the ANSI color code for the given color. COLOR_DEFAULT is +// an invalid input. +const char* GetAnsiColorCode(GTestColor color) { + switch (color) { + case COLOR_RED: return "1"; + case COLOR_GREEN: return "2"; + case COLOR_YELLOW: return "3"; + default: return NULL; + }; +} + +#endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE + +// Returns true iff Google Test should use colors in the output. +bool ShouldUseColor(bool stdout_is_tty) { + const char* const gtest_color = GTEST_FLAG(color).c_str(); + + if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) { +#if GTEST_OS_WINDOWS + // On Windows the TERM variable is usually not set, but the + // console there does support colors. + return stdout_is_tty; +#else + // On non-Windows platforms, we rely on the TERM variable. + const char* const term = posix::GetEnv("TERM"); + const bool term_supports_color = + String::CStringEquals(term, "xterm") || + String::CStringEquals(term, "xterm-color") || + String::CStringEquals(term, "xterm-256color") || + String::CStringEquals(term, "screen") || + String::CStringEquals(term, "screen-256color") || + String::CStringEquals(term, "linux") || + String::CStringEquals(term, "cygwin"); + return stdout_is_tty && term_supports_color; +#endif // GTEST_OS_WINDOWS + } + + return String::CaseInsensitiveCStringEquals(gtest_color, "yes") || + String::CaseInsensitiveCStringEquals(gtest_color, "true") || + String::CaseInsensitiveCStringEquals(gtest_color, "t") || + String::CStringEquals(gtest_color, "1"); + // We take "yes", "true", "t", and "1" as meaning "yes". If the + // value is neither one of these nor "auto", we treat it as "no" to + // be conservative. +} + +// Helpers for printing colored strings to stdout. Note that on Windows, we +// cannot simply emit special characters and have the terminal change colors. +// This routine must actually emit the characters rather than return a string +// that would be colored when printed, as can be done on Linux. +void ColoredPrintf(GTestColor color, const char* fmt, ...) { + va_list args; + va_start(args, fmt); + +#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS || GTEST_OS_IOS + const bool use_color = false; +#else + static const bool in_color_mode = + ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0); + const bool use_color = in_color_mode && (color != COLOR_DEFAULT); +#endif // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS + // The '!= 0' comparison is necessary to satisfy MSVC 7.1. + + if (!use_color) { + vprintf(fmt, args); + va_end(args); + return; + } + +#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE + const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE); + + // Gets the current text color. + CONSOLE_SCREEN_BUFFER_INFO buffer_info; + GetConsoleScreenBufferInfo(stdout_handle, &buffer_info); + const WORD old_color_attrs = buffer_info.wAttributes; + + // We need to flush the stream buffers into the console before each + // SetConsoleTextAttribute call lest it affect the text that is already + // printed but has not yet reached the console. + fflush(stdout); + SetConsoleTextAttribute(stdout_handle, + GetColorAttribute(color) | FOREGROUND_INTENSITY); + vprintf(fmt, args); + + fflush(stdout); + // Restores the text color. + SetConsoleTextAttribute(stdout_handle, old_color_attrs); +#else + printf("\033[0;3%sm", GetAnsiColorCode(color)); + vprintf(fmt, args); + printf("\033[m"); // Resets the terminal to default. +#endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE + va_end(args); +} + +// Text printed in Google Test's text output and --gunit_list_tests +// output to label the type parameter and value parameter for a test. +static const char kTypeParamLabel[] = "TypeParam"; +static const char kValueParamLabel[] = "GetParam()"; + +void PrintFullTestCommentIfPresent(const TestInfo& test_info) { + const char* const type_param = test_info.type_param(); + const char* const value_param = test_info.value_param(); + + if (type_param != NULL || value_param != NULL) { + printf(", where "); + if (type_param != NULL) { + printf("%s = %s", kTypeParamLabel, type_param); + if (value_param != NULL) + printf(" and "); + } + if (value_param != NULL) { + printf("%s = %s", kValueParamLabel, value_param); + } + } +} + +// This class implements the TestEventListener interface. +// +// Class PrettyUnitTestResultPrinter is copyable. +class PrettyUnitTestResultPrinter : public TestEventListener { + public: + PrettyUnitTestResultPrinter() {} + static void PrintTestName(const char * test_case, const char * test) { + printf("%s.%s", test_case, test); + } + + // The following methods override what's in the TestEventListener class. + virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {} + virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration); + virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test); + virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {} + virtual void OnTestCaseStart(const TestCase& test_case); + virtual void OnTestStart(const TestInfo& test_info); + virtual void OnTestPartResult(const TestPartResult& result); + virtual void OnTestEnd(const TestInfo& test_info); + virtual void OnTestCaseEnd(const TestCase& test_case); + virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test); + virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {} + virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration); + virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {} + + private: + static void PrintFailedTests(const UnitTest& unit_test); +}; + + // Fired before each iteration of tests starts. +void PrettyUnitTestResultPrinter::OnTestIterationStart( + const UnitTest& unit_test, int iteration) { + if (GTEST_FLAG(repeat) != 1) + printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1); + + const char* const filter = GTEST_FLAG(filter).c_str(); + + // Prints the filter if it's not *. This reminds the user that some + // tests may be skipped. + if (!String::CStringEquals(filter, kUniversalFilter)) { + ColoredPrintf(COLOR_YELLOW, + "Note: %s filter = %s\n", GTEST_NAME_, filter); + } + + if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) { + const Int32 shard_index = Int32FromEnvOrDie(kTestShardIndex, -1); + ColoredPrintf(COLOR_YELLOW, + "Note: This is test shard %d of %s.\n", + static_cast(shard_index) + 1, + internal::posix::GetEnv(kTestTotalShards)); + } + + if (GTEST_FLAG(shuffle)) { + ColoredPrintf(COLOR_YELLOW, + "Note: Randomizing tests' orders with a seed of %d .\n", + unit_test.random_seed()); + } + + ColoredPrintf(COLOR_GREEN, "[==========] "); + printf("Running %s from %s.\n", + FormatTestCount(unit_test.test_to_run_count()).c_str(), + FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str()); + fflush(stdout); +} + +void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart( + const UnitTest& /*unit_test*/) { + ColoredPrintf(COLOR_GREEN, "[----------] "); + printf("Global test environment set-up.\n"); + fflush(stdout); +} + +void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) { + const std::string counts = + FormatCountableNoun(test_case.test_to_run_count(), "test", "tests"); + ColoredPrintf(COLOR_GREEN, "[----------] "); + printf("%s from %s", counts.c_str(), test_case.name()); + if (test_case.type_param() == NULL) { + printf("\n"); + } else { + printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param()); + } + fflush(stdout); +} + +void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) { + ColoredPrintf(COLOR_GREEN, "[ RUN ] "); + PrintTestName(test_info.test_case_name(), test_info.name()); + printf("\n"); + fflush(stdout); +} + +// Called after an assertion failure. +void PrettyUnitTestResultPrinter::OnTestPartResult( + const TestPartResult& result) { + // If the test part succeeded, we don't need to do anything. + if (result.type() == TestPartResult::kSuccess) + return; + + // Print failure message from the assertion (e.g. expected this and got that). + PrintTestPartResult(result); + fflush(stdout); +} + +void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) { + if (test_info.result()->Passed()) { + ColoredPrintf(COLOR_GREEN, "[ OK ] "); + } else { + ColoredPrintf(COLOR_RED, "[ FAILED ] "); + } + PrintTestName(test_info.test_case_name(), test_info.name()); + if (test_info.result()->Failed()) + PrintFullTestCommentIfPresent(test_info); + + if (GTEST_FLAG(print_time)) { + printf(" (%s ms)\n", internal::StreamableToString( + test_info.result()->elapsed_time()).c_str()); + } else { + printf("\n"); + } + fflush(stdout); +} + +void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) { + if (!GTEST_FLAG(print_time)) return; + + const std::string counts = + FormatCountableNoun(test_case.test_to_run_count(), "test", "tests"); + ColoredPrintf(COLOR_GREEN, "[----------] "); + printf("%s from %s (%s ms total)\n\n", + counts.c_str(), test_case.name(), + internal::StreamableToString(test_case.elapsed_time()).c_str()); + fflush(stdout); +} + +void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart( + const UnitTest& /*unit_test*/) { + ColoredPrintf(COLOR_GREEN, "[----------] "); + printf("Global test environment tear-down\n"); + fflush(stdout); +} + +// Internal helper for printing the list of failed tests. +void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) { + const int failed_test_count = unit_test.failed_test_count(); + if (failed_test_count == 0) { + return; + } + + for (int i = 0; i < unit_test.total_test_case_count(); ++i) { + const TestCase& test_case = *unit_test.GetTestCase(i); + if (!test_case.should_run() || (test_case.failed_test_count() == 0)) { + continue; + } + for (int j = 0; j < test_case.total_test_count(); ++j) { + const TestInfo& test_info = *test_case.GetTestInfo(j); + if (!test_info.should_run() || test_info.result()->Passed()) { + continue; + } + ColoredPrintf(COLOR_RED, "[ FAILED ] "); + printf("%s.%s", test_case.name(), test_info.name()); + PrintFullTestCommentIfPresent(test_info); + printf("\n"); + } + } +} + +void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test, + int /*iteration*/) { + ColoredPrintf(COLOR_GREEN, "[==========] "); + printf("%s from %s ran.", + FormatTestCount(unit_test.test_to_run_count()).c_str(), + FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str()); + if (GTEST_FLAG(print_time)) { + printf(" (%s ms total)", + internal::StreamableToString(unit_test.elapsed_time()).c_str()); + } + printf("\n"); + ColoredPrintf(COLOR_GREEN, "[ PASSED ] "); + printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str()); + + int num_failures = unit_test.failed_test_count(); + if (!unit_test.Passed()) { + const int failed_test_count = unit_test.failed_test_count(); + ColoredPrintf(COLOR_RED, "[ FAILED ] "); + printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str()); + PrintFailedTests(unit_test); + printf("\n%2d FAILED %s\n", num_failures, + num_failures == 1 ? "TEST" : "TESTS"); + } + + int num_disabled = unit_test.reportable_disabled_test_count(); + if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) { + if (!num_failures) { + printf("\n"); // Add a spacer if no FAILURE banner is displayed. + } + ColoredPrintf(COLOR_YELLOW, + " YOU HAVE %d DISABLED %s\n\n", + num_disabled, + num_disabled == 1 ? "TEST" : "TESTS"); + } + // Ensure that Google Test output is printed before, e.g., heapchecker output. + fflush(stdout); +} + +// End PrettyUnitTestResultPrinter + +// class TestEventRepeater +// +// This class forwards events to other event listeners. +class TestEventRepeater : public TestEventListener { + public: + TestEventRepeater() : forwarding_enabled_(true) {} + virtual ~TestEventRepeater(); + void Append(TestEventListener *listener); + TestEventListener* Release(TestEventListener* listener); + + // Controls whether events will be forwarded to listeners_. Set to false + // in death test child processes. + bool forwarding_enabled() const { return forwarding_enabled_; } + void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; } + + virtual void OnTestProgramStart(const UnitTest& unit_test); + virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration); + virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test); + virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test); + virtual void OnTestCaseStart(const TestCase& test_case); + virtual void OnTestStart(const TestInfo& test_info); + virtual void OnTestPartResult(const TestPartResult& result); + virtual void OnTestEnd(const TestInfo& test_info); + virtual void OnTestCaseEnd(const TestCase& test_case); + virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test); + virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test); + virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration); + virtual void OnTestProgramEnd(const UnitTest& unit_test); + + private: + // Controls whether events will be forwarded to listeners_. Set to false + // in death test child processes. + bool forwarding_enabled_; + // The list of listeners that receive events. + std::vector listeners_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventRepeater); +}; + +TestEventRepeater::~TestEventRepeater() { + ForEach(listeners_, Delete); +} + +void TestEventRepeater::Append(TestEventListener *listener) { + listeners_.push_back(listener); +} + +// TODO(vladl@google.com): Factor the search functionality into Vector::Find. +TestEventListener* TestEventRepeater::Release(TestEventListener *listener) { + for (size_t i = 0; i < listeners_.size(); ++i) { + if (listeners_[i] == listener) { + listeners_.erase(listeners_.begin() + i); + return listener; + } + } + + return NULL; +} + +// Since most methods are very similar, use macros to reduce boilerplate. +// This defines a member that forwards the call to all listeners. +#define GTEST_REPEATER_METHOD_(Name, Type) \ +void TestEventRepeater::Name(const Type& parameter) { \ + if (forwarding_enabled_) { \ + for (size_t i = 0; i < listeners_.size(); i++) { \ + listeners_[i]->Name(parameter); \ + } \ + } \ +} +// This defines a member that forwards the call to all listeners in reverse +// order. +#define GTEST_REVERSE_REPEATER_METHOD_(Name, Type) \ +void TestEventRepeater::Name(const Type& parameter) { \ + if (forwarding_enabled_) { \ + for (int i = static_cast(listeners_.size()) - 1; i >= 0; i--) { \ + listeners_[i]->Name(parameter); \ + } \ + } \ +} + +GTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest) +GTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest) +GTEST_REPEATER_METHOD_(OnTestCaseStart, TestCase) +GTEST_REPEATER_METHOD_(OnTestStart, TestInfo) +GTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult) +GTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest) +GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest) +GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsTearDownEnd, UnitTest) +GTEST_REVERSE_REPEATER_METHOD_(OnTestEnd, TestInfo) +GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestCase) +GTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest) + +#undef GTEST_REPEATER_METHOD_ +#undef GTEST_REVERSE_REPEATER_METHOD_ + +void TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test, + int iteration) { + if (forwarding_enabled_) { + for (size_t i = 0; i < listeners_.size(); i++) { + listeners_[i]->OnTestIterationStart(unit_test, iteration); + } + } +} + +void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test, + int iteration) { + if (forwarding_enabled_) { + for (int i = static_cast(listeners_.size()) - 1; i >= 0; i--) { + listeners_[i]->OnTestIterationEnd(unit_test, iteration); + } + } +} + +// End TestEventRepeater + +// This class generates an XML output file. +class XmlUnitTestResultPrinter : public EmptyTestEventListener { + public: + explicit XmlUnitTestResultPrinter(const char* output_file); + + virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration); + + private: + // Is c a whitespace character that is normalized to a space character + // when it appears in an XML attribute value? + static bool IsNormalizableWhitespace(char c) { + return c == 0x9 || c == 0xA || c == 0xD; + } + + // May c appear in a well-formed XML document? + static bool IsValidXmlCharacter(char c) { + return IsNormalizableWhitespace(c) || c >= 0x20; + } + + // Returns an XML-escaped copy of the input string str. If + // is_attribute is true, the text is meant to appear as an attribute + // value, and normalizable whitespace is preserved by replacing it + // with character references. + static std::string EscapeXml(const std::string& str, bool is_attribute); + + // Returns the given string with all characters invalid in XML removed. + static std::string RemoveInvalidXmlCharacters(const std::string& str); + + // Convenience wrapper around EscapeXml when str is an attribute value. + static std::string EscapeXmlAttribute(const std::string& str) { + return EscapeXml(str, true); + } + + // Convenience wrapper around EscapeXml when str is not an attribute value. + static std::string EscapeXmlText(const char* str) { + return EscapeXml(str, false); + } + + // Verifies that the given attribute belongs to the given element and + // streams the attribute as XML. + static void OutputXmlAttribute(std::ostream* stream, + const std::string& element_name, + const std::string& name, + const std::string& value); + + // Streams an XML CDATA section, escaping invalid CDATA sequences as needed. + static void OutputXmlCDataSection(::std::ostream* stream, const char* data); + + // Streams an XML representation of a TestInfo object. + static void OutputXmlTestInfo(::std::ostream* stream, + const char* test_case_name, + const TestInfo& test_info); + + // Prints an XML representation of a TestCase object + static void PrintXmlTestCase(::std::ostream* stream, + const TestCase& test_case); + + // Prints an XML summary of unit_test to output stream out. + static void PrintXmlUnitTest(::std::ostream* stream, + const UnitTest& unit_test); + + // Produces a string representing the test properties in a result as space + // delimited XML attributes based on the property key="value" pairs. + // When the std::string is not empty, it includes a space at the beginning, + // to delimit this attribute from prior attributes. + static std::string TestPropertiesAsXmlAttributes(const TestResult& result); + + // The output file. + const std::string output_file_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter); +}; + +// Creates a new XmlUnitTestResultPrinter. +XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file) + : output_file_(output_file) { + if (output_file_.c_str() == NULL || output_file_.empty()) { + fprintf(stderr, "XML output file may not be null\n"); + fflush(stderr); + exit(EXIT_FAILURE); + } +} + +// Called after the unit test ends. +void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test, + int /*iteration*/) { + FILE* xmlout = NULL; + FilePath output_file(output_file_); + FilePath output_dir(output_file.RemoveFileName()); + + if (output_dir.CreateDirectoriesRecursively()) { + xmlout = posix::FOpen(output_file_.c_str(), "w"); + } + if (xmlout == NULL) { + // TODO(wan): report the reason of the failure. + // + // We don't do it for now as: + // + // 1. There is no urgent need for it. + // 2. It's a bit involved to make the errno variable thread-safe on + // all three operating systems (Linux, Windows, and Mac OS). + // 3. To interpret the meaning of errno in a thread-safe way, + // we need the strerror_r() function, which is not available on + // Windows. + fprintf(stderr, + "Unable to open file \"%s\"\n", + output_file_.c_str()); + fflush(stderr); + exit(EXIT_FAILURE); + } + std::stringstream stream; + PrintXmlUnitTest(&stream, unit_test); + fprintf(xmlout, "%s", StringStreamToString(&stream).c_str()); + fclose(xmlout); +} + +// Returns an XML-escaped copy of the input string str. If is_attribute +// is true, the text is meant to appear as an attribute value, and +// normalizable whitespace is preserved by replacing it with character +// references. +// +// Invalid XML characters in str, if any, are stripped from the output. +// It is expected that most, if not all, of the text processed by this +// module will consist of ordinary English text. +// If this module is ever modified to produce version 1.1 XML output, +// most invalid characters can be retained using character references. +// TODO(wan): It might be nice to have a minimally invasive, human-readable +// escaping scheme for invalid characters, rather than dropping them. +std::string XmlUnitTestResultPrinter::EscapeXml( + const std::string& str, bool is_attribute) { + Message m; + + for (size_t i = 0; i < str.size(); ++i) { + const char ch = str[i]; + switch (ch) { + case '<': + m << "<"; + break; + case '>': + m << ">"; + break; + case '&': + m << "&"; + break; + case '\'': + if (is_attribute) + m << "'"; + else + m << '\''; + break; + case '"': + if (is_attribute) + m << """; + else + m << '"'; + break; + default: + if (IsValidXmlCharacter(ch)) { + if (is_attribute && IsNormalizableWhitespace(ch)) + m << "&#x" << String::FormatByte(static_cast(ch)) + << ";"; + else + m << ch; + } + break; + } + } + + return m.GetString(); +} + +// Returns the given string with all characters invalid in XML removed. +// Currently invalid characters are dropped from the string. An +// alternative is to replace them with certain characters such as . or ?. +std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters( + const std::string& str) { + std::string output; + output.reserve(str.size()); + for (std::string::const_iterator it = str.begin(); it != str.end(); ++it) + if (IsValidXmlCharacter(*it)) + output.push_back(*it); + + return output; +} + +// The following routines generate an XML representation of a UnitTest +// object. +// +// This is how Google Test concepts map to the DTD: +// +// <-- corresponds to a UnitTest object +// <-- corresponds to a TestCase object +// <-- corresponds to a TestInfo object +// ... +// ... +// ... +// <-- individual assertion failures +// +// +// + +// Formats the given time in milliseconds as seconds. +std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) { + ::std::stringstream ss; + ss << ms/1000.0; + return ss.str(); +} + +// Converts the given epoch time in milliseconds to a date string in the ISO +// 8601 format, without the timezone information. +std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) { + // Using non-reentrant version as localtime_r is not portable. + time_t seconds = static_cast(ms / 1000); +#ifdef _MSC_VER +# pragma warning(push) // Saves the current warning state. +# pragma warning(disable:4996) // Temporarily disables warning 4996 + // (function or variable may be unsafe). + const struct tm* const time_struct = localtime(&seconds); // NOLINT +# pragma warning(pop) // Restores the warning state again. +#else + const struct tm* const time_struct = localtime(&seconds); // NOLINT +#endif + if (time_struct == NULL) + return ""; // Invalid ms value + + // YYYY-MM-DDThh:mm:ss + return StreamableToString(time_struct->tm_year + 1900) + "-" + + String::FormatIntWidth2(time_struct->tm_mon + 1) + "-" + + String::FormatIntWidth2(time_struct->tm_mday) + "T" + + String::FormatIntWidth2(time_struct->tm_hour) + ":" + + String::FormatIntWidth2(time_struct->tm_min) + ":" + + String::FormatIntWidth2(time_struct->tm_sec); +} + +// Streams an XML CDATA section, escaping invalid CDATA sequences as needed. +void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream, + const char* data) { + const char* segment = data; + *stream << ""); + if (next_segment != NULL) { + stream->write( + segment, static_cast(next_segment - segment)); + *stream << "]]>]]>"); + } else { + *stream << segment; + break; + } + } + *stream << "]]>"; +} + +void XmlUnitTestResultPrinter::OutputXmlAttribute( + std::ostream* stream, + const std::string& element_name, + const std::string& name, + const std::string& value) { + const std::vector& allowed_names = + GetReservedAttributesForElement(element_name); + + GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) != + allowed_names.end()) + << "Attribute " << name << " is not allowed for element <" << element_name + << ">."; + + *stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\""; +} + +// Prints an XML representation of a TestInfo object. +// TODO(wan): There is also value in printing properties with the plain printer. +void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream, + const char* test_case_name, + const TestInfo& test_info) { + const TestResult& result = *test_info.result(); + const std::string kTestcase = "testcase"; + + *stream << " \n"; + } + const string location = internal::FormatCompilerIndependentFileLocation( + part.file_name(), part.line_number()); + const string summary = location + "\n" + part.summary(); + *stream << " "; + const string detail = location + "\n" + part.message(); + OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str()); + *stream << "\n"; + } + } + + if (failures == 0) + *stream << " />\n"; + else + *stream << " \n"; +} + +// Prints an XML representation of a TestCase object +void XmlUnitTestResultPrinter::PrintXmlTestCase(std::ostream* stream, + const TestCase& test_case) { + const std::string kTestsuite = "testsuite"; + *stream << " <" << kTestsuite; + OutputXmlAttribute(stream, kTestsuite, "name", test_case.name()); + OutputXmlAttribute(stream, kTestsuite, "tests", + StreamableToString(test_case.reportable_test_count())); + OutputXmlAttribute(stream, kTestsuite, "failures", + StreamableToString(test_case.failed_test_count())); + OutputXmlAttribute( + stream, kTestsuite, "disabled", + StreamableToString(test_case.reportable_disabled_test_count())); + OutputXmlAttribute(stream, kTestsuite, "errors", "0"); + OutputXmlAttribute(stream, kTestsuite, "time", + FormatTimeInMillisAsSeconds(test_case.elapsed_time())); + *stream << TestPropertiesAsXmlAttributes(test_case.ad_hoc_test_result()) + << ">\n"; + + for (int i = 0; i < test_case.total_test_count(); ++i) { + if (test_case.GetTestInfo(i)->is_reportable()) + OutputXmlTestInfo(stream, test_case.name(), *test_case.GetTestInfo(i)); + } + *stream << " \n"; +} + +// Prints an XML summary of unit_test to output stream out. +void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream, + const UnitTest& unit_test) { + const std::string kTestsuites = "testsuites"; + + *stream << "\n"; + *stream << "<" << kTestsuites; + + OutputXmlAttribute(stream, kTestsuites, "tests", + StreamableToString(unit_test.reportable_test_count())); + OutputXmlAttribute(stream, kTestsuites, "failures", + StreamableToString(unit_test.failed_test_count())); + OutputXmlAttribute( + stream, kTestsuites, "disabled", + StreamableToString(unit_test.reportable_disabled_test_count())); + OutputXmlAttribute(stream, kTestsuites, "errors", "0"); + OutputXmlAttribute( + stream, kTestsuites, "timestamp", + FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp())); + OutputXmlAttribute(stream, kTestsuites, "time", + FormatTimeInMillisAsSeconds(unit_test.elapsed_time())); + + if (GTEST_FLAG(shuffle)) { + OutputXmlAttribute(stream, kTestsuites, "random_seed", + StreamableToString(unit_test.random_seed())); + } + + *stream << TestPropertiesAsXmlAttributes(unit_test.ad_hoc_test_result()); + + OutputXmlAttribute(stream, kTestsuites, "name", "AllTests"); + *stream << ">\n"; + + for (int i = 0; i < unit_test.total_test_case_count(); ++i) { + if (unit_test.GetTestCase(i)->reportable_test_count() > 0) + PrintXmlTestCase(stream, *unit_test.GetTestCase(i)); + } + *stream << "\n"; +} + +// Produces a string representing the test properties in a result as space +// delimited XML attributes based on the property key="value" pairs. +std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes( + const TestResult& result) { + Message attributes; + for (int i = 0; i < result.test_property_count(); ++i) { + const TestProperty& property = result.GetTestProperty(i); + attributes << " " << property.key() << "=" + << "\"" << EscapeXmlAttribute(property.value()) << "\""; + } + return attributes.GetString(); +} + +// End XmlUnitTestResultPrinter + +#if GTEST_CAN_STREAM_RESULTS_ + +// Checks if str contains '=', '&', '%' or '\n' characters. If yes, +// replaces them by "%xx" where xx is their hexadecimal value. For +// example, replaces "=" with "%3D". This algorithm is O(strlen(str)) +// in both time and space -- important as the input str may contain an +// arbitrarily long test failure message and stack trace. +string StreamingListener::UrlEncode(const char* str) { + string result; + result.reserve(strlen(str) + 1); + for (char ch = *str; ch != '\0'; ch = *++str) { + switch (ch) { + case '%': + case '=': + case '&': + case '\n': + result.append("%" + String::FormatByte(static_cast(ch))); + break; + default: + result.push_back(ch); + break; + } + } + return result; +} + +void StreamingListener::SocketWriter::MakeConnection() { + GTEST_CHECK_(sockfd_ == -1) + << "MakeConnection() can't be called when there is already a connection."; + + addrinfo hints; + memset(&hints, 0, sizeof(hints)); + hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6 addresses. + hints.ai_socktype = SOCK_STREAM; + addrinfo* servinfo = NULL; + + // Use the getaddrinfo() to get a linked list of IP addresses for + // the given host name. + const int error_num = getaddrinfo( + host_name_.c_str(), port_num_.c_str(), &hints, &servinfo); + if (error_num != 0) { + GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: " + << gai_strerror(error_num); + } + + // Loop through all the results and connect to the first we can. + for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != NULL; + cur_addr = cur_addr->ai_next) { + sockfd_ = socket( + cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol); + if (sockfd_ != -1) { + // Connect the client socket to the server socket. + if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) { + close(sockfd_); + sockfd_ = -1; + } + } + } + + freeaddrinfo(servinfo); // all done with this structure + + if (sockfd_ == -1) { + GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to " + << host_name_ << ":" << port_num_; + } +} + +// End of class Streaming Listener +#endif // GTEST_CAN_STREAM_RESULTS__ + +// Class ScopedTrace + +// Pushes the given source file location and message onto a per-thread +// trace stack maintained by Google Test. +ScopedTrace::ScopedTrace(const char* file, int line, const Message& message) + GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) { + TraceInfo trace; + trace.file = file; + trace.line = line; + trace.message = message.GetString(); + + UnitTest::GetInstance()->PushGTestTrace(trace); +} + +// Pops the info pushed by the c'tor. +ScopedTrace::~ScopedTrace() + GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) { + UnitTest::GetInstance()->PopGTestTrace(); +} + + +// class OsStackTraceGetter + +// 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. +// +string OsStackTraceGetter::CurrentStackTrace(int /* max_depth */, + int /* skip_count */) + GTEST_LOCK_EXCLUDED_(mutex_) { + return ""; +} + +void OsStackTraceGetter::UponLeavingGTest() + GTEST_LOCK_EXCLUDED_(mutex_) { +} + +const char* const +OsStackTraceGetter::kElidedFramesMarker = + "... " GTEST_NAME_ " internal frames ..."; + +// A helper class that creates the premature-exit file in its +// constructor and deletes the file in its destructor. +class ScopedPrematureExitFile { + public: + explicit ScopedPrematureExitFile(const char* premature_exit_filepath) + : premature_exit_filepath_(premature_exit_filepath) { + // If a path to the premature-exit file is specified... + if (premature_exit_filepath != NULL && *premature_exit_filepath != '\0') { + // create the file with a single "0" character in it. I/O + // errors are ignored as there's nothing better we can do and we + // don't want to fail the test because of this. + FILE* pfile = posix::FOpen(premature_exit_filepath, "w"); + fwrite("0", 1, 1, pfile); + fclose(pfile); + } + } + + ~ScopedPrematureExitFile() { + if (premature_exit_filepath_ != NULL && *premature_exit_filepath_ != '\0') { + remove(premature_exit_filepath_); + } + } + + private: + const char* const premature_exit_filepath_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedPrematureExitFile); +}; + +} // namespace internal + +// class TestEventListeners + +TestEventListeners::TestEventListeners() + : repeater_(new internal::TestEventRepeater()), + default_result_printer_(NULL), + default_xml_generator_(NULL) { +} + +TestEventListeners::~TestEventListeners() { delete repeater_; } + +// Returns the standard listener responsible for the default console +// output. Can be removed from the listeners list to shut down default +// console output. Note that removing this object from the listener list +// with Release transfers its ownership to the user. +void TestEventListeners::Append(TestEventListener* listener) { + repeater_->Append(listener); +} + +// Removes the given event listener from the list and returns it. It then +// becomes the caller's responsibility to delete the listener. Returns +// NULL if the listener is not found in the list. +TestEventListener* TestEventListeners::Release(TestEventListener* listener) { + if (listener == default_result_printer_) + default_result_printer_ = NULL; + else if (listener == default_xml_generator_) + default_xml_generator_ = NULL; + return repeater_->Release(listener); +} + +// Returns repeater that broadcasts the TestEventListener events to all +// subscribers. +TestEventListener* TestEventListeners::repeater() { return repeater_; } + +// Sets the default_result_printer attribute to the provided listener. +// The listener is also added to the listener list and previous +// default_result_printer is removed from it and deleted. The listener can +// also be NULL in which case it will not be added to the list. Does +// nothing if the previous and the current listener objects are the same. +void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) { + if (default_result_printer_ != listener) { + // It is an error to pass this method a listener that is already in the + // list. + delete Release(default_result_printer_); + default_result_printer_ = listener; + if (listener != NULL) + Append(listener); + } +} + +// Sets the default_xml_generator attribute to the provided listener. The +// listener is also added to the listener list and previous +// default_xml_generator is removed from it and deleted. The listener can +// also be NULL in which case it will not be added to the list. Does +// nothing if the previous and the current listener objects are the same. +void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) { + if (default_xml_generator_ != listener) { + // It is an error to pass this method a listener that is already in the + // list. + delete Release(default_xml_generator_); + default_xml_generator_ = listener; + if (listener != NULL) + Append(listener); + } +} + +// Controls whether events will be forwarded by the repeater to the +// listeners in the list. +bool TestEventListeners::EventForwardingEnabled() const { + return repeater_->forwarding_enabled(); +} + +void TestEventListeners::SuppressEventForwarding() { + repeater_->set_forwarding_enabled(false); +} + +// class UnitTest + +// Gets the singleton UnitTest object. The first time this method is +// called, a UnitTest object is constructed and returned. Consecutive +// calls will return the same object. +// +// We don't protect this under mutex_ as a user is not supposed to +// call this before main() starts, from which point on the return +// value will never change. +UnitTest* UnitTest::GetInstance() { + // When compiled with MSVC 7.1 in optimized mode, destroying the + // UnitTest object upon exiting the program messes up the exit code, + // causing successful tests to appear failed. We have to use a + // different implementation in this case to bypass the compiler bug. + // This implementation makes the compiler happy, at the cost of + // leaking the UnitTest object. + + // CodeGear C++Builder insists on a public destructor for the + // default implementation. Use this implementation to keep good OO + // design with private destructor. + +#if (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__) + static UnitTest* const instance = new UnitTest; + return instance; +#else + static UnitTest instance; + return &instance; +#endif // (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__) +} + +// Gets the number of successful test cases. +int UnitTest::successful_test_case_count() const { + return impl()->successful_test_case_count(); +} + +// Gets the number of failed test cases. +int UnitTest::failed_test_case_count() const { + return impl()->failed_test_case_count(); +} + +// Gets the number of all test cases. +int UnitTest::total_test_case_count() const { + return impl()->total_test_case_count(); +} + +// Gets the number of all test cases that contain at least one test +// that should run. +int UnitTest::test_case_to_run_count() const { + return impl()->test_case_to_run_count(); +} + +// Gets the number of successful tests. +int UnitTest::successful_test_count() const { + return impl()->successful_test_count(); +} + +// Gets the number of failed tests. +int UnitTest::failed_test_count() const { return impl()->failed_test_count(); } + +// Gets the number of disabled tests that will be reported in the XML report. +int UnitTest::reportable_disabled_test_count() const { + return impl()->reportable_disabled_test_count(); +} + +// Gets the number of disabled tests. +int UnitTest::disabled_test_count() const { + return impl()->disabled_test_count(); +} + +// Gets the number of tests to be printed in the XML report. +int UnitTest::reportable_test_count() const { + return impl()->reportable_test_count(); +} + +// Gets the number of all tests. +int UnitTest::total_test_count() const { return impl()->total_test_count(); } + +// Gets the number of tests that should run. +int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); } + +// Gets the time of the test program start, in ms from the start of the +// UNIX epoch. +internal::TimeInMillis UnitTest::start_timestamp() const { + return impl()->start_timestamp(); +} + +// Gets the elapsed time, in milliseconds. +internal::TimeInMillis UnitTest::elapsed_time() const { + return impl()->elapsed_time(); +} + +// Returns true iff the unit test passed (i.e. all test cases passed). +bool UnitTest::Passed() const { return impl()->Passed(); } + +// Returns true iff the unit test failed (i.e. some test case failed +// or something outside of all tests failed). +bool UnitTest::Failed() const { return impl()->Failed(); } + +// Gets the i-th test case among all the test cases. i can range from 0 to +// total_test_case_count() - 1. If i is not in that range, returns NULL. +const TestCase* UnitTest::GetTestCase(int i) const { + return impl()->GetTestCase(i); +} + +// Returns the TestResult containing information on test failures and +// properties logged outside of individual test cases. +const TestResult& UnitTest::ad_hoc_test_result() const { + return *impl()->ad_hoc_test_result(); +} + +// Gets the i-th test case among all the test cases. i can range from 0 to +// total_test_case_count() - 1. If i is not in that range, returns NULL. +TestCase* UnitTest::GetMutableTestCase(int i) { + return impl()->GetMutableTestCase(i); +} + +// Returns the list of event listeners that can be used to track events +// inside Google Test. +TestEventListeners& UnitTest::listeners() { + return *impl()->listeners(); +} + +// Registers and returns a global test environment. When a test +// program is run, all global test environments will be set-up in the +// order they were registered. After all tests in the program have +// finished, all global test environments will be torn-down in the +// *reverse* order they were registered. +// +// The UnitTest object takes ownership of the given environment. +// +// We don't protect this under mutex_, as we only support calling it +// from the main thread. +Environment* UnitTest::AddEnvironment(Environment* env) { + if (env == NULL) { + return NULL; + } + + impl_->environments().push_back(env); + return env; +} + +// Adds a TestPartResult to the current TestResult object. All Google Test +// assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call +// this to report their results. The user code should use the +// assertion macros instead of calling this directly. +void UnitTest::AddTestPartResult( + TestPartResult::Type result_type, + const char* file_name, + int line_number, + const std::string& message, + const std::string& os_stack_trace) GTEST_LOCK_EXCLUDED_(mutex_) { + Message msg; + msg << message; + + internal::MutexLock lock(&mutex_); + if (impl_->gtest_trace_stack().size() > 0) { + msg << "\n" << GTEST_NAME_ << " trace:"; + + for (int i = static_cast(impl_->gtest_trace_stack().size()); + i > 0; --i) { + const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i - 1]; + msg << "\n" << internal::FormatFileLocation(trace.file, trace.line) + << " " << trace.message; + } + } + + if (os_stack_trace.c_str() != NULL && !os_stack_trace.empty()) { + msg << internal::kStackTraceMarker << os_stack_trace; + } + + const TestPartResult result = + TestPartResult(result_type, file_name, line_number, + msg.GetString().c_str()); + impl_->GetTestPartResultReporterForCurrentThread()-> + ReportTestPartResult(result); + + if (result_type != TestPartResult::kSuccess) { + // gtest_break_on_failure takes precedence over + // gtest_throw_on_failure. This allows a user to set the latter + // in the code (perhaps in order to use Google Test assertions + // with another testing framework) and specify the former on the + // command line for debugging. + if (GTEST_FLAG(break_on_failure)) { +#if GTEST_OS_WINDOWS + // Using DebugBreak on Windows allows gtest to still break into a debugger + // when a failure happens and both the --gtest_break_on_failure and + // the --gtest_catch_exceptions flags are specified. + DebugBreak(); +#else + // Dereference NULL through a volatile pointer to prevent the compiler + // from removing. We use this rather than abort() or __builtin_trap() for + // portability: Symbian doesn't implement abort() well, and some debuggers + // don't correctly trap abort(). + *static_cast(NULL) = 1; +#endif // GTEST_OS_WINDOWS + } else if (GTEST_FLAG(throw_on_failure)) { +#if GTEST_HAS_EXCEPTIONS + throw internal::GoogleTestFailureException(result); +#else + // We cannot call abort() as it generates a pop-up in debug mode + // that cannot be suppressed in VC 7.1 or below. + exit(1); +#endif + } + } +} + +// Adds a TestProperty to the current TestResult object when invoked from +// inside a test, to current TestCase's ad_hoc_test_result_ when invoked +// from SetUpTestCase or TearDownTestCase, or to the global property set +// when invoked elsewhere. If the result already contains a property with +// the same key, the value will be updated. +void UnitTest::RecordProperty(const std::string& key, + const std::string& value) { + impl_->RecordProperty(TestProperty(key, value)); +} + +// Runs all tests in this UnitTest object and prints the result. +// Returns 0 if successful, or 1 otherwise. +// +// We don't protect this under mutex_, as we only support calling it +// from the main thread. +int UnitTest::Run() { + const bool in_death_test_child_process = + internal::GTEST_FLAG(internal_run_death_test).length() > 0; + + // Google Test implements this protocol for catching that a test + // program exits before returning control to Google Test: + // + // 1. Upon start, Google Test creates a file whose absolute path + // is specified by the environment variable + // TEST_PREMATURE_EXIT_FILE. + // 2. When Google Test has finished its work, it deletes the file. + // + // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before + // running a Google-Test-based test program and check the existence + // of the file at the end of the test execution to see if it has + // exited prematurely. + + // If we are in the child process of a death test, don't + // create/delete the premature exit file, as doing so is unnecessary + // and will confuse the parent process. Otherwise, create/delete + // the file upon entering/leaving this function. If the program + // somehow exits before this function has a chance to return, the + // premature-exit file will be left undeleted, causing a test runner + // that understands the premature-exit-file protocol to report the + // test as having failed. + const internal::ScopedPrematureExitFile premature_exit_file( + in_death_test_child_process ? + NULL : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE")); + + // Captures the value of GTEST_FLAG(catch_exceptions). This value will be + // used for the duration of the program. + impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions)); + +#if GTEST_HAS_SEH + // Either the user wants Google Test to catch exceptions thrown by the + // tests or this is executing in the context of death test child + // process. In either case the user does not want to see pop-up dialogs + // about crashes - they are expected. + if (impl()->catch_exceptions() || in_death_test_child_process) { +# if !GTEST_OS_WINDOWS_MOBILE + // SetErrorMode doesn't exist on CE. + SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT | + SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX); +# endif // !GTEST_OS_WINDOWS_MOBILE + +# if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE + // Death test children can be terminated with _abort(). On Windows, + // _abort() can show a dialog with a warning message. This forces the + // abort message to go to stderr instead. + _set_error_mode(_OUT_TO_STDERR); +# endif + +# if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE + // In the debug version, Visual Studio pops up a separate dialog + // offering a choice to debug the aborted program. We need to suppress + // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement + // executed. Google Test will notify the user of any unexpected + // failure via stderr. + // + // VC++ doesn't define _set_abort_behavior() prior to the version 8.0. + // Users of prior VC versions shall suffer the agony and pain of + // clicking through the countless debug dialogs. + // TODO(vladl@google.com): find a way to suppress the abort dialog() in the + // debug mode when compiled with VC 7.1 or lower. + if (!GTEST_FLAG(break_on_failure)) + _set_abort_behavior( + 0x0, // Clear the following flags: + _WRITE_ABORT_MSG | _CALL_REPORTFAULT); // pop-up window, core dump. +# endif + } +#endif // GTEST_HAS_SEH + + return internal::HandleExceptionsInMethodIfSupported( + impl(), + &internal::UnitTestImpl::RunAllTests, + "auxiliary test code (environments or event listeners)") ? 0 : 1; +} + +// Returns the working directory when the first TEST() or TEST_F() was +// executed. +const char* UnitTest::original_working_dir() const { + return impl_->original_working_dir_.c_str(); +} + +// Returns the TestCase object for the test that's currently running, +// or NULL if no test is running. +const TestCase* UnitTest::current_test_case() const + GTEST_LOCK_EXCLUDED_(mutex_) { + internal::MutexLock lock(&mutex_); + return impl_->current_test_case(); +} + +// Returns the TestInfo object for the test that's currently running, +// or NULL if no test is running. +const TestInfo* UnitTest::current_test_info() const + GTEST_LOCK_EXCLUDED_(mutex_) { + internal::MutexLock lock(&mutex_); + return impl_->current_test_info(); +} + +// Returns the random seed used at the start of the current test run. +int UnitTest::random_seed() const { return impl_->random_seed(); } + +#if GTEST_HAS_PARAM_TEST +// Returns ParameterizedTestCaseRegistry object used to keep track of +// value-parameterized tests and instantiate and register them. +internal::ParameterizedTestCaseRegistry& + UnitTest::parameterized_test_registry() + GTEST_LOCK_EXCLUDED_(mutex_) { + return impl_->parameterized_test_registry(); +} +#endif // GTEST_HAS_PARAM_TEST + +// Creates an empty UnitTest. +UnitTest::UnitTest() { + impl_ = new internal::UnitTestImpl(this); +} + +// Destructor of UnitTest. +UnitTest::~UnitTest() { + delete impl_; +} + +// Pushes a trace defined by SCOPED_TRACE() on to the per-thread +// Google Test trace stack. +void UnitTest::PushGTestTrace(const internal::TraceInfo& trace) + GTEST_LOCK_EXCLUDED_(mutex_) { + internal::MutexLock lock(&mutex_); + impl_->gtest_trace_stack().push_back(trace); +} + +// Pops a trace from the per-thread Google Test trace stack. +void UnitTest::PopGTestTrace() + GTEST_LOCK_EXCLUDED_(mutex_) { + internal::MutexLock lock(&mutex_); + impl_->gtest_trace_stack().pop_back(); +} + +namespace internal { + +UnitTestImpl::UnitTestImpl(UnitTest* parent) + : parent_(parent), +#ifdef _MSC_VER +# pragma warning(push) // Saves the current warning state. +# pragma warning(disable:4355) // Temporarily disables warning 4355 + // (using this in initializer). + default_global_test_part_result_reporter_(this), + default_per_thread_test_part_result_reporter_(this), +# pragma warning(pop) // Restores the warning state again. +#else + default_global_test_part_result_reporter_(this), + default_per_thread_test_part_result_reporter_(this), +#endif // _MSC_VER + global_test_part_result_repoter_( + &default_global_test_part_result_reporter_), + per_thread_test_part_result_reporter_( + &default_per_thread_test_part_result_reporter_), +#if GTEST_HAS_PARAM_TEST + parameterized_test_registry_(), + parameterized_tests_registered_(false), +#endif // GTEST_HAS_PARAM_TEST + last_death_test_case_(-1), + current_test_case_(NULL), + current_test_info_(NULL), + ad_hoc_test_result_(), + os_stack_trace_getter_(NULL), + post_flag_parse_init_performed_(false), + random_seed_(0), // Will be overridden by the flag before first use. + random_(0), // Will be reseeded before first use. + start_timestamp_(0), + elapsed_time_(0), +#if GTEST_HAS_DEATH_TEST + death_test_factory_(new DefaultDeathTestFactory), +#endif + // Will be overridden by the flag before first use. + catch_exceptions_(false) { + listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter); +} + +UnitTestImpl::~UnitTestImpl() { + // Deletes every TestCase. + ForEach(test_cases_, internal::Delete); + + // Deletes every Environment. + ForEach(environments_, internal::Delete); + + delete os_stack_trace_getter_; +} + +// Adds a TestProperty to the current TestResult object when invoked in a +// context of a test, to current test case's ad_hoc_test_result when invoke +// from SetUpTestCase/TearDownTestCase, or to the global property set +// otherwise. If the result already contains a property with the same key, +// the value will be updated. +void UnitTestImpl::RecordProperty(const TestProperty& test_property) { + std::string xml_element; + TestResult* test_result; // TestResult appropriate for property recording. + + if (current_test_info_ != NULL) { + xml_element = "testcase"; + test_result = &(current_test_info_->result_); + } else if (current_test_case_ != NULL) { + xml_element = "testsuite"; + test_result = &(current_test_case_->ad_hoc_test_result_); + } else { + xml_element = "testsuites"; + test_result = &ad_hoc_test_result_; + } + test_result->RecordProperty(xml_element, test_property); +} + +#if GTEST_HAS_DEATH_TEST +// Disables event forwarding if the control is currently in a death test +// subprocess. Must not be called before InitGoogleTest. +void UnitTestImpl::SuppressTestEventsIfInSubprocess() { + if (internal_run_death_test_flag_.get() != NULL) + listeners()->SuppressEventForwarding(); +} +#endif // GTEST_HAS_DEATH_TEST + +// Initializes event listeners performing XML output as specified by +// UnitTestOptions. Must not be called before InitGoogleTest. +void UnitTestImpl::ConfigureXmlOutput() { + const std::string& output_format = UnitTestOptions::GetOutputFormat(); + if (output_format == "xml") { + listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter( + UnitTestOptions::GetAbsolutePathToOutputFile().c_str())); + } else if (output_format != "") { + printf("WARNING: unrecognized output format \"%s\" ignored.\n", + output_format.c_str()); + fflush(stdout); + } +} + +#if GTEST_CAN_STREAM_RESULTS_ +// Initializes event listeners for streaming test results in string form. +// Must not be called before InitGoogleTest. +void UnitTestImpl::ConfigureStreamingOutput() { + const std::string& target = GTEST_FLAG(stream_result_to); + if (!target.empty()) { + const size_t pos = target.find(':'); + if (pos != std::string::npos) { + listeners()->Append(new StreamingListener(target.substr(0, pos), + target.substr(pos+1))); + } else { + printf("WARNING: unrecognized streaming target \"%s\" ignored.\n", + target.c_str()); + fflush(stdout); + } + } +} +#endif // GTEST_CAN_STREAM_RESULTS_ + +// Performs initialization dependent upon flag values obtained in +// ParseGoogleTestFlagsOnly. Is called from InitGoogleTest after the call to +// ParseGoogleTestFlagsOnly. In case a user neglects to call InitGoogleTest +// this function is also called from RunAllTests. Since this function can be +// called more than once, it has to be idempotent. +void UnitTestImpl::PostFlagParsingInit() { + // Ensures that this function does not execute more than once. + if (!post_flag_parse_init_performed_) { + post_flag_parse_init_performed_ = true; + +#if GTEST_HAS_DEATH_TEST + InitDeathTestSubprocessControlInfo(); + SuppressTestEventsIfInSubprocess(); +#endif // GTEST_HAS_DEATH_TEST + + // Registers parameterized tests. This makes parameterized tests + // available to the UnitTest reflection API without running + // RUN_ALL_TESTS. + RegisterParameterizedTests(); + + // Configures listeners for XML output. This makes it possible for users + // to shut down the default XML output before invoking RUN_ALL_TESTS. + ConfigureXmlOutput(); + +#if GTEST_CAN_STREAM_RESULTS_ + // Configures listeners for streaming test results to the specified server. + ConfigureStreamingOutput(); +#endif // GTEST_CAN_STREAM_RESULTS_ + } +} + +// A predicate that checks the name of a TestCase against a known +// value. +// +// This is used for implementation of the UnitTest class only. We put +// it in the anonymous namespace to prevent polluting the outer +// namespace. +// +// TestCaseNameIs is copyable. +class TestCaseNameIs { + public: + // Constructor. + explicit TestCaseNameIs(const std::string& name) + : name_(name) {} + + // Returns true iff the name of test_case matches name_. + bool operator()(const TestCase* test_case) const { + return test_case != NULL && strcmp(test_case->name(), name_.c_str()) == 0; + } + + private: + std::string name_; +}; + +// Finds and returns a TestCase with the given name. If one doesn't +// exist, creates one and returns it. It's the CALLER'S +// RESPONSIBILITY to ensure that this function is only called WHEN THE +// TESTS ARE NOT SHUFFLED. +// +// Arguments: +// +// test_case_name: name of the test case +// type_param: the name of the test case's type parameter, or NULL if +// this is not a typed or a type-parameterized test case. +// set_up_tc: pointer to the function that sets up the test case +// tear_down_tc: pointer to the function that tears down the test case +TestCase* UnitTestImpl::GetTestCase(const char* test_case_name, + const char* type_param, + Test::SetUpTestCaseFunc set_up_tc, + Test::TearDownTestCaseFunc tear_down_tc) { + // Can we find a TestCase with the given name? + const std::vector::const_iterator test_case = + std::find_if(test_cases_.begin(), test_cases_.end(), + TestCaseNameIs(test_case_name)); + + if (test_case != test_cases_.end()) + return *test_case; + + // No. Let's create one. + TestCase* const new_test_case = + new TestCase(test_case_name, type_param, set_up_tc, tear_down_tc); + + // Is this a death test case? + if (internal::UnitTestOptions::MatchesFilter(test_case_name, + kDeathTestCaseFilter)) { + // Yes. Inserts the test case after the last death test case + // defined so far. This only works when the test cases haven't + // been shuffled. Otherwise we may end up running a death test + // after a non-death test. + ++last_death_test_case_; + test_cases_.insert(test_cases_.begin() + last_death_test_case_, + new_test_case); + } else { + // No. Appends to the end of the list. + test_cases_.push_back(new_test_case); + } + + test_case_indices_.push_back(static_cast(test_case_indices_.size())); + return new_test_case; +} + +// Helpers for setting up / tearing down the given environment. They +// are for use in the ForEach() function. +static void SetUpEnvironment(Environment* env) { env->SetUp(); } +static void TearDownEnvironment(Environment* env) { env->TearDown(); } + +// Runs all tests in this UnitTest object, prints the result, and +// returns true if all tests are successful. If any exception is +// thrown during a test, the test is considered to be failed, but the +// rest of the tests will still be run. +// +// When parameterized tests are enabled, it expands and registers +// parameterized tests first in RegisterParameterizedTests(). +// All other functions called from RunAllTests() may safely assume that +// parameterized tests are ready to be counted and run. +bool UnitTestImpl::RunAllTests() { + // Makes sure InitGoogleTest() was called. + if (!GTestIsInitialized()) { + printf("%s", + "\nThis test program did NOT call ::testing::InitGoogleTest " + "before calling RUN_ALL_TESTS(). Please fix it.\n"); + return false; + } + + // Do not run any test if the --help flag was specified. + if (g_help_flag) + return true; + + // Repeats the call to the post-flag parsing initialization in case the + // user didn't call InitGoogleTest. + PostFlagParsingInit(); + + // Even if sharding is not on, test runners may want to use the + // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding + // protocol. + internal::WriteToShardStatusFileIfNeeded(); + + // True iff we are in a subprocess for running a thread-safe-style + // death test. + bool in_subprocess_for_death_test = false; + +#if GTEST_HAS_DEATH_TEST + in_subprocess_for_death_test = (internal_run_death_test_flag_.get() != NULL); +#endif // GTEST_HAS_DEATH_TEST + + const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex, + in_subprocess_for_death_test); + + // Compares the full test names with the filter to decide which + // tests to run. + const bool has_tests_to_run = FilterTests(should_shard + ? HONOR_SHARDING_PROTOCOL + : IGNORE_SHARDING_PROTOCOL) > 0; + + // Lists the tests and exits if the --gtest_list_tests flag was specified. + if (GTEST_FLAG(list_tests)) { + // This must be called *after* FilterTests() has been called. + ListTestsMatchingFilter(); + return true; + } + + random_seed_ = GTEST_FLAG(shuffle) ? + GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0; + + // True iff at least one test has failed. + bool failed = false; + + TestEventListener* repeater = listeners()->repeater(); + + start_timestamp_ = GetTimeInMillis(); + repeater->OnTestProgramStart(*parent_); + + // How many times to repeat the tests? We don't want to repeat them + // when we are inside the subprocess of a death test. + const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat); + // Repeats forever if the repeat count is negative. + const bool forever = repeat < 0; + for (int i = 0; forever || i != repeat; i++) { + // We want to preserve failures generated by ad-hoc test + // assertions executed before RUN_ALL_TESTS(). + ClearNonAdHocTestResult(); + + const TimeInMillis start = GetTimeInMillis(); + + // Shuffles test cases and tests if requested. + if (has_tests_to_run && GTEST_FLAG(shuffle)) { + random()->Reseed(random_seed_); + // This should be done before calling OnTestIterationStart(), + // such that a test event listener can see the actual test order + // in the event. + ShuffleTests(); + } + + // Tells the unit test event listeners that the tests are about to start. + repeater->OnTestIterationStart(*parent_, i); + + // Runs each test case if there is at least one test to run. + if (has_tests_to_run) { + // Sets up all environments beforehand. + repeater->OnEnvironmentsSetUpStart(*parent_); + ForEach(environments_, SetUpEnvironment); + repeater->OnEnvironmentsSetUpEnd(*parent_); + + // Runs the tests only if there was no fatal failure during global + // set-up. + if (!Test::HasFatalFailure()) { + for (int test_index = 0; test_index < total_test_case_count(); + test_index++) { + GetMutableTestCase(test_index)->Run(); + } + } + + // Tears down all environments in reverse order afterwards. + repeater->OnEnvironmentsTearDownStart(*parent_); + std::for_each(environments_.rbegin(), environments_.rend(), + TearDownEnvironment); + repeater->OnEnvironmentsTearDownEnd(*parent_); + } + + elapsed_time_ = GetTimeInMillis() - start; + + // Tells the unit test event listener that the tests have just finished. + repeater->OnTestIterationEnd(*parent_, i); + + // Gets the result and clears it. + if (!Passed()) { + failed = true; + } + + // Restores the original test order after the iteration. This + // allows the user to quickly repro a failure that happens in the + // N-th iteration without repeating the first (N - 1) iterations. + // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in + // case the user somehow changes the value of the flag somewhere + // (it's always safe to unshuffle the tests). + UnshuffleTests(); + + if (GTEST_FLAG(shuffle)) { + // Picks a new random seed for each iteration. + random_seed_ = GetNextRandomSeed(random_seed_); + } + } + + repeater->OnTestProgramEnd(*parent_); + + return !failed; +} + +// 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() { + const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile); + if (test_shard_file != NULL) { + FILE* const file = posix::FOpen(test_shard_file, "w"); + if (file == NULL) { + ColoredPrintf(COLOR_RED, + "Could not write to the test shard status file \"%s\" " + "specified by the %s environment variable.\n", + test_shard_file, kTestShardStatusFile); + fflush(stdout); + exit(EXIT_FAILURE); + } + fclose(file); + } +} + +// Checks whether sharding is enabled by examining the relevant +// environment variable values. If the variables are present, +// but inconsistent (i.e., 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. +bool ShouldShard(const char* total_shards_env, + const char* shard_index_env, + bool in_subprocess_for_death_test) { + if (in_subprocess_for_death_test) { + return false; + } + + const Int32 total_shards = Int32FromEnvOrDie(total_shards_env, -1); + const Int32 shard_index = Int32FromEnvOrDie(shard_index_env, -1); + + if (total_shards == -1 && shard_index == -1) { + return false; + } else if (total_shards == -1 && shard_index != -1) { + const Message msg = Message() + << "Invalid environment variables: you have " + << kTestShardIndex << " = " << shard_index + << ", but have left " << kTestTotalShards << " unset.\n"; + ColoredPrintf(COLOR_RED, msg.GetString().c_str()); + fflush(stdout); + exit(EXIT_FAILURE); + } else if (total_shards != -1 && shard_index == -1) { + const Message msg = Message() + << "Invalid environment variables: you have " + << kTestTotalShards << " = " << total_shards + << ", but have left " << kTestShardIndex << " unset.\n"; + ColoredPrintf(COLOR_RED, msg.GetString().c_str()); + fflush(stdout); + exit(EXIT_FAILURE); + } else if (shard_index < 0 || shard_index >= total_shards) { + const Message msg = Message() + << "Invalid environment variables: we require 0 <= " + << kTestShardIndex << " < " << kTestTotalShards + << ", but you have " << kTestShardIndex << "=" << shard_index + << ", " << kTestTotalShards << "=" << total_shards << ".\n"; + ColoredPrintf(COLOR_RED, msg.GetString().c_str()); + fflush(stdout); + exit(EXIT_FAILURE); + } + + return total_shards > 1; +} + +// Parses the environment variable var as an Int32. If it is unset, +// returns default_val. If it is not an Int32, prints an error +// and aborts. +Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) { + const char* str_val = posix::GetEnv(var); + if (str_val == NULL) { + return default_val; + } + + Int32 result; + if (!ParseInt32(Message() << "The value of environment variable " << var, + str_val, &result)) { + exit(EXIT_FAILURE); + } + return result; +} + +// Given the total number of shards, the shard index, and the test id, +// returns true iff 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. +bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) { + return (test_id % total_shards) == shard_index; +} + +// Compares the name of each test with the user-specified filter to +// decide whether the test should be run, then records the result in +// each TestCase and TestInfo object. +// If shard_tests == true, further filters tests based on sharding +// variables in the environment - see +// http://code.google.com/p/googletest/wiki/GoogleTestAdvancedGuide. +// Returns the number of tests that should run. +int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) { + const Int32 total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ? + Int32FromEnvOrDie(kTestTotalShards, -1) : -1; + const Int32 shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ? + Int32FromEnvOrDie(kTestShardIndex, -1) : -1; + + // num_runnable_tests are the number of tests that will + // run across all shards (i.e., match filter and are not disabled). + // num_selected_tests are the number of tests to be run on + // this shard. + int num_runnable_tests = 0; + int num_selected_tests = 0; + for (size_t i = 0; i < test_cases_.size(); i++) { + TestCase* const test_case = test_cases_[i]; + const std::string &test_case_name = test_case->name(); + test_case->set_should_run(false); + + for (size_t j = 0; j < test_case->test_info_list().size(); j++) { + TestInfo* const test_info = test_case->test_info_list()[j]; + const std::string test_name(test_info->name()); + // A test is disabled if test case name or test name matches + // kDisableTestFilter. + const bool is_disabled = + internal::UnitTestOptions::MatchesFilter(test_case_name, + kDisableTestFilter) || + internal::UnitTestOptions::MatchesFilter(test_name, + kDisableTestFilter); + test_info->is_disabled_ = is_disabled; + + const bool matches_filter = + internal::UnitTestOptions::FilterMatchesTest(test_case_name, + test_name); + test_info->matches_filter_ = matches_filter; + + const bool is_runnable = + (GTEST_FLAG(also_run_disabled_tests) || !is_disabled) && + matches_filter; + + const bool is_selected = is_runnable && + (shard_tests == IGNORE_SHARDING_PROTOCOL || + ShouldRunTestOnShard(total_shards, shard_index, + num_runnable_tests)); + + num_runnable_tests += is_runnable; + num_selected_tests += is_selected; + + test_info->should_run_ = is_selected; + test_case->set_should_run(test_case->should_run() || is_selected); + } + } + return num_selected_tests; +} + +// Prints the given C-string on a single line by replacing all '\n' +// characters with string "\\n". If the output takes more than +// max_length characters, only prints the first max_length characters +// and "...". +static void PrintOnOneLine(const char* str, int max_length) { + if (str != NULL) { + for (int i = 0; *str != '\0'; ++str) { + if (i >= max_length) { + printf("..."); + break; + } + if (*str == '\n') { + printf("\\n"); + i += 2; + } else { + printf("%c", *str); + ++i; + } + } + } +} + +// Prints the names of the tests matching the user-specified filter flag. +void UnitTestImpl::ListTestsMatchingFilter() { + // Print at most this many characters for each type/value parameter. + const int kMaxParamLength = 250; + + for (size_t i = 0; i < test_cases_.size(); i++) { + const TestCase* const test_case = test_cases_[i]; + bool printed_test_case_name = false; + + for (size_t j = 0; j < test_case->test_info_list().size(); j++) { + const TestInfo* const test_info = + test_case->test_info_list()[j]; + if (test_info->matches_filter_) { + if (!printed_test_case_name) { + printed_test_case_name = true; + printf("%s.", test_case->name()); + if (test_case->type_param() != NULL) { + printf(" # %s = ", kTypeParamLabel); + // We print the type parameter on a single line to make + // the output easy to parse by a program. + PrintOnOneLine(test_case->type_param(), kMaxParamLength); + } + printf("\n"); + } + printf(" %s", test_info->name()); + if (test_info->value_param() != NULL) { + printf(" # %s = ", kValueParamLabel); + // We print the value parameter on a single line to make the + // output easy to parse by a program. + PrintOnOneLine(test_info->value_param(), kMaxParamLength); + } + printf("\n"); + } + } + } + fflush(stdout); +} + +// Sets the OS stack trace getter. +// +// Does nothing if the input and the current OS stack trace getter are +// the same; otherwise, deletes the old getter and makes the input the +// current getter. +void UnitTestImpl::set_os_stack_trace_getter( + OsStackTraceGetterInterface* getter) { + if (os_stack_trace_getter_ != getter) { + delete os_stack_trace_getter_; + os_stack_trace_getter_ = getter; + } +} + +// Returns the current OS stack trace getter if it is not NULL; +// otherwise, creates an OsStackTraceGetter, makes it the current +// getter, and returns it. +OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() { + if (os_stack_trace_getter_ == NULL) { + os_stack_trace_getter_ = new OsStackTraceGetter; + } + + return os_stack_trace_getter_; +} + +// Returns the TestResult for the test that's currently running, or +// the TestResult for the ad hoc test if no test is running. +TestResult* UnitTestImpl::current_test_result() { + return current_test_info_ ? + &(current_test_info_->result_) : &ad_hoc_test_result_; +} + +// Shuffles all test cases, and the tests within each test case, +// making sure that death tests are still run first. +void UnitTestImpl::ShuffleTests() { + // Shuffles the death test cases. + ShuffleRange(random(), 0, last_death_test_case_ + 1, &test_case_indices_); + + // Shuffles the non-death test cases. + ShuffleRange(random(), last_death_test_case_ + 1, + static_cast(test_cases_.size()), &test_case_indices_); + + // Shuffles the tests inside each test case. + for (size_t i = 0; i < test_cases_.size(); i++) { + test_cases_[i]->ShuffleTests(random()); + } +} + +// Restores the test cases and tests to their order before the first shuffle. +void UnitTestImpl::UnshuffleTests() { + for (size_t i = 0; i < test_cases_.size(); i++) { + // Unshuffles the tests in each test case. + test_cases_[i]->UnshuffleTests(); + // Resets the index of each test case. + test_case_indices_[i] = static_cast(i); + } +} + +// Returns the current OS stack trace as an std::string. +// +// The maximum number of stack frames to be included is specified by +// the gtest_stack_trace_depth flag. The skip_count parameter +// specifies the number of top frames to be skipped, which doesn't +// count against the number of frames to be included. +// +// For example, if Foo() calls Bar(), which in turn calls +// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in +// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't. +std::string GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/, + int skip_count) { + // We pass skip_count + 1 to skip this wrapper function in addition + // to what the user really wants to skip. + return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1); +} + +// Used by the GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_ macro to +// suppress unreachable code warnings. +namespace { +class ClassUniqueToAlwaysTrue {}; +} + +bool IsTrue(bool condition) { return condition; } + +bool AlwaysTrue() { +#if GTEST_HAS_EXCEPTIONS + // This condition is always false so AlwaysTrue() never actually throws, + // but it makes the compiler think that it may throw. + if (IsTrue(false)) + throw ClassUniqueToAlwaysTrue(); +#endif // GTEST_HAS_EXCEPTIONS + return true; +} + +// If *pstr starts with the given prefix, modifies *pstr to be right +// past the prefix and returns true; otherwise leaves *pstr unchanged +// and returns false. None of pstr, *pstr, and prefix can be NULL. +bool SkipPrefix(const char* prefix, const char** pstr) { + const size_t prefix_len = strlen(prefix); + if (strncmp(*pstr, prefix, prefix_len) == 0) { + *pstr += prefix_len; + return true; + } + return false; +} + +// Parses a string as a command line flag. The string should have +// the format "--flag=value". When def_optional is true, the "=value" +// part can be omitted. +// +// Returns the value of the flag, or NULL if the parsing failed. +const char* ParseFlagValue(const char* str, + const char* flag, + bool def_optional) { + // str and flag must not be NULL. + if (str == NULL || flag == NULL) return NULL; + + // The flag must start with "--" followed by GTEST_FLAG_PREFIX_. + const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag; + const size_t flag_len = flag_str.length(); + if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL; + + // Skips the flag name. + const char* flag_end = str + flag_len; + + // When def_optional is true, it's OK to not have a "=value" part. + if (def_optional && (flag_end[0] == '\0')) { + return flag_end; + } + + // If def_optional is true and there are more characters after the + // flag name, or if def_optional is false, there must be a '=' after + // the flag name. + if (flag_end[0] != '=') return NULL; + + // Returns the string after "=". + return flag_end + 1; +} + +// Parses a string for a bool flag, in the form of either +// "--flag=value" or "--flag". +// +// In the former case, the value is taken as true as long as it does +// not start with '0', 'f', or 'F'. +// +// In the latter case, the value is taken as true. +// +// On success, stores the value of the flag in *value, and returns +// true. On failure, returns false without changing *value. +bool ParseBoolFlag(const char* str, const char* flag, bool* value) { + // Gets the value of the flag as a string. + const char* const value_str = ParseFlagValue(str, flag, true); + + // Aborts if the parsing failed. + if (value_str == NULL) return false; + + // Converts the string value to a bool. + *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F'); + return true; +} + +// 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. +bool ParseInt32Flag(const char* str, const char* flag, Int32* value) { + // Gets the value of the flag as a string. + const char* const value_str = ParseFlagValue(str, flag, false); + + // Aborts if the parsing failed. + if (value_str == NULL) return false; + + // Sets *value to the value of the flag. + return ParseInt32(Message() << "The value of flag --" << flag, + value_str, value); +} + +// Parses a string for a string 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. +bool ParseStringFlag(const char* str, const char* flag, std::string* value) { + // Gets the value of the flag as a string. + const char* const value_str = ParseFlagValue(str, flag, false); + + // Aborts if the parsing failed. + if (value_str == NULL) return false; + + // Sets *value to the value of the flag. + *value = value_str; + return true; +} + +// Determines whether a string has a prefix that Google Test uses for its +// flags, i.e., starts with GTEST_FLAG_PREFIX_ or GTEST_FLAG_PREFIX_DASH_. +// If Google Test detects that a command line flag has its prefix but is not +// recognized, it will print its help message. Flags starting with +// GTEST_INTERNAL_PREFIX_ followed by "internal_" are considered Google Test +// internal flags and do not trigger the help message. +static bool HasGoogleTestFlagPrefix(const char* str) { + return (SkipPrefix("--", &str) || + SkipPrefix("-", &str) || + SkipPrefix("/", &str)) && + !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) && + (SkipPrefix(GTEST_FLAG_PREFIX_, &str) || + SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str)); +} + +// Prints a string containing code-encoded text. The following escape +// sequences can be used in the string to control the text color: +// +// @@ prints a single '@' character. +// @R changes the color to red. +// @G changes the color to green. +// @Y changes the color to yellow. +// @D changes to the default terminal text color. +// +// TODO(wan@google.com): Write tests for this once we add stdout +// capturing to Google Test. +static void PrintColorEncoded(const char* str) { + GTestColor color = COLOR_DEFAULT; // The current color. + + // Conceptually, we split the string into segments divided by escape + // sequences. Then we print one segment at a time. At the end of + // each iteration, the str pointer advances to the beginning of the + // next segment. + for (;;) { + const char* p = strchr(str, '@'); + if (p == NULL) { + ColoredPrintf(color, "%s", str); + return; + } + + ColoredPrintf(color, "%s", std::string(str, p).c_str()); + + const char ch = p[1]; + str = p + 2; + if (ch == '@') { + ColoredPrintf(color, "@"); + } else if (ch == 'D') { + color = COLOR_DEFAULT; + } else if (ch == 'R') { + color = COLOR_RED; + } else if (ch == 'G') { + color = COLOR_GREEN; + } else if (ch == 'Y') { + color = COLOR_YELLOW; + } else { + --str; + } + } +} + +static const char kColorEncodedHelpMessage[] = +"This program contains tests written using " GTEST_NAME_ ". You can use the\n" +"following command line flags to control its behavior:\n" +"\n" +"Test Selection:\n" +" @G--" GTEST_FLAG_PREFIX_ "list_tests@D\n" +" List the names of all tests instead of running them. The name of\n" +" TEST(Foo, Bar) is \"Foo.Bar\".\n" +" @G--" GTEST_FLAG_PREFIX_ "filter=@YPOSTIVE_PATTERNS" + "[@G-@YNEGATIVE_PATTERNS]@D\n" +" Run only the tests whose name matches one of the positive patterns but\n" +" none of the negative patterns. '?' matches any single character; '*'\n" +" matches any substring; ':' separates two patterns.\n" +" @G--" GTEST_FLAG_PREFIX_ "also_run_disabled_tests@D\n" +" Run all disabled tests too.\n" +"\n" +"Test Execution:\n" +" @G--" GTEST_FLAG_PREFIX_ "repeat=@Y[COUNT]@D\n" +" Run the tests repeatedly; use a negative count to repeat forever.\n" +" @G--" GTEST_FLAG_PREFIX_ "shuffle@D\n" +" Randomize tests' orders on every iteration.\n" +" @G--" GTEST_FLAG_PREFIX_ "random_seed=@Y[NUMBER]@D\n" +" Random number seed to use for shuffling test orders (between 1 and\n" +" 99999, or 0 to use a seed based on the current time).\n" +"\n" +"Test Output:\n" +" @G--" GTEST_FLAG_PREFIX_ "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n" +" Enable/disable colored output. The default is @Gauto@D.\n" +" -@G-" GTEST_FLAG_PREFIX_ "print_time=0@D\n" +" Don't print the elapsed time of each test.\n" +" @G--" GTEST_FLAG_PREFIX_ "output=xml@Y[@G:@YDIRECTORY_PATH@G" + GTEST_PATH_SEP_ "@Y|@G:@YFILE_PATH]@D\n" +" Generate an XML report in the given directory or with the given file\n" +" name. @YFILE_PATH@D defaults to @Gtest_details.xml@D.\n" +#if GTEST_CAN_STREAM_RESULTS_ +" @G--" GTEST_FLAG_PREFIX_ "stream_result_to=@YHOST@G:@YPORT@D\n" +" Stream test results to the given server.\n" +#endif // GTEST_CAN_STREAM_RESULTS_ +"\n" +"Assertion Behavior:\n" +#if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS +" @G--" GTEST_FLAG_PREFIX_ "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n" +" Set the default death test style.\n" +#endif // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS +" @G--" GTEST_FLAG_PREFIX_ "break_on_failure@D\n" +" Turn assertion failures into debugger break-points.\n" +" @G--" GTEST_FLAG_PREFIX_ "throw_on_failure@D\n" +" Turn assertion failures into C++ exceptions.\n" +" @G--" GTEST_FLAG_PREFIX_ "catch_exceptions=0@D\n" +" Do not report exceptions as test failures. Instead, allow them\n" +" to crash the program or throw a pop-up (on Windows).\n" +"\n" +"Except for @G--" GTEST_FLAG_PREFIX_ "list_tests@D, you can alternatively set " + "the corresponding\n" +"environment variable of a flag (all letters in upper-case). For example, to\n" +"disable colored text output, you can either specify @G--" GTEST_FLAG_PREFIX_ + "color=no@D or set\n" +"the @G" GTEST_FLAG_PREFIX_UPPER_ "COLOR@D environment variable to @Gno@D.\n" +"\n" +"For more information, please read the " GTEST_NAME_ " documentation at\n" +"@G" GTEST_PROJECT_URL_ "@D. If you find a bug in " GTEST_NAME_ "\n" +"(not one in your own code or tests), please report it to\n" +"@G<" GTEST_DEV_EMAIL_ ">@D.\n"; + +// Parses the command line for Google Test flags, without initializing +// other parts of Google Test. The type parameter CharType can be +// instantiated to either char or wchar_t. +template +void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) { + for (int i = 1; i < *argc; i++) { + const std::string arg_string = StreamableToString(argv[i]); + const char* const arg = arg_string.c_str(); + + using internal::ParseBoolFlag; + using internal::ParseInt32Flag; + using internal::ParseStringFlag; + + // Do we see a Google Test flag? + if (ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag, + >EST_FLAG(also_run_disabled_tests)) || + ParseBoolFlag(arg, kBreakOnFailureFlag, + >EST_FLAG(break_on_failure)) || + ParseBoolFlag(arg, kCatchExceptionsFlag, + >EST_FLAG(catch_exceptions)) || + ParseStringFlag(arg, kColorFlag, >EST_FLAG(color)) || + ParseStringFlag(arg, kDeathTestStyleFlag, + >EST_FLAG(death_test_style)) || + ParseBoolFlag(arg, kDeathTestUseFork, + >EST_FLAG(death_test_use_fork)) || + ParseStringFlag(arg, kFilterFlag, >EST_FLAG(filter)) || + ParseStringFlag(arg, kInternalRunDeathTestFlag, + >EST_FLAG(internal_run_death_test)) || + ParseBoolFlag(arg, kListTestsFlag, >EST_FLAG(list_tests)) || + ParseStringFlag(arg, kOutputFlag, >EST_FLAG(output)) || + ParseBoolFlag(arg, kPrintTimeFlag, >EST_FLAG(print_time)) || + ParseInt32Flag(arg, kRandomSeedFlag, >EST_FLAG(random_seed)) || + ParseInt32Flag(arg, kRepeatFlag, >EST_FLAG(repeat)) || + ParseBoolFlag(arg, kShuffleFlag, >EST_FLAG(shuffle)) || + ParseInt32Flag(arg, kStackTraceDepthFlag, + >EST_FLAG(stack_trace_depth)) || + ParseStringFlag(arg, kStreamResultToFlag, + >EST_FLAG(stream_result_to)) || + ParseBoolFlag(arg, kThrowOnFailureFlag, + >EST_FLAG(throw_on_failure)) + ) { + // Yes. Shift the remainder of the argv list left by one. Note + // that argv has (*argc + 1) elements, the last one always being + // NULL. The following loop moves the trailing NULL element as + // well. + for (int j = i; j != *argc; j++) { + argv[j] = argv[j + 1]; + } + + // Decrements the argument count. + (*argc)--; + + // We also need to decrement the iterator as we just removed + // an element. + i--; + } else if (arg_string == "--help" || arg_string == "-h" || + arg_string == "-?" || arg_string == "/?" || + HasGoogleTestFlagPrefix(arg)) { + // Both help flag and unrecognized Google Test flags (excluding + // internal ones) trigger help display. + g_help_flag = true; + } + } + + if (g_help_flag) { + // We print the help here instead of in RUN_ALL_TESTS(), as the + // latter may not be called at all if the user is using Google + // Test with another testing framework. + PrintColorEncoded(kColorEncodedHelpMessage); + } +} + +// Parses the command line for Google Test flags, without initializing +// other parts of Google Test. +void ParseGoogleTestFlagsOnly(int* argc, char** argv) { + ParseGoogleTestFlagsOnlyImpl(argc, argv); +} +void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) { + ParseGoogleTestFlagsOnlyImpl(argc, argv); +} + +// The internal implementation of InitGoogleTest(). +// +// The type parameter CharType can be instantiated to either char or +// wchar_t. +template +void InitGoogleTestImpl(int* argc, CharType** argv) { + g_init_gtest_count++; + + // We don't want to run the initialization code twice. + if (g_init_gtest_count != 1) return; + + if (*argc <= 0) return; + + internal::g_executable_path = internal::StreamableToString(argv[0]); + +#if GTEST_HAS_DEATH_TEST + + g_argvs.clear(); + for (int i = 0; i != *argc; i++) { + g_argvs.push_back(StreamableToString(argv[i])); + } + +#endif // GTEST_HAS_DEATH_TEST + + ParseGoogleTestFlagsOnly(argc, argv); + GetUnitTestImpl()->PostFlagParsingInit(); +} + +} // namespace internal + +// Initializes Google Test. This must be called before calling +// RUN_ALL_TESTS(). In particular, it parses a command line for the +// flags that Google Test recognizes. Whenever a Google Test flag is +// seen, it is removed from argv, and *argc is decremented. +// +// No value is returned. Instead, the Google Test flag variables are +// updated. +// +// Calling the function for the second time has no user-visible effect. +void InitGoogleTest(int* argc, char** argv) { + internal::InitGoogleTestImpl(argc, argv); +} + +// This overloaded version can be used in Windows programs compiled in +// UNICODE mode. +void InitGoogleTest(int* argc, wchar_t** argv) { + internal::InitGoogleTestImpl(argc, argv); +} + +} // namespace testing +// 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), vladl@google.com (Vlad Losev) +// +// This file implements death tests. + + +#if GTEST_HAS_DEATH_TEST + +# if GTEST_OS_MAC +# include +# endif // GTEST_OS_MAC + +# include +# include +# include + +# if GTEST_OS_LINUX +# include +# endif // GTEST_OS_LINUX + +# include + +# if GTEST_OS_WINDOWS +# include +# else +# include +# include +# endif // GTEST_OS_WINDOWS + +# if GTEST_OS_QNX +# include +# endif // GTEST_OS_QNX + +#endif // GTEST_HAS_DEATH_TEST + + +// 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 +#undef GTEST_IMPLEMENTATION_ + +namespace testing { + +// Constants. + +// The default death test style. +static const char kDefaultDeathTestStyle[] = "fast"; + +GTEST_DEFINE_string_( + death_test_style, + internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle), + "Indicates how to run a death test in a forked child process: " + "\"threadsafe\" (child process re-executes the test binary " + "from the beginning, running only the specific death test) or " + "\"fast\" (child process runs the death test immediately " + "after forking)."); + +GTEST_DEFINE_bool_( + death_test_use_fork, + internal::BoolFromGTestEnv("death_test_use_fork", false), + "Instructs to use fork()/_exit() instead of clone() in death tests. " + "Ignored and always uses fork() on POSIX systems where clone() is not " + "implemented. Useful when running under valgrind or similar tools if " + "those do not support clone(). Valgrind 3.3.1 will just fail if " + "it sees an unsupported combination of clone() flags. " + "It is not recommended to use this flag w/o valgrind though it will " + "work in 99% of the cases. Once valgrind is fixed, this flag will " + "most likely be removed."); + +namespace internal { +GTEST_DEFINE_string_( + internal_run_death_test, "", + "Indicates the file, line number, temporal index of " + "the single death test to run, and a file descriptor to " + "which a success code may be sent, all separated by " + "the '|' characters. This flag is specified if and only if the current " + "process is a sub-process launched for running a thread-safe " + "death test. FOR INTERNAL USE ONLY."); +} // namespace internal + +#if GTEST_HAS_DEATH_TEST + +namespace internal { + +// Valid only for fast death tests. Indicates the code is running in the +// child process of a fast style death test. +static bool g_in_fast_death_test_child = false; + +// Returns a Boolean value indicating whether the caller is currently +// executing in the context of the death test child process. Tools such as +// Valgrind heap checkers may need this to modify their behavior in death +// tests. IMPORTANT: This is an internal utility. Using it may break the +// implementation of death tests. User code MUST NOT use it. +bool InDeathTestChild() { +# if GTEST_OS_WINDOWS + + // On Windows, death tests are thread-safe regardless of the value of the + // death_test_style flag. + return !GTEST_FLAG(internal_run_death_test).empty(); + +# else + + if (GTEST_FLAG(death_test_style) == "threadsafe") + return !GTEST_FLAG(internal_run_death_test).empty(); + else + return g_in_fast_death_test_child; +#endif +} + +} // namespace internal + +// ExitedWithCode constructor. +ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) { +} + +// ExitedWithCode function-call operator. +bool ExitedWithCode::operator()(int exit_status) const { +# if GTEST_OS_WINDOWS + + return exit_status == exit_code_; + +# else + + return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_; + +# endif // GTEST_OS_WINDOWS +} + +# if !GTEST_OS_WINDOWS +// KilledBySignal constructor. +KilledBySignal::KilledBySignal(int signum) : signum_(signum) { +} + +// KilledBySignal function-call operator. +bool KilledBySignal::operator()(int exit_status) const { + return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_; +} +# endif // !GTEST_OS_WINDOWS + +namespace internal { + +// Utilities needed for death tests. + +// Generates a textual description of a given exit code, in the format +// specified by wait(2). +static std::string ExitSummary(int exit_code) { + Message m; + +# if GTEST_OS_WINDOWS + + m << "Exited with exit status " << exit_code; + +# else + + if (WIFEXITED(exit_code)) { + m << "Exited with exit status " << WEXITSTATUS(exit_code); + } else if (WIFSIGNALED(exit_code)) { + m << "Terminated by signal " << WTERMSIG(exit_code); + } +# ifdef WCOREDUMP + if (WCOREDUMP(exit_code)) { + m << " (core dumped)"; + } +# endif +# endif // GTEST_OS_WINDOWS + + return m.GetString(); +} + +// Returns true if exit_status describes a process that was terminated +// by a signal, or exited normally with a nonzero exit code. +bool ExitedUnsuccessfully(int exit_status) { + return !ExitedWithCode(0)(exit_status); +} + +# if !GTEST_OS_WINDOWS +// Generates a textual failure message when a death test finds more than +// one thread running, or cannot determine the number of threads, prior +// to executing the given statement. It is the responsibility of the +// caller not to pass a thread_count of 1. +static std::string DeathTestThreadWarning(size_t thread_count) { + Message msg; + msg << "Death tests use fork(), which is unsafe particularly" + << " in a threaded context. For this test, " << GTEST_NAME_ << " "; + if (thread_count == 0) + msg << "couldn't detect the number of threads."; + else + msg << "detected " << thread_count << " threads."; + return msg.GetString(); +} +# endif // !GTEST_OS_WINDOWS + +// Flag characters for reporting a death test that did not die. +static const char kDeathTestLived = 'L'; +static const char kDeathTestReturned = 'R'; +static const char kDeathTestThrew = 'T'; +static const char kDeathTestInternalError = 'I'; + +// An enumeration describing all of the possible ways that a death test can +// conclude. DIED means that the process died while executing the test +// code; LIVED means that process lived beyond the end of the test code; +// RETURNED means that the test statement attempted to execute a return +// statement, which is not allowed; THREW means that the test statement +// returned control by throwing an exception. IN_PROGRESS means the test +// has not yet concluded. +// TODO(vladl@google.com): Unify names and possibly values for +// AbortReason, DeathTestOutcome, and flag characters above. +enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }; + +// Routine for aborting the program which is safe to call from an +// exec-style death test child process, in which case the error +// message is propagated back to the parent process. Otherwise, the +// message is simply printed to stderr. In either case, the program +// then exits with status 1. +void DeathTestAbort(const std::string& message) { + // On a POSIX system, this function may be called from a threadsafe-style + // death test child process, which operates on a very small stack. Use + // the heap for any additional non-minuscule memory requirements. + const InternalRunDeathTestFlag* const flag = + GetUnitTestImpl()->internal_run_death_test_flag(); + if (flag != NULL) { + FILE* parent = posix::FDOpen(flag->write_fd(), "w"); + fputc(kDeathTestInternalError, parent); + fprintf(parent, "%s", message.c_str()); + fflush(parent); + _exit(1); + } else { + fprintf(stderr, "%s", message.c_str()); + fflush(stderr); + posix::Abort(); + } +} + +// A replacement for CHECK that calls DeathTestAbort if the assertion +// fails. +# define GTEST_DEATH_TEST_CHECK_(expression) \ + do { \ + if (!::testing::internal::IsTrue(expression)) { \ + DeathTestAbort( \ + ::std::string("CHECK failed: File ") + __FILE__ + ", line " \ + + ::testing::internal::StreamableToString(__LINE__) + ": " \ + + #expression); \ + } \ + } while (::testing::internal::AlwaysFalse()) + +// This macro is similar to GTEST_DEATH_TEST_CHECK_, but it is meant for +// evaluating any system call that fulfills two conditions: it must return +// -1 on failure, and set errno to EINTR when it is interrupted and +// should be tried again. The macro expands to a loop that repeatedly +// evaluates the expression as long as it evaluates to -1 and sets +// errno to EINTR. If the expression evaluates to -1 but errno is +// something other than EINTR, DeathTestAbort is called. +# define GTEST_DEATH_TEST_CHECK_SYSCALL_(expression) \ + do { \ + int gtest_retval; \ + do { \ + gtest_retval = (expression); \ + } while (gtest_retval == -1 && errno == EINTR); \ + if (gtest_retval == -1) { \ + DeathTestAbort( \ + ::std::string("CHECK failed: File ") + __FILE__ + ", line " \ + + ::testing::internal::StreamableToString(__LINE__) + ": " \ + + #expression + " != -1"); \ + } \ + } while (::testing::internal::AlwaysFalse()) + +// Returns the message describing the last system error in errno. +std::string GetLastErrnoDescription() { + return errno == 0 ? "" : posix::StrError(errno); +} + +// This is called from a death test parent process to read a failure +// message from the death test child process and log it with the FATAL +// severity. On Windows, the message is read from a pipe handle. On other +// platforms, it is read from a file descriptor. +static void FailFromInternalError(int fd) { + Message error; + char buffer[256]; + int num_read; + + do { + while ((num_read = posix::Read(fd, buffer, 255)) > 0) { + buffer[num_read] = '\0'; + error << buffer; + } + } while (num_read == -1 && errno == EINTR); + + if (num_read == 0) { + GTEST_LOG_(FATAL) << error.GetString(); + } else { + const int last_error = errno; + GTEST_LOG_(FATAL) << "Error while reading death test internal: " + << GetLastErrnoDescription() << " [" << last_error << "]"; + } +} + +// Death test constructor. Increments the running death test count +// for the current test. +DeathTest::DeathTest() { + TestInfo* const info = GetUnitTestImpl()->current_test_info(); + if (info == NULL) { + DeathTestAbort("Cannot run a death test outside of a TEST or " + "TEST_F construct"); + } +} + +// Creates and returns a death test by dispatching to the current +// death test factory. +bool DeathTest::Create(const char* statement, const RE* regex, + const char* file, int line, DeathTest** test) { + return GetUnitTestImpl()->death_test_factory()->Create( + statement, regex, file, line, test); +} + +const char* DeathTest::LastMessage() { + return last_death_test_message_.c_str(); +} + +void DeathTest::set_last_death_test_message(const std::string& message) { + last_death_test_message_ = message; +} + +std::string DeathTest::last_death_test_message_; + +// Provides cross platform implementation for some death functionality. +class DeathTestImpl : public DeathTest { + protected: + DeathTestImpl(const char* a_statement, const RE* a_regex) + : statement_(a_statement), + regex_(a_regex), + spawned_(false), + status_(-1), + outcome_(IN_PROGRESS), + read_fd_(-1), + write_fd_(-1) {} + + // read_fd_ is expected to be closed and cleared by a derived class. + ~DeathTestImpl() { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); } + + void Abort(AbortReason reason); + virtual bool Passed(bool status_ok); + + const char* statement() const { return statement_; } + const RE* regex() const { return regex_; } + bool spawned() const { return spawned_; } + void set_spawned(bool is_spawned) { spawned_ = is_spawned; } + int status() const { return status_; } + void set_status(int a_status) { status_ = a_status; } + DeathTestOutcome outcome() const { return outcome_; } + void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outcome; } + int read_fd() const { return read_fd_; } + void set_read_fd(int fd) { read_fd_ = fd; } + int write_fd() const { return write_fd_; } + void set_write_fd(int fd) { write_fd_ = fd; } + + // Called in the parent process only. Reads the result code of the death + // test child process via a pipe, interprets it to set the outcome_ + // member, and closes read_fd_. Outputs diagnostics and terminates in + // case of unexpected codes. + void ReadAndInterpretStatusByte(); + + private: + // The textual content of the code this object is testing. This class + // doesn't own this string and should not attempt to delete it. + const char* const statement_; + // The regular expression which test output must match. DeathTestImpl + // doesn't own this object and should not attempt to delete it. + const RE* const regex_; + // True if the death test child process has been successfully spawned. + bool spawned_; + // The exit status of the child process. + int status_; + // How the death test concluded. + DeathTestOutcome outcome_; + // Descriptor to the read end of the pipe to the child process. It is + // always -1 in the child process. The child keeps its write end of the + // pipe in write_fd_. + int read_fd_; + // Descriptor to the child's write end of the pipe to the parent process. + // It is always -1 in the parent process. The parent keeps its end of the + // pipe in read_fd_. + int write_fd_; +}; + +// Called in the parent process only. Reads the result code of the death +// test child process via a pipe, interprets it to set the outcome_ +// member, and closes read_fd_. Outputs diagnostics and terminates in +// case of unexpected codes. +void DeathTestImpl::ReadAndInterpretStatusByte() { + char flag; + int bytes_read; + + // The read() here blocks until data is available (signifying the + // failure of the death test) or until the pipe is closed (signifying + // its success), so it's okay to call this in the parent before + // the child process has exited. + do { + bytes_read = posix::Read(read_fd(), &flag, 1); + } while (bytes_read == -1 && errno == EINTR); + + if (bytes_read == 0) { + set_outcome(DIED); + } else if (bytes_read == 1) { + switch (flag) { + case kDeathTestReturned: + set_outcome(RETURNED); + break; + case kDeathTestThrew: + set_outcome(THREW); + break; + case kDeathTestLived: + set_outcome(LIVED); + break; + case kDeathTestInternalError: + FailFromInternalError(read_fd()); // Does not return. + break; + default: + GTEST_LOG_(FATAL) << "Death test child process reported " + << "unexpected status byte (" + << static_cast(flag) << ")"; + } + } else { + GTEST_LOG_(FATAL) << "Read from death test child process failed: " + << GetLastErrnoDescription(); + } + GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd())); + set_read_fd(-1); +} + +// Signals that the death test code which should have exited, didn't. +// Should be called only in a death test child process. +// Writes a status byte to the child's status file descriptor, then +// calls _exit(1). +void DeathTestImpl::Abort(AbortReason reason) { + // The parent process considers the death test to be a failure if + // it finds any data in our pipe. So, here we write a single flag byte + // to the pipe, then exit. + const char status_ch = + reason == TEST_DID_NOT_DIE ? kDeathTestLived : + reason == TEST_THREW_EXCEPTION ? kDeathTestThrew : kDeathTestReturned; + + GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1)); + // We are leaking the descriptor here because on some platforms (i.e., + // when built as Windows DLL), destructors of global objects will still + // run after calling _exit(). On such systems, write_fd_ will be + // indirectly closed from the destructor of UnitTestImpl, causing double + // close if it is also closed here. On debug configurations, double close + // may assert. As there are no in-process buffers to flush here, we are + // relying on the OS to close the descriptor after the process terminates + // when the destructors are not run. + _exit(1); // Exits w/o any normal exit hooks (we were supposed to crash) +} + +// Returns an indented copy of stderr output for a death test. +// This makes distinguishing death test output lines from regular log lines +// much easier. +static ::std::string FormatDeathTestOutput(const ::std::string& output) { + ::std::string ret; + for (size_t at = 0; ; ) { + const size_t line_end = output.find('\n', at); + ret += "[ DEATH ] "; + if (line_end == ::std::string::npos) { + ret += output.substr(at); + break; + } + ret += output.substr(at, line_end + 1 - at); + at = line_end + 1; + } + return ret; +} + +// Assesses the success or failure of a death test, using both private +// members which have previously been set, and one argument: +// +// Private data members: +// outcome: An enumeration describing how the death test +// concluded: DIED, LIVED, THREW, or RETURNED. The death test +// fails in the latter three cases. +// status: The exit status of the child process. On *nix, it is in the +// in the format specified by wait(2). On Windows, this is the +// value supplied to the ExitProcess() API or a numeric code +// of the exception that terminated the program. +// regex: A regular expression object to be applied to +// the test's captured standard error output; the death test +// fails if it does not match. +// +// Argument: +// status_ok: true if exit_status is acceptable in the context of +// this particular death test, which fails if it is false +// +// Returns true iff all of the above conditions are met. Otherwise, the +// first failing condition, in the order given above, is the one that is +// reported. Also sets the last death test message string. +bool DeathTestImpl::Passed(bool status_ok) { + if (!spawned()) + return false; + + const std::string error_message = GetCapturedStderr(); + + bool success = false; + Message buffer; + + buffer << "Death test: " << statement() << "\n"; + switch (outcome()) { + case LIVED: + buffer << " Result: failed to die.\n" + << " Error msg:\n" << FormatDeathTestOutput(error_message); + break; + case THREW: + buffer << " Result: threw an exception.\n" + << " Error msg:\n" << FormatDeathTestOutput(error_message); + break; + case RETURNED: + buffer << " Result: illegal return in test statement.\n" + << " Error msg:\n" << FormatDeathTestOutput(error_message); + break; + case DIED: + if (status_ok) { + const bool matched = RE::PartialMatch(error_message.c_str(), *regex()); + if (matched) { + success = true; + } else { + buffer << " Result: died but not with expected error.\n" + << " Expected: " << regex()->pattern() << "\n" + << "Actual msg:\n" << FormatDeathTestOutput(error_message); + } + } else { + buffer << " Result: died but not with expected exit code:\n" + << " " << ExitSummary(status()) << "\n" + << "Actual msg:\n" << FormatDeathTestOutput(error_message); + } + break; + case IN_PROGRESS: + default: + GTEST_LOG_(FATAL) + << "DeathTest::Passed somehow called before conclusion of test"; + } + + DeathTest::set_last_death_test_message(buffer.GetString()); + return success; +} + +# if GTEST_OS_WINDOWS +// WindowsDeathTest implements death tests on Windows. Due to the +// specifics of starting new processes on Windows, death tests there are +// always threadsafe, and Google Test considers the +// --gtest_death_test_style=fast setting to be equivalent to +// --gtest_death_test_style=threadsafe there. +// +// A few implementation notes: Like the Linux version, the Windows +// implementation uses pipes for child-to-parent communication. But due to +// the specifics of pipes on Windows, some extra steps are required: +// +// 1. The parent creates a communication pipe and stores handles to both +// ends of it. +// 2. The parent starts the child and provides it with the information +// necessary to acquire the handle to the write end of the pipe. +// 3. The child acquires the write end of the pipe and signals the parent +// using a Windows event. +// 4. Now the parent can release the write end of the pipe on its side. If +// this is done before step 3, the object's reference count goes down to +// 0 and it is destroyed, preventing the child from acquiring it. The +// parent now has to release it, or read operations on the read end of +// the pipe will not return when the child terminates. +// 5. The parent reads child's output through the pipe (outcome code and +// any possible error messages) from the pipe, and its stderr and then +// determines whether to fail the test. +// +// Note: to distinguish Win32 API calls from the local method and function +// calls, the former are explicitly resolved in the global namespace. +// +class WindowsDeathTest : public DeathTestImpl { + public: + WindowsDeathTest(const char* a_statement, + const RE* a_regex, + const char* file, + int line) + : DeathTestImpl(a_statement, a_regex), file_(file), line_(line) {} + + // All of these virtual functions are inherited from DeathTest. + virtual int Wait(); + virtual TestRole AssumeRole(); + + private: + // The name of the file in which the death test is located. + const char* const file_; + // The line number on which the death test is located. + const int line_; + // Handle to the write end of the pipe to the child process. + AutoHandle write_handle_; + // Child process handle. + AutoHandle child_handle_; + // Event the child process uses to signal the parent that it has + // acquired the handle to the write end of the pipe. After seeing this + // event the parent can release its own handles to make sure its + // ReadFile() calls return when the child terminates. + AutoHandle event_handle_; +}; + +// Waits for the child in a death test to exit, returning its exit +// status, or 0 if no child process exists. As a side effect, sets the +// outcome data member. +int WindowsDeathTest::Wait() { + if (!spawned()) + return 0; + + // Wait until the child either signals that it has acquired the write end + // of the pipe or it dies. + const HANDLE wait_handles[2] = { child_handle_.Get(), event_handle_.Get() }; + switch (::WaitForMultipleObjects(2, + wait_handles, + FALSE, // Waits for any of the handles. + INFINITE)) { + case WAIT_OBJECT_0: + case WAIT_OBJECT_0 + 1: + break; + default: + GTEST_DEATH_TEST_CHECK_(false); // Should not get here. + } + + // The child has acquired the write end of the pipe or exited. + // We release the handle on our side and continue. + write_handle_.Reset(); + event_handle_.Reset(); + + ReadAndInterpretStatusByte(); + + // Waits for the child process to exit if it haven't already. This + // returns immediately if the child has already exited, regardless of + // whether previous calls to WaitForMultipleObjects synchronized on this + // handle or not. + GTEST_DEATH_TEST_CHECK_( + WAIT_OBJECT_0 == ::WaitForSingleObject(child_handle_.Get(), + INFINITE)); + DWORD status_code; + GTEST_DEATH_TEST_CHECK_( + ::GetExitCodeProcess(child_handle_.Get(), &status_code) != FALSE); + child_handle_.Reset(); + set_status(static_cast(status_code)); + return status(); +} + +// The AssumeRole process for a Windows death test. It creates a child +// process with the same executable as the current process to run the +// death test. The child process is given the --gtest_filter and +// --gtest_internal_run_death_test flags such that it knows to run the +// current death test only. +DeathTest::TestRole WindowsDeathTest::AssumeRole() { + const UnitTestImpl* const impl = GetUnitTestImpl(); + const InternalRunDeathTestFlag* const flag = + impl->internal_run_death_test_flag(); + const TestInfo* const info = impl->current_test_info(); + const int death_test_index = info->result()->death_test_count(); + + if (flag != NULL) { + // ParseInternalRunDeathTestFlag() has performed all the necessary + // processing. + set_write_fd(flag->write_fd()); + return EXECUTE_TEST; + } + + // WindowsDeathTest uses an anonymous pipe to communicate results of + // a death test. + SECURITY_ATTRIBUTES handles_are_inheritable = { + sizeof(SECURITY_ATTRIBUTES), NULL, TRUE }; + HANDLE read_handle, write_handle; + GTEST_DEATH_TEST_CHECK_( + ::CreatePipe(&read_handle, &write_handle, &handles_are_inheritable, + 0) // Default buffer size. + != FALSE); + set_read_fd(::_open_osfhandle(reinterpret_cast(read_handle), + O_RDONLY)); + write_handle_.Reset(write_handle); + event_handle_.Reset(::CreateEvent( + &handles_are_inheritable, + TRUE, // The event will automatically reset to non-signaled state. + FALSE, // The initial state is non-signalled. + NULL)); // The even is unnamed. + GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != NULL); + const std::string filter_flag = + std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "=" + + info->test_case_name() + "." + info->name(); + const std::string internal_flag = + std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + + "=" + file_ + "|" + StreamableToString(line_) + "|" + + StreamableToString(death_test_index) + "|" + + StreamableToString(static_cast(::GetCurrentProcessId())) + + // size_t has the same width as pointers on both 32-bit and 64-bit + // Windows platforms. + // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx. + "|" + StreamableToString(reinterpret_cast(write_handle)) + + "|" + StreamableToString(reinterpret_cast(event_handle_.Get())); + + char executable_path[_MAX_PATH + 1]; // NOLINT + GTEST_DEATH_TEST_CHECK_( + _MAX_PATH + 1 != ::GetModuleFileNameA(NULL, + executable_path, + _MAX_PATH)); + + std::string command_line = + std::string(::GetCommandLineA()) + " " + filter_flag + " \"" + + internal_flag + "\""; + + DeathTest::set_last_death_test_message(""); + + CaptureStderr(); + // Flush the log buffers since the log streams are shared with the child. + FlushInfoLog(); + + // The child process will share the standard handles with the parent. + STARTUPINFOA startup_info; + memset(&startup_info, 0, sizeof(STARTUPINFO)); + startup_info.dwFlags = STARTF_USESTDHANDLES; + startup_info.hStdInput = ::GetStdHandle(STD_INPUT_HANDLE); + startup_info.hStdOutput = ::GetStdHandle(STD_OUTPUT_HANDLE); + startup_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE); + + PROCESS_INFORMATION process_info; + GTEST_DEATH_TEST_CHECK_(::CreateProcessA( + executable_path, + const_cast(command_line.c_str()), + NULL, // Retuned process handle is not inheritable. + NULL, // Retuned thread handle is not inheritable. + TRUE, // Child inherits all inheritable handles (for write_handle_). + 0x0, // Default creation flags. + NULL, // Inherit the parent's environment. + UnitTest::GetInstance()->original_working_dir(), + &startup_info, + &process_info) != FALSE); + child_handle_.Reset(process_info.hProcess); + ::CloseHandle(process_info.hThread); + set_spawned(true); + return OVERSEE_TEST; +} +# else // We are not on Windows. + +// ForkingDeathTest provides implementations for most of the abstract +// methods of the DeathTest interface. Only the AssumeRole method is +// left undefined. +class ForkingDeathTest : public DeathTestImpl { + public: + ForkingDeathTest(const char* statement, const RE* regex); + + // All of these virtual functions are inherited from DeathTest. + virtual int Wait(); + + protected: + void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; } + + private: + // PID of child process during death test; 0 in the child process itself. + pid_t child_pid_; +}; + +// Constructs a ForkingDeathTest. +ForkingDeathTest::ForkingDeathTest(const char* a_statement, const RE* a_regex) + : DeathTestImpl(a_statement, a_regex), + child_pid_(-1) {} + +// Waits for the child in a death test to exit, returning its exit +// status, or 0 if no child process exists. As a side effect, sets the +// outcome data member. +int ForkingDeathTest::Wait() { + if (!spawned()) + return 0; + + ReadAndInterpretStatusByte(); + + int status_value; + GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0)); + set_status(status_value); + return status_value; +} + +// A concrete death test class that forks, then immediately runs the test +// in the child process. +class NoExecDeathTest : public ForkingDeathTest { + public: + NoExecDeathTest(const char* a_statement, const RE* a_regex) : + ForkingDeathTest(a_statement, a_regex) { } + virtual TestRole AssumeRole(); +}; + +// The AssumeRole process for a fork-and-run death test. It implements a +// straightforward fork, with a simple pipe to transmit the status byte. +DeathTest::TestRole NoExecDeathTest::AssumeRole() { + const size_t thread_count = GetThreadCount(); + if (thread_count != 1) { + GTEST_LOG_(WARNING) << DeathTestThreadWarning(thread_count); + } + + int pipe_fd[2]; + GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1); + + DeathTest::set_last_death_test_message(""); + CaptureStderr(); + // When we fork the process below, the log file buffers are copied, but the + // file descriptors are shared. We flush all log files here so that closing + // the file descriptors in the child process doesn't throw off the + // synchronization between descriptors and buffers in the parent process. + // This is as close to the fork as possible to avoid a race condition in case + // there are multiple threads running before the death test, and another + // thread writes to the log file. + FlushInfoLog(); + + const pid_t child_pid = fork(); + GTEST_DEATH_TEST_CHECK_(child_pid != -1); + set_child_pid(child_pid); + if (child_pid == 0) { + GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[0])); + set_write_fd(pipe_fd[1]); + // Redirects all logging to stderr in the child process to prevent + // concurrent writes to the log files. We capture stderr in the parent + // process and append the child process' output to a log. + LogToStderr(); + // Event forwarding to the listeners of event listener API mush be shut + // down in death test subprocesses. + GetUnitTestImpl()->listeners()->SuppressEventForwarding(); + g_in_fast_death_test_child = true; + return EXECUTE_TEST; + } else { + GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1])); + set_read_fd(pipe_fd[0]); + set_spawned(true); + return OVERSEE_TEST; + } +} + +// A concrete death test class that forks and re-executes the main +// program from the beginning, with command-line flags set that cause +// only this specific death test to be run. +class ExecDeathTest : public ForkingDeathTest { + public: + ExecDeathTest(const char* a_statement, const RE* a_regex, + const char* file, int line) : + ForkingDeathTest(a_statement, a_regex), file_(file), line_(line) { } + virtual TestRole AssumeRole(); + private: + static ::std::vector + GetArgvsForDeathTestChildProcess() { + ::std::vector args = GetInjectableArgvs(); + return args; + } + // The name of the file in which the death test is located. + const char* const file_; + // The line number on which the death test is located. + const int line_; +}; + +// Utility class for accumulating command-line arguments. +class Arguments { + public: + Arguments() { + args_.push_back(NULL); + } + + ~Arguments() { + for (std::vector::iterator i = args_.begin(); i != args_.end(); + ++i) { + free(*i); + } + } + void AddArgument(const char* argument) { + args_.insert(args_.end() - 1, posix::StrDup(argument)); + } + + template + void AddArguments(const ::std::vector& arguments) { + for (typename ::std::vector::const_iterator i = arguments.begin(); + i != arguments.end(); + ++i) { + args_.insert(args_.end() - 1, posix::StrDup(i->c_str())); + } + } + char* const* Argv() { + return &args_[0]; + } + + private: + std::vector args_; +}; + +// A struct that encompasses the arguments to the child process of a +// threadsafe-style death test process. +struct ExecDeathTestArgs { + char* const* argv; // Command-line arguments for the child's call to exec + int close_fd; // File descriptor to close; the read end of a pipe +}; + +# if GTEST_OS_MAC +inline char** GetEnviron() { + // When Google Test is built as a framework on MacOS X, the environ variable + // is unavailable. Apple's documentation (man environ) recommends using + // _NSGetEnviron() instead. + return *_NSGetEnviron(); +} +# else +// Some POSIX platforms expect you to declare environ. extern "C" makes +// it reside in the global namespace. +extern "C" char** environ; +inline char** GetEnviron() { return environ; } +# endif // GTEST_OS_MAC + +# if !GTEST_OS_QNX +// The main function for a threadsafe-style death test child process. +// This function is called in a clone()-ed process and thus must avoid +// any potentially unsafe operations like malloc or libc functions. +static int ExecDeathTestChildMain(void* child_arg) { + ExecDeathTestArgs* const args = static_cast(child_arg); + GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd)); + + // We need to execute the test program in the same environment where + // it was originally invoked. Therefore we change to the original + // working directory first. + const char* const original_dir = + UnitTest::GetInstance()->original_working_dir(); + // We can safely call chdir() as it's a direct system call. + if (chdir(original_dir) != 0) { + DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " + + GetLastErrnoDescription()); + return EXIT_FAILURE; + } + + // We can safely call execve() as it's a direct system call. We + // cannot use execvp() as it's a libc function and thus potentially + // unsafe. Since execve() doesn't search the PATH, the user must + // invoke the test program via a valid path that contains at least + // one path separator. + execve(args->argv[0], args->argv, GetEnviron()); + DeathTestAbort(std::string("execve(") + args->argv[0] + ", ...) in " + + original_dir + " failed: " + + GetLastErrnoDescription()); + return EXIT_FAILURE; +} +# endif // !GTEST_OS_QNX + +// Two utility routines that together determine the direction the stack +// grows. +// This could be accomplished more elegantly by a single recursive +// function, but we want to guard against the unlikely possibility of +// a smart compiler optimizing the recursion away. +// +// GTEST_NO_INLINE_ is required to prevent GCC 4.6 from inlining +// StackLowerThanAddress into StackGrowsDown, which then doesn't give +// correct answer. +void StackLowerThanAddress(const void* ptr, bool* result) GTEST_NO_INLINE_; +void StackLowerThanAddress(const void* ptr, bool* result) { + int dummy; + *result = (&dummy < ptr); +} + +bool StackGrowsDown() { + int dummy; + bool result; + StackLowerThanAddress(&dummy, &result); + return result; +} + +// Spawns a child process with the same executable as the current process in +// a thread-safe manner and instructs it to run the death test. The +// implementation uses fork(2) + exec. On systems where clone(2) is +// available, it is used instead, being slightly more thread-safe. On QNX, +// fork supports only single-threaded environments, so this function uses +// spawn(2) there instead. The function dies with an error message if +// anything goes wrong. +static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) { + ExecDeathTestArgs args = { argv, close_fd }; + pid_t child_pid = -1; + +# if GTEST_OS_QNX + // Obtains the current directory and sets it to be closed in the child + // process. + const int cwd_fd = open(".", O_RDONLY); + GTEST_DEATH_TEST_CHECK_(cwd_fd != -1); + GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(cwd_fd, F_SETFD, FD_CLOEXEC)); + // We need to execute the test program in the same environment where + // it was originally invoked. Therefore we change to the original + // working directory first. + const char* const original_dir = + UnitTest::GetInstance()->original_working_dir(); + // We can safely call chdir() as it's a direct system call. + if (chdir(original_dir) != 0) { + DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " + + GetLastErrnoDescription()); + return EXIT_FAILURE; + } + + int fd_flags; + // Set close_fd to be closed after spawn. + GTEST_DEATH_TEST_CHECK_SYSCALL_(fd_flags = fcntl(close_fd, F_GETFD)); + GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(close_fd, F_SETFD, + fd_flags | FD_CLOEXEC)); + struct inheritance inherit = {0}; + // spawn is a system call. + child_pid = spawn(args.argv[0], 0, NULL, &inherit, args.argv, GetEnviron()); + // Restores the current working directory. + GTEST_DEATH_TEST_CHECK_(fchdir(cwd_fd) != -1); + GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd)); + +# else // GTEST_OS_QNX +# if GTEST_OS_LINUX + // When a SIGPROF signal is received while fork() or clone() are executing, + // the process may hang. To avoid this, we ignore SIGPROF here and re-enable + // it after the call to fork()/clone() is complete. + struct sigaction saved_sigprof_action; + struct sigaction ignore_sigprof_action; + memset(&ignore_sigprof_action, 0, sizeof(ignore_sigprof_action)); + sigemptyset(&ignore_sigprof_action.sa_mask); + ignore_sigprof_action.sa_handler = SIG_IGN; + GTEST_DEATH_TEST_CHECK_SYSCALL_(sigaction( + SIGPROF, &ignore_sigprof_action, &saved_sigprof_action)); +# endif // GTEST_OS_LINUX + +# if GTEST_HAS_CLONE + const bool use_fork = GTEST_FLAG(death_test_use_fork); + + if (!use_fork) { + static const bool stack_grows_down = StackGrowsDown(); + const size_t stack_size = getpagesize(); + // MMAP_ANONYMOUS is not defined on Mac, so we use MAP_ANON instead. + void* const stack = mmap(NULL, stack_size, PROT_READ | PROT_WRITE, + MAP_ANON | MAP_PRIVATE, -1, 0); + GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED); + + // Maximum stack alignment in bytes: For a downward-growing stack, this + // amount is subtracted from size of the stack space to get an address + // that is within the stack space and is aligned on all systems we care + // about. As far as I know there is no ABI with stack alignment greater + // than 64. We assume stack and stack_size already have alignment of + // kMaxStackAlignment. + const size_t kMaxStackAlignment = 64; + void* const stack_top = + static_cast(stack) + + (stack_grows_down ? stack_size - kMaxStackAlignment : 0); + GTEST_DEATH_TEST_CHECK_(stack_size > kMaxStackAlignment && + reinterpret_cast(stack_top) % kMaxStackAlignment == 0); + + child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args); + + GTEST_DEATH_TEST_CHECK_(munmap(stack, stack_size) != -1); + } +# else + const bool use_fork = true; +# endif // GTEST_HAS_CLONE + + if (use_fork && (child_pid = fork()) == 0) { + ExecDeathTestChildMain(&args); + _exit(0); + } +# endif // GTEST_OS_QNX +# if GTEST_OS_LINUX + GTEST_DEATH_TEST_CHECK_SYSCALL_( + sigaction(SIGPROF, &saved_sigprof_action, NULL)); +# endif // GTEST_OS_LINUX + + GTEST_DEATH_TEST_CHECK_(child_pid != -1); + return child_pid; +} + +// The AssumeRole process for a fork-and-exec death test. It re-executes the +// main program from the beginning, setting the --gtest_filter +// and --gtest_internal_run_death_test flags to cause only the current +// death test to be re-run. +DeathTest::TestRole ExecDeathTest::AssumeRole() { + const UnitTestImpl* const impl = GetUnitTestImpl(); + const InternalRunDeathTestFlag* const flag = + impl->internal_run_death_test_flag(); + const TestInfo* const info = impl->current_test_info(); + const int death_test_index = info->result()->death_test_count(); + + if (flag != NULL) { + set_write_fd(flag->write_fd()); + return EXECUTE_TEST; + } + + int pipe_fd[2]; + GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1); + // Clear the close-on-exec flag on the write end of the pipe, lest + // it be closed when the child process does an exec: + GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1); + + const std::string filter_flag = + std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "=" + + info->test_case_name() + "." + info->name(); + const std::string internal_flag = + std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "=" + + file_ + "|" + StreamableToString(line_) + "|" + + StreamableToString(death_test_index) + "|" + + StreamableToString(pipe_fd[1]); + Arguments args; + args.AddArguments(GetArgvsForDeathTestChildProcess()); + args.AddArgument(filter_flag.c_str()); + args.AddArgument(internal_flag.c_str()); + + DeathTest::set_last_death_test_message(""); + + CaptureStderr(); + // See the comment in NoExecDeathTest::AssumeRole for why the next line + // is necessary. + FlushInfoLog(); + + const pid_t child_pid = ExecDeathTestSpawnChild(args.Argv(), pipe_fd[0]); + GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1])); + set_child_pid(child_pid); + set_read_fd(pipe_fd[0]); + set_spawned(true); + return OVERSEE_TEST; +} + +# endif // !GTEST_OS_WINDOWS + +// Creates a concrete DeathTest-derived class that depends on the +// --gtest_death_test_style flag, and sets the pointer pointed to +// by the "test" argument to its address. If the test should be +// skipped, sets that pointer to NULL. Returns true, unless the +// flag is set to an invalid value. +bool DefaultDeathTestFactory::Create(const char* statement, const RE* regex, + const char* file, int line, + DeathTest** test) { + UnitTestImpl* const impl = GetUnitTestImpl(); + const InternalRunDeathTestFlag* const flag = + impl->internal_run_death_test_flag(); + const int death_test_index = impl->current_test_info() + ->increment_death_test_count(); + + if (flag != NULL) { + if (death_test_index > flag->index()) { + DeathTest::set_last_death_test_message( + "Death test count (" + StreamableToString(death_test_index) + + ") somehow exceeded expected maximum (" + + StreamableToString(flag->index()) + ")"); + return false; + } + + if (!(flag->file() == file && flag->line() == line && + flag->index() == death_test_index)) { + *test = NULL; + return true; + } + } + +# if GTEST_OS_WINDOWS + + if (GTEST_FLAG(death_test_style) == "threadsafe" || + GTEST_FLAG(death_test_style) == "fast") { + *test = new WindowsDeathTest(statement, regex, file, line); + } + +# else + + if (GTEST_FLAG(death_test_style) == "threadsafe") { + *test = new ExecDeathTest(statement, regex, file, line); + } else if (GTEST_FLAG(death_test_style) == "fast") { + *test = new NoExecDeathTest(statement, regex); + } + +# endif // GTEST_OS_WINDOWS + + else { // NOLINT - this is more readable than unbalanced brackets inside #if. + DeathTest::set_last_death_test_message( + "Unknown death test style \"" + GTEST_FLAG(death_test_style) + + "\" encountered"); + return false; + } + + return true; +} + +// Splits a given string on a given delimiter, populating a given +// vector with the fields. GTEST_HAS_DEATH_TEST implies that we have +// ::std::string, so we can use it here. +static void SplitString(const ::std::string& str, char delimiter, + ::std::vector< ::std::string>* dest) { + ::std::vector< ::std::string> parsed; + ::std::string::size_type pos = 0; + while (::testing::internal::AlwaysTrue()) { + const ::std::string::size_type colon = str.find(delimiter, pos); + if (colon == ::std::string::npos) { + parsed.push_back(str.substr(pos)); + break; + } else { + parsed.push_back(str.substr(pos, colon - pos)); + pos = colon + 1; + } + } + dest->swap(parsed); +} + +# if GTEST_OS_WINDOWS +// Recreates the pipe and event handles from the provided parameters, +// signals the event, and returns a file descriptor wrapped around the pipe +// handle. This function is called in the child process only. +int GetStatusFileDescriptor(unsigned int parent_process_id, + size_t write_handle_as_size_t, + size_t event_handle_as_size_t) { + AutoHandle parent_process_handle(::OpenProcess(PROCESS_DUP_HANDLE, + FALSE, // Non-inheritable. + parent_process_id)); + if (parent_process_handle.Get() == INVALID_HANDLE_VALUE) { + DeathTestAbort("Unable to open parent process " + + StreamableToString(parent_process_id)); + } + + // TODO(vladl@google.com): Replace the following check with a + // compile-time assertion when available. + GTEST_CHECK_(sizeof(HANDLE) <= sizeof(size_t)); + + const HANDLE write_handle = + reinterpret_cast(write_handle_as_size_t); + HANDLE dup_write_handle; + + // The newly initialized handle is accessible only in in the parent + // process. To obtain one accessible within the child, we need to use + // DuplicateHandle. + if (!::DuplicateHandle(parent_process_handle.Get(), write_handle, + ::GetCurrentProcess(), &dup_write_handle, + 0x0, // Requested privileges ignored since + // DUPLICATE_SAME_ACCESS is used. + FALSE, // Request non-inheritable handler. + DUPLICATE_SAME_ACCESS)) { + DeathTestAbort("Unable to duplicate the pipe handle " + + StreamableToString(write_handle_as_size_t) + + " from the parent process " + + StreamableToString(parent_process_id)); + } + + const HANDLE event_handle = reinterpret_cast(event_handle_as_size_t); + HANDLE dup_event_handle; + + if (!::DuplicateHandle(parent_process_handle.Get(), event_handle, + ::GetCurrentProcess(), &dup_event_handle, + 0x0, + FALSE, + DUPLICATE_SAME_ACCESS)) { + DeathTestAbort("Unable to duplicate the event handle " + + StreamableToString(event_handle_as_size_t) + + " from the parent process " + + StreamableToString(parent_process_id)); + } + + const int write_fd = + ::_open_osfhandle(reinterpret_cast(dup_write_handle), O_APPEND); + if (write_fd == -1) { + DeathTestAbort("Unable to convert pipe handle " + + StreamableToString(write_handle_as_size_t) + + " to a file descriptor"); + } + + // Signals the parent that the write end of the pipe has been acquired + // so the parent can release its own write end. + ::SetEvent(dup_event_handle); + + return write_fd; +} +# endif // GTEST_OS_WINDOWS + +// Returns a newly created InternalRunDeathTestFlag object with fields +// initialized from the GTEST_FLAG(internal_run_death_test) flag if +// the flag is specified; otherwise returns NULL. +InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() { + if (GTEST_FLAG(internal_run_death_test) == "") return NULL; + + // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we + // can use it here. + int line = -1; + int index = -1; + ::std::vector< ::std::string> fields; + SplitString(GTEST_FLAG(internal_run_death_test).c_str(), '|', &fields); + int write_fd = -1; + +# if GTEST_OS_WINDOWS + + unsigned int parent_process_id = 0; + size_t write_handle_as_size_t = 0; + size_t event_handle_as_size_t = 0; + + if (fields.size() != 6 + || !ParseNaturalNumber(fields[1], &line) + || !ParseNaturalNumber(fields[2], &index) + || !ParseNaturalNumber(fields[3], &parent_process_id) + || !ParseNaturalNumber(fields[4], &write_handle_as_size_t) + || !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) { + DeathTestAbort("Bad --gtest_internal_run_death_test flag: " + + GTEST_FLAG(internal_run_death_test)); + } + write_fd = GetStatusFileDescriptor(parent_process_id, + write_handle_as_size_t, + event_handle_as_size_t); +# else + + if (fields.size() != 4 + || !ParseNaturalNumber(fields[1], &line) + || !ParseNaturalNumber(fields[2], &index) + || !ParseNaturalNumber(fields[3], &write_fd)) { + DeathTestAbort("Bad --gtest_internal_run_death_test flag: " + + GTEST_FLAG(internal_run_death_test)); + } + +# endif // GTEST_OS_WINDOWS + + return new InternalRunDeathTestFlag(fields[0], line, index, write_fd); +} + +} // namespace internal + +#endif // GTEST_HAS_DEATH_TEST + +} // namespace testing +// 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: keith.ray@gmail.com (Keith Ray) + + +#include + +#if GTEST_OS_WINDOWS_MOBILE +# include +#elif GTEST_OS_WINDOWS +# include +# include +#elif GTEST_OS_SYMBIAN +// Symbian OpenC has PATH_MAX in sys/syslimits.h +# include +#else +# include +# include // Some Linux distributions define PATH_MAX here. +#endif // GTEST_OS_WINDOWS_MOBILE + +#if GTEST_OS_WINDOWS +# define GTEST_PATH_MAX_ _MAX_PATH +#elif defined(PATH_MAX) +# define GTEST_PATH_MAX_ PATH_MAX +#elif defined(_XOPEN_PATH_MAX) +# define GTEST_PATH_MAX_ _XOPEN_PATH_MAX +#else +# define GTEST_PATH_MAX_ _POSIX_PATH_MAX +#endif // GTEST_OS_WINDOWS + + +namespace testing { +namespace internal { + +#if GTEST_OS_WINDOWS +// On Windows, '\\' is the standard path separator, but many tools and the +// Windows API also accept '/' as an alternate path separator. Unless otherwise +// noted, a file path can contain either kind of path separators, or a mixture +// of them. +const char kPathSeparator = '\\'; +const char kAlternatePathSeparator = '/'; +const char kPathSeparatorString[] = "\\"; +const char kAlternatePathSeparatorString[] = "/"; +# if GTEST_OS_WINDOWS_MOBILE +// Windows CE doesn't have a current directory. You should not use +// the current directory in tests on Windows CE, but this at least +// provides a reasonable fallback. +const char kCurrentDirectoryString[] = "\\"; +// Windows CE doesn't define INVALID_FILE_ATTRIBUTES +const DWORD kInvalidFileAttributes = 0xffffffff; +# else +const char kCurrentDirectoryString[] = ".\\"; +# endif // GTEST_OS_WINDOWS_MOBILE +#else +const char kPathSeparator = '/'; +const char kPathSeparatorString[] = "/"; +const char kCurrentDirectoryString[] = "./"; +#endif // GTEST_OS_WINDOWS + +// Returns whether the given character is a valid path separator. +static bool IsPathSeparator(char c) { +#if GTEST_HAS_ALT_PATH_SEP_ + return (c == kPathSeparator) || (c == kAlternatePathSeparator); +#else + return c == kPathSeparator; +#endif +} + +// Returns the current working directory, or "" if unsuccessful. +FilePath FilePath::GetCurrentDir() { +#if GTEST_OS_WINDOWS_MOBILE + // Windows CE doesn't have a current directory, so we just return + // something reasonable. + return FilePath(kCurrentDirectoryString); +#elif GTEST_OS_WINDOWS + char cwd[GTEST_PATH_MAX_ + 1] = { '\0' }; + return FilePath(_getcwd(cwd, sizeof(cwd)) == NULL ? "" : cwd); +#else + char cwd[GTEST_PATH_MAX_ + 1] = { '\0' }; + return FilePath(getcwd(cwd, sizeof(cwd)) == NULL ? "" : cwd); +#endif // GTEST_OS_WINDOWS_MOBILE +} + +// Returns a copy of the FilePath with the case-insensitive extension removed. +// Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns +// FilePath("dir/file"). If a case-insensitive extension is not +// found, returns a copy of the original FilePath. +FilePath FilePath::RemoveExtension(const char* extension) const { + const std::string dot_extension = std::string(".") + extension; + if (String::EndsWithCaseInsensitive(pathname_, dot_extension)) { + return FilePath(pathname_.substr( + 0, pathname_.length() - dot_extension.length())); + } + return *this; +} + +// Returns a pointer to the last occurence of a valid path separator in +// the FilePath. On Windows, for example, both '/' and '\' are valid path +// separators. Returns NULL if no path separator was found. +const char* FilePath::FindLastPathSeparator() const { + const char* const last_sep = strrchr(c_str(), kPathSeparator); +#if GTEST_HAS_ALT_PATH_SEP_ + const char* const last_alt_sep = strrchr(c_str(), kAlternatePathSeparator); + // Comparing two pointers of which only one is NULL is undefined. + if (last_alt_sep != NULL && + (last_sep == NULL || last_alt_sep > last_sep)) { + return last_alt_sep; + } +#endif + return last_sep; +} + +// Returns a copy of the FilePath with the directory part removed. +// Example: FilePath("path/to/file").RemoveDirectoryName() returns +// FilePath("file"). If there is no directory part ("just_a_file"), it returns +// the FilePath unmodified. If there is no file part ("just_a_dir/") it +// returns an empty FilePath (""). +// On Windows platform, '\' is the path separator, otherwise it is '/'. +FilePath FilePath::RemoveDirectoryName() const { + const char* const last_sep = FindLastPathSeparator(); + return last_sep ? FilePath(last_sep + 1) : *this; +} + +// RemoveFileName returns the directory path with the filename removed. +// Example: FilePath("path/to/file").RemoveFileName() returns "path/to/". +// If the FilePath is "a_file" or "/a_file", RemoveFileName returns +// FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does +// not have a file, like "just/a/dir/", it returns the FilePath unmodified. +// On Windows platform, '\' is the path separator, otherwise it is '/'. +FilePath FilePath::RemoveFileName() const { + const char* const last_sep = FindLastPathSeparator(); + std::string dir; + if (last_sep) { + dir = std::string(c_str(), last_sep + 1 - c_str()); + } else { + dir = kCurrentDirectoryString; + } + return FilePath(dir); +} + +// Helper functions for naming files in a directory for xml output. + +// Given directory = "dir", base_name = "test", number = 0, +// extension = "xml", returns "dir/test.xml". If number is greater +// than zero (e.g., 12), returns "dir/test_12.xml". +// On Windows platform, uses \ as the separator rather than /. +FilePath FilePath::MakeFileName(const FilePath& directory, + const FilePath& base_name, + int number, + const char* extension) { + std::string file; + if (number == 0) { + file = base_name.string() + "." + extension; + } else { + file = base_name.string() + "_" + StreamableToString(number) + + "." + extension; + } + return ConcatPaths(directory, FilePath(file)); +} + +// Given directory = "dir", relative_path = "test.xml", returns "dir/test.xml". +// On Windows, uses \ as the separator rather than /. +FilePath FilePath::ConcatPaths(const FilePath& directory, + const FilePath& relative_path) { + if (directory.IsEmpty()) + return relative_path; + const FilePath dir(directory.RemoveTrailingPathSeparator()); + return FilePath(dir.string() + kPathSeparator + relative_path.string()); +} + +// Returns true if pathname describes something findable in the file-system, +// either a file, directory, or whatever. +bool FilePath::FileOrDirectoryExists() const { +#if GTEST_OS_WINDOWS_MOBILE + LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str()); + const DWORD attributes = GetFileAttributes(unicode); + delete [] unicode; + return attributes != kInvalidFileAttributes; +#else + posix::StatStruct file_stat; + return posix::Stat(pathname_.c_str(), &file_stat) == 0; +#endif // GTEST_OS_WINDOWS_MOBILE +} + +// Returns true if pathname describes a directory in the file-system +// that exists. +bool FilePath::DirectoryExists() const { + bool result = false; +#if GTEST_OS_WINDOWS + // Don't strip off trailing separator if path is a root directory on + // Windows (like "C:\\"). + const FilePath& path(IsRootDirectory() ? *this : + RemoveTrailingPathSeparator()); +#else + const FilePath& path(*this); +#endif + +#if GTEST_OS_WINDOWS_MOBILE + LPCWSTR unicode = String::AnsiToUtf16(path.c_str()); + const DWORD attributes = GetFileAttributes(unicode); + delete [] unicode; + if ((attributes != kInvalidFileAttributes) && + (attributes & FILE_ATTRIBUTE_DIRECTORY)) { + result = true; + } +#else + posix::StatStruct file_stat; + result = posix::Stat(path.c_str(), &file_stat) == 0 && + posix::IsDir(file_stat); +#endif // GTEST_OS_WINDOWS_MOBILE + + return result; +} + +// Returns true if pathname describes a root directory. (Windows has one +// root directory per disk drive.) +bool FilePath::IsRootDirectory() const { +#if GTEST_OS_WINDOWS + // TODO(wan@google.com): on Windows a network share like + // \\server\share can be a root directory, although it cannot be the + // current directory. Handle this properly. + return pathname_.length() == 3 && IsAbsolutePath(); +#else + return pathname_.length() == 1 && IsPathSeparator(pathname_.c_str()[0]); +#endif +} + +// Returns true if pathname describes an absolute path. +bool FilePath::IsAbsolutePath() const { + const char* const name = pathname_.c_str(); +#if GTEST_OS_WINDOWS + return pathname_.length() >= 3 && + ((name[0] >= 'a' && name[0] <= 'z') || + (name[0] >= 'A' && name[0] <= 'Z')) && + name[1] == ':' && + IsPathSeparator(name[2]); +#else + return IsPathSeparator(name[0]); +#endif +} + +// Returns a pathname for a file that does not currently exist. The pathname +// will be directory/base_name.extension or +// directory/base_name_.extension if directory/base_name.extension +// already exists. The number will be incremented until a pathname is found +// that does not already exist. +// Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'. +// There could be a race condition if two or more processes are calling this +// function at the same time -- they could both pick the same filename. +FilePath FilePath::GenerateUniqueFileName(const FilePath& directory, + const FilePath& base_name, + const char* extension) { + FilePath full_pathname; + int number = 0; + do { + full_pathname.Set(MakeFileName(directory, base_name, number++, extension)); + } while (full_pathname.FileOrDirectoryExists()); + return full_pathname; +} + +// Returns true if FilePath ends with a path separator, which indicates that +// it is intended to represent a directory. Returns false otherwise. +// This does NOT check that a directory (or file) actually exists. +bool FilePath::IsDirectory() const { + return !pathname_.empty() && + IsPathSeparator(pathname_.c_str()[pathname_.length() - 1]); +} + +// Create directories so that path exists. Returns true if successful or if +// the directories already exist; returns false if unable to create directories +// for any reason. +bool FilePath::CreateDirectoriesRecursively() const { + if (!this->IsDirectory()) { + return false; + } + + if (pathname_.length() == 0 || this->DirectoryExists()) { + return true; + } + + const FilePath parent(this->RemoveTrailingPathSeparator().RemoveFileName()); + return parent.CreateDirectoriesRecursively() && this->CreateFolder(); +} + +// Create the directory so that path exists. Returns true if successful or +// if the directory already exists; returns false if unable to create the +// directory for any reason, including if the parent directory does not +// exist. Not named "CreateDirectory" because that's a macro on Windows. +bool FilePath::CreateFolder() const { +#if GTEST_OS_WINDOWS_MOBILE + FilePath removed_sep(this->RemoveTrailingPathSeparator()); + LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str()); + int result = CreateDirectory(unicode, NULL) ? 0 : -1; + delete [] unicode; +#elif GTEST_OS_WINDOWS + int result = _mkdir(pathname_.c_str()); +#else + int result = mkdir(pathname_.c_str(), 0777); +#endif // GTEST_OS_WINDOWS_MOBILE + + if (result == -1) { + return this->DirectoryExists(); // An error is OK if the directory exists. + } + return true; // No error. +} + +// If input name has a trailing separator character, remove it and return the +// name, otherwise return the name string unmodified. +// On Windows platform, uses \ as the separator, other platforms use /. +FilePath FilePath::RemoveTrailingPathSeparator() const { + return IsDirectory() + ? FilePath(pathname_.substr(0, pathname_.length() - 1)) + : *this; +} + +// Removes any redundant separators that might be in the pathname. +// For example, "bar///foo" becomes "bar/foo". Does not eliminate other +// redundancies that might be in a pathname involving "." or "..". +// TODO(wan@google.com): handle Windows network shares (e.g. \\server\share). +void FilePath::Normalize() { + if (pathname_.c_str() == NULL) { + pathname_ = ""; + return; + } + const char* src = pathname_.c_str(); + char* const dest = new char[pathname_.length() + 1]; + char* dest_ptr = dest; + memset(dest_ptr, 0, pathname_.length() + 1); + + while (*src != '\0') { + *dest_ptr = *src; + if (!IsPathSeparator(*src)) { + src++; + } else { +#if GTEST_HAS_ALT_PATH_SEP_ + if (*dest_ptr == kAlternatePathSeparator) { + *dest_ptr = kPathSeparator; + } +#endif + while (IsPathSeparator(*src)) + src++; + } + dest_ptr++; + } + *dest_ptr = '\0'; + pathname_ = dest; + delete[] dest; +} + +} // namespace internal +} // namespace testing +// 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. +// +// Author: wan@google.com (Zhanyong Wan) + + +#include +#include +#include +#include + +#if GTEST_OS_WINDOWS_MOBILE +# include // For TerminateProcess() +#elif GTEST_OS_WINDOWS +# include +# include +#else +# include +#endif // GTEST_OS_WINDOWS_MOBILE + +#if GTEST_OS_MAC +# include +# include +# include +#endif // GTEST_OS_MAC + +#if GTEST_OS_QNX +# include +# include +#endif // GTEST_OS_QNX + + +// 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 +#undef GTEST_IMPLEMENTATION_ + +namespace testing { +namespace internal { + +#if defined(_MSC_VER) || defined(__BORLANDC__) +// MSVC and C++Builder do not provide a definition of STDERR_FILENO. +const int kStdOutFileno = 1; +const int kStdErrFileno = 2; +#else +const int kStdOutFileno = STDOUT_FILENO; +const int kStdErrFileno = STDERR_FILENO; +#endif // _MSC_VER + +#if GTEST_OS_MAC + +// Returns the number of threads running in the process, or 0 to indicate that +// we cannot detect it. +size_t GetThreadCount() { + const task_t task = mach_task_self(); + mach_msg_type_number_t thread_count; + thread_act_array_t thread_list; + const kern_return_t status = task_threads(task, &thread_list, &thread_count); + if (status == KERN_SUCCESS) { + // task_threads allocates resources in thread_list and we need to free them + // to avoid leaks. + vm_deallocate(task, + reinterpret_cast(thread_list), + sizeof(thread_t) * thread_count); + return static_cast(thread_count); + } else { + return 0; + } +} + +#elif GTEST_OS_QNX + +// Returns the number of threads running in the process, or 0 to indicate that +// we cannot detect it. +size_t GetThreadCount() { + const int fd = open("/proc/self/as", O_RDONLY); + if (fd < 0) { + return 0; + } + procfs_info process_info; + const int status = + devctl(fd, DCMD_PROC_INFO, &process_info, sizeof(process_info), NULL); + close(fd); + if (status == EOK) { + return static_cast(process_info.num_threads); + } else { + return 0; + } +} + +#else + +size_t GetThreadCount() { + // There's no portable way to detect the number of threads, so we just + // return 0 to indicate that we cannot detect it. + return 0; +} + +#endif // GTEST_OS_MAC + +#if GTEST_USES_POSIX_RE + +// Implements RE. Currently only needed for death tests. + +RE::~RE() { + if (is_valid_) { + // regfree'ing an invalid regex might crash because the content + // of the regex is undefined. Since the regex's are essentially + // the same, one cannot be valid (or invalid) without the other + // being so too. + regfree(&partial_regex_); + regfree(&full_regex_); + } + free(const_cast(pattern_)); +} + +// Returns true iff regular expression re matches the entire str. +bool RE::FullMatch(const char* str, const RE& re) { + if (!re.is_valid_) return false; + + regmatch_t match; + return regexec(&re.full_regex_, str, 1, &match, 0) == 0; +} + +// Returns true iff regular expression re matches a substring of str +// (including str itself). +bool RE::PartialMatch(const char* str, const RE& re) { + if (!re.is_valid_) return false; + + regmatch_t match; + return regexec(&re.partial_regex_, str, 1, &match, 0) == 0; +} + +// Initializes an RE from its string representation. +void RE::Init(const char* regex) { + pattern_ = posix::StrDup(regex); + + // Reserves enough bytes to hold the regular expression used for a + // full match. + const size_t full_regex_len = strlen(regex) + 10; + char* const full_pattern = new char[full_regex_len]; + + snprintf(full_pattern, full_regex_len, "^(%s)$", regex); + is_valid_ = regcomp(&full_regex_, full_pattern, REG_EXTENDED) == 0; + // We want to call regcomp(&partial_regex_, ...) even if the + // previous expression returns false. Otherwise partial_regex_ may + // not be properly initialized can may cause trouble when it's + // freed. + // + // Some implementation of POSIX regex (e.g. on at least some + // versions of Cygwin) doesn't accept the empty string as a valid + // regex. We change it to an equivalent form "()" to be safe. + if (is_valid_) { + const char* const partial_regex = (*regex == '\0') ? "()" : regex; + is_valid_ = regcomp(&partial_regex_, partial_regex, REG_EXTENDED) == 0; + } + EXPECT_TRUE(is_valid_) + << "Regular expression \"" << regex + << "\" is not a valid POSIX Extended regular expression."; + + delete[] full_pattern; +} + +#elif GTEST_USES_SIMPLE_RE + +// Returns true iff ch appears anywhere in str (excluding the +// terminating '\0' character). +bool IsInSet(char ch, const char* str) { + return ch != '\0' && strchr(str, ch) != NULL; +} + +// Returns true iff ch belongs to the given classification. Unlike +// similar functions in , these aren't affected by the +// current locale. +bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; } +bool IsAsciiPunct(char ch) { + return IsInSet(ch, "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~"); +} +bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); } +bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); } +bool IsAsciiWordChar(char ch) { + return ('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') || + ('0' <= ch && ch <= '9') || ch == '_'; +} + +// Returns true iff "\\c" is a supported escape sequence. +bool IsValidEscape(char c) { + return (IsAsciiPunct(c) || IsInSet(c, "dDfnrsStvwW")); +} + +// Returns true iff the given atom (specified by escaped and pattern) +// matches ch. The result is undefined if the atom is invalid. +bool AtomMatchesChar(bool escaped, char pattern_char, char ch) { + if (escaped) { // "\\p" where p is pattern_char. + switch (pattern_char) { + case 'd': return IsAsciiDigit(ch); + case 'D': return !IsAsciiDigit(ch); + case 'f': return ch == '\f'; + case 'n': return ch == '\n'; + case 'r': return ch == '\r'; + case 's': return IsAsciiWhiteSpace(ch); + case 'S': return !IsAsciiWhiteSpace(ch); + case 't': return ch == '\t'; + case 'v': return ch == '\v'; + case 'w': return IsAsciiWordChar(ch); + case 'W': return !IsAsciiWordChar(ch); + } + return IsAsciiPunct(pattern_char) && pattern_char == ch; + } + + return (pattern_char == '.' && ch != '\n') || pattern_char == ch; +} + +// Helper function used by ValidateRegex() to format error messages. +std::string FormatRegexSyntaxError(const char* regex, int index) { + return (Message() << "Syntax error at index " << index + << " in simple regular expression \"" << regex << "\": ").GetString(); +} + +// Generates non-fatal failures and returns false if regex is invalid; +// otherwise returns true. +bool ValidateRegex(const char* regex) { + if (regex == NULL) { + // TODO(wan@google.com): fix the source file location in the + // assertion failures to match where the regex is used in user + // code. + ADD_FAILURE() << "NULL is not a valid simple regular expression."; + return false; + } + + bool is_valid = true; + + // True iff ?, *, or + can follow the previous atom. + bool prev_repeatable = false; + for (int i = 0; regex[i]; i++) { + if (regex[i] == '\\') { // An escape sequence + i++; + if (regex[i] == '\0') { + ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1) + << "'\\' cannot appear at the end."; + return false; + } + + if (!IsValidEscape(regex[i])) { + ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1) + << "invalid escape sequence \"\\" << regex[i] << "\"."; + is_valid = false; + } + prev_repeatable = true; + } else { // Not an escape sequence. + const char ch = regex[i]; + + if (ch == '^' && i > 0) { + ADD_FAILURE() << FormatRegexSyntaxError(regex, i) + << "'^' can only appear at the beginning."; + is_valid = false; + } else if (ch == '$' && regex[i + 1] != '\0') { + ADD_FAILURE() << FormatRegexSyntaxError(regex, i) + << "'$' can only appear at the end."; + is_valid = false; + } else if (IsInSet(ch, "()[]{}|")) { + ADD_FAILURE() << FormatRegexSyntaxError(regex, i) + << "'" << ch << "' is unsupported."; + is_valid = false; + } else if (IsRepeat(ch) && !prev_repeatable) { + ADD_FAILURE() << FormatRegexSyntaxError(regex, i) + << "'" << ch << "' can only follow a repeatable token."; + is_valid = false; + } + + prev_repeatable = !IsInSet(ch, "^$?*+"); + } + } + + return is_valid; +} + +// Matches a repeated regex atom followed by a valid simple regular +// expression. The regex atom is defined as c if escaped is false, +// or \c otherwise. repeat is the repetition meta character (?, *, +// or +). The behavior is undefined if str contains too many +// characters to be indexable by size_t, in which case the test will +// probably time out anyway. We are fine with this limitation as +// std::string has it too. +bool MatchRepetitionAndRegexAtHead( + bool escaped, char c, char repeat, const char* regex, + const char* str) { + const size_t min_count = (repeat == '+') ? 1 : 0; + const size_t max_count = (repeat == '?') ? 1 : + static_cast(-1) - 1; + // We cannot call numeric_limits::max() as it conflicts with the + // max() macro on Windows. + + for (size_t i = 0; i <= max_count; ++i) { + // We know that the atom matches each of the first i characters in str. + if (i >= min_count && MatchRegexAtHead(regex, str + i)) { + // We have enough matches at the head, and the tail matches too. + // Since we only care about *whether* the pattern matches str + // (as opposed to *how* it matches), there is no need to find a + // greedy match. + return true; + } + if (str[i] == '\0' || !AtomMatchesChar(escaped, c, str[i])) + return false; + } + return false; +} + +// Returns true iff regex matches a prefix of str. regex must be a +// valid simple regular expression and not start with "^", or the +// result is undefined. +bool MatchRegexAtHead(const char* regex, const char* str) { + if (*regex == '\0') // An empty regex matches a prefix of anything. + return true; + + // "$" only matches the end of a string. Note that regex being + // valid guarantees that there's nothing after "$" in it. + if (*regex == '$') + return *str == '\0'; + + // Is the first thing in regex an escape sequence? + const bool escaped = *regex == '\\'; + if (escaped) + ++regex; + if (IsRepeat(regex[1])) { + // MatchRepetitionAndRegexAtHead() calls MatchRegexAtHead(), so + // here's an indirect recursion. It terminates as the regex gets + // shorter in each recursion. + return MatchRepetitionAndRegexAtHead( + escaped, regex[0], regex[1], regex + 2, str); + } else { + // regex isn't empty, isn't "$", and doesn't start with a + // repetition. We match the first atom of regex with the first + // character of str and recurse. + return (*str != '\0') && AtomMatchesChar(escaped, *regex, *str) && + MatchRegexAtHead(regex + 1, str + 1); + } +} + +// Returns true iff regex matches any substring of str. regex must be +// a valid simple regular expression, or the result is undefined. +// +// The algorithm is recursive, but the recursion depth doesn't exceed +// the regex length, so we won't need to worry about running out of +// stack space normally. In rare cases the time complexity can be +// exponential with respect to the regex length + the string length, +// but usually it's must faster (often close to linear). +bool MatchRegexAnywhere(const char* regex, const char* str) { + if (regex == NULL || str == NULL) + return false; + + if (*regex == '^') + return MatchRegexAtHead(regex + 1, str); + + // A successful match can be anywhere in str. + do { + if (MatchRegexAtHead(regex, str)) + return true; + } while (*str++ != '\0'); + return false; +} + +// Implements the RE class. + +RE::~RE() { + free(const_cast(pattern_)); + free(const_cast(full_pattern_)); +} + +// Returns true iff regular expression re matches the entire str. +bool RE::FullMatch(const char* str, const RE& re) { + return re.is_valid_ && MatchRegexAnywhere(re.full_pattern_, str); +} + +// Returns true iff regular expression re matches a substring of str +// (including str itself). +bool RE::PartialMatch(const char* str, const RE& re) { + return re.is_valid_ && MatchRegexAnywhere(re.pattern_, str); +} + +// Initializes an RE from its string representation. +void RE::Init(const char* regex) { + pattern_ = full_pattern_ = NULL; + if (regex != NULL) { + pattern_ = posix::StrDup(regex); + } + + is_valid_ = ValidateRegex(regex); + if (!is_valid_) { + // No need to calculate the full pattern when the regex is invalid. + return; + } + + const size_t len = strlen(regex); + // Reserves enough bytes to hold the regular expression used for a + // full match: we need space to prepend a '^', append a '$', and + // terminate the string with '\0'. + char* buffer = static_cast(malloc(len + 3)); + full_pattern_ = buffer; + + if (*regex != '^') + *buffer++ = '^'; // Makes sure full_pattern_ starts with '^'. + + // We don't use snprintf or strncpy, as they trigger a warning when + // compiled with VC++ 8.0. + memcpy(buffer, regex, len); + buffer += len; + + if (len == 0 || regex[len - 1] != '$') + *buffer++ = '$'; // Makes sure full_pattern_ ends with '$'. + + *buffer = '\0'; +} + +#endif // GTEST_USES_POSIX_RE + +const char kUnknownFile[] = "unknown file"; + +// Formats a source file path and a line number as they would appear +// in an error message from the compiler used to compile this code. +GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) { + const std::string file_name(file == NULL ? kUnknownFile : file); + + if (line < 0) { + return file_name + ":"; + } +#ifdef _MSC_VER + return file_name + "(" + StreamableToString(line) + "):"; +#else + return file_name + ":" + StreamableToString(line) + ":"; +#endif // _MSC_VER +} + +// Formats a file location for compiler-independent XML output. +// Although this function is not platform dependent, we put it next to +// FormatFileLocation in order to contrast the two functions. +// Note that FormatCompilerIndependentFileLocation() does NOT append colon +// to the file location it produces, unlike FormatFileLocation(). +GTEST_API_ ::std::string FormatCompilerIndependentFileLocation( + const char* file, int line) { + const std::string file_name(file == NULL ? kUnknownFile : file); + + if (line < 0) + return file_name; + else + return file_name + ":" + StreamableToString(line); +} + + +GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line) + : severity_(severity) { + const char* const marker = + severity == GTEST_INFO ? "[ INFO ]" : + severity == GTEST_WARNING ? "[WARNING]" : + severity == GTEST_ERROR ? "[ ERROR ]" : "[ FATAL ]"; + GetStream() << ::std::endl << marker << " " + << FormatFileLocation(file, line).c_str() << ": "; +} + +// Flushes the buffers and, if severity is GTEST_FATAL, aborts the program. +GTestLog::~GTestLog() { + GetStream() << ::std::endl; + if (severity_ == GTEST_FATAL) { + fflush(stderr); + posix::Abort(); + } +} +// Disable Microsoft deprecation warnings for POSIX functions called from +// this class (creat, dup, dup2, and close) +#ifdef _MSC_VER +# pragma warning(push) +# pragma warning(disable: 4996) +#endif // _MSC_VER + +#if GTEST_HAS_STREAM_REDIRECTION + +// Object that captures an output stream (stdout/stderr). +class CapturedStream { + public: + // The ctor redirects the stream to a temporary file. + explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) { +# if GTEST_OS_WINDOWS + char temp_dir_path[MAX_PATH + 1] = { '\0' }; // NOLINT + char temp_file_path[MAX_PATH + 1] = { '\0' }; // NOLINT + + ::GetTempPathA(sizeof(temp_dir_path), temp_dir_path); + const UINT success = ::GetTempFileNameA(temp_dir_path, + "gtest_redir", + 0, // Generate unique file name. + temp_file_path); + GTEST_CHECK_(success != 0) + << "Unable to create a temporary file in " << temp_dir_path; + const int captured_fd = creat(temp_file_path, _S_IREAD | _S_IWRITE); + GTEST_CHECK_(captured_fd != -1) << "Unable to open temporary file " + << temp_file_path; + filename_ = temp_file_path; +# else + // There's no guarantee that a test has write access to the current + // directory, so we create the temporary file in the /tmp directory + // instead. We use /tmp on most systems, and /sdcard on Android. + // That's because Android doesn't have /tmp. +# if GTEST_OS_LINUX_ANDROID + // Note: Android applications are expected to call the framework's + // Context.getExternalStorageDirectory() method through JNI to get + // the location of the world-writable SD Card directory. However, + // this requires a Context handle, which cannot be retrieved + // globally from native code. Doing so also precludes running the + // code as part of a regular standalone executable, which doesn't + // run in a Dalvik process (e.g. when running it through 'adb shell'). + // + // The location /sdcard is directly accessible from native code + // and is the only location (unofficially) supported by the Android + // team. It's generally a symlink to the real SD Card mount point + // which can be /mnt/sdcard, /mnt/sdcard0, /system/media/sdcard, or + // other OEM-customized locations. Never rely on these, and always + // use /sdcard. + char name_template[] = "/sdcard/gtest_captured_stream.XXXXXX"; +# else + char name_template[] = "/tmp/captured_stream.XXXXXX"; +# endif // GTEST_OS_LINUX_ANDROID + const int captured_fd = mkstemp(name_template); + filename_ = name_template; +# endif // GTEST_OS_WINDOWS + fflush(NULL); + dup2(captured_fd, fd_); + close(captured_fd); + } + + ~CapturedStream() { + remove(filename_.c_str()); + } + + std::string GetCapturedString() { + if (uncaptured_fd_ != -1) { + // Restores the original stream. + fflush(NULL); + dup2(uncaptured_fd_, fd_); + close(uncaptured_fd_); + uncaptured_fd_ = -1; + } + + FILE* const file = posix::FOpen(filename_.c_str(), "r"); + const std::string content = ReadEntireFile(file); + posix::FClose(file); + return content; + } + + private: + // Reads the entire content of a file as an std::string. + static std::string ReadEntireFile(FILE* file); + + // Returns the size (in bytes) of a file. + static size_t GetFileSize(FILE* file); + + const int fd_; // A stream to capture. + int uncaptured_fd_; + // Name of the temporary file holding the stderr output. + ::std::string filename_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(CapturedStream); +}; + +// Returns the size (in bytes) of a file. +size_t CapturedStream::GetFileSize(FILE* file) { + fseek(file, 0, SEEK_END); + return static_cast(ftell(file)); +} + +// Reads the entire content of a file as a string. +std::string CapturedStream::ReadEntireFile(FILE* file) { + const size_t file_size = GetFileSize(file); + char* const buffer = new char[file_size]; + + size_t bytes_last_read = 0; // # of bytes read in the last fread() + size_t bytes_read = 0; // # of bytes read so far + + fseek(file, 0, SEEK_SET); + + // Keeps reading the file until we cannot read further or the + // pre-determined file size is reached. + do { + bytes_last_read = fread(buffer+bytes_read, 1, file_size-bytes_read, file); + bytes_read += bytes_last_read; + } while (bytes_last_read > 0 && bytes_read < file_size); + + const std::string content(buffer, bytes_read); + delete[] buffer; + + return content; +} + +# ifdef _MSC_VER +# pragma warning(pop) +# endif // _MSC_VER + +static CapturedStream* g_captured_stderr = NULL; +static CapturedStream* g_captured_stdout = NULL; + +// Starts capturing an output stream (stdout/stderr). +void CaptureStream(int fd, const char* stream_name, CapturedStream** stream) { + if (*stream != NULL) { + GTEST_LOG_(FATAL) << "Only one " << stream_name + << " capturer can exist at a time."; + } + *stream = new CapturedStream(fd); +} + +// Stops capturing the output stream and returns the captured string. +std::string GetCapturedStream(CapturedStream** captured_stream) { + const std::string content = (*captured_stream)->GetCapturedString(); + + delete *captured_stream; + *captured_stream = NULL; + + return content; +} + +// Starts capturing stdout. +void CaptureStdout() { + CaptureStream(kStdOutFileno, "stdout", &g_captured_stdout); +} + +// Starts capturing stderr. +void CaptureStderr() { + CaptureStream(kStdErrFileno, "stderr", &g_captured_stderr); +} + +// Stops capturing stdout and returns the captured string. +std::string GetCapturedStdout() { + return GetCapturedStream(&g_captured_stdout); +} + +// Stops capturing stderr and returns the captured string. +std::string GetCapturedStderr() { + return GetCapturedStream(&g_captured_stderr); +} + +#endif // GTEST_HAS_STREAM_REDIRECTION + +#if GTEST_HAS_DEATH_TEST + +// A copy of all command line arguments. Set by InitGoogleTest(). +::std::vector g_argvs; + +static const ::std::vector* g_injected_test_argvs = + NULL; // Owned. + +void SetInjectableArgvs(const ::std::vector* argvs) { + if (g_injected_test_argvs != argvs) + delete g_injected_test_argvs; + g_injected_test_argvs = argvs; +} + +const ::std::vector& GetInjectableArgvs() { + if (g_injected_test_argvs != NULL) { + return *g_injected_test_argvs; + } + return g_argvs; +} +#endif // GTEST_HAS_DEATH_TEST + +#if GTEST_OS_WINDOWS_MOBILE +namespace posix { +void Abort() { + DebugBreak(); + TerminateProcess(GetCurrentProcess(), 1); +} +} // namespace posix +#endif // GTEST_OS_WINDOWS_MOBILE + +// Returns the name of the environment variable corresponding to the +// given flag. For example, FlagToEnvVar("foo") will return +// "GTEST_FOO" in the open-source version. +static std::string FlagToEnvVar(const char* flag) { + const std::string full_flag = + (Message() << GTEST_FLAG_PREFIX_ << flag).GetString(); + + Message env_var; + for (size_t i = 0; i != full_flag.length(); i++) { + env_var << ToUpper(full_flag.c_str()[i]); + } + + return env_var.GetString(); +} + +// Parses 'str' for a 32-bit signed integer. If successful, writes +// the result to *value and returns true; otherwise leaves *value +// unchanged and returns false. +bool ParseInt32(const Message& src_text, const char* str, Int32* value) { + // Parses the environment variable as a decimal integer. + char* end = NULL; + const long long_value = strtol(str, &end, 10); // NOLINT + + // Has strtol() consumed all characters in the string? + if (*end != '\0') { + // No - an invalid character was encountered. + Message msg; + msg << "WARNING: " << src_text + << " is expected to be a 32-bit integer, but actually" + << " has value \"" << str << "\".\n"; + printf("%s", msg.GetString().c_str()); + fflush(stdout); + return false; + } + + // Is the parsed value in the range of an Int32? + const Int32 result = static_cast(long_value); + if (long_value == LONG_MAX || long_value == LONG_MIN || + // The parsed value overflows as a long. (strtol() returns + // LONG_MAX or LONG_MIN when the input overflows.) + result != long_value + // The parsed value overflows as an Int32. + ) { + Message msg; + msg << "WARNING: " << src_text + << " is expected to be a 32-bit integer, but actually" + << " has value " << str << ", which overflows.\n"; + printf("%s", msg.GetString().c_str()); + fflush(stdout); + return false; + } + + *value = result; + return true; +} + +// Reads and returns the Boolean environment variable corresponding to +// the given flag; if it's not set, returns default_value. +// +// The value is considered true iff it's not "0". +bool BoolFromGTestEnv(const char* flag, bool default_value) { + const std::string env_var = FlagToEnvVar(flag); + const char* const string_value = posix::GetEnv(env_var.c_str()); + return string_value == NULL ? + default_value : strcmp(string_value, "0") != 0; +} + +// Reads and returns a 32-bit integer stored in the environment +// variable corresponding to the given flag; if it isn't set or +// doesn't represent a valid 32-bit integer, returns default_value. +Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) { + const std::string env_var = FlagToEnvVar(flag); + const char* const string_value = posix::GetEnv(env_var.c_str()); + if (string_value == NULL) { + // The environment variable is not set. + return default_value; + } + + Int32 result = default_value; + if (!ParseInt32(Message() << "Environment variable " << env_var, + string_value, &result)) { + printf("The default value %s is used.\n", + (Message() << default_value).GetString().c_str()); + fflush(stdout); + return default_value; + } + + return result; +} + +// Reads and returns the string environment variable corresponding to +// the given flag; if it's not set, returns default_value. +const char* StringFromGTestEnv(const char* flag, const char* default_value) { + const std::string env_var = FlagToEnvVar(flag); + const char* const value = posix::GetEnv(env_var.c_str()); + return value == NULL ? default_value : value; +} + +} // namespace internal +} // namespace testing +// 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. +// +// Author: wan@google.com (Zhanyong Wan) + +// Google Test - The Google C++ Testing Framework +// +// This file implements a universal value printer that can print a +// value of any type T: +// +// void ::testing::internal::UniversalPrinter::Print(value, ostream_ptr); +// +// It uses the << operator when possible, and prints the bytes in the +// object otherwise. A user can override its behavior for a class +// type Foo by defining either operator<<(::std::ostream&, const Foo&) +// or void PrintTo(const Foo&, ::std::ostream*) in the namespace that +// defines Foo. + +#include +#include +#include // NOLINT +#include + +namespace testing { + +namespace { + +using ::std::ostream; + +// Prints a segment of bytes in the given object. +void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start, + size_t count, ostream* os) { + char text[5] = ""; + for (size_t i = 0; i != count; i++) { + const size_t j = start + i; + if (i != 0) { + // Organizes the bytes into groups of 2 for easy parsing by + // human. + if ((j % 2) == 0) + *os << ' '; + else + *os << '-'; + } + GTEST_SNPRINTF_(text, sizeof(text), "%02X", obj_bytes[j]); + *os << text; + } +} + +// Prints the bytes in the given value to the given ostream. +void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t count, + ostream* os) { + // Tells the user how big the object is. + *os << count << "-byte object <"; + + const size_t kThreshold = 132; + const size_t kChunkSize = 64; + // If the object size is bigger than kThreshold, we'll have to omit + // some details by printing only the first and the last kChunkSize + // bytes. + // TODO(wan): let the user control the threshold using a flag. + if (count < kThreshold) { + PrintByteSegmentInObjectTo(obj_bytes, 0, count, os); + } else { + PrintByteSegmentInObjectTo(obj_bytes, 0, kChunkSize, os); + *os << " ... "; + // Rounds up to 2-byte boundary. + const size_t resume_pos = (count - kChunkSize + 1)/2*2; + PrintByteSegmentInObjectTo(obj_bytes, resume_pos, count - resume_pos, os); + } + *os << ">"; +} + +} // namespace + +namespace internal2 { + +// Delegates to PrintBytesInObjectToImpl() to print the bytes in the +// given object. The delegation simplifies the implementation, which +// uses the << operator and thus is easier done outside of the +// ::testing::internal namespace, which contains a << operator that +// sometimes conflicts with the one in STL. +void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count, + ostream* os) { + PrintBytesInObjectToImpl(obj_bytes, count, os); +} + +} // namespace internal2 + +namespace internal { + +// Depending on the value of a char (or wchar_t), we print it in one +// of three formats: +// - as is if it's a printable ASCII (e.g. 'a', '2', ' '), +// - as a hexidecimal escape sequence (e.g. '\x7F'), or +// - as a special escape sequence (e.g. '\r', '\n'). +enum CharFormat { + kAsIs, + kHexEscape, + kSpecialEscape +}; + +// Returns true if c is a printable ASCII character. We test the +// value of c directly instead of calling isprint(), which is buggy on +// Windows Mobile. +inline bool IsPrintableAscii(wchar_t c) { + return 0x20 <= c && c <= 0x7E; +} + +// Prints a wide or narrow char c as a character literal without the +// quotes, escaping it when necessary; returns how c was formatted. +// The template argument UnsignedChar is the unsigned version of Char, +// which is the type of c. +template +static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) { + switch (static_cast(c)) { + case L'\0': + *os << "\\0"; + break; + case L'\'': + *os << "\\'"; + break; + case L'\\': + *os << "\\\\"; + break; + case L'\a': + *os << "\\a"; + break; + case L'\b': + *os << "\\b"; + break; + case L'\f': + *os << "\\f"; + break; + case L'\n': + *os << "\\n"; + break; + case L'\r': + *os << "\\r"; + break; + case L'\t': + *os << "\\t"; + break; + case L'\v': + *os << "\\v"; + break; + default: + if (IsPrintableAscii(c)) { + *os << static_cast(c); + return kAsIs; + } else { + *os << "\\x" + String::FormatHexInt(static_cast(c)); + return kHexEscape; + } + } + return kSpecialEscape; +} + +// Prints a wchar_t c as if it's part of a string literal, escaping it when +// necessary; returns how c was formatted. +static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) { + switch (c) { + case L'\'': + *os << "'"; + return kAsIs; + case L'"': + *os << "\\\""; + return kSpecialEscape; + default: + return PrintAsCharLiteralTo(c, os); + } +} + +// Prints a char c as if it's part of a string literal, escaping it when +// necessary; returns how c was formatted. +static CharFormat PrintAsStringLiteralTo(char c, ostream* os) { + return PrintAsStringLiteralTo( + static_cast(static_cast(c)), os); +} + +// Prints a wide or narrow character c and its code. '\0' is printed +// as "'\\0'", other unprintable characters are also properly escaped +// using the standard C++ escape sequence. The template argument +// UnsignedChar is the unsigned version of Char, which is the type of c. +template +void PrintCharAndCodeTo(Char c, ostream* os) { + // First, print c as a literal in the most readable form we can find. + *os << ((sizeof(c) > 1) ? "L'" : "'"); + const CharFormat format = PrintAsCharLiteralTo(c, os); + *os << "'"; + + // To aid user debugging, we also print c's code in decimal, unless + // it's 0 (in which case c was printed as '\\0', making the code + // obvious). + if (c == 0) + return; + *os << " (" << static_cast(c); + + // For more convenience, we print c's code again in hexidecimal, + // unless c was already printed in the form '\x##' or the code is in + // [1, 9]. + if (format == kHexEscape || (1 <= c && c <= 9)) { + // Do nothing. + } else { + *os << ", 0x" << String::FormatHexInt(static_cast(c)); + } + *os << ")"; +} + +void PrintTo(unsigned char c, ::std::ostream* os) { + PrintCharAndCodeTo(c, os); +} +void PrintTo(signed char c, ::std::ostream* os) { + PrintCharAndCodeTo(c, os); +} + +// Prints a wchar_t as a symbol if it is printable or as its internal +// code otherwise and also as its code. L'\0' is printed as "L'\\0'". +void PrintTo(wchar_t wc, ostream* os) { + PrintCharAndCodeTo(wc, os); +} + +// Prints the given array of characters to the ostream. CharType must be either +// char or wchar_t. +// The array starts at begin, the length is len, it may include '\0' characters +// and may not be NUL-terminated. +template +static void PrintCharsAsStringTo( + const CharType* begin, size_t len, ostream* os) { + const char* const kQuoteBegin = sizeof(CharType) == 1 ? "\"" : "L\""; + *os << kQuoteBegin; + bool is_previous_hex = false; + for (size_t index = 0; index < len; ++index) { + const CharType cur = begin[index]; + if (is_previous_hex && IsXDigit(cur)) { + // Previous character is of '\x..' form and this character can be + // interpreted as another hexadecimal digit in its number. Break string to + // disambiguate. + *os << "\" " << kQuoteBegin; + } + is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape; + } + *os << "\""; +} + +// Prints a (const) char/wchar_t array of 'len' elements, starting at address +// 'begin'. CharType must be either char or wchar_t. +template +static void UniversalPrintCharArray( + const CharType* begin, size_t len, ostream* os) { + // The code + // const char kFoo[] = "foo"; + // generates an array of 4, not 3, elements, with the last one being '\0'. + // + // Therefore when printing a char array, we don't print the last element if + // it's '\0', such that the output matches the string literal as it's + // written in the source code. + if (len > 0 && begin[len - 1] == '\0') { + PrintCharsAsStringTo(begin, len - 1, os); + return; + } + + // If, however, the last element in the array is not '\0', e.g. + // const char kFoo[] = { 'f', 'o', 'o' }; + // we must print the entire array. We also print a message to indicate + // that the array is not NUL-terminated. + PrintCharsAsStringTo(begin, len, os); + *os << " (no terminating NUL)"; +} + +// Prints a (const) char array of 'len' elements, starting at address 'begin'. +void UniversalPrintArray(const char* begin, size_t len, ostream* os) { + UniversalPrintCharArray(begin, len, os); +} + +// Prints a (const) wchar_t array of 'len' elements, starting at address +// 'begin'. +void UniversalPrintArray(const wchar_t* begin, size_t len, ostream* os) { + UniversalPrintCharArray(begin, len, os); +} + +// Prints the given C string to the ostream. +void PrintTo(const char* s, ostream* os) { + if (s == NULL) { + *os << "NULL"; + } else { + *os << ImplicitCast_(s) << " pointing to "; + PrintCharsAsStringTo(s, strlen(s), os); + } +} + +// MSVC compiler can be configured to define whar_t as a typedef +// of unsigned short. Defining an overload for const wchar_t* in that case +// would cause pointers to unsigned shorts be printed as wide strings, +// possibly accessing more memory than intended and causing invalid +// memory accesses. MSVC defines _NATIVE_WCHAR_T_DEFINED symbol when +// wchar_t is implemented as a native type. +#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) +// Prints the given wide C string to the ostream. +void PrintTo(const wchar_t* s, ostream* os) { + if (s == NULL) { + *os << "NULL"; + } else { + *os << ImplicitCast_(s) << " pointing to "; + PrintCharsAsStringTo(s, wcslen(s), os); + } +} +#endif // wchar_t is native + +// Prints a ::string object. +#if GTEST_HAS_GLOBAL_STRING +void PrintStringTo(const ::string& s, ostream* os) { + PrintCharsAsStringTo(s.data(), s.size(), os); +} +#endif // GTEST_HAS_GLOBAL_STRING + +void PrintStringTo(const ::std::string& s, ostream* os) { + PrintCharsAsStringTo(s.data(), s.size(), os); +} + +// Prints a ::wstring object. +#if GTEST_HAS_GLOBAL_WSTRING +void PrintWideStringTo(const ::wstring& s, ostream* os) { + PrintCharsAsStringTo(s.data(), s.size(), os); +} +#endif // GTEST_HAS_GLOBAL_WSTRING + +#if GTEST_HAS_STD_WSTRING +void PrintWideStringTo(const ::std::wstring& s, ostream* os) { + PrintCharsAsStringTo(s.data(), s.size(), os); +} +#endif // GTEST_HAS_STD_WSTRING + +} // namespace internal + +} // namespace testing +// 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. +// +// Author: mheule@google.com (Markus Heule) +// +// The Google C++ Testing Framework (Google Test) + + +// 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 +#undef GTEST_IMPLEMENTATION_ + +namespace testing { + +using internal::GetUnitTestImpl; + +// Gets the summary of the failure message by omitting the stack trace +// in it. +std::string TestPartResult::ExtractSummary(const char* message) { + const char* const stack_trace = strstr(message, internal::kStackTraceMarker); + return stack_trace == NULL ? message : + std::string(message, stack_trace); +} + +// Prints a TestPartResult object. +std::ostream& operator<<(std::ostream& os, const TestPartResult& result) { + return os + << result.file_name() << ":" << result.line_number() << ": " + << (result.type() == TestPartResult::kSuccess ? "Success" : + result.type() == TestPartResult::kFatalFailure ? "Fatal failure" : + "Non-fatal failure") << ":\n" + << result.message() << std::endl; +} + +// Appends a TestPartResult to the array. +void TestPartResultArray::Append(const TestPartResult& result) { + array_.push_back(result); +} + +// Returns the TestPartResult at the given index (0-based). +const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const { + if (index < 0 || index >= size()) { + printf("\nInvalid index (%d) into TestPartResultArray.\n", index); + internal::posix::Abort(); + } + + return array_[index]; +} + +// Returns the number of TestPartResult objects in the array. +int TestPartResultArray::size() const { + return static_cast(array_.size()); +} + +namespace internal { + +HasNewFatalFailureHelper::HasNewFatalFailureHelper() + : has_new_fatal_failure_(false), + original_reporter_(GetUnitTestImpl()-> + GetTestPartResultReporterForCurrentThread()) { + GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(this); +} + +HasNewFatalFailureHelper::~HasNewFatalFailureHelper() { + GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread( + original_reporter_); +} + +void HasNewFatalFailureHelper::ReportTestPartResult( + const TestPartResult& result) { + if (result.fatally_failed()) + has_new_fatal_failure_ = true; + original_reporter_->ReportTestPartResult(result); +} + +} // namespace internal + +} // namespace testing +// 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. +// +// Author: wan@google.com (Zhanyong Wan) + + +namespace testing { +namespace internal { + +#if GTEST_HAS_TYPED_TEST_P + +// Skips to the first non-space char in str. Returns an empty string if str +// contains only whitespace characters. +static const char* SkipSpaces(const char* str) { + while (IsSpace(*str)) + str++; + return str; +} + +// Verifies that registered_tests match the test names in +// defined_test_names_; returns registered_tests if successful, or +// aborts the program otherwise. +const char* TypedTestCasePState::VerifyRegisteredTestNames( + const char* file, int line, const char* registered_tests) { + typedef ::std::set::const_iterator DefinedTestIter; + registered_ = true; + + // Skip initial whitespace in registered_tests since some + // preprocessors prefix stringizied literals with whitespace. + registered_tests = SkipSpaces(registered_tests); + + Message errors; + ::std::set tests; + for (const char* names = registered_tests; names != NULL; + names = SkipComma(names)) { + const std::string name = GetPrefixUntilComma(names); + if (tests.count(name) != 0) { + errors << "Test " << name << " is listed more than once.\n"; + continue; + } + + bool found = false; + for (DefinedTestIter it = defined_test_names_.begin(); + it != defined_test_names_.end(); + ++it) { + if (name == *it) { + found = true; + break; + } + } + + if (found) { + tests.insert(name); + } else { + errors << "No test named " << name + << " can be found in this test case.\n"; + } + } + + for (DefinedTestIter it = defined_test_names_.begin(); + it != defined_test_names_.end(); + ++it) { + if (tests.count(*it) == 0) { + errors << "You forgot to list test " << *it << ".\n"; + } + } + + const std::string& errors_str = errors.GetString(); + if (errors_str != "") { + fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(), + errors_str.c_str()); + fflush(stderr); + posix::Abort(); + } + + return registered_tests; +} + +#endif // GTEST_HAS_TYPED_TEST_P + +} // namespace internal +} // namespace testing diff --git a/SaryninS/lab 1/gtest/gtest.h b/SaryninS/lab 1/gtest/gtest.h new file mode 100644 index 000000000..6e7cfc2be --- /dev/null +++ b/SaryninS/lab 1/gtest/gtest.h @@ -0,0 +1,20063 @@ +// 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) +// +// This header file defines the public API for Google Test. It should be +// included by any test program that uses Google Test. +// +// IMPORTANT NOTE: Due to limitation of the C++ language, we have to +// leave some internal implementation details in this header file. +// They are clearly marked by comments like this: +// +// // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +// +// Such code is NOT meant to be used by a user directly, and is subject +// to CHANGE WITHOUT NOTICE. Therefore DO NOT DEPEND ON IT in a user +// program! +// +// Acknowledgment: Google Test borrowed the idea of automatic test +// registration from Barthelemy Dagenais' (barthelemy@prologique.com) +// easyUnit framework. + +#define _VARIADIC_MAX 10 + +#ifndef GTEST_INCLUDE_GTEST_GTEST_H_ +#define GTEST_INCLUDE_GTEST_GTEST_H_ + +#include +#include +#include + +// 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. +// +// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee) +// +// The Google C++ Testing Framework (Google Test) +// +// This header file declares functions and macros used internally by +// Google Test. They are subject to change without notice. + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ + +// 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. +// +// Authors: wan@google.com (Zhanyong Wan) +// +// Low-level types and utilities for porting Google Test to various +// platforms. They are subject to change without notice. DO NOT USE +// THEM IN USER CODE. +// +// This file is fundamental to Google Test. All other Google Test source +// files are expected to #include this. Therefore, it cannot #include +// any other Google Test header. + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ + +// The user can define the following macros in the build script to +// control Google Test's behavior. If the user doesn't define a macro +// in this list, Google Test will define it. +// +// GTEST_HAS_CLONE - Define it to 1/0 to indicate that clone(2) +// is/isn't available. +// GTEST_HAS_EXCEPTIONS - Define it to 1/0 to indicate that exceptions +// are enabled. +// GTEST_HAS_GLOBAL_STRING - Define it to 1/0 to indicate that ::string +// is/isn't available (some systems define +// ::string, which is different to std::string). +// GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string +// is/isn't available (some systems define +// ::wstring, which is different to std::wstring). +// GTEST_HAS_POSIX_RE - Define it to 1/0 to indicate that POSIX regular +// expressions are/aren't available. +// GTEST_HAS_PTHREAD - Define it to 1/0 to indicate that +// is/isn't available. +// GTEST_HAS_RTTI - Define it to 1/0 to indicate that RTTI is/isn't +// enabled. +// GTEST_HAS_STD_WSTRING - Define it to 1/0 to indicate that +// std::wstring does/doesn't work (Google Test can +// be used where std::wstring is unavailable). +// GTEST_HAS_TR1_TUPLE - Define it to 1/0 to indicate tr1::tuple +// is/isn't available. +// GTEST_HAS_SEH - Define it to 1/0 to indicate whether the +// compiler supports Microsoft's "Structured +// Exception Handling". +// GTEST_HAS_STREAM_REDIRECTION +// - Define it to 1/0 to indicate whether the +// platform supports I/O stream redirection using +// dup() and dup2(). +// GTEST_USE_OWN_TR1_TUPLE - Define it to 1/0 to indicate whether Google +// Test's own tr1 tuple implementation should be +// used. Unused when the user sets +// GTEST_HAS_TR1_TUPLE to 0. +// GTEST_LANG_CXX11 - Define it to 1/0 to indicate that Google Test +// is building in C++11/C++98 mode. +// GTEST_LINKED_AS_SHARED_LIBRARY +// - Define to 1 when compiling tests that use +// Google Test as a shared library (known as +// DLL on Windows). +// GTEST_CREATE_SHARED_LIBRARY +// - Define to 1 when compiling Google Test itself +// as a shared library. + +// This header defines the following utilities: +// +// Macros indicating the current platform (defined to 1 if compiled on +// the given platform; otherwise undefined): +// GTEST_OS_AIX - IBM AIX +// GTEST_OS_CYGWIN - Cygwin +// GTEST_OS_HPUX - HP-UX +// GTEST_OS_LINUX - Linux +// GTEST_OS_LINUX_ANDROID - Google Android +// GTEST_OS_MAC - Mac OS X +// GTEST_OS_IOS - iOS +// GTEST_OS_IOS_SIMULATOR - iOS simulator +// GTEST_OS_NACL - Google Native Client (NaCl) +// GTEST_OS_OPENBSD - OpenBSD +// GTEST_OS_QNX - QNX +// GTEST_OS_SOLARIS - Sun Solaris +// GTEST_OS_SYMBIAN - Symbian +// GTEST_OS_WINDOWS - Windows (Desktop, MinGW, or Mobile) +// GTEST_OS_WINDOWS_DESKTOP - Windows Desktop +// GTEST_OS_WINDOWS_MINGW - MinGW +// GTEST_OS_WINDOWS_MOBILE - Windows Mobile +// GTEST_OS_ZOS - z/OS +// +// Among the platforms, Cygwin, Linux, Max OS X, and Windows have the +// most stable support. Since core members of the Google Test project +// don't have access to other platforms, support for them may be less +// stable. If you notice any problems on your platform, please notify +// googletestframework@googlegroups.com (patches for fixing them are +// even more welcome!). +// +// Note that it is possible that none of the GTEST_OS_* macros are defined. +// +// Macros indicating available Google Test features (defined to 1 if +// the corresponding feature is supported; otherwise undefined): +// GTEST_HAS_COMBINE - the Combine() function (for value-parameterized +// tests) +// GTEST_HAS_DEATH_TEST - death tests +// GTEST_HAS_PARAM_TEST - value-parameterized tests +// GTEST_HAS_TYPED_TEST - typed tests +// GTEST_HAS_TYPED_TEST_P - type-parameterized tests +// GTEST_USES_POSIX_RE - enhanced POSIX regex is used. Do not confuse with +// GTEST_HAS_POSIX_RE (see above) which users can +// define themselves. +// GTEST_USES_SIMPLE_RE - our own simple regex is used; +// the above two are mutually exclusive. +// GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ(). +// +// Macros for basic C++ coding: +// GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning. +// GTEST_ATTRIBUTE_UNUSED_ - declares that a class' instances or a +// variable don't have to be used. +// GTEST_DISALLOW_ASSIGN_ - disables operator=. +// GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=. +// GTEST_MUST_USE_RESULT_ - declares that a function's result must be used. +// +// Synchronization: +// Mutex, MutexLock, ThreadLocal, GetThreadCount() +// - synchronization primitives. +// GTEST_IS_THREADSAFE - defined to 1 to indicate that the above +// synchronization primitives have real implementations +// and Google Test is thread-safe; or 0 otherwise. +// +// Template meta programming: +// is_pointer - as in TR1; needed on Symbian and IBM XL C/C++ only. +// IteratorTraits - partial implementation of std::iterator_traits, which +// is not available in libCstd when compiled with Sun C++. +// +// Smart pointers: +// scoped_ptr - as in TR2. +// +// Regular expressions: +// RE - a simple regular expression class using the POSIX +// Extended Regular Expression syntax on UNIX-like +// platforms, or a reduced regular exception syntax on +// other platforms, including Windows. +// +// Logging: +// GTEST_LOG_() - logs messages at the specified severity level. +// LogToStderr() - directs all log messages to stderr. +// FlushInfoLog() - flushes informational log messages. +// +// Stdout and stderr capturing: +// CaptureStdout() - starts capturing stdout. +// GetCapturedStdout() - stops capturing stdout and returns the captured +// string. +// CaptureStderr() - starts capturing stderr. +// GetCapturedStderr() - stops capturing stderr and returns the captured +// string. +// +// Integer types: +// TypeWithSize - maps an integer to a int type. +// Int32, UInt32, Int64, UInt64, TimeInMillis +// - integers of known sizes. +// BiggestInt - the biggest signed integer type. +// +// Command-line utilities: +// GTEST_FLAG() - references a flag. +// GTEST_DECLARE_*() - declares a flag. +// GTEST_DEFINE_*() - defines a flag. +// GetInjectableArgvs() - returns the command line as a vector of strings. +// +// Environment variable utilities: +// GetEnv() - gets the value of an environment variable. +// BoolFromGTestEnv() - parses a bool environment variable. +// Int32FromGTestEnv() - parses an Int32 environment variable. +// StringFromGTestEnv() - parses a string environment variable. + +#include // for isspace, etc +#include // for ptrdiff_t +#include +#include +#include +#ifndef _WIN32_WCE +# include +# include +#endif // !_WIN32_WCE + +#if defined __APPLE__ +# include +# include +#endif + +#include // NOLINT +#include // NOLINT +#include // NOLINT + +#define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com" +#define GTEST_FLAG_PREFIX_ "gtest_" +#define GTEST_FLAG_PREFIX_DASH_ "gtest-" +#define GTEST_FLAG_PREFIX_UPPER_ "GTEST_" +#define GTEST_NAME_ "Google Test" +#define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/" + +// Determines the version of gcc that is used to compile this. +#ifdef __GNUC__ +// 40302 means version 4.3.2. +# define GTEST_GCC_VER_ \ + (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__) +#endif // __GNUC__ + +// Determines the platform on which Google Test is compiled. +#ifdef __CYGWIN__ +# define GTEST_OS_CYGWIN 1 +#elif defined __SYMBIAN32__ +# define GTEST_OS_SYMBIAN 1 +#elif defined _WIN32 +# define GTEST_OS_WINDOWS 1 +# ifdef _WIN32_WCE +# define GTEST_OS_WINDOWS_MOBILE 1 +# elif defined(__MINGW__) || defined(__MINGW32__) +# define GTEST_OS_WINDOWS_MINGW 1 +# else +# define GTEST_OS_WINDOWS_DESKTOP 1 +# endif // _WIN32_WCE +#elif defined __APPLE__ +# define GTEST_OS_MAC 1 +# if TARGET_OS_IPHONE +# define GTEST_OS_IOS 1 +# if TARGET_IPHONE_SIMULATOR +# define GTEST_OS_IOS_SIMULATOR 1 +# endif +# endif +#elif defined __linux__ +# define GTEST_OS_LINUX 1 +# if defined __ANDROID__ +# define GTEST_OS_LINUX_ANDROID 1 +# endif +#elif defined __MVS__ +# define GTEST_OS_ZOS 1 +#elif defined(__sun) && defined(__SVR4) +# define GTEST_OS_SOLARIS 1 +#elif defined(_AIX) +# define GTEST_OS_AIX 1 +#elif defined(__hpux) +# define GTEST_OS_HPUX 1 +#elif defined __native_client__ +# define GTEST_OS_NACL 1 +#elif defined __OpenBSD__ +# define GTEST_OS_OPENBSD 1 +#elif defined __QNX__ +# define GTEST_OS_QNX 1 +#endif // __CYGWIN__ + +#ifndef GTEST_LANG_CXX11 +// gcc and clang define __GXX_EXPERIMENTAL_CXX0X__ when +// -std={c,gnu}++{0x,11} is passed. The C++11 standard specifies a +// value for __cplusplus, and recent versions of clang, gcc, and +// probably other compilers set that too in C++11 mode. +# if __GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L +// Compiling in at least C++11 mode. +# define GTEST_LANG_CXX11 1 +# else +# define GTEST_LANG_CXX11 0 +# endif +#endif + +// Brings in definitions for functions used in the testing::internal::posix +// namespace (read, write, close, chdir, isatty, stat). We do not currently +// use them on Windows Mobile. +#if !GTEST_OS_WINDOWS +// This assumes that non-Windows OSes provide unistd.h. For OSes where this +// is not the case, we need to include headers that provide the functions +// mentioned above. +# include +# include +#elif !GTEST_OS_WINDOWS_MOBILE +# include +# include +#endif + +#if GTEST_OS_LINUX_ANDROID +// Used to define __ANDROID_API__ matching the target NDK API level. +# include // NOLINT +#endif + +// Defines this to true iff Google Test can use POSIX regular expressions. +#ifndef GTEST_HAS_POSIX_RE +# if GTEST_OS_LINUX_ANDROID +// On Android, is only available starting with Gingerbread. +# define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9) +# else +# define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS) +# endif +#endif + +#if GTEST_HAS_POSIX_RE + +// On some platforms, needs someone to define size_t, and +// won't compile otherwise. We can #include it here as we already +// included , which is guaranteed to define size_t through +// . +# include // NOLINT + +# define GTEST_USES_POSIX_RE 1 + +#elif GTEST_OS_WINDOWS + +// is not available on Windows. Use our own simple regex +// implementation instead. +# define GTEST_USES_SIMPLE_RE 1 + +#else + +// may not be available on this platform. Use our own +// simple regex implementation instead. +# define GTEST_USES_SIMPLE_RE 1 + +#endif // GTEST_HAS_POSIX_RE + +#ifndef GTEST_HAS_EXCEPTIONS +// The user didn't tell us whether exceptions are enabled, so we need +// to figure it out. +# if defined(_MSC_VER) || defined(__BORLANDC__) +// MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS +// macro to enable exceptions, so we'll do the same. +// Assumes that exceptions are enabled by default. +# ifndef _HAS_EXCEPTIONS +# define _HAS_EXCEPTIONS 1 +# endif // _HAS_EXCEPTIONS +# define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS +# elif defined(__GNUC__) && __EXCEPTIONS +// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled. +# define GTEST_HAS_EXCEPTIONS 1 +# elif defined(__SUNPRO_CC) +// Sun Pro CC supports exceptions. However, there is no compile-time way of +// detecting whether they are enabled or not. Therefore, we assume that +// they are enabled unless the user tells us otherwise. +# define GTEST_HAS_EXCEPTIONS 1 +# elif defined(__IBMCPP__) && __EXCEPTIONS +// xlC defines __EXCEPTIONS to 1 iff exceptions are enabled. +# define GTEST_HAS_EXCEPTIONS 1 +# elif defined(__HP_aCC) +// Exception handling is in effect by default in HP aCC compiler. It has to +// be turned of by +noeh compiler option if desired. +# define GTEST_HAS_EXCEPTIONS 1 +# else +// For other compilers, we assume exceptions are disabled to be +// conservative. +# define GTEST_HAS_EXCEPTIONS 0 +# endif // defined(_MSC_VER) || defined(__BORLANDC__) +#endif // GTEST_HAS_EXCEPTIONS + +#if !defined(GTEST_HAS_STD_STRING) +// Even though we don't use this macro any longer, we keep it in case +// some clients still depend on it. +# define GTEST_HAS_STD_STRING 1 +#elif !GTEST_HAS_STD_STRING +// The user told us that ::std::string isn't available. +# error "Google Test cannot be used where ::std::string isn't available." +#endif // !defined(GTEST_HAS_STD_STRING) + +#ifndef GTEST_HAS_GLOBAL_STRING +// The user didn't tell us whether ::string is available, so we need +// to figure it out. + +# define GTEST_HAS_GLOBAL_STRING 0 + +#endif // GTEST_HAS_GLOBAL_STRING + +#ifndef GTEST_HAS_STD_WSTRING +// The user didn't tell us whether ::std::wstring is available, so we need +// to figure it out. +// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring +// is available. + +// Cygwin 1.7 and below doesn't support ::std::wstring. +// Solaris' libc++ doesn't support it either. Android has +// no support for it at least as recent as Froyo (2.2). +# define GTEST_HAS_STD_WSTRING \ + (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS)) + +#endif // GTEST_HAS_STD_WSTRING + +#ifndef GTEST_HAS_GLOBAL_WSTRING +// The user didn't tell us whether ::wstring is available, so we need +// to figure it out. +# define GTEST_HAS_GLOBAL_WSTRING \ + (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING) +#endif // GTEST_HAS_GLOBAL_WSTRING + +// Determines whether RTTI is available. +#ifndef GTEST_HAS_RTTI +// The user didn't tell us whether RTTI is enabled, so we need to +// figure it out. + +# ifdef _MSC_VER + +# ifdef _CPPRTTI // MSVC defines this macro iff RTTI is enabled. +# define GTEST_HAS_RTTI 1 +# else +# define GTEST_HAS_RTTI 0 +# endif + +// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled. +# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302) + +# ifdef __GXX_RTTI +// When building against STLport with the Android NDK and with +// -frtti -fno-exceptions, the build fails at link time with undefined +// references to __cxa_bad_typeid. Note sure if STL or toolchain bug, +// so disable RTTI when detected. +# if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \ + !defined(__EXCEPTIONS) +# define GTEST_HAS_RTTI 0 +# else +# define GTEST_HAS_RTTI 1 +# endif // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS +# else +# define GTEST_HAS_RTTI 0 +# endif // __GXX_RTTI + +// Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends +// using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the +// first version with C++ support. +# elif defined(__clang__) + +# define GTEST_HAS_RTTI __has_feature(cxx_rtti) + +// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if +// both the typeid and dynamic_cast features are present. +# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900) + +# ifdef __RTTI_ALL__ +# define GTEST_HAS_RTTI 1 +# else +# define GTEST_HAS_RTTI 0 +# endif + +# else + +// For all other compilers, we assume RTTI is enabled. +# define GTEST_HAS_RTTI 1 + +# endif // _MSC_VER + +#endif // GTEST_HAS_RTTI + +// It's this header's responsibility to #include when RTTI +// is enabled. +#if GTEST_HAS_RTTI +# include +#endif + +// Determines whether Google Test can use the pthreads library. +#ifndef GTEST_HAS_PTHREAD +// The user didn't tell us explicitly, so we assume pthreads support is +// available on Linux and Mac. +// +// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0 +// to your compiler flags. +# define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX \ + || GTEST_OS_QNX) +#endif // GTEST_HAS_PTHREAD + +#if GTEST_HAS_PTHREAD +// gtest-port.h guarantees to #include when GTEST_HAS_PTHREAD is +// true. +# include // NOLINT + +// For timespec and nanosleep, used below. +# include // NOLINT +#endif + +// Determines whether Google Test can use tr1/tuple. You can define +// this macro to 0 to prevent Google Test from using tuple (any +// feature depending on tuple with be disabled in this mode). +#ifndef GTEST_HAS_TR1_TUPLE +# if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) +// STLport, provided with the Android NDK, has neither or . +# define GTEST_HAS_TR1_TUPLE 0 +# else +// The user didn't tell us not to do it, so we assume it's OK. +# define GTEST_HAS_TR1_TUPLE 1 +# endif +#endif // GTEST_HAS_TR1_TUPLE + +// Determines whether Google Test's own tr1 tuple implementation +// should be used. +#ifndef GTEST_USE_OWN_TR1_TUPLE +// The user didn't tell us, so we need to figure it out. + +// We use our own TR1 tuple if we aren't sure the user has an +// implementation of it already. At this time, libstdc++ 4.0.0+ and +// MSVC 2010 are the only mainstream standard libraries that come +// with a TR1 tuple implementation. NVIDIA's CUDA NVCC compiler +// pretends to be GCC by defining __GNUC__ and friends, but cannot +// compile GCC's tuple implementation. MSVC 2008 (9.0) provides TR1 +// tuple in a 323 MB Feature Pack download, which we cannot assume the +// user has. QNX's QCC compiler is a modified GCC but it doesn't +// support TR1 tuple. libc++ only provides std::tuple, in C++11 mode, +// and it can be used with some compilers that define __GNUC__. +# if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000) \ + && !GTEST_OS_QNX && !defined(_LIBCPP_VERSION)) || _MSC_VER >= 1600 +# define GTEST_ENV_HAS_TR1_TUPLE_ 1 +# endif + +// C++11 specifies that provides std::tuple. Use that if gtest is used +// in C++11 mode and libstdc++ isn't very old (binaries targeting OS X 10.6 +// can build with clang but need to use gcc4.2's libstdc++). +# if GTEST_LANG_CXX11 && (!defined(__GLIBCXX__) || __GLIBCXX__ > 20110325) +# define GTEST_ENV_HAS_STD_TUPLE_ 1 +# endif + +# if GTEST_ENV_HAS_TR1_TUPLE_ || GTEST_ENV_HAS_STD_TUPLE_ +# define GTEST_USE_OWN_TR1_TUPLE 0 +# else +# define GTEST_USE_OWN_TR1_TUPLE 1 +# endif + +#endif // GTEST_USE_OWN_TR1_TUPLE + +// To avoid conditional compilation everywhere, we make it +// gtest-port.h's responsibility to #include the header implementing +// tr1/tuple. +#if GTEST_HAS_TR1_TUPLE + +# if GTEST_USE_OWN_TR1_TUPLE +// This file was GENERATED by command: +// pump.py gtest-tuple.h.pump +// DO NOT EDIT BY HAND!!! + +// Copyright 2009 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) + +// Implements a subset of TR1 tuple needed by Google Test and Google Mock. + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ + +#include // For ::std::pair. + +// The compiler used in Symbian has a bug that prevents us from declaring the +// tuple template as a friend (it complains that tuple is redefined). This +// hack bypasses the bug by declaring the members that should otherwise be +// private as public. +// Sun Studio versions < 12 also have the above bug. +#if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590) +# define GTEST_DECLARE_TUPLE_AS_FRIEND_ public: +#else +# define GTEST_DECLARE_TUPLE_AS_FRIEND_ \ + template friend class tuple; \ + private: +#endif + +// GTEST_n_TUPLE_(T) is the type of an n-tuple. +#define GTEST_0_TUPLE_(T) tuple<> +#define GTEST_1_TUPLE_(T) tuple +#define GTEST_2_TUPLE_(T) tuple +#define GTEST_3_TUPLE_(T) tuple +#define GTEST_4_TUPLE_(T) tuple +#define GTEST_5_TUPLE_(T) tuple +#define GTEST_6_TUPLE_(T) tuple +#define GTEST_7_TUPLE_(T) tuple +#define GTEST_8_TUPLE_(T) tuple +#define GTEST_9_TUPLE_(T) tuple +#define GTEST_10_TUPLE_(T) tuple + +// GTEST_n_TYPENAMES_(T) declares a list of n typenames. +#define GTEST_0_TYPENAMES_(T) +#define GTEST_1_TYPENAMES_(T) typename T##0 +#define GTEST_2_TYPENAMES_(T) typename T##0, typename T##1 +#define GTEST_3_TYPENAMES_(T) typename T##0, typename T##1, typename T##2 +#define GTEST_4_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ + typename T##3 +#define GTEST_5_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ + typename T##3, typename T##4 +#define GTEST_6_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ + typename T##3, typename T##4, typename T##5 +#define GTEST_7_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ + typename T##3, typename T##4, typename T##5, typename T##6 +#define GTEST_8_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ + typename T##3, typename T##4, typename T##5, typename T##6, typename T##7 +#define GTEST_9_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ + typename T##3, typename T##4, typename T##5, typename T##6, \ + typename T##7, typename T##8 +#define GTEST_10_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ + typename T##3, typename T##4, typename T##5, typename T##6, \ + typename T##7, typename T##8, typename T##9 + +// In theory, defining stuff in the ::std namespace is undefined +// behavior. We can do this as we are playing the role of a standard +// library vendor. +namespace std { +namespace tr1 { + +template +class tuple; + +// Anything in namespace gtest_internal is Google Test's INTERNAL +// IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code. +namespace gtest_internal { + +// ByRef::type is T if T is a reference; otherwise it's const T&. +template +struct ByRef { typedef const T& type; }; // NOLINT +template +struct ByRef { typedef T& type; }; // NOLINT + +// A handy wrapper for ByRef. +#define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef::type + +// AddRef::type is T if T is a reference; otherwise it's T&. This +// is the same as tr1::add_reference::type. +template +struct AddRef { typedef T& type; }; // NOLINT +template +struct AddRef { typedef T& type; }; // NOLINT + +// A handy wrapper for AddRef. +#define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef::type + +// A helper for implementing get(). +template class Get; + +// A helper for implementing tuple_element. kIndexValid is true +// iff k < the number of fields in tuple type T. +template +struct TupleElement; + +template +struct TupleElement { + typedef T0 type; +}; + +template +struct TupleElement { + typedef T1 type; +}; + +template +struct TupleElement { + typedef T2 type; +}; + +template +struct TupleElement { + typedef T3 type; +}; + +template +struct TupleElement { + typedef T4 type; +}; + +template +struct TupleElement { + typedef T5 type; +}; + +template +struct TupleElement { + typedef T6 type; +}; + +template +struct TupleElement { + typedef T7 type; +}; + +template +struct TupleElement { + typedef T8 type; +}; + +template +struct TupleElement { + typedef T9 type; +}; + +} // namespace gtest_internal + +template <> +class tuple<> { + public: + tuple() {} + tuple(const tuple& /* t */) {} + tuple& operator=(const tuple& /* t */) { return *this; } +}; + +template +class GTEST_1_TUPLE_(T) { + public: + template friend class gtest_internal::Get; + + tuple() : f0_() {} + + explicit tuple(GTEST_BY_REF_(T0) f0) : f0_(f0) {} + + tuple(const tuple& t) : f0_(t.f0_) {} + + template + tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {} + + tuple& operator=(const tuple& t) { return CopyFrom(t); } + + template + tuple& operator=(const GTEST_1_TUPLE_(U)& t) { + return CopyFrom(t); + } + + GTEST_DECLARE_TUPLE_AS_FRIEND_ + + template + tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) { + f0_ = t.f0_; + return *this; + } + + T0 f0_; +}; + +template +class GTEST_2_TUPLE_(T) { + public: + template friend class gtest_internal::Get; + + tuple() : f0_(), f1_() {} + + explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1) : f0_(f0), + f1_(f1) {} + + tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_) {} + + template + tuple(const GTEST_2_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_) {} + template + tuple(const ::std::pair& p) : f0_(p.first), f1_(p.second) {} + + tuple& operator=(const tuple& t) { return CopyFrom(t); } + + template + tuple& operator=(const GTEST_2_TUPLE_(U)& t) { + return CopyFrom(t); + } + template + tuple& operator=(const ::std::pair& p) { + f0_ = p.first; + f1_ = p.second; + return *this; + } + + GTEST_DECLARE_TUPLE_AS_FRIEND_ + + template + tuple& CopyFrom(const GTEST_2_TUPLE_(U)& t) { + f0_ = t.f0_; + f1_ = t.f1_; + return *this; + } + + T0 f0_; + T1 f1_; +}; + +template +class GTEST_3_TUPLE_(T) { + public: + template friend class gtest_internal::Get; + + tuple() : f0_(), f1_(), f2_() {} + + explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, + GTEST_BY_REF_(T2) f2) : f0_(f0), f1_(f1), f2_(f2) {} + + tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {} + + template + tuple(const GTEST_3_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {} + + tuple& operator=(const tuple& t) { return CopyFrom(t); } + + template + tuple& operator=(const GTEST_3_TUPLE_(U)& t) { + return CopyFrom(t); + } + + GTEST_DECLARE_TUPLE_AS_FRIEND_ + + template + tuple& CopyFrom(const GTEST_3_TUPLE_(U)& t) { + f0_ = t.f0_; + f1_ = t.f1_; + f2_ = t.f2_; + return *this; + } + + T0 f0_; + T1 f1_; + T2 f2_; +}; + +template +class GTEST_4_TUPLE_(T) { + public: + template friend class gtest_internal::Get; + + tuple() : f0_(), f1_(), f2_(), f3_() {} + + explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, + GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3) : f0_(f0), f1_(f1), f2_(f2), + f3_(f3) {} + + tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_) {} + + template + tuple(const GTEST_4_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), + f3_(t.f3_) {} + + tuple& operator=(const tuple& t) { return CopyFrom(t); } + + template + tuple& operator=(const GTEST_4_TUPLE_(U)& t) { + return CopyFrom(t); + } + + GTEST_DECLARE_TUPLE_AS_FRIEND_ + + template + tuple& CopyFrom(const GTEST_4_TUPLE_(U)& t) { + f0_ = t.f0_; + f1_ = t.f1_; + f2_ = t.f2_; + f3_ = t.f3_; + return *this; + } + + T0 f0_; + T1 f1_; + T2 f2_; + T3 f3_; +}; + +template +class GTEST_5_TUPLE_(T) { + public: + template friend class gtest_internal::Get; + + tuple() : f0_(), f1_(), f2_(), f3_(), f4_() {} + + explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, + GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, + GTEST_BY_REF_(T4) f4) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4) {} + + tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), + f4_(t.f4_) {} + + template + tuple(const GTEST_5_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), + f3_(t.f3_), f4_(t.f4_) {} + + tuple& operator=(const tuple& t) { return CopyFrom(t); } + + template + tuple& operator=(const GTEST_5_TUPLE_(U)& t) { + return CopyFrom(t); + } + + GTEST_DECLARE_TUPLE_AS_FRIEND_ + + template + tuple& CopyFrom(const GTEST_5_TUPLE_(U)& t) { + f0_ = t.f0_; + f1_ = t.f1_; + f2_ = t.f2_; + f3_ = t.f3_; + f4_ = t.f4_; + return *this; + } + + T0 f0_; + T1 f1_; + T2 f2_; + T3 f3_; + T4 f4_; +}; + +template +class GTEST_6_TUPLE_(T) { + public: + template friend class gtest_internal::Get; + + tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_() {} + + explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, + GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, + GTEST_BY_REF_(T5) f5) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4), + f5_(f5) {} + + tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), + f4_(t.f4_), f5_(t.f5_) {} + + template + tuple(const GTEST_6_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), + f3_(t.f3_), f4_(t.f4_), f5_(t.f5_) {} + + tuple& operator=(const tuple& t) { return CopyFrom(t); } + + template + tuple& operator=(const GTEST_6_TUPLE_(U)& t) { + return CopyFrom(t); + } + + GTEST_DECLARE_TUPLE_AS_FRIEND_ + + template + tuple& CopyFrom(const GTEST_6_TUPLE_(U)& t) { + f0_ = t.f0_; + f1_ = t.f1_; + f2_ = t.f2_; + f3_ = t.f3_; + f4_ = t.f4_; + f5_ = t.f5_; + return *this; + } + + T0 f0_; + T1 f1_; + T2 f2_; + T3 f3_; + T4 f4_; + T5 f5_; +}; + +template +class GTEST_7_TUPLE_(T) { + public: + template friend class gtest_internal::Get; + + tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_() {} + + explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, + GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, + GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6) : f0_(f0), f1_(f1), f2_(f2), + f3_(f3), f4_(f4), f5_(f5), f6_(f6) {} + + tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), + f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {} + + template + tuple(const GTEST_7_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), + f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {} + + tuple& operator=(const tuple& t) { return CopyFrom(t); } + + template + tuple& operator=(const GTEST_7_TUPLE_(U)& t) { + return CopyFrom(t); + } + + GTEST_DECLARE_TUPLE_AS_FRIEND_ + + template + tuple& CopyFrom(const GTEST_7_TUPLE_(U)& t) { + f0_ = t.f0_; + f1_ = t.f1_; + f2_ = t.f2_; + f3_ = t.f3_; + f4_ = t.f4_; + f5_ = t.f5_; + f6_ = t.f6_; + return *this; + } + + T0 f0_; + T1 f1_; + T2 f2_; + T3 f3_; + T4 f4_; + T5 f5_; + T6 f6_; +}; + +template +class GTEST_8_TUPLE_(T) { + public: + template friend class gtest_internal::Get; + + tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_() {} + + explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, + GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, + GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, + GTEST_BY_REF_(T7) f7) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4), + f5_(f5), f6_(f6), f7_(f7) {} + + tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), + f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {} + + template + tuple(const GTEST_8_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), + f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {} + + tuple& operator=(const tuple& t) { return CopyFrom(t); } + + template + tuple& operator=(const GTEST_8_TUPLE_(U)& t) { + return CopyFrom(t); + } + + GTEST_DECLARE_TUPLE_AS_FRIEND_ + + template + tuple& CopyFrom(const GTEST_8_TUPLE_(U)& t) { + f0_ = t.f0_; + f1_ = t.f1_; + f2_ = t.f2_; + f3_ = t.f3_; + f4_ = t.f4_; + f5_ = t.f5_; + f6_ = t.f6_; + f7_ = t.f7_; + return *this; + } + + T0 f0_; + T1 f1_; + T2 f2_; + T3 f3_; + T4 f4_; + T5 f5_; + T6 f6_; + T7 f7_; +}; + +template +class GTEST_9_TUPLE_(T) { + public: + template friend class gtest_internal::Get; + + tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_() {} + + explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, + GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, + GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7, + GTEST_BY_REF_(T8) f8) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4), + f5_(f5), f6_(f6), f7_(f7), f8_(f8) {} + + tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), + f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {} + + template + tuple(const GTEST_9_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), + f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {} + + tuple& operator=(const tuple& t) { return CopyFrom(t); } + + template + tuple& operator=(const GTEST_9_TUPLE_(U)& t) { + return CopyFrom(t); + } + + GTEST_DECLARE_TUPLE_AS_FRIEND_ + + template + tuple& CopyFrom(const GTEST_9_TUPLE_(U)& t) { + f0_ = t.f0_; + f1_ = t.f1_; + f2_ = t.f2_; + f3_ = t.f3_; + f4_ = t.f4_; + f5_ = t.f5_; + f6_ = t.f6_; + f7_ = t.f7_; + f8_ = t.f8_; + return *this; + } + + T0 f0_; + T1 f1_; + T2 f2_; + T3 f3_; + T4 f4_; + T5 f5_; + T6 f6_; + T7 f7_; + T8 f8_; +}; + +template +class tuple { + public: + template friend class gtest_internal::Get; + + tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_(), + f9_() {} + + explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, + GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, + GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7, + GTEST_BY_REF_(T8) f8, GTEST_BY_REF_(T9) f9) : f0_(f0), f1_(f1), f2_(f2), + f3_(f3), f4_(f4), f5_(f5), f6_(f6), f7_(f7), f8_(f8), f9_(f9) {} + + tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), + f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), f9_(t.f9_) {} + + template + tuple(const GTEST_10_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), + f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), + f9_(t.f9_) {} + + tuple& operator=(const tuple& t) { return CopyFrom(t); } + + template + tuple& operator=(const GTEST_10_TUPLE_(U)& t) { + return CopyFrom(t); + } + + GTEST_DECLARE_TUPLE_AS_FRIEND_ + + template + tuple& CopyFrom(const GTEST_10_TUPLE_(U)& t) { + f0_ = t.f0_; + f1_ = t.f1_; + f2_ = t.f2_; + f3_ = t.f3_; + f4_ = t.f4_; + f5_ = t.f5_; + f6_ = t.f6_; + f7_ = t.f7_; + f8_ = t.f8_; + f9_ = t.f9_; + return *this; + } + + T0 f0_; + T1 f1_; + T2 f2_; + T3 f3_; + T4 f4_; + T5 f5_; + T6 f6_; + T7 f7_; + T8 f8_; + T9 f9_; +}; + +// 6.1.3.2 Tuple creation functions. + +// Known limitations: we don't support passing an +// std::tr1::reference_wrapper to make_tuple(). And we don't +// implement tie(). + +inline tuple<> make_tuple() { return tuple<>(); } + +template +inline GTEST_1_TUPLE_(T) make_tuple(const T0& f0) { + return GTEST_1_TUPLE_(T)(f0); +} + +template +inline GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) { + return GTEST_2_TUPLE_(T)(f0, f1); +} + +template +inline GTEST_3_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2) { + return GTEST_3_TUPLE_(T)(f0, f1, f2); +} + +template +inline GTEST_4_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, + const T3& f3) { + return GTEST_4_TUPLE_(T)(f0, f1, f2, f3); +} + +template +inline GTEST_5_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, + const T3& f3, const T4& f4) { + return GTEST_5_TUPLE_(T)(f0, f1, f2, f3, f4); +} + +template +inline GTEST_6_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, + const T3& f3, const T4& f4, const T5& f5) { + return GTEST_6_TUPLE_(T)(f0, f1, f2, f3, f4, f5); +} + +template +inline GTEST_7_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, + const T3& f3, const T4& f4, const T5& f5, const T6& f6) { + return GTEST_7_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6); +} + +template +inline GTEST_8_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, + const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7) { + return GTEST_8_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7); +} + +template +inline GTEST_9_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, + const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7, + const T8& f8) { + return GTEST_9_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8); +} + +template +inline GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, + const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7, + const T8& f8, const T9& f9) { + return GTEST_10_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9); +} + +// 6.1.3.3 Tuple helper classes. + +template struct tuple_size; + +template +struct tuple_size { + static const int value = 0; +}; + +template +struct tuple_size { + static const int value = 1; +}; + +template +struct tuple_size { + static const int value = 2; +}; + +template +struct tuple_size { + static const int value = 3; +}; + +template +struct tuple_size { + static const int value = 4; +}; + +template +struct tuple_size { + static const int value = 5; +}; + +template +struct tuple_size { + static const int value = 6; +}; + +template +struct tuple_size { + static const int value = 7; +}; + +template +struct tuple_size { + static const int value = 8; +}; + +template +struct tuple_size { + static const int value = 9; +}; + +template +struct tuple_size { + static const int value = 10; +}; + +template +struct tuple_element { + typedef typename gtest_internal::TupleElement< + k < (tuple_size::value), k, Tuple>::type type; +}; + +#define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element::type + +// 6.1.3.4 Element access. + +namespace gtest_internal { + +template <> +class Get<0> { + public: + template + static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple)) + Field(Tuple& t) { return t.f0_; } // NOLINT + + template + static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple)) + ConstField(const Tuple& t) { return t.f0_; } +}; + +template <> +class Get<1> { + public: + template + static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple)) + Field(Tuple& t) { return t.f1_; } // NOLINT + + template + static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple)) + ConstField(const Tuple& t) { return t.f1_; } +}; + +template <> +class Get<2> { + public: + template + static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple)) + Field(Tuple& t) { return t.f2_; } // NOLINT + + template + static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple)) + ConstField(const Tuple& t) { return t.f2_; } +}; + +template <> +class Get<3> { + public: + template + static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple)) + Field(Tuple& t) { return t.f3_; } // NOLINT + + template + static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple)) + ConstField(const Tuple& t) { return t.f3_; } +}; + +template <> +class Get<4> { + public: + template + static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple)) + Field(Tuple& t) { return t.f4_; } // NOLINT + + template + static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple)) + ConstField(const Tuple& t) { return t.f4_; } +}; + +template <> +class Get<5> { + public: + template + static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple)) + Field(Tuple& t) { return t.f5_; } // NOLINT + + template + static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple)) + ConstField(const Tuple& t) { return t.f5_; } +}; + +template <> +class Get<6> { + public: + template + static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple)) + Field(Tuple& t) { return t.f6_; } // NOLINT + + template + static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple)) + ConstField(const Tuple& t) { return t.f6_; } +}; + +template <> +class Get<7> { + public: + template + static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple)) + Field(Tuple& t) { return t.f7_; } // NOLINT + + template + static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple)) + ConstField(const Tuple& t) { return t.f7_; } +}; + +template <> +class Get<8> { + public: + template + static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple)) + Field(Tuple& t) { return t.f8_; } // NOLINT + + template + static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple)) + ConstField(const Tuple& t) { return t.f8_; } +}; + +template <> +class Get<9> { + public: + template + static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple)) + Field(Tuple& t) { return t.f9_; } // NOLINT + + template + static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple)) + ConstField(const Tuple& t) { return t.f9_; } +}; + +} // namespace gtest_internal + +template +GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T))) +get(GTEST_10_TUPLE_(T)& t) { + return gtest_internal::Get::Field(t); +} + +template +GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T))) +get(const GTEST_10_TUPLE_(T)& t) { + return gtest_internal::Get::ConstField(t); +} + +// 6.1.3.5 Relational operators + +// We only implement == and !=, as we don't have a need for the rest yet. + +namespace gtest_internal { + +// SameSizeTuplePrefixComparator::Eq(t1, t2) returns true if the +// first k fields of t1 equals the first k fields of t2. +// SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if +// k1 != k2. +template +struct SameSizeTuplePrefixComparator; + +template <> +struct SameSizeTuplePrefixComparator<0, 0> { + template + static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) { + return true; + } +}; + +template +struct SameSizeTuplePrefixComparator { + template + static bool Eq(const Tuple1& t1, const Tuple2& t2) { + return SameSizeTuplePrefixComparator::Eq(t1, t2) && + ::std::tr1::get(t1) == ::std::tr1::get(t2); + } +}; + +} // namespace gtest_internal + +template +inline bool operator==(const GTEST_10_TUPLE_(T)& t, + const GTEST_10_TUPLE_(U)& u) { + return gtest_internal::SameSizeTuplePrefixComparator< + tuple_size::value, + tuple_size::value>::Eq(t, u); +} + +template +inline bool operator!=(const GTEST_10_TUPLE_(T)& t, + const GTEST_10_TUPLE_(U)& u) { return !(t == u); } + +// 6.1.4 Pairs. +// Unimplemented. + +} // namespace tr1 +} // namespace std + +#undef GTEST_0_TUPLE_ +#undef GTEST_1_TUPLE_ +#undef GTEST_2_TUPLE_ +#undef GTEST_3_TUPLE_ +#undef GTEST_4_TUPLE_ +#undef GTEST_5_TUPLE_ +#undef GTEST_6_TUPLE_ +#undef GTEST_7_TUPLE_ +#undef GTEST_8_TUPLE_ +#undef GTEST_9_TUPLE_ +#undef GTEST_10_TUPLE_ + +#undef GTEST_0_TYPENAMES_ +#undef GTEST_1_TYPENAMES_ +#undef GTEST_2_TYPENAMES_ +#undef GTEST_3_TYPENAMES_ +#undef GTEST_4_TYPENAMES_ +#undef GTEST_5_TYPENAMES_ +#undef GTEST_6_TYPENAMES_ +#undef GTEST_7_TYPENAMES_ +#undef GTEST_8_TYPENAMES_ +#undef GTEST_9_TYPENAMES_ +#undef GTEST_10_TYPENAMES_ + +#undef GTEST_DECLARE_TUPLE_AS_FRIEND_ +#undef GTEST_BY_REF_ +#undef GTEST_ADD_REF_ +#undef GTEST_TUPLE_ELEMENT_ + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ +# elif GTEST_ENV_HAS_STD_TUPLE_ +# include +// C++11 puts its tuple into the ::std namespace rather than +// ::std::tr1. gtest expects tuple to live in ::std::tr1, so put it there. +// This causes undefined behavior, but supported compilers react in +// the way we intend. +namespace std { +namespace tr1 { +using ::std::get; +using ::std::make_tuple; +using ::std::tuple; +using ::std::tuple_element; +using ::std::tuple_size; +} +} + +# elif GTEST_OS_SYMBIAN + +// On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to +// use STLport's tuple implementation, which unfortunately doesn't +// work as the copy of STLport distributed with Symbian is incomplete. +// By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to +// use its own tuple implementation. +# ifdef BOOST_HAS_TR1_TUPLE +# undef BOOST_HAS_TR1_TUPLE +# endif // BOOST_HAS_TR1_TUPLE + +// This prevents , which defines +// BOOST_HAS_TR1_TUPLE, from being #included by Boost's . +# define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED +# include + +# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000) +// GCC 4.0+ implements tr1/tuple in the header. This does +// not conform to the TR1 spec, which requires the header to be . + +# if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 +// Until version 4.3.2, gcc has a bug that causes , +// which is #included by , to not compile when RTTI is +// disabled. _TR1_FUNCTIONAL is the header guard for +// . Hence the following #define is a hack to prevent +// from being included. +# define _TR1_FUNCTIONAL 1 +# include +# undef _TR1_FUNCTIONAL // Allows the user to #include + // if he chooses to. +# else +# include // NOLINT +# endif // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 + +# else +// If the compiler is not GCC 4.0+, we assume the user is using a +// spec-conforming TR1 implementation. +# include // NOLINT +# endif // GTEST_USE_OWN_TR1_TUPLE + +#endif // GTEST_HAS_TR1_TUPLE + +// Determines whether clone(2) is supported. +// Usually it will only be available on Linux, excluding +// Linux on the Itanium architecture. +// Also see http://linux.die.net/man/2/clone. +#ifndef GTEST_HAS_CLONE +// The user didn't tell us, so we need to figure it out. + +# if GTEST_OS_LINUX && !defined(__ia64__) +# if GTEST_OS_LINUX_ANDROID +// On Android, clone() is only available on ARM starting with Gingerbread. +# if defined(__arm__) && __ANDROID_API__ >= 9 +# define GTEST_HAS_CLONE 1 +# else +# define GTEST_HAS_CLONE 0 +# endif +# else +# define GTEST_HAS_CLONE 1 +# endif +# else +# define GTEST_HAS_CLONE 0 +# endif // GTEST_OS_LINUX && !defined(__ia64__) + +#endif // GTEST_HAS_CLONE + +// Determines whether to support stream redirection. This is used to test +// output correctness and to implement death tests. +#ifndef GTEST_HAS_STREAM_REDIRECTION +// By default, we assume that stream redirection is supported on all +// platforms except known mobile ones. +# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN +# define GTEST_HAS_STREAM_REDIRECTION 0 +# else +# define GTEST_HAS_STREAM_REDIRECTION 1 +# endif // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN +#endif // GTEST_HAS_STREAM_REDIRECTION + +// Determines whether to support death tests. +// Google Test does not support death tests for VC 7.1 and earlier as +// abort() in a VC 7.1 application compiled as GUI in debug config +// pops up a dialog window that cannot be suppressed programmatically. +#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \ + (GTEST_OS_MAC && !GTEST_OS_IOS) || GTEST_OS_IOS_SIMULATOR || \ + (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \ + GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX || \ + GTEST_OS_OPENBSD || GTEST_OS_QNX) +# define GTEST_HAS_DEATH_TEST 1 +# include // NOLINT +#endif + +// We don't support MSVC 7.1 with exceptions disabled now. Therefore +// all the compilers we care about are adequate for supporting +// value-parameterized tests. +#define GTEST_HAS_PARAM_TEST 1 + +// Determines whether to support type-driven tests. + +// Typed tests need and variadic macros, which GCC, VC++ 8.0, +// Sun Pro CC, IBM Visual Age, and HP aCC support. +#if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \ + defined(__IBMCPP__) || defined(__HP_aCC) +# define GTEST_HAS_TYPED_TEST 1 +# define GTEST_HAS_TYPED_TEST_P 1 +#endif + +// Determines whether to support Combine(). This only makes sense when +// value-parameterized tests are enabled. The implementation doesn't +// work on Sun Studio since it doesn't understand templated conversion +// operators. +#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE && !defined(__SUNPRO_CC) +# define GTEST_HAS_COMBINE 1 +#endif + +// Determines whether the system compiler uses UTF-16 for encoding wide strings. +#define GTEST_WIDE_STRING_USES_UTF16_ \ + (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN || GTEST_OS_AIX) + +// Determines whether test results can be streamed to a socket. +#if GTEST_OS_LINUX +# define GTEST_CAN_STREAM_RESULTS_ 1 +#endif + +// Defines some utility macros. + +// The GNU compiler emits a warning if nested "if" statements are followed by +// an "else" statement and braces are not used to explicitly disambiguate the +// "else" binding. This leads to problems with code like: +// +// if (gate) +// ASSERT_*(condition) << "Some message"; +// +// The "switch (0) case 0:" idiom is used to suppress this. +#ifdef __INTEL_COMPILER +# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ +#else +# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default: // NOLINT +#endif + +// Use this annotation at the end of a struct/class definition to +// prevent the compiler from optimizing away instances that are never +// used. This is useful when all interesting logic happens inside the +// c'tor and / or d'tor. Example: +// +// struct Foo { +// Foo() { ... } +// } GTEST_ATTRIBUTE_UNUSED_; +// +// Also use it after a variable or parameter declaration to tell the +// compiler the variable/parameter does not have to be used. +#if defined(__GNUC__) && !defined(COMPILER_ICC) +# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused)) +#else +# define GTEST_ATTRIBUTE_UNUSED_ +#endif + +// A macro to disallow operator= +// This should be used in the private: declarations for a class. +#define GTEST_DISALLOW_ASSIGN_(type)\ + void operator=(type const &) + +// A macro to disallow copy constructor and operator= +// This should be used in the private: declarations for a class. +#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\ + type(type const &);\ + GTEST_DISALLOW_ASSIGN_(type) + +// Tell the compiler to warn about unused return values for functions declared +// with this macro. The macro should be used on function declarations +// following the argument list: +// +// Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_; +#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC) +# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result)) +#else +# define GTEST_MUST_USE_RESULT_ +#endif // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC + +// Determine whether the compiler supports Microsoft's Structured Exception +// Handling. This is supported by several Windows compilers but generally +// does not exist on any other system. +#ifndef GTEST_HAS_SEH +// The user didn't tell us, so we need to figure it out. + +# if defined(_MSC_VER) || defined(__BORLANDC__) +// These two compilers are known to support SEH. +# define GTEST_HAS_SEH 1 +# else +// Assume no SEH. +# define GTEST_HAS_SEH 0 +# endif + +#endif // GTEST_HAS_SEH + +#ifdef _MSC_VER + +# if GTEST_LINKED_AS_SHARED_LIBRARY +# define GTEST_API_ __declspec(dllimport) +# elif GTEST_CREATE_SHARED_LIBRARY +# define GTEST_API_ __declspec(dllexport) +# endif + +#endif // _MSC_VER + +#ifndef GTEST_API_ +# define GTEST_API_ +#endif + +#ifdef __GNUC__ +// Ask the compiler to never inline a given function. +# define GTEST_NO_INLINE_ __attribute__((noinline)) +#else +# define GTEST_NO_INLINE_ +#endif + +// _LIBCPP_VERSION is defined by the libc++ library from the LLVM project. +#if defined(__GLIBCXX__) || defined(_LIBCPP_VERSION) +# define GTEST_HAS_CXXABI_H_ 1 +#else +# define GTEST_HAS_CXXABI_H_ 0 +#endif + +namespace testing { + +class Message; + +namespace internal { + +// A secret type that Google Test users don't know about. It has no +// definition on purpose. Therefore it's impossible to create a +// Secret object, which is what we want. +class Secret; + +// The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile time +// expression is true. For example, you could use it to verify the +// size of a static array: +// +// GTEST_COMPILE_ASSERT_(ARRAYSIZE(content_type_names) == CONTENT_NUM_TYPES, +// content_type_names_incorrect_size); +// +// or to make sure a struct is smaller than a certain size: +// +// GTEST_COMPILE_ASSERT_(sizeof(foo) < 128, foo_too_large); +// +// The second argument to the macro is the name of the variable. If +// the expression is false, most compilers will issue a warning/error +// containing the name of the variable. + +template +struct CompileAssert { +}; + +#define GTEST_COMPILE_ASSERT_(expr, msg) \ + typedef ::testing::internal::CompileAssert<(static_cast(expr))> \ + msg[static_cast(expr) ? 1 : -1] GTEST_ATTRIBUTE_UNUSED_ + +// Implementation details of GTEST_COMPILE_ASSERT_: +// +// - GTEST_COMPILE_ASSERT_ works by defining an array type that has -1 +// elements (and thus is invalid) when the expression is false. +// +// - The simpler definition +// +// #define GTEST_COMPILE_ASSERT_(expr, msg) typedef char msg[(expr) ? 1 : -1] +// +// does not work, as gcc supports variable-length arrays whose sizes +// are determined at run-time (this is gcc's extension and not part +// of the C++ standard). As a result, gcc fails to reject the +// following code with the simple definition: +// +// int foo; +// GTEST_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo is +// // not a compile-time constant. +// +// - By using the type CompileAssert<(bool(expr))>, we ensures that +// expr is a compile-time constant. (Template arguments must be +// determined at compile-time.) +// +// - The outter parentheses in CompileAssert<(bool(expr))> are necessary +// to work around a bug in gcc 3.4.4 and 4.0.1. If we had written +// +// CompileAssert +// +// instead, these compilers will refuse to compile +// +// GTEST_COMPILE_ASSERT_(5 > 0, some_message); +// +// (They seem to think the ">" in "5 > 0" marks the end of the +// template argument list.) +// +// - The array size is (bool(expr) ? 1 : -1), instead of simply +// +// ((expr) ? 1 : -1). +// +// This is to avoid running into a bug in MS VC 7.1, which +// causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1. + +// StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in gtest.h. +// +// This template is declared, but intentionally undefined. +template +struct StaticAssertTypeEqHelper; + +template +struct StaticAssertTypeEqHelper {}; + +#if GTEST_HAS_GLOBAL_STRING +typedef ::string string; +#else +typedef ::std::string string; +#endif // GTEST_HAS_GLOBAL_STRING + +#if GTEST_HAS_GLOBAL_WSTRING +typedef ::wstring wstring; +#elif GTEST_HAS_STD_WSTRING +typedef ::std::wstring wstring; +#endif // GTEST_HAS_GLOBAL_WSTRING + +// A helper for suppressing warnings on constant condition. It just +// returns 'condition'. +GTEST_API_ bool IsTrue(bool condition); + +// Defines scoped_ptr. + +// This implementation of scoped_ptr is PARTIAL - it only contains +// enough stuff to satisfy Google Test's need. +template +class scoped_ptr { + public: + typedef T element_type; + + explicit scoped_ptr(T* p = NULL) : ptr_(p) {} + ~scoped_ptr() { reset(); } + + T& operator*() const { return *ptr_; } + T* operator->() const { return ptr_; } + T* get() const { return ptr_; } + + T* release() { + T* const ptr = ptr_; + ptr_ = NULL; + return ptr; + } + + void reset(T* p = NULL) { + if (p != ptr_) { + if (IsTrue(sizeof(T) > 0)) { // Makes sure T is a complete type. + delete ptr_; + } + ptr_ = p; + } + } + + private: + T* ptr_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr); +}; + +// Defines RE. + +// A simple C++ wrapper for . It uses the POSIX Extended +// Regular Expression syntax. +class GTEST_API_ RE { + public: + // A copy constructor is required by the Standard to initialize object + // references from r-values. + RE(const RE& other) { Init(other.pattern()); } + + // Constructs an RE from a string. + RE(const ::std::string& regex) { Init(regex.c_str()); } // NOLINT + +#if GTEST_HAS_GLOBAL_STRING + + RE(const ::string& regex) { Init(regex.c_str()); } // NOLINT + +#endif // GTEST_HAS_GLOBAL_STRING + + RE(const char* regex) { Init(regex); } // NOLINT + ~RE(); + + // Returns the string representation of the regex. + const char* pattern() const { return pattern_; } + + // FullMatch(str, re) returns true iff regular expression re matches + // the entire str. + // PartialMatch(str, re) returns true iff regular expression re + // matches a substring of str (including str itself). + // + // TODO(wan@google.com): make FullMatch() and PartialMatch() work + // when str contains NUL characters. + static bool FullMatch(const ::std::string& str, const RE& re) { + return FullMatch(str.c_str(), re); + } + static bool PartialMatch(const ::std::string& str, const RE& re) { + return PartialMatch(str.c_str(), re); + } + +#if GTEST_HAS_GLOBAL_STRING + + static bool FullMatch(const ::string& str, const RE& re) { + return FullMatch(str.c_str(), re); + } + static bool PartialMatch(const ::string& str, const RE& re) { + return PartialMatch(str.c_str(), re); + } + +#endif // GTEST_HAS_GLOBAL_STRING + + static bool FullMatch(const char* str, const RE& re); + static bool PartialMatch(const char* str, const RE& re); + + private: + void Init(const char* regex); + + // We use a const char* instead of an std::string, as Google Test used to be + // used where std::string is not available. TODO(wan@google.com): change to + // std::string. + const char* pattern_; + bool is_valid_; + +#if GTEST_USES_POSIX_RE + + regex_t full_regex_; // For FullMatch(). + regex_t partial_regex_; // For PartialMatch(). + +#else // GTEST_USES_SIMPLE_RE + + const char* full_pattern_; // For FullMatch(); + +#endif + + GTEST_DISALLOW_ASSIGN_(RE); +}; + +// Formats a source file path and a line number as they would appear +// in an error message from the compiler used to compile this code. +GTEST_API_ ::std::string FormatFileLocation(const char* file, int line); + +// Formats a file location for compiler-independent XML output. +// Although this function is not platform dependent, we put it next to +// FormatFileLocation in order to contrast the two functions. +GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file, + int line); + +// Defines logging utilities: +// GTEST_LOG_(severity) - logs messages at the specified severity level. The +// message itself is streamed into the macro. +// LogToStderr() - directs all log messages to stderr. +// FlushInfoLog() - flushes informational log messages. + +enum GTestLogSeverity { + GTEST_INFO, + GTEST_WARNING, + GTEST_ERROR, + GTEST_FATAL +}; + +// Formats log entry severity, provides a stream object for streaming the +// log message, and terminates the message with a newline when going out of +// scope. +class GTEST_API_ GTestLog { + public: + GTestLog(GTestLogSeverity severity, const char* file, int line); + + // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program. + ~GTestLog(); + + ::std::ostream& GetStream() { return ::std::cerr; } + + private: + const GTestLogSeverity severity_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog); +}; + +#define GTEST_LOG_(severity) \ + ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \ + __FILE__, __LINE__).GetStream() + +inline void LogToStderr() {} +inline void FlushInfoLog() { fflush(NULL); } + +// INTERNAL IMPLEMENTATION - DO NOT USE. +// +// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition +// is not satisfied. +// Synopsys: +// GTEST_CHECK_(boolean_condition); +// or +// GTEST_CHECK_(boolean_condition) << "Additional message"; +// +// This checks the condition and if the condition is not satisfied +// it prints message about the condition violation, including the +// condition itself, plus additional message streamed into it, if any, +// and then it aborts the program. It aborts the program irrespective of +// whether it is built in the debug mode or not. +#define GTEST_CHECK_(condition) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (::testing::internal::IsTrue(condition)) \ + ; \ + else \ + GTEST_LOG_(FATAL) << "Condition " #condition " failed. " + +// An all-mode assert to verify that the given POSIX-style function +// call returns 0 (indicating success). Known limitation: this +// doesn't expand to a balanced 'if' statement, so enclose the macro +// in {} if you need to use it as the only statement in an 'if' +// branch. +#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \ + if (const int gtest_error = (posix_call)) \ + GTEST_LOG_(FATAL) << #posix_call << "failed with error " \ + << gtest_error + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// Use ImplicitCast_ as a safe version of static_cast for upcasting in +// the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a +// const Foo*). When you use ImplicitCast_, the compiler checks that +// the cast is safe. Such explicit ImplicitCast_s are necessary in +// surprisingly many situations where C++ demands an exact type match +// instead of an argument type convertable to a target type. +// +// The syntax for using ImplicitCast_ is the same as for static_cast: +// +// ImplicitCast_(expr) +// +// ImplicitCast_ would have been part of the C++ standard library, +// but the proposal was submitted too late. It will probably make +// its way into the language in the future. +// +// This relatively ugly name is intentional. It prevents clashes with +// similar functions users may have (e.g., implicit_cast). The internal +// namespace alone is not enough because the function can be found by ADL. +template +inline To ImplicitCast_(To x) { return x; } + +// When you upcast (that is, cast a pointer from type Foo to type +// SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts +// always succeed. When you downcast (that is, cast a pointer from +// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because +// how do you know the pointer is really of type SubclassOfFoo? It +// could be a bare Foo, or of type DifferentSubclassOfFoo. Thus, +// when you downcast, you should use this macro. In debug mode, we +// use dynamic_cast<> to double-check the downcast is legal (we die +// if it's not). In normal mode, we do the efficient static_cast<> +// instead. Thus, it's important to test in debug mode to make sure +// the cast is legal! +// This is the only place in the code we should use dynamic_cast<>. +// In particular, you SHOULDN'T be using dynamic_cast<> in order to +// do RTTI (eg code like this: +// if (dynamic_cast(foo)) HandleASubclass1Object(foo); +// if (dynamic_cast(foo)) HandleASubclass2Object(foo); +// You should design the code some other way not to need this. +// +// This relatively ugly name is intentional. It prevents clashes with +// similar functions users may have (e.g., down_cast). The internal +// namespace alone is not enough because the function can be found by ADL. +template // use like this: DownCast_(foo); +inline To DownCast_(From* f) { // so we only accept pointers + // Ensures that To is a sub-type of From *. This test is here only + // for compile-time type checking, and has no overhead in an + // optimized build at run-time, as it will be optimized away + // completely. + if (false) { + const To to = NULL; + ::testing::internal::ImplicitCast_(to); + } + +#if GTEST_HAS_RTTI + // RTTI: debug mode only! + GTEST_CHECK_(f == NULL || dynamic_cast(f) != NULL); +#endif + return static_cast(f); +} + +// Downcasts the pointer of type Base to Derived. +// Derived must be a subclass of Base. The parameter MUST +// point to a class of type Derived, not any subclass of it. +// When RTTI is available, the function performs a runtime +// check to enforce this. +template +Derived* CheckedDowncastToActualType(Base* base) { +#if GTEST_HAS_RTTI + GTEST_CHECK_(typeid(*base) == typeid(Derived)); + return dynamic_cast(base); // NOLINT +#else + return static_cast(base); // Poor man's downcast. +#endif +} + +#if GTEST_HAS_STREAM_REDIRECTION + +// Defines the stderr capturer: +// CaptureStdout - starts capturing stdout. +// GetCapturedStdout - stops capturing stdout and returns the captured string. +// CaptureStderr - starts capturing stderr. +// GetCapturedStderr - stops capturing stderr and returns the captured string. +// +GTEST_API_ void CaptureStdout(); +GTEST_API_ std::string GetCapturedStdout(); +GTEST_API_ void CaptureStderr(); +GTEST_API_ std::string GetCapturedStderr(); + +#endif // GTEST_HAS_STREAM_REDIRECTION + + +#if GTEST_HAS_DEATH_TEST + +const ::std::vector& GetInjectableArgvs(); +void SetInjectableArgvs(const ::std::vector* + new_argvs); + +// A copy of all command line arguments. Set by InitGoogleTest(). +extern ::std::vector g_argvs; + +#endif // GTEST_HAS_DEATH_TEST + +// Defines synchronization primitives. + +#if GTEST_HAS_PTHREAD + +// Sleeps for (roughly) n milli-seconds. This function is only for +// testing Google Test's own constructs. Don't use it in user tests, +// either directly or indirectly. +inline void SleepMilliseconds(int n) { + const timespec time = { + 0, // 0 seconds. + n * 1000L * 1000L, // And n ms. + }; + nanosleep(&time, NULL); +} + +// Allows a controller thread to pause execution of newly created +// threads until notified. Instances of this class must be created +// and destroyed in the controller thread. +// +// This class is only for testing Google Test's own constructs. Do not +// use it in user tests, either directly or indirectly. +class Notification { + public: + Notification() : notified_(false) { + GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL)); + } + ~Notification() { + pthread_mutex_destroy(&mutex_); + } + + // Notifies all threads created with this notification to start. Must + // be called from the controller thread. + void Notify() { + pthread_mutex_lock(&mutex_); + notified_ = true; + pthread_mutex_unlock(&mutex_); + } + + // Blocks until the controller thread notifies. Must be called from a test + // thread. + void WaitForNotification() { + for (;;) { + pthread_mutex_lock(&mutex_); + const bool notified = notified_; + pthread_mutex_unlock(&mutex_); + if (notified) + break; + SleepMilliseconds(10); + } + } + + private: + pthread_mutex_t mutex_; + bool notified_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification); +}; + +// As a C-function, ThreadFuncWithCLinkage cannot be templated itself. +// Consequently, it cannot select a correct instantiation of ThreadWithParam +// in order to call its Run(). Introducing ThreadWithParamBase as a +// non-templated base class for ThreadWithParam allows us to bypass this +// problem. +class ThreadWithParamBase { + public: + virtual ~ThreadWithParamBase() {} + virtual void Run() = 0; +}; + +// pthread_create() accepts a pointer to a function type with the C linkage. +// According to the Standard (7.5/1), function types with different linkages +// are different even if they are otherwise identical. Some compilers (for +// example, SunStudio) treat them as different types. Since class methods +// cannot be defined with C-linkage we need to define a free C-function to +// pass into pthread_create(). +extern "C" inline void* ThreadFuncWithCLinkage(void* thread) { + static_cast(thread)->Run(); + return NULL; +} + +// Helper class for testing Google Test's multi-threading constructs. +// To use it, write: +// +// void ThreadFunc(int param) { /* Do things with param */ } +// Notification thread_can_start; +// ... +// // The thread_can_start parameter is optional; you can supply NULL. +// ThreadWithParam thread(&ThreadFunc, 5, &thread_can_start); +// thread_can_start.Notify(); +// +// These classes are only for testing Google Test's own constructs. Do +// not use them in user tests, either directly or indirectly. +template +class ThreadWithParam : public ThreadWithParamBase { + public: + typedef void (*UserThreadFunc)(T); + + ThreadWithParam( + UserThreadFunc func, T param, Notification* thread_can_start) + : func_(func), + param_(param), + thread_can_start_(thread_can_start), + finished_(false) { + ThreadWithParamBase* const base = this; + // The thread can be created only after all fields except thread_ + // have been initialized. + GTEST_CHECK_POSIX_SUCCESS_( + pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base)); + } + ~ThreadWithParam() { Join(); } + + void Join() { + if (!finished_) { + GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0)); + finished_ = true; + } + } + + virtual void Run() { + if (thread_can_start_ != NULL) + thread_can_start_->WaitForNotification(); + func_(param_); + } + + private: + const UserThreadFunc func_; // User-supplied thread function. + const T param_; // User-supplied parameter to the thread function. + // When non-NULL, used to block execution until the controller thread + // notifies. + Notification* const thread_can_start_; + bool finished_; // true iff we know that the thread function has finished. + pthread_t thread_; // The native thread object. + + GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam); +}; + +// MutexBase and Mutex implement mutex on pthreads-based platforms. They +// are used in conjunction with class MutexLock: +// +// Mutex mutex; +// ... +// MutexLock lock(&mutex); // Acquires the mutex and releases it at the end +// // of the current scope. +// +// MutexBase implements behavior for both statically and dynamically +// allocated mutexes. Do not use MutexBase directly. Instead, write +// the following to define a static mutex: +// +// GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex); +// +// You can forward declare a static mutex like this: +// +// GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex); +// +// To create a dynamic mutex, just define an object of type Mutex. +class MutexBase { + public: + // Acquires this mutex. + void Lock() { + GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_)); + owner_ = pthread_self(); + has_owner_ = true; + } + + // Releases this mutex. + void Unlock() { + // Since the lock is being released the owner_ field should no longer be + // considered valid. We don't protect writing to has_owner_ here, as it's + // the caller's responsibility to ensure that the current thread holds the + // mutex when this is called. + has_owner_ = false; + GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_)); + } + + // Does nothing if the current thread holds the mutex. Otherwise, crashes + // with high probability. + void AssertHeld() const { + GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self())) + << "The current thread is not holding the mutex @" << this; + } + + // A static mutex may be used before main() is entered. It may even + // be used before the dynamic initialization stage. Therefore we + // must be able to initialize a static mutex object at link time. + // This means MutexBase has to be a POD and its member variables + // have to be public. + public: + pthread_mutex_t mutex_; // The underlying pthread mutex. + // has_owner_ indicates whether the owner_ field below contains a valid thread + // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All + // accesses to the owner_ field should be protected by a check of this field. + // An alternative might be to memset() owner_ to all zeros, but there's no + // guarantee that a zero'd pthread_t is necessarily invalid or even different + // from pthread_self(). + bool has_owner_; + pthread_t owner_; // The thread holding the mutex. +}; + +// Forward-declares a static mutex. +# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ + extern ::testing::internal::MutexBase mutex + +// Defines and statically (i.e. at link time) initializes a static mutex. +// The initialization list here does not explicitly initialize each field, +// instead relying on default initialization for the unspecified fields. In +// particular, the owner_ field (a pthread_t) is not explicitly initialized. +// This allows initialization to work whether pthread_t is a scalar or struct. +// The flag -Wmissing-field-initializers must not be specified for this to work. +# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \ + ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, false } + +// The Mutex class can only be used for mutexes created at runtime. It +// shares its API with MutexBase otherwise. +class Mutex : public MutexBase { + public: + Mutex() { + GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL)); + has_owner_ = false; + } + ~Mutex() { + GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_)); + } + + private: + GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex); +}; + +// We cannot name this class MutexLock as the ctor declaration would +// conflict with a macro named MutexLock, which is defined on some +// platforms. Hence the typedef trick below. +class GTestMutexLock { + public: + explicit GTestMutexLock(MutexBase* mutex) + : mutex_(mutex) { mutex_->Lock(); } + + ~GTestMutexLock() { mutex_->Unlock(); } + + private: + MutexBase* const mutex_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock); +}; + +typedef GTestMutexLock MutexLock; + +// Helpers for ThreadLocal. + +// pthread_key_create() requires DeleteThreadLocalValue() to have +// C-linkage. Therefore it cannot be templatized to access +// ThreadLocal. Hence the need for class +// ThreadLocalValueHolderBase. +class ThreadLocalValueHolderBase { + public: + virtual ~ThreadLocalValueHolderBase() {} +}; + +// Called by pthread to delete thread-local data stored by +// pthread_setspecific(). +extern "C" inline void DeleteThreadLocalValue(void* value_holder) { + delete static_cast(value_holder); +} + +// Implements thread-local storage on pthreads-based systems. +// +// // Thread 1 +// ThreadLocal tl(100); // 100 is the default value for each thread. +// +// // Thread 2 +// tl.set(150); // Changes the value for thread 2 only. +// EXPECT_EQ(150, tl.get()); +// +// // Thread 1 +// EXPECT_EQ(100, tl.get()); // In thread 1, tl has the original value. +// tl.set(200); +// EXPECT_EQ(200, tl.get()); +// +// The template type argument T must have a public copy constructor. +// In addition, the default ThreadLocal constructor requires T to have +// a public default constructor. +// +// An object managed for a thread by a ThreadLocal instance is deleted +// when the thread exits. Or, if the ThreadLocal instance dies in +// that thread, when the ThreadLocal dies. It's the user's +// responsibility to ensure that all other threads using a ThreadLocal +// have exited when it dies, or the per-thread objects for those +// threads will not be deleted. +// +// Google Test only uses global ThreadLocal objects. That means they +// will die after main() has returned. Therefore, no per-thread +// object managed by Google Test will be leaked as long as all threads +// using Google Test have exited when main() returns. +template +class ThreadLocal { + public: + ThreadLocal() : key_(CreateKey()), + default_() {} + explicit ThreadLocal(const T& value) : key_(CreateKey()), + default_(value) {} + + ~ThreadLocal() { + // Destroys the managed object for the current thread, if any. + DeleteThreadLocalValue(pthread_getspecific(key_)); + + // Releases resources associated with the key. This will *not* + // delete managed objects for other threads. + GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_)); + } + + T* pointer() { return GetOrCreateValue(); } + const T* pointer() const { return GetOrCreateValue(); } + const T& get() const { return *pointer(); } + void set(const T& value) { *pointer() = value; } + + private: + // Holds a value of type T. + class ValueHolder : public ThreadLocalValueHolderBase { + public: + explicit ValueHolder(const T& value) : value_(value) {} + + T* pointer() { return &value_; } + + private: + T value_; + GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder); + }; + + static pthread_key_t CreateKey() { + pthread_key_t key; + // When a thread exits, DeleteThreadLocalValue() will be called on + // the object managed for that thread. + GTEST_CHECK_POSIX_SUCCESS_( + pthread_key_create(&key, &DeleteThreadLocalValue)); + return key; + } + + T* GetOrCreateValue() const { + ThreadLocalValueHolderBase* const holder = + static_cast(pthread_getspecific(key_)); + if (holder != NULL) { + return CheckedDowncastToActualType(holder)->pointer(); + } + + ValueHolder* const new_holder = new ValueHolder(default_); + ThreadLocalValueHolderBase* const holder_base = new_holder; + GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base)); + return new_holder->pointer(); + } + + // A key pthreads uses for looking up per-thread values. + const pthread_key_t key_; + const T default_; // The default value for each thread. + + GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal); +}; + +# define GTEST_IS_THREADSAFE 1 + +#else // GTEST_HAS_PTHREAD + +// A dummy implementation of synchronization primitives (mutex, lock, +// and thread-local variable). Necessary for compiling Google Test where +// mutex is not supported - using Google Test in multiple threads is not +// supported on such platforms. + +class Mutex { + public: + Mutex() {} + void Lock() {} + void Unlock() {} + void AssertHeld() const {} +}; + +# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ + extern ::testing::internal::Mutex mutex + +# define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex + +class GTestMutexLock { + public: + explicit GTestMutexLock(Mutex*) {} // NOLINT +}; + +typedef GTestMutexLock MutexLock; + +template +class ThreadLocal { + public: + ThreadLocal() : value_() {} + explicit ThreadLocal(const T& value) : value_(value) {} + T* pointer() { return &value_; } + const T* pointer() const { return &value_; } + const T& get() const { return value_; } + void set(const T& value) { value_ = value; } + private: + T value_; +}; + +// The above synchronization primitives have dummy implementations. +// Therefore Google Test is not thread-safe. +# define GTEST_IS_THREADSAFE 0 + +#endif // GTEST_HAS_PTHREAD + +// Returns the number of threads running in the process, or 0 to indicate that +// we cannot detect it. +GTEST_API_ size_t GetThreadCount(); + +// Passing non-POD classes through ellipsis (...) crashes the ARM +// compiler and generates a warning in Sun Studio. The Nokia Symbian +// and the IBM XL C/C++ compiler try to instantiate a copy constructor +// for objects passed through ellipsis (...), failing for uncopyable +// objects. We define this to ensure that only POD is passed through +// ellipsis on these systems. +#if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC) +// We lose support for NULL detection where the compiler doesn't like +// passing non-POD classes through ellipsis (...). +# define GTEST_ELLIPSIS_NEEDS_POD_ 1 +#else +# define GTEST_CAN_COMPARE_NULL 1 +#endif + +// The Nokia Symbian and IBM XL C/C++ compilers cannot decide between +// const T& and const T* in a function template. These compilers +// _can_ decide between class template specializations for T and T*, +// so a tr1::type_traits-like is_pointer works. +#if defined(__SYMBIAN32__) || defined(__IBMCPP__) +# define GTEST_NEEDS_IS_POINTER_ 1 +#endif + +template +struct bool_constant { + typedef bool_constant type; + static const bool value = bool_value; +}; +template const bool bool_constant::value; + +typedef bool_constant false_type; +typedef bool_constant true_type; + +template +struct is_pointer : public false_type {}; + +template +struct is_pointer : public true_type {}; + +template +struct IteratorTraits { + typedef typename Iterator::value_type value_type; +}; + +template +struct IteratorTraits { + typedef T value_type; +}; + +template +struct IteratorTraits { + typedef T value_type; +}; + +#if GTEST_OS_WINDOWS +# define GTEST_PATH_SEP_ "\\" +# define GTEST_HAS_ALT_PATH_SEP_ 1 +// The biggest signed integer type the compiler supports. +typedef __int64 BiggestInt; +#else +# define GTEST_PATH_SEP_ "/" +# define GTEST_HAS_ALT_PATH_SEP_ 0 +typedef long long BiggestInt; // NOLINT +#endif // GTEST_OS_WINDOWS + +// Utilities for char. + +// isspace(int ch) and friends accept an unsigned char or EOF. char +// may be signed, depending on the compiler (or compiler flags). +// Therefore we need to cast a char to unsigned char before calling +// isspace(), etc. + +inline bool IsAlpha(char ch) { + return isalpha(static_cast(ch)) != 0; +} +inline bool IsAlNum(char ch) { + return isalnum(static_cast(ch)) != 0; +} +inline bool IsDigit(char ch) { + return isdigit(static_cast(ch)) != 0; +} +inline bool IsLower(char ch) { + return islower(static_cast(ch)) != 0; +} +inline bool IsSpace(char ch) { + return isspace(static_cast(ch)) != 0; +} +inline bool IsUpper(char ch) { + return isupper(static_cast(ch)) != 0; +} +inline bool IsXDigit(char ch) { + return isxdigit(static_cast(ch)) != 0; +} +inline bool IsXDigit(wchar_t ch) { + const unsigned char low_byte = static_cast(ch); + return ch == low_byte && isxdigit(low_byte) != 0; +} + +inline char ToLower(char ch) { + return static_cast(tolower(static_cast(ch))); +} +inline char ToUpper(char ch) { + return static_cast(toupper(static_cast(ch))); +} + +// The testing::internal::posix namespace holds wrappers for common +// POSIX functions. These wrappers hide the differences between +// Windows/MSVC and POSIX systems. Since some compilers define these +// standard functions as macros, the wrapper cannot have the same name +// as the wrapped function. + +namespace posix { + +// Functions with a different name on Windows. + +#if GTEST_OS_WINDOWS + +typedef struct _stat StatStruct; + +# ifdef __BORLANDC__ +inline int IsATTY(int fd) { return isatty(fd); } +inline int StrCaseCmp(const char* s1, const char* s2) { + return stricmp(s1, s2); +} +inline char* StrDup(const char* src) { return strdup(src); } +# else // !__BORLANDC__ +# if GTEST_OS_WINDOWS_MOBILE +inline int IsATTY(int /* fd */) { return 0; } +# else +inline int IsATTY(int fd) { return _isatty(fd); } +# endif // GTEST_OS_WINDOWS_MOBILE +inline int StrCaseCmp(const char* s1, const char* s2) { + return _stricmp(s1, s2); +} +inline char* StrDup(const char* src) { return _strdup(src); } +# endif // __BORLANDC__ + +# if GTEST_OS_WINDOWS_MOBILE +inline int FileNo(FILE* file) { return reinterpret_cast(_fileno(file)); } +// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this +// time and thus not defined there. +# else +inline int FileNo(FILE* file) { return _fileno(file); } +inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); } +inline int RmDir(const char* dir) { return _rmdir(dir); } +inline bool IsDir(const StatStruct& st) { + return (_S_IFDIR & st.st_mode) != 0; +} +# endif // GTEST_OS_WINDOWS_MOBILE + +#else + +typedef struct stat StatStruct; + +inline int FileNo(FILE* file) { return fileno(file); } +inline int IsATTY(int fd) { return isatty(fd); } +inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); } +inline int StrCaseCmp(const char* s1, const char* s2) { + return strcasecmp(s1, s2); +} +inline char* StrDup(const char* src) { return strdup(src); } +inline int RmDir(const char* dir) { return rmdir(dir); } +inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); } + +#endif // GTEST_OS_WINDOWS + +// Functions deprecated by MSVC 8.0. + +#ifdef _MSC_VER +// Temporarily disable warning 4996 (deprecated function). +# pragma warning(push) +# pragma warning(disable:4996) +#endif + +inline const char* StrNCpy(char* dest, const char* src, size_t n) { + return strncpy(dest, src, n); +} + +// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and +// StrError() aren't needed on Windows CE at this time and thus not +// defined there. + +#if !GTEST_OS_WINDOWS_MOBILE +inline int ChDir(const char* dir) { return chdir(dir); } +#endif +inline FILE* FOpen(const char* path, const char* mode) { + return fopen(path, mode); +} +#if !GTEST_OS_WINDOWS_MOBILE +inline FILE *FReopen(const char* path, const char* mode, FILE* stream) { + return freopen(path, mode, stream); +} +inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); } +#endif +inline int FClose(FILE* fp) { return fclose(fp); } +#if !GTEST_OS_WINDOWS_MOBILE +inline int Read(int fd, void* buf, unsigned int count) { + return static_cast(read(fd, buf, count)); +} +inline int Write(int fd, const void* buf, unsigned int count) { + return static_cast(write(fd, buf, count)); +} +inline int Close(int fd) { return close(fd); } +inline const char* StrError(int errnum) { return strerror(errnum); } +#endif +inline const char* GetEnv(const char* name) { +#if GTEST_OS_WINDOWS_MOBILE + // We are on Windows CE, which has no environment variables. + return NULL; +#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9) + // Environment variables which we programmatically clear will be set to the + // empty string rather than unset (NULL). Handle that case. + const char* const env = getenv(name); + return (env != NULL && env[0] != '\0') ? env : NULL; +#else + return getenv(name); +#endif +} + +#ifdef _MSC_VER +# pragma warning(pop) // Restores the warning state. +#endif + +#if GTEST_OS_WINDOWS_MOBILE +// Windows CE has no C library. The abort() function is used in +// several places in Google Test. This implementation provides a reasonable +// imitation of standard behaviour. +void Abort(); +#else +inline void Abort() { abort(); } +#endif // GTEST_OS_WINDOWS_MOBILE + +} // namespace posix + +// MSVC "deprecates" snprintf and issues warnings wherever it is used. In +// order to avoid these warnings, we need to use _snprintf or _snprintf_s on +// MSVC-based platforms. We map the GTEST_SNPRINTF_ macro to the appropriate +// function in order to achieve that. We use macro definition here because +// snprintf is a variadic function. +#if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE +// MSVC 2005 and above support variadic macros. +# define GTEST_SNPRINTF_(buffer, size, format, ...) \ + _snprintf_s(buffer, size, size, format, __VA_ARGS__) +#elif defined(_MSC_VER) +// Windows CE does not define _snprintf_s and MSVC prior to 2005 doesn't +// complain about _snprintf. +# define GTEST_SNPRINTF_ _snprintf +#else +# define GTEST_SNPRINTF_ snprintf +#endif + +// The maximum number a BiggestInt can represent. This definition +// works no matter BiggestInt is represented in one's complement or +// two's complement. +// +// We cannot rely on numeric_limits in STL, as __int64 and long long +// are not part of standard C++ and numeric_limits doesn't need to be +// defined for them. +const BiggestInt kMaxBiggestInt = + ~(static_cast(1) << (8*sizeof(BiggestInt) - 1)); + +// This template class serves as a compile-time function from size to +// type. It maps a size in bytes to a primitive type with that +// size. e.g. +// +// TypeWithSize<4>::UInt +// +// is typedef-ed to be unsigned int (unsigned integer made up of 4 +// bytes). +// +// Such functionality should belong to STL, but I cannot find it +// there. +// +// Google Test uses this class in the implementation of floating-point +// comparison. +// +// For now it only handles UInt (unsigned int) as that's all Google Test +// needs. Other types can be easily added in the future if need +// arises. +template +class TypeWithSize { + public: + // This prevents the user from using TypeWithSize with incorrect + // values of N. + typedef void UInt; +}; + +// The specialization for size 4. +template <> +class TypeWithSize<4> { + public: + // unsigned int has size 4 in both gcc and MSVC. + // + // As base/basictypes.h doesn't compile on Windows, we cannot use + // uint32, uint64, and etc here. + typedef int Int; + typedef unsigned int UInt; +}; + +// The specialization for size 8. +template <> +class TypeWithSize<8> { + public: +#if GTEST_OS_WINDOWS + typedef __int64 Int; + typedef unsigned __int64 UInt; +#else + typedef long long Int; // NOLINT + typedef unsigned long long UInt; // NOLINT +#endif // GTEST_OS_WINDOWS +}; + +// Integer types of known sizes. +typedef TypeWithSize<4>::Int Int32; +typedef TypeWithSize<4>::UInt UInt32; +typedef TypeWithSize<8>::Int Int64; +typedef TypeWithSize<8>::UInt UInt64; +typedef TypeWithSize<8>::Int TimeInMillis; // Represents time in milliseconds. + +// Utilities for command line flags and environment variables. + +// Macro for referencing flags. +#define GTEST_FLAG(name) FLAGS_gtest_##name + +// Macros for declaring flags. +#define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name) +#define GTEST_DECLARE_int32_(name) \ + GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name) +#define GTEST_DECLARE_string_(name) \ + GTEST_API_ extern ::std::string GTEST_FLAG(name) + +// Macros for defining flags. +#define GTEST_DEFINE_bool_(name, default_val, doc) \ + GTEST_API_ bool GTEST_FLAG(name) = (default_val) +#define GTEST_DEFINE_int32_(name, default_val, doc) \ + GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val) +#define GTEST_DEFINE_string_(name, default_val, doc) \ + GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val) + +// Thread annotations +#define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks) +#define GTEST_LOCK_EXCLUDED_(locks) + +// Parses 'str' for a 32-bit signed integer. If successful, writes the result +// to *value and returns true; otherwise leaves *value unchanged and returns +// false. +// TODO(chandlerc): Find a better way to refactor flag and environment parsing +// out of both gtest-port.cc and gtest.cc to avoid exporting this utility +// function. +bool ParseInt32(const Message& src_text, const char* str, Int32* value); + +// Parses a bool/Int32/string from the environment variable +// corresponding to the given Google Test flag. +bool BoolFromGTestEnv(const char* flag, bool default_val); +GTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val); +const char* StringFromGTestEnv(const char* flag, const char* default_val); + +} // namespace internal +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ + +#if GTEST_OS_LINUX +# include +# include +# include +# include +#endif // GTEST_OS_LINUX + +#if GTEST_HAS_EXCEPTIONS +# include +#endif + +#include +#include +#include +#include +#include +#include + +// 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) +// +// This header file defines the Message class. +// +// IMPORTANT NOTE: Due to limitation of the C++ language, we have to +// leave some internal implementation details in this header file. +// They are clearly marked by comments like this: +// +// // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +// +// Such code is NOT meant to be used by a user directly, and is subject +// to CHANGE WITHOUT NOTICE. Therefore DO NOT DEPEND ON IT in a user +// program! + +#ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ +#define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ + +#include + + +// Ensures that there is at least one operator<< in the global namespace. +// See Message& operator<<(...) below for why. +void operator<<(const testing::internal::Secret&, int); + +namespace testing { + +// The Message class works like an ostream repeater. +// +// Typical usage: +// +// 1. You stream a bunch of values to a Message object. +// It will remember the text in a stringstream. +// 2. Then you stream the Message object to an ostream. +// This causes the text in the Message to be streamed +// to the ostream. +// +// For example; +// +// testing::Message foo; +// foo << 1 << " != " << 2; +// std::cout << foo; +// +// will print "1 != 2". +// +// Message is not intended to be inherited from. In particular, its +// destructor is not virtual. +// +// Note that stringstream behaves differently in gcc and in MSVC. You +// can stream a NULL char pointer to it in the former, but not in the +// latter (it causes an access violation if you do). The Message +// class hides this difference by treating a NULL char pointer as +// "(null)". +class GTEST_API_ Message { + private: + // The type of basic IO manipulators (endl, ends, and flush) for + // narrow streams. + typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&); + + public: + // Constructs an empty Message. + Message(); + + // Copy constructor. + Message(const Message& msg) : ss_(new ::std::stringstream) { // NOLINT + *ss_ << msg.GetString(); + } + + // Constructs a Message from a C-string. + explicit Message(const char* str) : ss_(new ::std::stringstream) { + *ss_ << str; + } + +#if GTEST_OS_SYMBIAN + // Streams a value (either a pointer or not) to this object. + template + inline Message& operator <<(const T& value) { + StreamHelper(typename internal::is_pointer::type(), value); + return *this; + } +#else + // Streams a non-pointer value to this object. + template + inline Message& operator <<(const T& val) { + // Some libraries overload << for STL containers. These + // overloads are defined in the global namespace instead of ::std. + // + // C++'s symbol lookup rule (i.e. Koenig lookup) says that these + // overloads are visible in either the std namespace or the global + // namespace, but not other namespaces, including the testing + // namespace which Google Test's Message class is in. + // + // To allow STL containers (and other types that has a << operator + // defined in the global namespace) to be used in Google Test + // assertions, testing::Message must access the custom << operator + // from the global namespace. With this using declaration, + // overloads of << defined in the global namespace and those + // visible via Koenig lookup are both exposed in this function. + using ::operator <<; + *ss_ << val; + return *this; + } + + // Streams a pointer value to this object. + // + // This function is an overload of the previous one. When you + // stream a pointer to a Message, this definition will be used as it + // is more specialized. (The C++ Standard, section + // [temp.func.order].) If you stream a non-pointer, then the + // previous definition will be used. + // + // The reason for this overload is that streaming a NULL pointer to + // ostream is undefined behavior. Depending on the compiler, you + // may get "0", "(nil)", "(null)", or an access violation. To + // ensure consistent result across compilers, we always treat NULL + // as "(null)". + template + inline Message& operator <<(T* const& pointer) { // NOLINT + if (pointer == NULL) { + *ss_ << "(null)"; + } else { + *ss_ << pointer; + } + return *this; + } +#endif // GTEST_OS_SYMBIAN + + // Since the basic IO manipulators are overloaded for both narrow + // and wide streams, we have to provide this specialized definition + // of operator <<, even though its body is the same as the + // templatized version above. Without this definition, streaming + // endl or other basic IO manipulators to Message will confuse the + // compiler. + Message& operator <<(BasicNarrowIoManip val) { + *ss_ << val; + return *this; + } + + // Instead of 1/0, we want to see true/false for bool values. + Message& operator <<(bool b) { + return *this << (b ? "true" : "false"); + } + + // These two overloads allow streaming a wide C string to a Message + // using the UTF-8 encoding. + Message& operator <<(const wchar_t* wide_c_str); + Message& operator <<(wchar_t* wide_c_str); + +#if GTEST_HAS_STD_WSTRING + // Converts the given wide string to a narrow string using the UTF-8 + // encoding, and streams the result to this Message object. + Message& operator <<(const ::std::wstring& wstr); +#endif // GTEST_HAS_STD_WSTRING + +#if GTEST_HAS_GLOBAL_WSTRING + // Converts the given wide string to a narrow string using the UTF-8 + // encoding, and streams the result to this Message object. + Message& operator <<(const ::wstring& wstr); +#endif // GTEST_HAS_GLOBAL_WSTRING + + // Gets the text streamed to this object so far as an std::string. + // Each '\0' character in the buffer is replaced with "\\0". + // + // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. + std::string GetString() const; + + private: + +#if GTEST_OS_SYMBIAN + // These are needed as the Nokia Symbian Compiler cannot decide between + // const T& and const T* in a function template. The Nokia compiler _can_ + // decide between class template specializations for T and T*, so a + // tr1::type_traits-like is_pointer works, and we can overload on that. + template + inline void StreamHelper(internal::true_type /*is_pointer*/, T* pointer) { + if (pointer == NULL) { + *ss_ << "(null)"; + } else { + *ss_ << pointer; + } + } + template + inline void StreamHelper(internal::false_type /*is_pointer*/, + const T& value) { + // See the comments in Message& operator <<(const T&) above for why + // we need this using statement. + using ::operator <<; + *ss_ << value; + } +#endif // GTEST_OS_SYMBIAN + + // We'll hold the text streamed to this object here. + const internal::scoped_ptr< ::std::stringstream> ss_; + + // We declare (but don't implement) this to prevent the compiler + // from implementing the assignment operator. + void operator=(const Message&); +}; + +// Streams a Message to an ostream. +inline std::ostream& operator <<(std::ostream& os, const Message& sb) { + return os << sb.GetString(); +} + +namespace internal { + +// Converts a streamable value to an std::string. A NULL pointer is +// converted to "(null)". When the input value is a ::string, +// ::std::string, ::wstring, or ::std::wstring object, each NUL +// character in it is replaced with "\\0". +template +std::string StreamableToString(const T& streamable) { + return (Message() << streamable).GetString(); +} + +} // namespace internal +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ +// 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. +// +// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee) +// +// The Google C++ Testing Framework (Google Test) +// +// This header file declares the String class and functions used internally by +// Google Test. They are subject to change without notice. They should not used +// by code external to Google Test. +// +// This header file is #included by . +// It should not be #included by other files. + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_ + +#ifdef __BORLANDC__ +// string.h is not guaranteed to provide strcpy on C++ Builder. +# include +#endif + +#include +#include + + +namespace testing { +namespace internal { + +// String - an abstract class holding static string utilities. +class GTEST_API_ String { + public: + // Static utility methods + + // Clones a 0-terminated C string, allocating memory using new. The + // caller is responsible for deleting the return value using + // delete[]. Returns the cloned string, or NULL if the input is + // NULL. + // + // This is different from strdup() in string.h, which allocates + // memory using malloc(). + static const char* CloneCString(const char* c_str); + +#if GTEST_OS_WINDOWS_MOBILE + // Windows CE does not have the 'ANSI' versions of Win32 APIs. To be + // able to pass strings to Win32 APIs on CE we need to convert them + // to 'Unicode', UTF-16. + + // Creates a UTF-16 wide string from the given ANSI string, allocating + // memory using new. The caller is responsible for deleting the return + // value using delete[]. Returns the wide string, or NULL if the + // input is NULL. + // + // The wide string is created using the ANSI codepage (CP_ACP) to + // match the behaviour of the ANSI versions of Win32 calls and the + // C runtime. + static LPCWSTR AnsiToUtf16(const char* c_str); + + // Creates an ANSI string from the given wide string, allocating + // memory using new. The caller is responsible for deleting the return + // value using delete[]. Returns the ANSI string, or NULL if the + // input is NULL. + // + // The returned string is created using the ANSI codepage (CP_ACP) to + // match the behaviour of the ANSI versions of Win32 calls and the + // C runtime. + static const char* Utf16ToAnsi(LPCWSTR utf16_str); +#endif + + // Compares two C strings. Returns true iff they have the same content. + // + // Unlike strcmp(), this function can handle NULL argument(s). A + // NULL C string is considered different to any non-NULL C string, + // including the empty string. + static bool CStringEquals(const char* lhs, const char* rhs); + + // Converts a wide C string to a String using the UTF-8 encoding. + // NULL will be converted to "(null)". If an error occurred during + // the conversion, "(failed to convert from wide string)" is + // returned. + static std::string ShowWideCString(const wchar_t* wide_c_str); + + // Compares two wide C strings. Returns true iff they have the same + // content. + // + // Unlike wcscmp(), this function can handle NULL argument(s). A + // NULL C string is considered different to any non-NULL C string, + // including the empty string. + static bool WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs); + + // Compares two C strings, ignoring case. Returns true iff they + // have the same content. + // + // Unlike strcasecmp(), this function can handle NULL argument(s). + // A NULL C string is considered different to any non-NULL C string, + // including the empty string. + static bool CaseInsensitiveCStringEquals(const char* lhs, + const char* rhs); + + // Compares two wide C strings, ignoring case. Returns true iff they + // have the same content. + // + // Unlike wcscasecmp(), this function can handle NULL argument(s). + // A NULL C string is considered different to any non-NULL wide C string, + // including the empty string. + // NB: The implementations on different platforms slightly differ. + // On windows, this method uses _wcsicmp which compares according to LC_CTYPE + // environment variable. On GNU platform this method uses wcscasecmp + // which compares according to LC_CTYPE category of the current locale. + // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the + // current locale. + static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs, + const wchar_t* rhs); + + // Returns true iff the given string ends with the given suffix, ignoring + // case. Any string is considered to end with an empty suffix. + static bool EndsWithCaseInsensitive( + const std::string& str, const std::string& suffix); + + // Formats an int value as "%02d". + static std::string FormatIntWidth2(int value); // "%02d" for width == 2 + + // Formats an int value as "%X". + static std::string FormatHexInt(int value); + + // Formats a byte as "%02X". + static std::string FormatByte(unsigned char value); + + private: + String(); // Not meant to be instantiated. +}; // class String + +// Gets the content of the stringstream's buffer as an std::string. Each '\0' +// character in the buffer is replaced with "\\0". +GTEST_API_ std::string StringStreamToString(::std::stringstream* stream); + +} // namespace internal +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_ +// 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. +// +// Author: keith.ray@gmail.com (Keith Ray) +// +// Google Test filepath utilities +// +// This header file declares classes and functions used internally by +// Google Test. They are subject to change without notice. +// +// This file is #included in . +// Do not include this header file separately! + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_ + + +namespace testing { +namespace internal { + +// FilePath - a class for file and directory pathname manipulation which +// handles platform-specific conventions (like the pathname separator). +// Used for helper functions for naming files in a directory for xml output. +// Except for Set methods, all methods are const or static, which provides an +// "immutable value object" -- useful for peace of mind. +// A FilePath with a value ending in a path separator ("like/this/") represents +// a directory, otherwise it is assumed to represent a file. In either case, +// it may or may not represent an actual file or directory in the file system. +// Names are NOT checked for syntax correctness -- no checking for illegal +// characters, malformed paths, etc. + +class GTEST_API_ FilePath { + public: + FilePath() : pathname_("") { } + FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { } + + explicit FilePath(const std::string& pathname) : pathname_(pathname) { + Normalize(); + } + + FilePath& operator=(const FilePath& rhs) { + Set(rhs); + return *this; + } + + void Set(const FilePath& rhs) { + pathname_ = rhs.pathname_; + } + + const std::string& string() const { return pathname_; } + const char* c_str() const { return pathname_.c_str(); } + + // Returns the current working directory, or "" if unsuccessful. + static FilePath GetCurrentDir(); + + // Given directory = "dir", base_name = "test", number = 0, + // extension = "xml", returns "dir/test.xml". If number is greater + // than zero (e.g., 12), returns "dir/test_12.xml". + // On Windows platform, uses \ as the separator rather than /. + static FilePath MakeFileName(const FilePath& directory, + const FilePath& base_name, + int number, + const char* extension); + + // Given directory = "dir", relative_path = "test.xml", + // returns "dir/test.xml". + // On Windows, uses \ as the separator rather than /. + static FilePath ConcatPaths(const FilePath& directory, + const FilePath& relative_path); + + // Returns a pathname for a file that does not currently exist. The pathname + // will be directory/base_name.extension or + // directory/base_name_.extension if directory/base_name.extension + // already exists. The number will be incremented until a pathname is found + // that does not already exist. + // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'. + // There could be a race condition if two or more processes are calling this + // function at the same time -- they could both pick the same filename. + static FilePath GenerateUniqueFileName(const FilePath& directory, + const FilePath& base_name, + const char* extension); + + // Returns true iff the path is "". + bool IsEmpty() const { return pathname_.empty(); } + + // If input name has a trailing separator character, removes it and returns + // the name, otherwise return the name string unmodified. + // On Windows platform, uses \ as the separator, other platforms use /. + FilePath RemoveTrailingPathSeparator() const; + + // Returns a copy of the FilePath with the directory part removed. + // Example: FilePath("path/to/file").RemoveDirectoryName() returns + // FilePath("file"). If there is no directory part ("just_a_file"), it returns + // the FilePath unmodified. If there is no file part ("just_a_dir/") it + // returns an empty FilePath (""). + // On Windows platform, '\' is the path separator, otherwise it is '/'. + FilePath RemoveDirectoryName() const; + + // RemoveFileName returns the directory path with the filename removed. + // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/". + // If the FilePath is "a_file" or "/a_file", RemoveFileName returns + // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does + // not have a file, like "just/a/dir/", it returns the FilePath unmodified. + // On Windows platform, '\' is the path separator, otherwise it is '/'. + FilePath RemoveFileName() const; + + // Returns a copy of the FilePath with the case-insensitive extension removed. + // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns + // FilePath("dir/file"). If a case-insensitive extension is not + // found, returns a copy of the original FilePath. + FilePath RemoveExtension(const char* extension) const; + + // Creates directories so that path exists. Returns true if successful or if + // the directories already exist; returns false if unable to create + // directories for any reason. Will also return false if the FilePath does + // not represent a directory (that is, it doesn't end with a path separator). + bool CreateDirectoriesRecursively() const; + + // Create the directory so that path exists. Returns true if successful or + // if the directory already exists; returns false if unable to create the + // directory for any reason, including if the parent directory does not + // exist. Not named "CreateDirectory" because that's a macro on Windows. + bool CreateFolder() const; + + // Returns true if FilePath describes something in the file-system, + // either a file, directory, or whatever, and that something exists. + bool FileOrDirectoryExists() const; + + // Returns true if pathname describes a directory in the file-system + // that exists. + bool DirectoryExists() const; + + // Returns true if FilePath ends with a path separator, which indicates that + // it is intended to represent a directory. Returns false otherwise. + // This does NOT check that a directory (or file) actually exists. + bool IsDirectory() const; + + // Returns true if pathname describes a root directory. (Windows has one + // root directory per disk drive.) + bool IsRootDirectory() const; + + // Returns true if pathname describes an absolute path. + bool IsAbsolutePath() const; + + private: + // Replaces multiple consecutive separators with a single separator. + // For example, "bar///foo" becomes "bar/foo". Does not eliminate other + // redundancies that might be in a pathname involving "." or "..". + // + // A pathname with multiple consecutive separators may occur either through + // user error or as a result of some scripts or APIs that generate a pathname + // with a trailing separator. On other platforms the same API or script + // may NOT generate a pathname with a trailing "/". Then elsewhere that + // pathname may have another "/" and pathname components added to it, + // without checking for the separator already being there. + // The script language and operating system may allow paths like "foo//bar" + // but some of the functions in FilePath will not handle that correctly. In + // particular, RemoveTrailingPathSeparator() only removes one separator, and + // it is called in CreateDirectoriesRecursively() assuming that it will change + // a pathname from directory syntax (trailing separator) to filename syntax. + // + // On Windows this method also replaces the alternate path separator '/' with + // the primary path separator '\\', so that for example "bar\\/\\foo" becomes + // "bar\\foo". + + void Normalize(); + + // Returns a pointer to the last occurence of a valid path separator in + // the FilePath. On Windows, for example, both '/' and '\' are valid path + // separators. Returns NULL if no path separator was found. + const char* FindLastPathSeparator() const; + + std::string pathname_; +}; // class FilePath + +} // namespace internal +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_ +// This file was GENERATED by command: +// pump.py gtest-type-util.h.pump +// DO NOT EDIT BY HAND!!! + +// 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. +// +// Author: wan@google.com (Zhanyong Wan) + +// Type utilities needed for implementing typed and type-parameterized +// tests. This file is generated by a SCRIPT. DO NOT EDIT BY HAND! +// +// Currently we support at most 50 types in a list, and at most 50 +// type-parameterized tests in one type-parameterized test case. +// Please contact googletestframework@googlegroups.com if you need +// more. + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ + + +// #ifdef __GNUC__ is too general here. It is possible to use gcc without using +// libstdc++ (which is where cxxabi.h comes from). +# if GTEST_HAS_CXXABI_H_ +# include +# elif defined(__HP_aCC) +# include +# endif // GTEST_HASH_CXXABI_H_ + +namespace testing { +namespace internal { + +// GetTypeName() returns a human-readable name of type T. +// NB: This function is also used in Google Mock, so don't move it inside of +// the typed-test-only section below. +template +std::string GetTypeName() { +# if GTEST_HAS_RTTI + + const char* const name = typeid(T).name(); +# if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC) + int status = 0; + // gcc's implementation of typeid(T).name() mangles the type name, + // so we have to demangle it. +# if GTEST_HAS_CXXABI_H_ + using abi::__cxa_demangle; +# endif // GTEST_HAS_CXXABI_H_ + char* const readable_name = __cxa_demangle(name, 0, 0, &status); + const std::string name_str(status == 0 ? readable_name : name); + free(readable_name); + return name_str; +# else + return name; +# endif // GTEST_HAS_CXXABI_H_ || __HP_aCC + +# else + + return ""; + +# endif // GTEST_HAS_RTTI +} + +#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P + +// AssertyTypeEq::type is defined iff T1 and T2 are the same +// type. This can be used as a compile-time assertion to ensure that +// two types are equal. + +template +struct AssertTypeEq; + +template +struct AssertTypeEq { + typedef bool type; +}; + +// A unique type used as the default value for the arguments of class +// template Types. This allows us to simulate variadic templates +// (e.g. Types, Type, and etc), which C++ doesn't +// support directly. +struct None {}; + +// The following family of struct and struct templates are used to +// represent type lists. In particular, TypesN +// represents a type list with N types (T1, T2, ..., and TN) in it. +// Except for Types0, every struct in the family has two member types: +// Head for the first type in the list, and Tail for the rest of the +// list. + +// The empty type list. +struct Types0 {}; + +// Type lists of length 1, 2, 3, and so on. + +template +struct Types1 { + typedef T1 Head; + typedef Types0 Tail; +}; +template +struct Types2 { + typedef T1 Head; + typedef Types1 Tail; +}; + +template +struct Types3 { + typedef T1 Head; + typedef Types2 Tail; +}; + +template +struct Types4 { + typedef T1 Head; + typedef Types3 Tail; +}; + +template +struct Types5 { + typedef T1 Head; + typedef Types4 Tail; +}; + +template +struct Types6 { + typedef T1 Head; + typedef Types5 Tail; +}; + +template +struct Types7 { + typedef T1 Head; + typedef Types6 Tail; +}; + +template +struct Types8 { + typedef T1 Head; + typedef Types7 Tail; +}; + +template +struct Types9 { + typedef T1 Head; + typedef Types8 Tail; +}; + +template +struct Types10 { + typedef T1 Head; + typedef Types9 Tail; +}; + +template +struct Types11 { + typedef T1 Head; + typedef Types10 Tail; +}; + +template +struct Types12 { + typedef T1 Head; + typedef Types11 Tail; +}; + +template +struct Types13 { + typedef T1 Head; + typedef Types12 Tail; +}; + +template +struct Types14 { + typedef T1 Head; + typedef Types13 Tail; +}; + +template +struct Types15 { + typedef T1 Head; + typedef Types14 Tail; +}; + +template +struct Types16 { + typedef T1 Head; + typedef Types15 Tail; +}; + +template +struct Types17 { + typedef T1 Head; + typedef Types16 Tail; +}; + +template +struct Types18 { + typedef T1 Head; + typedef Types17 Tail; +}; + +template +struct Types19 { + typedef T1 Head; + typedef Types18 Tail; +}; + +template +struct Types20 { + typedef T1 Head; + typedef Types19 Tail; +}; + +template +struct Types21 { + typedef T1 Head; + typedef Types20 Tail; +}; + +template +struct Types22 { + typedef T1 Head; + typedef Types21 Tail; +}; + +template +struct Types23 { + typedef T1 Head; + typedef Types22 Tail; +}; + +template +struct Types24 { + typedef T1 Head; + typedef Types23 Tail; +}; + +template +struct Types25 { + typedef T1 Head; + typedef Types24 Tail; +}; + +template +struct Types26 { + typedef T1 Head; + typedef Types25 Tail; +}; + +template +struct Types27 { + typedef T1 Head; + typedef Types26 Tail; +}; + +template +struct Types28 { + typedef T1 Head; + typedef Types27 Tail; +}; + +template +struct Types29 { + typedef T1 Head; + typedef Types28 Tail; +}; + +template +struct Types30 { + typedef T1 Head; + typedef Types29 Tail; +}; + +template +struct Types31 { + typedef T1 Head; + typedef Types30 Tail; +}; + +template +struct Types32 { + typedef T1 Head; + typedef Types31 Tail; +}; + +template +struct Types33 { + typedef T1 Head; + typedef Types32 Tail; +}; + +template +struct Types34 { + typedef T1 Head; + typedef Types33 Tail; +}; + +template +struct Types35 { + typedef T1 Head; + typedef Types34 Tail; +}; + +template +struct Types36 { + typedef T1 Head; + typedef Types35 Tail; +}; + +template +struct Types37 { + typedef T1 Head; + typedef Types36 Tail; +}; + +template +struct Types38 { + typedef T1 Head; + typedef Types37 Tail; +}; + +template +struct Types39 { + typedef T1 Head; + typedef Types38 Tail; +}; + +template +struct Types40 { + typedef T1 Head; + typedef Types39 Tail; +}; + +template +struct Types41 { + typedef T1 Head; + typedef Types40 Tail; +}; + +template +struct Types42 { + typedef T1 Head; + typedef Types41 Tail; +}; + +template +struct Types43 { + typedef T1 Head; + typedef Types42 Tail; +}; + +template +struct Types44 { + typedef T1 Head; + typedef Types43 Tail; +}; + +template +struct Types45 { + typedef T1 Head; + typedef Types44 Tail; +}; + +template +struct Types46 { + typedef T1 Head; + typedef Types45 Tail; +}; + +template +struct Types47 { + typedef T1 Head; + typedef Types46 Tail; +}; + +template +struct Types48 { + typedef T1 Head; + typedef Types47 Tail; +}; + +template +struct Types49 { + typedef T1 Head; + typedef Types48 Tail; +}; + +template +struct Types50 { + typedef T1 Head; + typedef Types49 Tail; +}; + + +} // namespace internal + +// We don't want to require the users to write TypesN<...> directly, +// as that would require them to count the length. Types<...> is much +// easier to write, but generates horrible messages when there is a +// compiler error, as gcc insists on printing out each template +// argument, even if it has the default value (this means Types +// will appear as Types in the compiler +// errors). +// +// Our solution is to combine the best part of the two approaches: a +// user would write Types, and Google Test will translate +// that to TypesN internally to make error messages +// readable. The translation is done by the 'type' member of the +// Types template. +template +struct Types { + typedef internal::Types50 type; +}; + +template <> +struct Types { + typedef internal::Types0 type; +}; +template +struct Types { + typedef internal::Types1 type; +}; +template +struct Types { + typedef internal::Types2 type; +}; +template +struct Types { + typedef internal::Types3 type; +}; +template +struct Types { + typedef internal::Types4 type; +}; +template +struct Types { + typedef internal::Types5 type; +}; +template +struct Types { + typedef internal::Types6 type; +}; +template +struct Types { + typedef internal::Types7 type; +}; +template +struct Types { + typedef internal::Types8 type; +}; +template +struct Types { + typedef internal::Types9 type; +}; +template +struct Types { + typedef internal::Types10 type; +}; +template +struct Types { + typedef internal::Types11 type; +}; +template +struct Types { + typedef internal::Types12 type; +}; +template +struct Types { + typedef internal::Types13 type; +}; +template +struct Types { + typedef internal::Types14 type; +}; +template +struct Types { + typedef internal::Types15 type; +}; +template +struct Types { + typedef internal::Types16 type; +}; +template +struct Types { + typedef internal::Types17 type; +}; +template +struct Types { + typedef internal::Types18 type; +}; +template +struct Types { + typedef internal::Types19 type; +}; +template +struct Types { + typedef internal::Types20 type; +}; +template +struct Types { + typedef internal::Types21 type; +}; +template +struct Types { + typedef internal::Types22 type; +}; +template +struct Types { + typedef internal::Types23 type; +}; +template +struct Types { + typedef internal::Types24 type; +}; +template +struct Types { + typedef internal::Types25 type; +}; +template +struct Types { + typedef internal::Types26 type; +}; +template +struct Types { + typedef internal::Types27 type; +}; +template +struct Types { + typedef internal::Types28 type; +}; +template +struct Types { + typedef internal::Types29 type; +}; +template +struct Types { + typedef internal::Types30 type; +}; +template +struct Types { + typedef internal::Types31 type; +}; +template +struct Types { + typedef internal::Types32 type; +}; +template +struct Types { + typedef internal::Types33 type; +}; +template +struct Types { + typedef internal::Types34 type; +}; +template +struct Types { + typedef internal::Types35 type; +}; +template +struct Types { + typedef internal::Types36 type; +}; +template +struct Types { + typedef internal::Types37 type; +}; +template +struct Types { + typedef internal::Types38 type; +}; +template +struct Types { + typedef internal::Types39 type; +}; +template +struct Types { + typedef internal::Types40 type; +}; +template +struct Types { + typedef internal::Types41 type; +}; +template +struct Types { + typedef internal::Types42 type; +}; +template +struct Types { + typedef internal::Types43 type; +}; +template +struct Types { + typedef internal::Types44 type; +}; +template +struct Types { + typedef internal::Types45 type; +}; +template +struct Types { + typedef internal::Types46 type; +}; +template +struct Types { + typedef internal::Types47 type; +}; +template +struct Types { + typedef internal::Types48 type; +}; +template +struct Types { + typedef internal::Types49 type; +}; + +namespace internal { + +# define GTEST_TEMPLATE_ template class + +// The template "selector" struct TemplateSel is used to +// represent Tmpl, which must be a class template with one type +// parameter, as a type. TemplateSel::Bind::type is defined +// as the type Tmpl. This allows us to actually instantiate the +// template "selected" by TemplateSel. +// +// This trick is necessary for simulating typedef for class templates, +// which C++ doesn't support directly. +template +struct TemplateSel { + template + struct Bind { + typedef Tmpl type; + }; +}; + +# define GTEST_BIND_(TmplSel, T) \ + TmplSel::template Bind::type + +// A unique struct template used as the default value for the +// arguments of class template Templates. This allows us to simulate +// variadic templates (e.g. Templates, Templates, +// and etc), which C++ doesn't support directly. +template +struct NoneT {}; + +// The following family of struct and struct templates are used to +// represent template lists. In particular, TemplatesN represents a list of N templates (T1, T2, ..., and TN). Except +// for Templates0, every struct in the family has two member types: +// Head for the selector of the first template in the list, and Tail +// for the rest of the list. + +// The empty template list. +struct Templates0 {}; + +// Template lists of length 1, 2, 3, and so on. + +template +struct Templates1 { + typedef TemplateSel Head; + typedef Templates0 Tail; +}; +template +struct Templates2 { + typedef TemplateSel Head; + typedef Templates1 Tail; +}; + +template +struct Templates3 { + typedef TemplateSel Head; + typedef Templates2 Tail; +}; + +template +struct Templates4 { + typedef TemplateSel Head; + typedef Templates3 Tail; +}; + +template +struct Templates5 { + typedef TemplateSel Head; + typedef Templates4 Tail; +}; + +template +struct Templates6 { + typedef TemplateSel Head; + typedef Templates5 Tail; +}; + +template +struct Templates7 { + typedef TemplateSel Head; + typedef Templates6 Tail; +}; + +template +struct Templates8 { + typedef TemplateSel Head; + typedef Templates7 Tail; +}; + +template +struct Templates9 { + typedef TemplateSel Head; + typedef Templates8 Tail; +}; + +template +struct Templates10 { + typedef TemplateSel Head; + typedef Templates9 Tail; +}; + +template +struct Templates11 { + typedef TemplateSel Head; + typedef Templates10 Tail; +}; + +template +struct Templates12 { + typedef TemplateSel Head; + typedef Templates11 Tail; +}; + +template +struct Templates13 { + typedef TemplateSel Head; + typedef Templates12 Tail; +}; + +template +struct Templates14 { + typedef TemplateSel Head; + typedef Templates13 Tail; +}; + +template +struct Templates15 { + typedef TemplateSel Head; + typedef Templates14 Tail; +}; + +template +struct Templates16 { + typedef TemplateSel Head; + typedef Templates15 Tail; +}; + +template +struct Templates17 { + typedef TemplateSel Head; + typedef Templates16 Tail; +}; + +template +struct Templates18 { + typedef TemplateSel Head; + typedef Templates17 Tail; +}; + +template +struct Templates19 { + typedef TemplateSel Head; + typedef Templates18 Tail; +}; + +template +struct Templates20 { + typedef TemplateSel Head; + typedef Templates19 Tail; +}; + +template +struct Templates21 { + typedef TemplateSel Head; + typedef Templates20 Tail; +}; + +template +struct Templates22 { + typedef TemplateSel Head; + typedef Templates21 Tail; +}; + +template +struct Templates23 { + typedef TemplateSel Head; + typedef Templates22 Tail; +}; + +template +struct Templates24 { + typedef TemplateSel Head; + typedef Templates23 Tail; +}; + +template +struct Templates25 { + typedef TemplateSel Head; + typedef Templates24 Tail; +}; + +template +struct Templates26 { + typedef TemplateSel Head; + typedef Templates25 Tail; +}; + +template +struct Templates27 { + typedef TemplateSel Head; + typedef Templates26 Tail; +}; + +template +struct Templates28 { + typedef TemplateSel Head; + typedef Templates27 Tail; +}; + +template +struct Templates29 { + typedef TemplateSel Head; + typedef Templates28 Tail; +}; + +template +struct Templates30 { + typedef TemplateSel Head; + typedef Templates29 Tail; +}; + +template +struct Templates31 { + typedef TemplateSel Head; + typedef Templates30 Tail; +}; + +template +struct Templates32 { + typedef TemplateSel Head; + typedef Templates31 Tail; +}; + +template +struct Templates33 { + typedef TemplateSel Head; + typedef Templates32 Tail; +}; + +template +struct Templates34 { + typedef TemplateSel Head; + typedef Templates33 Tail; +}; + +template +struct Templates35 { + typedef TemplateSel Head; + typedef Templates34 Tail; +}; + +template +struct Templates36 { + typedef TemplateSel Head; + typedef Templates35 Tail; +}; + +template +struct Templates37 { + typedef TemplateSel Head; + typedef Templates36 Tail; +}; + +template +struct Templates38 { + typedef TemplateSel Head; + typedef Templates37 Tail; +}; + +template +struct Templates39 { + typedef TemplateSel Head; + typedef Templates38 Tail; +}; + +template +struct Templates40 { + typedef TemplateSel Head; + typedef Templates39 Tail; +}; + +template +struct Templates41 { + typedef TemplateSel Head; + typedef Templates40 Tail; +}; + +template +struct Templates42 { + typedef TemplateSel Head; + typedef Templates41 Tail; +}; + +template +struct Templates43 { + typedef TemplateSel Head; + typedef Templates42 Tail; +}; + +template +struct Templates44 { + typedef TemplateSel Head; + typedef Templates43 Tail; +}; + +template +struct Templates45 { + typedef TemplateSel Head; + typedef Templates44 Tail; +}; + +template +struct Templates46 { + typedef TemplateSel Head; + typedef Templates45 Tail; +}; + +template +struct Templates47 { + typedef TemplateSel Head; + typedef Templates46 Tail; +}; + +template +struct Templates48 { + typedef TemplateSel Head; + typedef Templates47 Tail; +}; + +template +struct Templates49 { + typedef TemplateSel Head; + typedef Templates48 Tail; +}; + +template +struct Templates50 { + typedef TemplateSel Head; + typedef Templates49 Tail; +}; + + +// We don't want to require the users to write TemplatesN<...> directly, +// as that would require them to count the length. Templates<...> is much +// easier to write, but generates horrible messages when there is a +// compiler error, as gcc insists on printing out each template +// argument, even if it has the default value (this means Templates +// will appear as Templates in the compiler +// errors). +// +// Our solution is to combine the best part of the two approaches: a +// user would write Templates, and Google Test will translate +// that to TemplatesN internally to make error messages +// readable. The translation is done by the 'type' member of the +// Templates template. +template +struct Templates { + typedef Templates50 type; +}; + +template <> +struct Templates { + typedef Templates0 type; +}; +template +struct Templates { + typedef Templates1 type; +}; +template +struct Templates { + typedef Templates2 type; +}; +template +struct Templates { + typedef Templates3 type; +}; +template +struct Templates { + typedef Templates4 type; +}; +template +struct Templates { + typedef Templates5 type; +}; +template +struct Templates { + typedef Templates6 type; +}; +template +struct Templates { + typedef Templates7 type; +}; +template +struct Templates { + typedef Templates8 type; +}; +template +struct Templates { + typedef Templates9 type; +}; +template +struct Templates { + typedef Templates10 type; +}; +template +struct Templates { + typedef Templates11 type; +}; +template +struct Templates { + typedef Templates12 type; +}; +template +struct Templates { + typedef Templates13 type; +}; +template +struct Templates { + typedef Templates14 type; +}; +template +struct Templates { + typedef Templates15 type; +}; +template +struct Templates { + typedef Templates16 type; +}; +template +struct Templates { + typedef Templates17 type; +}; +template +struct Templates { + typedef Templates18 type; +}; +template +struct Templates { + typedef Templates19 type; +}; +template +struct Templates { + typedef Templates20 type; +}; +template +struct Templates { + typedef Templates21 type; +}; +template +struct Templates { + typedef Templates22 type; +}; +template +struct Templates { + typedef Templates23 type; +}; +template +struct Templates { + typedef Templates24 type; +}; +template +struct Templates { + typedef Templates25 type; +}; +template +struct Templates { + typedef Templates26 type; +}; +template +struct Templates { + typedef Templates27 type; +}; +template +struct Templates { + typedef Templates28 type; +}; +template +struct Templates { + typedef Templates29 type; +}; +template +struct Templates { + typedef Templates30 type; +}; +template +struct Templates { + typedef Templates31 type; +}; +template +struct Templates { + typedef Templates32 type; +}; +template +struct Templates { + typedef Templates33 type; +}; +template +struct Templates { + typedef Templates34 type; +}; +template +struct Templates { + typedef Templates35 type; +}; +template +struct Templates { + typedef Templates36 type; +}; +template +struct Templates { + typedef Templates37 type; +}; +template +struct Templates { + typedef Templates38 type; +}; +template +struct Templates { + typedef Templates39 type; +}; +template +struct Templates { + typedef Templates40 type; +}; +template +struct Templates { + typedef Templates41 type; +}; +template +struct Templates { + typedef Templates42 type; +}; +template +struct Templates { + typedef Templates43 type; +}; +template +struct Templates { + typedef Templates44 type; +}; +template +struct Templates { + typedef Templates45 type; +}; +template +struct Templates { + typedef Templates46 type; +}; +template +struct Templates { + typedef Templates47 type; +}; +template +struct Templates { + typedef Templates48 type; +}; +template +struct Templates { + typedef Templates49 type; +}; + +// The TypeList template makes it possible to use either a single type +// or a Types<...> list in TYPED_TEST_CASE() and +// INSTANTIATE_TYPED_TEST_CASE_P(). + +template +struct TypeList { + typedef Types1 type; +}; + +template +struct TypeList > { + typedef typename Types::type type; +}; + +#endif // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P + +} // namespace internal +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ + +// Due to C++ preprocessor weirdness, we need double indirection to +// concatenate two tokens when one of them is __LINE__. Writing +// +// foo ## __LINE__ +// +// will result in the token foo__LINE__, instead of foo followed by +// the current line number. For more details, see +// http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6 +#define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar) +#define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar + +class ProtocolMessage; +namespace proto2 { class Message; } + +namespace testing { + +// Forward declarations. + +class AssertionResult; // Result of an assertion. +class Message; // Represents a failure message. +class Test; // Represents a test. +class TestInfo; // Information about a test. +class TestPartResult; // Result of a test part. +class UnitTest; // A collection of test cases. + +template +::std::string PrintToString(const T& value); + +namespace internal { + +struct TraceInfo; // Information about a trace point. +class ScopedTrace; // Implements scoped trace. +class TestInfoImpl; // Opaque implementation of TestInfo +class UnitTestImpl; // Opaque implementation of UnitTest + +// How many times InitGoogleTest() has been called. +GTEST_API_ extern int g_init_gtest_count; + +// The text used in failure messages to indicate the start of the +// stack trace. +GTEST_API_ extern const char kStackTraceMarker[]; + +// Two overloaded helpers for checking at compile time whether an +// expression is a null pointer literal (i.e. NULL or any 0-valued +// compile-time integral constant). Their return values have +// different sizes, so we can use sizeof() to test which version is +// picked by the compiler. These helpers have no implementations, as +// we only need their signatures. +// +// Given IsNullLiteralHelper(x), the compiler will pick the first +// version if x can be implicitly converted to Secret*, and pick the +// second version otherwise. Since Secret is a secret and incomplete +// type, the only expression a user can write that has type Secret* is +// a null pointer literal. Therefore, we know that x is a null +// pointer literal if and only if the first version is picked by the +// compiler. +char IsNullLiteralHelper(Secret* p); +char (&IsNullLiteralHelper(...))[2]; // NOLINT + +// A compile-time bool constant that is true if and only if x is a +// null pointer literal (i.e. NULL or any 0-valued compile-time +// integral constant). +#ifdef GTEST_ELLIPSIS_NEEDS_POD_ +// We lose support for NULL detection where the compiler doesn't like +// passing non-POD classes through ellipsis (...). +# define GTEST_IS_NULL_LITERAL_(x) false +#else +# define GTEST_IS_NULL_LITERAL_(x) \ + (sizeof(::testing::internal::IsNullLiteralHelper(x)) == 1) +#endif // GTEST_ELLIPSIS_NEEDS_POD_ + +// Appends the user-supplied message to the Google-Test-generated message. +GTEST_API_ std::string AppendUserMessage( + const std::string& gtest_msg, const Message& user_msg); + +#if GTEST_HAS_EXCEPTIONS + +// This exception is thrown by (and only by) a failed Google Test +// assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions +// are enabled). We derive it from std::runtime_error, which is for +// errors presumably detectable only at run time. Since +// std::runtime_error inherits from std::exception, many testing +// frameworks know how to extract and print the message inside it. +class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error { + public: + explicit GoogleTestFailureException(const TestPartResult& failure); +}; + +#endif // GTEST_HAS_EXCEPTIONS + +// A helper class for creating scoped traces in user programs. +class GTEST_API_ ScopedTrace { + public: + // The c'tor pushes the given source file location and message onto + // a trace stack maintained by Google Test. + ScopedTrace(const char* file, int line, const Message& message); + + // The d'tor pops the info pushed by the c'tor. + // + // Note that the d'tor is not virtual in order to be efficient. + // Don't inherit from ScopedTrace! + ~ScopedTrace(); + + private: + GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace); +} GTEST_ATTRIBUTE_UNUSED_; // A ScopedTrace object does its job in its + // c'tor and d'tor. Therefore it doesn't + // need to be used otherwise. + +// Constructs and returns the message for an equality assertion +// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure. +// +// The first four parameters are the expressions used in the assertion +// and their values, as strings. For example, for ASSERT_EQ(foo, bar) +// where foo is 5 and bar is 6, we have: +// +// expected_expression: "foo" +// actual_expression: "bar" +// expected_value: "5" +// actual_value: "6" +// +// The ignoring_case parameter is true iff the assertion is a +// *_STRCASEEQ*. When it's true, the string " (ignoring case)" will +// be inserted into the message. +GTEST_API_ AssertionResult EqFailure(const char* expected_expression, + const char* actual_expression, + const std::string& expected_value, + const std::string& actual_value, + bool ignoring_case); + +// Constructs a failure message for Boolean assertions such as EXPECT_TRUE. +GTEST_API_ std::string GetBoolAssertionFailureMessage( + const AssertionResult& assertion_result, + const char* expression_text, + const char* actual_predicate_value, + const char* expected_predicate_value); + +// This template class represents an IEEE floating-point number +// (either single-precision or double-precision, depending on the +// template parameters). +// +// The purpose of this class is to do more sophisticated number +// comparison. (Due to round-off error, etc, it's very unlikely that +// two floating-points will be equal exactly. Hence a naive +// comparison by the == operation often doesn't work.) +// +// Format of IEEE floating-point: +// +// The most-significant bit being the leftmost, an IEEE +// floating-point looks like +// +// sign_bit exponent_bits fraction_bits +// +// Here, sign_bit is a single bit that designates the sign of the +// number. +// +// For float, there are 8 exponent bits and 23 fraction bits. +// +// For double, there are 11 exponent bits and 52 fraction bits. +// +// More details can be found at +// http://en.wikipedia.org/wiki/IEEE_floating-point_standard. +// +// Template parameter: +// +// RawType: the raw floating-point type (either float or double) +template +class FloatingPoint { + public: + // Defines the unsigned integer type that has the same size as the + // floating point number. + typedef typename TypeWithSize::UInt Bits; + + // Constants. + + // # of bits in a number. + static const size_t kBitCount = 8*sizeof(RawType); + + // # of fraction bits in a number. + static const size_t kFractionBitCount = + std::numeric_limits::digits - 1; + + // # of exponent bits in a number. + static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount; + + // The mask for the sign bit. + static const Bits kSignBitMask = static_cast(1) << (kBitCount - 1); + + // The mask for the fraction bits. + static const Bits kFractionBitMask = + ~static_cast(0) >> (kExponentBitCount + 1); + + // The mask for the exponent bits. + static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask); + + // How many ULP's (Units in the Last Place) we want to tolerate when + // comparing two numbers. The larger the value, the more error we + // allow. A 0 value means that two numbers must be exactly the same + // to be considered equal. + // + // The maximum error of a single floating-point operation is 0.5 + // units in the last place. On Intel CPU's, all floating-point + // calculations are done with 80-bit precision, while double has 64 + // bits. Therefore, 4 should be enough for ordinary use. + // + // See the following article for more details on ULP: + // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/ + static const size_t kMaxUlps = 4; + + // Constructs a FloatingPoint from a raw floating-point number. + // + // On an Intel CPU, passing a non-normalized NAN (Not a Number) + // around may change its bits, although the new value is guaranteed + // to be also a NAN. Therefore, don't expect this constructor to + // preserve the bits in x when x is a NAN. + explicit FloatingPoint(const RawType& x) { u_.value_ = x; } + + // Static methods + + // Reinterprets a bit pattern as a floating-point number. + // + // This function is needed to test the AlmostEquals() method. + static RawType ReinterpretBits(const Bits bits) { + FloatingPoint fp(0); + fp.u_.bits_ = bits; + return fp.u_.value_; + } + + // Returns the floating-point number that represent positive infinity. + static RawType Infinity() { + return ReinterpretBits(kExponentBitMask); + } + + // Returns the maximum representable finite floating-point number. + static RawType Max(); + + // Non-static methods + + // Returns the bits that represents this number. + const Bits &bits() const { return u_.bits_; } + + // Returns the exponent bits of this number. + Bits exponent_bits() const { return kExponentBitMask & u_.bits_; } + + // Returns the fraction bits of this number. + Bits fraction_bits() const { return kFractionBitMask & u_.bits_; } + + // Returns the sign bit of this number. + Bits sign_bit() const { return kSignBitMask & u_.bits_; } + + // Returns true iff this is NAN (not a number). + bool is_nan() const { + // It's a NAN if the exponent bits are all ones and the fraction + // bits are not entirely zeros. + return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0); + } + + // Returns true iff this number is at most kMaxUlps ULP's away from + // rhs. In particular, this function: + // + // - returns false if either number is (or both are) NAN. + // - treats really large numbers as almost equal to infinity. + // - thinks +0.0 and -0.0 are 0 DLP's apart. + bool AlmostEquals(const FloatingPoint& rhs) const { + // The IEEE standard says that any comparison operation involving + // a NAN must return false. + if (is_nan() || rhs.is_nan()) return false; + + return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_) + <= kMaxUlps; + } + + private: + // The data type used to store the actual floating-point number. + union FloatingPointUnion { + RawType value_; // The raw floating-point number. + Bits bits_; // The bits that represent the number. + }; + + // Converts an integer from the sign-and-magnitude representation to + // the biased representation. More precisely, let N be 2 to the + // power of (kBitCount - 1), an integer x is represented by the + // unsigned number x + N. + // + // For instance, + // + // -N + 1 (the most negative number representable using + // sign-and-magnitude) is represented by 1; + // 0 is represented by N; and + // N - 1 (the biggest number representable using + // sign-and-magnitude) is represented by 2N - 1. + // + // Read http://en.wikipedia.org/wiki/Signed_number_representations + // for more details on signed number representations. + static Bits SignAndMagnitudeToBiased(const Bits &sam) { + if (kSignBitMask & sam) { + // sam represents a negative number. + return ~sam + 1; + } else { + // sam represents a positive number. + return kSignBitMask | sam; + } + } + + // Given two numbers in the sign-and-magnitude representation, + // returns the distance between them as an unsigned number. + static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1, + const Bits &sam2) { + const Bits biased1 = SignAndMagnitudeToBiased(sam1); + const Bits biased2 = SignAndMagnitudeToBiased(sam2); + return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1); + } + + FloatingPointUnion u_; +}; + +// We cannot use std::numeric_limits::max() as it clashes with the max() +// macro defined by . +template <> +inline float FloatingPoint::Max() { return FLT_MAX; } +template <> +inline double FloatingPoint::Max() { return DBL_MAX; } + +// Typedefs the instances of the FloatingPoint template class that we +// care to use. +typedef FloatingPoint Float; +typedef FloatingPoint Double; + +// In order to catch the mistake of putting tests that use different +// test fixture classes in the same test case, we need to assign +// unique IDs to fixture classes and compare them. The TypeId type is +// used to hold such IDs. The user should treat TypeId as an opaque +// type: the only operation allowed on TypeId values is to compare +// them for equality using the == operator. +typedef const void* TypeId; + +template +class TypeIdHelper { + public: + // dummy_ must not have a const type. Otherwise an overly eager + // compiler (e.g. MSVC 7.1 & 8.0) may try to merge + // TypeIdHelper::dummy_ for different Ts as an "optimization". + static bool dummy_; +}; + +template +bool TypeIdHelper::dummy_ = false; + +// GetTypeId() returns the ID of type T. Different values will be +// returned for different types. Calling the function twice with the +// same type argument is guaranteed to return the same ID. +template +TypeId GetTypeId() { + // The compiler is required to allocate a different + // TypeIdHelper::dummy_ variable for each T used to instantiate + // the template. Therefore, the address of dummy_ is guaranteed to + // be unique. + return &(TypeIdHelper::dummy_); +} + +// Returns the type ID of ::testing::Test. Always call this instead +// of GetTypeId< ::testing::Test>() to get the type ID of +// ::testing::Test, as the latter may give the wrong result due to a +// suspected linker bug when compiling Google Test as a Mac OS X +// framework. +GTEST_API_ TypeId GetTestTypeId(); + +// Defines the abstract factory interface that creates instances +// of a Test object. +class TestFactoryBase { + public: + virtual ~TestFactoryBase() {} + + // Creates a test instance to run. The instance is both created and destroyed + // within TestInfoImpl::Run() + virtual Test* CreateTest() = 0; + + protected: + TestFactoryBase() {} + + private: + GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase); +}; + +// This class provides implementation of TeastFactoryBase interface. +// It is used in TEST and TEST_F macros. +template +class TestFactoryImpl : public TestFactoryBase { + public: + virtual Test* CreateTest() { return new TestClass; } +}; + +#if GTEST_OS_WINDOWS + +// Predicate-formatters for implementing the HRESULT checking macros +// {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED} +// We pass a long instead of HRESULT to avoid causing an +// include dependency for the HRESULT type. +GTEST_API_ AssertionResult IsHRESULTSuccess(const char* expr, + long hr); // NOLINT +GTEST_API_ AssertionResult IsHRESULTFailure(const char* expr, + long hr); // NOLINT + +#endif // GTEST_OS_WINDOWS + +// Types of SetUpTestCase() and TearDownTestCase() functions. +typedef void (*SetUpTestCaseFunc)(); +typedef void (*TearDownTestCaseFunc)(); + +// Creates a new TestInfo object and registers it with Google Test; +// returns the created object. +// +// Arguments: +// +// test_case_name: name of the test case +// name: name of the test +// type_param the name of the test's type parameter, or NULL if +// this is not a typed or a type-parameterized test. +// value_param text representation of the test's value parameter, +// or NULL if this is not a type-parameterized test. +// fixture_class_id: ID of the test fixture class +// set_up_tc: pointer to the function that sets up the test case +// tear_down_tc: pointer to the function that tears down the test case +// factory: pointer to the factory that creates a test object. +// The newly created TestInfo instance will assume +// ownership of the factory object. +GTEST_API_ TestInfo* MakeAndRegisterTestInfo( + const char* test_case_name, + const char* name, + const char* type_param, + const char* value_param, + TypeId fixture_class_id, + SetUpTestCaseFunc set_up_tc, + TearDownTestCaseFunc tear_down_tc, + TestFactoryBase* factory); + +// If *pstr starts with the given prefix, modifies *pstr to be right +// past the prefix and returns true; otherwise leaves *pstr unchanged +// and returns false. None of pstr, *pstr, and prefix can be NULL. +GTEST_API_ bool SkipPrefix(const char* prefix, const char** pstr); + +#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P + +// State of the definition of a type-parameterized test case. +class GTEST_API_ TypedTestCasePState { + public: + TypedTestCasePState() : registered_(false) {} + + // Adds the given test name to defined_test_names_ and return true + // if the test case hasn't been registered; otherwise aborts the + // program. + bool AddTestName(const char* file, int line, const char* case_name, + const char* test_name) { + if (registered_) { + fprintf(stderr, "%s Test %s must be defined before " + "REGISTER_TYPED_TEST_CASE_P(%s, ...).\n", + FormatFileLocation(file, line).c_str(), test_name, case_name); + fflush(stderr); + posix::Abort(); + } + defined_test_names_.insert(test_name); + return true; + } + + // Verifies that registered_tests match the test names in + // defined_test_names_; returns registered_tests if successful, or + // aborts the program otherwise. + const char* VerifyRegisteredTestNames( + const char* file, int line, const char* registered_tests); + + private: + bool registered_; + ::std::set defined_test_names_; +}; + +// Skips to the first non-space char after the first comma in 'str'; +// returns NULL if no comma is found in 'str'. +inline const char* SkipComma(const char* str) { + const char* comma = strchr(str, ','); + if (comma == NULL) { + return NULL; + } + while (IsSpace(*(++comma))) {} + return comma; +} + +// Returns the prefix of 'str' before the first comma in it; returns +// the entire string if it contains no comma. +inline std::string GetPrefixUntilComma(const char* str) { + const char* comma = strchr(str, ','); + return comma == NULL ? str : std::string(str, comma); +} + +// TypeParameterizedTest::Register() +// registers a list of type-parameterized tests with Google Test. The +// return value is insignificant - we just need to return something +// such that we can call this function in a namespace scope. +// +// Implementation note: The GTEST_TEMPLATE_ macro declares a template +// template parameter. It's defined in gtest-type-util.h. +template +class TypeParameterizedTest { + public: + // 'index' is the index of the test in the type list 'Types' + // specified in INSTANTIATE_TYPED_TEST_CASE_P(Prefix, TestCase, + // Types). Valid values for 'index' are [0, N - 1] where N is the + // length of Types. + static bool Register(const char* prefix, const char* case_name, + const char* test_names, int index) { + typedef typename Types::Head Type; + typedef Fixture FixtureClass; + typedef typename GTEST_BIND_(TestSel, Type) TestClass; + + // First, registers the first type-parameterized test in the type + // list. + MakeAndRegisterTestInfo( + (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name + "/" + + StreamableToString(index)).c_str(), + GetPrefixUntilComma(test_names).c_str(), + GetTypeName().c_str(), + NULL, // No value parameter. + GetTypeId(), + TestClass::SetUpTestCase, + TestClass::TearDownTestCase, + new TestFactoryImpl); + + // Next, recurses (at compile time) with the tail of the type list. + return TypeParameterizedTest + ::Register(prefix, case_name, test_names, index + 1); + } +}; + +// The base case for the compile time recursion. +template +class TypeParameterizedTest { + public: + static bool Register(const char* /*prefix*/, const char* /*case_name*/, + const char* /*test_names*/, int /*index*/) { + return true; + } +}; + +// TypeParameterizedTestCase::Register() +// registers *all combinations* of 'Tests' and 'Types' with Google +// Test. The return value is insignificant - we just need to return +// something such that we can call this function in a namespace scope. +template +class TypeParameterizedTestCase { + public: + static bool Register(const char* prefix, const char* case_name, + const char* test_names) { + typedef typename Tests::Head Head; + + // First, register the first test in 'Test' for each type in 'Types'. + TypeParameterizedTest::Register( + prefix, case_name, test_names, 0); + + // Next, recurses (at compile time) with the tail of the test list. + return TypeParameterizedTestCase + ::Register(prefix, case_name, SkipComma(test_names)); + } +}; + +// The base case for the compile time recursion. +template +class TypeParameterizedTestCase { + public: + static bool Register(const char* /*prefix*/, const char* /*case_name*/, + const char* /*test_names*/) { + return true; + } +}; + +#endif // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P + +// Returns the current OS stack trace as an std::string. +// +// The maximum number of stack frames to be included is specified by +// the gtest_stack_trace_depth flag. The skip_count parameter +// specifies the number of top frames to be skipped, which doesn't +// count against the number of frames to be included. +// +// For example, if Foo() calls Bar(), which in turn calls +// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in +// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't. +GTEST_API_ std::string GetCurrentOsStackTraceExceptTop( + UnitTest* unit_test, int skip_count); + +// Helpers for suppressing warnings on unreachable code or constant +// condition. + +// Always returns true. +GTEST_API_ bool AlwaysTrue(); + +// Always returns false. +inline bool AlwaysFalse() { return !AlwaysTrue(); } + +// Helper for suppressing false warning from Clang on a const char* +// variable declared in a conditional expression always being NULL in +// the else branch. +struct GTEST_API_ ConstCharPtr { + ConstCharPtr(const char* str) : value(str) {} + operator bool() const { return true; } + const char* value; +}; + +// A simple Linear Congruential Generator for generating random +// numbers with a uniform distribution. Unlike rand() and srand(), it +// doesn't use global state (and therefore can't interfere with user +// code). Unlike rand_r(), it's portable. An LCG isn't very random, +// but it's good enough for our purposes. +class GTEST_API_ Random { + public: + static const UInt32 kMaxRange = 1u << 31; + + explicit Random(UInt32 seed) : state_(seed) {} + + void Reseed(UInt32 seed) { state_ = seed; } + + // Generates a random number from [0, range). Crashes if 'range' is + // 0 or greater than kMaxRange. + UInt32 Generate(UInt32 range); + + private: + UInt32 state_; + GTEST_DISALLOW_COPY_AND_ASSIGN_(Random); +}; + +// Defining a variable of type CompileAssertTypesEqual will cause a +// compiler error iff T1 and T2 are different types. +template +struct CompileAssertTypesEqual; + +template +struct CompileAssertTypesEqual { +}; + +// Removes the reference from a type if it is a reference type, +// otherwise leaves it unchanged. This is the same as +// tr1::remove_reference, which is not widely available yet. +template +struct RemoveReference { typedef T type; }; // NOLINT +template +struct RemoveReference { typedef T type; }; // NOLINT + +// A handy wrapper around RemoveReference that works when the argument +// T depends on template parameters. +#define GTEST_REMOVE_REFERENCE_(T) \ + typename ::testing::internal::RemoveReference::type + +// Removes const from a type if it is a const type, otherwise leaves +// it unchanged. This is the same as tr1::remove_const, which is not +// widely available yet. +template +struct RemoveConst { typedef T type; }; // NOLINT +template +struct RemoveConst { typedef T type; }; // NOLINT + +// MSVC 8.0, Sun C++, and IBM XL C++ have a bug which causes the above +// definition to fail to remove the const in 'const int[3]' and 'const +// char[3][4]'. The following specialization works around the bug. +template +struct RemoveConst { + typedef typename RemoveConst::type type[N]; +}; + +#if defined(_MSC_VER) && _MSC_VER < 1400 +// This is the only specialization that allows VC++ 7.1 to remove const in +// 'const int[3] and 'const int[3][4]'. However, it causes trouble with GCC +// and thus needs to be conditionally compiled. +template +struct RemoveConst { + typedef typename RemoveConst::type type[N]; +}; +#endif + +// A handy wrapper around RemoveConst that works when the argument +// T depends on template parameters. +#define GTEST_REMOVE_CONST_(T) \ + typename ::testing::internal::RemoveConst::type + +// Turns const U&, U&, const U, and U all into U. +#define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \ + GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T)) + +// Adds reference to a type if it is not a reference type, +// otherwise leaves it unchanged. This is the same as +// tr1::add_reference, which is not widely available yet. +template +struct AddReference { typedef T& type; }; // NOLINT +template +struct AddReference { typedef T& type; }; // NOLINT + +// A handy wrapper around AddReference that works when the argument T +// depends on template parameters. +#define GTEST_ADD_REFERENCE_(T) \ + typename ::testing::internal::AddReference::type + +// Adds a reference to const on top of T as necessary. For example, +// it transforms +// +// char ==> const char& +// const char ==> const char& +// char& ==> const char& +// const char& ==> const char& +// +// The argument T must depend on some template parameters. +#define GTEST_REFERENCE_TO_CONST_(T) \ + GTEST_ADD_REFERENCE_(const GTEST_REMOVE_REFERENCE_(T)) + +// ImplicitlyConvertible::value is a compile-time bool +// constant that's true iff type From can be implicitly converted to +// type To. +template +class ImplicitlyConvertible { + private: + // We need the following helper functions only for their types. + // They have no implementations. + + // MakeFrom() is an expression whose type is From. We cannot simply + // use From(), as the type From may not have a public default + // constructor. + static From MakeFrom(); + + // These two functions are overloaded. Given an expression + // Helper(x), the compiler will pick the first version if x can be + // implicitly converted to type To; otherwise it will pick the + // second version. + // + // The first version returns a value of size 1, and the second + // version returns a value of size 2. Therefore, by checking the + // size of Helper(x), which can be done at compile time, we can tell + // which version of Helper() is used, and hence whether x can be + // implicitly converted to type To. + static char Helper(To); + static char (&Helper(...))[2]; // NOLINT + + // We have to put the 'public' section after the 'private' section, + // or MSVC refuses to compile the code. + public: + // MSVC warns about implicitly converting from double to int for + // possible loss of data, so we need to temporarily disable the + // warning. +#ifdef _MSC_VER +# pragma warning(push) // Saves the current warning state. +# pragma warning(disable:4244) // Temporarily disables warning 4244. + + static const bool value = + sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1; +# pragma warning(pop) // Restores the warning state. +#elif defined(__BORLANDC__) + // C++Builder cannot use member overload resolution during template + // instantiation. The simplest workaround is to use its C++0x type traits + // functions (C++Builder 2009 and above only). + static const bool value = __is_convertible(From, To); +#else + static const bool value = + sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1; +#endif // _MSV_VER +}; +template +const bool ImplicitlyConvertible::value; + +// IsAProtocolMessage::value is a compile-time bool constant that's +// true iff T is type ProtocolMessage, proto2::Message, or a subclass +// of those. +template +struct IsAProtocolMessage + : public bool_constant< + ImplicitlyConvertible::value || + ImplicitlyConvertible::value> { +}; + +// When the compiler sees expression IsContainerTest(0), if C is an +// STL-style container class, the first overload of IsContainerTest +// will be viable (since both C::iterator* and C::const_iterator* are +// valid types and NULL can be implicitly converted to them). It will +// be picked over the second overload as 'int' is a perfect match for +// the type of argument 0. If C::iterator or C::const_iterator is not +// a valid type, the first overload is not viable, and the second +// overload will be picked. Therefore, we can determine whether C is +// a container class by checking the type of IsContainerTest(0). +// The value of the expression is insignificant. +// +// Note that we look for both C::iterator and C::const_iterator. The +// reason is that C++ injects the name of a class as a member of the +// class itself (e.g. you can refer to class iterator as either +// 'iterator' or 'iterator::iterator'). If we look for C::iterator +// only, for example, we would mistakenly think that a class named +// iterator is an STL container. +// +// Also note that the simpler approach of overloading +// IsContainerTest(typename C::const_iterator*) and +// IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++. +typedef int IsContainer; +template +IsContainer IsContainerTest(int /* dummy */, + typename C::iterator* /* it */ = NULL, + typename C::const_iterator* /* const_it */ = NULL) { + return 0; +} + +typedef char IsNotContainer; +template +IsNotContainer IsContainerTest(long /* dummy */) { return '\0'; } + +// EnableIf::type is void when 'Cond' is true, and +// undefined when 'Cond' is false. To use SFINAE to make a function +// overload only apply when a particular expression is true, add +// "typename EnableIf::type* = 0" as the last parameter. +template struct EnableIf; +template<> struct EnableIf { typedef void type; }; // NOLINT + +// Utilities for native arrays. + +// ArrayEq() compares two k-dimensional native arrays using the +// elements' operator==, where k can be any integer >= 0. When k is +// 0, ArrayEq() degenerates into comparing a single pair of values. + +template +bool ArrayEq(const T* lhs, size_t size, const U* rhs); + +// This generic version is used when k is 0. +template +inline bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; } + +// This overload is used when k >= 1. +template +inline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) { + return internal::ArrayEq(lhs, N, rhs); +} + +// This helper reduces code bloat. If we instead put its logic inside +// the previous ArrayEq() function, arrays with different sizes would +// lead to different copies of the template code. +template +bool ArrayEq(const T* lhs, size_t size, const U* rhs) { + for (size_t i = 0; i != size; i++) { + if (!internal::ArrayEq(lhs[i], rhs[i])) + return false; + } + return true; +} + +// Finds the first element in the iterator range [begin, end) that +// equals elem. Element may be a native array type itself. +template +Iter ArrayAwareFind(Iter begin, Iter end, const Element& elem) { + for (Iter it = begin; it != end; ++it) { + if (internal::ArrayEq(*it, elem)) + return it; + } + return end; +} + +// CopyArray() copies a k-dimensional native array using the elements' +// operator=, where k can be any integer >= 0. When k is 0, +// CopyArray() degenerates into copying a single value. + +template +void CopyArray(const T* from, size_t size, U* to); + +// This generic version is used when k is 0. +template +inline void CopyArray(const T& from, U* to) { *to = from; } + +// This overload is used when k >= 1. +template +inline void CopyArray(const T(&from)[N], U(*to)[N]) { + internal::CopyArray(from, N, *to); +} + +// This helper reduces code bloat. If we instead put its logic inside +// the previous CopyArray() function, arrays with different sizes +// would lead to different copies of the template code. +template +void CopyArray(const T* from, size_t size, U* to) { + for (size_t i = 0; i != size; i++) { + internal::CopyArray(from[i], to + i); + } +} + +// The relation between an NativeArray object (see below) and the +// native array it represents. +enum RelationToSource { + kReference, // The NativeArray references the native array. + kCopy // The NativeArray makes a copy of the native array and + // owns the copy. +}; + +// Adapts a native array to a read-only STL-style container. Instead +// of the complete STL container concept, this adaptor only implements +// members useful for Google Mock's container matchers. New members +// should be added as needed. To simplify the implementation, we only +// support Element being a raw type (i.e. having no top-level const or +// reference modifier). It's the client's responsibility to satisfy +// this requirement. Element can be an array type itself (hence +// multi-dimensional arrays are supported). +template +class NativeArray { + public: + // STL-style container typedefs. + typedef Element value_type; + typedef Element* iterator; + typedef const Element* const_iterator; + + // Constructs from a native array. + NativeArray(const Element* array, size_t count, RelationToSource relation) { + Init(array, count, relation); + } + + // Copy constructor. + NativeArray(const NativeArray& rhs) { + Init(rhs.array_, rhs.size_, rhs.relation_to_source_); + } + + ~NativeArray() { + // Ensures that the user doesn't instantiate NativeArray with a + // const or reference type. + static_cast(StaticAssertTypeEqHelper()); + if (relation_to_source_ == kCopy) + delete[] array_; + } + + // STL-style container methods. + size_t size() const { return size_; } + const_iterator begin() const { return array_; } + const_iterator end() const { return array_ + size_; } + bool operator==(const NativeArray& rhs) const { + return size() == rhs.size() && + ArrayEq(begin(), size(), rhs.begin()); + } + + private: + // Initializes this object; makes a copy of the input array if + // 'relation' is kCopy. + void Init(const Element* array, size_t a_size, RelationToSource relation) { + if (relation == kReference) { + array_ = array; + } else { + Element* const copy = new Element[a_size]; + CopyArray(array, a_size, copy); + array_ = copy; + } + size_ = a_size; + relation_to_source_ = relation; + } + + const Element* array_; + size_t size_; + RelationToSource relation_to_source_; + + GTEST_DISALLOW_ASSIGN_(NativeArray); +}; + +} // namespace internal +} // namespace testing + +#define GTEST_MESSAGE_AT_(file, line, message, result_type) \ + ::testing::internal::AssertHelper(result_type, file, line, message) \ + = ::testing::Message() + +#define GTEST_MESSAGE_(message, result_type) \ + GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type) + +#define GTEST_FATAL_FAILURE_(message) \ + return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure) + +#define GTEST_NONFATAL_FAILURE_(message) \ + GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure) + +#define GTEST_SUCCESS_(message) \ + GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess) + +// Suppresses MSVC warnings 4072 (unreachable code) for the code following +// statement if it returns or throws (or doesn't return or throw in some +// situations). +#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \ + if (::testing::internal::AlwaysTrue()) { statement; } + +#define GTEST_TEST_THROW_(statement, expected_exception, fail) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (::testing::internal::ConstCharPtr gtest_msg = "") { \ + bool gtest_caught_expected = false; \ + try { \ + GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ + } \ + catch (expected_exception const&) { \ + gtest_caught_expected = true; \ + } \ + catch (...) { \ + gtest_msg.value = \ + "Expected: " #statement " throws an exception of type " \ + #expected_exception ".\n Actual: it throws a different type."; \ + goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \ + } \ + if (!gtest_caught_expected) { \ + gtest_msg.value = \ + "Expected: " #statement " throws an exception of type " \ + #expected_exception ".\n Actual: it throws nothing."; \ + goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \ + } \ + } else \ + GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__): \ + fail(gtest_msg.value) + +#define GTEST_TEST_NO_THROW_(statement, fail) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (::testing::internal::AlwaysTrue()) { \ + try { \ + GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ + } \ + catch (...) { \ + goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \ + } \ + } else \ + GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \ + fail("Expected: " #statement " doesn't throw an exception.\n" \ + " Actual: it throws.") + +#define GTEST_TEST_ANY_THROW_(statement, fail) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (::testing::internal::AlwaysTrue()) { \ + bool gtest_caught_any = false; \ + try { \ + GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ + } \ + catch (...) { \ + gtest_caught_any = true; \ + } \ + if (!gtest_caught_any) { \ + goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \ + } \ + } else \ + GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \ + fail("Expected: " #statement " throws an exception.\n" \ + " Actual: it doesn't.") + + +// Implements Boolean test assertions such as EXPECT_TRUE. expression can be +// either a boolean expression or an AssertionResult. text is a textual +// represenation of expression as it was passed into the EXPECT_TRUE. +#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (const ::testing::AssertionResult gtest_ar_ = \ + ::testing::AssertionResult(expression)) \ + ; \ + else \ + fail(::testing::internal::GetBoolAssertionFailureMessage(\ + gtest_ar_, text, #actual, #expected).c_str()) + +#define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (::testing::internal::AlwaysTrue()) { \ + ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \ + GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ + if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \ + goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \ + } \ + } else \ + GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \ + fail("Expected: " #statement " doesn't generate new fatal " \ + "failures in the current thread.\n" \ + " Actual: it does.") + +// Expands to the name of the class that implements the given test. +#define GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \ + test_case_name##_##test_name##_Test + +// Helper macro for defining tests. +#define GTEST_TEST_(test_case_name, test_name, parent_class, parent_id)\ +class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public parent_class {\ + public:\ + GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {}\ + private:\ + virtual void TestBody();\ + static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;\ + GTEST_DISALLOW_COPY_AND_ASSIGN_(\ + GTEST_TEST_CLASS_NAME_(test_case_name, test_name));\ +};\ +\ +::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_case_name, test_name)\ + ::test_info_ =\ + ::testing::internal::MakeAndRegisterTestInfo(\ + #test_case_name, #test_name, NULL, NULL, \ + (parent_id), \ + parent_class::SetUpTestCase, \ + parent_class::TearDownTestCase, \ + new ::testing::internal::TestFactoryImpl<\ + GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>);\ +void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody() + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ +// 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) +// +// This header file defines the public API for death tests. It is +// #included by gtest.h so a user doesn't need to include this +// directly. + +#ifndef GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ +#define GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ + +// 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. +// +// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee) +// +// The Google C++ Testing Framework (Google Test) +// +// This header file defines internal utilities needed for implementing +// death tests. They are subject to change without notice. + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_ + + +#include + +namespace testing { +namespace internal { + +GTEST_DECLARE_string_(internal_run_death_test); + +// Names of the flags (needed for parsing Google Test flags). +const char kDeathTestStyleFlag[] = "death_test_style"; +const char kDeathTestUseFork[] = "death_test_use_fork"; +const char kInternalRunDeathTestFlag[] = "internal_run_death_test"; + +#if GTEST_HAS_DEATH_TEST + +// DeathTest is a class that hides much of the complexity of the +// GTEST_DEATH_TEST_ macro. It is abstract; its static Create method +// returns a concrete class that depends on the prevailing death test +// style, as defined by the --gtest_death_test_style and/or +// --gtest_internal_run_death_test flags. + +// In describing the results of death tests, these terms are used with +// the corresponding definitions: +// +// exit status: The integer exit information in the format specified +// by wait(2) +// exit code: The integer code passed to exit(3), _exit(2), or +// returned from main() +class GTEST_API_ DeathTest { + public: + // Create returns false if there was an error determining the + // appropriate action to take for the current death test; for example, + // if the gtest_death_test_style flag is set to an invalid value. + // The LastMessage method will return a more detailed message in that + // case. Otherwise, the DeathTest pointer pointed to by the "test" + // argument is set. If the death test should be skipped, the pointer + // is set to NULL; otherwise, it is set to the address of a new concrete + // DeathTest object that controls the execution of the current test. + static bool Create(const char* statement, const RE* regex, + const char* file, int line, DeathTest** test); + DeathTest(); + virtual ~DeathTest() { } + + // A helper class that aborts a death test when it's deleted. + class ReturnSentinel { + public: + explicit ReturnSentinel(DeathTest* test) : test_(test) { } + ~ReturnSentinel() { test_->Abort(TEST_ENCOUNTERED_RETURN_STATEMENT); } + private: + DeathTest* const test_; + GTEST_DISALLOW_COPY_AND_ASSIGN_(ReturnSentinel); + } GTEST_ATTRIBUTE_UNUSED_; + + // An enumeration of possible roles that may be taken when a death + // test is encountered. EXECUTE means that the death test logic should + // be executed immediately. OVERSEE means that the program should prepare + // the appropriate environment for a child process to execute the death + // test, then wait for it to complete. + enum TestRole { OVERSEE_TEST, EXECUTE_TEST }; + + // An enumeration of the three reasons that a test might be aborted. + enum AbortReason { + TEST_ENCOUNTERED_RETURN_STATEMENT, + TEST_THREW_EXCEPTION, + TEST_DID_NOT_DIE + }; + + // Assumes one of the above roles. + virtual TestRole AssumeRole() = 0; + + // Waits for the death test to finish and returns its status. + virtual int Wait() = 0; + + // Returns true if the death test passed; that is, the test process + // exited during the test, its exit status matches a user-supplied + // predicate, and its stderr output matches a user-supplied regular + // expression. + // The user-supplied predicate may be a macro expression rather + // than a function pointer or functor, or else Wait and Passed could + // be combined. + virtual bool Passed(bool exit_status_ok) = 0; + + // Signals that the death test did not die as expected. + virtual void Abort(AbortReason reason) = 0; + + // Returns a human-readable outcome message regarding the outcome of + // the last death test. + static const char* LastMessage(); + + static void set_last_death_test_message(const std::string& message); + + private: + // A string containing a description of the outcome of the last death test. + static std::string last_death_test_message_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest); +}; + +// Factory interface for death tests. May be mocked out for testing. +class DeathTestFactory { + public: + virtual ~DeathTestFactory() { } + virtual bool Create(const char* statement, const RE* regex, + const char* file, int line, DeathTest** test) = 0; +}; + +// A concrete DeathTestFactory implementation for normal use. +class DefaultDeathTestFactory : public DeathTestFactory { + public: + virtual bool Create(const char* statement, const RE* regex, + const char* file, int line, DeathTest** test); +}; + +// Returns true if exit_status describes a process that was terminated +// by a signal, or exited normally with a nonzero exit code. +GTEST_API_ bool ExitedUnsuccessfully(int exit_status); + +// Traps C++ exceptions escaping statement and reports them as test +// failures. Note that trapping SEH exceptions is not implemented here. +# if GTEST_HAS_EXCEPTIONS +# define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \ + try { \ + GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ + } catch (const ::std::exception& gtest_exception) { \ + fprintf(\ + stderr, \ + "\n%s: Caught std::exception-derived exception escaping the " \ + "death test statement. Exception message: %s\n", \ + ::testing::internal::FormatFileLocation(__FILE__, __LINE__).c_str(), \ + gtest_exception.what()); \ + fflush(stderr); \ + death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \ + } catch (...) { \ + death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \ + } + +# else +# define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \ + GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) + +# endif + +// This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*, +// ASSERT_EXIT*, and EXPECT_EXIT*. +# define GTEST_DEATH_TEST_(statement, predicate, regex, fail) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (::testing::internal::AlwaysTrue()) { \ + const ::testing::internal::RE& gtest_regex = (regex); \ + ::testing::internal::DeathTest* gtest_dt; \ + if (!::testing::internal::DeathTest::Create(#statement, >est_regex, \ + __FILE__, __LINE__, >est_dt)) { \ + goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \ + } \ + if (gtest_dt != NULL) { \ + ::testing::internal::scoped_ptr< ::testing::internal::DeathTest> \ + gtest_dt_ptr(gtest_dt); \ + switch (gtest_dt->AssumeRole()) { \ + case ::testing::internal::DeathTest::OVERSEE_TEST: \ + if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) { \ + goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \ + } \ + break; \ + case ::testing::internal::DeathTest::EXECUTE_TEST: { \ + ::testing::internal::DeathTest::ReturnSentinel \ + gtest_sentinel(gtest_dt); \ + GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt); \ + gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE); \ + break; \ + } \ + default: \ + break; \ + } \ + } \ + } else \ + GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__): \ + fail(::testing::internal::DeathTest::LastMessage()) +// The symbol "fail" here expands to something into which a message +// can be streamed. + +// This macro is for implementing ASSERT/EXPECT_DEBUG_DEATH when compiled in +// NDEBUG mode. In this case we need the statements to be executed, the regex is +// ignored, and the macro must accept a streamed message even though the message +// is never printed. +# define GTEST_EXECUTE_STATEMENT_(statement, regex) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (::testing::internal::AlwaysTrue()) { \ + GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ + } else \ + ::testing::Message() + +// A class representing the parsed contents of the +// --gtest_internal_run_death_test flag, as it existed when +// RUN_ALL_TESTS was called. +class InternalRunDeathTestFlag { + public: + InternalRunDeathTestFlag(const std::string& a_file, + int a_line, + int an_index, + int a_write_fd) + : file_(a_file), line_(a_line), index_(an_index), + write_fd_(a_write_fd) {} + + ~InternalRunDeathTestFlag() { + if (write_fd_ >= 0) + posix::Close(write_fd_); + } + + const std::string& file() const { return file_; } + int line() const { return line_; } + int index() const { return index_; } + int write_fd() const { return write_fd_; } + + private: + std::string file_; + int line_; + int index_; + int write_fd_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(InternalRunDeathTestFlag); +}; + +// Returns a newly created InternalRunDeathTestFlag object with fields +// initialized from the GTEST_FLAG(internal_run_death_test) flag if +// the flag is specified; otherwise returns NULL. +InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag(); + +#else // GTEST_HAS_DEATH_TEST + +// This macro is used for implementing macros such as +// EXPECT_DEATH_IF_SUPPORTED and ASSERT_DEATH_IF_SUPPORTED on systems where +// death tests are not supported. Those macros must compile on such systems +// iff EXPECT_DEATH and ASSERT_DEATH compile with the same parameters on +// systems that support death tests. This allows one to write such a macro +// on a system that does not support death tests and be sure that it will +// compile on a death-test supporting system. +// +// Parameters: +// statement - A statement that a macro such as EXPECT_DEATH would test +// for program termination. This macro has to make sure this +// statement is compiled but not executed, to ensure that +// EXPECT_DEATH_IF_SUPPORTED compiles with a certain +// parameter iff EXPECT_DEATH compiles with it. +// regex - A regex that a macro such as EXPECT_DEATH would use to test +// the output of statement. This parameter has to be +// compiled but not evaluated by this macro, to ensure that +// this macro only accepts expressions that a macro such as +// EXPECT_DEATH would accept. +// terminator - Must be an empty statement for EXPECT_DEATH_IF_SUPPORTED +// and a return statement for ASSERT_DEATH_IF_SUPPORTED. +// This ensures that ASSERT_DEATH_IF_SUPPORTED will not +// compile inside functions where ASSERT_DEATH doesn't +// compile. +// +// The branch that has an always false condition is used to ensure that +// statement and regex are compiled (and thus syntactically correct) but +// never executed. The unreachable code macro protects the terminator +// statement from generating an 'unreachable code' warning in case +// statement unconditionally returns or throws. The Message constructor at +// the end allows the syntax of streaming additional messages into the +// macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH. +# define GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, terminator) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (::testing::internal::AlwaysTrue()) { \ + GTEST_LOG_(WARNING) \ + << "Death tests are not supported on this platform.\n" \ + << "Statement '" #statement "' cannot be verified."; \ + } else if (::testing::internal::AlwaysFalse()) { \ + ::testing::internal::RE::PartialMatch(".*", (regex)); \ + GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ + terminator; \ + } else \ + ::testing::Message() + +#endif // GTEST_HAS_DEATH_TEST + +} // namespace internal +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_ + +namespace testing { + +// This flag controls the style of death tests. Valid values are "threadsafe", +// meaning that the death test child process will re-execute the test binary +// from the start, running only a single death test, or "fast", +// meaning that the child process will execute the test logic immediately +// after forking. +GTEST_DECLARE_string_(death_test_style); + +#if GTEST_HAS_DEATH_TEST + +namespace internal { + +// Returns a Boolean value indicating whether the caller is currently +// executing in the context of the death test child process. Tools such as +// Valgrind heap checkers may need this to modify their behavior in death +// tests. IMPORTANT: This is an internal utility. Using it may break the +// implementation of death tests. User code MUST NOT use it. +GTEST_API_ bool InDeathTestChild(); + +} // namespace internal + +// The following macros are useful for writing death tests. + +// Here's what happens when an ASSERT_DEATH* or EXPECT_DEATH* is +// executed: +// +// 1. It generates a warning if there is more than one active +// thread. This is because it's safe to fork() or clone() only +// when there is a single thread. +// +// 2. The parent process clone()s a sub-process and runs the death +// test in it; the sub-process exits with code 0 at the end of the +// death test, if it hasn't exited already. +// +// 3. The parent process waits for the sub-process to terminate. +// +// 4. The parent process checks the exit code and error message of +// the sub-process. +// +// Examples: +// +// ASSERT_DEATH(server.SendMessage(56, "Hello"), "Invalid port number"); +// for (int i = 0; i < 5; i++) { +// EXPECT_DEATH(server.ProcessRequest(i), +// "Invalid request .* in ProcessRequest()") +// << "Failed to die on request " << i; +// } +// +// ASSERT_EXIT(server.ExitNow(), ::testing::ExitedWithCode(0), "Exiting"); +// +// bool KilledBySIGHUP(int exit_code) { +// return WIFSIGNALED(exit_code) && WTERMSIG(exit_code) == SIGHUP; +// } +// +// ASSERT_EXIT(client.HangUpServer(), KilledBySIGHUP, "Hanging up!"); +// +// On the regular expressions used in death tests: +// +// On POSIX-compliant systems (*nix), we use the library, +// which uses the POSIX extended regex syntax. +// +// On other platforms (e.g. Windows), we only support a simple regex +// syntax implemented as part of Google Test. This limited +// implementation should be enough most of the time when writing +// death tests; though it lacks many features you can find in PCRE +// or POSIX extended regex syntax. For example, we don't support +// union ("x|y"), grouping ("(xy)"), brackets ("[xy]"), and +// repetition count ("x{5,7}"), among others. +// +// Below is the syntax that we do support. We chose it to be a +// subset of both PCRE and POSIX extended regex, so it's easy to +// learn wherever you come from. In the following: 'A' denotes a +// literal character, period (.), or a single \\ escape sequence; +// 'x' and 'y' denote regular expressions; 'm' and 'n' are for +// natural numbers. +// +// c matches any literal character c +// \\d matches any decimal digit +// \\D matches any character that's not a decimal digit +// \\f matches \f +// \\n matches \n +// \\r matches \r +// \\s matches any ASCII whitespace, including \n +// \\S matches any character that's not a whitespace +// \\t matches \t +// \\v matches \v +// \\w matches any letter, _, or decimal digit +// \\W matches any character that \\w doesn't match +// \\c matches any literal character c, which must be a punctuation +// . matches any single character except \n +// A? matches 0 or 1 occurrences of A +// A* matches 0 or many occurrences of A +// A+ matches 1 or many occurrences of A +// ^ matches the beginning of a string (not that of each line) +// $ matches the end of a string (not that of each line) +// xy matches x followed by y +// +// If you accidentally use PCRE or POSIX extended regex features +// not implemented by us, you will get a run-time failure. In that +// case, please try to rewrite your regular expression within the +// above syntax. +// +// This implementation is *not* meant to be as highly tuned or robust +// as a compiled regex library, but should perform well enough for a +// death test, which already incurs significant overhead by launching +// a child process. +// +// Known caveats: +// +// A "threadsafe" style death test obtains the path to the test +// program from argv[0] and re-executes it in the sub-process. For +// simplicity, the current implementation doesn't search the PATH +// when launching the sub-process. This means that the user must +// invoke the test program via a path that contains at least one +// path separator (e.g. path/to/foo_test and +// /absolute/path/to/bar_test are fine, but foo_test is not). This +// is rarely a problem as people usually don't put the test binary +// directory in PATH. +// +// TODO(wan@google.com): make thread-safe death tests search the PATH. + +// Asserts that a given statement causes the program to exit, with an +// integer exit status that satisfies predicate, and emitting error output +// that matches regex. +# define ASSERT_EXIT(statement, predicate, regex) \ + GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_FATAL_FAILURE_) + +// Like ASSERT_EXIT, but continues on to successive tests in the +// test case, if any: +# define EXPECT_EXIT(statement, predicate, regex) \ + GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_NONFATAL_FAILURE_) + +// Asserts that a given statement causes the program to exit, either by +// explicitly exiting with a nonzero exit code or being killed by a +// signal, and emitting error output that matches regex. +# define ASSERT_DEATH(statement, regex) \ + ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex) + +// Like ASSERT_DEATH, but continues on to successive tests in the +// test case, if any: +# define EXPECT_DEATH(statement, regex) \ + EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex) + +// Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*: + +// Tests that an exit code describes a normal exit with a given exit code. +class GTEST_API_ ExitedWithCode { + public: + explicit ExitedWithCode(int exit_code); + bool operator()(int exit_status) const; + private: + // No implementation - assignment is unsupported. + void operator=(const ExitedWithCode& other); + + const int exit_code_; +}; + +# if !GTEST_OS_WINDOWS +// Tests that an exit code describes an exit due to termination by a +// given signal. +class GTEST_API_ KilledBySignal { + public: + explicit KilledBySignal(int signum); + bool operator()(int exit_status) const; + private: + const int signum_; +}; +# endif // !GTEST_OS_WINDOWS + +// EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode. +// The death testing framework causes this to have interesting semantics, +// since the sideeffects of the call are only visible in opt mode, and not +// in debug mode. +// +// In practice, this can be used to test functions that utilize the +// LOG(DFATAL) macro using the following style: +// +// int DieInDebugOr12(int* sideeffect) { +// if (sideeffect) { +// *sideeffect = 12; +// } +// LOG(DFATAL) << "death"; +// return 12; +// } +// +// TEST(TestCase, TestDieOr12WorksInDgbAndOpt) { +// int sideeffect = 0; +// // Only asserts in dbg. +// EXPECT_DEBUG_DEATH(DieInDebugOr12(&sideeffect), "death"); +// +// #ifdef NDEBUG +// // opt-mode has sideeffect visible. +// EXPECT_EQ(12, sideeffect); +// #else +// // dbg-mode no visible sideeffect. +// EXPECT_EQ(0, sideeffect); +// #endif +// } +// +// This will assert that DieInDebugReturn12InOpt() crashes in debug +// mode, usually due to a DCHECK or LOG(DFATAL), but returns the +// appropriate fallback value (12 in this case) in opt mode. If you +// need to test that a function has appropriate side-effects in opt +// mode, include assertions against the side-effects. A general +// pattern for this is: +// +// EXPECT_DEBUG_DEATH({ +// // Side-effects here will have an effect after this statement in +// // opt mode, but none in debug mode. +// EXPECT_EQ(12, DieInDebugOr12(&sideeffect)); +// }, "death"); +// +# ifdef NDEBUG + +# define EXPECT_DEBUG_DEATH(statement, regex) \ + GTEST_EXECUTE_STATEMENT_(statement, regex) + +# define ASSERT_DEBUG_DEATH(statement, regex) \ + GTEST_EXECUTE_STATEMENT_(statement, regex) + +# else + +# define EXPECT_DEBUG_DEATH(statement, regex) \ + EXPECT_DEATH(statement, regex) + +# define ASSERT_DEBUG_DEATH(statement, regex) \ + ASSERT_DEATH(statement, regex) + +# endif // NDEBUG for EXPECT_DEBUG_DEATH +#endif // GTEST_HAS_DEATH_TEST + +// EXPECT_DEATH_IF_SUPPORTED(statement, regex) and +// ASSERT_DEATH_IF_SUPPORTED(statement, regex) expand to real death tests if +// death tests are supported; otherwise they just issue a warning. This is +// useful when you are combining death test assertions with normal test +// assertions in one test. +#if GTEST_HAS_DEATH_TEST +# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \ + EXPECT_DEATH(statement, regex) +# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \ + ASSERT_DEATH(statement, regex) +#else +# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \ + GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, ) +# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \ + GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, return) +#endif + +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ +// This file was GENERATED by command: +// pump.py gtest-param-test.h.pump +// DO NOT EDIT BY HAND!!! + +// 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) +// +// Macros and functions for implementing parameterized tests +// in Google C++ Testing Framework (Google Test) +// +// This file is generated by a SCRIPT. DO NOT EDIT BY HAND! +// +#ifndef GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ +#define GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ + + +// Value-parameterized tests allow you to test your code with different +// parameters without writing multiple copies of the same test. +// +// Here is how you use value-parameterized tests: + +#if 0 + +// To write value-parameterized tests, first you should define a fixture +// class. It is usually derived from testing::TestWithParam (see below for +// another inheritance scheme that's sometimes useful in more complicated +// class hierarchies), where the type of your parameter values. +// TestWithParam is itself derived from testing::Test. T can be any +// copyable type. If it's a raw pointer, you are responsible for managing the +// lifespan of the pointed values. + +class FooTest : public ::testing::TestWithParam { + // You can implement all the usual class fixture members here. +}; + +// Then, use the TEST_P macro to define as many parameterized tests +// for this fixture as you want. The _P suffix is for "parameterized" +// or "pattern", whichever you prefer to think. + +TEST_P(FooTest, DoesBlah) { + // Inside a test, access the test parameter with the GetParam() method + // of the TestWithParam class: + EXPECT_TRUE(foo.Blah(GetParam())); + ... +} + +TEST_P(FooTest, HasBlahBlah) { + ... +} + +// Finally, you can use INSTANTIATE_TEST_CASE_P to instantiate the test +// case with any set of parameters you want. Google Test defines a number +// of functions for generating test parameters. They return what we call +// (surprise!) parameter generators. Here is a summary of them, which +// are all in the testing namespace: +// +// +// Range(begin, end [, step]) - Yields values {begin, begin+step, +// begin+step+step, ...}. The values do not +// include end. step defaults to 1. +// Values(v1, v2, ..., vN) - Yields values {v1, v2, ..., vN}. +// ValuesIn(container) - Yields values from a C-style array, an STL +// ValuesIn(begin,end) container, or an iterator range [begin, end). +// Bool() - Yields sequence {false, true}. +// Combine(g1, g2, ..., gN) - Yields all combinations (the Cartesian product +// for the math savvy) of the values generated +// by the N generators. +// +// For more details, see comments at the definitions of these functions below +// in this file. +// +// The following statement will instantiate tests from the FooTest test case +// each with parameter values "meeny", "miny", and "moe". + +INSTANTIATE_TEST_CASE_P(InstantiationName, + FooTest, + Values("meeny", "miny", "moe")); + +// To distinguish different instances of the pattern, (yes, you +// can instantiate it more then once) the first argument to the +// INSTANTIATE_TEST_CASE_P macro is a prefix that will be added to the +// actual test case name. Remember to pick unique prefixes for different +// instantiations. The tests from the instantiation above will have +// these names: +// +// * InstantiationName/FooTest.DoesBlah/0 for "meeny" +// * InstantiationName/FooTest.DoesBlah/1 for "miny" +// * InstantiationName/FooTest.DoesBlah/2 for "moe" +// * InstantiationName/FooTest.HasBlahBlah/0 for "meeny" +// * InstantiationName/FooTest.HasBlahBlah/1 for "miny" +// * InstantiationName/FooTest.HasBlahBlah/2 for "moe" +// +// You can use these names in --gtest_filter. +// +// This statement will instantiate all tests from FooTest again, each +// with parameter values "cat" and "dog": + +const char* pets[] = {"cat", "dog"}; +INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets)); + +// The tests from the instantiation above will have these names: +// +// * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat" +// * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog" +// * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat" +// * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog" +// +// Please note that INSTANTIATE_TEST_CASE_P will instantiate all tests +// in the given test case, whether their definitions come before or +// AFTER the INSTANTIATE_TEST_CASE_P statement. +// +// Please also note that generator expressions (including parameters to the +// generators) are evaluated in InitGoogleTest(), after main() has started. +// This allows the user on one hand, to adjust generator parameters in order +// to dynamically determine a set of tests to run and on the other hand, +// give the user a chance to inspect the generated tests with Google Test +// reflection API before RUN_ALL_TESTS() is executed. +// +// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc +// for more examples. +// +// In the future, we plan to publish the API for defining new parameter +// generators. But for now this interface remains part of the internal +// implementation and is subject to change. +// +// +// A parameterized test fixture must be derived from testing::Test and from +// testing::WithParamInterface, where T is the type of the parameter +// values. Inheriting from TestWithParam satisfies that requirement because +// TestWithParam inherits from both Test and WithParamInterface. In more +// complicated hierarchies, however, it is occasionally useful to inherit +// separately from Test and WithParamInterface. For example: + +class BaseTest : public ::testing::Test { + // You can inherit all the usual members for a non-parameterized test + // fixture here. +}; + +class DerivedTest : public BaseTest, public ::testing::WithParamInterface { + // The usual test fixture members go here too. +}; + +TEST_F(BaseTest, HasFoo) { + // This is an ordinary non-parameterized test. +} + +TEST_P(DerivedTest, DoesBlah) { + // GetParam works just the same here as if you inherit from TestWithParam. + EXPECT_TRUE(foo.Blah(GetParam())); +} + +#endif // 0 + + +#if !GTEST_OS_SYMBIAN +# include +#endif + +// scripts/fuse_gtest.py depends on gtest's own header being #included +// *unconditionally*. Therefore these #includes cannot be moved +// inside #if GTEST_HAS_PARAM_TEST. +// 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. +// +// Author: vladl@google.com (Vlad Losev) + +// Type and function utilities for implementing parameterized tests. + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ + +#include +#include +#include + +// scripts/fuse_gtest.py depends on gtest's own header being #included +// *unconditionally*. Therefore these #includes cannot be moved +// inside #if GTEST_HAS_PARAM_TEST. +// Copyright 2003 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: Dan Egnor (egnor@google.com) +// +// A "smart" pointer type with reference tracking. Every pointer to a +// particular object is kept on a circular linked list. When the last pointer +// to an object is destroyed or reassigned, the object is deleted. +// +// Used properly, this deletes the object when the last reference goes away. +// There are several caveats: +// - Like all reference counting schemes, cycles lead to leaks. +// - Each smart pointer is actually two pointers (8 bytes instead of 4). +// - Every time a pointer is assigned, the entire list of pointers to that +// object is traversed. This class is therefore NOT SUITABLE when there +// will often be more than two or three pointers to a particular object. +// - References are only tracked as long as linked_ptr<> objects are copied. +// If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS +// will happen (double deletion). +// +// A good use of this class is storing object references in STL containers. +// You can safely put linked_ptr<> in a vector<>. +// Other uses may not be as good. +// +// Note: If you use an incomplete type with linked_ptr<>, the class +// *containing* linked_ptr<> must have a constructor and destructor (even +// if they do nothing!). +// +// Bill Gibbons suggested we use something like this. +// +// Thread Safety: +// Unlike other linked_ptr implementations, in this implementation +// a linked_ptr object is thread-safe in the sense that: +// - it's safe to copy linked_ptr objects concurrently, +// - it's safe to copy *from* a linked_ptr and read its underlying +// raw pointer (e.g. via get()) concurrently, and +// - it's safe to write to two linked_ptrs that point to the same +// shared object concurrently. +// TODO(wan@google.com): rename this to safe_linked_ptr to avoid +// confusion with normal linked_ptr. + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_ + +#include +#include + + +namespace testing { +namespace internal { + +// Protects copying of all linked_ptr objects. +GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_linked_ptr_mutex); + +// This is used internally by all instances of linked_ptr<>. It needs to be +// a non-template class because different types of linked_ptr<> can refer to +// the same object (linked_ptr(obj) vs linked_ptr(obj)). +// So, it needs to be possible for different types of linked_ptr to participate +// in the same circular linked list, so we need a single class type here. +// +// DO NOT USE THIS CLASS DIRECTLY YOURSELF. Use linked_ptr. +class linked_ptr_internal { + public: + // Create a new circle that includes only this instance. + void join_new() { + next_ = this; + } + + // Many linked_ptr operations may change p.link_ for some linked_ptr + // variable p in the same circle as this object. Therefore we need + // to prevent two such operations from occurring concurrently. + // + // Note that different types of linked_ptr objects can coexist in a + // circle (e.g. linked_ptr, linked_ptr, and + // linked_ptr). Therefore we must use a single mutex to + // protect all linked_ptr objects. This can create serious + // contention in production code, but is acceptable in a testing + // framework. + + // Join an existing circle. + void join(linked_ptr_internal const* ptr) + GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) { + MutexLock lock(&g_linked_ptr_mutex); + + linked_ptr_internal const* p = ptr; + while (p->next_ != ptr) p = p->next_; + p->next_ = this; + next_ = ptr; + } + + // Leave whatever circle we're part of. Returns true if we were the + // last member of the circle. Once this is done, you can join() another. + bool depart() + GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) { + MutexLock lock(&g_linked_ptr_mutex); + + if (next_ == this) return true; + linked_ptr_internal const* p = next_; + while (p->next_ != this) p = p->next_; + p->next_ = next_; + return false; + } + + private: + mutable linked_ptr_internal const* next_; +}; + +template +class linked_ptr { + public: + typedef T element_type; + + // Take over ownership of a raw pointer. This should happen as soon as + // possible after the object is created. + explicit linked_ptr(T* ptr = NULL) { capture(ptr); } + ~linked_ptr() { depart(); } + + // Copy an existing linked_ptr<>, adding ourselves to the list of references. + template linked_ptr(linked_ptr const& ptr) { copy(&ptr); } + linked_ptr(linked_ptr const& ptr) { // NOLINT + assert(&ptr != this); + copy(&ptr); + } + + // Assignment releases the old value and acquires the new. + template linked_ptr& operator=(linked_ptr const& ptr) { + depart(); + copy(&ptr); + return *this; + } + + linked_ptr& operator=(linked_ptr const& ptr) { + if (&ptr != this) { + depart(); + copy(&ptr); + } + return *this; + } + + // Smart pointer members. + void reset(T* ptr = NULL) { + depart(); + capture(ptr); + } + T* get() const { return value_; } + T* operator->() const { return value_; } + T& operator*() const { return *value_; } + + bool operator==(T* p) const { return value_ == p; } + bool operator!=(T* p) const { return value_ != p; } + template + bool operator==(linked_ptr const& ptr) const { + return value_ == ptr.get(); + } + template + bool operator!=(linked_ptr const& ptr) const { + return value_ != ptr.get(); + } + + private: + template + friend class linked_ptr; + + T* value_; + linked_ptr_internal link_; + + void depart() { + if (link_.depart()) delete value_; + } + + void capture(T* ptr) { + value_ = ptr; + link_.join_new(); + } + + template void copy(linked_ptr const* ptr) { + value_ = ptr->get(); + if (value_) + link_.join(&ptr->link_); + else + link_.join_new(); + } +}; + +template inline +bool operator==(T* ptr, const linked_ptr& x) { + return ptr == x.get(); +} + +template inline +bool operator!=(T* ptr, const linked_ptr& x) { + return ptr != x.get(); +} + +// A function to convert T* into linked_ptr +// Doing e.g. make_linked_ptr(new FooBarBaz(arg)) is a shorter notation +// for linked_ptr >(new FooBarBaz(arg)) +template +linked_ptr make_linked_ptr(T* ptr) { + return linked_ptr(ptr); +} + +} // namespace internal +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_ +// 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. +// +// Author: wan@google.com (Zhanyong Wan) + +// Google Test - The Google C++ Testing Framework +// +// This file implements a universal value printer that can print a +// value of any type T: +// +// void ::testing::internal::UniversalPrinter::Print(value, ostream_ptr); +// +// A user can teach this function how to print a class type T by +// defining either operator<<() or PrintTo() in the namespace that +// defines T. More specifically, the FIRST defined function in the +// following list will be used (assuming T is defined in namespace +// foo): +// +// 1. foo::PrintTo(const T&, ostream*) +// 2. operator<<(ostream&, const T&) defined in either foo or the +// global namespace. +// +// If none of the above is defined, it will print the debug string of +// the value if it is a protocol buffer, or print the raw bytes in the +// value otherwise. +// +// To aid debugging: when T is a reference type, the address of the +// value is also printed; when T is a (const) char pointer, both the +// pointer value and the NUL-terminated string it points to are +// printed. +// +// We also provide some convenient wrappers: +// +// // Prints a value to a string. For a (const or not) char +// // pointer, the NUL-terminated string (but not the pointer) is +// // printed. +// std::string ::testing::PrintToString(const T& value); +// +// // Prints a value tersely: for a reference type, the referenced +// // value (but not the address) is printed; for a (const or not) char +// // pointer, the NUL-terminated string (but not the pointer) is +// // printed. +// void ::testing::internal::UniversalTersePrint(const T& value, ostream*); +// +// // Prints value using the type inferred by the compiler. The difference +// // from UniversalTersePrint() is that this function prints both the +// // pointer and the NUL-terminated string for a (const or not) char pointer. +// void ::testing::internal::UniversalPrint(const T& value, ostream*); +// +// // Prints the fields of a tuple tersely to a string vector, one +// // element for each field. Tuple support must be enabled in +// // gtest-port.h. +// std::vector UniversalTersePrintTupleFieldsToStrings( +// const Tuple& value); +// +// Known limitation: +// +// The print primitives print the elements of an STL-style container +// using the compiler-inferred type of *iter where iter is a +// const_iterator of the container. When const_iterator is an input +// iterator but not a forward iterator, this inferred type may not +// match value_type, and the print output may be incorrect. In +// practice, this is rarely a problem as for most containers +// const_iterator is a forward iterator. We'll fix this if there's an +// actual need for it. Note that this fix cannot rely on value_type +// being defined as many user-defined container types don't have +// value_type. + +#ifndef GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_ +#define GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_ + +#include // NOLINT +#include +#include +#include +#include + +namespace testing { + +// Definitions in the 'internal' and 'internal2' name spaces are +// subject to change without notice. DO NOT USE THEM IN USER CODE! +namespace internal2 { + +// Prints the given number of bytes in the given object to the given +// ostream. +GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes, + size_t count, + ::std::ostream* os); + +// For selecting which printer to use when a given type has neither << +// nor PrintTo(). +enum TypeKind { + kProtobuf, // a protobuf type + kConvertibleToInteger, // a type implicitly convertible to BiggestInt + // (e.g. a named or unnamed enum type) + kOtherType // anything else +}; + +// TypeWithoutFormatter::PrintValue(value, os) is called +// by the universal printer to print a value of type T when neither +// operator<< nor PrintTo() is defined for T, where kTypeKind is the +// "kind" of T as defined by enum TypeKind. +template +class TypeWithoutFormatter { + public: + // This default version is called when kTypeKind is kOtherType. + static void PrintValue(const T& value, ::std::ostream* os) { + PrintBytesInObjectTo(reinterpret_cast(&value), + sizeof(value), os); + } +}; + +// We print a protobuf using its ShortDebugString() when the string +// doesn't exceed this many characters; otherwise we print it using +// DebugString() for better readability. +const size_t kProtobufOneLinerMaxLength = 50; + +template +class TypeWithoutFormatter { + public: + static void PrintValue(const T& value, ::std::ostream* os) { + const ::testing::internal::string short_str = value.ShortDebugString(); + const ::testing::internal::string pretty_str = + short_str.length() <= kProtobufOneLinerMaxLength ? + short_str : ("\n" + value.DebugString()); + *os << ("<" + pretty_str + ">"); + } +}; + +template +class TypeWithoutFormatter { + public: + // Since T has no << operator or PrintTo() but can be implicitly + // converted to BiggestInt, we print it as a BiggestInt. + // + // Most likely T is an enum type (either named or unnamed), in which + // case printing it as an integer is the desired behavior. In case + // T is not an enum, printing it as an integer is the best we can do + // given that it has no user-defined printer. + static void PrintValue(const T& value, ::std::ostream* os) { + const internal::BiggestInt kBigInt = value; + *os << kBigInt; + } +}; + +// Prints the given value to the given ostream. If the value is a +// protocol message, its debug string is printed; if it's an enum or +// of a type implicitly convertible to BiggestInt, it's printed as an +// integer; otherwise the bytes in the value are printed. This is +// what UniversalPrinter::Print() does when it knows nothing about +// type T and T has neither << operator nor PrintTo(). +// +// A user can override this behavior for a class type Foo by defining +// a << operator in the namespace where Foo is defined. +// +// We put this operator in namespace 'internal2' instead of 'internal' +// to simplify the implementation, as much code in 'internal' needs to +// use << in STL, which would conflict with our own << were it defined +// in 'internal'. +// +// Note that this operator<< takes a generic std::basic_ostream type instead of the more restricted std::ostream. If +// we define it to take an std::ostream instead, we'll get an +// "ambiguous overloads" compiler error when trying to print a type +// Foo that supports streaming to std::basic_ostream, as the compiler cannot tell whether +// operator<<(std::ostream&, const T&) or +// operator<<(std::basic_stream, const Foo&) is more +// specific. +template +::std::basic_ostream& operator<<( + ::std::basic_ostream& os, const T& x) { + TypeWithoutFormatter::value ? kProtobuf : + internal::ImplicitlyConvertible::value ? + kConvertibleToInteger : kOtherType)>::PrintValue(x, &os); + return os; +} + +} // namespace internal2 +} // namespace testing + +// This namespace MUST NOT BE NESTED IN ::testing, or the name look-up +// magic needed for implementing UniversalPrinter won't work. +namespace testing_internal { + +// Used to print a value that is not an STL-style container when the +// user doesn't define PrintTo() for it. +template +void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) { + // With the following statement, during unqualified name lookup, + // testing::internal2::operator<< appears as if it was declared in + // the nearest enclosing namespace that contains both + // ::testing_internal and ::testing::internal2, i.e. the global + // namespace. For more details, refer to the C++ Standard section + // 7.3.4-1 [namespace.udir]. This allows us to fall back onto + // testing::internal2::operator<< in case T doesn't come with a << + // operator. + // + // We cannot write 'using ::testing::internal2::operator<<;', which + // gcc 3.3 fails to compile due to a compiler bug. + using namespace ::testing::internal2; // NOLINT + + // Assuming T is defined in namespace foo, in the next statement, + // the compiler will consider all of: + // + // 1. foo::operator<< (thanks to Koenig look-up), + // 2. ::operator<< (as the current namespace is enclosed in ::), + // 3. testing::internal2::operator<< (thanks to the using statement above). + // + // The operator<< whose type matches T best will be picked. + // + // We deliberately allow #2 to be a candidate, as sometimes it's + // impossible to define #1 (e.g. when foo is ::std, defining + // anything in it is undefined behavior unless you are a compiler + // vendor.). + *os << value; +} + +} // namespace testing_internal + +namespace testing { +namespace internal { + +// UniversalPrinter::Print(value, ostream_ptr) prints the given +// value to the given ostream. The caller must ensure that +// 'ostream_ptr' is not NULL, or the behavior is undefined. +// +// We define UniversalPrinter as a class template (as opposed to a +// function template), as we need to partially specialize it for +// reference types, which cannot be done with function templates. +template +class UniversalPrinter; + +template +void UniversalPrint(const T& value, ::std::ostream* os); + +// Used to print an STL-style container when the user doesn't define +// a PrintTo() for it. +template +void DefaultPrintTo(IsContainer /* dummy */, + false_type /* is not a pointer */, + const C& container, ::std::ostream* os) { + const size_t kMaxCount = 32; // The maximum number of elements to print. + *os << '{'; + size_t count = 0; + for (typename C::const_iterator it = container.begin(); + it != container.end(); ++it, ++count) { + if (count > 0) { + *os << ','; + if (count == kMaxCount) { // Enough has been printed. + *os << " ..."; + break; + } + } + *os << ' '; + // We cannot call PrintTo(*it, os) here as PrintTo() doesn't + // handle *it being a native array. + internal::UniversalPrint(*it, os); + } + + if (count > 0) { + *os << ' '; + } + *os << '}'; +} + +// Used to print a pointer that is neither a char pointer nor a member +// pointer, when the user doesn't define PrintTo() for it. (A member +// variable pointer or member function pointer doesn't really point to +// a location in the address space. Their representation is +// implementation-defined. Therefore they will be printed as raw +// bytes.) +template +void DefaultPrintTo(IsNotContainer /* dummy */, + true_type /* is a pointer */, + T* p, ::std::ostream* os) { + if (p == NULL) { + *os << "NULL"; + } else { + // C++ doesn't allow casting from a function pointer to any object + // pointer. + // + // IsTrue() silences warnings: "Condition is always true", + // "unreachable code". + if (IsTrue(ImplicitlyConvertible::value)) { + // T is not a function type. We just call << to print p, + // relying on ADL to pick up user-defined << for their pointer + // types, if any. + *os << p; + } else { + // T is a function type, so '*os << p' doesn't do what we want + // (it just prints p as bool). We want to print p as a const + // void*. However, we cannot cast it to const void* directly, + // even using reinterpret_cast, as earlier versions of gcc + // (e.g. 3.4.5) cannot compile the cast when p is a function + // pointer. Casting to UInt64 first solves the problem. + *os << reinterpret_cast( + reinterpret_cast(p)); + } + } +} + +// Used to print a non-container, non-pointer value when the user +// doesn't define PrintTo() for it. +template +void DefaultPrintTo(IsNotContainer /* dummy */, + false_type /* is not a pointer */, + const T& value, ::std::ostream* os) { + ::testing_internal::DefaultPrintNonContainerTo(value, os); +} + +// Prints the given value using the << operator if it has one; +// otherwise prints the bytes in it. This is what +// UniversalPrinter::Print() does when PrintTo() is not specialized +// or overloaded for type T. +// +// A user can override this behavior for a class type Foo by defining +// an overload of PrintTo() in the namespace where Foo is defined. We +// give the user this option as sometimes defining a << operator for +// Foo is not desirable (e.g. the coding style may prevent doing it, +// or there is already a << operator but it doesn't do what the user +// wants). +template +void PrintTo(const T& value, ::std::ostream* os) { + // DefaultPrintTo() is overloaded. The type of its first two + // arguments determine which version will be picked. If T is an + // STL-style container, the version for container will be called; if + // T is a pointer, the pointer version will be called; otherwise the + // generic version will be called. + // + // Note that we check for container types here, prior to we check + // for protocol message types in our operator<<. The rationale is: + // + // For protocol messages, we want to give people a chance to + // override Google Mock's format by defining a PrintTo() or + // operator<<. For STL containers, other formats can be + // incompatible with Google Mock's format for the container + // elements; therefore we check for container types here to ensure + // that our format is used. + // + // The second argument of DefaultPrintTo() is needed to bypass a bug + // in Symbian's C++ compiler that prevents it from picking the right + // overload between: + // + // PrintTo(const T& x, ...); + // PrintTo(T* x, ...); + DefaultPrintTo(IsContainerTest(0), is_pointer(), value, os); +} + +// The following list of PrintTo() overloads tells +// UniversalPrinter::Print() how to print standard types (built-in +// types, strings, plain arrays, and pointers). + +// Overloads for various char types. +GTEST_API_ void PrintTo(unsigned char c, ::std::ostream* os); +GTEST_API_ void PrintTo(signed char c, ::std::ostream* os); +inline void PrintTo(char c, ::std::ostream* os) { + // When printing a plain char, we always treat it as unsigned. This + // way, the output won't be affected by whether the compiler thinks + // char is signed or not. + PrintTo(static_cast(c), os); +} + +// Overloads for other simple built-in types. +inline void PrintTo(bool x, ::std::ostream* os) { + *os << (x ? "true" : "false"); +} + +// Overload for wchar_t type. +// Prints a wchar_t as a symbol if it is printable or as its internal +// code otherwise and also as its decimal code (except for L'\0'). +// The L'\0' char is printed as "L'\\0'". The decimal code is printed +// as signed integer when wchar_t is implemented by the compiler +// as a signed type and is printed as an unsigned integer when wchar_t +// is implemented as an unsigned type. +GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os); + +// Overloads for C strings. +GTEST_API_ void PrintTo(const char* s, ::std::ostream* os); +inline void PrintTo(char* s, ::std::ostream* os) { + PrintTo(ImplicitCast_(s), os); +} + +// signed/unsigned char is often used for representing binary data, so +// we print pointers to it as void* to be safe. +inline void PrintTo(const signed char* s, ::std::ostream* os) { + PrintTo(ImplicitCast_(s), os); +} +inline void PrintTo(signed char* s, ::std::ostream* os) { + PrintTo(ImplicitCast_(s), os); +} +inline void PrintTo(const unsigned char* s, ::std::ostream* os) { + PrintTo(ImplicitCast_(s), os); +} +inline void PrintTo(unsigned char* s, ::std::ostream* os) { + PrintTo(ImplicitCast_(s), os); +} + +// MSVC can be configured to define wchar_t as a typedef of unsigned +// short. It defines _NATIVE_WCHAR_T_DEFINED when wchar_t is a native +// type. When wchar_t is a typedef, defining an overload for const +// wchar_t* would cause unsigned short* be printed as a wide string, +// possibly causing invalid memory accesses. +#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) +// Overloads for wide C strings +GTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os); +inline void PrintTo(wchar_t* s, ::std::ostream* os) { + PrintTo(ImplicitCast_(s), os); +} +#endif + +// Overload for C arrays. Multi-dimensional arrays are printed +// properly. + +// Prints the given number of elements in an array, without printing +// the curly braces. +template +void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) { + UniversalPrint(a[0], os); + for (size_t i = 1; i != count; i++) { + *os << ", "; + UniversalPrint(a[i], os); + } +} + +// Overloads for ::string and ::std::string. +#if GTEST_HAS_GLOBAL_STRING +GTEST_API_ void PrintStringTo(const ::string&s, ::std::ostream* os); +inline void PrintTo(const ::string& s, ::std::ostream* os) { + PrintStringTo(s, os); +} +#endif // GTEST_HAS_GLOBAL_STRING + +GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os); +inline void PrintTo(const ::std::string& s, ::std::ostream* os) { + PrintStringTo(s, os); +} + +// Overloads for ::wstring and ::std::wstring. +#if GTEST_HAS_GLOBAL_WSTRING +GTEST_API_ void PrintWideStringTo(const ::wstring&s, ::std::ostream* os); +inline void PrintTo(const ::wstring& s, ::std::ostream* os) { + PrintWideStringTo(s, os); +} +#endif // GTEST_HAS_GLOBAL_WSTRING + +#if GTEST_HAS_STD_WSTRING +GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os); +inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) { + PrintWideStringTo(s, os); +} +#endif // GTEST_HAS_STD_WSTRING + +#if GTEST_HAS_TR1_TUPLE +// Overload for ::std::tr1::tuple. Needed for printing function arguments, +// which are packed as tuples. + +// Helper function for printing a tuple. T must be instantiated with +// a tuple type. +template +void PrintTupleTo(const T& t, ::std::ostream* os); + +// Overloaded PrintTo() for tuples of various arities. We support +// tuples of up-to 10 fields. The following implementation works +// regardless of whether tr1::tuple is implemented using the +// non-standard variadic template feature or not. + +inline void PrintTo(const ::std::tr1::tuple<>& t, ::std::ostream* os) { + PrintTupleTo(t, os); +} + +template +void PrintTo(const ::std::tr1::tuple& t, ::std::ostream* os) { + PrintTupleTo(t, os); +} + +template +void PrintTo(const ::std::tr1::tuple& t, ::std::ostream* os) { + PrintTupleTo(t, os); +} + +template +void PrintTo(const ::std::tr1::tuple& t, ::std::ostream* os) { + PrintTupleTo(t, os); +} + +template +void PrintTo(const ::std::tr1::tuple& t, ::std::ostream* os) { + PrintTupleTo(t, os); +} + +template +void PrintTo(const ::std::tr1::tuple& t, + ::std::ostream* os) { + PrintTupleTo(t, os); +} + +template +void PrintTo(const ::std::tr1::tuple& t, + ::std::ostream* os) { + PrintTupleTo(t, os); +} + +template +void PrintTo(const ::std::tr1::tuple& t, + ::std::ostream* os) { + PrintTupleTo(t, os); +} + +template +void PrintTo(const ::std::tr1::tuple& t, + ::std::ostream* os) { + PrintTupleTo(t, os); +} + +template +void PrintTo(const ::std::tr1::tuple& t, + ::std::ostream* os) { + PrintTupleTo(t, os); +} + +template +void PrintTo( + const ::std::tr1::tuple& t, + ::std::ostream* os) { + PrintTupleTo(t, os); +} +#endif // GTEST_HAS_TR1_TUPLE + +// Overload for std::pair. +template +void PrintTo(const ::std::pair& value, ::std::ostream* os) { + *os << '('; + // We cannot use UniversalPrint(value.first, os) here, as T1 may be + // a reference type. The same for printing value.second. + UniversalPrinter::Print(value.first, os); + *os << ", "; + UniversalPrinter::Print(value.second, os); + *os << ')'; +} + +// Implements printing a non-reference type T by letting the compiler +// pick the right overload of PrintTo() for T. +template +class UniversalPrinter { + public: + // MSVC warns about adding const to a function type, so we want to + // disable the warning. +#ifdef _MSC_VER +# pragma warning(push) // Saves the current warning state. +# pragma warning(disable:4180) // Temporarily disables warning 4180. +#endif // _MSC_VER + + // Note: we deliberately don't call this PrintTo(), as that name + // conflicts with ::testing::internal::PrintTo in the body of the + // function. + static void Print(const T& value, ::std::ostream* os) { + // By default, ::testing::internal::PrintTo() is used for printing + // the value. + // + // Thanks to Koenig look-up, if T is a class and has its own + // PrintTo() function defined in its namespace, that function will + // be visible here. Since it is more specific than the generic ones + // in ::testing::internal, it will be picked by the compiler in the + // following statement - exactly what we want. + PrintTo(value, os); + } + +#ifdef _MSC_VER +# pragma warning(pop) // Restores the warning state. +#endif // _MSC_VER +}; + +// UniversalPrintArray(begin, len, os) prints an array of 'len' +// elements, starting at address 'begin'. +template +void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) { + if (len == 0) { + *os << "{}"; + } else { + *os << "{ "; + const size_t kThreshold = 18; + const size_t kChunkSize = 8; + // If the array has more than kThreshold elements, we'll have to + // omit some details by printing only the first and the last + // kChunkSize elements. + // TODO(wan@google.com): let the user control the threshold using a flag. + if (len <= kThreshold) { + PrintRawArrayTo(begin, len, os); + } else { + PrintRawArrayTo(begin, kChunkSize, os); + *os << ", ..., "; + PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os); + } + *os << " }"; + } +} +// This overload prints a (const) char array compactly. +GTEST_API_ void UniversalPrintArray( + const char* begin, size_t len, ::std::ostream* os); + +// This overload prints a (const) wchar_t array compactly. +GTEST_API_ void UniversalPrintArray( + const wchar_t* begin, size_t len, ::std::ostream* os); + +// Implements printing an array type T[N]. +template +class UniversalPrinter { + public: + // Prints the given array, omitting some elements when there are too + // many. + static void Print(const T (&a)[N], ::std::ostream* os) { + UniversalPrintArray(a, N, os); + } +}; + +// Implements printing a reference type T&. +template +class UniversalPrinter { + public: + // MSVC warns about adding const to a function type, so we want to + // disable the warning. +#ifdef _MSC_VER +# pragma warning(push) // Saves the current warning state. +# pragma warning(disable:4180) // Temporarily disables warning 4180. +#endif // _MSC_VER + + static void Print(const T& value, ::std::ostream* os) { + // Prints the address of the value. We use reinterpret_cast here + // as static_cast doesn't compile when T is a function type. + *os << "@" << reinterpret_cast(&value) << " "; + + // Then prints the value itself. + UniversalPrint(value, os); + } + +#ifdef _MSC_VER +# pragma warning(pop) // Restores the warning state. +#endif // _MSC_VER +}; + +// Prints a value tersely: for a reference type, the referenced value +// (but not the address) is printed; for a (const) char pointer, the +// NUL-terminated string (but not the pointer) is printed. + +template +class UniversalTersePrinter { + public: + static void Print(const T& value, ::std::ostream* os) { + UniversalPrint(value, os); + } +}; +template +class UniversalTersePrinter { + public: + static void Print(const T& value, ::std::ostream* os) { + UniversalPrint(value, os); + } +}; +template +class UniversalTersePrinter { + public: + static void Print(const T (&value)[N], ::std::ostream* os) { + UniversalPrinter::Print(value, os); + } +}; +template <> +class UniversalTersePrinter { + public: + static void Print(const char* str, ::std::ostream* os) { + if (str == NULL) { + *os << "NULL"; + } else { + UniversalPrint(string(str), os); + } + } +}; +template <> +class UniversalTersePrinter { + public: + static void Print(char* str, ::std::ostream* os) { + UniversalTersePrinter::Print(str, os); + } +}; + +#if GTEST_HAS_STD_WSTRING +template <> +class UniversalTersePrinter { + public: + static void Print(const wchar_t* str, ::std::ostream* os) { + if (str == NULL) { + *os << "NULL"; + } else { + UniversalPrint(::std::wstring(str), os); + } + } +}; +#endif + +template <> +class UniversalTersePrinter { + public: + static void Print(wchar_t* str, ::std::ostream* os) { + UniversalTersePrinter::Print(str, os); + } +}; + +template +void UniversalTersePrint(const T& value, ::std::ostream* os) { + UniversalTersePrinter::Print(value, os); +} + +// Prints a value using the type inferred by the compiler. The +// difference between this and UniversalTersePrint() is that for a +// (const) char pointer, this prints both the pointer and the +// NUL-terminated string. +template +void UniversalPrint(const T& value, ::std::ostream* os) { + // A workarond for the bug in VC++ 7.1 that prevents us from instantiating + // UniversalPrinter with T directly. + typedef T T1; + UniversalPrinter::Print(value, os); +} + +#if GTEST_HAS_TR1_TUPLE +typedef ::std::vector Strings; + +// This helper template allows PrintTo() for tuples and +// UniversalTersePrintTupleFieldsToStrings() to be defined by +// induction on the number of tuple fields. The idea is that +// TuplePrefixPrinter::PrintPrefixTo(t, os) prints the first N +// fields in tuple t, and can be defined in terms of +// TuplePrefixPrinter. + +// The inductive case. +template +struct TuplePrefixPrinter { + // Prints the first N fields of a tuple. + template + static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) { + TuplePrefixPrinter::PrintPrefixTo(t, os); + *os << ", "; + UniversalPrinter::type> + ::Print(::std::tr1::get(t), os); + } + + // Tersely prints the first N fields of a tuple to a string vector, + // one element for each field. + template + static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) { + TuplePrefixPrinter::TersePrintPrefixToStrings(t, strings); + ::std::stringstream ss; + UniversalTersePrint(::std::tr1::get(t), &ss); + strings->push_back(ss.str()); + } +}; + +// Base cases. +template <> +struct TuplePrefixPrinter<0> { + template + static void PrintPrefixTo(const Tuple&, ::std::ostream*) {} + + template + static void TersePrintPrefixToStrings(const Tuple&, Strings*) {} +}; +// We have to specialize the entire TuplePrefixPrinter<> class +// template here, even though the definition of +// TersePrintPrefixToStrings() is the same as the generic version, as +// Embarcadero (formerly CodeGear, formerly Borland) C++ doesn't +// support specializing a method template of a class template. +template <> +struct TuplePrefixPrinter<1> { + template + static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) { + UniversalPrinter::type>:: + Print(::std::tr1::get<0>(t), os); + } + + template + static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) { + ::std::stringstream ss; + UniversalTersePrint(::std::tr1::get<0>(t), &ss); + strings->push_back(ss.str()); + } +}; + +// Helper function for printing a tuple. T must be instantiated with +// a tuple type. +template +void PrintTupleTo(const T& t, ::std::ostream* os) { + *os << "("; + TuplePrefixPrinter< ::std::tr1::tuple_size::value>:: + PrintPrefixTo(t, os); + *os << ")"; +} + +// Prints the fields of a tuple tersely to a string vector, one +// element for each field. See the comment before +// UniversalTersePrint() for how we define "tersely". +template +Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) { + Strings result; + TuplePrefixPrinter< ::std::tr1::tuple_size::value>:: + TersePrintPrefixToStrings(value, &result); + return result; +} +#endif // GTEST_HAS_TR1_TUPLE + +} // namespace internal + +template +::std::string PrintToString(const T& value) { + ::std::stringstream ss; + internal::UniversalTersePrinter::Print(value, &ss); + return ss.str(); +} + +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_ + +#if GTEST_HAS_PARAM_TEST + +namespace testing { +namespace internal { + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// Outputs a message explaining invalid registration of different +// fixture class for the same test case. This may happen when +// TEST_P macro is used to define two tests with the same name +// but in different namespaces. +GTEST_API_ void ReportInvalidTestCaseType(const char* test_case_name, + const char* file, int line); + +template class ParamGeneratorInterface; +template class ParamGenerator; + +// Interface for iterating over elements provided by an implementation +// of ParamGeneratorInterface. +template +class ParamIteratorInterface { + public: + virtual ~ParamIteratorInterface() {} + // A pointer to the base generator instance. + // Used only for the purposes of iterator comparison + // to make sure that two iterators belong to the same generator. + virtual const ParamGeneratorInterface* BaseGenerator() const = 0; + // Advances iterator to point to the next element + // provided by the generator. The caller is responsible + // for not calling Advance() on an iterator equal to + // BaseGenerator()->End(). + virtual void Advance() = 0; + // Clones the iterator object. Used for implementing copy semantics + // of ParamIterator. + virtual ParamIteratorInterface* Clone() const = 0; + // Dereferences the current iterator and provides (read-only) access + // to the pointed value. It is the caller's responsibility not to call + // Current() on an iterator equal to BaseGenerator()->End(). + // Used for implementing ParamGenerator::operator*(). + virtual const T* Current() const = 0; + // Determines whether the given iterator and other point to the same + // element in the sequence generated by the generator. + // Used for implementing ParamGenerator::operator==(). + virtual bool Equals(const ParamIteratorInterface& other) const = 0; +}; + +// Class iterating over elements provided by an implementation of +// ParamGeneratorInterface. It wraps ParamIteratorInterface +// and implements the const forward iterator concept. +template +class ParamIterator { + public: + typedef T value_type; + typedef const T& reference; + typedef ptrdiff_t difference_type; + + // ParamIterator assumes ownership of the impl_ pointer. + ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {} + ParamIterator& operator=(const ParamIterator& other) { + if (this != &other) + impl_.reset(other.impl_->Clone()); + return *this; + } + + const T& operator*() const { return *impl_->Current(); } + const T* operator->() const { return impl_->Current(); } + // Prefix version of operator++. + ParamIterator& operator++() { + impl_->Advance(); + return *this; + } + // Postfix version of operator++. + ParamIterator operator++(int /*unused*/) { + ParamIteratorInterface* clone = impl_->Clone(); + impl_->Advance(); + return ParamIterator(clone); + } + bool operator==(const ParamIterator& other) const { + return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_); + } + bool operator!=(const ParamIterator& other) const { + return !(*this == other); + } + + private: + friend class ParamGenerator; + explicit ParamIterator(ParamIteratorInterface* impl) : impl_(impl) {} + scoped_ptr > impl_; +}; + +// ParamGeneratorInterface is the binary interface to access generators +// defined in other translation units. +template +class ParamGeneratorInterface { + public: + typedef T ParamType; + + virtual ~ParamGeneratorInterface() {} + + // Generator interface definition + virtual ParamIteratorInterface* Begin() const = 0; + virtual ParamIteratorInterface* End() const = 0; +}; + +// Wraps ParamGeneratorInterface and provides general generator syntax +// compatible with the STL Container concept. +// This class implements copy initialization semantics and the contained +// ParamGeneratorInterface instance is shared among all copies +// of the original object. This is possible because that instance is immutable. +template +class ParamGenerator { + public: + typedef ParamIterator iterator; + + explicit ParamGenerator(ParamGeneratorInterface* impl) : impl_(impl) {} + ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {} + + ParamGenerator& operator=(const ParamGenerator& other) { + impl_ = other.impl_; + return *this; + } + + iterator begin() const { return iterator(impl_->Begin()); } + iterator end() const { return iterator(impl_->End()); } + + private: + linked_ptr > impl_; +}; + +// Generates values from a range of two comparable values. Can be used to +// generate sequences of user-defined types that implement operator+() and +// operator<(). +// This class is used in the Range() function. +template +class RangeGenerator : public ParamGeneratorInterface { + public: + RangeGenerator(T begin, T end, IncrementT step) + : begin_(begin), end_(end), + step_(step), end_index_(CalculateEndIndex(begin, end, step)) {} + virtual ~RangeGenerator() {} + + virtual ParamIteratorInterface* Begin() const { + return new Iterator(this, begin_, 0, step_); + } + virtual ParamIteratorInterface* End() const { + return new Iterator(this, end_, end_index_, step_); + } + + private: + class Iterator : public ParamIteratorInterface { + public: + Iterator(const ParamGeneratorInterface* base, T value, int index, + IncrementT step) + : base_(base), value_(value), index_(index), step_(step) {} + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface* BaseGenerator() const { + return base_; + } + virtual void Advance() { + value_ = value_ + step_; + index_++; + } + virtual ParamIteratorInterface* Clone() const { + return new Iterator(*this); + } + virtual const T* Current() const { return &value_; } + virtual bool Equals(const ParamIteratorInterface& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + const int other_index = + CheckedDowncastToActualType(&other)->index_; + return index_ == other_index; + } + + private: + Iterator(const Iterator& other) + : ParamIteratorInterface(), + base_(other.base_), value_(other.value_), index_(other.index_), + step_(other.step_) {} + + // No implementation - assignment is unsupported. + void operator=(const Iterator& other); + + const ParamGeneratorInterface* const base_; + T value_; + int index_; + const IncrementT step_; + }; // class RangeGenerator::Iterator + + static int CalculateEndIndex(const T& begin, + const T& end, + const IncrementT& step) { + int end_index = 0; + for (T i = begin; i < end; i = i + step) + end_index++; + return end_index; + } + + // No implementation - assignment is unsupported. + void operator=(const RangeGenerator& other); + + const T begin_; + const T end_; + const IncrementT step_; + // The index for the end() iterator. All the elements in the generated + // sequence are indexed (0-based) to aid iterator comparison. + const int end_index_; +}; // class RangeGenerator + + +// Generates values from a pair of STL-style iterators. Used in the +// ValuesIn() function. The elements are copied from the source range +// since the source can be located on the stack, and the generator +// is likely to persist beyond that stack frame. +template +class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface { + public: + template + ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end) + : container_(begin, end) {} + virtual ~ValuesInIteratorRangeGenerator() {} + + virtual ParamIteratorInterface* Begin() const { + return new Iterator(this, container_.begin()); + } + virtual ParamIteratorInterface* End() const { + return new Iterator(this, container_.end()); + } + + private: + typedef typename ::std::vector ContainerType; + + class Iterator : public ParamIteratorInterface { + public: + Iterator(const ParamGeneratorInterface* base, + typename ContainerType::const_iterator iterator) + : base_(base), iterator_(iterator) {} + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface* BaseGenerator() const { + return base_; + } + virtual void Advance() { + ++iterator_; + value_.reset(); + } + virtual ParamIteratorInterface* Clone() const { + return new Iterator(*this); + } + // We need to use cached value referenced by iterator_ because *iterator_ + // can return a temporary object (and of type other then T), so just + // having "return &*iterator_;" doesn't work. + // value_ is updated here and not in Advance() because Advance() + // can advance iterator_ beyond the end of the range, and we cannot + // detect that fact. The client code, on the other hand, is + // responsible for not calling Current() on an out-of-range iterator. + virtual const T* Current() const { + if (value_.get() == NULL) + value_.reset(new T(*iterator_)); + return value_.get(); + } + virtual bool Equals(const ParamIteratorInterface& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + return iterator_ == + CheckedDowncastToActualType(&other)->iterator_; + } + + private: + Iterator(const Iterator& other) + // The explicit constructor call suppresses a false warning + // emitted by gcc when supplied with the -Wextra option. + : ParamIteratorInterface(), + base_(other.base_), + iterator_(other.iterator_) {} + + const ParamGeneratorInterface* const base_; + typename ContainerType::const_iterator iterator_; + // A cached value of *iterator_. We keep it here to allow access by + // pointer in the wrapping iterator's operator->(). + // value_ needs to be mutable to be accessed in Current(). + // Use of scoped_ptr helps manage cached value's lifetime, + // which is bound by the lifespan of the iterator itself. + mutable scoped_ptr value_; + }; // class ValuesInIteratorRangeGenerator::Iterator + + // No implementation - assignment is unsupported. + void operator=(const ValuesInIteratorRangeGenerator& other); + + const ContainerType container_; +}; // class ValuesInIteratorRangeGenerator + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// Stores a parameter value and later creates tests parameterized with that +// value. +template +class ParameterizedTestFactory : public TestFactoryBase { + public: + typedef typename TestClass::ParamType ParamType; + explicit ParameterizedTestFactory(ParamType parameter) : + parameter_(parameter) {} + virtual Test* CreateTest() { + TestClass::SetParam(¶meter_); + return new TestClass(); + } + + private: + const ParamType parameter_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory); +}; + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// TestMetaFactoryBase is a base class for meta-factories that create +// test factories for passing into MakeAndRegisterTestInfo function. +template +class TestMetaFactoryBase { + public: + virtual ~TestMetaFactoryBase() {} + + virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0; +}; + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// TestMetaFactory creates test factories for passing into +// MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives +// ownership of test factory pointer, same factory object cannot be passed +// into that method twice. But ParameterizedTestCaseInfo is going to call +// it for each Test/Parameter value combination. Thus it needs meta factory +// creator class. +template +class TestMetaFactory + : public TestMetaFactoryBase { + public: + typedef typename TestCase::ParamType ParamType; + + TestMetaFactory() {} + + virtual TestFactoryBase* CreateTestFactory(ParamType parameter) { + return new ParameterizedTestFactory(parameter); + } + + private: + GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory); +}; + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// ParameterizedTestCaseInfoBase is a generic interface +// to ParameterizedTestCaseInfo classes. ParameterizedTestCaseInfoBase +// accumulates test information provided by TEST_P macro invocations +// and generators provided by INSTANTIATE_TEST_CASE_P macro invocations +// and uses that information to register all resulting test instances +// in RegisterTests method. The ParameterizeTestCaseRegistry class holds +// a collection of pointers to the ParameterizedTestCaseInfo objects +// and calls RegisterTests() on each of them when asked. +class ParameterizedTestCaseInfoBase { + public: + virtual ~ParameterizedTestCaseInfoBase() {} + + // Base part of test case name for display purposes. + virtual const string& GetTestCaseName() const = 0; + // Test case id to verify identity. + virtual TypeId GetTestCaseTypeId() const = 0; + // UnitTest class invokes this method to register tests in this + // test case right before running them in RUN_ALL_TESTS macro. + // This method should not be called more then once on any single + // instance of a ParameterizedTestCaseInfoBase derived class. + virtual void RegisterTests() = 0; + + protected: + ParameterizedTestCaseInfoBase() {} + + private: + GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfoBase); +}; + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// ParameterizedTestCaseInfo accumulates tests obtained from TEST_P +// macro invocations for a particular test case and generators +// obtained from INSTANTIATE_TEST_CASE_P macro invocations for that +// test case. It registers tests with all values generated by all +// generators when asked. +template +class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase { + public: + // ParamType and GeneratorCreationFunc are private types but are required + // for declarations of public methods AddTestPattern() and + // AddTestCaseInstantiation(). + typedef typename TestCase::ParamType ParamType; + // A function that returns an instance of appropriate generator type. + typedef ParamGenerator(GeneratorCreationFunc)(); + + explicit ParameterizedTestCaseInfo(const char* name) + : test_case_name_(name) {} + + // Test case base name for display purposes. + virtual const string& GetTestCaseName() const { return test_case_name_; } + // Test case id to verify identity. + virtual TypeId GetTestCaseTypeId() const { return GetTypeId(); } + // TEST_P macro uses AddTestPattern() to record information + // about a single test in a LocalTestInfo structure. + // test_case_name is the base name of the test case (without invocation + // prefix). test_base_name is the name of an individual test without + // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is + // test case base name and DoBar is test base name. + void AddTestPattern(const char* test_case_name, + const char* test_base_name, + TestMetaFactoryBase* meta_factory) { + tests_.push_back(linked_ptr(new TestInfo(test_case_name, + test_base_name, + meta_factory))); + } + // INSTANTIATE_TEST_CASE_P macro uses AddGenerator() to record information + // about a generator. + int AddTestCaseInstantiation(const string& instantiation_name, + GeneratorCreationFunc* func, + const char* /* file */, + int /* line */) { + instantiations_.push_back(::std::make_pair(instantiation_name, func)); + return 0; // Return value used only to run this method in namespace scope. + } + // UnitTest class invokes this method to register tests in this test case + // test cases right before running tests in RUN_ALL_TESTS macro. + // This method should not be called more then once on any single + // instance of a ParameterizedTestCaseInfoBase derived class. + // UnitTest has a guard to prevent from calling this method more then once. + virtual void RegisterTests() { + for (typename TestInfoContainer::iterator test_it = tests_.begin(); + test_it != tests_.end(); ++test_it) { + linked_ptr test_info = *test_it; + for (typename InstantiationContainer::iterator gen_it = + instantiations_.begin(); gen_it != instantiations_.end(); + ++gen_it) { + const string& instantiation_name = gen_it->first; + ParamGenerator generator((*gen_it->second)()); + + string test_case_name; + if ( !instantiation_name.empty() ) + test_case_name = instantiation_name + "/"; + test_case_name += test_info->test_case_base_name; + + int i = 0; + for (typename ParamGenerator::iterator param_it = + generator.begin(); + param_it != generator.end(); ++param_it, ++i) { + Message test_name_stream; + test_name_stream << test_info->test_base_name << "/" << i; + MakeAndRegisterTestInfo( + test_case_name.c_str(), + test_name_stream.GetString().c_str(), + NULL, // No type parameter. + PrintToString(*param_it).c_str(), + GetTestCaseTypeId(), + TestCase::SetUpTestCase, + TestCase::TearDownTestCase, + test_info->test_meta_factory->CreateTestFactory(*param_it)); + } // for param_it + } // for gen_it + } // for test_it + } // RegisterTests + + private: + // LocalTestInfo structure keeps information about a single test registered + // with TEST_P macro. + struct TestInfo { + TestInfo(const char* a_test_case_base_name, + const char* a_test_base_name, + TestMetaFactoryBase* a_test_meta_factory) : + test_case_base_name(a_test_case_base_name), + test_base_name(a_test_base_name), + test_meta_factory(a_test_meta_factory) {} + + const string test_case_base_name; + const string test_base_name; + const scoped_ptr > test_meta_factory; + }; + typedef ::std::vector > TestInfoContainer; + // Keeps pairs of + // received from INSTANTIATE_TEST_CASE_P macros. + typedef ::std::vector > + InstantiationContainer; + + const string test_case_name_; + TestInfoContainer tests_; + InstantiationContainer instantiations_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfo); +}; // class ParameterizedTestCaseInfo + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// ParameterizedTestCaseRegistry contains a map of ParameterizedTestCaseInfoBase +// classes accessed by test case names. TEST_P and INSTANTIATE_TEST_CASE_P +// macros use it to locate their corresponding ParameterizedTestCaseInfo +// descriptors. +class ParameterizedTestCaseRegistry { + public: + ParameterizedTestCaseRegistry() {} + ~ParameterizedTestCaseRegistry() { + for (TestCaseInfoContainer::iterator it = test_case_infos_.begin(); + it != test_case_infos_.end(); ++it) { + delete *it; + } + } + + // Looks up or creates and returns a structure containing information about + // tests and instantiations of a particular test case. + template + ParameterizedTestCaseInfo* GetTestCasePatternHolder( + const char* test_case_name, + const char* file, + int line) { + ParameterizedTestCaseInfo* typed_test_info = NULL; + for (TestCaseInfoContainer::iterator it = test_case_infos_.begin(); + it != test_case_infos_.end(); ++it) { + if ((*it)->GetTestCaseName() == test_case_name) { + if ((*it)->GetTestCaseTypeId() != GetTypeId()) { + // Complain about incorrect usage of Google Test facilities + // and terminate the program since we cannot guaranty correct + // test case setup and tear-down in this case. + ReportInvalidTestCaseType(test_case_name, file, line); + posix::Abort(); + } else { + // At this point we are sure that the object we found is of the same + // type we are looking for, so we downcast it to that type + // without further checks. + typed_test_info = CheckedDowncastToActualType< + ParameterizedTestCaseInfo >(*it); + } + break; + } + } + if (typed_test_info == NULL) { + typed_test_info = new ParameterizedTestCaseInfo(test_case_name); + test_case_infos_.push_back(typed_test_info); + } + return typed_test_info; + } + void RegisterTests() { + for (TestCaseInfoContainer::iterator it = test_case_infos_.begin(); + it != test_case_infos_.end(); ++it) { + (*it)->RegisterTests(); + } + } + + private: + typedef ::std::vector TestCaseInfoContainer; + + TestCaseInfoContainer test_case_infos_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseRegistry); +}; + +} // namespace internal +} // namespace testing + +#endif // GTEST_HAS_PARAM_TEST + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ +// This file was GENERATED by command: +// pump.py gtest-param-util-generated.h.pump +// DO NOT EDIT BY HAND!!! + +// 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. +// +// Author: vladl@google.com (Vlad Losev) + +// Type and function utilities for implementing parameterized tests. +// This file is generated by a SCRIPT. DO NOT EDIT BY HAND! +// +// Currently Google Test supports at most 50 arguments in Values, +// and at most 10 arguments in Combine. Please contact +// googletestframework@googlegroups.com if you need more. +// Please note that the number of arguments to Combine is limited +// by the maximum arity of the implementation of tr1::tuple which is +// currently set at 10. + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_ + +// scripts/fuse_gtest.py depends on gtest's own header being #included +// *unconditionally*. Therefore these #includes cannot be moved +// inside #if GTEST_HAS_PARAM_TEST. + +#if GTEST_HAS_PARAM_TEST + +namespace testing { + +// Forward declarations of ValuesIn(), which is implemented in +// include/gtest/gtest-param-test.h. +template +internal::ParamGenerator< + typename ::testing::internal::IteratorTraits::value_type> +ValuesIn(ForwardIterator begin, ForwardIterator end); + +template +internal::ParamGenerator ValuesIn(const T (&array)[N]); + +template +internal::ParamGenerator ValuesIn( + const Container& container); + +namespace internal { + +// Used in the Values() function to provide polymorphic capabilities. +template +class ValueArray1 { + public: + explicit ValueArray1(T1 v1) : v1_(v1) {} + + template + operator ParamGenerator() const { return ValuesIn(&v1_, &v1_ + 1); } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray1& other); + + const T1 v1_; +}; + +template +class ValueArray2 { + public: + ValueArray2(T1 v1, T2 v2) : v1_(v1), v2_(v2) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray2& other); + + const T1 v1_; + const T2 v2_; +}; + +template +class ValueArray3 { + public: + ValueArray3(T1 v1, T2 v2, T3 v3) : v1_(v1), v2_(v2), v3_(v3) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray3& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; +}; + +template +class ValueArray4 { + public: + ValueArray4(T1 v1, T2 v2, T3 v3, T4 v4) : v1_(v1), v2_(v2), v3_(v3), + v4_(v4) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray4& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; +}; + +template +class ValueArray5 { + public: + ValueArray5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) : v1_(v1), v2_(v2), v3_(v3), + v4_(v4), v5_(v5) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray5& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; +}; + +template +class ValueArray6 { + public: + ValueArray6(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) : v1_(v1), v2_(v2), + v3_(v3), v4_(v4), v5_(v5), v6_(v6) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray6& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; +}; + +template +class ValueArray7 { + public: + ValueArray7(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) : v1_(v1), + v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray7& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; +}; + +template +class ValueArray8 { + public: + ValueArray8(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, + T8 v8) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray8& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; +}; + +template +class ValueArray9 { + public: + ValueArray9(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, + T9 v9) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray9& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; +}; + +template +class ValueArray10 { + public: + ValueArray10(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray10& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; +}; + +template +class ValueArray11 { + public: + ValueArray11(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), + v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray11& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; +}; + +template +class ValueArray12 { + public: + ValueArray12(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), + v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray12& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; +}; + +template +class ValueArray13 { + public: + ValueArray13(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), + v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), + v12_(v12), v13_(v13) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray13& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; +}; + +template +class ValueArray14 { + public: + ValueArray14(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) : v1_(v1), v2_(v2), v3_(v3), + v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), + v11_(v11), v12_(v12), v13_(v13), v14_(v14) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray14& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; +}; + +template +class ValueArray15 { + public: + ValueArray15(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) : v1_(v1), v2_(v2), + v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), + v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray15& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; +}; + +template +class ValueArray16 { + public: + ValueArray16(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16) : v1_(v1), + v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), + v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), + v16_(v16) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray16& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; +}; + +template +class ValueArray17 { + public: + ValueArray17(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, + T17 v17) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), + v15_(v15), v16_(v16), v17_(v17) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray17& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; +}; + +template +class ValueArray18 { + public: + ValueArray18(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), + v15_(v15), v16_(v16), v17_(v17), v18_(v18) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray18& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; +}; + +template +class ValueArray19 { + public: + ValueArray19(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), + v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), + v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray19& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; +}; + +template +class ValueArray20 { + public: + ValueArray20(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), + v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), + v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), + v19_(v19), v20_(v20) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray20& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; +}; + +template +class ValueArray21 { + public: + ValueArray21(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), + v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), + v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), + v18_(v18), v19_(v19), v20_(v20), v21_(v21) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray21& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; +}; + +template +class ValueArray22 { + public: + ValueArray22(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22) : v1_(v1), v2_(v2), v3_(v3), + v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), + v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), + v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray22& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; +}; + +template +class ValueArray23 { + public: + ValueArray23(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23) : v1_(v1), v2_(v2), + v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), + v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), + v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), + v23_(v23) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray23& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; +}; + +template +class ValueArray24 { + public: + ValueArray24(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24) : v1_(v1), + v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), + v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), + v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), + v22_(v22), v23_(v23), v24_(v24) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray24& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; +}; + +template +class ValueArray25 { + public: + ValueArray25(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, + T25 v25) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), + v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), + v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray25& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; +}; + +template +class ValueArray26 { + public: + ValueArray26(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), + v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), + v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray26& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; +}; + +template +class ValueArray27 { + public: + ValueArray27(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), + v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), + v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), + v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), + v26_(v26), v27_(v27) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray27& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; +}; + +template +class ValueArray28 { + public: + ValueArray28(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), + v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), + v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), + v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), + v25_(v25), v26_(v26), v27_(v27), v28_(v28) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray28& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; +}; + +template +class ValueArray29 { + public: + ValueArray29(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), + v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), + v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), + v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), + v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray29& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; +}; + +template +class ValueArray30 { + public: + ValueArray30(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) : v1_(v1), v2_(v2), v3_(v3), + v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), + v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), + v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), + v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), + v29_(v29), v30_(v30) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_), + static_cast(v30_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray30& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; +}; + +template +class ValueArray31 { + public: + ValueArray31(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31) : v1_(v1), v2_(v2), + v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), + v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), + v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), + v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), + v29_(v29), v30_(v30), v31_(v31) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_), + static_cast(v30_), static_cast(v31_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray31& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; +}; + +template +class ValueArray32 { + public: + ValueArray32(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32) : v1_(v1), + v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), + v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), + v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), + v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), + v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_), + static_cast(v30_), static_cast(v31_), static_cast(v32_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray32& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; +}; + +template +class ValueArray33 { + public: + ValueArray33(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, + T33 v33) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), + v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), + v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), + v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), + v33_(v33) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_), + static_cast(v30_), static_cast(v31_), static_cast(v32_), + static_cast(v33_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray33& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; +}; + +template +class ValueArray34 { + public: + ValueArray34(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), + v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), + v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), + v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), + v33_(v33), v34_(v34) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_), + static_cast(v30_), static_cast(v31_), static_cast(v32_), + static_cast(v33_), static_cast(v34_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray34& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; +}; + +template +class ValueArray35 { + public: + ValueArray35(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), + v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), + v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), + v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), + v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), + v32_(v32), v33_(v33), v34_(v34), v35_(v35) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_), + static_cast(v30_), static_cast(v31_), static_cast(v32_), + static_cast(v33_), static_cast(v34_), static_cast(v35_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray35& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; +}; + +template +class ValueArray36 { + public: + ValueArray36(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), + v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), + v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), + v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), + v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), + v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_), + static_cast(v30_), static_cast(v31_), static_cast(v32_), + static_cast(v33_), static_cast(v34_), static_cast(v35_), + static_cast(v36_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray36& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; +}; + +template +class ValueArray37 { + public: + ValueArray37(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), + v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), + v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), + v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), + v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), + v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), + v36_(v36), v37_(v37) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_), + static_cast(v30_), static_cast(v31_), static_cast(v32_), + static_cast(v33_), static_cast(v34_), static_cast(v35_), + static_cast(v36_), static_cast(v37_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray37& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; +}; + +template +class ValueArray38 { + public: + ValueArray38(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38) : v1_(v1), v2_(v2), v3_(v3), + v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), + v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), + v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), + v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), + v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), + v35_(v35), v36_(v36), v37_(v37), v38_(v38) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_), + static_cast(v30_), static_cast(v31_), static_cast(v32_), + static_cast(v33_), static_cast(v34_), static_cast(v35_), + static_cast(v36_), static_cast(v37_), static_cast(v38_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray38& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; +}; + +template +class ValueArray39 { + public: + ValueArray39(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39) : v1_(v1), v2_(v2), + v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), + v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), + v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), + v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), + v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), + v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_), + static_cast(v30_), static_cast(v31_), static_cast(v32_), + static_cast(v33_), static_cast(v34_), static_cast(v35_), + static_cast(v36_), static_cast(v37_), static_cast(v38_), + static_cast(v39_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray39& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; +}; + +template +class ValueArray40 { + public: + ValueArray40(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40) : v1_(v1), + v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), + v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), + v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), + v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), + v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), + v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), + v40_(v40) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_), + static_cast(v30_), static_cast(v31_), static_cast(v32_), + static_cast(v33_), static_cast(v34_), static_cast(v35_), + static_cast(v36_), static_cast(v37_), static_cast(v38_), + static_cast(v39_), static_cast(v40_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray40& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; +}; + +template +class ValueArray41 { + public: + ValueArray41(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, + T41 v41) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), + v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), + v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), + v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), + v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), + v39_(v39), v40_(v40), v41_(v41) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_), + static_cast(v30_), static_cast(v31_), static_cast(v32_), + static_cast(v33_), static_cast(v34_), static_cast(v35_), + static_cast(v36_), static_cast(v37_), static_cast(v38_), + static_cast(v39_), static_cast(v40_), static_cast(v41_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray41& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; + const T41 v41_; +}; + +template +class ValueArray42 { + public: + ValueArray42(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), + v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), + v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), + v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), + v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), + v39_(v39), v40_(v40), v41_(v41), v42_(v42) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_), + static_cast(v30_), static_cast(v31_), static_cast(v32_), + static_cast(v33_), static_cast(v34_), static_cast(v35_), + static_cast(v36_), static_cast(v37_), static_cast(v38_), + static_cast(v39_), static_cast(v40_), static_cast(v41_), + static_cast(v42_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray42& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; + const T41 v41_; + const T42 v42_; +}; + +template +class ValueArray43 { + public: + ValueArray43(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42, T43 v43) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), + v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), + v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), + v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), + v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), + v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), + v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_), + static_cast(v30_), static_cast(v31_), static_cast(v32_), + static_cast(v33_), static_cast(v34_), static_cast(v35_), + static_cast(v36_), static_cast(v37_), static_cast(v38_), + static_cast(v39_), static_cast(v40_), static_cast(v41_), + static_cast(v42_), static_cast(v43_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray43& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; + const T41 v41_; + const T42 v42_; + const T43 v43_; +}; + +template +class ValueArray44 { + public: + ValueArray44(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42, T43 v43, T44 v44) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), + v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), + v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), + v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), + v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), + v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), + v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42), + v43_(v43), v44_(v44) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_), + static_cast(v30_), static_cast(v31_), static_cast(v32_), + static_cast(v33_), static_cast(v34_), static_cast(v35_), + static_cast(v36_), static_cast(v37_), static_cast(v38_), + static_cast(v39_), static_cast(v40_), static_cast(v41_), + static_cast(v42_), static_cast(v43_), static_cast(v44_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray44& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; + const T41 v41_; + const T42 v42_; + const T43 v43_; + const T44 v44_; +}; + +template +class ValueArray45 { + public: + ValueArray45(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42, T43 v43, T44 v44, T45 v45) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), + v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), + v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), + v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), + v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), + v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), + v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41), + v42_(v42), v43_(v43), v44_(v44), v45_(v45) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_), + static_cast(v30_), static_cast(v31_), static_cast(v32_), + static_cast(v33_), static_cast(v34_), static_cast(v35_), + static_cast(v36_), static_cast(v37_), static_cast(v38_), + static_cast(v39_), static_cast(v40_), static_cast(v41_), + static_cast(v42_), static_cast(v43_), static_cast(v44_), + static_cast(v45_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray45& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; + const T41 v41_; + const T42 v42_; + const T43 v43_; + const T44 v44_; + const T45 v45_; +}; + +template +class ValueArray46 { + public: + ValueArray46(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42, T43 v43, T44 v44, T45 v45, T46 v46) : v1_(v1), v2_(v2), v3_(v3), + v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), + v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), + v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), + v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), + v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), + v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), + v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_), + static_cast(v30_), static_cast(v31_), static_cast(v32_), + static_cast(v33_), static_cast(v34_), static_cast(v35_), + static_cast(v36_), static_cast(v37_), static_cast(v38_), + static_cast(v39_), static_cast(v40_), static_cast(v41_), + static_cast(v42_), static_cast(v43_), static_cast(v44_), + static_cast(v45_), static_cast(v46_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray46& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; + const T41 v41_; + const T42 v42_; + const T43 v43_; + const T44 v44_; + const T45 v45_; + const T46 v46_; +}; + +template +class ValueArray47 { + public: + ValueArray47(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47) : v1_(v1), v2_(v2), + v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), + v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), + v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), + v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), + v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), + v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), + v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46), + v47_(v47) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_), + static_cast(v30_), static_cast(v31_), static_cast(v32_), + static_cast(v33_), static_cast(v34_), static_cast(v35_), + static_cast(v36_), static_cast(v37_), static_cast(v38_), + static_cast(v39_), static_cast(v40_), static_cast(v41_), + static_cast(v42_), static_cast(v43_), static_cast(v44_), + static_cast(v45_), static_cast(v46_), static_cast(v47_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray47& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; + const T41 v41_; + const T42 v42_; + const T43 v43_; + const T44 v44_; + const T45 v45_; + const T46 v46_; + const T47 v47_; +}; + +template +class ValueArray48 { + public: + ValueArray48(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48) : v1_(v1), + v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), + v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), + v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), + v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), + v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), + v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), + v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), + v46_(v46), v47_(v47), v48_(v48) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_), + static_cast(v30_), static_cast(v31_), static_cast(v32_), + static_cast(v33_), static_cast(v34_), static_cast(v35_), + static_cast(v36_), static_cast(v37_), static_cast(v38_), + static_cast(v39_), static_cast(v40_), static_cast(v41_), + static_cast(v42_), static_cast(v43_), static_cast(v44_), + static_cast(v45_), static_cast(v46_), static_cast(v47_), + static_cast(v48_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray48& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; + const T41 v41_; + const T42 v42_; + const T43 v43_; + const T44 v44_; + const T45 v45_; + const T46 v46_; + const T47 v47_; + const T48 v48_; +}; + +template +class ValueArray49 { + public: + ValueArray49(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48, + T49 v49) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), + v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), + v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), + v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), + v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), + v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44), + v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_), + static_cast(v30_), static_cast(v31_), static_cast(v32_), + static_cast(v33_), static_cast(v34_), static_cast(v35_), + static_cast(v36_), static_cast(v37_), static_cast(v38_), + static_cast(v39_), static_cast(v40_), static_cast(v41_), + static_cast(v42_), static_cast(v43_), static_cast(v44_), + static_cast(v45_), static_cast(v46_), static_cast(v47_), + static_cast(v48_), static_cast(v49_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray49& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; + const T41 v41_; + const T42 v42_; + const T43 v43_; + const T44 v44_; + const T45 v45_; + const T46 v46_; + const T47 v47_; + const T48 v48_; + const T49 v49_; +}; + +template +class ValueArray50 { + public: + ValueArray50(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48, T49 v49, + T50 v50) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), + v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), + v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), + v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), + v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), + v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44), + v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49), v50_(v50) {} + + template + operator ParamGenerator() const { + const T array[] = {static_cast(v1_), static_cast(v2_), + static_cast(v3_), static_cast(v4_), static_cast(v5_), + static_cast(v6_), static_cast(v7_), static_cast(v8_), + static_cast(v9_), static_cast(v10_), static_cast(v11_), + static_cast(v12_), static_cast(v13_), static_cast(v14_), + static_cast(v15_), static_cast(v16_), static_cast(v17_), + static_cast(v18_), static_cast(v19_), static_cast(v20_), + static_cast(v21_), static_cast(v22_), static_cast(v23_), + static_cast(v24_), static_cast(v25_), static_cast(v26_), + static_cast(v27_), static_cast(v28_), static_cast(v29_), + static_cast(v30_), static_cast(v31_), static_cast(v32_), + static_cast(v33_), static_cast(v34_), static_cast(v35_), + static_cast(v36_), static_cast(v37_), static_cast(v38_), + static_cast(v39_), static_cast(v40_), static_cast(v41_), + static_cast(v42_), static_cast(v43_), static_cast(v44_), + static_cast(v45_), static_cast(v46_), static_cast(v47_), + static_cast(v48_), static_cast(v49_), static_cast(v50_)}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray50& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; + const T9 v9_; + const T10 v10_; + const T11 v11_; + const T12 v12_; + const T13 v13_; + const T14 v14_; + const T15 v15_; + const T16 v16_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; + const T41 v41_; + const T42 v42_; + const T43 v43_; + const T44 v44_; + const T45 v45_; + const T46 v46_; + const T47 v47_; + const T48 v48_; + const T49 v49_; + const T50 v50_; +}; + +# if GTEST_HAS_COMBINE +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// Generates values from the Cartesian product of values produced +// by the argument generators. +// +template +class CartesianProductGenerator2 + : public ParamGeneratorInterface< ::std::tr1::tuple > { + public: + typedef ::std::tr1::tuple ParamType; + + CartesianProductGenerator2(const ParamGenerator& g1, + const ParamGenerator& g2) + : g1_(g1), g2_(g2) {} + virtual ~CartesianProductGenerator2() {} + + virtual ParamIteratorInterface* Begin() const { + return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin()); + } + virtual ParamIteratorInterface* End() const { + return new Iterator(this, g1_, g1_.end(), g2_, g2_.end()); + } + + private: + class Iterator : public ParamIteratorInterface { + public: + Iterator(const ParamGeneratorInterface* base, + const ParamGenerator& g1, + const typename ParamGenerator::iterator& current1, + const ParamGenerator& g2, + const typename ParamGenerator::iterator& current2) + : base_(base), + begin1_(g1.begin()), end1_(g1.end()), current1_(current1), + begin2_(g2.begin()), end2_(g2.end()), current2_(current2) { + ComputeCurrentValue(); + } + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface* BaseGenerator() const { + return base_; + } + // Advance should not be called on beyond-of-range iterators + // so no component iterators must be beyond end of range, either. + virtual void Advance() { + assert(!AtEnd()); + ++current2_; + if (current2_ == end2_) { + current2_ = begin2_; + ++current1_; + } + ComputeCurrentValue(); + } + virtual ParamIteratorInterface* Clone() const { + return new Iterator(*this); + } + virtual const ParamType* Current() const { return ¤t_value_; } + virtual bool Equals(const ParamIteratorInterface& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + const Iterator* typed_other = + CheckedDowncastToActualType(&other); + // We must report iterators equal if they both point beyond their + // respective ranges. That can happen in a variety of fashions, + // so we have to consult AtEnd(). + return (AtEnd() && typed_other->AtEnd()) || + ( + current1_ == typed_other->current1_ && + current2_ == typed_other->current2_); + } + + private: + Iterator(const Iterator& other) + : base_(other.base_), + begin1_(other.begin1_), + end1_(other.end1_), + current1_(other.current1_), + begin2_(other.begin2_), + end2_(other.end2_), + current2_(other.current2_) { + ComputeCurrentValue(); + } + + void ComputeCurrentValue() { + if (!AtEnd()) + current_value_ = ParamType(*current1_, *current2_); + } + bool AtEnd() const { + // We must report iterator past the end of the range when either of the + // component iterators has reached the end of its range. + return + current1_ == end1_ || + current2_ == end2_; + } + + // No implementation - assignment is unsupported. + void operator=(const Iterator& other); + + const ParamGeneratorInterface* const base_; + // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. + // current[i]_ is the actual traversing iterator. + const typename ParamGenerator::iterator begin1_; + const typename ParamGenerator::iterator end1_; + typename ParamGenerator::iterator current1_; + const typename ParamGenerator::iterator begin2_; + const typename ParamGenerator::iterator end2_; + typename ParamGenerator::iterator current2_; + ParamType current_value_; + }; // class CartesianProductGenerator2::Iterator + + // No implementation - assignment is unsupported. + void operator=(const CartesianProductGenerator2& other); + + const ParamGenerator g1_; + const ParamGenerator g2_; +}; // class CartesianProductGenerator2 + + +template +class CartesianProductGenerator3 + : public ParamGeneratorInterface< ::std::tr1::tuple > { + public: + typedef ::std::tr1::tuple ParamType; + + CartesianProductGenerator3(const ParamGenerator& g1, + const ParamGenerator& g2, const ParamGenerator& g3) + : g1_(g1), g2_(g2), g3_(g3) {} + virtual ~CartesianProductGenerator3() {} + + virtual ParamIteratorInterface* Begin() const { + return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, + g3_.begin()); + } + virtual ParamIteratorInterface* End() const { + return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end()); + } + + private: + class Iterator : public ParamIteratorInterface { + public: + Iterator(const ParamGeneratorInterface* base, + const ParamGenerator& g1, + const typename ParamGenerator::iterator& current1, + const ParamGenerator& g2, + const typename ParamGenerator::iterator& current2, + const ParamGenerator& g3, + const typename ParamGenerator::iterator& current3) + : base_(base), + begin1_(g1.begin()), end1_(g1.end()), current1_(current1), + begin2_(g2.begin()), end2_(g2.end()), current2_(current2), + begin3_(g3.begin()), end3_(g3.end()), current3_(current3) { + ComputeCurrentValue(); + } + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface* BaseGenerator() const { + return base_; + } + // Advance should not be called on beyond-of-range iterators + // so no component iterators must be beyond end of range, either. + virtual void Advance() { + assert(!AtEnd()); + ++current3_; + if (current3_ == end3_) { + current3_ = begin3_; + ++current2_; + } + if (current2_ == end2_) { + current2_ = begin2_; + ++current1_; + } + ComputeCurrentValue(); + } + virtual ParamIteratorInterface* Clone() const { + return new Iterator(*this); + } + virtual const ParamType* Current() const { return ¤t_value_; } + virtual bool Equals(const ParamIteratorInterface& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + const Iterator* typed_other = + CheckedDowncastToActualType(&other); + // We must report iterators equal if they both point beyond their + // respective ranges. That can happen in a variety of fashions, + // so we have to consult AtEnd(). + return (AtEnd() && typed_other->AtEnd()) || + ( + current1_ == typed_other->current1_ && + current2_ == typed_other->current2_ && + current3_ == typed_other->current3_); + } + + private: + Iterator(const Iterator& other) + : base_(other.base_), + begin1_(other.begin1_), + end1_(other.end1_), + current1_(other.current1_), + begin2_(other.begin2_), + end2_(other.end2_), + current2_(other.current2_), + begin3_(other.begin3_), + end3_(other.end3_), + current3_(other.current3_) { + ComputeCurrentValue(); + } + + void ComputeCurrentValue() { + if (!AtEnd()) + current_value_ = ParamType(*current1_, *current2_, *current3_); + } + bool AtEnd() const { + // We must report iterator past the end of the range when either of the + // component iterators has reached the end of its range. + return + current1_ == end1_ || + current2_ == end2_ || + current3_ == end3_; + } + + // No implementation - assignment is unsupported. + void operator=(const Iterator& other); + + const ParamGeneratorInterface* const base_; + // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. + // current[i]_ is the actual traversing iterator. + const typename ParamGenerator::iterator begin1_; + const typename ParamGenerator::iterator end1_; + typename ParamGenerator::iterator current1_; + const typename ParamGenerator::iterator begin2_; + const typename ParamGenerator::iterator end2_; + typename ParamGenerator::iterator current2_; + const typename ParamGenerator::iterator begin3_; + const typename ParamGenerator::iterator end3_; + typename ParamGenerator::iterator current3_; + ParamType current_value_; + }; // class CartesianProductGenerator3::Iterator + + // No implementation - assignment is unsupported. + void operator=(const CartesianProductGenerator3& other); + + const ParamGenerator g1_; + const ParamGenerator g2_; + const ParamGenerator g3_; +}; // class CartesianProductGenerator3 + + +template +class CartesianProductGenerator4 + : public ParamGeneratorInterface< ::std::tr1::tuple > { + public: + typedef ::std::tr1::tuple ParamType; + + CartesianProductGenerator4(const ParamGenerator& g1, + const ParamGenerator& g2, const ParamGenerator& g3, + const ParamGenerator& g4) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {} + virtual ~CartesianProductGenerator4() {} + + virtual ParamIteratorInterface* Begin() const { + return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, + g3_.begin(), g4_, g4_.begin()); + } + virtual ParamIteratorInterface* End() const { + return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(), + g4_, g4_.end()); + } + + private: + class Iterator : public ParamIteratorInterface { + public: + Iterator(const ParamGeneratorInterface* base, + const ParamGenerator& g1, + const typename ParamGenerator::iterator& current1, + const ParamGenerator& g2, + const typename ParamGenerator::iterator& current2, + const ParamGenerator& g3, + const typename ParamGenerator::iterator& current3, + const ParamGenerator& g4, + const typename ParamGenerator::iterator& current4) + : base_(base), + begin1_(g1.begin()), end1_(g1.end()), current1_(current1), + begin2_(g2.begin()), end2_(g2.end()), current2_(current2), + begin3_(g3.begin()), end3_(g3.end()), current3_(current3), + begin4_(g4.begin()), end4_(g4.end()), current4_(current4) { + ComputeCurrentValue(); + } + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface* BaseGenerator() const { + return base_; + } + // Advance should not be called on beyond-of-range iterators + // so no component iterators must be beyond end of range, either. + virtual void Advance() { + assert(!AtEnd()); + ++current4_; + if (current4_ == end4_) { + current4_ = begin4_; + ++current3_; + } + if (current3_ == end3_) { + current3_ = begin3_; + ++current2_; + } + if (current2_ == end2_) { + current2_ = begin2_; + ++current1_; + } + ComputeCurrentValue(); + } + virtual ParamIteratorInterface* Clone() const { + return new Iterator(*this); + } + virtual const ParamType* Current() const { return ¤t_value_; } + virtual bool Equals(const ParamIteratorInterface& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + const Iterator* typed_other = + CheckedDowncastToActualType(&other); + // We must report iterators equal if they both point beyond their + // respective ranges. That can happen in a variety of fashions, + // so we have to consult AtEnd(). + return (AtEnd() && typed_other->AtEnd()) || + ( + current1_ == typed_other->current1_ && + current2_ == typed_other->current2_ && + current3_ == typed_other->current3_ && + current4_ == typed_other->current4_); + } + + private: + Iterator(const Iterator& other) + : base_(other.base_), + begin1_(other.begin1_), + end1_(other.end1_), + current1_(other.current1_), + begin2_(other.begin2_), + end2_(other.end2_), + current2_(other.current2_), + begin3_(other.begin3_), + end3_(other.end3_), + current3_(other.current3_), + begin4_(other.begin4_), + end4_(other.end4_), + current4_(other.current4_) { + ComputeCurrentValue(); + } + + void ComputeCurrentValue() { + if (!AtEnd()) + current_value_ = ParamType(*current1_, *current2_, *current3_, + *current4_); + } + bool AtEnd() const { + // We must report iterator past the end of the range when either of the + // component iterators has reached the end of its range. + return + current1_ == end1_ || + current2_ == end2_ || + current3_ == end3_ || + current4_ == end4_; + } + + // No implementation - assignment is unsupported. + void operator=(const Iterator& other); + + const ParamGeneratorInterface* const base_; + // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. + // current[i]_ is the actual traversing iterator. + const typename ParamGenerator::iterator begin1_; + const typename ParamGenerator::iterator end1_; + typename ParamGenerator::iterator current1_; + const typename ParamGenerator::iterator begin2_; + const typename ParamGenerator::iterator end2_; + typename ParamGenerator::iterator current2_; + const typename ParamGenerator::iterator begin3_; + const typename ParamGenerator::iterator end3_; + typename ParamGenerator::iterator current3_; + const typename ParamGenerator::iterator begin4_; + const typename ParamGenerator::iterator end4_; + typename ParamGenerator::iterator current4_; + ParamType current_value_; + }; // class CartesianProductGenerator4::Iterator + + // No implementation - assignment is unsupported. + void operator=(const CartesianProductGenerator4& other); + + const ParamGenerator g1_; + const ParamGenerator g2_; + const ParamGenerator g3_; + const ParamGenerator g4_; +}; // class CartesianProductGenerator4 + + +template +class CartesianProductGenerator5 + : public ParamGeneratorInterface< ::std::tr1::tuple > { + public: + typedef ::std::tr1::tuple ParamType; + + CartesianProductGenerator5(const ParamGenerator& g1, + const ParamGenerator& g2, const ParamGenerator& g3, + const ParamGenerator& g4, const ParamGenerator& g5) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {} + virtual ~CartesianProductGenerator5() {} + + virtual ParamIteratorInterface* Begin() const { + return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, + g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin()); + } + virtual ParamIteratorInterface* End() const { + return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(), + g4_, g4_.end(), g5_, g5_.end()); + } + + private: + class Iterator : public ParamIteratorInterface { + public: + Iterator(const ParamGeneratorInterface* base, + const ParamGenerator& g1, + const typename ParamGenerator::iterator& current1, + const ParamGenerator& g2, + const typename ParamGenerator::iterator& current2, + const ParamGenerator& g3, + const typename ParamGenerator::iterator& current3, + const ParamGenerator& g4, + const typename ParamGenerator::iterator& current4, + const ParamGenerator& g5, + const typename ParamGenerator::iterator& current5) + : base_(base), + begin1_(g1.begin()), end1_(g1.end()), current1_(current1), + begin2_(g2.begin()), end2_(g2.end()), current2_(current2), + begin3_(g3.begin()), end3_(g3.end()), current3_(current3), + begin4_(g4.begin()), end4_(g4.end()), current4_(current4), + begin5_(g5.begin()), end5_(g5.end()), current5_(current5) { + ComputeCurrentValue(); + } + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface* BaseGenerator() const { + return base_; + } + // Advance should not be called on beyond-of-range iterators + // so no component iterators must be beyond end of range, either. + virtual void Advance() { + assert(!AtEnd()); + ++current5_; + if (current5_ == end5_) { + current5_ = begin5_; + ++current4_; + } + if (current4_ == end4_) { + current4_ = begin4_; + ++current3_; + } + if (current3_ == end3_) { + current3_ = begin3_; + ++current2_; + } + if (current2_ == end2_) { + current2_ = begin2_; + ++current1_; + } + ComputeCurrentValue(); + } + virtual ParamIteratorInterface* Clone() const { + return new Iterator(*this); + } + virtual const ParamType* Current() const { return ¤t_value_; } + virtual bool Equals(const ParamIteratorInterface& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + const Iterator* typed_other = + CheckedDowncastToActualType(&other); + // We must report iterators equal if they both point beyond their + // respective ranges. That can happen in a variety of fashions, + // so we have to consult AtEnd(). + return (AtEnd() && typed_other->AtEnd()) || + ( + current1_ == typed_other->current1_ && + current2_ == typed_other->current2_ && + current3_ == typed_other->current3_ && + current4_ == typed_other->current4_ && + current5_ == typed_other->current5_); + } + + private: + Iterator(const Iterator& other) + : base_(other.base_), + begin1_(other.begin1_), + end1_(other.end1_), + current1_(other.current1_), + begin2_(other.begin2_), + end2_(other.end2_), + current2_(other.current2_), + begin3_(other.begin3_), + end3_(other.end3_), + current3_(other.current3_), + begin4_(other.begin4_), + end4_(other.end4_), + current4_(other.current4_), + begin5_(other.begin5_), + end5_(other.end5_), + current5_(other.current5_) { + ComputeCurrentValue(); + } + + void ComputeCurrentValue() { + if (!AtEnd()) + current_value_ = ParamType(*current1_, *current2_, *current3_, + *current4_, *current5_); + } + bool AtEnd() const { + // We must report iterator past the end of the range when either of the + // component iterators has reached the end of its range. + return + current1_ == end1_ || + current2_ == end2_ || + current3_ == end3_ || + current4_ == end4_ || + current5_ == end5_; + } + + // No implementation - assignment is unsupported. + void operator=(const Iterator& other); + + const ParamGeneratorInterface* const base_; + // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. + // current[i]_ is the actual traversing iterator. + const typename ParamGenerator::iterator begin1_; + const typename ParamGenerator::iterator end1_; + typename ParamGenerator::iterator current1_; + const typename ParamGenerator::iterator begin2_; + const typename ParamGenerator::iterator end2_; + typename ParamGenerator::iterator current2_; + const typename ParamGenerator::iterator begin3_; + const typename ParamGenerator::iterator end3_; + typename ParamGenerator::iterator current3_; + const typename ParamGenerator::iterator begin4_; + const typename ParamGenerator::iterator end4_; + typename ParamGenerator::iterator current4_; + const typename ParamGenerator::iterator begin5_; + const typename ParamGenerator::iterator end5_; + typename ParamGenerator::iterator current5_; + ParamType current_value_; + }; // class CartesianProductGenerator5::Iterator + + // No implementation - assignment is unsupported. + void operator=(const CartesianProductGenerator5& other); + + const ParamGenerator g1_; + const ParamGenerator g2_; + const ParamGenerator g3_; + const ParamGenerator g4_; + const ParamGenerator g5_; +}; // class CartesianProductGenerator5 + + +template +class CartesianProductGenerator6 + : public ParamGeneratorInterface< ::std::tr1::tuple > { + public: + typedef ::std::tr1::tuple ParamType; + + CartesianProductGenerator6(const ParamGenerator& g1, + const ParamGenerator& g2, const ParamGenerator& g3, + const ParamGenerator& g4, const ParamGenerator& g5, + const ParamGenerator& g6) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {} + virtual ~CartesianProductGenerator6() {} + + virtual ParamIteratorInterface* Begin() const { + return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, + g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin()); + } + virtual ParamIteratorInterface* End() const { + return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(), + g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end()); + } + + private: + class Iterator : public ParamIteratorInterface { + public: + Iterator(const ParamGeneratorInterface* base, + const ParamGenerator& g1, + const typename ParamGenerator::iterator& current1, + const ParamGenerator& g2, + const typename ParamGenerator::iterator& current2, + const ParamGenerator& g3, + const typename ParamGenerator::iterator& current3, + const ParamGenerator& g4, + const typename ParamGenerator::iterator& current4, + const ParamGenerator& g5, + const typename ParamGenerator::iterator& current5, + const ParamGenerator& g6, + const typename ParamGenerator::iterator& current6) + : base_(base), + begin1_(g1.begin()), end1_(g1.end()), current1_(current1), + begin2_(g2.begin()), end2_(g2.end()), current2_(current2), + begin3_(g3.begin()), end3_(g3.end()), current3_(current3), + begin4_(g4.begin()), end4_(g4.end()), current4_(current4), + begin5_(g5.begin()), end5_(g5.end()), current5_(current5), + begin6_(g6.begin()), end6_(g6.end()), current6_(current6) { + ComputeCurrentValue(); + } + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface* BaseGenerator() const { + return base_; + } + // Advance should not be called on beyond-of-range iterators + // so no component iterators must be beyond end of range, either. + virtual void Advance() { + assert(!AtEnd()); + ++current6_; + if (current6_ == end6_) { + current6_ = begin6_; + ++current5_; + } + if (current5_ == end5_) { + current5_ = begin5_; + ++current4_; + } + if (current4_ == end4_) { + current4_ = begin4_; + ++current3_; + } + if (current3_ == end3_) { + current3_ = begin3_; + ++current2_; + } + if (current2_ == end2_) { + current2_ = begin2_; + ++current1_; + } + ComputeCurrentValue(); + } + virtual ParamIteratorInterface* Clone() const { + return new Iterator(*this); + } + virtual const ParamType* Current() const { return ¤t_value_; } + virtual bool Equals(const ParamIteratorInterface& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + const Iterator* typed_other = + CheckedDowncastToActualType(&other); + // We must report iterators equal if they both point beyond their + // respective ranges. That can happen in a variety of fashions, + // so we have to consult AtEnd(). + return (AtEnd() && typed_other->AtEnd()) || + ( + current1_ == typed_other->current1_ && + current2_ == typed_other->current2_ && + current3_ == typed_other->current3_ && + current4_ == typed_other->current4_ && + current5_ == typed_other->current5_ && + current6_ == typed_other->current6_); + } + + private: + Iterator(const Iterator& other) + : base_(other.base_), + begin1_(other.begin1_), + end1_(other.end1_), + current1_(other.current1_), + begin2_(other.begin2_), + end2_(other.end2_), + current2_(other.current2_), + begin3_(other.begin3_), + end3_(other.end3_), + current3_(other.current3_), + begin4_(other.begin4_), + end4_(other.end4_), + current4_(other.current4_), + begin5_(other.begin5_), + end5_(other.end5_), + current5_(other.current5_), + begin6_(other.begin6_), + end6_(other.end6_), + current6_(other.current6_) { + ComputeCurrentValue(); + } + + void ComputeCurrentValue() { + if (!AtEnd()) + current_value_ = ParamType(*current1_, *current2_, *current3_, + *current4_, *current5_, *current6_); + } + bool AtEnd() const { + // We must report iterator past the end of the range when either of the + // component iterators has reached the end of its range. + return + current1_ == end1_ || + current2_ == end2_ || + current3_ == end3_ || + current4_ == end4_ || + current5_ == end5_ || + current6_ == end6_; + } + + // No implementation - assignment is unsupported. + void operator=(const Iterator& other); + + const ParamGeneratorInterface* const base_; + // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. + // current[i]_ is the actual traversing iterator. + const typename ParamGenerator::iterator begin1_; + const typename ParamGenerator::iterator end1_; + typename ParamGenerator::iterator current1_; + const typename ParamGenerator::iterator begin2_; + const typename ParamGenerator::iterator end2_; + typename ParamGenerator::iterator current2_; + const typename ParamGenerator::iterator begin3_; + const typename ParamGenerator::iterator end3_; + typename ParamGenerator::iterator current3_; + const typename ParamGenerator::iterator begin4_; + const typename ParamGenerator::iterator end4_; + typename ParamGenerator::iterator current4_; + const typename ParamGenerator::iterator begin5_; + const typename ParamGenerator::iterator end5_; + typename ParamGenerator::iterator current5_; + const typename ParamGenerator::iterator begin6_; + const typename ParamGenerator::iterator end6_; + typename ParamGenerator::iterator current6_; + ParamType current_value_; + }; // class CartesianProductGenerator6::Iterator + + // No implementation - assignment is unsupported. + void operator=(const CartesianProductGenerator6& other); + + const ParamGenerator g1_; + const ParamGenerator g2_; + const ParamGenerator g3_; + const ParamGenerator g4_; + const ParamGenerator g5_; + const ParamGenerator g6_; +}; // class CartesianProductGenerator6 + + +template +class CartesianProductGenerator7 + : public ParamGeneratorInterface< ::std::tr1::tuple > { + public: + typedef ::std::tr1::tuple ParamType; + + CartesianProductGenerator7(const ParamGenerator& g1, + const ParamGenerator& g2, const ParamGenerator& g3, + const ParamGenerator& g4, const ParamGenerator& g5, + const ParamGenerator& g6, const ParamGenerator& g7) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {} + virtual ~CartesianProductGenerator7() {} + + virtual ParamIteratorInterface* Begin() const { + return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, + g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_, + g7_.begin()); + } + virtual ParamIteratorInterface* End() const { + return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(), + g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end()); + } + + private: + class Iterator : public ParamIteratorInterface { + public: + Iterator(const ParamGeneratorInterface* base, + const ParamGenerator& g1, + const typename ParamGenerator::iterator& current1, + const ParamGenerator& g2, + const typename ParamGenerator::iterator& current2, + const ParamGenerator& g3, + const typename ParamGenerator::iterator& current3, + const ParamGenerator& g4, + const typename ParamGenerator::iterator& current4, + const ParamGenerator& g5, + const typename ParamGenerator::iterator& current5, + const ParamGenerator& g6, + const typename ParamGenerator::iterator& current6, + const ParamGenerator& g7, + const typename ParamGenerator::iterator& current7) + : base_(base), + begin1_(g1.begin()), end1_(g1.end()), current1_(current1), + begin2_(g2.begin()), end2_(g2.end()), current2_(current2), + begin3_(g3.begin()), end3_(g3.end()), current3_(current3), + begin4_(g4.begin()), end4_(g4.end()), current4_(current4), + begin5_(g5.begin()), end5_(g5.end()), current5_(current5), + begin6_(g6.begin()), end6_(g6.end()), current6_(current6), + begin7_(g7.begin()), end7_(g7.end()), current7_(current7) { + ComputeCurrentValue(); + } + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface* BaseGenerator() const { + return base_; + } + // Advance should not be called on beyond-of-range iterators + // so no component iterators must be beyond end of range, either. + virtual void Advance() { + assert(!AtEnd()); + ++current7_; + if (current7_ == end7_) { + current7_ = begin7_; + ++current6_; + } + if (current6_ == end6_) { + current6_ = begin6_; + ++current5_; + } + if (current5_ == end5_) { + current5_ = begin5_; + ++current4_; + } + if (current4_ == end4_) { + current4_ = begin4_; + ++current3_; + } + if (current3_ == end3_) { + current3_ = begin3_; + ++current2_; + } + if (current2_ == end2_) { + current2_ = begin2_; + ++current1_; + } + ComputeCurrentValue(); + } + virtual ParamIteratorInterface* Clone() const { + return new Iterator(*this); + } + virtual const ParamType* Current() const { return ¤t_value_; } + virtual bool Equals(const ParamIteratorInterface& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + const Iterator* typed_other = + CheckedDowncastToActualType(&other); + // We must report iterators equal if they both point beyond their + // respective ranges. That can happen in a variety of fashions, + // so we have to consult AtEnd(). + return (AtEnd() && typed_other->AtEnd()) || + ( + current1_ == typed_other->current1_ && + current2_ == typed_other->current2_ && + current3_ == typed_other->current3_ && + current4_ == typed_other->current4_ && + current5_ == typed_other->current5_ && + current6_ == typed_other->current6_ && + current7_ == typed_other->current7_); + } + + private: + Iterator(const Iterator& other) + : base_(other.base_), + begin1_(other.begin1_), + end1_(other.end1_), + current1_(other.current1_), + begin2_(other.begin2_), + end2_(other.end2_), + current2_(other.current2_), + begin3_(other.begin3_), + end3_(other.end3_), + current3_(other.current3_), + begin4_(other.begin4_), + end4_(other.end4_), + current4_(other.current4_), + begin5_(other.begin5_), + end5_(other.end5_), + current5_(other.current5_), + begin6_(other.begin6_), + end6_(other.end6_), + current6_(other.current6_), + begin7_(other.begin7_), + end7_(other.end7_), + current7_(other.current7_) { + ComputeCurrentValue(); + } + + void ComputeCurrentValue() { + if (!AtEnd()) + current_value_ = ParamType(*current1_, *current2_, *current3_, + *current4_, *current5_, *current6_, *current7_); + } + bool AtEnd() const { + // We must report iterator past the end of the range when either of the + // component iterators has reached the end of its range. + return + current1_ == end1_ || + current2_ == end2_ || + current3_ == end3_ || + current4_ == end4_ || + current5_ == end5_ || + current6_ == end6_ || + current7_ == end7_; + } + + // No implementation - assignment is unsupported. + void operator=(const Iterator& other); + + const ParamGeneratorInterface* const base_; + // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. + // current[i]_ is the actual traversing iterator. + const typename ParamGenerator::iterator begin1_; + const typename ParamGenerator::iterator end1_; + typename ParamGenerator::iterator current1_; + const typename ParamGenerator::iterator begin2_; + const typename ParamGenerator::iterator end2_; + typename ParamGenerator::iterator current2_; + const typename ParamGenerator::iterator begin3_; + const typename ParamGenerator::iterator end3_; + typename ParamGenerator::iterator current3_; + const typename ParamGenerator::iterator begin4_; + const typename ParamGenerator::iterator end4_; + typename ParamGenerator::iterator current4_; + const typename ParamGenerator::iterator begin5_; + const typename ParamGenerator::iterator end5_; + typename ParamGenerator::iterator current5_; + const typename ParamGenerator::iterator begin6_; + const typename ParamGenerator::iterator end6_; + typename ParamGenerator::iterator current6_; + const typename ParamGenerator::iterator begin7_; + const typename ParamGenerator::iterator end7_; + typename ParamGenerator::iterator current7_; + ParamType current_value_; + }; // class CartesianProductGenerator7::Iterator + + // No implementation - assignment is unsupported. + void operator=(const CartesianProductGenerator7& other); + + const ParamGenerator g1_; + const ParamGenerator g2_; + const ParamGenerator g3_; + const ParamGenerator g4_; + const ParamGenerator g5_; + const ParamGenerator g6_; + const ParamGenerator g7_; +}; // class CartesianProductGenerator7 + + +template +class CartesianProductGenerator8 + : public ParamGeneratorInterface< ::std::tr1::tuple > { + public: + typedef ::std::tr1::tuple ParamType; + + CartesianProductGenerator8(const ParamGenerator& g1, + const ParamGenerator& g2, const ParamGenerator& g3, + const ParamGenerator& g4, const ParamGenerator& g5, + const ParamGenerator& g6, const ParamGenerator& g7, + const ParamGenerator& g8) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), + g8_(g8) {} + virtual ~CartesianProductGenerator8() {} + + virtual ParamIteratorInterface* Begin() const { + return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, + g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_, + g7_.begin(), g8_, g8_.begin()); + } + virtual ParamIteratorInterface* End() const { + return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(), + g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_, + g8_.end()); + } + + private: + class Iterator : public ParamIteratorInterface { + public: + Iterator(const ParamGeneratorInterface* base, + const ParamGenerator& g1, + const typename ParamGenerator::iterator& current1, + const ParamGenerator& g2, + const typename ParamGenerator::iterator& current2, + const ParamGenerator& g3, + const typename ParamGenerator::iterator& current3, + const ParamGenerator& g4, + const typename ParamGenerator::iterator& current4, + const ParamGenerator& g5, + const typename ParamGenerator::iterator& current5, + const ParamGenerator& g6, + const typename ParamGenerator::iterator& current6, + const ParamGenerator& g7, + const typename ParamGenerator::iterator& current7, + const ParamGenerator& g8, + const typename ParamGenerator::iterator& current8) + : base_(base), + begin1_(g1.begin()), end1_(g1.end()), current1_(current1), + begin2_(g2.begin()), end2_(g2.end()), current2_(current2), + begin3_(g3.begin()), end3_(g3.end()), current3_(current3), + begin4_(g4.begin()), end4_(g4.end()), current4_(current4), + begin5_(g5.begin()), end5_(g5.end()), current5_(current5), + begin6_(g6.begin()), end6_(g6.end()), current6_(current6), + begin7_(g7.begin()), end7_(g7.end()), current7_(current7), + begin8_(g8.begin()), end8_(g8.end()), current8_(current8) { + ComputeCurrentValue(); + } + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface* BaseGenerator() const { + return base_; + } + // Advance should not be called on beyond-of-range iterators + // so no component iterators must be beyond end of range, either. + virtual void Advance() { + assert(!AtEnd()); + ++current8_; + if (current8_ == end8_) { + current8_ = begin8_; + ++current7_; + } + if (current7_ == end7_) { + current7_ = begin7_; + ++current6_; + } + if (current6_ == end6_) { + current6_ = begin6_; + ++current5_; + } + if (current5_ == end5_) { + current5_ = begin5_; + ++current4_; + } + if (current4_ == end4_) { + current4_ = begin4_; + ++current3_; + } + if (current3_ == end3_) { + current3_ = begin3_; + ++current2_; + } + if (current2_ == end2_) { + current2_ = begin2_; + ++current1_; + } + ComputeCurrentValue(); + } + virtual ParamIteratorInterface* Clone() const { + return new Iterator(*this); + } + virtual const ParamType* Current() const { return ¤t_value_; } + virtual bool Equals(const ParamIteratorInterface& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + const Iterator* typed_other = + CheckedDowncastToActualType(&other); + // We must report iterators equal if they both point beyond their + // respective ranges. That can happen in a variety of fashions, + // so we have to consult AtEnd(). + return (AtEnd() && typed_other->AtEnd()) || + ( + current1_ == typed_other->current1_ && + current2_ == typed_other->current2_ && + current3_ == typed_other->current3_ && + current4_ == typed_other->current4_ && + current5_ == typed_other->current5_ && + current6_ == typed_other->current6_ && + current7_ == typed_other->current7_ && + current8_ == typed_other->current8_); + } + + private: + Iterator(const Iterator& other) + : base_(other.base_), + begin1_(other.begin1_), + end1_(other.end1_), + current1_(other.current1_), + begin2_(other.begin2_), + end2_(other.end2_), + current2_(other.current2_), + begin3_(other.begin3_), + end3_(other.end3_), + current3_(other.current3_), + begin4_(other.begin4_), + end4_(other.end4_), + current4_(other.current4_), + begin5_(other.begin5_), + end5_(other.end5_), + current5_(other.current5_), + begin6_(other.begin6_), + end6_(other.end6_), + current6_(other.current6_), + begin7_(other.begin7_), + end7_(other.end7_), + current7_(other.current7_), + begin8_(other.begin8_), + end8_(other.end8_), + current8_(other.current8_) { + ComputeCurrentValue(); + } + + void ComputeCurrentValue() { + if (!AtEnd()) + current_value_ = ParamType(*current1_, *current2_, *current3_, + *current4_, *current5_, *current6_, *current7_, *current8_); + } + bool AtEnd() const { + // We must report iterator past the end of the range when either of the + // component iterators has reached the end of its range. + return + current1_ == end1_ || + current2_ == end2_ || + current3_ == end3_ || + current4_ == end4_ || + current5_ == end5_ || + current6_ == end6_ || + current7_ == end7_ || + current8_ == end8_; + } + + // No implementation - assignment is unsupported. + void operator=(const Iterator& other); + + const ParamGeneratorInterface* const base_; + // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. + // current[i]_ is the actual traversing iterator. + const typename ParamGenerator::iterator begin1_; + const typename ParamGenerator::iterator end1_; + typename ParamGenerator::iterator current1_; + const typename ParamGenerator::iterator begin2_; + const typename ParamGenerator::iterator end2_; + typename ParamGenerator::iterator current2_; + const typename ParamGenerator::iterator begin3_; + const typename ParamGenerator::iterator end3_; + typename ParamGenerator::iterator current3_; + const typename ParamGenerator::iterator begin4_; + const typename ParamGenerator::iterator end4_; + typename ParamGenerator::iterator current4_; + const typename ParamGenerator::iterator begin5_; + const typename ParamGenerator::iterator end5_; + typename ParamGenerator::iterator current5_; + const typename ParamGenerator::iterator begin6_; + const typename ParamGenerator::iterator end6_; + typename ParamGenerator::iterator current6_; + const typename ParamGenerator::iterator begin7_; + const typename ParamGenerator::iterator end7_; + typename ParamGenerator::iterator current7_; + const typename ParamGenerator::iterator begin8_; + const typename ParamGenerator::iterator end8_; + typename ParamGenerator::iterator current8_; + ParamType current_value_; + }; // class CartesianProductGenerator8::Iterator + + // No implementation - assignment is unsupported. + void operator=(const CartesianProductGenerator8& other); + + const ParamGenerator g1_; + const ParamGenerator g2_; + const ParamGenerator g3_; + const ParamGenerator g4_; + const ParamGenerator g5_; + const ParamGenerator g6_; + const ParamGenerator g7_; + const ParamGenerator g8_; +}; // class CartesianProductGenerator8 + + +template +class CartesianProductGenerator9 + : public ParamGeneratorInterface< ::std::tr1::tuple > { + public: + typedef ::std::tr1::tuple ParamType; + + CartesianProductGenerator9(const ParamGenerator& g1, + const ParamGenerator& g2, const ParamGenerator& g3, + const ParamGenerator& g4, const ParamGenerator& g5, + const ParamGenerator& g6, const ParamGenerator& g7, + const ParamGenerator& g8, const ParamGenerator& g9) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8), + g9_(g9) {} + virtual ~CartesianProductGenerator9() {} + + virtual ParamIteratorInterface* Begin() const { + return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, + g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_, + g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin()); + } + virtual ParamIteratorInterface* End() const { + return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(), + g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_, + g8_.end(), g9_, g9_.end()); + } + + private: + class Iterator : public ParamIteratorInterface { + public: + Iterator(const ParamGeneratorInterface* base, + const ParamGenerator& g1, + const typename ParamGenerator::iterator& current1, + const ParamGenerator& g2, + const typename ParamGenerator::iterator& current2, + const ParamGenerator& g3, + const typename ParamGenerator::iterator& current3, + const ParamGenerator& g4, + const typename ParamGenerator::iterator& current4, + const ParamGenerator& g5, + const typename ParamGenerator::iterator& current5, + const ParamGenerator& g6, + const typename ParamGenerator::iterator& current6, + const ParamGenerator& g7, + const typename ParamGenerator::iterator& current7, + const ParamGenerator& g8, + const typename ParamGenerator::iterator& current8, + const ParamGenerator& g9, + const typename ParamGenerator::iterator& current9) + : base_(base), + begin1_(g1.begin()), end1_(g1.end()), current1_(current1), + begin2_(g2.begin()), end2_(g2.end()), current2_(current2), + begin3_(g3.begin()), end3_(g3.end()), current3_(current3), + begin4_(g4.begin()), end4_(g4.end()), current4_(current4), + begin5_(g5.begin()), end5_(g5.end()), current5_(current5), + begin6_(g6.begin()), end6_(g6.end()), current6_(current6), + begin7_(g7.begin()), end7_(g7.end()), current7_(current7), + begin8_(g8.begin()), end8_(g8.end()), current8_(current8), + begin9_(g9.begin()), end9_(g9.end()), current9_(current9) { + ComputeCurrentValue(); + } + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface* BaseGenerator() const { + return base_; + } + // Advance should not be called on beyond-of-range iterators + // so no component iterators must be beyond end of range, either. + virtual void Advance() { + assert(!AtEnd()); + ++current9_; + if (current9_ == end9_) { + current9_ = begin9_; + ++current8_; + } + if (current8_ == end8_) { + current8_ = begin8_; + ++current7_; + } + if (current7_ == end7_) { + current7_ = begin7_; + ++current6_; + } + if (current6_ == end6_) { + current6_ = begin6_; + ++current5_; + } + if (current5_ == end5_) { + current5_ = begin5_; + ++current4_; + } + if (current4_ == end4_) { + current4_ = begin4_; + ++current3_; + } + if (current3_ == end3_) { + current3_ = begin3_; + ++current2_; + } + if (current2_ == end2_) { + current2_ = begin2_; + ++current1_; + } + ComputeCurrentValue(); + } + virtual ParamIteratorInterface* Clone() const { + return new Iterator(*this); + } + virtual const ParamType* Current() const { return ¤t_value_; } + virtual bool Equals(const ParamIteratorInterface& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + const Iterator* typed_other = + CheckedDowncastToActualType(&other); + // We must report iterators equal if they both point beyond their + // respective ranges. That can happen in a variety of fashions, + // so we have to consult AtEnd(). + return (AtEnd() && typed_other->AtEnd()) || + ( + current1_ == typed_other->current1_ && + current2_ == typed_other->current2_ && + current3_ == typed_other->current3_ && + current4_ == typed_other->current4_ && + current5_ == typed_other->current5_ && + current6_ == typed_other->current6_ && + current7_ == typed_other->current7_ && + current8_ == typed_other->current8_ && + current9_ == typed_other->current9_); + } + + private: + Iterator(const Iterator& other) + : base_(other.base_), + begin1_(other.begin1_), + end1_(other.end1_), + current1_(other.current1_), + begin2_(other.begin2_), + end2_(other.end2_), + current2_(other.current2_), + begin3_(other.begin3_), + end3_(other.end3_), + current3_(other.current3_), + begin4_(other.begin4_), + end4_(other.end4_), + current4_(other.current4_), + begin5_(other.begin5_), + end5_(other.end5_), + current5_(other.current5_), + begin6_(other.begin6_), + end6_(other.end6_), + current6_(other.current6_), + begin7_(other.begin7_), + end7_(other.end7_), + current7_(other.current7_), + begin8_(other.begin8_), + end8_(other.end8_), + current8_(other.current8_), + begin9_(other.begin9_), + end9_(other.end9_), + current9_(other.current9_) { + ComputeCurrentValue(); + } + + void ComputeCurrentValue() { + if (!AtEnd()) + current_value_ = ParamType(*current1_, *current2_, *current3_, + *current4_, *current5_, *current6_, *current7_, *current8_, + *current9_); + } + bool AtEnd() const { + // We must report iterator past the end of the range when either of the + // component iterators has reached the end of its range. + return + current1_ == end1_ || + current2_ == end2_ || + current3_ == end3_ || + current4_ == end4_ || + current5_ == end5_ || + current6_ == end6_ || + current7_ == end7_ || + current8_ == end8_ || + current9_ == end9_; + } + + // No implementation - assignment is unsupported. + void operator=(const Iterator& other); + + const ParamGeneratorInterface* const base_; + // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. + // current[i]_ is the actual traversing iterator. + const typename ParamGenerator::iterator begin1_; + const typename ParamGenerator::iterator end1_; + typename ParamGenerator::iterator current1_; + const typename ParamGenerator::iterator begin2_; + const typename ParamGenerator::iterator end2_; + typename ParamGenerator::iterator current2_; + const typename ParamGenerator::iterator begin3_; + const typename ParamGenerator::iterator end3_; + typename ParamGenerator::iterator current3_; + const typename ParamGenerator::iterator begin4_; + const typename ParamGenerator::iterator end4_; + typename ParamGenerator::iterator current4_; + const typename ParamGenerator::iterator begin5_; + const typename ParamGenerator::iterator end5_; + typename ParamGenerator::iterator current5_; + const typename ParamGenerator::iterator begin6_; + const typename ParamGenerator::iterator end6_; + typename ParamGenerator::iterator current6_; + const typename ParamGenerator::iterator begin7_; + const typename ParamGenerator::iterator end7_; + typename ParamGenerator::iterator current7_; + const typename ParamGenerator::iterator begin8_; + const typename ParamGenerator::iterator end8_; + typename ParamGenerator::iterator current8_; + const typename ParamGenerator::iterator begin9_; + const typename ParamGenerator::iterator end9_; + typename ParamGenerator::iterator current9_; + ParamType current_value_; + }; // class CartesianProductGenerator9::Iterator + + // No implementation - assignment is unsupported. + void operator=(const CartesianProductGenerator9& other); + + const ParamGenerator g1_; + const ParamGenerator g2_; + const ParamGenerator g3_; + const ParamGenerator g4_; + const ParamGenerator g5_; + const ParamGenerator g6_; + const ParamGenerator g7_; + const ParamGenerator g8_; + const ParamGenerator g9_; +}; // class CartesianProductGenerator9 + + +template +class CartesianProductGenerator10 + : public ParamGeneratorInterface< ::std::tr1::tuple > { + public: + typedef ::std::tr1::tuple ParamType; + + CartesianProductGenerator10(const ParamGenerator& g1, + const ParamGenerator& g2, const ParamGenerator& g3, + const ParamGenerator& g4, const ParamGenerator& g5, + const ParamGenerator& g6, const ParamGenerator& g7, + const ParamGenerator& g8, const ParamGenerator& g9, + const ParamGenerator& g10) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8), + g9_(g9), g10_(g10) {} + virtual ~CartesianProductGenerator10() {} + + virtual ParamIteratorInterface* Begin() const { + return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, + g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_, + g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin(), g10_, g10_.begin()); + } + virtual ParamIteratorInterface* End() const { + return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(), + g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_, + g8_.end(), g9_, g9_.end(), g10_, g10_.end()); + } + + private: + class Iterator : public ParamIteratorInterface { + public: + Iterator(const ParamGeneratorInterface* base, + const ParamGenerator& g1, + const typename ParamGenerator::iterator& current1, + const ParamGenerator& g2, + const typename ParamGenerator::iterator& current2, + const ParamGenerator& g3, + const typename ParamGenerator::iterator& current3, + const ParamGenerator& g4, + const typename ParamGenerator::iterator& current4, + const ParamGenerator& g5, + const typename ParamGenerator::iterator& current5, + const ParamGenerator& g6, + const typename ParamGenerator::iterator& current6, + const ParamGenerator& g7, + const typename ParamGenerator::iterator& current7, + const ParamGenerator& g8, + const typename ParamGenerator::iterator& current8, + const ParamGenerator& g9, + const typename ParamGenerator::iterator& current9, + const ParamGenerator& g10, + const typename ParamGenerator::iterator& current10) + : base_(base), + begin1_(g1.begin()), end1_(g1.end()), current1_(current1), + begin2_(g2.begin()), end2_(g2.end()), current2_(current2), + begin3_(g3.begin()), end3_(g3.end()), current3_(current3), + begin4_(g4.begin()), end4_(g4.end()), current4_(current4), + begin5_(g5.begin()), end5_(g5.end()), current5_(current5), + begin6_(g6.begin()), end6_(g6.end()), current6_(current6), + begin7_(g7.begin()), end7_(g7.end()), current7_(current7), + begin8_(g8.begin()), end8_(g8.end()), current8_(current8), + begin9_(g9.begin()), end9_(g9.end()), current9_(current9), + begin10_(g10.begin()), end10_(g10.end()), current10_(current10) { + ComputeCurrentValue(); + } + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface* BaseGenerator() const { + return base_; + } + // Advance should not be called on beyond-of-range iterators + // so no component iterators must be beyond end of range, either. + virtual void Advance() { + assert(!AtEnd()); + ++current10_; + if (current10_ == end10_) { + current10_ = begin10_; + ++current9_; + } + if (current9_ == end9_) { + current9_ = begin9_; + ++current8_; + } + if (current8_ == end8_) { + current8_ = begin8_; + ++current7_; + } + if (current7_ == end7_) { + current7_ = begin7_; + ++current6_; + } + if (current6_ == end6_) { + current6_ = begin6_; + ++current5_; + } + if (current5_ == end5_) { + current5_ = begin5_; + ++current4_; + } + if (current4_ == end4_) { + current4_ = begin4_; + ++current3_; + } + if (current3_ == end3_) { + current3_ = begin3_; + ++current2_; + } + if (current2_ == end2_) { + current2_ = begin2_; + ++current1_; + } + ComputeCurrentValue(); + } + virtual ParamIteratorInterface* Clone() const { + return new Iterator(*this); + } + virtual const ParamType* Current() const { return ¤t_value_; } + virtual bool Equals(const ParamIteratorInterface& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + const Iterator* typed_other = + CheckedDowncastToActualType(&other); + // We must report iterators equal if they both point beyond their + // respective ranges. That can happen in a variety of fashions, + // so we have to consult AtEnd(). + return (AtEnd() && typed_other->AtEnd()) || + ( + current1_ == typed_other->current1_ && + current2_ == typed_other->current2_ && + current3_ == typed_other->current3_ && + current4_ == typed_other->current4_ && + current5_ == typed_other->current5_ && + current6_ == typed_other->current6_ && + current7_ == typed_other->current7_ && + current8_ == typed_other->current8_ && + current9_ == typed_other->current9_ && + current10_ == typed_other->current10_); + } + + private: + Iterator(const Iterator& other) + : base_(other.base_), + begin1_(other.begin1_), + end1_(other.end1_), + current1_(other.current1_), + begin2_(other.begin2_), + end2_(other.end2_), + current2_(other.current2_), + begin3_(other.begin3_), + end3_(other.end3_), + current3_(other.current3_), + begin4_(other.begin4_), + end4_(other.end4_), + current4_(other.current4_), + begin5_(other.begin5_), + end5_(other.end5_), + current5_(other.current5_), + begin6_(other.begin6_), + end6_(other.end6_), + current6_(other.current6_), + begin7_(other.begin7_), + end7_(other.end7_), + current7_(other.current7_), + begin8_(other.begin8_), + end8_(other.end8_), + current8_(other.current8_), + begin9_(other.begin9_), + end9_(other.end9_), + current9_(other.current9_), + begin10_(other.begin10_), + end10_(other.end10_), + current10_(other.current10_) { + ComputeCurrentValue(); + } + + void ComputeCurrentValue() { + if (!AtEnd()) + current_value_ = ParamType(*current1_, *current2_, *current3_, + *current4_, *current5_, *current6_, *current7_, *current8_, + *current9_, *current10_); + } + bool AtEnd() const { + // We must report iterator past the end of the range when either of the + // component iterators has reached the end of its range. + return + current1_ == end1_ || + current2_ == end2_ || + current3_ == end3_ || + current4_ == end4_ || + current5_ == end5_ || + current6_ == end6_ || + current7_ == end7_ || + current8_ == end8_ || + current9_ == end9_ || + current10_ == end10_; + } + + // No implementation - assignment is unsupported. + void operator=(const Iterator& other); + + const ParamGeneratorInterface* const base_; + // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. + // current[i]_ is the actual traversing iterator. + const typename ParamGenerator::iterator begin1_; + const typename ParamGenerator::iterator end1_; + typename ParamGenerator::iterator current1_; + const typename ParamGenerator::iterator begin2_; + const typename ParamGenerator::iterator end2_; + typename ParamGenerator::iterator current2_; + const typename ParamGenerator::iterator begin3_; + const typename ParamGenerator::iterator end3_; + typename ParamGenerator::iterator current3_; + const typename ParamGenerator::iterator begin4_; + const typename ParamGenerator::iterator end4_; + typename ParamGenerator::iterator current4_; + const typename ParamGenerator::iterator begin5_; + const typename ParamGenerator::iterator end5_; + typename ParamGenerator::iterator current5_; + const typename ParamGenerator::iterator begin6_; + const typename ParamGenerator::iterator end6_; + typename ParamGenerator::iterator current6_; + const typename ParamGenerator::iterator begin7_; + const typename ParamGenerator::iterator end7_; + typename ParamGenerator::iterator current7_; + const typename ParamGenerator::iterator begin8_; + const typename ParamGenerator::iterator end8_; + typename ParamGenerator::iterator current8_; + const typename ParamGenerator::iterator begin9_; + const typename ParamGenerator::iterator end9_; + typename ParamGenerator::iterator current9_; + const typename ParamGenerator::iterator begin10_; + const typename ParamGenerator::iterator end10_; + typename ParamGenerator::iterator current10_; + ParamType current_value_; + }; // class CartesianProductGenerator10::Iterator + + // No implementation - assignment is unsupported. + void operator=(const CartesianProductGenerator10& other); + + const ParamGenerator g1_; + const ParamGenerator g2_; + const ParamGenerator g3_; + const ParamGenerator g4_; + const ParamGenerator g5_; + const ParamGenerator g6_; + const ParamGenerator g7_; + const ParamGenerator g8_; + const ParamGenerator g9_; + const ParamGenerator g10_; +}; // class CartesianProductGenerator10 + + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// Helper classes providing Combine() with polymorphic features. They allow +// casting CartesianProductGeneratorN to ParamGenerator if T is +// convertible to U. +// +template +class CartesianProductHolder2 { + public: +CartesianProductHolder2(const Generator1& g1, const Generator2& g2) + : g1_(g1), g2_(g2) {} + template + operator ParamGenerator< ::std::tr1::tuple >() const { + return ParamGenerator< ::std::tr1::tuple >( + new CartesianProductGenerator2( + static_cast >(g1_), + static_cast >(g2_))); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const CartesianProductHolder2& other); + + const Generator1 g1_; + const Generator2 g2_; +}; // class CartesianProductHolder2 + +template +class CartesianProductHolder3 { + public: +CartesianProductHolder3(const Generator1& g1, const Generator2& g2, + const Generator3& g3) + : g1_(g1), g2_(g2), g3_(g3) {} + template + operator ParamGenerator< ::std::tr1::tuple >() const { + return ParamGenerator< ::std::tr1::tuple >( + new CartesianProductGenerator3( + static_cast >(g1_), + static_cast >(g2_), + static_cast >(g3_))); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const CartesianProductHolder3& other); + + const Generator1 g1_; + const Generator2 g2_; + const Generator3 g3_; +}; // class CartesianProductHolder3 + +template +class CartesianProductHolder4 { + public: +CartesianProductHolder4(const Generator1& g1, const Generator2& g2, + const Generator3& g3, const Generator4& g4) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {} + template + operator ParamGenerator< ::std::tr1::tuple >() const { + return ParamGenerator< ::std::tr1::tuple >( + new CartesianProductGenerator4( + static_cast >(g1_), + static_cast >(g2_), + static_cast >(g3_), + static_cast >(g4_))); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const CartesianProductHolder4& other); + + const Generator1 g1_; + const Generator2 g2_; + const Generator3 g3_; + const Generator4 g4_; +}; // class CartesianProductHolder4 + +template +class CartesianProductHolder5 { + public: +CartesianProductHolder5(const Generator1& g1, const Generator2& g2, + const Generator3& g3, const Generator4& g4, const Generator5& g5) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {} + template + operator ParamGenerator< ::std::tr1::tuple >() const { + return ParamGenerator< ::std::tr1::tuple >( + new CartesianProductGenerator5( + static_cast >(g1_), + static_cast >(g2_), + static_cast >(g3_), + static_cast >(g4_), + static_cast >(g5_))); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const CartesianProductHolder5& other); + + const Generator1 g1_; + const Generator2 g2_; + const Generator3 g3_; + const Generator4 g4_; + const Generator5 g5_; +}; // class CartesianProductHolder5 + +template +class CartesianProductHolder6 { + public: +CartesianProductHolder6(const Generator1& g1, const Generator2& g2, + const Generator3& g3, const Generator4& g4, const Generator5& g5, + const Generator6& g6) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {} + template + operator ParamGenerator< ::std::tr1::tuple >() const { + return ParamGenerator< ::std::tr1::tuple >( + new CartesianProductGenerator6( + static_cast >(g1_), + static_cast >(g2_), + static_cast >(g3_), + static_cast >(g4_), + static_cast >(g5_), + static_cast >(g6_))); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const CartesianProductHolder6& other); + + const Generator1 g1_; + const Generator2 g2_; + const Generator3 g3_; + const Generator4 g4_; + const Generator5 g5_; + const Generator6 g6_; +}; // class CartesianProductHolder6 + +template +class CartesianProductHolder7 { + public: +CartesianProductHolder7(const Generator1& g1, const Generator2& g2, + const Generator3& g3, const Generator4& g4, const Generator5& g5, + const Generator6& g6, const Generator7& g7) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {} + template + operator ParamGenerator< ::std::tr1::tuple >() const { + return ParamGenerator< ::std::tr1::tuple >( + new CartesianProductGenerator7( + static_cast >(g1_), + static_cast >(g2_), + static_cast >(g3_), + static_cast >(g4_), + static_cast >(g5_), + static_cast >(g6_), + static_cast >(g7_))); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const CartesianProductHolder7& other); + + const Generator1 g1_; + const Generator2 g2_; + const Generator3 g3_; + const Generator4 g4_; + const Generator5 g5_; + const Generator6 g6_; + const Generator7 g7_; +}; // class CartesianProductHolder7 + +template +class CartesianProductHolder8 { + public: +CartesianProductHolder8(const Generator1& g1, const Generator2& g2, + const Generator3& g3, const Generator4& g4, const Generator5& g5, + const Generator6& g6, const Generator7& g7, const Generator8& g8) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), + g8_(g8) {} + template + operator ParamGenerator< ::std::tr1::tuple >() const { + return ParamGenerator< ::std::tr1::tuple >( + new CartesianProductGenerator8( + static_cast >(g1_), + static_cast >(g2_), + static_cast >(g3_), + static_cast >(g4_), + static_cast >(g5_), + static_cast >(g6_), + static_cast >(g7_), + static_cast >(g8_))); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const CartesianProductHolder8& other); + + const Generator1 g1_; + const Generator2 g2_; + const Generator3 g3_; + const Generator4 g4_; + const Generator5 g5_; + const Generator6 g6_; + const Generator7 g7_; + const Generator8 g8_; +}; // class CartesianProductHolder8 + +template +class CartesianProductHolder9 { + public: +CartesianProductHolder9(const Generator1& g1, const Generator2& g2, + const Generator3& g3, const Generator4& g4, const Generator5& g5, + const Generator6& g6, const Generator7& g7, const Generator8& g8, + const Generator9& g9) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8), + g9_(g9) {} + template + operator ParamGenerator< ::std::tr1::tuple >() const { + return ParamGenerator< ::std::tr1::tuple >( + new CartesianProductGenerator9( + static_cast >(g1_), + static_cast >(g2_), + static_cast >(g3_), + static_cast >(g4_), + static_cast >(g5_), + static_cast >(g6_), + static_cast >(g7_), + static_cast >(g8_), + static_cast >(g9_))); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const CartesianProductHolder9& other); + + const Generator1 g1_; + const Generator2 g2_; + const Generator3 g3_; + const Generator4 g4_; + const Generator5 g5_; + const Generator6 g6_; + const Generator7 g7_; + const Generator8 g8_; + const Generator9 g9_; +}; // class CartesianProductHolder9 + +template +class CartesianProductHolder10 { + public: +CartesianProductHolder10(const Generator1& g1, const Generator2& g2, + const Generator3& g3, const Generator4& g4, const Generator5& g5, + const Generator6& g6, const Generator7& g7, const Generator8& g8, + const Generator9& g9, const Generator10& g10) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8), + g9_(g9), g10_(g10) {} + template + operator ParamGenerator< ::std::tr1::tuple >() const { + return ParamGenerator< ::std::tr1::tuple >( + new CartesianProductGenerator10( + static_cast >(g1_), + static_cast >(g2_), + static_cast >(g3_), + static_cast >(g4_), + static_cast >(g5_), + static_cast >(g6_), + static_cast >(g7_), + static_cast >(g8_), + static_cast >(g9_), + static_cast >(g10_))); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const CartesianProductHolder10& other); + + const Generator1 g1_; + const Generator2 g2_; + const Generator3 g3_; + const Generator4 g4_; + const Generator5 g5_; + const Generator6 g6_; + const Generator7 g7_; + const Generator8 g8_; + const Generator9 g9_; + const Generator10 g10_; +}; // class CartesianProductHolder10 + +# endif // GTEST_HAS_COMBINE + +} // namespace internal +} // namespace testing + +#endif // GTEST_HAS_PARAM_TEST + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_ + +#if GTEST_HAS_PARAM_TEST + +namespace testing { + +// Functions producing parameter generators. +// +// Google Test uses these generators to produce parameters for value- +// parameterized tests. When a parameterized test case is instantiated +// with a particular generator, Google Test creates and runs tests +// for each element in the sequence produced by the generator. +// +// In the following sample, tests from test case FooTest are instantiated +// each three times with parameter values 3, 5, and 8: +// +// class FooTest : public TestWithParam { ... }; +// +// TEST_P(FooTest, TestThis) { +// } +// TEST_P(FooTest, TestThat) { +// } +// INSTANTIATE_TEST_CASE_P(TestSequence, FooTest, Values(3, 5, 8)); +// + +// Range() returns generators providing sequences of values in a range. +// +// Synopsis: +// Range(start, end) +// - returns a generator producing a sequence of values {start, start+1, +// start+2, ..., }. +// Range(start, end, step) +// - returns a generator producing a sequence of values {start, start+step, +// start+step+step, ..., }. +// Notes: +// * The generated sequences never include end. For example, Range(1, 5) +// returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2) +// returns a generator producing {1, 3, 5, 7}. +// * start and end must have the same type. That type may be any integral or +// floating-point type or a user defined type satisfying these conditions: +// * It must be assignable (have operator=() defined). +// * It must have operator+() (operator+(int-compatible type) for +// two-operand version). +// * It must have operator<() defined. +// Elements in the resulting sequences will also have that type. +// * Condition start < end must be satisfied in order for resulting sequences +// to contain any elements. +// +template +internal::ParamGenerator Range(T start, T end, IncrementT step) { + return internal::ParamGenerator( + new internal::RangeGenerator(start, end, step)); +} + +template +internal::ParamGenerator Range(T start, T end) { + return Range(start, end, 1); +} + +// ValuesIn() function allows generation of tests with parameters coming from +// a container. +// +// Synopsis: +// ValuesIn(const T (&array)[N]) +// - returns a generator producing sequences with elements from +// a C-style array. +// ValuesIn(const Container& container) +// - returns a generator producing sequences with elements from +// an STL-style container. +// ValuesIn(Iterator begin, Iterator end) +// - returns a generator producing sequences with elements from +// a range [begin, end) defined by a pair of STL-style iterators. These +// iterators can also be plain C pointers. +// +// Please note that ValuesIn copies the values from the containers +// passed in and keeps them to generate tests in RUN_ALL_TESTS(). +// +// Examples: +// +// This instantiates tests from test case StringTest +// each with C-string values of "foo", "bar", and "baz": +// +// const char* strings[] = {"foo", "bar", "baz"}; +// INSTANTIATE_TEST_CASE_P(StringSequence, SrtingTest, ValuesIn(strings)); +// +// This instantiates tests from test case StlStringTest +// each with STL strings with values "a" and "b": +// +// ::std::vector< ::std::string> GetParameterStrings() { +// ::std::vector< ::std::string> v; +// v.push_back("a"); +// v.push_back("b"); +// return v; +// } +// +// INSTANTIATE_TEST_CASE_P(CharSequence, +// StlStringTest, +// ValuesIn(GetParameterStrings())); +// +// +// This will also instantiate tests from CharTest +// each with parameter values 'a' and 'b': +// +// ::std::list GetParameterChars() { +// ::std::list list; +// list.push_back('a'); +// list.push_back('b'); +// return list; +// } +// ::std::list l = GetParameterChars(); +// INSTANTIATE_TEST_CASE_P(CharSequence2, +// CharTest, +// ValuesIn(l.begin(), l.end())); +// +template +internal::ParamGenerator< + typename ::testing::internal::IteratorTraits::value_type> +ValuesIn(ForwardIterator begin, ForwardIterator end) { + typedef typename ::testing::internal::IteratorTraits + ::value_type ParamType; + return internal::ParamGenerator( + new internal::ValuesInIteratorRangeGenerator(begin, end)); +} + +template +internal::ParamGenerator ValuesIn(const T (&array)[N]) { + return ValuesIn(array, array + N); +} + +template +internal::ParamGenerator ValuesIn( + const Container& container) { + return ValuesIn(container.begin(), container.end()); +} + +// Values() allows generating tests from explicitly specified list of +// parameters. +// +// Synopsis: +// Values(T v1, T v2, ..., T vN) +// - returns a generator producing sequences with elements v1, v2, ..., vN. +// +// For example, this instantiates tests from test case BarTest each +// with values "one", "two", and "three": +// +// INSTANTIATE_TEST_CASE_P(NumSequence, BarTest, Values("one", "two", "three")); +// +// This instantiates tests from test case BazTest each with values 1, 2, 3.5. +// The exact type of values will depend on the type of parameter in BazTest. +// +// INSTANTIATE_TEST_CASE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5)); +// +// Currently, Values() supports from 1 to 50 parameters. +// +template +internal::ValueArray1 Values(T1 v1) { + return internal::ValueArray1(v1); +} + +template +internal::ValueArray2 Values(T1 v1, T2 v2) { + return internal::ValueArray2(v1, v2); +} + +template +internal::ValueArray3 Values(T1 v1, T2 v2, T3 v3) { + return internal::ValueArray3(v1, v2, v3); +} + +template +internal::ValueArray4 Values(T1 v1, T2 v2, T3 v3, T4 v4) { + return internal::ValueArray4(v1, v2, v3, v4); +} + +template +internal::ValueArray5 Values(T1 v1, T2 v2, T3 v3, T4 v4, + T5 v5) { + return internal::ValueArray5(v1, v2, v3, v4, v5); +} + +template +internal::ValueArray6 Values(T1 v1, T2 v2, T3 v3, + T4 v4, T5 v5, T6 v6) { + return internal::ValueArray6(v1, v2, v3, v4, v5, v6); +} + +template +internal::ValueArray7 Values(T1 v1, T2 v2, T3 v3, + T4 v4, T5 v5, T6 v6, T7 v7) { + return internal::ValueArray7(v1, v2, v3, v4, v5, + v6, v7); +} + +template +internal::ValueArray8 Values(T1 v1, T2 v2, + T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) { + return internal::ValueArray8(v1, v2, v3, v4, + v5, v6, v7, v8); +} + +template +internal::ValueArray9 Values(T1 v1, T2 v2, + T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) { + return internal::ValueArray9(v1, v2, v3, + v4, v5, v6, v7, v8, v9); +} + +template +internal::ValueArray10 Values(T1 v1, + T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10) { + return internal::ValueArray10(v1, + v2, v3, v4, v5, v6, v7, v8, v9, v10); +} + +template +internal::ValueArray11 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11) { + return internal::ValueArray11(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11); +} + +template +internal::ValueArray12 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12) { + return internal::ValueArray12(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12); +} + +template +internal::ValueArray13 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13) { + return internal::ValueArray13(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13); +} + +template +internal::ValueArray14 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) { + return internal::ValueArray14(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, + v14); +} + +template +internal::ValueArray15 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, + T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) { + return internal::ValueArray15(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, + v13, v14, v15); +} + +template +internal::ValueArray16 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, + T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, + T16 v16) { + return internal::ValueArray16(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, + v12, v13, v14, v15, v16); +} + +template +internal::ValueArray17 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, + T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, + T16 v16, T17 v17) { + return internal::ValueArray17(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, + v11, v12, v13, v14, v15, v16, v17); +} + +template +internal::ValueArray18 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, + T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, + T16 v16, T17 v17, T18 v18) { + return internal::ValueArray18(v1, v2, v3, v4, v5, v6, v7, v8, v9, + v10, v11, v12, v13, v14, v15, v16, v17, v18); +} + +template +internal::ValueArray19 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, + T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, + T15 v15, T16 v16, T17 v17, T18 v18, T19 v19) { + return internal::ValueArray19(v1, v2, v3, v4, v5, v6, v7, v8, + v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19); +} + +template +internal::ValueArray20 Values(T1 v1, T2 v2, T3 v3, T4 v4, + T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, + T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20) { + return internal::ValueArray20(v1, v2, v3, v4, v5, v6, v7, + v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20); +} + +template +internal::ValueArray21 Values(T1 v1, T2 v2, T3 v3, T4 v4, + T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, + T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21) { + return internal::ValueArray21(v1, v2, v3, v4, v5, v6, + v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21); +} + +template +internal::ValueArray22 Values(T1 v1, T2 v2, T3 v3, + T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, + T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, + T21 v21, T22 v22) { + return internal::ValueArray22(v1, v2, v3, v4, + v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, + v20, v21, v22); +} + +template +internal::ValueArray23 Values(T1 v1, T2 v2, + T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, + T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, + T21 v21, T22 v22, T23 v23) { + return internal::ValueArray23(v1, v2, v3, + v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, + v20, v21, v22, v23); +} + +template +internal::ValueArray24 Values(T1 v1, T2 v2, + T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, + T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, + T21 v21, T22 v22, T23 v23, T24 v24) { + return internal::ValueArray24(v1, v2, + v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, + v19, v20, v21, v22, v23, v24); +} + +template +internal::ValueArray25 Values(T1 v1, + T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, + T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, + T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25) { + return internal::ValueArray25(v1, + v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, + v18, v19, v20, v21, v22, v23, v24, v25); +} + +template +internal::ValueArray26 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26) { + return internal::ValueArray26(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, + v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26); +} + +template +internal::ValueArray27 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27) { + return internal::ValueArray27(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, + v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27); +} + +template +internal::ValueArray28 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28) { + return internal::ValueArray28(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, + v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, + v28); +} + +template +internal::ValueArray29 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29) { + return internal::ValueArray29(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, + v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, + v27, v28, v29); +} + +template +internal::ValueArray30 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, + T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, + T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, + T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) { + return internal::ValueArray30(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, + v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, + v26, v27, v28, v29, v30); +} + +template +internal::ValueArray31 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, + T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, + T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, + T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31) { + return internal::ValueArray31(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, + v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, + v25, v26, v27, v28, v29, v30, v31); +} + +template +internal::ValueArray32 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, + T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, + T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, + T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, + T32 v32) { + return internal::ValueArray32(v1, v2, v3, v4, v5, v6, v7, v8, v9, + v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, + v24, v25, v26, v27, v28, v29, v30, v31, v32); +} + +template +internal::ValueArray33 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, + T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, + T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, + T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, + T32 v32, T33 v33) { + return internal::ValueArray33(v1, v2, v3, v4, v5, v6, v7, v8, + v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, + v24, v25, v26, v27, v28, v29, v30, v31, v32, v33); +} + +template +internal::ValueArray34 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, + T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, + T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, + T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, + T31 v31, T32 v32, T33 v33, T34 v34) { + return internal::ValueArray34(v1, v2, v3, v4, v5, v6, v7, + v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, + v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34); +} + +template +internal::ValueArray35 Values(T1 v1, T2 v2, T3 v3, T4 v4, + T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, + T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, + T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, + T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35) { + return internal::ValueArray35(v1, v2, v3, v4, v5, v6, + v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, + v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35); +} + +template +internal::ValueArray36 Values(T1 v1, T2 v2, T3 v3, T4 v4, + T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, + T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, + T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, + T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36) { + return internal::ValueArray36(v1, v2, v3, v4, + v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, + v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, + v34, v35, v36); +} + +template +internal::ValueArray37 Values(T1 v1, T2 v2, T3 v3, + T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, + T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, + T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, + T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, + T37 v37) { + return internal::ValueArray37(v1, v2, v3, + v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, + v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, + v34, v35, v36, v37); +} + +template +internal::ValueArray38 Values(T1 v1, T2 v2, + T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, + T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, + T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, + T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, + T37 v37, T38 v38) { + return internal::ValueArray38(v1, v2, + v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, + v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, + v33, v34, v35, v36, v37, v38); +} + +template +internal::ValueArray39 Values(T1 v1, T2 v2, + T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, + T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, + T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, + T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, + T37 v37, T38 v38, T39 v39) { + return internal::ValueArray39(v1, + v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, + v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, + v32, v33, v34, v35, v36, v37, v38, v39); +} + +template +internal::ValueArray40 Values(T1 v1, + T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, + T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, + T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, + T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, + T36 v36, T37 v37, T38 v38, T39 v39, T40 v40) { + return internal::ValueArray40(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, + v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, + v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40); +} + +template +internal::ValueArray41 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41) { + return internal::ValueArray41(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, + v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, + v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41); +} + +template +internal::ValueArray42 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42) { + return internal::ValueArray42(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, + v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, + v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, + v42); +} + +template +internal::ValueArray43 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42, T43 v43) { + return internal::ValueArray43(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, + v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, + v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, + v41, v42, v43); +} + +template +internal::ValueArray44 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42, T43 v43, T44 v44) { + return internal::ValueArray44(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, + v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, + v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, + v40, v41, v42, v43, v44); +} + +template +internal::ValueArray45 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, + T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, + T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, + T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, + T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, + T41 v41, T42 v42, T43 v43, T44 v44, T45 v45) { + return internal::ValueArray45(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, + v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, + v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, + v39, v40, v41, v42, v43, v44, v45); +} + +template +internal::ValueArray46 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, + T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, + T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, + T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, + T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, + T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46) { + return internal::ValueArray46(v1, v2, v3, v4, v5, v6, v7, v8, v9, + v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, + v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, + v38, v39, v40, v41, v42, v43, v44, v45, v46); +} + +template +internal::ValueArray47 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, + T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, + T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, + T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, + T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, + T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47) { + return internal::ValueArray47(v1, v2, v3, v4, v5, v6, v7, v8, + v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, + v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, + v38, v39, v40, v41, v42, v43, v44, v45, v46, v47); +} + +template +internal::ValueArray48 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, + T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, + T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, + T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, + T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, + T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, + T48 v48) { + return internal::ValueArray48(v1, v2, v3, v4, v5, v6, v7, + v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, + v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, + v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48); +} + +template +internal::ValueArray49 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, + T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, + T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, + T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, + T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, + T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, + T47 v47, T48 v48, T49 v49) { + return internal::ValueArray49(v1, v2, v3, v4, v5, v6, + v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, + v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, + v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49); +} + +template +internal::ValueArray50 Values(T1 v1, T2 v2, T3 v3, T4 v4, + T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, + T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, + T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, + T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, + T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, + T46 v46, T47 v47, T48 v48, T49 v49, T50 v50) { + return internal::ValueArray50(v1, v2, v3, v4, + v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, + v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, + v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, + v48, v49, v50); +} + +// Bool() allows generating tests with parameters in a set of (false, true). +// +// Synopsis: +// Bool() +// - returns a generator producing sequences with elements {false, true}. +// +// It is useful when testing code that depends on Boolean flags. Combinations +// of multiple flags can be tested when several Bool()'s are combined using +// Combine() function. +// +// In the following example all tests in the test case FlagDependentTest +// will be instantiated twice with parameters false and true. +// +// class FlagDependentTest : public testing::TestWithParam { +// virtual void SetUp() { +// external_flag = GetParam(); +// } +// } +// INSTANTIATE_TEST_CASE_P(BoolSequence, FlagDependentTest, Bool()); +// +inline internal::ParamGenerator Bool() { + return Values(false, true); +} + +# if GTEST_HAS_COMBINE +// Combine() allows the user to combine two or more sequences to produce +// values of a Cartesian product of those sequences' elements. +// +// Synopsis: +// Combine(gen1, gen2, ..., genN) +// - returns a generator producing sequences with elements coming from +// the Cartesian product of elements from the sequences generated by +// gen1, gen2, ..., genN. The sequence elements will have a type of +// tuple where T1, T2, ..., TN are the types +// of elements from sequences produces by gen1, gen2, ..., genN. +// +// Combine can have up to 10 arguments. This number is currently limited +// by the maximum number of elements in the tuple implementation used by Google +// Test. +// +// Example: +// +// This will instantiate tests in test case AnimalTest each one with +// the parameter values tuple("cat", BLACK), tuple("cat", WHITE), +// tuple("dog", BLACK), and tuple("dog", WHITE): +// +// enum Color { BLACK, GRAY, WHITE }; +// class AnimalTest +// : public testing::TestWithParam > {...}; +// +// TEST_P(AnimalTest, AnimalLooksNice) {...} +// +// INSTANTIATE_TEST_CASE_P(AnimalVariations, AnimalTest, +// Combine(Values("cat", "dog"), +// Values(BLACK, WHITE))); +// +// This will instantiate tests in FlagDependentTest with all variations of two +// Boolean flags: +// +// class FlagDependentTest +// : public testing::TestWithParam > { +// virtual void SetUp() { +// // Assigns external_flag_1 and external_flag_2 values from the tuple. +// tie(external_flag_1, external_flag_2) = GetParam(); +// } +// }; +// +// TEST_P(FlagDependentTest, TestFeature1) { +// // Test your code using external_flag_1 and external_flag_2 here. +// } +// INSTANTIATE_TEST_CASE_P(TwoBoolSequence, FlagDependentTest, +// Combine(Bool(), Bool())); +// +template +internal::CartesianProductHolder2 Combine( + const Generator1& g1, const Generator2& g2) { + return internal::CartesianProductHolder2( + g1, g2); +} + +template +internal::CartesianProductHolder3 Combine( + const Generator1& g1, const Generator2& g2, const Generator3& g3) { + return internal::CartesianProductHolder3( + g1, g2, g3); +} + +template +internal::CartesianProductHolder4 Combine( + const Generator1& g1, const Generator2& g2, const Generator3& g3, + const Generator4& g4) { + return internal::CartesianProductHolder4( + g1, g2, g3, g4); +} + +template +internal::CartesianProductHolder5 Combine( + const Generator1& g1, const Generator2& g2, const Generator3& g3, + const Generator4& g4, const Generator5& g5) { + return internal::CartesianProductHolder5( + g1, g2, g3, g4, g5); +} + +template +internal::CartesianProductHolder6 Combine( + const Generator1& g1, const Generator2& g2, const Generator3& g3, + const Generator4& g4, const Generator5& g5, const Generator6& g6) { + return internal::CartesianProductHolder6( + g1, g2, g3, g4, g5, g6); +} + +template +internal::CartesianProductHolder7 Combine( + const Generator1& g1, const Generator2& g2, const Generator3& g3, + const Generator4& g4, const Generator5& g5, const Generator6& g6, + const Generator7& g7) { + return internal::CartesianProductHolder7( + g1, g2, g3, g4, g5, g6, g7); +} + +template +internal::CartesianProductHolder8 Combine( + const Generator1& g1, const Generator2& g2, const Generator3& g3, + const Generator4& g4, const Generator5& g5, const Generator6& g6, + const Generator7& g7, const Generator8& g8) { + return internal::CartesianProductHolder8( + g1, g2, g3, g4, g5, g6, g7, g8); +} + +template +internal::CartesianProductHolder9 Combine( + const Generator1& g1, const Generator2& g2, const Generator3& g3, + const Generator4& g4, const Generator5& g5, const Generator6& g6, + const Generator7& g7, const Generator8& g8, const Generator9& g9) { + return internal::CartesianProductHolder9( + g1, g2, g3, g4, g5, g6, g7, g8, g9); +} + +template +internal::CartesianProductHolder10 Combine( + const Generator1& g1, const Generator2& g2, const Generator3& g3, + const Generator4& g4, const Generator5& g5, const Generator6& g6, + const Generator7& g7, const Generator8& g8, const Generator9& g9, + const Generator10& g10) { + return internal::CartesianProductHolder10( + g1, g2, g3, g4, g5, g6, g7, g8, g9, g10); +} +# endif // GTEST_HAS_COMBINE + + + +# define TEST_P(test_case_name, test_name) \ + class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \ + : public test_case_name { \ + public: \ + GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {} \ + virtual void TestBody(); \ + private: \ + static int AddToRegistry() { \ + ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \ + GetTestCasePatternHolder(\ + #test_case_name, __FILE__, __LINE__)->AddTestPattern(\ + #test_case_name, \ + #test_name, \ + new ::testing::internal::TestMetaFactory< \ + GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>()); \ + return 0; \ + } \ + static int gtest_registering_dummy_; \ + GTEST_DISALLOW_COPY_AND_ASSIGN_(\ + GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \ + }; \ + int GTEST_TEST_CLASS_NAME_(test_case_name, \ + test_name)::gtest_registering_dummy_ = \ + GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \ + void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody() + +# define INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator) \ + ::testing::internal::ParamGenerator \ + gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \ + int gtest_##prefix##test_case_name##_dummy_ = \ + ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \ + GetTestCasePatternHolder(\ + #test_case_name, __FILE__, __LINE__)->AddTestCaseInstantiation(\ + #prefix, \ + >est_##prefix##test_case_name##_EvalGenerator_, \ + __FILE__, __LINE__) + +} // namespace testing + +#endif // GTEST_HAS_PARAM_TEST + +#endif // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ +// Copyright 2006, 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) +// +// Google C++ Testing Framework definitions useful in production code. + +#ifndef GTEST_INCLUDE_GTEST_GTEST_PROD_H_ +#define GTEST_INCLUDE_GTEST_GTEST_PROD_H_ + +// When you need to test the private or protected members of a class, +// use the FRIEND_TEST macro to declare your tests as friends of the +// class. For example: +// +// class MyClass { +// private: +// void MyMethod(); +// FRIEND_TEST(MyClassTest, MyMethod); +// }; +// +// class MyClassTest : public testing::Test { +// // ... +// }; +// +// TEST_F(MyClassTest, MyMethod) { +// // Can call MyClass::MyMethod() here. +// } + +#define FRIEND_TEST(test_case_name, test_name)\ +friend class test_case_name##_##test_name##_Test + +#endif // GTEST_INCLUDE_GTEST_GTEST_PROD_H_ +// 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. +// +// Author: mheule@google.com (Markus Heule) +// + +#ifndef GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_ +#define GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_ + +#include +#include + +namespace testing { + +// A copyable object representing the result of a test part (i.e. an +// assertion or an explicit FAIL(), ADD_FAILURE(), or SUCCESS()). +// +// Don't inherit from TestPartResult as its destructor is not virtual. +class GTEST_API_ TestPartResult { + public: + // The possible outcomes of a test part (i.e. an assertion or an + // explicit SUCCEED(), FAIL(), or ADD_FAILURE()). + enum Type { + kSuccess, // Succeeded. + kNonFatalFailure, // Failed but the test can continue. + kFatalFailure // Failed and the test should be terminated. + }; + + // C'tor. TestPartResult does NOT have a default constructor. + // Always use this constructor (with parameters) to create a + // TestPartResult object. + TestPartResult(Type a_type, + const char* a_file_name, + int a_line_number, + const char* a_message) + : type_(a_type), + file_name_(a_file_name == NULL ? "" : a_file_name), + line_number_(a_line_number), + summary_(ExtractSummary(a_message)), + message_(a_message) { + } + + // Gets the outcome of the test part. + Type type() const { return type_; } + + // Gets the name of the source file where the test part took place, or + // NULL if it's unknown. + const char* file_name() const { + return file_name_.empty() ? NULL : file_name_.c_str(); + } + + // Gets the line in the source file where the test part took place, + // or -1 if it's unknown. + int line_number() const { return line_number_; } + + // Gets the summary of the failure message. + const char* summary() const { return summary_.c_str(); } + + // Gets the message associated with the test part. + const char* message() const { return message_.c_str(); } + + // Returns true iff the test part passed. + bool passed() const { return type_ == kSuccess; } + + // Returns true iff the test part failed. + bool failed() const { return type_ != kSuccess; } + + // Returns true iff the test part non-fatally failed. + bool nonfatally_failed() const { return type_ == kNonFatalFailure; } + + // Returns true iff the test part fatally failed. + bool fatally_failed() const { return type_ == kFatalFailure; } + + private: + Type type_; + + // Gets the summary of the failure message by omitting the stack + // trace in it. + static std::string ExtractSummary(const char* message); + + // The name of the source file where the test part took place, or + // "" if the source file is unknown. + std::string file_name_; + // The line in the source file where the test part took place, or -1 + // if the line number is unknown. + int line_number_; + std::string summary_; // The test failure summary. + std::string message_; // The test failure message. +}; + +// Prints a TestPartResult object. +std::ostream& operator<<(std::ostream& os, const TestPartResult& result); + +// An array of TestPartResult objects. +// +// Don't inherit from TestPartResultArray as its destructor is not +// virtual. +class GTEST_API_ TestPartResultArray { + public: + TestPartResultArray() {} + + // Appends the given TestPartResult to the array. + void Append(const TestPartResult& result); + + // Returns the TestPartResult at the given index (0-based). + const TestPartResult& GetTestPartResult(int index) const; + + // Returns the number of TestPartResult objects in the array. + int size() const; + + private: + std::vector array_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(TestPartResultArray); +}; + +// This interface knows how to report a test part result. +class TestPartResultReporterInterface { + public: + virtual ~TestPartResultReporterInterface() {} + + virtual void ReportTestPartResult(const TestPartResult& result) = 0; +}; + +namespace internal { + +// This helper class is used by {ASSERT|EXPECT}_NO_FATAL_FAILURE to check if a +// statement generates new fatal failures. To do so it registers itself as the +// current test part result reporter. Besides checking if fatal failures were +// reported, it only delegates the reporting to the former result reporter. +// The original result reporter is restored in the destructor. +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +class GTEST_API_ HasNewFatalFailureHelper + : public TestPartResultReporterInterface { + public: + HasNewFatalFailureHelper(); + virtual ~HasNewFatalFailureHelper(); + virtual void ReportTestPartResult(const TestPartResult& result); + bool has_new_fatal_failure() const { return has_new_fatal_failure_; } + private: + bool has_new_fatal_failure_; + TestPartResultReporterInterface* original_reporter_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(HasNewFatalFailureHelper); +}; + +} // namespace internal + +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_ +// 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. +// +// Author: wan@google.com (Zhanyong Wan) + +#ifndef GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_ +#define GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_ + +// This header implements typed tests and type-parameterized tests. + +// Typed (aka type-driven) tests repeat the same test for types in a +// list. You must know which types you want to test with when writing +// typed tests. Here's how you do it: + +#if 0 + +// First, define a fixture class template. It should be parameterized +// by a type. Remember to derive it from testing::Test. +template +class FooTest : public testing::Test { + public: + ... + typedef std::list List; + static T shared_; + T value_; +}; + +// Next, associate a list of types with the test case, which will be +// repeated for each type in the list. The typedef is necessary for +// the macro to parse correctly. +typedef testing::Types MyTypes; +TYPED_TEST_CASE(FooTest, MyTypes); + +// If the type list contains only one type, you can write that type +// directly without Types<...>: +// TYPED_TEST_CASE(FooTest, int); + +// Then, use TYPED_TEST() instead of TEST_F() to define as many typed +// tests for this test case as you want. +TYPED_TEST(FooTest, DoesBlah) { + // Inside a test, refer to TypeParam to get the type parameter. + // Since we are inside a derived class template, C++ requires use to + // visit the members of FooTest via 'this'. + TypeParam n = this->value_; + + // To visit static members of the fixture, add the TestFixture:: + // prefix. + n += TestFixture::shared_; + + // To refer to typedefs in the fixture, add the "typename + // TestFixture::" prefix. + typename TestFixture::List values; + values.push_back(n); + ... +} + +TYPED_TEST(FooTest, HasPropertyA) { ... } + +#endif // 0 + +// Type-parameterized tests are abstract test patterns parameterized +// by a type. Compared with typed tests, type-parameterized tests +// allow you to define the test pattern without knowing what the type +// parameters are. The defined pattern can be instantiated with +// different types any number of times, in any number of translation +// units. +// +// If you are designing an interface or concept, you can define a +// suite of type-parameterized tests to verify properties that any +// valid implementation of the interface/concept should have. Then, +// each implementation can easily instantiate the test suite to verify +// that it conforms to the requirements, without having to write +// similar tests repeatedly. Here's an example: + +#if 0 + +// First, define a fixture class template. It should be parameterized +// by a type. Remember to derive it from testing::Test. +template +class FooTest : public testing::Test { + ... +}; + +// Next, declare that you will define a type-parameterized test case +// (the _P suffix is for "parameterized" or "pattern", whichever you +// prefer): +TYPED_TEST_CASE_P(FooTest); + +// Then, use TYPED_TEST_P() to define as many type-parameterized tests +// for this type-parameterized test case as you want. +TYPED_TEST_P(FooTest, DoesBlah) { + // Inside a test, refer to TypeParam to get the type parameter. + TypeParam n = 0; + ... +} + +TYPED_TEST_P(FooTest, HasPropertyA) { ... } + +// Now the tricky part: you need to register all test patterns before +// you can instantiate them. The first argument of the macro is the +// test case name; the rest are the names of the tests in this test +// case. +REGISTER_TYPED_TEST_CASE_P(FooTest, + DoesBlah, HasPropertyA); + +// Finally, you are free to instantiate the pattern with the types you +// want. If you put the above code in a header file, you can #include +// it in multiple C++ source files and instantiate it multiple times. +// +// To distinguish different instances of the pattern, the first +// argument to the INSTANTIATE_* macro is a prefix that will be added +// to the actual test case name. Remember to pick unique prefixes for +// different instances. +typedef testing::Types MyTypes; +INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes); + +// If the type list contains only one type, you can write that type +// directly without Types<...>: +// INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int); + +#endif // 0 + + +// Implements typed tests. + +#if GTEST_HAS_TYPED_TEST + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// Expands to the name of the typedef for the type parameters of the +// given test case. +# define GTEST_TYPE_PARAMS_(TestCaseName) gtest_type_params_##TestCaseName##_ + +// The 'Types' template argument below must have spaces around it +// since some compilers may choke on '>>' when passing a template +// instance (e.g. Types) +# define TYPED_TEST_CASE(CaseName, Types) \ + typedef ::testing::internal::TypeList< Types >::type \ + GTEST_TYPE_PARAMS_(CaseName) + +# define TYPED_TEST(CaseName, TestName) \ + template \ + class GTEST_TEST_CLASS_NAME_(CaseName, TestName) \ + : public CaseName { \ + private: \ + typedef CaseName TestFixture; \ + typedef gtest_TypeParam_ TypeParam; \ + virtual void TestBody(); \ + }; \ + bool gtest_##CaseName##_##TestName##_registered_ GTEST_ATTRIBUTE_UNUSED_ = \ + ::testing::internal::TypeParameterizedTest< \ + CaseName, \ + ::testing::internal::TemplateSel< \ + GTEST_TEST_CLASS_NAME_(CaseName, TestName)>, \ + GTEST_TYPE_PARAMS_(CaseName)>::Register(\ + "", #CaseName, #TestName, 0); \ + template \ + void GTEST_TEST_CLASS_NAME_(CaseName, TestName)::TestBody() + +#endif // GTEST_HAS_TYPED_TEST + +// Implements type-parameterized tests. + +#if GTEST_HAS_TYPED_TEST_P + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// Expands to the namespace name that the type-parameterized tests for +// the given type-parameterized test case are defined in. The exact +// name of the namespace is subject to change without notice. +# define GTEST_CASE_NAMESPACE_(TestCaseName) \ + gtest_case_##TestCaseName##_ + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// Expands to the name of the variable used to remember the names of +// the defined tests in the given test case. +# define GTEST_TYPED_TEST_CASE_P_STATE_(TestCaseName) \ + gtest_typed_test_case_p_state_##TestCaseName##_ + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE DIRECTLY. +// +// Expands to the name of the variable used to remember the names of +// the registered tests in the given test case. +# define GTEST_REGISTERED_TEST_NAMES_(TestCaseName) \ + gtest_registered_test_names_##TestCaseName##_ + +// The variables defined in the type-parameterized test macros are +// static as typically these macros are used in a .h file that can be +// #included in multiple translation units linked together. +# define TYPED_TEST_CASE_P(CaseName) \ + static ::testing::internal::TypedTestCasePState \ + GTEST_TYPED_TEST_CASE_P_STATE_(CaseName) + +# define TYPED_TEST_P(CaseName, TestName) \ + namespace GTEST_CASE_NAMESPACE_(CaseName) { \ + template \ + class TestName : public CaseName { \ + private: \ + typedef CaseName TestFixture; \ + typedef gtest_TypeParam_ TypeParam; \ + virtual void TestBody(); \ + }; \ + static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \ + GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).AddTestName(\ + __FILE__, __LINE__, #CaseName, #TestName); \ + } \ + template \ + void GTEST_CASE_NAMESPACE_(CaseName)::TestName::TestBody() + +# define REGISTER_TYPED_TEST_CASE_P(CaseName, ...) \ + namespace GTEST_CASE_NAMESPACE_(CaseName) { \ + typedef ::testing::internal::Templates<__VA_ARGS__>::type gtest_AllTests_; \ + } \ + static const char* const GTEST_REGISTERED_TEST_NAMES_(CaseName) = \ + GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).VerifyRegisteredTestNames(\ + __FILE__, __LINE__, #__VA_ARGS__) + +// The 'Types' template argument below must have spaces around it +// since some compilers may choke on '>>' when passing a template +// instance (e.g. Types) +# define INSTANTIATE_TYPED_TEST_CASE_P(Prefix, CaseName, Types) \ + bool gtest_##Prefix##_##CaseName GTEST_ATTRIBUTE_UNUSED_ = \ + ::testing::internal::TypeParameterizedTestCase::type>::Register(\ + #Prefix, #CaseName, GTEST_REGISTERED_TEST_NAMES_(CaseName)) + +#endif // GTEST_HAS_TYPED_TEST_P + +#endif // GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_ + +// Depending on the platform, different string classes are available. +// On Linux, in addition to ::std::string, Google also makes use of +// class ::string, which has the same interface as ::std::string, but +// has a different implementation. +// +// The user can define GTEST_HAS_GLOBAL_STRING to 1 to indicate that +// ::string is available AND is a distinct type to ::std::string, or +// define it to 0 to indicate otherwise. +// +// If the user's ::std::string and ::string are the same class due to +// aliasing, he should define GTEST_HAS_GLOBAL_STRING to 0. +// +// If the user doesn't define GTEST_HAS_GLOBAL_STRING, it is defined +// heuristically. + +namespace testing { + +// Declares the flags. + +// This flag temporary enables the disabled tests. +GTEST_DECLARE_bool_(also_run_disabled_tests); + +// This flag brings the debugger on an assertion failure. +GTEST_DECLARE_bool_(break_on_failure); + +// This flag controls whether Google Test catches all test-thrown exceptions +// and logs them as failures. +GTEST_DECLARE_bool_(catch_exceptions); + +// This flag enables using colors in terminal output. Available values are +// "yes" to enable colors, "no" (disable colors), or "auto" (the default) +// to let Google Test decide. +GTEST_DECLARE_string_(color); + +// This flag sets up the filter to select by name using a glob pattern +// the tests to run. If the filter is not given all tests are executed. +GTEST_DECLARE_string_(filter); + +// This flag causes the Google Test to list tests. None of the tests listed +// are actually run if the flag is provided. +GTEST_DECLARE_bool_(list_tests); + +// This flag controls whether Google Test emits a detailed XML report to a file +// in addition to its normal textual output. +GTEST_DECLARE_string_(output); + +// This flags control whether Google Test prints the elapsed time for each +// test. +GTEST_DECLARE_bool_(print_time); + +// This flag specifies the random number seed. +GTEST_DECLARE_int32_(random_seed); + +// This flag sets how many times the tests are repeated. The default value +// is 1. If the value is -1 the tests are repeating forever. +GTEST_DECLARE_int32_(repeat); + +// This flag controls whether Google Test includes Google Test internal +// stack frames in failure stack traces. +GTEST_DECLARE_bool_(show_internal_stack_frames); + +// When this flag is specified, tests' order is randomized on every iteration. +GTEST_DECLARE_bool_(shuffle); + +// This flag specifies the maximum number of stack frames to be +// printed in a failure message. +GTEST_DECLARE_int32_(stack_trace_depth); + +// 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. +GTEST_DECLARE_bool_(throw_on_failure); + +// When this flag is set with a "host:port" string, on supported +// platforms test results are streamed to the specified port on +// the specified host machine. +GTEST_DECLARE_string_(stream_result_to); + +// The upper limit for valid stack trace depths. +const int kMaxStackTraceDepth = 100; + +namespace internal { + +class AssertHelper; +class DefaultGlobalTestPartResultReporter; +class ExecDeathTest; +class NoExecDeathTest; +class FinalSuccessChecker; +class GTestFlagSaver; +class StreamingListenerTest; +class TestResultAccessor; +class TestEventListenersAccessor; +class TestEventRepeater; +class UnitTestRecordPropertyTestHelper; +class WindowsDeathTest; +class UnitTestImpl* GetUnitTestImpl(); +void ReportFailureInUnknownLocation(TestPartResult::Type result_type, + const std::string& message); + +} // namespace internal + +// The friend relationship of some of these classes is cyclic. +// If we don't forward declare them the compiler might confuse the classes +// in friendship clauses with same named classes on the scope. +class Test; +class TestCase; +class TestInfo; +class UnitTest; + +// A class for indicating whether an assertion was successful. When +// the assertion wasn't successful, the AssertionResult object +// remembers a non-empty message that describes how it failed. +// +// To create an instance of this class, use one of the factory functions +// (AssertionSuccess() and AssertionFailure()). +// +// This class is useful for two purposes: +// 1. Defining predicate functions to be used with Boolean test assertions +// EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts +// 2. Defining predicate-format functions to be +// used with predicate assertions (ASSERT_PRED_FORMAT*, etc). +// +// For example, if you define IsEven predicate: +// +// testing::AssertionResult IsEven(int n) { +// if ((n % 2) == 0) +// return testing::AssertionSuccess(); +// else +// return testing::AssertionFailure() << n << " is odd"; +// } +// +// Then the failed expectation EXPECT_TRUE(IsEven(Fib(5))) +// will print the message +// +// Value of: IsEven(Fib(5)) +// Actual: false (5 is odd) +// Expected: true +// +// instead of a more opaque +// +// Value of: IsEven(Fib(5)) +// Actual: false +// Expected: true +// +// in case IsEven is a simple Boolean predicate. +// +// If you expect your predicate to be reused and want to support informative +// messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up +// about half as often as positive ones in our tests), supply messages for +// both success and failure cases: +// +// testing::AssertionResult IsEven(int n) { +// if ((n % 2) == 0) +// return testing::AssertionSuccess() << n << " is even"; +// else +// return testing::AssertionFailure() << n << " is odd"; +// } +// +// Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print +// +// Value of: IsEven(Fib(6)) +// Actual: true (8 is even) +// Expected: false +// +// NB: Predicates that support negative Boolean assertions have reduced +// performance in positive ones so be careful not to use them in tests +// that have lots (tens of thousands) of positive Boolean assertions. +// +// To use this class with EXPECT_PRED_FORMAT assertions such as: +// +// // Verifies that Foo() returns an even number. +// EXPECT_PRED_FORMAT1(IsEven, Foo()); +// +// you need to define: +// +// testing::AssertionResult IsEven(const char* expr, int n) { +// if ((n % 2) == 0) +// return testing::AssertionSuccess(); +// else +// return testing::AssertionFailure() +// << "Expected: " << expr << " is even\n Actual: it's " << n; +// } +// +// If Foo() returns 5, you will see the following message: +// +// Expected: Foo() is even +// Actual: it's 5 +// +class GTEST_API_ AssertionResult { + public: + // Copy constructor. + // Used in EXPECT_TRUE/FALSE(assertion_result). + AssertionResult(const AssertionResult& other); + // Used in the EXPECT_TRUE/FALSE(bool_expression). + explicit AssertionResult(bool success) : success_(success) {} + + // Returns true iff the assertion succeeded. + operator bool() const { return success_; } // NOLINT + + // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE. + AssertionResult operator!() const; + + // Returns the text streamed into this AssertionResult. Test assertions + // use it when they fail (i.e., the predicate's outcome doesn't match the + // assertion's expectation). When nothing has been streamed into the + // object, returns an empty string. + const char* message() const { + return message_.get() != NULL ? message_->c_str() : ""; + } + // TODO(vladl@google.com): Remove this after making sure no clients use it. + // Deprecated; please use message() instead. + const char* failure_message() const { return message(); } + + // Streams a custom failure message into this object. + template AssertionResult& operator<<(const T& value) { + AppendMessage(Message() << value); + return *this; + } + + // Allows streaming basic output manipulators such as endl or flush into + // this object. + AssertionResult& operator<<( + ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) { + AppendMessage(Message() << basic_manipulator); + return *this; + } + + private: + // Appends the contents of message to message_. + void AppendMessage(const Message& a_message) { + if (message_.get() == NULL) + message_.reset(new ::std::string); + message_->append(a_message.GetString().c_str()); + } + + // Stores result of the assertion predicate. + bool success_; + // Stores the message describing the condition in case the expectation + // construct is not satisfied with the predicate's outcome. + // Referenced via a pointer to avoid taking too much stack frame space + // with test assertions. + internal::scoped_ptr< ::std::string> message_; + + GTEST_DISALLOW_ASSIGN_(AssertionResult); +}; + +// Makes a successful assertion result. +GTEST_API_ AssertionResult AssertionSuccess(); + +// Makes a failed assertion result. +GTEST_API_ AssertionResult AssertionFailure(); + +// Makes a failed assertion result with the given failure message. +// Deprecated; use AssertionFailure() << msg. +GTEST_API_ AssertionResult AssertionFailure(const Message& msg); + +// The abstract class that all tests inherit from. +// +// In Google Test, a unit test program contains one or many TestCases, and +// each TestCase contains one or many Tests. +// +// When you define a test using the TEST macro, you don't need to +// explicitly derive from Test - the TEST macro automatically does +// this for you. +// +// The only time you derive from Test is when defining a test fixture +// to be used a TEST_F. For example: +// +// class FooTest : public testing::Test { +// protected: +// virtual void SetUp() { ... } +// virtual void TearDown() { ... } +// ... +// }; +// +// TEST_F(FooTest, Bar) { ... } +// TEST_F(FooTest, Baz) { ... } +// +// Test is not copyable. +class GTEST_API_ Test { + public: + friend class TestInfo; + + // Defines types for pointers to functions that set up and tear down + // a test case. + typedef internal::SetUpTestCaseFunc SetUpTestCaseFunc; + typedef internal::TearDownTestCaseFunc TearDownTestCaseFunc; + + // The d'tor is virtual as we intend to inherit from Test. + virtual ~Test(); + + // Sets up the stuff shared by all tests in this test case. + // + // Google Test will call Foo::SetUpTestCase() before running the first + // test in test case Foo. Hence a sub-class can define its own + // SetUpTestCase() method to shadow the one defined in the super + // class. + static void SetUpTestCase() {} + + // Tears down the stuff shared by all tests in this test case. + // + // Google Test will call Foo::TearDownTestCase() after running the last + // test in test case Foo. Hence a sub-class can define its own + // TearDownTestCase() method to shadow the one defined in the super + // class. + static void TearDownTestCase() {} + + // Returns true iff the current test has a fatal failure. + static bool HasFatalFailure(); + + // Returns true iff the current test has a non-fatal failure. + static bool HasNonfatalFailure(); + + // Returns true iff the current test has a (either fatal or + // non-fatal) failure. + static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); } + + // Logs a property for the current test, test case, or for the entire + // invocation of the test program when used outside of the context of a + // test case. Only the last value for a given key is remembered. These + // are public static so they can be called from utility functions that are + // not members of the test fixture. Calls to RecordProperty made during + // lifespan of the test (from the moment its constructor starts to the + // moment its destructor finishes) will be output in XML as attributes of + // the element. Properties recorded from fixture's + // SetUpTestCase or TearDownTestCase are logged as attributes of the + // corresponding element. Calls to RecordProperty made in the + // global context (before or after invocation of RUN_ALL_TESTS and from + // SetUp/TearDown method of Environment objects registered with Google + // Test) will be output as attributes of the element. + static void RecordProperty(const std::string& key, const std::string& value); + static void RecordProperty(const std::string& key, int value); + + protected: + // Creates a Test object. + Test(); + + // Sets up the test fixture. + virtual void SetUp(); + + // Tears down the test fixture. + virtual void TearDown(); + + private: + // Returns true iff the current test has the same fixture class as + // the first test in the current test case. + static bool HasSameFixtureClass(); + + // Runs the test after the test fixture has been set up. + // + // A sub-class must implement this to define the test logic. + // + // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM. + // Instead, use the TEST or TEST_F macro. + virtual void TestBody() = 0; + + // Sets up, executes, and tears down the test. + void Run(); + + // Deletes self. We deliberately pick an unusual name for this + // internal method to avoid clashing with names used in user TESTs. + void DeleteSelf_() { delete this; } + + // Uses a GTestFlagSaver to save and restore all Google Test flags. + const internal::GTestFlagSaver* const gtest_flag_saver_; + + // Often a user mis-spells SetUp() as Setup() and spends a long time + // wondering why it is never called by Google Test. The declaration of + // the following method is solely for catching such an error at + // compile time: + // + // - The return type is deliberately chosen to be not void, so it + // will be a conflict if a user declares void Setup() in his test + // fixture. + // + // - This method is private, so it will be another compiler error + // if a user calls it from his test fixture. + // + // DO NOT OVERRIDE THIS FUNCTION. + // + // If you see an error about overriding the following function or + // about it being private, you have mis-spelled SetUp() as Setup(). + struct Setup_should_be_spelled_SetUp {}; + virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; } + + // We disallow copying Tests. + GTEST_DISALLOW_COPY_AND_ASSIGN_(Test); +}; + +typedef internal::TimeInMillis TimeInMillis; + +// A copyable object representing a user specified test property which can be +// output as a key/value string pair. +// +// Don't inherit from TestProperty as its destructor is not virtual. +class TestProperty { + public: + // C'tor. TestProperty does NOT have a default constructor. + // Always use this constructor (with parameters) to create a + // TestProperty object. + TestProperty(const std::string& a_key, const std::string& a_value) : + key_(a_key), value_(a_value) { + } + + // Gets the user supplied key. + const char* key() const { + return key_.c_str(); + } + + // Gets the user supplied value. + const char* value() const { + return value_.c_str(); + } + + // Sets a new value, overriding the one supplied in the constructor. + void SetValue(const std::string& new_value) { + value_ = new_value; + } + + private: + // The key supplied by the user. + std::string key_; + // The value supplied by the user. + std::string value_; +}; + +// The result of a single Test. This includes a list of +// TestPartResults, a list of TestProperties, a count of how many +// death tests there are in the Test, and how much time it took to run +// the Test. +// +// TestResult is not copyable. +class GTEST_API_ TestResult { + public: + // Creates an empty TestResult. + TestResult(); + + // D'tor. Do not inherit from TestResult. + ~TestResult(); + + // Gets the number of all test parts. This is the sum of the number + // of successful test parts and the number of failed test parts. + int total_part_count() const; + + // Returns the number of the test properties. + int test_property_count() const; + + // Returns true iff the test passed (i.e. no test part failed). + bool Passed() const { return !Failed(); } + + // Returns true iff the test failed. + bool Failed() const; + + // Returns true iff the test fatally failed. + bool HasFatalFailure() const; + + // Returns true iff the test has a non-fatal failure. + bool HasNonfatalFailure() const; + + // Returns the elapsed time, in milliseconds. + TimeInMillis elapsed_time() const { return elapsed_time_; } + + // Returns the i-th test part result among all the results. i can range + // from 0 to test_property_count() - 1. If i is not in that range, aborts + // the program. + const TestPartResult& GetTestPartResult(int i) const; + + // Returns the i-th test property. i can range from 0 to + // test_property_count() - 1. If i is not in that range, aborts the + // program. + const TestProperty& GetTestProperty(int i) const; + + private: + friend class TestInfo; + friend class TestCase; + friend class UnitTest; + friend class internal::DefaultGlobalTestPartResultReporter; + friend class internal::ExecDeathTest; + friend class internal::TestResultAccessor; + friend class internal::UnitTestImpl; + friend class internal::WindowsDeathTest; + + // Gets the vector of TestPartResults. + const std::vector& test_part_results() const { + return test_part_results_; + } + + // Gets the vector of TestProperties. + const std::vector& test_properties() const { + return test_properties_; + } + + // Sets the elapsed time. + void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; } + + // Adds a test property to the list. The property is validated and may add + // a non-fatal failure if invalid (e.g., if it conflicts with reserved + // key names). If a property is already recorded for the same key, the + // value will be updated, rather than storing multiple values for the same + // key. xml_element specifies the element for which the property is being + // recorded and is used for validation. + void RecordProperty(const std::string& xml_element, + const TestProperty& test_property); + + // Adds a failure if the key is a reserved attribute of Google Test + // testcase tags. Returns true if the property is valid. + // TODO(russr): Validate attribute names are legal and human readable. + static bool ValidateTestProperty(const std::string& xml_element, + const TestProperty& test_property); + + // Adds a test part result to the list. + void AddTestPartResult(const TestPartResult& test_part_result); + + // Returns the death test count. + int death_test_count() const { return death_test_count_; } + + // Increments the death test count, returning the new count. + int increment_death_test_count() { return ++death_test_count_; } + + // Clears the test part results. + void ClearTestPartResults(); + + // Clears the object. + void Clear(); + + // Protects mutable state of the property vector and of owned + // properties, whose values may be updated. + internal::Mutex test_properites_mutex_; + + // The vector of TestPartResults + std::vector test_part_results_; + // The vector of TestProperties + std::vector test_properties_; + // Running count of death tests. + int death_test_count_; + // The elapsed time, in milliseconds. + TimeInMillis elapsed_time_; + + // We disallow copying TestResult. + GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult); +}; // class TestResult + +// A TestInfo object stores the following information about a test: +// +// Test case name +// Test name +// Whether the test should be run +// A function pointer that creates the test object when invoked +// Test result +// +// The constructor of TestInfo registers itself with the UnitTest +// singleton such that the RUN_ALL_TESTS() macro knows which tests to +// run. +class GTEST_API_ TestInfo { + public: + // Destructs a TestInfo object. This function is not virtual, so + // don't inherit from TestInfo. + ~TestInfo(); + + // Returns the test case name. + const char* test_case_name() const { return test_case_name_.c_str(); } + + // Returns the test name. + const char* name() const { return name_.c_str(); } + + // Returns the name of the parameter type, or NULL if this is not a typed + // or a type-parameterized test. + const char* type_param() const { + if (type_param_.get() != NULL) + return type_param_->c_str(); + return NULL; + } + + // Returns the text representation of the value parameter, or NULL if this + // is not a value-parameterized test. + const char* value_param() const { + if (value_param_.get() != NULL) + return value_param_->c_str(); + return NULL; + } + + // Returns true if this test should run, that is if the test is not + // disabled (or it is disabled but the also_run_disabled_tests flag has + // been specified) and its full name matches the user-specified filter. + // + // Google Test allows the user to filter the tests by their full names. + // The full name of a test Bar in test case Foo is defined as + // "Foo.Bar". Only the tests that match the filter will run. + // + // A filter is a colon-separated list of glob (not regex) patterns, + // optionally followed by a '-' and a colon-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. + // + // For example, *A*:Foo.* is a filter that matches any string that + // contains the character 'A' or starts with "Foo.". + bool should_run() const { return should_run_; } + + // Returns true iff this test will appear in the XML report. + bool is_reportable() const { + // For now, the XML report includes all tests matching the filter. + // In the future, we may trim tests that are excluded because of + // sharding. + return matches_filter_; + } + + // Returns the result of the test. + const TestResult* result() const { return &result_; } + + private: +#if GTEST_HAS_DEATH_TEST + friend class internal::DefaultDeathTestFactory; +#endif // GTEST_HAS_DEATH_TEST + friend class Test; + friend class TestCase; + friend class internal::UnitTestImpl; + friend class internal::StreamingListenerTest; + friend TestInfo* internal::MakeAndRegisterTestInfo( + const char* test_case_name, + const char* name, + const char* type_param, + const char* value_param, + internal::TypeId fixture_class_id, + Test::SetUpTestCaseFunc set_up_tc, + Test::TearDownTestCaseFunc tear_down_tc, + internal::TestFactoryBase* factory); + + // Constructs a TestInfo object. The newly constructed instance assumes + // ownership of the factory object. + TestInfo(const std::string& test_case_name, + const std::string& name, + const char* a_type_param, // NULL if not a type-parameterized test + const char* a_value_param, // NULL if not a value-parameterized test + internal::TypeId fixture_class_id, + internal::TestFactoryBase* factory); + + // Increments the number of death tests encountered in this test so + // far. + int increment_death_test_count() { + return result_.increment_death_test_count(); + } + + // Creates the test object, runs it, records its result, and then + // deletes it. + void Run(); + + static void ClearTestResult(TestInfo* test_info) { + test_info->result_.Clear(); + } + + // These fields are immutable properties of the test. + const std::string test_case_name_; // Test case name + const std::string name_; // Test name + // Name of the parameter type, or NULL if this is not a typed or a + // type-parameterized test. + const internal::scoped_ptr type_param_; + // Text representation of the value parameter, or NULL if this is not a + // value-parameterized test. + const internal::scoped_ptr value_param_; + const internal::TypeId fixture_class_id_; // ID of the test fixture class + bool should_run_; // True iff this test should run + bool is_disabled_; // True iff this test is disabled + bool matches_filter_; // True if this test matches the + // user-specified filter. + internal::TestFactoryBase* const factory_; // The factory that creates + // the test object + + // This field is mutable and needs to be reset before running the + // test for the second time. + TestResult result_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo); +}; + +// A test case, which consists of a vector of TestInfos. +// +// TestCase is not copyable. +class GTEST_API_ TestCase { + public: + // Creates a TestCase with the given name. + // + // TestCase does NOT have a default constructor. Always use this + // constructor to create a TestCase object. + // + // Arguments: + // + // name: name of the test case + // a_type_param: the name of the test's type parameter, or NULL if + // this is not a type-parameterized test. + // set_up_tc: pointer to the function that sets up the test case + // tear_down_tc: pointer to the function that tears down the test case + TestCase(const char* name, const char* a_type_param, + Test::SetUpTestCaseFunc set_up_tc, + Test::TearDownTestCaseFunc tear_down_tc); + + // Destructor of TestCase. + virtual ~TestCase(); + + // Gets the name of the TestCase. + const char* name() const { return name_.c_str(); } + + // Returns the name of the parameter type, or NULL if this is not a + // type-parameterized test case. + const char* type_param() const { + if (type_param_.get() != NULL) + return type_param_->c_str(); + return NULL; + } + + // Returns true if any test in this test case should run. + bool should_run() const { return should_run_; } + + // Gets the number of successful tests in this test case. + int successful_test_count() const; + + // Gets the number of failed tests in this test case. + int failed_test_count() const; + + // Gets the number of disabled tests that will be reported in the XML report. + int reportable_disabled_test_count() const; + + // Gets the number of disabled tests in this test case. + int disabled_test_count() const; + + // Gets the number of tests to be printed in the XML report. + int reportable_test_count() const; + + // Get the number of tests in this test case that should run. + int test_to_run_count() const; + + // Gets the number of all tests in this test case. + int total_test_count() const; + + // Returns true iff the test case passed. + bool Passed() const { return !Failed(); } + + // Returns true iff the test case failed. + bool Failed() const { return failed_test_count() > 0; } + + // Returns the elapsed time, in milliseconds. + TimeInMillis elapsed_time() const { return elapsed_time_; } + + // Returns the i-th test among all the tests. i can range from 0 to + // total_test_count() - 1. If i is not in that range, returns NULL. + const TestInfo* GetTestInfo(int i) const; + + // Returns the TestResult that holds test properties recorded during + // execution of SetUpTestCase and TearDownTestCase. + const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; } + + private: + friend class Test; + friend class internal::UnitTestImpl; + + // Gets the (mutable) vector of TestInfos in this TestCase. + std::vector& test_info_list() { return test_info_list_; } + + // Gets the (immutable) vector of TestInfos in this TestCase. + const std::vector& test_info_list() const { + return test_info_list_; + } + + // Returns the i-th test among all the tests. i can range from 0 to + // total_test_count() - 1. If i is not in that range, returns NULL. + TestInfo* GetMutableTestInfo(int i); + + // Sets the should_run member. + void set_should_run(bool should) { should_run_ = should; } + + // Adds a TestInfo to this test case. Will delete the TestInfo upon + // destruction of the TestCase object. + void AddTestInfo(TestInfo * test_info); + + // Clears the results of all tests in this test case. + void ClearResult(); + + // Clears the results of all tests in the given test case. + static void ClearTestCaseResult(TestCase* test_case) { + test_case->ClearResult(); + } + + // Runs every test in this TestCase. + void Run(); + + // Runs SetUpTestCase() for this TestCase. This wrapper is needed + // for catching exceptions thrown from SetUpTestCase(). + void RunSetUpTestCase() { (*set_up_tc_)(); } + + // Runs TearDownTestCase() for this TestCase. This wrapper is + // needed for catching exceptions thrown from TearDownTestCase(). + void RunTearDownTestCase() { (*tear_down_tc_)(); } + + // Returns true iff test passed. + static bool TestPassed(const TestInfo* test_info) { + return test_info->should_run() && test_info->result()->Passed(); + } + + // Returns true iff test failed. + static bool TestFailed(const TestInfo* test_info) { + return test_info->should_run() && test_info->result()->Failed(); + } + + // Returns true iff the test is disabled and will be reported in the XML + // report. + static bool TestReportableDisabled(const TestInfo* test_info) { + return test_info->is_reportable() && test_info->is_disabled_; + } + + // Returns true iff test is disabled. + static bool TestDisabled(const TestInfo* test_info) { + return test_info->is_disabled_; + } + + // Returns true iff this test will appear in the XML report. + static bool TestReportable(const TestInfo* test_info) { + return test_info->is_reportable(); + } + + // Returns true if the given test should run. + static bool ShouldRunTest(const TestInfo* test_info) { + return test_info->should_run(); + } + + // Shuffles the tests in this test case. + void ShuffleTests(internal::Random* random); + + // Restores the test order to before the first shuffle. + void UnshuffleTests(); + + // Name of the test case. + std::string name_; + // Name of the parameter type, or NULL if this is not a typed or a + // type-parameterized test. + const internal::scoped_ptr type_param_; + // The vector of TestInfos in their original order. It owns the + // elements in the vector. + std::vector test_info_list_; + // Provides a level of indirection for the test list to allow easy + // shuffling and restoring the test order. The i-th element in this + // vector is the index of the i-th test in the shuffled test list. + std::vector test_indices_; + // Pointer to the function that sets up the test case. + Test::SetUpTestCaseFunc set_up_tc_; + // Pointer to the function that tears down the test case. + Test::TearDownTestCaseFunc tear_down_tc_; + // True iff any test in this test case should run. + bool should_run_; + // Elapsed time, in milliseconds. + TimeInMillis elapsed_time_; + // Holds test properties recorded during execution of SetUpTestCase and + // TearDownTestCase. + TestResult ad_hoc_test_result_; + + // We disallow copying TestCases. + GTEST_DISALLOW_COPY_AND_ASSIGN_(TestCase); +}; + +// An Environment object is capable of setting up and tearing down an +// environment. The user should subclass this to define his own +// environment(s). +// +// An Environment object does the set-up and tear-down in virtual +// methods SetUp() and TearDown() instead of the constructor and the +// destructor, as: +// +// 1. You cannot safely throw from a destructor. This is a problem +// as in some cases Google Test is used where exceptions are enabled, and +// we may want to implement ASSERT_* using exceptions where they are +// available. +// 2. You cannot use ASSERT_* directly in a constructor or +// destructor. +class Environment { + public: + // The d'tor is virtual as we need to subclass Environment. + virtual ~Environment() {} + + // Override this to define how to set up the environment. + virtual void SetUp() {} + + // Override this to define how to tear down the environment. + virtual void TearDown() {} + private: + // If you see an error about overriding the following function or + // about it being private, you have mis-spelled SetUp() as Setup(). + struct Setup_should_be_spelled_SetUp {}; + virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; } +}; + +// The interface for tracing execution of tests. The methods are organized in +// the order the corresponding events are fired. +class TestEventListener { + public: + virtual ~TestEventListener() {} + + // Fired before any test activity starts. + virtual void OnTestProgramStart(const UnitTest& unit_test) = 0; + + // Fired before each iteration of tests starts. There may be more than + // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration + // index, starting from 0. + virtual void OnTestIterationStart(const UnitTest& unit_test, + int iteration) = 0; + + // Fired before environment set-up for each iteration of tests starts. + virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0; + + // Fired after environment set-up for each iteration of tests ends. + virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0; + + // Fired before the test case starts. + virtual void OnTestCaseStart(const TestCase& test_case) = 0; + + // Fired before the test starts. + virtual void OnTestStart(const TestInfo& test_info) = 0; + + // Fired after a failed assertion or a SUCCEED() invocation. + virtual void OnTestPartResult(const TestPartResult& test_part_result) = 0; + + // Fired after the test ends. + virtual void OnTestEnd(const TestInfo& test_info) = 0; + + // Fired after the test case ends. + virtual void OnTestCaseEnd(const TestCase& test_case) = 0; + + // Fired before environment tear-down for each iteration of tests starts. + virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0; + + // Fired after environment tear-down for each iteration of tests ends. + virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0; + + // Fired after each iteration of tests finishes. + virtual void OnTestIterationEnd(const UnitTest& unit_test, + int iteration) = 0; + + // Fired after all test activities have ended. + virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0; +}; + +// The convenience class for users who need to override just one or two +// methods and are not concerned that a possible change to a signature of +// the methods they override will not be caught during the build. For +// comments about each method please see the definition of TestEventListener +// above. +class EmptyTestEventListener : public TestEventListener { + public: + virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {} + virtual void OnTestIterationStart(const UnitTest& /*unit_test*/, + int /*iteration*/) {} + virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {} + virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {} + virtual void OnTestCaseStart(const TestCase& /*test_case*/) {} + virtual void OnTestStart(const TestInfo& /*test_info*/) {} + virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {} + virtual void OnTestEnd(const TestInfo& /*test_info*/) {} + virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {} + virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {} + virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {} + virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/, + int /*iteration*/) {} + virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {} +}; + +// TestEventListeners lets users add listeners to track events in Google Test. +class GTEST_API_ TestEventListeners { + public: + TestEventListeners(); + ~TestEventListeners(); + + // Appends an event listener to the end of the list. Google Test assumes + // the ownership of the listener (i.e. it will delete the listener when + // the test program finishes). + void Append(TestEventListener* listener); + + // Removes the given event listener from the list and returns it. It then + // becomes the caller's responsibility to delete the listener. Returns + // NULL if the listener is not found in the list. + TestEventListener* Release(TestEventListener* listener); + + // Returns the standard listener responsible for the default console + // output. Can be removed from the listeners list to shut down default + // console output. Note that removing this object from the listener list + // with Release transfers its ownership to the caller and makes this + // function return NULL the next time. + TestEventListener* default_result_printer() const { + return default_result_printer_; + } + + // Returns the standard listener responsible for the default XML output + // controlled by the --gtest_output=xml flag. Can be removed from the + // listeners list by users who want to shut down the default XML output + // controlled by this flag and substitute it with custom one. Note that + // removing this object from the listener list with Release transfers its + // ownership to the caller and makes this function return NULL the next + // time. + TestEventListener* default_xml_generator() const { + return default_xml_generator_; + } + + private: + friend class TestCase; + friend class TestInfo; + friend class internal::DefaultGlobalTestPartResultReporter; + friend class internal::NoExecDeathTest; + friend class internal::TestEventListenersAccessor; + friend class internal::UnitTestImpl; + + // Returns repeater that broadcasts the TestEventListener events to all + // subscribers. + TestEventListener* repeater(); + + // Sets the default_result_printer attribute to the provided listener. + // The listener is also added to the listener list and previous + // default_result_printer is removed from it and deleted. The listener can + // also be NULL in which case it will not be added to the list. Does + // nothing if the previous and the current listener objects are the same. + void SetDefaultResultPrinter(TestEventListener* listener); + + // Sets the default_xml_generator attribute to the provided listener. The + // listener is also added to the listener list and previous + // default_xml_generator is removed from it and deleted. The listener can + // also be NULL in which case it will not be added to the list. Does + // nothing if the previous and the current listener objects are the same. + void SetDefaultXmlGenerator(TestEventListener* listener); + + // Controls whether events will be forwarded by the repeater to the + // listeners in the list. + bool EventForwardingEnabled() const; + void SuppressEventForwarding(); + + // The actual list of listeners. + internal::TestEventRepeater* repeater_; + // Listener responsible for the standard result output. + TestEventListener* default_result_printer_; + // Listener responsible for the creation of the XML output file. + TestEventListener* default_xml_generator_; + + // We disallow copying TestEventListeners. + GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners); +}; + +// A UnitTest consists of a vector of TestCases. +// +// This is a singleton class. The only instance of UnitTest is +// created when UnitTest::GetInstance() is first called. This +// instance is never deleted. +// +// UnitTest is not copyable. +// +// This class is thread-safe as long as the methods are called +// according to their specification. +class GTEST_API_ UnitTest { + public: + // Gets the singleton UnitTest object. The first time this method + // is called, a UnitTest object is constructed and returned. + // Consecutive calls will return the same object. + static UnitTest* GetInstance(); + + // Runs all tests in this UnitTest object and prints the result. + // Returns 0 if successful, or 1 otherwise. + // + // This method can only be called from the main thread. + // + // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. + int Run() GTEST_MUST_USE_RESULT_; + + // Returns the working directory when the first TEST() or TEST_F() + // was executed. The UnitTest object owns the string. + const char* original_working_dir() const; + + // Returns the TestCase object for the test that's currently running, + // or NULL if no test is running. + const TestCase* current_test_case() const + GTEST_LOCK_EXCLUDED_(mutex_); + + // Returns the TestInfo object for the test that's currently running, + // or NULL if no test is running. + const TestInfo* current_test_info() const + GTEST_LOCK_EXCLUDED_(mutex_); + + // Returns the random seed used at the start of the current test run. + int random_seed() const; + +#if GTEST_HAS_PARAM_TEST + // Returns the ParameterizedTestCaseRegistry object used to keep track of + // value-parameterized tests and instantiate and register them. + // + // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. + internal::ParameterizedTestCaseRegistry& parameterized_test_registry() + GTEST_LOCK_EXCLUDED_(mutex_); +#endif // GTEST_HAS_PARAM_TEST + + // Gets the number of successful test cases. + int successful_test_case_count() const; + + // Gets the number of failed test cases. + int failed_test_case_count() const; + + // Gets the number of all test cases. + int total_test_case_count() const; + + // Gets the number of all test cases that contain at least one test + // that should run. + int test_case_to_run_count() const; + + // Gets the number of successful tests. + int successful_test_count() const; + + // Gets the number of failed tests. + int failed_test_count() const; + + // Gets the number of disabled tests that will be reported in the XML report. + int reportable_disabled_test_count() const; + + // Gets the number of disabled tests. + int disabled_test_count() const; + + // Gets the number of tests to be printed in the XML report. + int reportable_test_count() const; + + // Gets the number of all tests. + int total_test_count() const; + + // Gets the number of tests that should run. + int test_to_run_count() const; + + // Gets the time of the test program start, in ms from the start of the + // UNIX epoch. + TimeInMillis start_timestamp() const; + + // Gets the elapsed time, in milliseconds. + TimeInMillis elapsed_time() const; + + // Returns true iff the unit test passed (i.e. all test cases passed). + bool Passed() const; + + // Returns true iff the unit test failed (i.e. some test case failed + // or something outside of all tests failed). + bool Failed() const; + + // Gets the i-th test case among all the test cases. i can range from 0 to + // total_test_case_count() - 1. If i is not in that range, returns NULL. + const TestCase* GetTestCase(int i) const; + + // Returns the TestResult containing information on test failures and + // properties logged outside of individual test cases. + const TestResult& ad_hoc_test_result() const; + + // Returns the list of event listeners that can be used to track events + // inside Google Test. + TestEventListeners& listeners(); + + private: + // Registers and returns a global test environment. When a test + // program is run, all global test environments will be set-up in + // the order they were registered. After all tests in the program + // have finished, all global test environments will be torn-down in + // the *reverse* order they were registered. + // + // The UnitTest object takes ownership of the given environment. + // + // This method can only be called from the main thread. + Environment* AddEnvironment(Environment* env); + + // Adds a TestPartResult to the current TestResult object. All + // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) + // eventually call this to report their results. The user code + // should use the assertion macros instead of calling this directly. + void AddTestPartResult(TestPartResult::Type result_type, + const char* file_name, + int line_number, + const std::string& message, + const std::string& os_stack_trace) + GTEST_LOCK_EXCLUDED_(mutex_); + + // Adds a TestProperty to the current TestResult object when invoked from + // inside a test, to current TestCase's ad_hoc_test_result_ when invoked + // from SetUpTestCase or TearDownTestCase, or to the global property set + // when invoked elsewhere. If the result already contains a property with + // the same key, the value will be updated. + void RecordProperty(const std::string& key, const std::string& value); + + // Gets the i-th test case among all the test cases. i can range from 0 to + // total_test_case_count() - 1. If i is not in that range, returns NULL. + TestCase* GetMutableTestCase(int i); + + // Accessors for the implementation object. + internal::UnitTestImpl* impl() { return impl_; } + const internal::UnitTestImpl* impl() const { return impl_; } + + // These classes and funcions are friends as they need to access private + // members of UnitTest. + friend class Test; + friend class internal::AssertHelper; + friend class internal::ScopedTrace; + friend class internal::StreamingListenerTest; + friend class internal::UnitTestRecordPropertyTestHelper; + friend Environment* AddGlobalTestEnvironment(Environment* env); + friend internal::UnitTestImpl* internal::GetUnitTestImpl(); + friend void internal::ReportFailureInUnknownLocation( + TestPartResult::Type result_type, + const std::string& message); + + // Creates an empty UnitTest. + UnitTest(); + + // D'tor + virtual ~UnitTest(); + + // Pushes a trace defined by SCOPED_TRACE() on to the per-thread + // Google Test trace stack. + void PushGTestTrace(const internal::TraceInfo& trace) + GTEST_LOCK_EXCLUDED_(mutex_); + + // Pops a trace from the per-thread Google Test trace stack. + void PopGTestTrace() + GTEST_LOCK_EXCLUDED_(mutex_); + + // Protects mutable state in *impl_. This is mutable as some const + // methods need to lock it too. + mutable internal::Mutex mutex_; + + // Opaque implementation object. This field is never changed once + // the object is constructed. We don't mark it as const here, as + // doing so will cause a warning in the constructor of UnitTest. + // Mutable state in *impl_ is protected by mutex_. + internal::UnitTestImpl* impl_; + + // We disallow copying UnitTest. + GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest); +}; + +// A convenient wrapper for adding an environment for the test +// program. +// +// You should call this before RUN_ALL_TESTS() is called, probably in +// main(). If you use gtest_main, you need to call this before main() +// starts for it to take effect. For example, you can define a global +// variable like this: +// +// testing::Environment* const foo_env = +// testing::AddGlobalTestEnvironment(new FooEnvironment); +// +// However, we strongly recommend you to write your own main() and +// call AddGlobalTestEnvironment() there, as relying on initialization +// of global variables makes the code harder to read and may cause +// problems when you register multiple environments from different +// translation units and the environments have dependencies among them +// (remember that the compiler doesn't guarantee the order in which +// global variables from different translation units are initialized). +inline Environment* AddGlobalTestEnvironment(Environment* env) { + return UnitTest::GetInstance()->AddEnvironment(env); +} + +// Initializes Google Test. This must be called before calling +// RUN_ALL_TESTS(). In particular, it parses a command line for the +// flags that Google Test recognizes. Whenever a Google Test flag is +// seen, it is removed from argv, and *argc is decremented. +// +// No value is returned. Instead, the Google Test flag variables are +// updated. +// +// Calling the function for the second time has no user-visible effect. +GTEST_API_ void InitGoogleTest(int* argc, char** argv); + +// This overloaded version can be used in Windows programs compiled in +// UNICODE mode. +GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv); + +namespace internal { + +// FormatForComparison::Format(value) formats a +// value of type ToPrint that is an operand of a comparison assertion +// (e.g. ASSERT_EQ). OtherOperand is the type of the other operand in +// the comparison, and is used to help determine the best way to +// format the value. In particular, when the value is a C string +// (char pointer) and the other operand is an STL string object, we +// want to format the C string as a string, since we know it is +// compared by value with the string object. If the value is a char +// pointer but the other operand is not an STL string object, we don't +// know whether the pointer is supposed to point to a NUL-terminated +// string, and thus want to print it as a pointer to be safe. +// +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. + +// The default case. +template +class FormatForComparison { + public: + static ::std::string Format(const ToPrint& value) { + return ::testing::PrintToString(value); + } +}; + +// Array. +template +class FormatForComparison { + public: + static ::std::string Format(const ToPrint* value) { + return FormatForComparison::Format(value); + } +}; + +// By default, print C string as pointers to be safe, as we don't know +// whether they actually point to a NUL-terminated string. + +#define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType) \ + template \ + class FormatForComparison { \ + public: \ + static ::std::string Format(CharType* value) { \ + return ::testing::PrintToString(static_cast(value)); \ + } \ + } + +GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char); +GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char); +GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t); +GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t); + +#undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ + +// If a C string is compared with an STL string object, we know it's meant +// to point to a NUL-terminated string, and thus can print it as a string. + +#define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \ + template <> \ + class FormatForComparison { \ + public: \ + static ::std::string Format(CharType* value) { \ + return ::testing::PrintToString(value); \ + } \ + } + +GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string); +GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string); + +#if GTEST_HAS_GLOBAL_STRING +GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::string); +GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::string); +#endif + +#if GTEST_HAS_GLOBAL_WSTRING +GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::wstring); +GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::wstring); +#endif + +#if GTEST_HAS_STD_WSTRING +GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring); +GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring); +#endif + +#undef GTEST_IMPL_FORMAT_C_STRING_AS_STRING_ + +// Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc) +// operand to be used in a failure message. The type (but not value) +// of the other operand may affect the format. This allows us to +// print a char* as a raw pointer when it is compared against another +// char* or void*, and print it as a C string when it is compared +// against an std::string object, for example. +// +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +template +std::string FormatForComparisonFailureMessage( + const T1& value, const T2& /* other_operand */) { + return FormatForComparison::Format(value); +} + +// The helper function for {ASSERT|EXPECT}_EQ. +template +AssertionResult CmpHelperEQ(const char* expected_expression, + const char* actual_expression, + const T1& expected, + const T2& actual) { +#ifdef _MSC_VER +# pragma warning(push) // Saves the current warning state. +# pragma warning(disable:4389) // Temporarily disables warning on + // signed/unsigned mismatch. +#endif + + if (expected == actual) { + return AssertionSuccess(); + } + +#ifdef _MSC_VER +# pragma warning(pop) // Restores the warning state. +#endif + + return EqFailure(expected_expression, + actual_expression, + FormatForComparisonFailureMessage(expected, actual), + FormatForComparisonFailureMessage(actual, expected), + false); +} + +// With this overloaded version, we allow anonymous enums to be used +// in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous enums +// can be implicitly cast to BiggestInt. +GTEST_API_ AssertionResult CmpHelperEQ(const char* expected_expression, + const char* actual_expression, + BiggestInt expected, + BiggestInt actual); + +// The helper class for {ASSERT|EXPECT}_EQ. The template argument +// lhs_is_null_literal is true iff the first argument to ASSERT_EQ() +// is a null pointer literal. The following default implementation is +// for lhs_is_null_literal being false. +template +class EqHelper { + public: + // This templatized version is for the general case. + template + static AssertionResult Compare(const char* expected_expression, + const char* actual_expression, + const T1& expected, + const T2& actual) { + return CmpHelperEQ(expected_expression, actual_expression, expected, + actual); + } + + // With this overloaded version, we allow anonymous enums to be used + // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous + // enums can be implicitly cast to BiggestInt. + // + // Even though its body looks the same as the above version, we + // cannot merge the two, as it will make anonymous enums unhappy. + static AssertionResult Compare(const char* expected_expression, + const char* actual_expression, + BiggestInt expected, + BiggestInt actual) { + return CmpHelperEQ(expected_expression, actual_expression, expected, + actual); + } +}; + +// This specialization is used when the first argument to ASSERT_EQ() +// is a null pointer literal, like NULL, false, or 0. +template <> +class EqHelper { + public: + // We define two overloaded versions of Compare(). The first + // version will be picked when the second argument to ASSERT_EQ() is + // NOT a pointer, e.g. ASSERT_EQ(0, AnIntFunction()) or + // EXPECT_EQ(false, a_bool). + template + static AssertionResult Compare( + const char* expected_expression, + const char* actual_expression, + const T1& expected, + const T2& actual, + // The following line prevents this overload from being considered if T2 + // is not a pointer type. We need this because ASSERT_EQ(NULL, my_ptr) + // expands to Compare("", "", NULL, my_ptr), which requires a conversion + // to match the Secret* in the other overload, which would otherwise make + // this template match better. + typename EnableIf::value>::type* = 0) { + return CmpHelperEQ(expected_expression, actual_expression, expected, + actual); + } + + // This version will be picked when the second argument to ASSERT_EQ() is a + // pointer, e.g. ASSERT_EQ(NULL, a_pointer). + template + static AssertionResult Compare( + const char* expected_expression, + const char* actual_expression, + // We used to have a second template parameter instead of Secret*. That + // template parameter would deduce to 'long', making this a better match + // than the first overload even without the first overload's EnableIf. + // Unfortunately, gcc with -Wconversion-null warns when "passing NULL to + // non-pointer argument" (even a deduced integral argument), so the old + // implementation caused warnings in user code. + Secret* /* expected (NULL) */, + T* actual) { + // We already know that 'expected' is a null pointer. + return CmpHelperEQ(expected_expression, actual_expression, + static_cast(NULL), actual); + } +}; + +// A macro for implementing the helper functions needed to implement +// ASSERT_?? and EXPECT_??. It is here just to avoid copy-and-paste +// of similar code. +// +// For each templatized helper function, we also define an overloaded +// version for BiggestInt in order to reduce code bloat and allow +// anonymous enums to be used with {ASSERT|EXPECT}_?? when compiled +// with gcc 4. +// +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +#define GTEST_IMPL_CMP_HELPER_(op_name, op)\ +template \ +AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ + const T1& val1, const T2& val2) {\ + if (val1 op val2) {\ + return AssertionSuccess();\ + } else {\ + return AssertionFailure() \ + << "Expected: (" << expr1 << ") " #op " (" << expr2\ + << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\ + << " vs " << FormatForComparisonFailureMessage(val2, val1);\ + }\ +}\ +GTEST_API_ AssertionResult CmpHelper##op_name(\ + const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2) + +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. + +// Implements the helper function for {ASSERT|EXPECT}_NE +GTEST_IMPL_CMP_HELPER_(NE, !=); +// Implements the helper function for {ASSERT|EXPECT}_LE +GTEST_IMPL_CMP_HELPER_(LE, <=); +// Implements the helper function for {ASSERT|EXPECT}_LT +GTEST_IMPL_CMP_HELPER_(LT, <); +// Implements the helper function for {ASSERT|EXPECT}_GE +GTEST_IMPL_CMP_HELPER_(GE, >=); +// Implements the helper function for {ASSERT|EXPECT}_GT +GTEST_IMPL_CMP_HELPER_(GT, >); + +#undef GTEST_IMPL_CMP_HELPER_ + +// The helper function for {ASSERT|EXPECT}_STREQ. +// +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +GTEST_API_ AssertionResult CmpHelperSTREQ(const char* expected_expression, + const char* actual_expression, + const char* expected, + const char* actual); + +// The helper function for {ASSERT|EXPECT}_STRCASEEQ. +// +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression, + const char* actual_expression, + const char* expected, + const char* actual); + +// The helper function for {ASSERT|EXPECT}_STRNE. +// +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression, + const char* s2_expression, + const char* s1, + const char* s2); + +// The helper function for {ASSERT|EXPECT}_STRCASENE. +// +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression, + const char* s2_expression, + const char* s1, + const char* s2); + + +// Helper function for *_STREQ on wide strings. +// +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +GTEST_API_ AssertionResult CmpHelperSTREQ(const char* expected_expression, + const char* actual_expression, + const wchar_t* expected, + const wchar_t* actual); + +// Helper function for *_STRNE on wide strings. +// +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression, + const char* s2_expression, + const wchar_t* s1, + const wchar_t* s2); + +} // namespace internal + +// IsSubstring() and IsNotSubstring() are intended to be used as the +// first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by +// themselves. They check whether needle is a substring of haystack +// (NULL is considered a substring of itself only), and return an +// appropriate error message when they fail. +// +// The {needle,haystack}_expr arguments are the stringified +// expressions that generated the two real arguments. +GTEST_API_ AssertionResult IsSubstring( + const char* needle_expr, const char* haystack_expr, + const char* needle, const char* haystack); +GTEST_API_ AssertionResult IsSubstring( + const char* needle_expr, const char* haystack_expr, + const wchar_t* needle, const wchar_t* haystack); +GTEST_API_ AssertionResult IsNotSubstring( + const char* needle_expr, const char* haystack_expr, + const char* needle, const char* haystack); +GTEST_API_ AssertionResult IsNotSubstring( + const char* needle_expr, const char* haystack_expr, + const wchar_t* needle, const wchar_t* haystack); +GTEST_API_ AssertionResult IsSubstring( + const char* needle_expr, const char* haystack_expr, + const ::std::string& needle, const ::std::string& haystack); +GTEST_API_ AssertionResult IsNotSubstring( + const char* needle_expr, const char* haystack_expr, + const ::std::string& needle, const ::std::string& haystack); + +#if GTEST_HAS_STD_WSTRING +GTEST_API_ AssertionResult IsSubstring( + const char* needle_expr, const char* haystack_expr, + const ::std::wstring& needle, const ::std::wstring& haystack); +GTEST_API_ AssertionResult IsNotSubstring( + const char* needle_expr, const char* haystack_expr, + const ::std::wstring& needle, const ::std::wstring& haystack); +#endif // GTEST_HAS_STD_WSTRING + +namespace internal { + +// Helper template function for comparing floating-points. +// +// Template parameter: +// +// RawType: the raw floating-point type (either float or double) +// +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +template +AssertionResult CmpHelperFloatingPointEQ(const char* expected_expression, + const char* actual_expression, + RawType expected, + RawType actual) { + const FloatingPoint lhs(expected), rhs(actual); + + if (lhs.AlmostEquals(rhs)) { + return AssertionSuccess(); + } + + ::std::stringstream expected_ss; + expected_ss << std::setprecision(std::numeric_limits::digits10 + 2) + << expected; + + ::std::stringstream actual_ss; + actual_ss << std::setprecision(std::numeric_limits::digits10 + 2) + << actual; + + return EqFailure(expected_expression, + actual_expression, + StringStreamToString(&expected_ss), + StringStreamToString(&actual_ss), + false); +} + +// Helper function for implementing ASSERT_NEAR. +// +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1, + const char* expr2, + const char* abs_error_expr, + double val1, + double val2, + double abs_error); + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// A class that enables one to stream messages to assertion macros +class GTEST_API_ AssertHelper { + public: + // Constructor. + AssertHelper(TestPartResult::Type type, + const char* file, + int line, + const char* message); + ~AssertHelper(); + + // Message assignment is a semantic trick to enable assertion + // streaming; see the GTEST_MESSAGE_ macro below. + void operator=(const Message& message) const; + + private: + // We put our data in a struct so that the size of the AssertHelper class can + // be as small as possible. This is important because gcc is incapable of + // re-using stack space even for temporary variables, so every EXPECT_EQ + // reserves stack space for another AssertHelper. + struct AssertHelperData { + AssertHelperData(TestPartResult::Type t, + const char* srcfile, + int line_num, + const char* msg) + : type(t), file(srcfile), line(line_num), message(msg) { } + + TestPartResult::Type const type; + const char* const file; + int const line; + std::string const message; + + private: + GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData); + }; + + AssertHelperData* const data_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper); +}; + +} // namespace internal + +#if GTEST_HAS_PARAM_TEST +// The pure interface class that all value-parameterized tests inherit from. +// A value-parameterized class must inherit from both ::testing::Test and +// ::testing::WithParamInterface. In most cases that just means inheriting +// from ::testing::TestWithParam, but more complicated test hierarchies +// may need to inherit from Test and WithParamInterface at different levels. +// +// This interface has support for accessing the test parameter value via +// the GetParam() method. +// +// Use it with one of the parameter generator defining functions, like Range(), +// Values(), ValuesIn(), Bool(), and Combine(). +// +// class FooTest : public ::testing::TestWithParam { +// protected: +// FooTest() { +// // Can use GetParam() here. +// } +// virtual ~FooTest() { +// // Can use GetParam() here. +// } +// virtual void SetUp() { +// // Can use GetParam() here. +// } +// virtual void TearDown { +// // Can use GetParam() here. +// } +// }; +// TEST_P(FooTest, DoesBar) { +// // Can use GetParam() method here. +// Foo foo; +// ASSERT_TRUE(foo.DoesBar(GetParam())); +// } +// INSTANTIATE_TEST_CASE_P(OneToTenRange, FooTest, ::testing::Range(1, 10)); + +template +class WithParamInterface { + public: + typedef T ParamType; + virtual ~WithParamInterface() {} + + // The current parameter value. Is also available in the test fixture's + // constructor. This member function is non-static, even though it only + // references static data, to reduce the opportunity for incorrect uses + // like writing 'WithParamInterface::GetParam()' for a test that + // uses a fixture whose parameter type is int. + const ParamType& GetParam() const { + GTEST_CHECK_(parameter_ != NULL) + << "GetParam() can only be called inside a value-parameterized test " + << "-- did you intend to write TEST_P instead of TEST_F?"; + return *parameter_; + } + + private: + // Sets parameter value. The caller is responsible for making sure the value + // remains alive and unchanged throughout the current test. + static void SetParam(const ParamType* parameter) { + parameter_ = parameter; + } + + // Static value used for accessing parameter during a test lifetime. + static const ParamType* parameter_; + + // TestClass must be a subclass of WithParamInterface and Test. + template friend class internal::ParameterizedTestFactory; +}; + +template +const T* WithParamInterface::parameter_ = NULL; + +// Most value-parameterized classes can ignore the existence of +// WithParamInterface, and can just inherit from ::testing::TestWithParam. + +template +class TestWithParam : public Test, public WithParamInterface { +}; + +#endif // GTEST_HAS_PARAM_TEST + +// Macros for indicating success/failure in test code. + +// ADD_FAILURE unconditionally adds a failure to the current test. +// SUCCEED generates a success - it doesn't automatically make the +// current test successful, as a test is only successful when it has +// no failure. +// +// EXPECT_* verifies that a certain condition is satisfied. If not, +// it behaves like ADD_FAILURE. In particular: +// +// EXPECT_TRUE verifies that a Boolean condition is true. +// EXPECT_FALSE verifies that a Boolean condition is false. +// +// FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except +// that they will also abort the current function on failure. People +// usually want the fail-fast behavior of FAIL and ASSERT_*, but those +// writing data-driven tests often find themselves using ADD_FAILURE +// and EXPECT_* more. + +// Generates a nonfatal failure with a generic message. +#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed") + +// Generates a nonfatal failure at the given source file location with +// a generic message. +#define ADD_FAILURE_AT(file, line) \ + GTEST_MESSAGE_AT_(file, line, "Failed", \ + ::testing::TestPartResult::kNonFatalFailure) + +// Generates a fatal failure with a generic message. +#define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed") + +// Define this macro to 1 to omit the definition of FAIL(), which is a +// generic name and clashes with some other libraries. +#if !GTEST_DONT_DEFINE_FAIL +# define FAIL() GTEST_FAIL() +#endif + +// Generates a success with a generic message. +#define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded") + +// Define this macro to 1 to omit the definition of SUCCEED(), which +// is a generic name and clashes with some other libraries. +#if !GTEST_DONT_DEFINE_SUCCEED +# define SUCCEED() GTEST_SUCCEED() +#endif + +// Macros for testing exceptions. +// +// * {ASSERT|EXPECT}_THROW(statement, expected_exception): +// Tests that the statement throws the expected exception. +// * {ASSERT|EXPECT}_NO_THROW(statement): +// Tests that the statement doesn't throw any exception. +// * {ASSERT|EXPECT}_ANY_THROW(statement): +// Tests that the statement throws an exception. + +#define EXPECT_THROW(statement, expected_exception) \ + GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_) +#define EXPECT_NO_THROW(statement) \ + GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_) +#define EXPECT_ANY_THROW(statement) \ + GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_) +#define ASSERT_THROW(statement, expected_exception) \ + GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_) +#define ASSERT_NO_THROW(statement) \ + GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_) +#define ASSERT_ANY_THROW(statement) \ + GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_) + +// Boolean assertions. Condition can be either a Boolean expression or an +// AssertionResult. For more information on how to use AssertionResult with +// these macros see comments on that class. +#define EXPECT_TRUE(condition) \ + GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \ + GTEST_NONFATAL_FAILURE_) +#define EXPECT_FALSE(condition) \ + GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \ + GTEST_NONFATAL_FAILURE_) +#define ASSERT_TRUE(condition) \ + GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \ + GTEST_FATAL_FAILURE_) +#define ASSERT_FALSE(condition) \ + GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \ + GTEST_FATAL_FAILURE_) + +// Includes the auto-generated header that implements a family of +// generic predicate assertion macros. +// Copyright 2006, 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. + +// This file is AUTOMATICALLY GENERATED on 10/31/2011 by command +// 'gen_gtest_pred_impl.py 5'. DO NOT EDIT BY HAND! +// +// Implements a family of generic predicate assertion macros. + +#ifndef GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ +#define GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ + +// Makes sure this header is not included before gtest.h. +#ifndef GTEST_INCLUDE_GTEST_GTEST_H_ +# error Do not include gtest_pred_impl.h directly. Include gtest.h instead. +#endif // GTEST_INCLUDE_GTEST_GTEST_H_ + +// This header implements a family of generic predicate assertion +// macros: +// +// ASSERT_PRED_FORMAT1(pred_format, v1) +// ASSERT_PRED_FORMAT2(pred_format, v1, v2) +// ... +// +// where pred_format is a function or functor that takes n (in the +// case of ASSERT_PRED_FORMATn) values and their source expression +// text, and returns a testing::AssertionResult. See the definition +// of ASSERT_EQ in gtest.h for an example. +// +// If you don't care about formatting, you can use the more +// restrictive version: +// +// ASSERT_PRED1(pred, v1) +// ASSERT_PRED2(pred, v1, v2) +// ... +// +// where pred is an n-ary function or functor that returns bool, +// and the values v1, v2, ..., must support the << operator for +// streaming to std::ostream. +// +// We also define the EXPECT_* variations. +// +// For now we only support predicates whose arity is at most 5. +// Please email googletestframework@googlegroups.com if you need +// support for higher arities. + +// GTEST_ASSERT_ is the basic statement to which all of the assertions +// in this file reduce. Don't use this in your code. + +#define GTEST_ASSERT_(expression, on_failure) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (const ::testing::AssertionResult gtest_ar = (expression)) \ + ; \ + else \ + on_failure(gtest_ar.failure_message()) + + +// Helper function for implementing {EXPECT|ASSERT}_PRED1. Don't use +// this in your code. +template +AssertionResult AssertPred1Helper(const char* pred_text, + const char* e1, + Pred pred, + const T1& v1) { + if (pred(v1)) return AssertionSuccess(); + + return AssertionFailure() << pred_text << "(" + << e1 << ") evaluates to false, where" + << "\n" << e1 << " evaluates to " << v1; +} + +// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1. +// Don't use this in your code. +#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\ + GTEST_ASSERT_(pred_format(#v1, v1), \ + on_failure) + +// Internal macro for implementing {EXPECT|ASSERT}_PRED1. Don't use +// this in your code. +#define GTEST_PRED1_(pred, v1, on_failure)\ + GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \ + #v1, \ + pred, \ + v1), on_failure) + +// Unary predicate assertion macros. +#define EXPECT_PRED_FORMAT1(pred_format, v1) \ + GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_) +#define EXPECT_PRED1(pred, v1) \ + GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_) +#define ASSERT_PRED_FORMAT1(pred_format, v1) \ + GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_) +#define ASSERT_PRED1(pred, v1) \ + GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_) + + + +// Helper function for implementing {EXPECT|ASSERT}_PRED2. Don't use +// this in your code. +template +AssertionResult AssertPred2Helper(const char* pred_text, + const char* e1, + const char* e2, + Pred pred, + const T1& v1, + const T2& v2) { + if (pred(v1, v2)) return AssertionSuccess(); + + return AssertionFailure() << pred_text << "(" + << e1 << ", " + << e2 << ") evaluates to false, where" + << "\n" << e1 << " evaluates to " << v1 + << "\n" << e2 << " evaluates to " << v2; +} + +// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2. +// Don't use this in your code. +#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\ + GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), \ + on_failure) + +// Internal macro for implementing {EXPECT|ASSERT}_PRED2. Don't use +// this in your code. +#define GTEST_PRED2_(pred, v1, v2, on_failure)\ + GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, \ + #v1, \ + #v2, \ + pred, \ + v1, \ + v2), on_failure) + +// Binary predicate assertion macros. +#define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \ + GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_) +#define EXPECT_PRED2(pred, v1, v2) \ + GTEST_PRED2_(pred, v1, v2, GTEST_NONFATAL_FAILURE_) +#define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \ + GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_) +#define ASSERT_PRED2(pred, v1, v2) \ + GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_) + + + +// Helper function for implementing {EXPECT|ASSERT}_PRED3. Don't use +// this in your code. +template +AssertionResult AssertPred3Helper(const char* pred_text, + const char* e1, + const char* e2, + const char* e3, + Pred pred, + const T1& v1, + const T2& v2, + const T3& v3) { + if (pred(v1, v2, v3)) return AssertionSuccess(); + + return AssertionFailure() << pred_text << "(" + << e1 << ", " + << e2 << ", " + << e3 << ") evaluates to false, where" + << "\n" << e1 << " evaluates to " << v1 + << "\n" << e2 << " evaluates to " << v2 + << "\n" << e3 << " evaluates to " << v3; +} + +// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3. +// Don't use this in your code. +#define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\ + GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3), \ + on_failure) + +// Internal macro for implementing {EXPECT|ASSERT}_PRED3. Don't use +// this in your code. +#define GTEST_PRED3_(pred, v1, v2, v3, on_failure)\ + GTEST_ASSERT_(::testing::AssertPred3Helper(#pred, \ + #v1, \ + #v2, \ + #v3, \ + pred, \ + v1, \ + v2, \ + v3), on_failure) + +// Ternary predicate assertion macros. +#define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \ + GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE_) +#define EXPECT_PRED3(pred, v1, v2, v3) \ + GTEST_PRED3_(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE_) +#define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3) \ + GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE_) +#define ASSERT_PRED3(pred, v1, v2, v3) \ + GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_) + + + +// Helper function for implementing {EXPECT|ASSERT}_PRED4. Don't use +// this in your code. +template +AssertionResult AssertPred4Helper(const char* pred_text, + const char* e1, + const char* e2, + const char* e3, + const char* e4, + Pred pred, + const T1& v1, + const T2& v2, + const T3& v3, + const T4& v4) { + if (pred(v1, v2, v3, v4)) return AssertionSuccess(); + + return AssertionFailure() << pred_text << "(" + << e1 << ", " + << e2 << ", " + << e3 << ", " + << e4 << ") evaluates to false, where" + << "\n" << e1 << " evaluates to " << v1 + << "\n" << e2 << " evaluates to " << v2 + << "\n" << e3 << " evaluates to " << v3 + << "\n" << e4 << " evaluates to " << v4; +} + +// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4. +// Don't use this in your code. +#define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\ + GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4), \ + on_failure) + +// Internal macro for implementing {EXPECT|ASSERT}_PRED4. Don't use +// this in your code. +#define GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)\ + GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, \ + #v1, \ + #v2, \ + #v3, \ + #v4, \ + pred, \ + v1, \ + v2, \ + v3, \ + v4), on_failure) + +// 4-ary predicate assertion macros. +#define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \ + GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_) +#define EXPECT_PRED4(pred, v1, v2, v3, v4) \ + GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_) +#define ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \ + GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE_) +#define ASSERT_PRED4(pred, v1, v2, v3, v4) \ + GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_) + + + +// Helper function for implementing {EXPECT|ASSERT}_PRED5. Don't use +// this in your code. +template +AssertionResult AssertPred5Helper(const char* pred_text, + const char* e1, + const char* e2, + const char* e3, + const char* e4, + const char* e5, + Pred pred, + const T1& v1, + const T2& v2, + const T3& v3, + const T4& v4, + const T5& v5) { + if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess(); + + return AssertionFailure() << pred_text << "(" + << e1 << ", " + << e2 << ", " + << e3 << ", " + << e4 << ", " + << e5 << ") evaluates to false, where" + << "\n" << e1 << " evaluates to " << v1 + << "\n" << e2 << " evaluates to " << v2 + << "\n" << e3 << " evaluates to " << v3 + << "\n" << e4 << " evaluates to " << v4 + << "\n" << e5 << " evaluates to " << v5; +} + +// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5. +// Don't use this in your code. +#define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\ + GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5), \ + on_failure) + +// Internal macro for implementing {EXPECT|ASSERT}_PRED5. Don't use +// this in your code. +#define GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)\ + GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, \ + #v1, \ + #v2, \ + #v3, \ + #v4, \ + #v5, \ + pred, \ + v1, \ + v2, \ + v3, \ + v4, \ + v5), on_failure) + +// 5-ary predicate assertion macros. +#define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \ + GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_) +#define EXPECT_PRED5(pred, v1, v2, v3, v4, v5) \ + GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_) +#define ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \ + GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_) +#define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \ + GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_) + + + +#endif // GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ + +// Macros for testing equalities and inequalities. +// +// * {ASSERT|EXPECT}_EQ(expected, actual): Tests that expected == actual +// * {ASSERT|EXPECT}_NE(v1, v2): Tests that v1 != v2 +// * {ASSERT|EXPECT}_LT(v1, v2): Tests that v1 < v2 +// * {ASSERT|EXPECT}_LE(v1, v2): Tests that v1 <= v2 +// * {ASSERT|EXPECT}_GT(v1, v2): Tests that v1 > v2 +// * {ASSERT|EXPECT}_GE(v1, v2): Tests that v1 >= v2 +// +// When they are not, Google Test prints both the tested expressions and +// their actual values. The values must be compatible built-in types, +// or you will get a compiler error. By "compatible" we mean that the +// values can be compared by the respective operator. +// +// Note: +// +// 1. It is possible to make a user-defined type work with +// {ASSERT|EXPECT}_??(), but that requires overloading the +// comparison operators and is thus discouraged by the Google C++ +// Usage Guide. Therefore, you are advised to use the +// {ASSERT|EXPECT}_TRUE() macro to assert that two objects are +// equal. +// +// 2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on +// pointers (in particular, C strings). Therefore, if you use it +// with two C strings, you are testing how their locations in memory +// are related, not how their content is related. To compare two C +// strings by content, use {ASSERT|EXPECT}_STR*(). +// +// 3. {ASSERT|EXPECT}_EQ(expected, actual) is preferred to +// {ASSERT|EXPECT}_TRUE(expected == actual), as the former tells you +// what the actual value is when it fails, and similarly for the +// other comparisons. +// +// 4. Do not depend on the order in which {ASSERT|EXPECT}_??() +// evaluate their arguments, which is undefined. +// +// 5. These macros evaluate their arguments exactly once. +// +// Examples: +// +// EXPECT_NE(5, Foo()); +// EXPECT_EQ(NULL, a_pointer); +// ASSERT_LT(i, array_size); +// ASSERT_GT(records.size(), 0) << "There is no record left."; + +#define EXPECT_EQ(expected, actual) \ + EXPECT_PRED_FORMAT2(::testing::internal:: \ + EqHelper::Compare, \ + expected, actual) +#define EXPECT_NE(expected, actual) \ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, expected, actual) +#define EXPECT_LE(val1, val2) \ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2) +#define EXPECT_LT(val1, val2) \ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2) +#define EXPECT_GE(val1, val2) \ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2) +#define EXPECT_GT(val1, val2) \ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2) + +#define GTEST_ASSERT_EQ(expected, actual) \ + ASSERT_PRED_FORMAT2(::testing::internal:: \ + EqHelper::Compare, \ + expected, actual) +#define GTEST_ASSERT_NE(val1, val2) \ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2) +#define GTEST_ASSERT_LE(val1, val2) \ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2) +#define GTEST_ASSERT_LT(val1, val2) \ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2) +#define GTEST_ASSERT_GE(val1, val2) \ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2) +#define GTEST_ASSERT_GT(val1, val2) \ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2) + +// Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of +// ASSERT_XY(), which clashes with some users' own code. + +#if !GTEST_DONT_DEFINE_ASSERT_EQ +# define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2) +#endif + +#if !GTEST_DONT_DEFINE_ASSERT_NE +# define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2) +#endif + +#if !GTEST_DONT_DEFINE_ASSERT_LE +# define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2) +#endif + +#if !GTEST_DONT_DEFINE_ASSERT_LT +# define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2) +#endif + +#if !GTEST_DONT_DEFINE_ASSERT_GE +# define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2) +#endif + +#if !GTEST_DONT_DEFINE_ASSERT_GT +# define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2) +#endif + +// C-string Comparisons. All tests treat NULL and any non-NULL string +// as different. Two NULLs are equal. +// +// * {ASSERT|EXPECT}_STREQ(s1, s2): Tests that s1 == s2 +// * {ASSERT|EXPECT}_STRNE(s1, s2): Tests that s1 != s2 +// * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case +// * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case +// +// For wide or narrow string objects, you can use the +// {ASSERT|EXPECT}_??() macros. +// +// Don't depend on the order in which the arguments are evaluated, +// which is undefined. +// +// These macros evaluate their arguments exactly once. + +#define EXPECT_STREQ(expected, actual) \ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual) +#define EXPECT_STRNE(s1, s2) \ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2) +#define EXPECT_STRCASEEQ(expected, actual) \ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual) +#define EXPECT_STRCASENE(s1, s2)\ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2) + +#define ASSERT_STREQ(expected, actual) \ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual) +#define ASSERT_STRNE(s1, s2) \ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2) +#define ASSERT_STRCASEEQ(expected, actual) \ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual) +#define ASSERT_STRCASENE(s1, s2)\ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2) + +// Macros for comparing floating-point numbers. +// +// * {ASSERT|EXPECT}_FLOAT_EQ(expected, actual): +// Tests that two float values are almost equal. +// * {ASSERT|EXPECT}_DOUBLE_EQ(expected, actual): +// Tests that two double values are almost equal. +// * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error): +// Tests that v1 and v2 are within the given distance to each other. +// +// Google Test uses ULP-based comparison to automatically pick a default +// error bound that is appropriate for the operands. See the +// FloatingPoint template class in gtest-internal.h if you are +// interested in the implementation details. + +#define EXPECT_FLOAT_EQ(expected, actual)\ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ, \ + expected, actual) + +#define EXPECT_DOUBLE_EQ(expected, actual)\ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ, \ + expected, actual) + +#define ASSERT_FLOAT_EQ(expected, actual)\ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ, \ + expected, actual) + +#define ASSERT_DOUBLE_EQ(expected, actual)\ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ, \ + expected, actual) + +#define EXPECT_NEAR(val1, val2, abs_error)\ + EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \ + val1, val2, abs_error) + +#define ASSERT_NEAR(val1, val2, abs_error)\ + ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \ + val1, val2, abs_error) + +// These predicate format functions work on floating-point values, and +// can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g. +// +// EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0); + +// Asserts that val1 is less than, or almost equal to, val2. Fails +// otherwise. In particular, it fails if either val1 or val2 is NaN. +GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2, + float val1, float val2); +GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2, + double val1, double val2); + + +#if GTEST_OS_WINDOWS + +// Macros that test for HRESULT failure and success, these are only useful +// on Windows, and rely on Windows SDK macros and APIs to compile. +// +// * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr) +// +// When expr unexpectedly fails or succeeds, Google Test prints the +// expected result and the actual result with both a human-readable +// string representation of the error, if available, as well as the +// hex result code. +# define EXPECT_HRESULT_SUCCEEDED(expr) \ + EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr)) + +# define ASSERT_HRESULT_SUCCEEDED(expr) \ + ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr)) + +# define EXPECT_HRESULT_FAILED(expr) \ + EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr)) + +# define ASSERT_HRESULT_FAILED(expr) \ + ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr)) + +#endif // GTEST_OS_WINDOWS + +// Macros that execute statement and check that it doesn't generate new fatal +// failures in the current thread. +// +// * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement); +// +// Examples: +// +// EXPECT_NO_FATAL_FAILURE(Process()); +// ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed"; +// +#define ASSERT_NO_FATAL_FAILURE(statement) \ + GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_) +#define EXPECT_NO_FATAL_FAILURE(statement) \ + GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_) + +// Causes a trace (including the source file path, the current line +// number, and the given message) to be included in every test failure +// message generated by code in the current scope. The effect is +// undone when the control leaves the current scope. +// +// The message argument can be anything streamable to std::ostream. +// +// In the implementation, we include the current line number as part +// of the dummy variable name, thus allowing multiple SCOPED_TRACE()s +// to appear in the same block - as long as they are on different +// lines. +#define SCOPED_TRACE(message) \ + ::testing::internal::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\ + __FILE__, __LINE__, ::testing::Message() << (message)) + +// Compile-time assertion for type equality. +// StaticAssertTypeEq() compiles iff type1 and type2 are +// the same type. The value it returns is not interesting. +// +// Instead of making StaticAssertTypeEq a class template, we make it a +// function template that invokes a helper class template. This +// prevents a user from misusing StaticAssertTypeEq by +// defining objects of that type. +// +// CAVEAT: +// +// When used inside a method of a class template, +// StaticAssertTypeEq() is effective ONLY IF the method is +// instantiated. For example, given: +// +// template class Foo { +// public: +// void Bar() { testing::StaticAssertTypeEq(); } +// }; +// +// the code: +// +// void Test1() { Foo foo; } +// +// will NOT generate a compiler error, as Foo::Bar() is never +// actually instantiated. Instead, you need: +// +// void Test2() { Foo foo; foo.Bar(); } +// +// to cause a compiler error. +template +bool StaticAssertTypeEq() { + (void)internal::StaticAssertTypeEqHelper(); + return true; +} + +// Defines a test. +// +// The first parameter is the name of the test case, and the second +// parameter is the name of the test within the test case. +// +// The convention is to end the test case name with "Test". For +// example, a test case for the Foo class can be named FooTest. +// +// The user should put his test code between braces after using this +// macro. Example: +// +// TEST(FooTest, InitializesCorrectly) { +// Foo foo; +// EXPECT_TRUE(foo.StatusIsOK()); +// } + +// Note that we call GetTestTypeId() instead of GetTypeId< +// ::testing::Test>() here to get the type ID of testing::Test. This +// is to work around a suspected linker bug when using Google Test as +// a framework on Mac OS X. The bug causes GetTypeId< +// ::testing::Test>() to return different values depending on whether +// the call is from the Google Test framework itself or from user test +// code. GetTestTypeId() is guaranteed to always return the same +// value, as it always calls GetTypeId<>() from the Google Test +// framework. +#define GTEST_TEST(test_case_name, test_name)\ + GTEST_TEST_(test_case_name, test_name, \ + ::testing::Test, ::testing::internal::GetTestTypeId()) + +// Define this macro to 1 to omit the definition of TEST(), which +// is a generic name and clashes with some other libraries. +#if !GTEST_DONT_DEFINE_TEST +# define TEST(test_case_name, test_name) GTEST_TEST(test_case_name, test_name) +#endif + +// Defines a test that uses a test fixture. +// +// The first parameter is the name of the test fixture class, which +// also doubles as the test case name. The second parameter is the +// name of the test within the test case. +// +// A test fixture class must be declared earlier. The user should put +// his test code between braces after using this macro. Example: +// +// class FooTest : public testing::Test { +// protected: +// virtual void SetUp() { b_.AddElement(3); } +// +// Foo a_; +// Foo b_; +// }; +// +// TEST_F(FooTest, InitializesCorrectly) { +// EXPECT_TRUE(a_.StatusIsOK()); +// } +// +// TEST_F(FooTest, ReturnsElementCountCorrectly) { +// EXPECT_EQ(0, a_.size()); +// EXPECT_EQ(1, b_.size()); +// } + +#define TEST_F(test_fixture, test_name)\ + GTEST_TEST_(test_fixture, test_name, test_fixture, \ + ::testing::internal::GetTypeId()) + +} // namespace testing + +// Use this function in main() to run all tests. It returns 0 if all +// tests are successful, or 1 otherwise. +// +// RUN_ALL_TESTS() should be invoked after the command line has been +// parsed by InitGoogleTest(). +// +// This function was formerly a macro; thus, it is in the global +// namespace and has an all-caps name. +int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_; + +inline int RUN_ALL_TESTS() { + return ::testing::UnitTest::GetInstance()->Run(); +} + +#endif // GTEST_INCLUDE_GTEST_GTEST_H_ diff --git a/SaryninS/lab 1/include/TLink.h.txt b/SaryninS/lab 1/include/TLink.h.txt new file mode 100644 index 000000000..e69de29bb diff --git a/SaryninS/lab 1/sample/main.cpp.txt b/SaryninS/lab 1/sample/main.cpp.txt new file mode 100644 index 000000000..e69de29bb diff --git a/SaryninS/lab 1/src/TLink.cpp.txt b/SaryninS/lab 1/src/TLink.cpp.txt new file mode 100644 index 000000000..e69de29bb diff --git a/SaryninS/lab 1/test/test_main.cpp b/SaryninS/lab 1/test/test_main.cpp new file mode 100644 index 000000000..c8647a653 --- /dev/null +++ b/SaryninS/lab 1/test/test_main.cpp @@ -0,0 +1,7 @@ +#include + +int main(int argc, char **argv) +{ + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} From 7d5ec2c01d0365eb7003f5ef73b3153b6bc4a84a Mon Sep 17 00:00:00 2001 From: AngryHedgehogg Date: Sun, 18 Mar 2018 19:11:44 +0300 Subject: [PATCH 02/10] lib --- SaryninS/lab 1/gtest/gtest.h | 2 + SaryninS/lab 1/include/List.h | 0 SaryninS/lab 1/include/monom.h | 0 SaryninS/lab 1/include/node.h | 0 SaryninS/lab 1/include/polinom.h | 0 SaryninS/lab 1/sample/main.cpp | 6 + .../ipch/AutoPCH/bdb1795fab4df8ee/MAIN.ipch | Bin 0 -> 327680 bytes .../AutoPCH/e3ad92ca303ea824/GTEST-ALL.ipch | Bin 0 -> 61341696 bytes SaryninS/lab 1/sln/polinom/Project1.sln | 61 +++++++ .../sln/polinom/Project1/Project1.vcxproj | 162 +++++++++++++++++ .../polinom/Project1/Project1.vcxproj.filters | 23 +++ .../polinom/polinom_lib/polinom_lib.vcxproj | 168 ++++++++++++++++++ .../polinom_lib/polinom_lib.vcxproj.filters | 41 +++++ .../polinom_sample/polinom_sample.vcxproj | 157 ++++++++++++++++ .../polinom_sample.vcxproj.filters | 14 ++ .../polinom_tests/polinom_tests.vcxproj | 157 ++++++++++++++++ .../polinom_tests.vcxproj.filters | 14 ++ SaryninS/lab 1/src/List.cpp | 0 SaryninS/lab 1/src/monom.cpp | 0 SaryninS/lab 1/src/node.cpp | 0 SaryninS/lab 1/src/polinom.cpp | 0 21 files changed, 805 insertions(+) create mode 100644 SaryninS/lab 1/include/List.h create mode 100644 SaryninS/lab 1/include/monom.h create mode 100644 SaryninS/lab 1/include/node.h create mode 100644 SaryninS/lab 1/include/polinom.h create mode 100644 SaryninS/lab 1/sample/main.cpp create mode 100644 SaryninS/lab 1/sln/polinom/.vs/Project1/v15/ipch/AutoPCH/bdb1795fab4df8ee/MAIN.ipch create mode 100644 SaryninS/lab 1/sln/polinom/.vs/Project1/v15/ipch/AutoPCH/e3ad92ca303ea824/GTEST-ALL.ipch create mode 100644 SaryninS/lab 1/sln/polinom/Project1.sln create mode 100644 SaryninS/lab 1/sln/polinom/Project1/Project1.vcxproj create mode 100644 SaryninS/lab 1/sln/polinom/Project1/Project1.vcxproj.filters create mode 100644 SaryninS/lab 1/sln/polinom/polinom_lib/polinom_lib.vcxproj create mode 100644 SaryninS/lab 1/sln/polinom/polinom_lib/polinom_lib.vcxproj.filters create mode 100644 SaryninS/lab 1/sln/polinom/polinom_sample/polinom_sample.vcxproj create mode 100644 SaryninS/lab 1/sln/polinom/polinom_sample/polinom_sample.vcxproj.filters create mode 100644 SaryninS/lab 1/sln/polinom/polinom_tests/polinom_tests.vcxproj create mode 100644 SaryninS/lab 1/sln/polinom/polinom_tests/polinom_tests.vcxproj.filters create mode 100644 SaryninS/lab 1/src/List.cpp create mode 100644 SaryninS/lab 1/src/monom.cpp create mode 100644 SaryninS/lab 1/src/node.cpp create mode 100644 SaryninS/lab 1/src/polinom.cpp diff --git a/SaryninS/lab 1/gtest/gtest.h b/SaryninS/lab 1/gtest/gtest.h index 6e7cfc2be..f0c26ee80 100644 --- a/SaryninS/lab 1/gtest/gtest.h +++ b/SaryninS/lab 1/gtest/gtest.h @@ -48,6 +48,8 @@ // registration from Barthelemy Dagenais' (barthelemy@prologique.com) // easyUnit framework. +#define _SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING //////////////////// ???????? + #define _VARIADIC_MAX 10 #ifndef GTEST_INCLUDE_GTEST_GTEST_H_ diff --git a/SaryninS/lab 1/include/List.h b/SaryninS/lab 1/include/List.h new file mode 100644 index 000000000..e69de29bb diff --git a/SaryninS/lab 1/include/monom.h b/SaryninS/lab 1/include/monom.h new file mode 100644 index 000000000..e69de29bb diff --git a/SaryninS/lab 1/include/node.h b/SaryninS/lab 1/include/node.h new file mode 100644 index 000000000..e69de29bb diff --git a/SaryninS/lab 1/include/polinom.h b/SaryninS/lab 1/include/polinom.h new file mode 100644 index 000000000..e69de29bb diff --git a/SaryninS/lab 1/sample/main.cpp b/SaryninS/lab 1/sample/main.cpp new file mode 100644 index 000000000..86e2278b3 --- /dev/null +++ b/SaryninS/lab 1/sample/main.cpp @@ -0,0 +1,6 @@ +#include "List.h" + +int main() +{ + return 0; +} diff --git a/SaryninS/lab 1/sln/polinom/.vs/Project1/v15/ipch/AutoPCH/bdb1795fab4df8ee/MAIN.ipch b/SaryninS/lab 1/sln/polinom/.vs/Project1/v15/ipch/AutoPCH/bdb1795fab4df8ee/MAIN.ipch new file mode 100644 index 0000000000000000000000000000000000000000..a9c2e38c037c0ef67878a5f11f098fbfd76986c8 GIT binary patch literal 327680 zcmeEv4}4TtnfByQ+q9)EZE2gfRHyA!Q%fO%6hfsnl!PWWKqR4^YIG8kfr-sOlN+Fw zRn$@QDXaL&uF<8+>Zq|xHM_Dd?qbDnu^W|DRIH=Y6<5|xS60!Eii-Ao-h1D3@45G$ znaL%g1UUD{<(~7t?|Gl+Jm=iMb2C$0bANc*yk&RX5#A8*AL#7u30KaoSP(9&iMNNb zonKzDC|pr>cV)%hcg?^3l2Ab?6k3gS+1)K`2GF3TV*Y~4yIN}E1CJQJeJu;-&u{7O zn}26te_OlJ*&c6cYU_Wrr?aQ2rK@dixT0mCtEZ)}x2vL!u3w&{W9RgGrW6^--nY+Su`S#$le+LorJs~=ujzp|;NVd;Iy+O%{Vk?@K#cHF?wJV$ISFLP<#agHbi?GtxUZ`?6R-dtoLN35svAAMBmCc31mSQa^ z#D8XpZ8q^QN7clCuy*x5zLsW4sR&uVrlBDw;^yB~wV=YxMgI|u8GIQEX1@E@)Hl@J zQ%+8Eu_G=*HTF>b$^~wcX6qT`TM?^|RxP||VY#BQmEH`9EpNQXo#KA9CK!963bFSY zovzo`+#g%EYDHsxLoH1fYq7ark9urPQ*ErKc3DGHW9_o0*z#4YV@*pN?s511Mg$gI ziT~!#ZL$7!_Oy2mcEqiOjUWh`L?wiuo)ZVv-dSWehvx`v&)0IuD8ft~pNoso6 ztgK(Qsz%{0L4&N$OU=ZMjcZndRgEh(bziMrE~dqla7D8#li72coUxjQ2EWIeg&5IT zf`2sN|Ea*k|d~!uN_?9(!wsQxjAsHFyS!K*x$RpzpXpG zyt6Al5H8zPwea?q6`k$xI>XICeVnk^4D zWrtdt9qOUZo{rv)1K|fc4IG`zTk5S{2F1DMb1N3kU%Ys3dCOpXzkw9iLIZA!$A@6m zh)pbOw@7JDA~WYQn6k`*3FRC}wDre3{CV%2WZsRPJt_%kzZHrNy1VlPTm>(}{Oaml z+k(Bs)nyaA6{ajwPI`x$UZ7`E<*DC`vuYb)FQy#6Jy<5(q z*{7y!FJD>Pygb@e^FT}G+=X*1S{l?TzlCfCbm1`dSD8p^E_BRWfVH3>|4jkR+zkVC zrh8+&-Kc2UP;pmFXJ31wW$B>N+qkT*Wo^gWibad>TGzI=vSVFUJZ@5;|A5X*{#Cm#r`r~a~v9)aj@mPCT+rU7408VS6_-|sRt!tqRQMv}AOO{(2ItProiCfGl z5xE?WWp~drFWTps7wz--qJ17N+ULm^?eoM%`#kfaeIB1|=UHh(vCLK(UDPO-S#K^%9($CMTMIQ1jf72ar-uT?(}RX)ah5AEk$E(c znCT`1aaQqG*`^!!bD7V%sQ=mCr?Z{^xxByVzG(%t0$KsBfL1^&pcT*xXa!UX=xcbD zDrc{a9{h^+?Cr(rW3K1>>C;wco_-4G`9A%|L^IL~Xa%$aS^=$qRzNGD6_}g?*2_+l z%P}2W>udMvI4YWxRzNGD70?Q31PWJgBN_sJ@#+n-Ge==pv&jh5!B70?Q31+)TM0j+>mKr1j21$o77_e)syt8Go(wi=(qf(F$k&QZzY4#y zRa=le91q?P(rfq~!P`wo9W*DcKu`sWii&C`e0a+Ct8(;vw<8Z(zdmR(ia@M`h**{0# z;FLwz5-ml^q1P8B(+~T7BIaD&&c5;d>hHNYhTc9MpPhe9(?6ZM<9*+i`SH9Q&)2%~ zHB0x*7pG4D^HodT@B9ix|2x<`Gxi3H&(AsbLZO}nQr|p`?H>d z(``)7H$Ksy`{!WhbAB7?((v+N$Jp~tOWoh;r@+_*t_u>EPwl)e`=xsSnSSa_FGk~+ zoccJVpM7yOpEC!~>yAteD|5gdH}YF|eR`>{*-QroGM_#>=SWNKsqeefLHDzTLt1gY zcD8VzEYI;A*PmsXso!smk*Uu)Sq)CLec7+ijlOJ|b^4AoiQ?0j`&7q`+9hUAKVFF| zrXQ!tXsl{`0M~jdyS7ce0-4dNIX-1RHu*gJ_&uJf?`5!zjn|%;`DZ+yT|?vVvitJ& zE^_ag=}$gh)75Y6J9Vv3SD(s`pB_$`bLd(tm-b~RPmg}NFthoL9TVfSdD-dPZ?{&S zzTDaRJss?+Th;weR;%sVI7k0yVq=)Cy|%wN3Y0y6?vB%VmV1G+U!8q@9=prh|4x<% z+YeuyS)@_40&WGux9fT8R%G(E^bcR$Tf2c=9zd<&slk#%FdI&=gdsQcS7WG zIG@VVAFKDxvq1ynZ>J~svOi_#Ro3hr^S0gLl+Omeb8#Gh5w4-5Kgq6ZE^gDsXN)=g zjonUps`+KUe(JfS-#_)Xlj%qFXJ-a?GMt07P3X@@g2<&~^C*z{RIvS}>y|Tru4%;g zOXlfTVE5?Dg5@mx-(b20CZrpLjK5cFoZ;{A(h>zzV9pdj2NmeXS^9Ung8$jPEz9yO z`b_t!^5$U2(=*LizOg-<{Lvo;-#@0Jf5x6OgF6-6b&m5(ffMK9v3fd< zaKkCQ2QX3o$6j@IU+2#X_}pirx}1)2r=f_R6B<@WxZ?hpfe^lrv9FA01AGKeaKkygPEL`OejL&3S&iB9rAl@m$p-SHCh( zzxew_<}|*mkjV142E$qGxwM(6&p7zvYdBGE=Sy7XpHKf7?0?CbId_RM%uM3%;YMD> z&-xNG&a6&CFTFiK6fpk%^zZxUhmyLNS^=%V*{Xms1>coGZw^GXlP| z=kDFvQ7bJCHU`Eid`^9KC~lk_RMTv=0-@08HNlQ~nXgQI zA1QALmYc>S^NQeY&c|^yK9hYMqSD`K$=VEMu~W>R96mY6sg^VUFFW5;%{i6rb}O#G zwp@39&Be@@tuY!eIKTQmmGfw#xvC?lU*pWbPVaqgqFU*=>8n8E&eK1Sr*H2yv+1lr z^x3oH__tqw|IKusMrQ@L@iX|H)ag8b19Mggcpi~VuReX}?2$iD?3kO#b&oOk^zl27 zhWU(jHIwCUsLvQ74XhP7%N0nU;oq4WzepdG&(st${>eF~mc8JV&lDfR&G0*1%~Slh zIGHD=NB_>Gwo{F5Own(gU}x3&bN!ad z@t%2l8vkaR7^@d^YfSKc z=S$=rIX*q+iJz%sF+T3+m{HiA7E@oUyIvm?C#q`ZAN}Jsk+!Wb&8>0zEdO1diD-~5 zCUHq_ZL+n~_FxKRPUG(#1!HnwPV;v=WzN8F6Q3KSo4XgrIqA&~hVDZzbubRvGsX%55e&gCWaBBBW zQ=xeJ88`NLmhT8CT{AWNrtu9o-cZunNncn*TLpZ*>8izpGvWeq)-`>Gelt|&AeTpersGuFXWo;2yrvR|a+N(aHCRS~-~6iL-_MLr@v%0eKVz8c z>EX(^y<%$SiYuwEOo;;JcTKOciB90}^D{ZV=UgR$Gpys?J4m~%a$ma+T-Uq-^1s^%;uYQ)zosyhBFa+;tYQG zM&c~~Ub@kMzc)3JvCuJRUV-w((`Vm2^J<*G42(1M{b=Wc;=5m6l$`1LPJoR5Ebg=n zt?{}1*LbG|_%tRpzIb-_DLQ_3@;;42IpNf0f6T32`cQ8Fgn_0waOC9lP)~Mk=t%t0KF28sRq<`idd&i3>J`YEJ>9jkYY)A53H=Isv zo!hOzmL(IPAMTcus~P;;r<2Q)yY=`KKR?ce7M-Toy16)K^BJf3-7(qnY5Vk7z?gz} zD$9O1b?1+f%+%$Y{_1OnT7iiv5Pij&IbRdIkzbwr`(*li?mo6oAw)L5fO+~YSjS*I>bWO-4tVCvGH^_iLnoOzhqQIOnvhMyy~&MHin;9b}~;R1UV zBGo)=lUywg*cKl4J0kD+-e783oD88<7v3wjgc{wo+_2 zqrKoZ2FwQ7W?Wj3tb@JuI$$B!;mZn=qo_BcZ8>m;ux^6A1UwD!8U@w?;tA|Z!bR>a z$Tb`BBd{Ms&I9lXoDg_Lu!c8Vw(vU(lXK#Qrayu5Cag5STc3T{ZbF5Z&M4w~N$AAO zt(Z+0S*F&Hg+h^y><$&!yT|TiVX_eB7qF1ma?pIS@C2@Cskd4It$mKr5gX&mKr5gX&m zKr5gX&mKr0X`4HYEQFVIiY(@(<}@K42CKN(Ly8-Eqnf|5|^0&FRkepcRVhbcrq zQZIggzTgt8PWIv~cFHH>3pu_V`7eZ>Fs{bh3S9gPZG)YD@!o46ft~zb`##u_(zMUQ zwuJw?Z;uC!S-vhjj+9>pdfh}>csUrtlMCxeuiPcob9D#$4d4p*soC7 z8)2UbJN5T^S~-6LcIqd!osBhgvDM!#uoG{ueHeD)?X{1>PQ1PLG1!T>*M0kvetwq=C{$s5`JQpsKoJN1Y1glR>mscjT?%1ic} z$&UV#y$^QEOZHpHj{IaFf}Qe`{Z_247$maqgguNc*&|rPY~KSr<)xV0unqx?cpikE z@=`o4d(bJ0q49X(1wybE8q=`39|(&zf1R48N0leWn}_C71IKg~6(nh;938N2Mwzg; zV!Ivd4)*oLH^lp4Z|myn-5Bq{c4OP41AdM)uMN&UhPJfA6dGci*x%%SLFUjf`ze+d zFK3$PyYj?Pp8Z*3C?74vFU>KD;({ctWIx8XVg!1zDeuWFd8sWeG!JJM&@swcL>_@n z$A}2W90e||6kW--A_X?-Rmc9)3$R~cr8ZHv(ea4Ji}n|>5Ke;q!sg{d`}HP{=|fIh zDRw*CR9q-;Dob8!OABeWn`6e1lUA~i<;Y8YIGiUh9T$&L49_RZDf&cZS_nH-s2&4y z(L&=t3o$2|7umddXe`SR(~u*Eu$CYul_Q4oG$JN(p``(;J}lC-12N<~fw+>3tkqx} z9Uo{JlIq0QOhj8Oq|FZYn+E*n?GqjMNAtwcJ~oD!lQ}e|W5*HBGXk!(!W25eHsb5W zro1IZxyOZK!ipGgKdTUPD2JZK$kU+6BOh-_^A^NJN^tDMx|`Q7*fyhl0Xnb^+hMFb zvF^f(CZTn0T?27!js8K}g!M_WE=V@=ItJSul!@;WY-_OAVWoUMZARw?ux#(`4t2Nnw5?}yY0jhK zMq`^{e-e3)V%>vvMsZwRcLE4A6m zZB*kxIK%K~(3ceAX{9#1aNXtORCqPzL)F7s~PnJlD`A> zBU~qL2I?oJdJ^@S7g`!peiM`H)CXEBrMg!OIxp10zaR5;47q5fHZ3A28hG1~#$D_` zNqo4?X10m>Yc`~0SZFM_vfnh|KW|>rFU2vppeh})?4 zEy5XxzZ`8ch^Lj>oXCMw41Y;UVRAk1(EQkhm@;rX#w+C-;@m2J)Ml9d;hDIY)4=# z$Chxbv8};chn4bmbajQ|o8qB?c>jjZ_IRij_C1_~_U%5@$GA?qZb3cGb;8?*`Z(9A zpF2@M!F8HPqo|i$?Cb~oP@gT;529Wv)sLWF$92kg9Q78d9zvfsah>wdM14rAQ=fNm zo%qwTOR9Uvg2rn<{OKImsC0fxa}LT!3-w*zH|g2HF~k@+X73;lSShaL607fp0QO?j zwL~fW!+e~lcvVa}V!}91ke?QB49&|r#xVmFF?4;@nkRafPUgu&e75I_ zA>DW7i6K7w5VIu*A38o9KujI><5^eZ+{f!-&MoG^F|N~`@#;t85V{mOus=r8ehg~@ zYbk8xGIc?Hj#M8)y_)NkZy5DvsXl^wLWX-wC$RO zYfh|(q&BlrAD8NLP(R6a>cbM$XU=f?)PQ<~>x9>WdL`G16Jaz+@i2v2qg@ zuf}}diMF&-o2^m~ZyTCVJJ^2+@w8H#U2Ibw=V*S7!QX=8BE`}|dFlS1wzN>*BZ%3A zbHJQytd;D?IWOtqFN8R2UkYU<@nc@83G2lbT~ijkk) z(Dl|~#O%g#q2xMirO*?w(Ux*}^OD{rmqSa>vBVOCT3OEsW+SE&`dY%}-H~H{la^(OprJ?c=jiGtVq)xh#A2+plB}M ze$n;kF2q!N=DD1Q`o0e_oB5bXiBx&gh#{X?yfKvL7-E`v+$hc)L&uupnTW|TUUUvB zMNB47%p8izgH?@~nK}ASW6?}8IgTf^Pj?_@R}L)tY-1B*mRz5GEC_1{Vh&*3qc>VB zOrc${(N=X1B2D+gUy8h2(dGcw9as->8=5D(P(Lcw_o9A6s#BX8SGtcIv!%Lsj7a}7 z_)pS#Z#JH1V4aC|iPR>HdIQ(#98NKfwv8fT^jyjj-_~S4COtEm{g8^pFaPbaTWT6 zn5vtsm2#EAMq5>%Nb73&t8T!x7TVBCvCX25f-mjU9q_lH%}&JAN^LgfXhS$d@Td5B z2E}{(Nc-jv#LU2X^8|91yu?~ZMP6!zWuH{{<{)l|;6DH@m!LhZ)Mh+K8{&2X{zJg* zLp-h2X2#XLU!bhQnGOGv9LGKyvvS1Df=-l=7H=MksYcA<9CM1UTN)A5nq%Ll`?6NV z9F>ltG~T6f5GF0fST`ev%F&l%|Hn$@t!yK|mmeK_b`W-sc}L?mikRa$&Rulu*^ii- z9M38!<`80LGA~qpd`PdOh#{X?yqqad1~Ew-=c>cjO0mVWct1b`Y9n7q)4Z7l|1pe} zfi|>Kn=;V`WiJjL8>`^2!LfS;@w8H#Ms7n~X_*tpvHND+gDfvH{bL)g?e;AepV|FR ze`c+7%G7pr&|N1REk`+5_?>FM6?J<4-`3$^w*IMWGhH_y`TCnSlRkRU3TOqi0$KsB zfL1^&Fx?a=qKj!Pao)DP!nroLJomKr5gXcrg?heuwp0^U1e6pEmKr5gX&mKr5gX&iV)jm zus`xq{MI>_gW%WMnViBL#-F>mxsdWY9)Bsrm?^{wu0inY{V79BfKR_~-@P<_J>^w| z*d~Mhk&mJOTn>W&fSt)HGyxto{wWT!Y}R^rsAM27WQ@ zU+ilwq`Zm{+hnjm^0(+emxJK1vNJh_t&IPhkF*w2UdQ7vWf(JsIKedtexpBSXb0>6 zl1GmGCFNCw*d~Mhk&mPQTn>W&8atCy*adt#{`K5i@j1%tc>JXdW2O)%xCX&r?N1rn z3;ZJ3V~>=CD6b;KHW}=Xd;!GF-7 zGIX5vKYsUn3MsE5#5Ni1k9-pS=W-DIhwMyJ;aWcbJbv#{$}4$%#SCMn5GS|>!H@bf zhC;J|PsiVx|8>P~%Bu*mO$PfTpDIWSu0il0wlg_}2=HnDpSk0PuToye<1b|xKZQ8K zH3bD5on0TSqr8sCU&=6M3UPvK z5d7EsQ-+!u|2K&fb(B{TVw(*1M@G z!H@YlihFlGvI zf@=``Hh;>{cHqYk>v;U7 z3}dDcC%6W|Z}+DR?P2|&TmR#4P+modZ8F#&`8)KV%R%ttb|$AV#`vH9pSe#^UdQ7v zWf(JsIKedt{;T~dLuugC@&CRTu3JcX6(P3CV1Hy6`p@Mc_^-1wIfZfH)BHPl(f1yp zypG3T$}naMae`|Q{0@K0&`IFa{{N;o#J)&*6(P3CV1MLE^q}3qm`YFf zit(TO*%$wX@;V-WDZ`j4#0jpG#cyEzBZXD}KzaSBj>TYqLpIpH6>{@+v}XlfnMT-=qIr4uU^s zXL1UAflufEyKcSo6O`BS_)8haOd(Ei4TAq3f6CAS;1|Qb;n8~vDX${LHW}=X`~&*W z<;mh720nc~+Tdr~GnCf`Qxr0cnL?c48U+8nik!!RPxJr5FF*baP^B z{{Q*6z0Xo!8%$BiFlGvIf@=``w<&T)dHg@J{Qo8?uOh@Y8SIaI0sZIlWbqTgr}N)| zeSiHy%4>ru3K_;sAx>}&g1=djb2ISi`19K8Tb`u6iV)jmus`xo=s%Yyi@%Ng|JFrI zzC(F!FhwE5m?^{wu0inMuE?3<{{P^}i62s4MTl)O*dN)0{&RV<_~+hnjmvKRg5@?`O&z`qO#w}0yS7bvd{ zrYK|>Gle+8H3!T&#soI8L|^RH`O*Xt>-BE&Ws?2kN!{&P79{&qW)Qy2w4&A-}5Rvf3i zj>lihFlGvIg6m}Q_W_^w|7RZlWCi8*qdFFY{gE%D|6C4&pKwyyr9-U$KfUqCS5scw zp(tb+Gle+8b+Y*5z`qh$&wY2Gi1I36ZIi+N$UgL+%ag?~zQLORYhH8oM#^i0DGC|J zOd(Ei4T3+W$XN<}I{q|2zVw@vR}o^H4E9I9g8p+k2>#dXOirO3_;mkuGle+8H3|2N-@{v)q~qHW4BW(skFYY_Yo*qNNd zPVWEKFQNZ=@D27yzKZ^Hd9wJU-2dM{e^Z9?I?Vi~3}dDcC%6W|f83ukw2%9L$-wg; zp}dL^+hnjm@^nE`aGfmvLGJ%E8T21{Z7@Y4!}ux039do#KdQ)ig!}*B)c-vA2Kyub zhW>MTviQdZ{x4tl7RsxjXqz&OnL?c48U+7ib|$HCqjmi68+zL(D6i!46%F=B#?XH* zPZobB@ag<_{kP`7h4T79B}0ZWQ-~8>gW&I!a*1M?`~UIvfB6Z@E9|PR!T!kC(0?vZ z7QdYF?{CEOf8gW&(INF;5mfnSXJ(5LYHKM%ga{>azSe=biJzmdoP zi90TS3+0ul`HC6FOd(Ei4TAp>U&c_V75H@j^N}^rUPO5nA-2h2f8-nJKbM2xf6&h4 z6b#_g_0PZup85#obv*u3hA~r!6I>^Yp9DVLe}3r=UwE4G`cWN=!T!hr^q%>|_1^?&|L6D6ix3moki*LY&|l1pjaRDMN?2|9k4*^OK`@=l+gMgZV|iiT-mr z2>uQQ{!!r5^OrY1U3C-XRfO243}dDcM;eeL2>vJROitk>@ag`4-veELMR^^MzhtmK z@-6hA%R%rz?oSz-Iorbj^6qaxPI(m}wkgAyDZ~k`LGb6$k574)2;<*T*t(qZdfcw6 z!T!iW^qrO3(!-^FlGvIf@=_b)#qPzz^CKyHDCY3k0`GP z(p5FsANe-=&*dQa|JRkxsziZL*FP_-Klpaas|c}88OAL6F8V(O_{HBTNY21|Io9j2 zUXS%wthZq;$2uSDy;!TUz8Y%-)`ze@j5UGvjaVPUx*6*`u)Y)PUt=A{`UKWpSU-pL z@3DRX>mICM!TPUQpT;_d^#ImyV*MW0b-n%Jcw2iSRMa0|7jExr8yK*P14jQ~yAdkd z(AG5=7Y?f;T=Aa4Zs9S@!qM4d#QWE^wcG6+g9stCp7_R4QD0lX(b?7&mf&TR6wh2j zMRvAO5$K1C2-{8+qQ5K%g%TL!Yq0(DFYcBV1Qe`)AIt|7#U`4D7|-Kp5ehJa7! z_)ov>Pj8^SS)fgGl>H@#3X+0r5d3BZ{tn>NG5)`YKKu^Kn+re9_(O;jT!Y~ML6Lkn z@aZ$=Z+!aJms4Ivh;53pzvO%9KbM2x|IyCm6vlY`t9w8Eca+!h_)BTV973Gn8U(*c zq5nAW=^87w?~lKtyna;25@mnMGw45;gW$hZfgifbddB*O&DG_U*Fp1_(u_HTIKedt zeprED3jA4s`eobj^OV<*>R6)eFZn+D&*dQaH!JX~fPXn4p4_(ZNy_V>`AccW973Gn z8U+6q4?ev!(8&1X3+{T7^7>I7OO*X3Y4o4VLGW+&;8W%V@agz->pOq1_L`18ilPseBfE9G_2{G}-SOP)plxf}%lJ_UXf_;mh> zKlu6+l-G~ySkjC+ggC)92>wYYm0d~!|9aGR9_(zRytYG8h_b)rKhS?J2f_c7BIg+J zY5#A&z5X94uOh@Yr5SSwae`|Q{6E{7oWfDofA)eeJVALKkG~XUf60&0e=Y~XSA7{o z@k=fJf7kKTt(4b~>R8f@IfOXDH3+`>1Jh1Avs4Cr(*LQewmn99J#JSu%Knlg=s%Z( z;1_u2KlP^u_@zKG`;WXXKu;yjm_vvYT!Y{jdhwAjA>mVA52ULaWq-*}(0?um!7ujU zQ}V6Ar*{l)dwpsT<#hpiDrv?XLY&|l1pfjBehT<>|8=|Zj`@_=1L>+p*e*kEbqw-x12|fpk@)>@WE# z`p@Mc_$3PbW8D8Q9WtJ#ye>dbCC!*ah!b3c;9so34~4B~jDOyoXs5g$NLMw={*t5U zKbM2xU!uUD1$_F9Wy$*=T}*jhfSyX4F^3Q*xCX($RDoXxe7gRQ|KgK#DX$08RgJR0 z<`Cip*C6;;D)0{gpRRx3`SIni zr@S6WS2fE1l5zB(%R%t3Qs8HRPuHKLfAODNDX$CAQ%N)C5aI;aAoy1+@JnyD@E?9I z(MEYakgjT!{Uy(#|6C4&KTCnX1o(9Q^}+t?cT-*$pr?{%%pt@Hu0imx@!-?_OceMx z0LQ%l$%7wdf64!#|6C4&f2{|fy0;nlv$1_P^yNCrOSWuFnlXnEM;cIE5d7;r_@rkF z__Y6#{**TxHrb=>FZnt8&*dQar5=3Bxexd>|5FD)@fylYwroq9F^3Q*xCX($UV(oU z_%{OZ&kwDhOL?pujJ=#XA0OT>H0=Q{G(oX~rKyoZuP+|3(FV z8SqK}*S-1YrIa@pew6+6oJ4R9fQ5Q_)7Xk4GR1b;M4uY%Bz3bM0s=JkFY=bOZ1=1LGYI;@b?3sK3VK6E(uZI zT=-?|Ph%^%2EqTfBKbk!(`WX-{LsappuCC@+cd)d=yCL)%R%tJYG-l^M}S|9YWXi- zSx9*ukH1vL{xr6N>tykd1D~E}wp`o2g!1}P9m@#&qrXD`xf}%lFPv0%spMAcerB-b zww;vMb|?yE>`!AWxCX(0iy~(P_%!|>tULS}%Bu*mO(X1&{u=$~auEFQ*qNL{CF9?F z+3Y7MujBET%GjUAR&Wi1|6PB|Pz~_uosBI|UGxIwRfO245%x!)NB_AT1pj+>Ca2KM z`2SXW;UkpS@%T$+>`!AWxCX(0#-B3O0epIA=AUmo`BTcP2(e8g?2l&9e=Y~X|Cyc1 zDHy<~=LuVX`q!6HUdQ7vm9amKt>792KkZK$8sh#xvhBN9Q(i@gZ5m;J^f%}~mxJK{ zz|Q0phJjD-to`At;dzwT@%T$+>`!AWxCX)hp+9A47w~ERe<(Wqeafo{u}vfFkNy_@ z=W-DIAK96l!d@Q#n!o)1os`${_)BH%Ph%^%2EjkH0{9@R5M!r}`c@-hHX@vdJ z-=Y6p4ub!zoyjR20X`jn8|EB%n({gxf2oZ9X>0}8Ao%~`PZ>H6e7gSl-1{#MQC>xe zZ5m;J^aT3P(ei^eFg`!AWxCX&L zglyhR@K)f{{J-i7%>O+2BkYg<5&h?K5d7~e@VkId^MB`8zw{{OMKSAA#{M+6f@=`` zpC~eK20opC)0f?QJLOe`*rpNoM^B>vTn>W2(az))wlV(GAFjWh@;V-Wsf_(;Yz5aK z_?!GGLn+`F!(Q{_m4%d75n`K0*dP59`p@Mc_{Z!_PGL9j>G=QVkN)zrl-Ke2OJ(d& zV=K4@!T(=>%Fur9f7uC~|MK9Eus`}|^qOs}T7pr-MqRC4)Wv@%G;JJ)Mum zJMOiBOndv_fYIB{7OPd;`t|+s^=(Gm+OD{uM6u=@<7}Y1h>H(cMzXbc4Rm(MF@1f# zYu^~h+viS9+dwS7sjojiFwoiCdrZ2vvPbyoJ`)#+d0r@^R=j1y20Mn_NbfNV4F2a zh@-ag?oOk#!x^{k-VPy^mBZ>wXLnz3zai}l-tm{`aC`&2G3=7@&JA&E7|mS9qkXR2 z;MO~6#5&@A@tzK6T3Ecy9Il~L=IHG+I=ivobGMmudv8Ccnry>Pi4Is6>i4?N{sAM_ z$vv{PkOzQb67jCS_Fnvr$R=rCNb`;S>pI=X5vupJb-S=BE+*~$BDZ8Rd3)>B&a%lY zc)ziD)z@$*-8nnD#2}O1m$$P6a$60}cD=oia2k_`JeKZqR}AxGQ1qDEdix4w+eCiv z@yzLygrB3I6fgJQ1$8@xna!9h2PqE&4kZoVec8r_i8G}dNx_4W7i7on5AS2{1s7kZ|zE8aGU zi_13YBFnVneAL@xPa|_4;Uq`$nB_kF!C^OF8JgIha|JF=I|uMriDm<-4X$8}-K zJ4x(2w%f;2D^g(KbnH6U(OmG_7=os;e7Z7u&1fI%=goH&~G^_oX-T%5SC3%zr&ufJ`5 zcbnACtV2HcrLHyh{k?Q$8;iH~cUf1`JSX~l*NY>Y&_?FmXIR5-YT4i0w>~b-C)E4o z`DNAdSE@3n-VL2ND$6;g-P7deJvQ|XuEinJ$(B9wK=k!gga=Sj)UTw91(;#*NoRgh){c+P4 zOW^LHi@Qy+-aZdV`!}`e#6IFa`-)@Q1bouOuy`r1Kg6FKOXvOmxPg|Idem;9%{hxu zy#t4_m}4?^Sl-)@<4%)&J89aRmd1Q8%2D3~h|Z2>iMV|V6!AV6#W(g2SYo0~b>y{8 zroZ2s3Bt!!GnNAH!=Z{VyX5w=*^XW9nOBS@o2}UXxUW6M%4Ua;)13J_2GOTM^DYxL zyN^wh$;9L{SzAv}FLq~|plz0m|1MHxj*8 zIAM5sn=u~p78mEHo9e1-;R)$0&2lsEARfB(8?ktQe{Vl771s44ITrE>8~;(iZ6Da! zX|yMty@+Dhb;i4d2xeX@#=apWo3z_mV~NK#iT+-C%w*>_+SbdLI%b?#BRrHCh{x!O zjM>bLF%ooSbUzQGdv7t=CVqcg&j9Yv<>xwHPI!1EouMop2740r9UbMtg%=Kp4))+c zo9kGPIW&NC3SEAi5?Ya*%YHhgu5YM_wRIT|E5d_KKE;{+B^!PH0WBP3%VgH^;HIA+ zj+u4OwXyeFc|&ImyN7++RO-GF2lQAs#7~GLtcC5cwdy9R3H(Q&YpE9EOG`oMa;w1q z7xFfZ-w}2>P!VmscDYV5bdf1+R9}l}Bj3k(pXs$H+Fa*(x`*iO5uS>bx8bd7@JgXyBU zu3q~wso73-O^oyApo}|^uy2FSHgsI>mGaXCnS4Eivon2dh>d9-Bb++T5$I(5<(n7c zIEcH5^*!$U#|^#WD$eTf#)R{5h}vK*>=P^1u z_5`6+=^$At_|Rk$v5oxftS1{_?L*GDb7g8yJwmn{L?9*IA? zvA18orjvGWj#-OOz?^H@m{Vmx<^|4XZTKXus}rB(*+&aY6FN4VclLZDu{1~^5ECA| z1ykf)WN+{7;~RY^7FS#S$ZVZ}`0U7<<3?csk4|YPd(5pLap|JZEyWJa`VTnL#^gsE zqCW$8#NE+ehCN^L`fwrF1NicRB^Cm-bKnUBn5xcVr zhwP@@^!;0wa&jA7;mcLAi1}pZQpAw{0>OFkZSxe(bH&Jg zWv)&pNi#96B&QE2SB!(>i}K~kzb|_t1W!DhisSh!ZoU0u1Fg)%uQl3^#?~D)Kf}f$ zm0s|`*~)wz9rWL<~sh&$a>Q-ZzH*TfC%TVmMXam+)#sADwKRyFH5wo;Fwy z6C4N6eSBz$FGqBEOS_zzb6tNYK4f?N@*Gp6AAR;REj=*rzQshOTzG3Dk?EznIZg49R@_LD&APX9 zjAZM_Wi56<43yzGU?(4)N(CdT)Au{lLgkHg108ejMX6e`kPRF|wgvOuwza+P=XC4Z zoEvA#iyd5?x=kGM;tKgtj>X@E0v4*T?WALmSrv8Hd4y(%{G158uo+BkQFi4L4atWG zW&*~{yNR9TL)msxz2i|lp6P7&X-9`MahGf2DV|#n4!ECdQ5*YV4{}pGypMs;7x+XrdZn8^ZfDLFdK=5kWaTpNETs3O%(}Fnw)e&! zl^zY6Sg^^D8-%TGW1E|Q%xWrqqG@4bf44)4Yb++uGAqV<9vH)?)b3|hu~@vrI#AiS zI3~VjH=jO}G`7>qPi=60+|jvioq3S6-BMecv2Lf+mibAE9ba!BrmOWpf^}w&=9Q6f zSn;@DTUlEZTUNJpb(6czt$4VC+tY9?=8g$V?_2G>vM9Od<^E@9JeQ*&1 zV_==$EwXvo(jg6~TH(OXP&N<_4>L&Li;6B6TlAp7PD85t8y^`~|xX12W zwW`5A3tU`XemA!**A^wm0&+`b;dVsHZRzUOOCOG{YOGzow0YI)Chnk{pC^VXQcUS} zMad2mPbiaryJW6fyDgl@tzB(&S#2Xdd=}I^$3(|3lp|iF;8kqmZ7;hjLoU1{gAm>aL&NEHB_nL_G!!v?*e1IRLyF)x1 z!{^sR8TWiv$I=8@R90j3x5q+ol$%b>5$qv;9{tv7UjB?oI~q^Yz480$XI! zhT@a6i;~SIem<6tzqwM)*Wf(gY2Jk1Z3=sBqU?6=oGXsI|W<4NX)eBc6iYBwib zlx#Hlm#S;fBP#PCg@2}m5rz;ULD>2SzbDqgJSIEVB2 zIj)cQ#PL@s_zafyGs24RxEaTSfPD97;d>}6-_D){_~H}z3C@Wu z@iZr@%B>I3Au8z|x&`+KCZBvNJN~Y_)p~E`Jbu0D`V5aO`|xfMzxM5)$F3Nc(iFP` zJR>Hq!y{j5#w*o4t2vLKXTJHse$sJqxj2NGI#%6^>)e3+Qd#&N&C1WY8u069`m7PQ zF0o8rhrp}L#L1_Y<8N4^)@=*t@$1&#wvqobLG1K?eo_pvTvSmm5Gl4Vg7dzKE3Emq zC$jJia~=gxeCYlre28kk&LF5Nj!*RAyb~wWC9X4WD@yJP$aVA{wWbGhaHTittS7-8 z@eX`wjbo}Qib7lStvgRFXybC5uLh~j2zWAU&m7p%Es9hYt9hqp0@G!qNHJR$gi)6*m9p*=V8v{*O^`vu|B)@ zKJ@U<4`nP#Z9nv&Hpjrb%;X_h<==*vsd+bW9zSpQri)K8X6>GK3>9alAFI^afS7=EybM#zb+F`^eX?hX1Q9kBQ~C|FWdX8X}77EI*ox#wV7L}kbiqJ3ztUDJTCq4=Nq;6uU^^^Td_16yRW{v$;#s5>5B=w-Ur`Sj(x$z6b$lj$Fp!O z<2){oE1Di$W_~uS;AZ>G(`@;C>tlFx?#-zvN{$BPwe8hv?e?p9#U5O`x_)U*{jykd z?FxJj)@*;|Wa8WVg(6O#ll#H5&cw~Hn~11e{6>_M0=V zG4{m>hSomSGQTK!JRrwR7LGGayZ18>=7@J1mab`Nj;*YHC}#c%lKJtYcn!#-Ywk8- z>2EeN;J=-5g@*aIsRp&i`;`3YbH!!&G`YDp+PFGayK?D$4fY!?p5sz1ORTitZ(V@T zKTQ05EFFLO3N_zNoX0&Uh=b~V8`EwNKFyIxC7yAZxgD&0r2|>G%;G$LF1T=^Q(ab0 zwm)21VO{^H>M9p^B$=IRM>O$X$8oDDbVn;N@@-9CileP_sHq|CJo%Z(_0b3DHa9(z+NLnE8Y?|8{>C{3_1l z)?nExywp-F|6Q#>ApGONPX)xUYs%7pB|g1S)6~3lMWekFc*kJN-O#|yDVXKo?$5$u z3FnbDaIT-szwHZ)?8M_Jun*lx{h9dE+^p{ZhyptnbARW7!-eeOGWy%>+ZmepYGVNiZ z1aTP!mpU`Iu;$;M$igMcdEENY-#5wM9_Qa@tM9>_3CLmdgK9mFDLB~ur)MpvaBogJ z9X9dY+EhIR4h80^F?1!nuEI9Tv9b>CmJ_cLwu?V5w}Lz?qV~hY)3cnExYO@A(L zQOdEWg}eKC(p^;xtT)bxW3J~(=;>tp62=p`{e-q0`w1>$#Kbv&LM{oQQkr z!+!34WMl3#h&YzZunu!Sr(FMl&wz;cK?U!s*E+oE``>A~7;7`fP8ILiidcQL%K6)U zXCE-_;f3Ya5D?Gid-0rucqtb04=a2nuXFlA{ArhAuMiat3Sa|vZUsyc) zHT}oXpF;}Hl!5w_Anu;!u+$%UK8;Uxf9Muv*{T(dxC#~zw2715C)qFEHz!|(>mmhj z>ISu6(&F#aezJM?@0p0*%Xy}3jPQCgUZh^u(9~GFtSPp96&?>Rm7Z7GeN)DXyC16` zv#X1en-qN!{fxZc-_IekaX;z!Ma%VAhdIww^;3F0Y-%q0B_A4SEOw(0tqPvRi~QpX zU*j8`KG5${&_c(DK8~HLK46^gTXVme-qi=o?jDPVrMUJZUW$eKF{<#*jye61k8hP6 zJ7xW#M^dXA_|1JwS1}&u<0|+>Z;0zr^yQd>FLjOln~Aq)8JGGZ&hhk{F(Hnfvc9ZY zS-)&mjk+)Fll!vyKK#9(f-g~{zSOn)`!Y&4-bduV9GK$1$Xy{WVoW^UFnP{ehG!iL zuA(0^+x-35LN@M)IPXw@wsW2-8xuTNUb7N=b`7!d&M)B;qhk4Yp+5}@&Z7Mhg|BL@ z(;xY~)5@_^)gLhqr?Q_96GzW-LgFp&=d(F>s(8m%G@HosT!PIOp6o3(INvKcQbY1b z+x`6al8xul1r&(oLaaxontx3Lp9wv42zJp4;+R1nwkvoNFY?ds@b_UG*|-nHofbNG zq&UyijR7vPV)%NYWq7J-qImkULh^H`i1XH3yyv9gO)1EKJd02CN!*jrHA^4IPF0_X z!>KNZ&$+Wy<}(82j8&mY4W>{|ZgCBVVE(?^q=q zE)&sZNQ!rIS!W^f9hPKIdFF)^D@x8**443QFNt$r_K4h`AR1C8xnJJQ#NGT-1?TH! z&Hei5tBaBcJA-LE=PgdWz$pk>S1K+JQeF{9Ta}I~o7~1*7S}~y`$X$gt!?c7HRkV@ z^mSSL+eCTL@lv%Ev#~gIMQ9@X;Sp#ZL_;rb3wX;s_*9j1PKkKJT3(N6&Ev(OF6fMJKLBC(M{wMTWTx5S12sLbO*K| zIlW^cayxTCTrpUlsHCZg6j6OG4|o-^~{C1yzqh?r7jE3w9m^C!Y{bv8Ph>ayR#xKh_rRd;I>*l#l%K ze1F~REfkks`Z6kSJ}X-Nf6#HI{h$MSsIn36PWDY?Tn|fm1ZSEza&BRlZQe4)Bo805z#NuzX**B3fJ}Kp){_aElRL7V&c=vnPwT~d_*%EHP`EmF)`RB)O%!g`E z?t_>!!gMC)2fh=`{#gl!2Yok~_zpqyi|D%J-T27?4j?@oe_{}?uD2Te(TN$yG6ktujGw*>rZ+7@dK*9P`s)i_&!ZXHcu|{ zW$Oog_OAe0$8V?q@bx$i-TmCyK9CiUeA)2e%ZdkIc0AWWdAPU+%JOx@*AA}teP`qv z9!!dPKq~Vq#inl7Qz}b~l~PO$KdkTwe)$AnvbY}KXFMRjSdelx58#=PbkFZSW{7qdI>Mnzl>D*LHde#J6fKo`*@}eSCu(dkOeZvuxKa zqR-;@Gs-;}rQBXNi#D>2%CcQ9d*kxescmUH{$@Q#zm6+-$$3>{FoOeV9;(iPljTh5 zjm?(c-f^JZBj{6~)Te6CSRKwXFXcHX<_G1=#rFiT=48o7Jae@rf3Ahv?(Zy0ZqCt{ z-Mr79>b%>g*ym-=bet0$X)J|LY=tk#mfF@lQj{FZ(XRxKce!$^j#XmbQ9C-OcsY9O zx$=8`qV0^ouy}drl<!grtQOiM{VW(p6aK194SO&I+hF0 zlSLeUkPKs-NndrTvD^uh^Ii%g<

?h*oWb*ik_7qpf*Gs~t+P}?w2oPI} zm30+u$-ilWxI3p9S8xcrCC=gx(8Ei@a*@ATI=p61cujcj+_~Wg!uN*F?>-MV%?Z;( zeEJH!aPypSb9g0OG4qPm^AjJidM{?f_k^2YDR>gT^-ar`h3aD)@fpALY|nd*Ta9Ol zR&?(Fz4MIjlV?y{`Gm_U2shi3bDm{ul*dkZ%kH?t7j^ROlY34&j`oyP^rt|1C1kN!3;@w$v$c3A4oR)BZhu<+djRo&wE);ksl)w>w5l>s< ze+vfw7B*6S8JEQ-S06=;*k;pK9Q(3y6Mm70wiY*wnaS(!7QB78x~ZjN{({Q8T54*W z9%x?G*s@^${FW7s^Y3h2y%axKwyd_LY3b^RSJtm=YH3({U$_EQ{QYNb%ZjD-E9c^k z7z=^&%}y33#Y%P6wbB+VJnR3|uI63V_)(eG@H?G3zif&*9|UKy5*E!d+MWa^ttf`J zU?p2CcwysP$X7X+|4dWq)w+3Ij zGBD2^k9jrmfk%wqzIhmrdEI^U@5CSJ;QNKz{;3mKr5gX&mKr5gX&mKr5gX&mKr5gX&xpkYW*tn$O{GLZ&?q+7v(bjzVk#;??j;ZeP_{T z=52+^3s8Cf(A*~|udu7O3HFy36q)=eCJ25Q@m~Be@aZ?lpS$wn5amTN>oU&x!-x}H zgW%tc%wGICz`qdo%dh(4Gn6+gI2;M~mlmS`Tn>VNhXQ{I@agxtuMdYplo!RU%Q#~W zBTjG)f@U3#{pWHJ{GZ#IoWeffm!Nv%s~@?K@;V-W zX`C^K5hu6?!T+T{W#|y&zxr=}`zYmAgxID8`%5oE|G69l|EQhGDU1XEGE}eq;|+%? zujBET#u;-Mae`|Q{Nw(Vq0q}L{a3%R_WhJs6(Vd2_Lr8R|6C4&|0|J5+Rg(0MW{bo z@V{44UdiPvjx**k;snOu|9|%7hR;!6AE;zVu)p+T^q;JKj@B0+x^?^!;1p7-bLI1fN1iw;&-@^FY zKDF;tlvjfD6~`HK7;%DY5c~xS{4O5<&_8_dDCPBmN`?gcOD{$Lxf}%lUIqRZ9{(S_ zX4?-auLS2Sjx**k;sns^&OraU90b2wfjMA#e@JH6!ocYOb+lvfdAn-c6Vy&V1LauECzb|$BA zlJVdE%-z4FypG3T8fVO5#0joJ@M{$FZ`R8TlUD+&=gAKopuB!m$C6-w=@sZdmxJIh zSKyZee-$&F{6_A7*=1WkMtS|HjwQkV(wXQ#mxJKf zDe$|1e-$7;u<%bWqr489zckL6!-x}HgW%UI@P~j;^Z$-L@B10$^`knL1p7;`ME|)Q z1pfgA{!ZZ2@$b@(@Bf1GI%xjVIAiWaoZuP+|35q_3&5v>ZF|6DCdvmF-tjKV?+JBP z``BM|6?EWoJ|1${k9+dd{zpp!_7mVy06}h9(bgXhF9^>suc*4ka)+X2*0t&nzx8AZ zVY6AenZ^F2*oyuH;kezC|7w8(`*!dsxC9)_7u;Q0b$3Mt6U;EbWzSsqEy5K|RNLL` z-+XmZQuHMVze==|^9p_`x{K`KNo|lVUA7%fRYm1Vi4?%d9 zqn(^j@ESqh1bB#X6kCcNgZ*-B-@5rkE8)uRz2!#smtI$t6nzQ8@1Q5Y;8zEG@tqDo z!tFqvj(<0Id~6ZndAZ2-an3u6IMIh7yb_-Lg4Yq`O?h|~&$Z5rvrj($IN`}WyyY$I zuPep;=W-BUc<|}UFL-T2t|j0hkK+#1>3Q|VUuyje!t-*G>!s{Jg01L75MINc{DRj^ z*vCA)%H~lV9+vhCNaaUKqIf<>gi73oYa%Y;-Jp+pB(mJ7IeH$n~R~ zdlYe^A3-$h@Z=ZV(#U(r=2lTz!52i86@|$gK;W72CmRV<=He}HVSmGoMM=?*AlyP| zC+8I04CLJk9+qwu3(6N;QO95_Me(hR?|B_z%5A;n+3X+3R`eqXw;i7Rg4;~ktLF=D z<%`NIE##fB5x37j^7zw)>E$EW_pm=XyC^C85rkV6+R6C@w_V7avAIDv=GMHRFnJ9c z{AzUf5Mjz~z2#>1hi@uMihcy)cF2=oaI1qo1s=RF*t!*0THG23KlTV=dilupt<`zg=2-LTQM(1-5b{9(eBxp>Q4*&lsLQBw3H2)7w%C+8I0 zwjl2bo0~JH(Yq|&{_z*@dLv=VZN23(_Ghpa{RqNs#FJlen+^L2c-UjQC={a4s!JAH z*BsyY+83TCOfMg~zMuWuUW(7Qxg3OB4cf{11h+lNRRuDR4XD$uGDy!+zZ6R=!Z|r;UrObJmY~55I~qy?o^QNzOfnIMI(Fx^4F4 z7u=2`?4`TIrp(1#9%g^X&A2Dyau9B%XeZ|s+_oZDGkAE% zbT@2te7nByjZwms+j`5D!hZ{{Wln+HZqc3-3vOkw7cUmvaIT*p3egyKz(&_0G^Qb7 zdilupgPeN@;zU1!=+@}TFSzYT-u*T==NJ;X+u9dCbkq0h2~+0cEqAfM>Q=;YIS997 zp8SGaE9_n1!N-urBhVJrF(gxe6e7uf~3li)Vv zl{U93aUIeH8{NAP&Hbx)6Q*dV+NRjw7b!}LegxqbK|49G;5LlBDTmvligGKec!_mi zwPjgHKViykz2$25&$tcOg3L1rw|$=cf?Fl*4dB6JYIEBK8$I()U-kH#2-C|)t{>*y zBZw3I2*Rz!lV5N@a+3Xxx8oTImxFLCMmssD;I;|5W-S%mock;T zHsW^MXWsnpgekZ6mc#5nhOOvF5NZj2+gCo?a42= zHNYNTW^-FuzQ97>0vlbwwa;6%m@vJ3gG-D2IhAFxZ1j#QE&K0r=NF${g^_PYEx6%j9^y8C!QzT4 zt4XK}cDjc9eEoM;5iXmRn*;10zOyJP`a=BBWpl~L?`Rf&dy#h+@x#l0GPfDat#j(a zzxrb}VJbFO2h?f|%e7r`o@HzorM?Ac$@3)>m-+kB4Uc$>piR{DdZ=F|^6n!9G^!%EZe7t7e z>&`Fc+BW3v0uNcQ1E|wJ@Z{&WJxF*aK$ic?*?$6C(Ffv{CEPU2Tt_|m#r|0a`$-S4 zmb${^^~lh^Zr)9VmkVQz{oBfMKIU=|UUg_E=NG*8A=fVOD8PhR$j?7!)LYN%KYHko z>j_V8=PkFge@+FiuTFv25l?)cP=JmVLH>E$EW zPjc@4h!gz?qSH&T7oYet;mJI_$ zxrP0aN_wVl#RlPZ*ppxIYKA=p9`ZOAudv?5JN)^|CkW5WMXqN!?_R`-J_O-qc=8Kg z$B?%iJPL3@P+76SgxrQYor|_!{+C}SJeh~Lyp{c}cj4NH%RzX}Ks!07;FUzK1H=n2 zD-HGxbgu7-cZ5583=unLrS-hyn>z<~5Vo+Zw&md;Q)qOIVy54j?%+;c67I(??`hpYekr-UcB z^OjrLA6|sx|0(b~;>j;~MPc6$9)uTZw9en#mw))zgyZEP*N=0)QN#)EL3HZ#R|5#O2G<0O36pq-27@|m!Fs<)c)^Of6wGt4-yzkj^m+RvdB?n(HZ@bFze4dB6e zqbT`q`0P`^e~WQ^4(|C$YaiHz``#WW;gdo;7tiH0Vfj>VGuNx-#mm0HIIh2c+-&XB zD200xK2sjP%cl`M7%%hsitH%zz?blz!ultPQHOReZ`o6x1=a*&@V!UP!v{Ok*BGzr z7W3S4`LpkQi!t4{{&BOlS8c{`055>sl!q_e8c^Q?9zM4*)bZKnh4PQyXH1`udp>Ki zPry(5kwmvn4_~;Q1?~)ZNUX-~X1;mv>dW6{EU6Eb1J<6xbENQ3!l@+B^JhPBGvL9P zIh34l-fF+}2aFTqA$1kj-h$^x;hu!gVGrLOzw_WBdp3C{9D#rT4%C+|zLyc(IBfNI z!Y1!UuCL$7eW=)Tu%D+L75wT(>gP~D-WrXy3VrIn%V@IdZgY+He|YUx?5p%YR90L2 zEK1Rjn&8oEAxT`fE$ieR!f_9udz>5Aum2CW)?SsuyHAG~ z|5lAj@XeX|WS!`B#>4l=Ob+%lmRH{{^ZmrrFKyY+crK=YJZo{s;3s{cUeuc@j#tLR z_jz@~J^?<&YP-k$ZS1SBzc<8qtjm|O*5340%mMb8ytoE3#qnB&cE;0u`n<|u9|Rv- ztM4^)`P=DxZ)ZHWoqt?q?b9fw59Gzad0>j;Rn@Q*-{++>BYw!OWz9Y5AGP_Cz3M*0YaAtc{W^QobByP<^N*XXz4B(P zeGV`Fc9)%wK;xzWdXR$GUu}-`aO!oJb$Yi_ca}alFc6#@Bh^4}g!)w-W8@_ZYr8 zlze}G`gfO>kjFycJRfVVeGaAcjeKPv5XX1S!}oa|hkf4i8roZ$Ed!66pT4n_@$yhw zsGhL)XKum!AA3w*e6Ph6$EykLjHmhZc{RZP3i#04nl|geQ@?7wmhs$n{_!ryE`1;` z*%QR^ns(X~+vjx#_QT*qTlxLwI_`YzvXbhrhk41mIA?L&zY+E$o}c&~xTH$N$~ZCF znhcJV)B6o4@lR5o0G8;IuOAh5zV`?9*Pc;6)4L%t(h{&%rL@juSG zDmyNg%V8i>goYT)9Qz#GGHxm!Fz>0>{5A7zF&r}O=Km9T{>E=%a~#%!+jxTe&uLolkn>AHhhmJf02SkV0Y1l}88xPcqVrUT*)JaZ?4hI7Gz2T! zk6C-!?ThV0{%)PC{UEM$-L2smZkwdXNwwz~h{U+a+SlNoq{h@xbe_U|&3Uxt)fe9- zADPEpZnAc)58Tt7ulb(ZOvUpsFddo+Qu!O_*EXje%Fcn3XbKui7~{FrQA=_-wA79yVY=Wee)d`>Te71 znww2bVoUrSI7uHEi`f0Ply?`xsnxdk%i|E%?Y zC&oW*{paD&@$={IXA1Ip!1`BYjQ>oGe;52Gx2??9z`q#%8}Vb}dH6S2|2X}(@W;nU zZPx#xpY|5KzFXnnw;gjH{CWSy;cth3Bm9SpxZKe+>RpMe_d;{`EUB zHx$YLBlwrYzx*N7-?;H#f*;8Z!@t`4$LX_zKdM7Y!JqTVZ+oUUEmQfq&mc$=rG;{B;Rvas!&rBdb^?3$unVH%HKE@LLtiLC!562^4^cD58&x0Hf;PHMv zY_sQH)M>xfM>dBO9Z}8#RDN&NMtyz=2WFS3ltbcrP$*1^C6~d4;zOgN8r#?r}h?!|Jz|mNW``iGx5u1x^vFJ6E zhu=}SFb~6?bo?x$nd{zTr>v5D_*VK8D%3hBr3`~=L*lh8{z+a?7IckLBk^+|p>{2j#O2 zpA(pg>DvpPj|KeQXN6F_LU?8ON8`KC3ZZy~@LB?Rymxs2GBaM1duKF&=kEPO@e1*q z3*fo;HsdAX*YH48KX)z;#Vf>bD1b+PGPg3GJD(K7qHQ{W=kDc0@d{zqVf_1ccP}4` z=li?oyr0~29<#r)H)lMVuYA8^&$%`UUMOC%IO0b<*&F8q{KYR+hWy!I!K=nTJ;`2# z{(ct$ za_*MYpZjj+7R=AW+4aeHOn=`-{RMB7^L>K7JpDs>@@z7fke?e{bff-NP7ppPxQTXI zo6mXr(@&ml$c6oq;sS-;W&Ja>If%5N-yM}8ciGDef|E9;8(*Ii$e z@@om;k)N!u#7nZijt21D^))HKxd5KKz9z+MI2hHB{gw5QcuCgRp#a`;-hE96@Z9w) zX@Bdw!~K=@m3T?ki);XIIq$M^0X$w0Suc|Es}6kkLOfZ|i07^;JTH_o0lekBn@abD zug4LPV6KEc$-AL}hogAzyRJ~YLj7fY-@XAABQ}o(?7qKy9`fgYWyI#tdg`|Kk42lw zN6ha|#Qr%s2$XzQ=bnIRG_Zd2eHY(}tvIwI%YA_H41b=$d%&<|Y3)$V?_^~^v9#6V z*~&GG#}|4u*NFd906h54lDhG|rRbLgllxgoYah?wfA%S^UxK6M#aEya_lO^*0TrV* z`?g}vWxnz6qqytNIru07FeiP#JRg|jIEM&cF}!`B?11^(vm>7zyn%CxZ|6B*=k%Zo|g9>uVeK^*)$6*j>AE!-m=e-5b_*_w3%A z>DarkcH8crN4q+@w$*m--m~Vq+K#Thoe!n=)i!nXX1>@C?DOaYV_Yn)qz{atNfl59 zQ~^~$6;K6K0aZX1Pz6*0RX`O`1yli5Kow90Q~^~$6;K6K0aZX1Pz6*0RX`O`1yli5 zKow90Q~^~$6;K6K0aZX1Pz6*0RX`O`1yli5Kow90Q~^~$6;K6K0aZX1Pz6*0RX`O` z1yli5Kow90Q~^~$6;K6K0aZX1Pz6*0RX`O`1yli5Kow90Q~^~$6;K6K0aZX1Pz6*0 zRX`O`1yli5Kow90Q~^~$6;K6K0aZX1Pz6*0RX`O`1yli5Kow90Q~^~$6;K6K0aZX1 YPz6*0RX`O`1yli5Kow90K0XEh4PGyJF8}}l literal 0 HcmV?d00001 diff --git a/SaryninS/lab 1/sln/polinom/.vs/Project1/v15/ipch/AutoPCH/e3ad92ca303ea824/GTEST-ALL.ipch b/SaryninS/lab 1/sln/polinom/.vs/Project1/v15/ipch/AutoPCH/e3ad92ca303ea824/GTEST-ALL.ipch new file mode 100644 index 0000000000000000000000000000000000000000..7cf9be81c7ffb42c03546944e898cbb82c4309ea GIT binary patch literal 61341696 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%0A(O!BuweGX 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

QTB+Uo+u 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≫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

%PvW$*YD9aZAnY&YvB3YOAOo2s1IB8&)=3} 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℞{RqPks6PG4+kY7{=;r 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

#w($@p34Ii}XEouY4ch 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

os!RDevobJGL8-cW-Mxcgz>$A4ae7b4T*> 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