gtest-internal-inl.h revision fbaaef999ba563838ebd00874ed8a1c01fbf286d
1fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Copyright 2005, Google Inc. 2fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// All rights reserved. 3fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 4fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Redistribution and use in source and binary forms, with or without 5fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// modification, are permitted provided that the following conditions are 6fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// met: 7fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 8fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * Redistributions of source code must retain the above copyright 9fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// notice, this list of conditions and the following disclaimer. 10fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * Redistributions in binary form must reproduce the above 11fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// copyright notice, this list of conditions and the following disclaimer 12fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// in the documentation and/or other materials provided with the 13fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// distribution. 14fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * Neither the name of Google Inc. nor the names of its 15fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// contributors may be used to endorse or promote products derived from 16fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// this software without specific prior written permission. 17fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 18fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 30fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Utility functions and classes used by the Google C++ testing framework. 31fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 32fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Author: wan@google.com (Zhanyong Wan) 33fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 34fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This file contains purely Google Test's internal implementation. Please 35fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// DO NOT #INCLUDE IT IN A USER PROGRAM. 36fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 37fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifndef GTEST_SRC_GTEST_INTERNAL_INL_H_ 38fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_SRC_GTEST_INTERNAL_INL_H_ 39fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 40fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_IMPLEMENTATION_ is defined to 1 iff the current translation unit is 41fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// part of Google Test's implementation; otherwise it's undefined. 42fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if !GTEST_IMPLEMENTATION_ 43fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A user is trying to include this from his code - just say no. 44fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#error "gtest-internal-inl.h is part of Google Test's internal implementation." 45fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#error "It must not be included except by Google Test itself." 46fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_IMPLEMENTATION_ 47fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 48fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifndef _WIN32_WCE 49fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <errno.h> 50fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // !_WIN32_WCE 51fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <stddef.h> 52fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <stdlib.h> // For strtoll/_strtoul64/malloc/free. 53fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <string.h> // For memmove. 54fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 55fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <string> 56fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 57fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <gtest/internal/gtest-port.h> 58fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 59fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_OS_WINDOWS 60fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <windows.h> // For DWORD. 61fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_OS_WINDOWS 62fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 63fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <gtest/gtest.h> 64fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <gtest/gtest-spi.h> 65fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 66fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace testing { 67fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 68fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Declares the flags. 69fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 70fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// We don't want the users to modify this flag in the code, but want 71fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Google Test's own unit tests to be able to access it. Therefore we 72fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// declare it here as opposed to in gtest.h. 73fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleGTEST_DECLARE_bool_(death_test_use_fork); 74fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 75fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace internal { 76fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 77fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The value of GetTestTypeId() as seen from within the Google Test 78fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// library. This is solely for testing GetTestTypeId(). 79fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleextern const TypeId kTestTypeIdInGoogleTest; 80fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 81fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Names of the flags (needed for parsing Google Test flags). 82fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests"; 83fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst char kBreakOnFailureFlag[] = "break_on_failure"; 84fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst char kCatchExceptionsFlag[] = "catch_exceptions"; 85fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst char kColorFlag[] = "color"; 86fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst char kFilterFlag[] = "filter"; 87fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst char kListTestsFlag[] = "list_tests"; 88fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst char kOutputFlag[] = "output"; 89fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst char kPrintTimeFlag[] = "print_time"; 90fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst char kRandomSeedFlag[] = "random_seed"; 91fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst char kRepeatFlag[] = "repeat"; 92fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst char kShuffleFlag[] = "shuffle"; 93fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst char kThrowOnFailureFlag[] = "throw_on_failure"; 94fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 95fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A valid random seed must be in [1, kMaxRandomSeed]. 96fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst int kMaxRandomSeed = 99999; 97fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 98fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Returns the current time in milliseconds. 99fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTimeInMillis GetTimeInMillis(); 100fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 101fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Returns a random seed in range [1, kMaxRandomSeed] based on the 102fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// given --gtest_random_seed flag value. 103fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int GetRandomSeedFromFlag(Int32 random_seed_flag) { 104fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const unsigned int raw_seed = (random_seed_flag == 0) ? 105fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static_cast<unsigned int>(GetTimeInMillis()) : 106fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static_cast<unsigned int>(random_seed_flag); 107fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 108fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Normalizes the actual seed to range [1, kMaxRandomSeed] such that 109fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // it's easy to type. 110fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int normalized_seed = 111fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static_cast<int>((raw_seed - 1U) % 112fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static_cast<unsigned int>(kMaxRandomSeed)) + 1; 113fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return normalized_seed; 114fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 115fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 116fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Returns the first valid random seed after 'seed'. The behavior is 117fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// undefined if 'seed' is invalid. The seed after kMaxRandomSeed is 118fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// considered to be 1. 119fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int GetNextRandomSeed(int seed) { 120fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed) 121fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "Invalid random seed " << seed << " - must be in [1, " 122fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << kMaxRandomSeed << "]."; 123fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int next_seed = seed + 1; 124fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return (next_seed > kMaxRandomSeed) ? 1 : next_seed; 125fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 126fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 127fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This class saves the values of all Google Test flags in its c'tor, and 128fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// restores them in its d'tor. 129fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass GTestFlagSaver { 130fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 131fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The c'tor. 132fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTestFlagSaver() { 133fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests); 134fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville break_on_failure_ = GTEST_FLAG(break_on_failure); 135fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville catch_exceptions_ = GTEST_FLAG(catch_exceptions); 136fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville color_ = GTEST_FLAG(color); 137fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville death_test_style_ = GTEST_FLAG(death_test_style); 138fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville death_test_use_fork_ = GTEST_FLAG(death_test_use_fork); 139fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville filter_ = GTEST_FLAG(filter); 140fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal_run_death_test_ = GTEST_FLAG(internal_run_death_test); 141fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville list_tests_ = GTEST_FLAG(list_tests); 142fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville output_ = GTEST_FLAG(output); 143fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville print_time_ = GTEST_FLAG(print_time); 144fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville random_seed_ = GTEST_FLAG(random_seed); 145fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville repeat_ = GTEST_FLAG(repeat); 146fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville shuffle_ = GTEST_FLAG(shuffle); 147fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville throw_on_failure_ = GTEST_FLAG(throw_on_failure); 148fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 149fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 150fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The d'tor is not virtual. DO NOT INHERIT FROM THIS CLASS. 151fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~GTestFlagSaver() { 152fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_; 153fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_FLAG(break_on_failure) = break_on_failure_; 154fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_FLAG(catch_exceptions) = catch_exceptions_; 155fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_FLAG(color) = color_; 156fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_FLAG(death_test_style) = death_test_style_; 157fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_FLAG(death_test_use_fork) = death_test_use_fork_; 158fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_FLAG(filter) = filter_; 159fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_FLAG(internal_run_death_test) = internal_run_death_test_; 160fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_FLAG(list_tests) = list_tests_; 161fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_FLAG(output) = output_; 162fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_FLAG(print_time) = print_time_; 163fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_FLAG(random_seed) = random_seed_; 164fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_FLAG(repeat) = repeat_; 165fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_FLAG(shuffle) = shuffle_; 166fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_FLAG(throw_on_failure) = throw_on_failure_; 167fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 168fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 169fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Fields for saving the original values of flags. 170fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool also_run_disabled_tests_; 171fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool break_on_failure_; 172fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool catch_exceptions_; 173fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville String color_; 174fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville String death_test_style_; 175fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool death_test_use_fork_; 176fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville String filter_; 177fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville String internal_run_death_test_; 178fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool list_tests_; 179fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville String output_; 180fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool print_time_; 181fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool pretty_; 182fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::Int32 random_seed_; 183fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::Int32 repeat_; 184fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool shuffle_; 185fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool throw_on_failure_; 186fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} GTEST_ATTRIBUTE_UNUSED_; 187fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 188fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Converts a Unicode code point to a narrow string in UTF-8 encoding. 189fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// code_point parameter is of type UInt32 because wchar_t may not be 190fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// wide enough to contain a code point. 191fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The output buffer str must containt at least 32 characters. 192fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The function returns the address of the output buffer. 193fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// If the code_point is not a valid Unicode code point 194fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be output 195fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// as '(Invalid Unicode 0xXXXXXXXX)'. 196fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillechar* CodePointToUtf8(UInt32 code_point, char* str); 197fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 198fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Converts a wide string to a narrow string in UTF-8 encoding. 199fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The wide string is assumed to have the following encoding: 200fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin, Symbian OS) 201fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// UTF-32 if sizeof(wchar_t) == 4 (on Linux) 202fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Parameter str points to a null-terminated wide string. 203fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Parameter num_chars may additionally limit the number 204fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// of wchar_t characters processed. -1 is used when the entire string 205fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// should be processed. 206fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// If the string contains code points that are not valid Unicode code points 207fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output 208fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding 209fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// and contains invalid UTF-16 surrogate pairs, values in those pairs 210fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// will be encoded as individual Unicode characters from Basic Normal Plane. 211fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleString WideStringToUtf8(const wchar_t* str, int num_chars); 212fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 213fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Returns the number of active threads, or 0 when there is an error. 214fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillesize_t GetThreadCount(); 215fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 216fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file 217fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// if the variable is present. If a file already exists at this location, this 218fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// function will write over it. If the variable is present, but the file cannot 219fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// be created, prints an error and exits. 220fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillevoid WriteToShardStatusFileIfNeeded(); 221fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 222fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Checks whether sharding is enabled by examining the relevant 223fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// environment variable values. If the variables are present, 224fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// but inconsistent (e.g., shard_index >= total_shards), prints 225fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// an error and exits. If in_subprocess_for_death_test, sharding is 226fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// disabled because it must only be applied to the original test 227fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// process. Otherwise, we could filter out death tests we intended to execute. 228fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillebool ShouldShard(const char* total_shards_str, const char* shard_index_str, 229fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool in_subprocess_for_death_test); 230fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 231fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Parses the environment variable var as an Int32. If it is unset, 232fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// returns default_val. If it is not an Int32, prints an error and 233fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// and aborts. 234fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleInt32 Int32FromEnvOrDie(const char* env_var, Int32 default_val); 235fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 236fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Given the total number of shards, the shard index, and the test id, 237fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// returns true iff the test should be run on this shard. The test id is 238fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// some arbitrary but unique non-negative integer assigned to each test 239fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// method. Assumes that 0 <= shard_index < total_shards. 240fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillebool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id); 241fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 242fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Vector is an ordered container that supports random access to the 243fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// elements. 244fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 245fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// We cannot use std::vector, as Visual C++ 7.1's implementation of 246fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// STL has problems compiling when exceptions are disabled. There is 247fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// a hack to work around the problems, but we've seen cases where the 248fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// hack fails to work. 249fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 250fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The element type must support copy constructor and operator=. 251fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename E> // E is the element type. 252fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass Vector { 253fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 254fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Creates an empty Vector. 255fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Vector() : elements_(NULL), capacity_(0), size_(0) {} 256fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 257fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // D'tor. 258fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual ~Vector() { Clear(); } 259fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 260fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Clears the Vector. 261fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void Clear() { 262fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (elements_ != NULL) { 263fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville for (int i = 0; i < size_; i++) { 264fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville delete elements_[i]; 265fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 266fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 267fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville free(elements_); 268fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville elements_ = NULL; 269fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville capacity_ = size_ = 0; 270fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 271fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 272fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 273fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of elements. 274fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int size() const { return size_; } 275fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 276fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Adds an element to the end of the Vector. A copy of the element 277fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // is created using the copy constructor, and then stored in the 278fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Vector. Changes made to the element in the Vector doesn't affect 279fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // the source object, and vice versa. 280fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void PushBack(const E & element) { Insert(element, size_); } 281fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 282fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Adds an element to the beginning of this Vector. 283fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void PushFront(const E& element) { Insert(element, 0); } 284fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 285fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Removes an element from the beginning of this Vector. If the 286fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // result argument is not NULL, the removed element is stored in the 287fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // memory it points to. Otherwise the element is thrown away. 288fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff the vector wasn't empty before the operation. 289fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool PopFront(E* result) { 290fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (size_ == 0) 291fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return false; 292fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 293fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (result != NULL) 294fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville *result = GetElement(0); 295fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 296fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Erase(0); 297fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return true; 298fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 299fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 300fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Inserts an element at the given index. It's the caller's 301fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // responsibility to ensure that the given index is in the range [0, 302fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // size()]. 303fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void Insert(const E& element, int index) { 304fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GrowIfNeeded(); 305fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville MoveElements(index, size_ - index, index + 1); 306fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville elements_[index] = new E(element); 307fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville size_++; 308fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 309fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 310fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Erases the element at the specified index, or aborts the program if the 311fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // index is not in range [0, size()). 312fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void Erase(int index) { 313fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_CHECK_(0 <= index && index < size_) 314fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "Invalid Vector index " << index << ": must be in range [0, " 315fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << (size_ - 1) << "]."; 316fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 317fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville delete elements_[index]; 318fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville MoveElements(index + 1, size_ - index - 1, index); 319fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville size_--; 320fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 321fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 322fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the number of elements that satisfy a given predicate. 323fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The parameter 'predicate' is a Boolean function or functor that 324fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // accepts a 'const E &', where E is the element type. 325fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville template <typename P> // P is the type of the predicate function/functor 326fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int CountIf(P predicate) const { 327fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int count = 0; 328fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville for (int i = 0; i < size_; i++) { 329fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (predicate(*(elements_[i]))) { 330fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville count++; 331fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 332fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 333fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 334fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return count; 335fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 336fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 337fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Applies a function/functor to each element in the Vector. The 338fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // parameter 'functor' is a function/functor that accepts a 'const 339fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // E &', where E is the element type. This method does not change 340fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // the elements. 341fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville template <typename F> // F is the type of the function/functor 342fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void ForEach(F functor) const { 343fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville for (int i = 0; i < size_; i++) { 344fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville functor(*(elements_[i])); 345fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 346fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 347fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 348fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the first node whose element satisfies a given predicate, 349fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // or NULL if none is found. The parameter 'predicate' is a 350fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // function/functor that accepts a 'const E &', where E is the 351fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // element type. This method does not change the elements. 352fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville template <typename P> // P is the type of the predicate function/functor. 353fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const E* FindIf(P predicate) const { 354fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville for (int i = 0; i < size_; i++) { 355fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (predicate(*elements_[i])) { 356fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return elements_[i]; 357fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 358fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 359fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return NULL; 360fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 361fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 362fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville template <typename P> 363fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville E* FindIf(P predicate) { 364fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville for (int i = 0; i < size_; i++) { 365fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (predicate(*elements_[i])) { 366fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return elements_[i]; 367fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 368fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 369fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return NULL; 370fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 371fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 372fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the i-th element of the list, or aborts the program if i 373fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // is not in range [0, size()). 374fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const E& GetElement(int i) const { 375fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_CHECK_(0 <= i && i < size_) 376fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "Invalid Vector index " << i << ": must be in range [0, " 377fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << (size_ - 1) << "]."; 378fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 379fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return *(elements_[i]); 380fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 381fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 382fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the i-th element of the list, or default_value if i is not 383fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // in range [0, size()). 384fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville E GetElementOr(int i, E default_value) const { 385fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return (i < 0 || i >= size_) ? default_value : *(elements_[i]); 386fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 387fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 388fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 389fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Grows the buffer if it is not big enough to hold one more element. 390fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void GrowIfNeeded() { 391fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (size_ < capacity_) 392fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return; 393fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 394fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Exponential bump-up is necessary to ensure that inserting N 395fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // elements is O(N) instead of O(N^2). The factor 3/2 means that 396fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // no more than 1/3 of the slots are wasted. 397fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int new_capacity = 3*(capacity_/2 + 1); 398fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_CHECK_(new_capacity > capacity_) // Does the new capacity overflow? 399fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "Cannot grow a Vector with " << capacity_ << " elements already."; 400fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville capacity_ = new_capacity; 401fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville elements_ = static_cast<E**>( 402fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville realloc(elements_, capacity_*sizeof(elements_[0]))); 403fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 404fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 405fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Moves the give consecutive elements to a new index in the Vector. 406fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void MoveElements(int source, int count, int dest) { 407fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville memmove(elements_ + dest, elements_ + source, count*sizeof(elements_[0])); 408fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 409fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 410fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville E** elements_; 411fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int capacity_; // The number of elements allocated for elements_. 412fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int size_; // The number of elements; in the range [0, capacity_]. 413fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 414fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // We disallow copying Vector. 415fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_DISALLOW_COPY_AND_ASSIGN_(Vector); 416fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; // class Vector 417fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 418fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A function for deleting an object. Handy for being used as a 419fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// functor. 420fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename T> 421fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillestatic void Delete(T * x) { 422fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville delete x; 423fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 424fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 425fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A predicate that checks the key of a TestProperty against a known key. 426fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 427fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// TestPropertyKeyIs is copyable. 428fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass TestPropertyKeyIs { 429fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 430fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Constructor. 431fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 432fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // TestPropertyKeyIs has NO default constructor. 433fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville explicit TestPropertyKeyIs(const char* key) 434fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville : key_(key) {} 435fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 436fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff the test name of test property matches on key_. 437fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool operator()(const TestProperty& test_property) const { 438fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return String(test_property.key()).Compare(key_) == 0; 439fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 440fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 441fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 442fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville String key_; 443fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 444fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 445fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass TestInfoImpl { 446fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 447fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestInfoImpl(TestInfo* parent, const char* test_case_name, 448fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* name, const char* test_case_comment, 449fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* comment, TypeId fixture_class_id, 450fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::TestFactoryBase* factory); 451fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~TestInfoImpl(); 452fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 453fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true if this test should run. 454fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool should_run() const { return should_run_; } 455fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 456fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Sets the should_run member. 457fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void set_should_run(bool should) { should_run_ = should; } 458fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 459fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true if this test is disabled. Disabled tests are not run. 460fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool is_disabled() const { return is_disabled_; } 461fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 462fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Sets the is_disabled member. 463fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void set_is_disabled(bool is) { is_disabled_ = is; } 464fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 465fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true if this test matches the filter specified by the user. 466fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool matches_filter() const { return matches_filter_; } 467fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 468fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Sets the matches_filter member. 469fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void set_matches_filter(bool matches) { matches_filter_ = matches; } 470fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 471fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the test case name. 472fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* test_case_name() const { return test_case_name_.c_str(); } 473fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 474fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the test name. 475fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* name() const { return name_.c_str(); } 476fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 477fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the test case comment. 478fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* test_case_comment() const { return test_case_comment_.c_str(); } 479fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 480fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the test comment. 481fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* comment() const { return comment_.c_str(); } 482fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 483fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the ID of the test fixture class. 484fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TypeId fixture_class_id() const { return fixture_class_id_; } 485fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 486fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the test result. 487fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestResult* result() { return &result_; } 488fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const TestResult* result() const { return &result_; } 489fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 490fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Creates the test object, runs it, records its result, and then 491fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // deletes it. 492fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void Run(); 493fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 494fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Calls the given TestInfo object's Run() method. 495fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static void RunTest(TestInfo * test_info) { 496fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_info->impl()->Run(); 497fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 498fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 499fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Clears the test result. 500fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void ClearResult() { result_.Clear(); } 501fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 502fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Clears the test result in the given TestInfo object. 503fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static void ClearTestResult(TestInfo * test_info) { 504fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_info->impl()->ClearResult(); 505fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 506fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 507fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 508fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // These fields are immutable properties of the test. 509fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestInfo* const parent_; // The owner of this object 510fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const String test_case_name_; // Test case name 511fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const String name_; // Test name 512fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const String test_case_comment_; // Test case comment 513fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const String comment_; // Test comment 514fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const TypeId fixture_class_id_; // ID of the test fixture class 515fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool should_run_; // True iff this test should run 516fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool is_disabled_; // True iff this test is disabled 517fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool matches_filter_; // True if this test matches the 518fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // user-specified filter. 519fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::TestFactoryBase* const factory_; // The factory that creates 520fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // the test object 521fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 522fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // This field is mutable and needs to be reset before running the 523fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // test for the second time. 524fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestResult result_; 525fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 526fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfoImpl); 527fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 528fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 529fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Class UnitTestOptions. 530fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 531fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This class contains functions for processing options the user 532fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// specifies when running the tests. It has only static members. 533fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 534fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// In most cases, the user can specify an option using either an 535fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// environment variable or a command line flag. E.g. you can set the 536fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// test filter using either GTEST_FILTER or --gtest_filter. If both 537fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the variable and the flag are present, the latter overrides the 538fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// former. 539fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass UnitTestOptions { 540fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 541fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Functions for processing the gtest_output flag. 542fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 543fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the output format, or "" for normal printed output. 544fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static String GetOutputFormat(); 545fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 546fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the absolute path of the requested output file, or the 547fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // default (test_detail.xml in the original working directory) if 548fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // none was explicitly specified. 549fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static String GetAbsolutePathToOutputFile(); 550fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 551fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Functions for processing the gtest_filter flag. 552fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 553fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff the wildcard pattern matches the string. The 554fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // first ':' or '\0' character in pattern marks the end of it. 555fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 556fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // This recursive algorithm isn't very efficient, but is clear and 557fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // works well enough for matching test names, which are short. 558fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static bool PatternMatchesString(const char *pattern, const char *str); 559fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 560fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff the user-specified filter matches the test case 561fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // name and the test name. 562fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static bool FilterMatchesTest(const String &test_case_name, 563fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const String &test_name); 564fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 565fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_OS_WINDOWS 566fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Function for supporting the gtest_catch_exception flag. 567fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 568fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the 569fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise. 570fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // This function is useful as an __except condition. 571fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static int GTestShouldProcessSEH(DWORD exception_code); 572fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_OS_WINDOWS 573fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 574fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true if "name" matches the ':' separated list of glob-style 575fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // filters in "filter". 576fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static bool MatchesFilter(const String& name, const char* filter); 577fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 578fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 579fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Returns the current application's name, removing directory path if that 580fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// is present. Used by UnitTestOptions::GetOutputFile. 581fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleFilePath GetCurrentExecutableName(); 582fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 583fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The role interface for getting the OS stack trace as a string. 584fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass OsStackTraceGetterInterface { 585fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 586fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville OsStackTraceGetterInterface() {} 587fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual ~OsStackTraceGetterInterface() {} 588fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 589fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the current OS stack trace as a String. Parameters: 590fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 591fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // max_depth - the maximum number of stack frames to be included 592fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // in the trace. 593fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // skip_count - the number of top frames to be skipped; doesn't count 594fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // against max_depth. 595fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual String CurrentStackTrace(int max_depth, int skip_count) = 0; 596fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 597fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // UponLeavingGTest() should be called immediately before Google Test calls 598fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // user code. It saves some information about the current stack that 599fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // CurrentStackTrace() will use to find and hide Google Test stack frames. 600fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual void UponLeavingGTest() = 0; 601fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 602fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 603fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface); 604fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 605fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 606fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A working implementation of the OsStackTraceGetterInterface interface. 607fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass OsStackTraceGetter : public OsStackTraceGetterInterface { 608fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 609fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville OsStackTraceGetter() {} 610fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual String CurrentStackTrace(int max_depth, int skip_count); 611fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual void UponLeavingGTest(); 612fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 613fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // This string is inserted in place of stack frames that are part of 614fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Google Test's implementation. 615fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static const char* const kElidedFramesMarker; 616fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 617fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 618fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Mutex mutex_; // protects all internal state 619fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 620fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // We save the stack frame below the frame that calls user code. 621fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // We do this because the address of the frame immediately below 622fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // the user code changes between the call to UponLeavingGTest() 623fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // and any calls to CurrentStackTrace() from within the user code. 624fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void* caller_frame_; 625fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 626fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter); 627fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 628fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 629fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Information about a Google Test trace point. 630fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillestruct TraceInfo { 631fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* file; 632fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int line; 633fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville String message; 634fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 635fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 636fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This is the default global test part result reporter used in UnitTestImpl. 637fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This class should only be used by UnitTestImpl. 638fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass DefaultGlobalTestPartResultReporter 639fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville : public TestPartResultReporterInterface { 640fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 641fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville explicit DefaultGlobalTestPartResultReporter(UnitTestImpl* unit_test); 642fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Implements the TestPartResultReporterInterface. Reports the test part 643fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // result in the current test. 644fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual void ReportTestPartResult(const TestPartResult& result); 645fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 646fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 647fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville UnitTestImpl* const unit_test_; 648fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 649fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter); 650fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 651fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 652fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This is the default per thread test part result reporter used in 653fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// UnitTestImpl. This class should only be used by UnitTestImpl. 654fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass DefaultPerThreadTestPartResultReporter 655fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville : public TestPartResultReporterInterface { 656fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 657fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville explicit DefaultPerThreadTestPartResultReporter(UnitTestImpl* unit_test); 658fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Implements the TestPartResultReporterInterface. The implementation just 659fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // delegates to the current global test part result reporter of *unit_test_. 660fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual void ReportTestPartResult(const TestPartResult& result); 661fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 662fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 663fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville UnitTestImpl* const unit_test_; 664fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 665fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter); 666fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 667fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 668fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The private implementation of the UnitTest class. We don't protect 669fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the methods under a mutex, as this class is not accessible by a 670fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// user and the UnitTest class that delegates work to this class does 671fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// proper locking. 672fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass UnitTestImpl { 673fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 674fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville explicit UnitTestImpl(UnitTest* parent); 675fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual ~UnitTestImpl(); 676fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 677fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // There are two different ways to register your own TestPartResultReporter. 678fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // You can register your own repoter to listen either only for test results 679fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // from the current thread or for results from all threads. 680fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // By default, each per-thread test result repoter just passes a new 681fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // TestPartResult to the global test result reporter, which registers the 682fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // test part result for the currently running test. 683fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 684fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the global test part result reporter. 685fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestPartResultReporterInterface* GetGlobalTestPartResultReporter(); 686fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 687fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Sets the global test part result reporter. 688fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void SetGlobalTestPartResultReporter( 689fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestPartResultReporterInterface* reporter); 690fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 691fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the test part result reporter for the current thread. 692fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestPartResultReporterInterface* GetTestPartResultReporterForCurrentThread(); 693fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 694fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Sets the test part result reporter for the current thread. 695fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void SetTestPartResultReporterForCurrentThread( 696fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestPartResultReporterInterface* reporter); 697fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 698fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of successful test cases. 699fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int successful_test_case_count() const; 700fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 701fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of failed test cases. 702fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int failed_test_case_count() const; 703fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 704fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of all test cases. 705fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int total_test_case_count() const; 706fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 707fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of all test cases that contain at least one test 708fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // that should run. 709fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int test_case_to_run_count() const; 710fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 711fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of successful tests. 712fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int successful_test_count() const; 713fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 714fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of failed tests. 715fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int failed_test_count() const; 716fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 717fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of disabled tests. 718fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int disabled_test_count() const; 719fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 720fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of all tests. 721fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int total_test_count() const; 722fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 723fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the number of tests that should run. 724fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int test_to_run_count() const; 725fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 726fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the elapsed time, in milliseconds. 727fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TimeInMillis elapsed_time() const { return elapsed_time_; } 728fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 729fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff the unit test passed (i.e. all test cases passed). 730fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool Passed() const { return !Failed(); } 731fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 732fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns true iff the unit test failed (i.e. some test case failed 733fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // or something outside of all tests failed). 734fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool Failed() const { 735fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return failed_test_case_count() > 0 || ad_hoc_test_result()->Failed(); 736fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 737fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 738fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the i-th test case among all the test cases. i can range from 0 to 739fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // total_test_case_count() - 1. If i is not in that range, returns NULL. 740fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const TestCase* GetTestCase(int i) const { 741fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return test_cases_.GetElementOr(i, NULL); 742fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 743fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 744fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the TestResult for the test that's currently running, or 745fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // the TestResult for the ad hoc test if no test is running. 746fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestResult* current_test_result(); 747fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 748fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the TestResult for the ad hoc test. 749fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const TestResult* ad_hoc_test_result() const { return &ad_hoc_test_result_; } 750fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 751fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Sets the unit test result printer. 752fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 753fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Does nothing if the input and the current printer object are the 754fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // same; otherwise, deletes the old printer object and makes the 755fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // input the current printer. 756fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void set_result_printer(UnitTestEventListenerInterface* result_printer); 757fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 758fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the current unit test result printer if it is not NULL; 759fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // otherwise, creates an appropriate result printer, makes it the 760fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // current printer, and returns it. 761fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville UnitTestEventListenerInterface* result_printer(); 762fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 763fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Sets the OS stack trace getter. 764fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 765fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Does nothing if the input and the current OS stack trace getter 766fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // are the same; otherwise, deletes the old getter and makes the 767fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // input the current getter. 768fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void set_os_stack_trace_getter(OsStackTraceGetterInterface* getter); 769fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 770fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the current OS stack trace getter if it is not NULL; 771fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // otherwise, creates an OsStackTraceGetter, makes it the current 772fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // getter, and returns it. 773fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville OsStackTraceGetterInterface* os_stack_trace_getter(); 774fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 775fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the current OS stack trace as a String. 776fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 777fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The maximum number of stack frames to be included is specified by 778fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // the gtest_stack_trace_depth flag. The skip_count parameter 779fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // specifies the number of top frames to be skipped, which doesn't 780fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // count against the number of frames to be included. 781fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 782fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // For example, if Foo() calls Bar(), which in turn calls 783fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // CurrentOsStackTraceExceptTop(1), Foo() will be included in the 784fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // trace but Bar() and CurrentOsStackTraceExceptTop() won't. 785fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville String CurrentOsStackTraceExceptTop(int skip_count); 786fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 787fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Finds and returns a TestCase with the given name. If one doesn't 788fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // exist, creates one and returns it. 789fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 790fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Arguments: 791fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 792fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // test_case_name: name of the test case 793fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // set_up_tc: pointer to the function that sets up the test case 794fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // tear_down_tc: pointer to the function that tears down the test case 795fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestCase* GetTestCase(const char* test_case_name, 796fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* comment, 797fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Test::SetUpTestCaseFunc set_up_tc, 798fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Test::TearDownTestCaseFunc tear_down_tc); 799fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 800fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Adds a TestInfo to the unit test. 801fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 802fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Arguments: 803fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 804fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // set_up_tc: pointer to the function that sets up the test case 805fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // tear_down_tc: pointer to the function that tears down the test case 806fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // test_info: the TestInfo object 807fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void AddTestInfo(Test::SetUpTestCaseFunc set_up_tc, 808fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Test::TearDownTestCaseFunc tear_down_tc, 809fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestInfo * test_info) { 810fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // In order to support thread-safe death tests, we need to 811fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // remember the original working directory when the test program 812fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // was first invoked. We cannot do this in RUN_ALL_TESTS(), as 813fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // the user may have changed the current directory before calling 814fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // RUN_ALL_TESTS(). Therefore we capture the current directory in 815fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // AddTestInfo(), which is called to register a TEST or TEST_F 816fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // before main() is reached. 817fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (original_working_dir_.IsEmpty()) { 818fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville original_working_dir_.Set(FilePath::GetCurrentDir()); 819fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_CHECK_(!original_working_dir_.IsEmpty()) 820fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "Failed to get the current working directory."; 821fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 822fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 823fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GetTestCase(test_info->test_case_name(), 824fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_info->test_case_comment(), 825fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville set_up_tc, 826fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville tear_down_tc)->AddTestInfo(test_info); 827fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 828fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 829fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_PARAM_TEST 830fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns ParameterizedTestCaseRegistry object used to keep track of 831fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // value-parameterized tests and instantiate and register them. 832fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::ParameterizedTestCaseRegistry& parameterized_test_registry() { 833fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return parameterized_test_registry_; 834fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 835fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_PARAM_TEST 836fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 837fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Sets the TestCase object for the test that's currently running. 838fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void set_current_test_case(TestCase* current_test_case) { 839fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville current_test_case_ = current_test_case; 840fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 841fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 842fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Sets the TestInfo object for the test that's currently running. If 843fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // current_test_info is NULL, the assertion results will be stored in 844fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // ad_hoc_test_result_. 845fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void set_current_test_info(TestInfo* current_test_info) { 846fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville current_test_info_ = current_test_info; 847fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 848fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 849fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Registers all parameterized tests defined using TEST_P and 850fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // INSTANTIATE_TEST_P, creating regular tests for each test/parameter 851fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // combination. This method can be called more then once; it has 852fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // guards protecting from registering the tests more then once. 853fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // If value-parameterized tests are disabled, RegisterParameterizedTests 854fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // is present but does nothing. 855fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void RegisterParameterizedTests(); 856fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 857fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Runs all tests in this UnitTest object, prints the result, and 858fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // returns 0 if all tests are successful, or 1 otherwise. If any 859fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // exception is thrown during a test on Windows, this test is 860fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // considered to be failed, but the rest of the tests will still be 861fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // run. (We disable exceptions on Linux and Mac OS X, so the issue 862fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // doesn't apply there.) 863fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int RunAllTests(); 864fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 865fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Clears the results of all tests, including the ad hoc test. 866fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void ClearResult() { 867fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_cases_.ForEach(TestCase::ClearTestCaseResult); 868fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ad_hoc_test_result_.Clear(); 869fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 870fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 871fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville enum ReactionToSharding { 872fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville HONOR_SHARDING_PROTOCOL, 873fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville IGNORE_SHARDING_PROTOCOL 874fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville }; 875fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 876fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Matches the full name of each test against the user-specified 877fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // filter to decide whether the test should run, then records the 878fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // result in each TestCase and TestInfo object. 879fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // If shard_tests == HONOR_SHARDING_PROTOCOL, further filters tests 880fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // based on sharding variables in the environment. 881fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the number of tests that should run. 882fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int FilterTests(ReactionToSharding shard_tests); 883fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 884fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Prints the names of the tests matching the user-specified filter flag. 885fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void ListTestsMatchingFilter(); 886fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 887fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const TestCase* current_test_case() const { return current_test_case_; } 888fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestInfo* current_test_info() { return current_test_info_; } 889fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const TestInfo* current_test_info() const { return current_test_info_; } 890fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 891fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the vector of environments that need to be set-up/torn-down 892fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // before/after the tests are run. 893fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::Vector<Environment*>* environments() { return &environments_; } 894fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::Vector<Environment*>* environments_in_reverse_order() { 895fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return &environments_in_reverse_order_; 896fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 897fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 898fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::Vector<TestCase*>* test_cases() { return &test_cases_; } 899fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const internal::Vector<TestCase*>* test_cases() const { return &test_cases_; } 900fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 901fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Getters for the per-thread Google Test trace stack. 902fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::Vector<TraceInfo>* gtest_trace_stack() { 903fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return gtest_trace_stack_.pointer(); 904fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 905fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const internal::Vector<TraceInfo>* gtest_trace_stack() const { 906fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return gtest_trace_stack_.pointer(); 907fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 908fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 909fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_DEATH_TEST 910fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns a pointer to the parsed --gtest_internal_run_death_test 911fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // flag, or NULL if that flag was not specified. 912fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // This information is useful only in a death test child process. 913fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const InternalRunDeathTestFlag* internal_run_death_test_flag() const { 914fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return internal_run_death_test_flag_.get(); 915fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 916fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 917fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns a pointer to the current death test factory. 918fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::DeathTestFactory* death_test_factory() { 919fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return death_test_factory_.get(); 920fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 921fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 922fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend class ReplaceDeathTestFactory; 923fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_DEATH_TEST 924fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 925fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Gets the random seed used at the start of the current test run. 926fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int random_seed() const { return random_seed_; } 927fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 928fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 929fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend class ::testing::UnitTest; 930fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 931fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The UnitTest object that owns this implementation object. 932fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville UnitTest* const parent_; 933fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 934fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The working directory when the first TEST() or TEST_F() was 935fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // executed. 936fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::FilePath original_working_dir_; 937fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 938fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The default test part result reporters. 939fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville DefaultGlobalTestPartResultReporter default_global_test_part_result_reporter_; 940fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville DefaultPerThreadTestPartResultReporter 941fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville default_per_thread_test_part_result_reporter_; 942fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 943fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Points to (but doesn't own) the global test part result reporter. 944fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestPartResultReporterInterface* global_test_part_result_repoter_; 945fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 946fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Protects read and write access to global_test_part_result_reporter_. 947fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::Mutex global_test_part_result_reporter_mutex_; 948fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 949fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Points to (but doesn't own) the per-thread test part result reporter. 950fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::ThreadLocal<TestPartResultReporterInterface*> 951fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville per_thread_test_part_result_reporter_; 952fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 953fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The vector of environments that need to be set-up/torn-down 954fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // before/after the tests are run. environments_in_reverse_order_ 955fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // simply mirrors environments_ in reverse order. 956fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::Vector<Environment*> environments_; 957fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::Vector<Environment*> environments_in_reverse_order_; 958fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 959fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::Vector<TestCase*> test_cases_; // The vector of TestCases. 960fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 961fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_PARAM_TEST 962fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // ParameterizedTestRegistry object used to register value-parameterized 963fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // tests. 964fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::ParameterizedTestCaseRegistry parameterized_test_registry_; 965fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 966fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Indicates whether RegisterParameterizedTests() has been called already. 967fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool parameterized_tests_registered_; 968fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_PARAM_TEST 969fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 970fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Index of the last death test case registered. Initially -1. 971fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int last_death_test_case_; 972fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 973fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // This points to the TestCase for the currently running test. It 974fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // changes as Google Test goes through one test case after another. 975fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // When no test is running, this is set to NULL and Google Test 976fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // stores assertion results in ad_hoc_test_result_. Initially NULL. 977fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestCase* current_test_case_; 978fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 979fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // This points to the TestInfo for the currently running test. It 980fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // changes as Google Test goes through one test after another. When 981fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // no test is running, this is set to NULL and Google Test stores 982fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // assertion results in ad_hoc_test_result_. Initially NULL. 983fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestInfo* current_test_info_; 984fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 985fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Normally, a user only writes assertions inside a TEST or TEST_F, 986fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // or inside a function called by a TEST or TEST_F. Since Google 987fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Test keeps track of which test is current running, it can 988fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // associate such an assertion with the test it belongs to. 989fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 990fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // If an assertion is encountered when no TEST or TEST_F is running, 991fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Google Test attributes the assertion result to an imaginary "ad hoc" 992fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // test, and records the result in ad_hoc_test_result_. 993fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestResult ad_hoc_test_result_; 994fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 995fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The unit test result printer. Will be deleted when the UnitTest 996fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // object is destructed. By default, a plain text printer is used, 997fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // but the user can set this field to use a custom printer if that 998fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // is desired. 999fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville UnitTestEventListenerInterface* result_printer_; 1000fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1001fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The OS stack trace getter. Will be deleted when the UnitTest 1002fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // object is destructed. By default, an OsStackTraceGetter is used, 1003fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // but the user can set this field to use a custom getter if that is 1004fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // desired. 1005fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville OsStackTraceGetterInterface* os_stack_trace_getter_; 1006fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1007fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The random number seed used at the beginning of the test run. 1008fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int random_seed_; 1009fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1010fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // How long the test took to run, in milliseconds. 1011fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TimeInMillis elapsed_time_; 1012fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1013fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_DEATH_TEST 1014fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The decomposed components of the gtest_internal_run_death_test flag, 1015fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // parsed when RUN_ALL_TESTS is called. 1016fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::scoped_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_; 1017fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::scoped_ptr<internal::DeathTestFactory> death_test_factory_; 1018fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_DEATH_TEST 1019fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1020fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // A per-thread stack of traces created by the SCOPED_TRACE() macro. 1021fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville internal::ThreadLocal<internal::Vector<TraceInfo> > gtest_trace_stack_; 1022fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1023fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl); 1024fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; // class UnitTestImpl 1025fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1026fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Convenience function for accessing the global UnitTest 1027fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// implementation object. 1028fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline UnitTestImpl* GetUnitTestImpl() { 1029fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return UnitTest::GetInstance()->impl(); 1030fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1031fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1032fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Internal helper functions for implementing the simple regular 1033fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// expression matcher. 1034fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillebool IsInSet(char ch, const char* str); 1035fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillebool IsDigit(char ch); 1036fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillebool IsPunct(char ch); 1037fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillebool IsRepeat(char ch); 1038fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillebool IsWhiteSpace(char ch); 1039fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillebool IsWordChar(char ch); 1040fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillebool IsValidEscape(char ch); 1041fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillebool AtomMatchesChar(bool escaped, char pattern, char ch); 1042fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillebool ValidateRegex(const char* regex); 1043fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillebool MatchRegexAtHead(const char* regex, const char* str); 1044fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillebool MatchRepetitionAndRegexAtHead( 1045fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool escaped, char ch, char repeat, const char* regex, const char* str); 1046fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillebool MatchRegexAnywhere(const char* regex, const char* str); 1047fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1048fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Parses the command line for Google Test flags, without initializing 1049fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// other parts of Google Test. 1050fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillevoid ParseGoogleTestFlagsOnly(int* argc, char** argv); 1051fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillevoid ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv); 1052fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1053fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_DEATH_TEST 1054fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1055fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Returns the message describing the last system error, regardless of the 1056fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// platform. 1057fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleString GetLastErrnoDescription(); 1058fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1059fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_OS_WINDOWS 1060fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Provides leak-safe Windows kernel handle ownership. 1061fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass AutoHandle { 1062fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 1063fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville AutoHandle() : handle_(INVALID_HANDLE_VALUE) {} 1064fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville explicit AutoHandle(HANDLE handle) : handle_(handle) {} 1065fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1066fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~AutoHandle() { Reset(); } 1067fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1068fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville HANDLE Get() const { return handle_; } 1069fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void Reset() { Reset(INVALID_HANDLE_VALUE); } 1070fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void Reset(HANDLE handle) { 1071fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (handle != handle_) { 1072fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (handle_ != INVALID_HANDLE_VALUE) 1073fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ::CloseHandle(handle_); 1074fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville handle_ = handle; 1075fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 1076fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 1077fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1078fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 1079fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville HANDLE handle_; 1080fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1081fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle); 1082fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 1083fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_OS_WINDOWS 1084fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1085fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Attempts to parse a string into a positive integer pointed to by the 1086fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// number parameter. Returns true if that is possible. 1087fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can use 1088fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// it here. 1089fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename Integer> 1090fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillebool ParseNaturalNumber(const ::std::string& str, Integer* number) { 1091fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Fail fast if the given string does not begin with a digit; 1092fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // this bypasses strtoXXX's "optional leading whitespace and plus 1093fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // or minus sign" semantics, which are undesirable here. 1094fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (str.empty() || !isdigit(str[0])) { 1095fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return false; 1096fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 1097fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville errno = 0; 1098fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1099fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville char* end; 1100fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // BiggestConvertible is the largest integer type that system-provided 1101fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // string-to-number conversion routines can return. 1102fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_OS_WINDOWS 1103fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef unsigned __int64 BiggestConvertible; 1104fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const BiggestConvertible parsed = _strtoui64(str.c_str(), &end, 10); 1105fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 1106fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef unsigned long long BiggestConvertible; // NOLINT 1107fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10); 1108fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_OS_WINDOWS 1109fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const bool parse_success = *end == '\0' && errno == 0; 1110fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1111fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // TODO(vladl@google.com): Convert this to compile time assertion when it is 1112fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // available. 1113fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed)); 1114fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1115fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const Integer result = static_cast<Integer>(parsed); 1116fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (parse_success && static_cast<BiggestConvertible>(result) == parsed) { 1117fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville *number = result; 1118fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return true; 1119fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 1120fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return false; 1121fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1122fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_DEATH_TEST 1123fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1124fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// TestResult contains some private methods that should be hidden from 1125fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Google Test user but are required for testing. This class allow our tests 1126fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// to access them. 1127fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass TestResultAccessor { 1128fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 1129fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static void RecordProperty(TestResult* test_result, 1130fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const TestProperty& property) { 1131fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_result->RecordProperty(property); 1132fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 1133fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1134fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static bool Passed(const TestResult& result) { return result.Passed(); } 1135fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1136fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static void ClearTestPartResults(TestResult* test_result) { 1137fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_result->ClearTestPartResults(); 1138fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 1139fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1140fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static const Vector<testing::TestPartResult>& test_part_results( 1141fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const TestResult& test_result) { 1142fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return test_result.test_part_results(); 1143fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 1144fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 1145fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1146fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace internal 1147fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace testing 1148fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1149fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_SRC_GTEST_INTERNAL_INL_H_ 1150