111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Copyright 2005, Google Inc. 211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// All rights reserved. 311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Redistribution and use in source and binary forms, with or without 511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// modification, are permitted provided that the following conditions are 611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// met: 711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// * Redistributions of source code must retain the above copyright 911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// notice, this list of conditions and the following disclaimer. 1011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// * Redistributions in binary form must reproduce the above 1111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// copyright notice, this list of conditions and the following disclaimer 1211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// in the documentation and/or other materials provided with the 1311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// distribution. 1411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// * Neither the name of Google Inc. nor the names of its 1511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// contributors may be used to endorse or promote products derived from 1611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// this software without specific prior written permission. 1711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 1811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 1911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 2011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 2111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 2211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 2311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 2411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 2511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 2611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 2711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 2811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 2911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 3011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Utility functions and classes used by the Google C++ testing framework. 3111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 3211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Author: wan@google.com (Zhanyong Wan) 3311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 3411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This file contains purely Google Test's internal implementation. Please 3511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// DO NOT #INCLUDE IT IN A USER PROGRAM. 3611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 3711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef GTEST_SRC_GTEST_INTERNAL_INL_H_ 3811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_SRC_GTEST_INTERNAL_INL_H_ 3911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 4011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_IMPLEMENTATION_ is defined to 1 iff the current translation unit is 4111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// part of Google Test's implementation; otherwise it's undefined. 4211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !GTEST_IMPLEMENTATION_ 4311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A user is trying to include this from his code - just say no. 4411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# error "gtest-internal-inl.h is part of Google Test's internal implementation." 4511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# error "It must not be included except by Google Test itself." 4611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_IMPLEMENTATION_ 4711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 4811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef _WIN32_WCE 4911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <errno.h> 5011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // !_WIN32_WCE 5111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <stddef.h> 5211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <stdlib.h> // For strtoll/_strtoul64/malloc/free. 5311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <string.h> // For memmove. 5411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 5511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <algorithm> 5611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <string> 5711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <vector> 5811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 5911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include "gtest/internal/gtest-port.h" 6011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 6111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_CAN_STREAM_RESULTS_ 6211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <arpa/inet.h> // NOLINT 6311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <netdb.h> // NOLINT 6411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 6511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 6611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_OS_WINDOWS 6711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <windows.h> // NOLINT 6811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_OS_WINDOWS 6911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 7011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include "gtest/gtest.h" // NOLINT 7111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include "gtest/gtest-spi.h" 7211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 7311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace testing { 7411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 7511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Declares the flags. 7611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 7711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// We don't want the users to modify this flag in the code, but want 7811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Google Test's own unit tests to be able to access it. Therefore we 7911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// declare it here as opposed to in gtest.h. 8011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_DECLARE_bool_(death_test_use_fork); 8111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 8211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace internal { 8311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 8411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The value of GetTestTypeId() as seen from within the Google Test 8511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// library. This is solely for testing GetTestTypeId(). 8611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ extern const TypeId kTestTypeIdInGoogleTest; 8711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 8811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Names of the flags (needed for parsing Google Test flags). 8911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests"; 9011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst char kBreakOnFailureFlag[] = "break_on_failure"; 9111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst char kCatchExceptionsFlag[] = "catch_exceptions"; 9211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst char kColorFlag[] = "color"; 9311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst char kFilterFlag[] = "filter"; 9411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst char kListTestsFlag[] = "list_tests"; 9511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst char kOutputFlag[] = "output"; 9611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst char kPrintTimeFlag[] = "print_time"; 9711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst char kRandomSeedFlag[] = "random_seed"; 9811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst char kRepeatFlag[] = "repeat"; 9911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst char kShuffleFlag[] = "shuffle"; 10011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst char kStackTraceDepthFlag[] = "stack_trace_depth"; 10111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst char kStreamResultToFlag[] = "stream_result_to"; 10211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst char kThrowOnFailureFlag[] = "throw_on_failure"; 10311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 10411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A valid random seed must be in [1, kMaxRandomSeed]. 10511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst int kMaxRandomSeed = 99999; 10611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 10711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// g_help_flag is true iff the --help flag or an equivalent form is 10811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// specified on the command line. 10911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ extern bool g_help_flag; 11011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 11111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Returns the current time in milliseconds. 11211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ TimeInMillis GetTimeInMillis(); 11311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 11411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Returns true iff Google Test should use colors in the output. 11511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ bool ShouldUseColor(bool stdout_is_tty); 11611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 11711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Formats the given time in milliseconds as seconds. 11811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms); 11911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 12011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Converts the given time in milliseconds to a date string in the ISO 8601 12111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// format, without the timezone information. N.B.: due to the use the 12211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// non-reentrant localtime() function, this function is not thread safe. Do 12311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// not use it in any code that can be called from multiple threads. 12411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms); 12511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 12611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Parses a string for an Int32 flag, in the form of "--flag=value". 12711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 12811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// On success, stores the value of the flag in *value, and returns 12911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// true. On failure, returns false without changing *value. 13011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ bool ParseInt32Flag( 13111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* str, const char* flag, Int32* value); 13211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 13311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Returns a random seed in range [1, kMaxRandomSeed] based on the 13411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// given --gtest_random_seed flag value. 13511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int GetRandomSeedFromFlag(Int32 random_seed_flag) { 13611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const unsigned int raw_seed = (random_seed_flag == 0) ? 13711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static_cast<unsigned int>(GetTimeInMillis()) : 13811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static_cast<unsigned int>(random_seed_flag); 13911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 14011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Normalizes the actual seed to range [1, kMaxRandomSeed] such that 14111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // it's easy to type. 14211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int normalized_seed = 14311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static_cast<int>((raw_seed - 1U) % 14411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static_cast<unsigned int>(kMaxRandomSeed)) + 1; 14511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return normalized_seed; 14611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 14711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 14811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Returns the first valid random seed after 'seed'. The behavior is 14911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// undefined if 'seed' is invalid. The seed after kMaxRandomSeed is 15011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// considered to be 1. 15111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int GetNextRandomSeed(int seed) { 15211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed) 15311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "Invalid random seed " << seed << " - must be in [1, " 15411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << kMaxRandomSeed << "]."; 15511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int next_seed = seed + 1; 15611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return (next_seed > kMaxRandomSeed) ? 1 : next_seed; 15711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 15811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 15911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This class saves the values of all Google Test flags in its c'tor, and 16011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// restores them in its d'tor. 16111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass GTestFlagSaver { 16211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 16311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The c'tor. 16411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTestFlagSaver() { 16511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests); 16611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break_on_failure_ = GTEST_FLAG(break_on_failure); 16711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert catch_exceptions_ = GTEST_FLAG(catch_exceptions); 16811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert color_ = GTEST_FLAG(color); 16911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert death_test_style_ = GTEST_FLAG(death_test_style); 17011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert death_test_use_fork_ = GTEST_FLAG(death_test_use_fork); 17111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert filter_ = GTEST_FLAG(filter); 17211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert internal_run_death_test_ = GTEST_FLAG(internal_run_death_test); 17311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert list_tests_ = GTEST_FLAG(list_tests); 17411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert output_ = GTEST_FLAG(output); 17511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert print_time_ = GTEST_FLAG(print_time); 17611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert random_seed_ = GTEST_FLAG(random_seed); 17711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert repeat_ = GTEST_FLAG(repeat); 17811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert shuffle_ = GTEST_FLAG(shuffle); 17911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert stack_trace_depth_ = GTEST_FLAG(stack_trace_depth); 18011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert stream_result_to_ = GTEST_FLAG(stream_result_to); 18111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert throw_on_failure_ = GTEST_FLAG(throw_on_failure); 18211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 18311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 18411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The d'tor is not virtual. DO NOT INHERIT FROM THIS CLASS. 18511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ~GTestFlagSaver() { 18611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_; 18711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(break_on_failure) = break_on_failure_; 18811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(catch_exceptions) = catch_exceptions_; 18911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(color) = color_; 19011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(death_test_style) = death_test_style_; 19111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(death_test_use_fork) = death_test_use_fork_; 19211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(filter) = filter_; 19311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(internal_run_death_test) = internal_run_death_test_; 19411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(list_tests) = list_tests_; 19511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(output) = output_; 19611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(print_time) = print_time_; 19711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(random_seed) = random_seed_; 19811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(repeat) = repeat_; 19911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(shuffle) = shuffle_; 20011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(stack_trace_depth) = stack_trace_depth_; 20111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(stream_result_to) = stream_result_to_; 20211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(throw_on_failure) = throw_on_failure_; 20311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 20411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 20511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 20611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Fields for saving the original values of flags. 20711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool also_run_disabled_tests_; 20811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool break_on_failure_; 20911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool catch_exceptions_; 21011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::string color_; 21111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::string death_test_style_; 21211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool death_test_use_fork_; 21311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::string filter_; 21411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::string internal_run_death_test_; 21511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool list_tests_; 21611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::string output_; 21711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool print_time_; 21811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert internal::Int32 random_seed_; 21911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert internal::Int32 repeat_; 22011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool shuffle_; 22111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert internal::Int32 stack_trace_depth_; 22211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::string stream_result_to_; 22311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool throw_on_failure_; 22411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} GTEST_ATTRIBUTE_UNUSED_; 22511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 22611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Converts a Unicode code point to a narrow string in UTF-8 encoding. 22711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// code_point parameter is of type UInt32 because wchar_t may not be 22811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// wide enough to contain a code point. 22911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// If the code_point is not a valid Unicode code point 23011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted 23111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// to "(Invalid Unicode 0xXXXXXXXX)". 23211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ std::string CodePointToUtf8(UInt32 code_point); 23311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 23411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Converts a wide string to a narrow string in UTF-8 encoding. 23511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The wide string is assumed to have the following encoding: 23611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin, Symbian OS) 23711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// UTF-32 if sizeof(wchar_t) == 4 (on Linux) 23811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Parameter str points to a null-terminated wide string. 23911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Parameter num_chars may additionally limit the number 24011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// of wchar_t characters processed. -1 is used when the entire string 24111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// should be processed. 24211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// If the string contains code points that are not valid Unicode code points 24311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output 24411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding 24511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// and contains invalid UTF-16 surrogate pairs, values in those pairs 24611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// will be encoded as individual Unicode characters from Basic Normal Plane. 24711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ std::string WideStringToUtf8(const wchar_t* str, int num_chars); 24811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 24911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file 25011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// if the variable is present. If a file already exists at this location, this 25111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// function will write over it. If the variable is present, but the file cannot 25211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// be created, prints an error and exits. 25311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid WriteToShardStatusFileIfNeeded(); 25411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 25511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Checks whether sharding is enabled by examining the relevant 25611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// environment variable values. If the variables are present, 25711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// but inconsistent (e.g., shard_index >= total_shards), prints 25811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// an error and exits. If in_subprocess_for_death_test, sharding is 25911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// disabled because it must only be applied to the original test 26011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// process. Otherwise, we could filter out death tests we intended to execute. 26111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ bool ShouldShard(const char* total_shards_str, 26211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* shard_index_str, 26311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool in_subprocess_for_death_test); 26411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 26511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Parses the environment variable var as an Int32. If it is unset, 26611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// returns default_val. If it is not an Int32, prints an error and 26711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// and aborts. 26811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ Int32 Int32FromEnvOrDie(const char* env_var, Int32 default_val); 26911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 27011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Given the total number of shards, the shard index, and the test id, 27111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// returns true iff the test should be run on this shard. The test id is 27211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// some arbitrary but unique non-negative integer assigned to each test 27311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// method. Assumes that 0 <= shard_index < total_shards. 27411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ bool ShouldRunTestOnShard( 27511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int total_shards, int shard_index, int test_id); 27611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 27711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// STL container utilities. 27811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 27911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Returns the number of elements in the given container that satisfy 28011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the given predicate. 28111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class Container, typename Predicate> 28211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int CountIf(const Container& c, Predicate predicate) { 28311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Implemented as an explicit loop since std::count_if() in libCstd on 28411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Solaris has a non-standard signature. 28511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int count = 0; 28611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) { 28711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (predicate(*it)) 28811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++count; 28911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 29011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return count; 29111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 29211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 29311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Applies a function/functor to each element in the container. 29411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class Container, typename Functor> 29511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid ForEach(const Container& c, Functor functor) { 29611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::for_each(c.begin(), c.end(), functor); 29711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 29811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 29911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Returns the i-th element of the vector, or default_value if i is not 30011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// in range [0, v.size()). 30111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename E> 30211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline E GetElementOr(const std::vector<E>& v, int i, E default_value) { 30311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return (i < 0 || i >= static_cast<int>(v.size())) ? default_value : v[i]; 30411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 30511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 30611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Performs an in-place shuffle of a range of the vector's elements. 30711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 'begin' and 'end' are element indices as an STL-style range; 30811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// i.e. [begin, end) are shuffled, where 'end' == size() means to 30911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// shuffle to the end of the vector. 31011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename E> 31111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid ShuffleRange(internal::Random* random, int begin, int end, 31211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::vector<E>* v) { 31311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int size = static_cast<int>(v->size()); 31411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_CHECK_(0 <= begin && begin <= size) 31511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "Invalid shuffle range start " << begin << ": must be in range [0, " 31611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << size << "]."; 31711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_CHECK_(begin <= end && end <= size) 31811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "Invalid shuffle range finish " << end << ": must be in range [" 31911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << begin << ", " << size << "]."; 32011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 32111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Fisher-Yates shuffle, from 32211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle 32311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (int range_width = end - begin; range_width >= 2; range_width--) { 32411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int last_in_range = begin + range_width - 1; 32511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int selected = begin + random->Generate(range_width); 32611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::swap((*v)[selected], (*v)[last_in_range]); 32711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 32811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 32911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 33011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Performs an in-place shuffle of the vector's elements. 33111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename E> 33211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline void Shuffle(internal::Random* random, std::vector<E>* v) { 33311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ShuffleRange(random, 0, static_cast<int>(v->size()), v); 33411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 33511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 33611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A function for deleting an object. Handy for being used as a 33711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// functor. 33811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T> 33911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic void Delete(T* x) { 34011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert delete x; 34111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 34211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 34311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A predicate that checks the key of a TestProperty against a known key. 34411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 34511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// TestPropertyKeyIs is copyable. 34611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass TestPropertyKeyIs { 34711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 34811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Constructor. 34911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 35011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // TestPropertyKeyIs has NO default constructor. 35111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert explicit TestPropertyKeyIs(const std::string& key) : key_(key) {} 35211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 35311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns true iff the test name of test property matches on key_. 35411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool operator()(const TestProperty& test_property) const { 35511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return test_property.key() == key_; 35611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 35711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 35811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 35911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::string key_; 36011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 36111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 36211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Class UnitTestOptions. 36311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 36411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This class contains functions for processing options the user 36511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// specifies when running the tests. It has only static members. 36611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 36711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// In most cases, the user can specify an option using either an 36811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// environment variable or a command line flag. E.g. you can set the 36911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// test filter using either GTEST_FILTER or --gtest_filter. If both 37011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the variable and the flag are present, the latter overrides the 37111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// former. 37211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass GTEST_API_ UnitTestOptions { 37311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 37411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Functions for processing the gtest_output flag. 37511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 37611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns the output format, or "" for normal printed output. 37711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static std::string GetOutputFormat(); 37811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 37911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns the absolute path of the requested output file, or the 38011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // default (test_detail.xml in the original working directory) if 38111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // none was explicitly specified. 38211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static std::string GetAbsolutePathToOutputFile(); 38311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 38411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Functions for processing the gtest_filter flag. 38511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 38611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns true iff the wildcard pattern matches the string. The 38711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // first ':' or '\0' character in pattern marks the end of it. 38811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 38911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This recursive algorithm isn't very efficient, but is clear and 39011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // works well enough for matching test names, which are short. 39111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static bool PatternMatchesString(const char *pattern, const char *str); 39211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 39311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns true iff the user-specified filter matches the test case 39411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // name and the test name. 39511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static bool FilterMatchesTest(const std::string &test_case_name, 39611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const std::string &test_name); 39711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 39811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_OS_WINDOWS 39911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Function for supporting the gtest_catch_exception flag. 40011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 40111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the 40211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise. 40311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This function is useful as an __except condition. 40411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static int GTestShouldProcessSEH(DWORD exception_code); 40511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_OS_WINDOWS 40611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 40711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns true if "name" matches the ':' separated list of glob-style 40811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // filters in "filter". 40911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static bool MatchesFilter(const std::string& name, const char* filter); 41011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 41111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 41211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Returns the current application's name, removing directory path if that 41311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// is present. Used by UnitTestOptions::GetOutputFile. 41411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ FilePath GetCurrentExecutableName(); 41511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 41611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The role interface for getting the OS stack trace as a string. 41711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass OsStackTraceGetterInterface { 41811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 41911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert OsStackTraceGetterInterface() {} 42011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual ~OsStackTraceGetterInterface() {} 42111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 42211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns the current OS stack trace as an std::string. Parameters: 42311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 42411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // max_depth - the maximum number of stack frames to be included 42511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // in the trace. 42611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // skip_count - the number of top frames to be skipped; doesn't count 42711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // against max_depth. 42811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual string CurrentStackTrace(int max_depth, int skip_count) = 0; 42911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 43011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // UponLeavingGTest() should be called immediately before Google Test calls 43111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // user code. It saves some information about the current stack that 43211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // CurrentStackTrace() will use to find and hide Google Test stack frames. 43311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void UponLeavingGTest() = 0; 43411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 43511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 43611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface); 43711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 43811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 43911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A working implementation of the OsStackTraceGetterInterface interface. 44011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass OsStackTraceGetter : public OsStackTraceGetterInterface { 44111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 44211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert OsStackTraceGetter() : caller_frame_(NULL) {} 44311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 44411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual string CurrentStackTrace(int max_depth, int skip_count) 44511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_LOCK_EXCLUDED_(mutex_); 44611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 44711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_); 44811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 44911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This string is inserted in place of stack frames that are part of 45011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Google Test's implementation. 45111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const char* const kElidedFramesMarker; 45211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 45311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 45411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Mutex mutex_; // protects all internal state 45511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 45611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We save the stack frame below the frame that calls user code. 45711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We do this because the address of the frame immediately below 45811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the user code changes between the call to UponLeavingGTest() 45911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // and any calls to CurrentStackTrace() from within the user code. 46011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void* caller_frame_; 46111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 46211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter); 46311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 46411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 46511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Information about a Google Test trace point. 46611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct TraceInfo { 46711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* file; 46811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int line; 46911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::string message; 47011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 47111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 47211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This is the default global test part result reporter used in UnitTestImpl. 47311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This class should only be used by UnitTestImpl. 47411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass DefaultGlobalTestPartResultReporter 47511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : public TestPartResultReporterInterface { 47611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 47711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert explicit DefaultGlobalTestPartResultReporter(UnitTestImpl* unit_test); 47811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Implements the TestPartResultReporterInterface. Reports the test part 47911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // result in the current test. 48011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void ReportTestPartResult(const TestPartResult& result); 48111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 48211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 48311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert UnitTestImpl* const unit_test_; 48411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 48511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter); 48611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 48711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 48811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This is the default per thread test part result reporter used in 48911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// UnitTestImpl. This class should only be used by UnitTestImpl. 49011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass DefaultPerThreadTestPartResultReporter 49111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : public TestPartResultReporterInterface { 49211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 49311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert explicit DefaultPerThreadTestPartResultReporter(UnitTestImpl* unit_test); 49411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Implements the TestPartResultReporterInterface. The implementation just 49511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // delegates to the current global test part result reporter of *unit_test_. 49611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void ReportTestPartResult(const TestPartResult& result); 49711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 49811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 49911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert UnitTestImpl* const unit_test_; 50011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 50111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter); 50211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 50311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 50411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The private implementation of the UnitTest class. We don't protect 50511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the methods under a mutex, as this class is not accessible by a 50611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// user and the UnitTest class that delegates work to this class does 50711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// proper locking. 50811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass GTEST_API_ UnitTestImpl { 50911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 51011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert explicit UnitTestImpl(UnitTest* parent); 51111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual ~UnitTestImpl(); 51211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 51311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // There are two different ways to register your own TestPartResultReporter. 51411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // You can register your own repoter to listen either only for test results 51511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // from the current thread or for results from all threads. 51611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // By default, each per-thread test result repoter just passes a new 51711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // TestPartResult to the global test result reporter, which registers the 51811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // test part result for the currently running test. 51911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 52011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns the global test part result reporter. 52111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestPartResultReporterInterface* GetGlobalTestPartResultReporter(); 52211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 52311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Sets the global test part result reporter. 52411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void SetGlobalTestPartResultReporter( 52511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestPartResultReporterInterface* reporter); 52611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 52711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns the test part result reporter for the current thread. 52811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestPartResultReporterInterface* GetTestPartResultReporterForCurrentThread(); 52911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 53011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Sets the test part result reporter for the current thread. 53111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void SetTestPartResultReporterForCurrentThread( 53211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestPartResultReporterInterface* reporter); 53311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 53411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Gets the number of successful test cases. 53511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int successful_test_case_count() const; 53611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 53711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Gets the number of failed test cases. 53811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int failed_test_case_count() const; 53911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 54011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Gets the number of all test cases. 54111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int total_test_case_count() const; 54211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 54311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Gets the number of all test cases that contain at least one test 54411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // that should run. 54511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int test_case_to_run_count() const; 54611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 54711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Gets the number of successful tests. 54811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int successful_test_count() const; 54911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 55011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Gets the number of failed tests. 55111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int failed_test_count() const; 55211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 55311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Gets the number of disabled tests. 55411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int disabled_test_count() const; 55511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 55611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Gets the number of all tests. 55711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int total_test_count() const; 55811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 55911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Gets the number of tests that should run. 56011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int test_to_run_count() const; 56111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 56211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Gets the time of the test program start, in ms from the start of the 56311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // UNIX epoch. 56411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TimeInMillis start_timestamp() const { return start_timestamp_; } 56511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 56611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Gets the elapsed time, in milliseconds. 56711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TimeInMillis elapsed_time() const { return elapsed_time_; } 56811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 56911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns true iff the unit test passed (i.e. all test cases passed). 57011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool Passed() const { return !Failed(); } 57111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 57211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns true iff the unit test failed (i.e. some test case failed 57311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // or something outside of all tests failed). 57411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool Failed() const { 57511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return failed_test_case_count() > 0 || ad_hoc_test_result()->Failed(); 57611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 57711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 57811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Gets the i-th test case among all the test cases. i can range from 0 to 57911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // total_test_case_count() - 1. If i is not in that range, returns NULL. 58011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestCase* GetTestCase(int i) const { 58111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int index = GetElementOr(test_case_indices_, i, -1); 58211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return index < 0 ? NULL : test_cases_[i]; 58311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 58411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 58511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Gets the i-th test case among all the test cases. i can range from 0 to 58611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // total_test_case_count() - 1. If i is not in that range, returns NULL. 58711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestCase* GetMutableTestCase(int i) { 58811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int index = GetElementOr(test_case_indices_, i, -1); 58911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return index < 0 ? NULL : test_cases_[index]; 59011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 59111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 59211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Provides access to the event listener list. 59311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListeners* listeners() { return &listeners_; } 59411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 59511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns the TestResult for the test that's currently running, or 59611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the TestResult for the ad hoc test if no test is running. 59711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestResult* current_test_result(); 59811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 59911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns the TestResult for the ad hoc test. 60011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestResult* ad_hoc_test_result() const { return &ad_hoc_test_result_; } 60111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 60211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Sets the OS stack trace getter. 60311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 60411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Does nothing if the input and the current OS stack trace getter 60511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // are the same; otherwise, deletes the old getter and makes the 60611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // input the current getter. 60711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void set_os_stack_trace_getter(OsStackTraceGetterInterface* getter); 60811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 60911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns the current OS stack trace getter if it is not NULL; 61011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // otherwise, creates an OsStackTraceGetter, makes it the current 61111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // getter, and returns it. 61211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert OsStackTraceGetterInterface* os_stack_trace_getter(); 61311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 61411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns the current OS stack trace as an std::string. 61511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 61611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The maximum number of stack frames to be included is specified by 61711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the gtest_stack_trace_depth flag. The skip_count parameter 61811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // specifies the number of top frames to be skipped, which doesn't 61911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // count against the number of frames to be included. 62011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 62111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // For example, if Foo() calls Bar(), which in turn calls 62211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // CurrentOsStackTraceExceptTop(1), Foo() will be included in the 62311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // trace but Bar() and CurrentOsStackTraceExceptTop() won't. 62411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::string CurrentOsStackTraceExceptTop(int skip_count) GTEST_NO_INLINE_; 62511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 62611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Finds and returns a TestCase with the given name. If one doesn't 62711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // exist, creates one and returns it. 62811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 62911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Arguments: 63011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 63111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // test_case_name: name of the test case 63211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // type_param: the name of the test's type parameter, or NULL if 63311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // this is not a typed or a type-parameterized test. 63411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // set_up_tc: pointer to the function that sets up the test case 63511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // tear_down_tc: pointer to the function that tears down the test case 63611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestCase* GetTestCase(const char* test_case_name, 63711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* type_param, 63811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Test::SetUpTestCaseFunc set_up_tc, 63911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Test::TearDownTestCaseFunc tear_down_tc); 64011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 64111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Adds a TestInfo to the unit test. 64211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 64311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Arguments: 64411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 64511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // set_up_tc: pointer to the function that sets up the test case 64611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // tear_down_tc: pointer to the function that tears down the test case 64711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // test_info: the TestInfo object 64811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void AddTestInfo(Test::SetUpTestCaseFunc set_up_tc, 64911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Test::TearDownTestCaseFunc tear_down_tc, 65011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestInfo* test_info) { 65111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // In order to support thread-safe death tests, we need to 65211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // remember the original working directory when the test program 65311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // was first invoked. We cannot do this in RUN_ALL_TESTS(), as 65411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the user may have changed the current directory before calling 65511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // RUN_ALL_TESTS(). Therefore we capture the current directory in 65611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // AddTestInfo(), which is called to register a TEST or TEST_F 65711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // before main() is reached. 65811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (original_working_dir_.IsEmpty()) { 65911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert original_working_dir_.Set(FilePath::GetCurrentDir()); 66011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_CHECK_(!original_working_dir_.IsEmpty()) 66111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "Failed to get the current working directory."; 66211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 66311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 66411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GetTestCase(test_info->test_case_name(), 66511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert test_info->type_param(), 66611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert set_up_tc, 66711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert tear_down_tc)->AddTestInfo(test_info); 66811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 66911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 67011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_PARAM_TEST 67111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns ParameterizedTestCaseRegistry object used to keep track of 67211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // value-parameterized tests and instantiate and register them. 67311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert internal::ParameterizedTestCaseRegistry& parameterized_test_registry() { 67411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return parameterized_test_registry_; 67511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 67611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_PARAM_TEST 67711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 67811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Sets the TestCase object for the test that's currently running. 67911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void set_current_test_case(TestCase* a_current_test_case) { 68011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert current_test_case_ = a_current_test_case; 68111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 68211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 68311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Sets the TestInfo object for the test that's currently running. If 68411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // current_test_info is NULL, the assertion results will be stored in 68511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ad_hoc_test_result_. 68611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void set_current_test_info(TestInfo* a_current_test_info) { 68711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert current_test_info_ = a_current_test_info; 68811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 68911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 69011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Registers all parameterized tests defined using TEST_P and 69111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // INSTANTIATE_TEST_CASE_P, creating regular tests for each test/parameter 69211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // combination. This method can be called more then once; it has guards 69311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // protecting from registering the tests more then once. If 69411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // value-parameterized tests are disabled, RegisterParameterizedTests is 69511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // present but does nothing. 69611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void RegisterParameterizedTests(); 69711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 69811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Runs all tests in this UnitTest object, prints the result, and 69911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // returns true if all tests are successful. If any exception is 70011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // thrown during a test, this test is considered to be failed, but 70111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the rest of the tests will still be run. 70211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool RunAllTests(); 70311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 70411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Clears the results of all tests, except the ad hoc tests. 70511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void ClearNonAdHocTestResult() { 70611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ForEach(test_cases_, TestCase::ClearTestCaseResult); 70711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 70811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 70911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Clears the results of ad-hoc test assertions. 71011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void ClearAdHocTestResult() { 71111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ad_hoc_test_result_.Clear(); 71211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 71311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 71411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Adds a TestProperty to the current TestResult object when invoked in a 71511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // context of a test or a test case, or to the global property set. If the 71611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // result already contains a property with the same key, the value will be 71711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // updated. 71811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void RecordProperty(const TestProperty& test_property); 71911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 72011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert enum ReactionToSharding { 72111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert HONOR_SHARDING_PROTOCOL, 72211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert IGNORE_SHARDING_PROTOCOL 72311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 72411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 72511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Matches the full name of each test against the user-specified 72611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // filter to decide whether the test should run, then records the 72711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // result in each TestCase and TestInfo object. 72811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // If shard_tests == HONOR_SHARDING_PROTOCOL, further filters tests 72911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // based on sharding variables in the environment. 73011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns the number of tests that should run. 73111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int FilterTests(ReactionToSharding shard_tests); 73211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 73311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Prints the names of the tests matching the user-specified filter flag. 73411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void ListTestsMatchingFilter(); 73511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 73611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestCase* current_test_case() const { return current_test_case_; } 73711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestInfo* current_test_info() { return current_test_info_; } 73811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestInfo* current_test_info() const { return current_test_info_; } 73911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 74011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns the vector of environments that need to be set-up/torn-down 74111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // before/after the tests are run. 74211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::vector<Environment*>& environments() { return environments_; } 74311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 74411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Getters for the per-thread Google Test trace stack. 74511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::vector<TraceInfo>& gtest_trace_stack() { 74611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *(gtest_trace_stack_.pointer()); 74711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 74811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const std::vector<TraceInfo>& gtest_trace_stack() const { 74911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return gtest_trace_stack_.get(); 75011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 75111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 75211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_DEATH_TEST 75311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void InitDeathTestSubprocessControlInfo() { 75411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag()); 75511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 75611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns a pointer to the parsed --gtest_internal_run_death_test 75711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // flag, or NULL if that flag was not specified. 75811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This information is useful only in a death test child process. 75911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Must not be called before a call to InitGoogleTest. 76011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const InternalRunDeathTestFlag* internal_run_death_test_flag() const { 76111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return internal_run_death_test_flag_.get(); 76211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 76311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 76411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns a pointer to the current death test factory. 76511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert internal::DeathTestFactory* death_test_factory() { 76611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return death_test_factory_.get(); 76711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 76811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 76911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void SuppressTestEventsIfInSubprocess(); 77011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 77111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert friend class ReplaceDeathTestFactory; 77211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_DEATH_TEST 77311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 77411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Initializes the event listener performing XML output as specified by 77511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // UnitTestOptions. Must not be called before InitGoogleTest. 77611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void ConfigureXmlOutput(); 77711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 77811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_CAN_STREAM_RESULTS_ 77911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Initializes the event listener for streaming test results to a socket. 78011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Must not be called before InitGoogleTest. 78111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void ConfigureStreamingOutput(); 78211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 78311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 78411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Performs initialization dependent upon flag values obtained in 78511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ParseGoogleTestFlagsOnly. Is called from InitGoogleTest after the call to 78611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ParseGoogleTestFlagsOnly. In case a user neglects to call InitGoogleTest 78711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // this function is also called from RunAllTests. Since this function can be 78811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // called more than once, it has to be idempotent. 78911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void PostFlagParsingInit(); 79011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 79111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Gets the random seed used at the start of the current test iteration. 79211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int random_seed() const { return random_seed_; } 79311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 79411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Gets the random number generator. 79511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert internal::Random* random() { return &random_; } 79611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 79711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Shuffles all test cases, and the tests within each test case, 79811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // making sure that death tests are still run first. 79911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void ShuffleTests(); 80011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 80111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Restores the test cases and tests to their order before the first shuffle. 80211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void UnshuffleTests(); 80311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 80411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns the value of GTEST_FLAG(catch_exceptions) at the moment 80511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // UnitTest::Run() starts. 80611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool catch_exceptions() const { return catch_exceptions_; } 80711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 80811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 80911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert friend class ::testing::UnitTest; 81011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 81111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Used by UnitTest::Run() to capture the state of 81211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // GTEST_FLAG(catch_exceptions) at the moment it starts. 81311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void set_catch_exceptions(bool value) { catch_exceptions_ = value; } 81411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 81511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The UnitTest object that owns this implementation object. 81611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert UnitTest* const parent_; 81711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 81811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The working directory when the first TEST() or TEST_F() was 81911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // executed. 82011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert internal::FilePath original_working_dir_; 82111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 82211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The default test part result reporters. 82311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DefaultGlobalTestPartResultReporter default_global_test_part_result_reporter_; 82411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DefaultPerThreadTestPartResultReporter 82511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert default_per_thread_test_part_result_reporter_; 82611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 82711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Points to (but doesn't own) the global test part result reporter. 82811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestPartResultReporterInterface* global_test_part_result_repoter_; 82911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 83011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Protects read and write access to global_test_part_result_reporter_. 83111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert internal::Mutex global_test_part_result_reporter_mutex_; 83211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 83311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Points to (but doesn't own) the per-thread test part result reporter. 83411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert internal::ThreadLocal<TestPartResultReporterInterface*> 83511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert per_thread_test_part_result_reporter_; 83611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 83711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The vector of environments that need to be set-up/torn-down 83811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // before/after the tests are run. 83911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::vector<Environment*> environments_; 84011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 84111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The vector of TestCases in their original order. It owns the 84211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // elements in the vector. 84311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::vector<TestCase*> test_cases_; 84411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 84511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Provides a level of indirection for the test case list to allow 84611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // easy shuffling and restoring the test case order. The i-th 84711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // element of this vector is the index of the i-th test case in the 84811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // shuffled order. 84911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::vector<int> test_case_indices_; 85011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 85111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_PARAM_TEST 85211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ParameterizedTestRegistry object used to register value-parameterized 85311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // tests. 85411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert internal::ParameterizedTestCaseRegistry parameterized_test_registry_; 85511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 85611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Indicates whether RegisterParameterizedTests() has been called already. 85711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool parameterized_tests_registered_; 85811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_PARAM_TEST 85911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 86011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Index of the last death test case registered. Initially -1. 86111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int last_death_test_case_; 86211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 86311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This points to the TestCase for the currently running test. It 86411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // changes as Google Test goes through one test case after another. 86511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // When no test is running, this is set to NULL and Google Test 86611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // stores assertion results in ad_hoc_test_result_. Initially NULL. 86711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestCase* current_test_case_; 86811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 86911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This points to the TestInfo for the currently running test. It 87011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // changes as Google Test goes through one test after another. When 87111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // no test is running, this is set to NULL and Google Test stores 87211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // assertion results in ad_hoc_test_result_. Initially NULL. 87311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestInfo* current_test_info_; 87411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 87511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Normally, a user only writes assertions inside a TEST or TEST_F, 87611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // or inside a function called by a TEST or TEST_F. Since Google 87711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Test keeps track of which test is current running, it can 87811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // associate such an assertion with the test it belongs to. 87911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 88011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // If an assertion is encountered when no TEST or TEST_F is running, 88111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Google Test attributes the assertion result to an imaginary "ad hoc" 88211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // test, and records the result in ad_hoc_test_result_. 88311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestResult ad_hoc_test_result_; 88411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 88511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The list of event listeners that can be used to track events inside 88611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Google Test. 88711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListeners listeners_; 88811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 88911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The OS stack trace getter. Will be deleted when the UnitTest 89011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // object is destructed. By default, an OsStackTraceGetter is used, 89111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // but the user can set this field to use a custom getter if that is 89211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // desired. 89311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert OsStackTraceGetterInterface* os_stack_trace_getter_; 89411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 89511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // True iff PostFlagParsingInit() has been called. 89611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool post_flag_parse_init_performed_; 89711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 89811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The random number seed used at the beginning of the test run. 89911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int random_seed_; 90011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 90111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Our random number generator. 90211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert internal::Random random_; 90311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 90411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The time of the test program start, in ms from the start of the 90511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // UNIX epoch. 90611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TimeInMillis start_timestamp_; 90711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 90811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // How long the test took to run, in milliseconds. 90911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TimeInMillis elapsed_time_; 91011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 91111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_DEATH_TEST 91211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The decomposed components of the gtest_internal_run_death_test flag, 91311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // parsed when RUN_ALL_TESTS is called. 91411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert internal::scoped_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_; 91511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert internal::scoped_ptr<internal::DeathTestFactory> death_test_factory_; 91611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_DEATH_TEST 91711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 91811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A per-thread stack of traces created by the SCOPED_TRACE() macro. 91911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert internal::ThreadLocal<std::vector<TraceInfo> > gtest_trace_stack_; 92011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 92111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The value of GTEST_FLAG(catch_exceptions) at the moment RunAllTests() 92211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // starts. 92311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool catch_exceptions_; 92411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 92511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl); 92611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; // class UnitTestImpl 92711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 92811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Convenience function for accessing the global UnitTest 92911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// implementation object. 93011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline UnitTestImpl* GetUnitTestImpl() { 93111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return UnitTest::GetInstance()->impl(); 93211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 93311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 93411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_USES_SIMPLE_RE 93511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 93611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Internal helper functions for implementing the simple regular 93711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// expression matcher. 93811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ bool IsInSet(char ch, const char* str); 93911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ bool IsAsciiDigit(char ch); 94011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ bool IsAsciiPunct(char ch); 94111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ bool IsRepeat(char ch); 94211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ bool IsAsciiWhiteSpace(char ch); 94311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ bool IsAsciiWordChar(char ch); 94411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ bool IsValidEscape(char ch); 94511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ bool AtomMatchesChar(bool escaped, char pattern, char ch); 94611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ bool ValidateRegex(const char* regex); 94711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ bool MatchRegexAtHead(const char* regex, const char* str); 94811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ bool MatchRepetitionAndRegexAtHead( 94911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool escaped, char ch, char repeat, const char* regex, const char* str); 95011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str); 95111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 95211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_USES_SIMPLE_RE 95311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 95411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Parses the command line for Google Test flags, without initializing 95511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// other parts of Google Test. 95611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, char** argv); 95711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv); 95811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 95911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_DEATH_TEST 96011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 96111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Returns the message describing the last system error, regardless of the 96211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// platform. 96311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ std::string GetLastErrnoDescription(); 96411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 96511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_WINDOWS 96611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Provides leak-safe Windows kernel handle ownership. 96711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass AutoHandle { 96811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 96911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AutoHandle() : handle_(INVALID_HANDLE_VALUE) {} 97011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert explicit AutoHandle(HANDLE handle) : handle_(handle) {} 97111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 97211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ~AutoHandle() { Reset(); } 97311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 97411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert HANDLE Get() const { return handle_; } 97511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void Reset() { Reset(INVALID_HANDLE_VALUE); } 97611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void Reset(HANDLE handle) { 97711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (handle != handle_) { 97811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (handle_ != INVALID_HANDLE_VALUE) 97911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ::CloseHandle(handle_); 98011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert handle_ = handle; 98111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 98211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 98311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 98411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 98511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert HANDLE handle_; 98611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 98711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle); 98811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 98911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_OS_WINDOWS 99011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 99111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Attempts to parse a string into a positive integer pointed to by the 99211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// number parameter. Returns true if that is possible. 99311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can use 99411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// it here. 99511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename Integer> 99611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbool ParseNaturalNumber(const ::std::string& str, Integer* number) { 99711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Fail fast if the given string does not begin with a digit; 99811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // this bypasses strtoXXX's "optional leading whitespace and plus 99911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // or minus sign" semantics, which are undesirable here. 100011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (str.empty() || !IsDigit(str[0])) { 100111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return false; 100211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 100311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert errno = 0; 100411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 100511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char* end; 100611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // BiggestConvertible is the largest integer type that system-provided 100711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // string-to-number conversion routines can return. 100811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 100911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_WINDOWS && !defined(__GNUC__) 101011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 101111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // MSVC and C++ Builder define __int64 instead of the standard long long. 101211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef unsigned __int64 BiggestConvertible; 101311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const BiggestConvertible parsed = _strtoui64(str.c_str(), &end, 10); 101411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 101511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 101611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 101711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef unsigned long long BiggestConvertible; // NOLINT 101811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10); 101911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 102011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_OS_WINDOWS && !defined(__GNUC__) 102111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 102211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const bool parse_success = *end == '\0' && errno == 0; 102311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 102411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // TODO(vladl@google.com): Convert this to compile time assertion when it is 102511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // available. 102611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed)); 102711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 102811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const Integer result = static_cast<Integer>(parsed); 102911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (parse_success && static_cast<BiggestConvertible>(result) == parsed) { 103011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *number = result; 103111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return true; 103211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 103311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return false; 103411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 103511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_DEATH_TEST 103611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 103711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// TestResult contains some private methods that should be hidden from 103811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Google Test user but are required for testing. This class allow our tests 103911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// to access them. 104011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 104111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This class is supplied only for the purpose of testing Google Test's own 104211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// constructs. Do not use it in user tests, either directly or indirectly. 104311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass TestResultAccessor { 104411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 104511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void RecordProperty(TestResult* test_result, 104611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const std::string& xml_element, 104711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestProperty& property) { 104811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert test_result->RecordProperty(xml_element, property); 104911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 105011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 105111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void ClearTestPartResults(TestResult* test_result) { 105211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert test_result->ClearTestPartResults(); 105311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 105411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 105511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const std::vector<testing::TestPartResult>& test_part_results( 105611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestResult& test_result) { 105711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return test_result.test_part_results(); 105811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 105911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 106011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 106111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_CAN_STREAM_RESULTS_ 106211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 106311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Streams test results to the given port on the given host machine. 106411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass StreamingListener : public EmptyTestEventListener { 106511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 106611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Abstract base class for writing strings to a socket. 106711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert class AbstractSocketWriter { 106811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 106911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual ~AbstractSocketWriter() {} 107011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 107111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Sends a string to the socket. 107211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void Send(const string& message) = 0; 107311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 107411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Closes the socket. 107511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void CloseConnection() {} 107611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 107711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Sends a string and a newline to the socket. 107811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void SendLn(const string& message) { 107911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Send(message + "\n"); 108011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 108111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 108211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 108311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Concrete class for actually writing strings to a socket. 108411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert class SocketWriter : public AbstractSocketWriter { 108511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 108611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SocketWriter(const string& host, const string& port) 108711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : sockfd_(-1), host_name_(host), port_num_(port) { 108811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert MakeConnection(); 108911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 109011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 109111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual ~SocketWriter() { 109211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (sockfd_ != -1) 109311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CloseConnection(); 109411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 109511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 109611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Sends a string to the socket. 109711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void Send(const string& message) { 109811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_CHECK_(sockfd_ != -1) 109911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "Send() can be called only when there is a connection."; 110011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 110111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int len = static_cast<int>(message.length()); 110211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (write(sockfd_, message.c_str(), len) != len) { 110311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_LOG_(WARNING) 110411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "stream_result_to: failed to stream to " 110511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << host_name_ << ":" << port_num_; 110611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 110711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 110811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 110911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 111011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Creates a client socket and connects to the server. 111111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void MakeConnection(); 111211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 111311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Closes the socket. 111411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void CloseConnection() { 111511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_CHECK_(sockfd_ != -1) 111611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "CloseConnection() can be called only when there is a connection."; 111711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 111811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert close(sockfd_); 111911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sockfd_ = -1; 112011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 112111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 112211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int sockfd_; // socket file descriptor 112311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const string host_name_; 112411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const string port_num_; 112511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 112611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_DISALLOW_COPY_AND_ASSIGN_(SocketWriter); 112711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; // class SocketWriter 112811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 112911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Escapes '=', '&', '%', and '\n' characters in str as "%xx". 113011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static string UrlEncode(const char* str); 113111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 113211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert StreamingListener(const string& host, const string& port) 113311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : socket_writer_(new SocketWriter(host, port)) { Start(); } 113411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 113511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert explicit StreamingListener(AbstractSocketWriter* socket_writer) 113611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : socket_writer_(socket_writer) { Start(); } 113711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 113811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void OnTestProgramStart(const UnitTest& /* unit_test */) { 113911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SendLn("event=TestProgramStart"); 114011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 114111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 114211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void OnTestProgramEnd(const UnitTest& unit_test) { 114311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Note that Google Test current only report elapsed time for each 114411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // test iteration, not for the entire test program. 114511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed())); 114611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 114711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Notify the streaming server to stop. 114811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert socket_writer_->CloseConnection(); 114911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 115011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 115111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void OnTestIterationStart(const UnitTest& /* unit_test */, int iteration) { 115211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SendLn("event=TestIterationStart&iteration=" + 115311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert StreamableToString(iteration)); 115411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 115511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 115611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration */) { 115711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SendLn("event=TestIterationEnd&passed=" + 115811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FormatBool(unit_test.Passed()) + "&elapsed_time=" + 115911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert StreamableToString(unit_test.elapsed_time()) + "ms"); 116011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 116111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 116211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void OnTestCaseStart(const TestCase& test_case) { 116311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SendLn(std::string("event=TestCaseStart&name=") + test_case.name()); 116411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 116511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 116611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void OnTestCaseEnd(const TestCase& test_case) { 116711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed()) 116811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert + "&elapsed_time=" + StreamableToString(test_case.elapsed_time()) 116911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert + "ms"); 117011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 117111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 117211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void OnTestStart(const TestInfo& test_info) { 117311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SendLn(std::string("event=TestStart&name=") + test_info.name()); 117411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 117511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 117611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void OnTestEnd(const TestInfo& test_info) { 117711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SendLn("event=TestEnd&passed=" + 117811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FormatBool((test_info.result())->Passed()) + 117911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "&elapsed_time=" + 118011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert StreamableToString((test_info.result())->elapsed_time()) + "ms"); 118111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 118211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 118311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void OnTestPartResult(const TestPartResult& test_part_result) { 118411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* file_name = test_part_result.file_name(); 118511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (file_name == NULL) 118611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert file_name = ""; 118711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SendLn("event=TestPartResult&file=" + UrlEncode(file_name) + 118811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "&line=" + StreamableToString(test_part_result.line_number()) + 118911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "&message=" + UrlEncode(test_part_result.message())); 119011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 119111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 119211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 119311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Sends the given message and a newline to the socket. 119411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void SendLn(const string& message) { socket_writer_->SendLn(message); } 119511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 119611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Called at the start of streaming to notify the receiver what 119711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // protocol we are using. 119811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void Start() { SendLn("gtest_streaming_protocol_version=1.0"); } 119911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 120011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert string FormatBool(bool value) { return value ? "1" : "0"; } 120111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 120211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const scoped_ptr<AbstractSocketWriter> socket_writer_; 120311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 120411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener); 120511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; // class StreamingListener 120611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 120711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_CAN_STREAM_RESULTS_ 120811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 120911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} // namespace internal 121011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} // namespace testing 121111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 121211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_SRC_GTEST_INTERNAL_INL_H_ 1213