SYMBOL INDEX (5410 symbols across 165 files)

FILE: googlemock/include/gmock/gmock-actions.h
  function namespace (line 152) | namespace testing {
  function Result (line 495) | Result Call(Args... args) && {
  function StdFunctionAdaptor (line 508) | StdFunctionAdaptor final {
  type T (line 589) | typedef T (*FactoryFunction)();
  function SetFactory (line 590) | static void SetFactory(FactoryFunction factory) {
  function Clear (line 596) | static void Clear() {
  function IsSet (line 602) | static bool IsSet() { return producer_ != nullptr; }
  function Exists (line 606) | static bool Exists() {
  function T (line 613) | static T Get() {
  function class (line 625) | class FixedValueProducer : public ValueProducer {
  function class (line 636) | class FactoryValueProducer : public ValueProducer {
  function Clear (line 662) | static void Clear() { address_ = nullptr; }
  function IsSet (line 665) | static bool IsSet() { return address_ != nullptr; }
  function Exists (line 669) | static bool Exists() {
  function T (line 676) | static T& Get() {
  function Get (line 691) | static void Get() {}
  type typename (line 707) | typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
  type ActionAdapter (line 739) | struct ActionAdapter {
  type typename (line 755) | typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
  function explicit (line 774) | explicit Action(ActionInterface<F>* impl)
  function Result (line 793) | Result Perform(ArgumentTuple args) const {
  function operator (line 802) | operator OnceAction<F>() const {  // NOLINT
  type typename (line 886) | typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
  function explicit (line 888) | explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
  function Result (line 890) | Result Perform(const ArgumentTuple& args) override {
  function explicit (line 926) | explicit ByMoveWrapper(T value) : payload(std::move(value)) {}
  function ReturnAction (line 932) | [[nodiscard]] ReturnAction final {
  type State (line 1114) | struct State {
  function class (line 1125) | class [[nodiscard]] ReturnNullAction {
  function class (line 1137) | class [[nodiscard]] ReturnVoidAction {
  type typename (line 1159) | typedef typename Function<F>::Result Result;
  type typename (line 1174) | typedef typename Function<F>::ArgumentTuple ArgumentTuple;
  function explicit (line 1176) | explicit Impl(T& ref) : ref_(ref) {}
  function Result (line 1178) | Result Perform(const ArgumentTuple&) override { return ref_; }
  type typename (line 1201) | typedef typename Function<F>::Result Result;
  type typename (line 1216) | typedef typename Function<F>::ArgumentTuple ArgumentTuple;
  function explicit (line 1218) | explicit Impl(const T& value) : value_(value) {}
  function Result (line 1220) | Result Perform(const ArgumentTuple&) override { return value_; }
  function T (line 1247) | T Next() {
  function class (line 1260) | class [[nodiscard]] DoDefaultAction {
  type typename (line 1381) | typedef typename internal::Function<F>::Result Result;
  function R (line 1448) | R operator()(Args&&... args) && {
  function R (line 1472) | R operator()(Args&&... args) && {
  type UserConstructorTag (line 1512) | struct UserConstructorTag {}
  function R (line 1645) | R operator()(Args... args) && {
  type OA (line 1695) | struct OA {
  function T (line 1720) | T* operator()() const {
  function DoDelete (line 1808) | void DoDelete(T* ptr) {
  function DoDelete (line 1813) | [[deprecated(
  type RethrowAction (line 1839) | struct RethrowAction {
  type internal (line 1880) | typedef internal::IgnoredValue Unused;
  function typename (line 1885) | typename std::decay<Action>::type DoAll(Action&& action) {
  function PolymorphicAction (line 1960) | inline PolymorphicAction<internal::ReturnNullAction> ReturnNull() {
  function PolymorphicAction (line 1965) | inline PolymorphicAction<internal::ReturnVoidAction> Return() {
  function internal (line 2016) | inline internal::DoDefaultAction DoDefault() {
  function typename (line 2059) | typename std::decay<FunctionImpl>::type Invoke(FunctionImpl&& function_i...
  function internal (line 2191) | inline internal::RethrowAction Rethrow(std::exception_ptr exception) {
  function namespace (line 2196) | namespace internal {
  function explicit (line 2237) | explicit ActionImpl(std::shared_ptr<Impl> impl) : Base{std::move(impl)} {}

FILE: googlemock/include/gmock/gmock-cardinalities.h
  function namespace (line 53) | namespace testing {

FILE: googlemock/include/gmock/gmock-function-mocker.h
  function namespace (line 48) | namespace testing {

FILE: googlemock/include/gmock/gmock-matchers.h
  function namespace (line 291) | namespace testing {
  type RawT (line 556) | typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT;
  type RawU (line 557) | typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU;
  function namespace (line 573) | namespace internal {
  function class (line 794) | class [[nodiscard]] NotNullMatcher {
  function DescribeTo (line 802) | void DescribeTo(::std::ostream* os) const { *os << "isn't NULL"; }
  function DescribeNegationTo (line 803) | void DescribeNegationTo(::std::ostream* os) const { *os << "is NULL"; }
  function MatchAndExplain (line 853) | bool MatchAndExplain(Super& x,
  function DescribeTo (line 859) | void DescribeTo(::std::ostream* os) const override {
  function DescribeNegationTo (line 864) | void DescribeNegationTo(::std::ostream* os) const override {
  function CaseInsensitiveCStringEquals (line 877) | inline bool CaseInsensitiveCStringEquals(const char* lhs, const char* rh...
  function CaseInsensitiveCStringEquals (line 881) | inline bool CaseInsensitiveCStringEquals(const wchar_t* lhs,
  function MatchAndExplain (line 988) | bool MatchAndExplain(const internal::StringView& s,
  function DescribeTo (line 1018) | void DescribeTo(::std::ostream* os) const {
  function DescribeNegationTo (line 1023) | void DescribeNegationTo(::std::ostream* os) const {
  function MatchAndExplain (line 1041) | bool MatchAndExplain(const internal::StringView& s,
  function DescribeTo (line 1072) | void DescribeTo(::std::ostream* os) const {
  function DescribeNegationTo (line 1077) | void DescribeNegationTo(::std::ostream* os) const {
  function MatchAndExplain (line 1095) | bool MatchAndExplain(const internal::StringView& s,
  function DescribeTo (line 1126) | void DescribeTo(::std::ostream* os) const {
  function DescribeNegationTo (line 1131) | void DescribeNegationTo(::std::ostream* os) const {
  function class (line 1142) | class [[nodiscard]] WhenBase64UnescapedMatcher {
  function DescribeTo (line 1211) | void DescribeTo(::std::ostream* os) const override {
  function DescribeNegationTo (line 1214) | void DescribeNegationTo(::std::ostream* os) const override {
  function matcher_ (line 1257) | matcher_(matcher) {}
  function MatchAndExplain (line 1259) | bool MatchAndExplain(const T& x,
  function DescribeTo (line 1264) | void DescribeTo(::std::ostream* os) const override {
  function DescribeNegationTo (line 1268) | void DescribeNegationTo(::std::ostream* os) const override {
  function DescribeTo (line 1304) | void DescribeTo(::std::ostream* os) const override {
  function DescribeNegationTo (line 1313) | void DescribeNegationTo(::std::ostream* os) const override {
  function MatchAndExplain (line 1322) | bool MatchAndExplain(const T& x,
  function DescribeNegationTo (line 1449) | void DescribeNegationTo(::std::ostream* os) const override {
  function MatchAndExplain (line 1458) | bool MatchAndExplain(const T& x,
  function DescribeTo (line 1602) | void DescribeTo(::std::ostream* os) const {
  function DescribeNegationTo (line 1606) | void DescribeNegationTo(::std::ostream* os) const {
  function class (line 1712) | class [[nodiscard]] IsNanMatcher {
  function DescribeTo (line 1720) | void DescribeTo(::std::ostream* os) const { *os << "is NaN"; }
  function DescribeNegationTo (line 1721) | void DescribeNegationTo(::std::ostream* os) const { *os << "isn't NaN"; }
  function DescribeTo (line 1796) | void DescribeTo(::std::ostream* os) const override {
  function DescribeNegationTo (line 1817) | void DescribeNegationTo(::std::ostream* os) const override {
  function operator (line 1854) | operator Matcher<const FloatType&>() const {
  function operator (line 1859) | operator Matcher<FloatType&>() const {
  function explicit (line 1881) | explicit FloatingEq2Matcher(bool nan_eq_nan) { Init(-1, nan_eq_nan); }
  function explicit (line 1883) | explicit FloatingEq2Matcher(FloatType max_abs_error) {
  function explicit (line 1975) | explicit Impl(const InnerMatcher& matcher)
  function DescribeTo (line 1978) | void DescribeTo(::std::ostream* os) const override {
  function DescribeNegationTo (line 1983) | void DescribeNegationTo(::std::ostream* os) const override {
  function MatchAndExplain (line 1988) | bool MatchAndExplain(Pointer pointer,
  function typename (line 2031) | typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_(
  function DescribeTo (line 2037) | void DescribeTo(::std::ostream* os) const override {
  function DescribeNegationTo (line 2042) | void DescribeNegationTo(::std::ostream* os) const override {
  function MatchAndExplain (line 2047) | bool MatchAndExplain(PointerType pointer,
  function matcher_ (line 2072) | matcher_(matcher) {}
  function DescribeTo (line 2074) | void DescribeTo(::std::ostream* os) const {
  function DescribeNegationTo (line 2079) | void DescribeNegationTo(::std::ostream* os) const {
  function std (line 2087) | static std::string GetToName() { return GetTypeName<To>(); }
  function DescribeTo (line 2148) | void DescribeTo(::std::ostream* os) const {
  function DescribeNegationTo (line 2153) | void DescribeNegationTo(::std::ostream* os) const {
  function MatchAndExplainImpl (line 2175) | bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p,
  function DescribeTo (line 2215) | void DescribeTo(::std::ostream* os) const {
  function DescribeNegationTo (line 2220) | void DescribeNegationTo(::std::ostream* os) const {
  function MatchAndExplainImpl (line 2243) | bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p,
  type Functor (line 2266) | typedef Functor StorageType;
  function CheckIsValid (line 2268) | static void CheckIsValid(Functor /* functor */) {}
  type ResType (line 2279) | typedef ResType ResultType;
  type ResType (line 2280) | typedef ResType (*StorageType)(ArgType);
  function CheckIsValid (line 2282) | static void CheckIsValid(ResType (*f)(ArgType)) {
  function ResType (line 2287) | ResType Invoke(ResType (*f)(ArgType), T arg) {
  function DescribeTo (line 2334) | void DescribeTo(::std::ostream* os) const override {
  function DescribeNegationTo (line 2343) | void DescribeNegationTo(::std::ostream* os) const override {
  function MatchAndExplain (line 2352) | bool MatchAndExplain(T obj, MatchResultListener* listener) const override {
  function explicit (line 2399) | explicit Impl(const SizeMatcher& size_matcher)
  function DescribeTo (line 2402) | void DescribeTo(::std::ostream* os) const override {
  function DescribeNegationTo (line 2406) | void DescribeNegationTo(::std::ostream* os) const override {
  function MatchAndExplain (line 2411) | bool MatchAndExplain(Container container,
  type typename (line 2449) | typedef typename std::iterator_traits<
  function explicit (line 2452) | explicit Impl(const DistanceMatcher& distance_matcher)
  function DescribeTo (line 2455) | void DescribeTo(::std::ostream* os) const override {
  function DescribeNegationTo (line 2459) | void DescribeNegationTo(::std::ostream* os) const override {
  function MatchAndExplain (line 2464) | bool MatchAndExplain(Container container,
  type typename (line 2500) | typedef typename View::type StlContainer;
  type typename (line 2501) | typedef typename View::const_reference StlContainerReference;
  function explicit (line 2510) | explicit ContainerEqMatcher(const Container& expected)
  function DescribeTo (line 2513) | void DescribeTo(::std::ostream* os) const {
  function DescribeNegationTo (line 2517) | void DescribeNegationTo(::std::ostream* os) const {
  type internal (line 2525) | typedef internal::StlContainerView<
  type typename (line 2601) | typedef typename LhsView::type LhsStlContainer;
  type typename (line 2602) | typedef typename LhsView::const_reference LhsStlContainerReference;
  type typename (line 2605) | typedef typename RemoveConstFromKey<
  function DescribeTo (line 2612) | void DescribeTo(::std::ostream* os) const override {
  function DescribeNegationTo (line 2617) | void DescribeNegationTo(::std::ostream* os) const override {
  function MatchAndExplain (line 2622) | bool MatchAndExplain(LhsContainer lhs,
  type typename (line 2672) | typedef typename RhsView::type RhsStlContainer;
  type typename (line 2673) | typedef typename internal::RangeTraits<RhsStlContainer>::value_type RhsV...
  type typename (line 2701) | typedef typename LhsView::type LhsStlContainer;
  type typename (line 2702) | typedef typename LhsView::const_reference LhsStlContainerReference;
  type typename (line 2703) | typedef
  type LhsValue (line 2709) | typedef ::std::tuple<const LhsValue&, const RhsValue&> InnerMatcherArg;
  function DescribeTo (line 2716) | void DescribeTo(::std::ostream* os) const override {
  function DescribeNegationTo (line 2723) | void DescribeNegationTo(::std::ostream* os) const override {
  function MatchAndExplain (line 2732) | bool MatchAndExplain(LhsContainer lhs,
  type typename (line 2788) | typedef typename View::type StlContainer;
  type typename (line 2789) | typedef typename View::const_reference StlContainerReference;
  type typename (line 2790) | typedef typename internal::RangeTraits<StlContainer>::value_type Element;
  function MatchAndExplainImpl (line 2800) | bool MatchAndExplainImpl(bool all_elements_should_match, Container conta...
  function MatchAndExplainImpl (line 2819) | bool MatchAndExplainImpl(const Matcher<size_t>& count_matcher,
  function DescribeTo (line 2956) | void DescribeTo(::std::ostream* os) const override {
  function DescribeNegationTo (line 2961) | void DescribeNegationTo(::std::ostream* os) const override {
  function MatchAndExplain (line 2966) | bool MatchAndExplain(Container container,
  function DescribeTo (line 2984) | void DescribeTo(::std::ostream* os) const override {
  function DescribeNegationTo (line 2991) | void DescribeNegationTo(::std::ostream* os) const override {
  function MatchAndExplain (line 2998) | bool MatchAndExplain(Container container,
  type typename (line 3136) | typedef typename RawPairType::first_type KeyType;
  function MatchAndExplain (line 3145) | bool MatchAndExplain(PairType key_value,
  function DescribeTo (line 3158) | void DescribeTo(::std::ostream* os) const override {
  function DescribeNegationTo (line 3164) | void DescribeNegationTo(::std::ostream* os) const override {
  function explicit (line 3206) | explicit Impl(const InnerMatcher& matcher)
  function DescribeTo (line 3209) | void DescribeTo(::std::ostream* os) const override {
  function DescribeNegationTo (line 3214) | void DescribeNegationTo(::std::ostream* os) const override {
  function MatchAndExplain (line 3219) | bool MatchAndExplain(Type object,
  type typename (line 3238) | typedef typename RawPairType::first_type FirstType;
  type typename (line 3239) | typedef typename RawPairType::second_type SecondType;
  function DescribeTo (line 3249) | void DescribeTo(::std::ostream* os) const override {
  function DescribeNegationTo (line 3257) | void DescribeNegationTo(::std::ostream* os) const override {
  function MatchAndExplain (line 3266) | bool MatchAndExplain(PairType a_pair,
  function matchers_ (line 3514) | FieldsAreMatcherImpl(const Inner& matchers)
  function DescribeTo (line 3519) | void DescribeTo(::std::ostream* os) const override {
  type typename (line 4432) | typedef typename ::std::iterator_traits<Iter>::value_type T;
  type typename (line 5082) | typedef typename internal::StlContainerView<RhsContainer> RhsView;
  type typename (line 5083) | typedef typename RhsView::type RhsStlContainer;
  type typename (line 5084) | typedef typename internal::RangeTraits<RhsStlContainer>::value_type Second;

FILE: googlemock/include/gmock/gmock-more-actions.h
  function namespace (line 578) | namespace testing {

FILE: googlemock/include/gmock/gmock-more-matchers.h
  function namespace (line 48) | namespace testing {

FILE: googlemock/include/gmock/gmock-nice-strict.h
  function namespace (line 72) | namespace testing {

FILE: googlemock/include/gmock/gmock-spec-builders.h
  function namespace (line 90) | namespace testing {
  type CallReaction (line 355) | enum CallReaction {
  function class (line 364) | class GTEST_API_ Mock {
  function class (line 481) | class GTEST_API_ Expectation {
  function class (line 560) | class ExpectationSet {
  function class (line 615) | class GTEST_API_ Sequence {
  function class (line 653) | class GTEST_API_ InSequence {
  function namespace (line 665) | namespace internal {
  type typename (line 1285) | typedef
  function T (line 1351) | T Unwrap() { return std::move(value_); }
  function explicit (line 1371) | explicit ReferenceOrValueWrapper(reference ref) : value_ptr_(&ref) {}
  function class (line 1393) | class Cleanup final {
  function UninterestingCallCleanupHandler (line 1402) | struct UntypedFunctionMockerBase::UninterestingCallCleanupHandler {
  function FailureCleanupHandler (line 1411) | struct UntypedFunctionMockerBase::FailureCleanupHandler {
  function public (line 1441) | public UntypedFunctionMockerBase {
  function namespace (line 1900) | namespace internal {
  function Expectation (line 2066) | inline Expectation::Expectation(internal::ExpectationBase& exp)  // NOLINT

FILE: googlemock/include/gmock/gmock.h
  function namespace (line 72) | namespace testing {

FILE: googlemock/include/gmock/internal/gmock-internal-utils.h
  function namespace (line 54) | namespace testing {

FILE: googlemock/src/gmock-cardinalities.cc
  type testing (line 45) | namespace testing {
    class BetweenCardinalityImpl (line 50) | class BetweenCardinalityImpl : public CardinalityInterface {
      method BetweenCardinalityImpl (line 52) | BetweenCardinalityImpl(int min, int max)
      method ConservativeLowerBound (line 72) | int ConservativeLowerBound() const override { return min_; }
      method ConservativeUpperBound (line 73) | int ConservativeUpperBound() const override { return max_; }
      method IsSatisfiedByCallCount (line 75) | bool IsSatisfiedByCallCount(int call_count) const override {
      method IsSaturatedByCallCount (line 79) | bool IsSaturatedByCallCount(int call_count) const override {
      method BetweenCardinalityImpl (line 89) | BetweenCardinalityImpl(const BetweenCardinalityImpl&) = delete;
      method BetweenCardinalityImpl (line 90) | BetweenCardinalityImpl& operator=(const BetweenCardinalityImpl&) = d...
    function FormatTimes (line 94) | inline std::string FormatTimes(int n) {
    function GTEST_API_ (line 139) | GTEST_API_ Cardinality AtLeast(int n) { return Between(n, INT_MAX); }
    function GTEST_API_ (line 142) | GTEST_API_ Cardinality AtMost(int n) { return Between(0, n); }
    function GTEST_API_ (line 145) | GTEST_API_ Cardinality AnyNumber() { return AtLeast(0); }
    function GTEST_API_ (line 148) | GTEST_API_ Cardinality Between(int min, int max) {
    function GTEST_API_ (line 153) | GTEST_API_ Cardinality Exactly(int n) { return Between(n, n); }

FILE: googlemock/src/gmock-internal-utils.cc
  type testing (line 54) | namespace testing {
    type internal (line 55) | namespace internal {
      function GTEST_API_ (line 59) | GTEST_API_ std::string JoinAsKeyValueTuple(
      function GTEST_API_ (line 81) | GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_n...
      class GoogleTestFailureReporter (line 102) | class GoogleTestFailureReporter : public FailureReporterInterface {
        method ReportFailure (line 104) | void ReportFailure(FailureType type, const char* file, int line,
      function GTEST_API_ (line 117) | GTEST_API_ FailureReporterInterface* GetFailureReporter() {
      function GTEST_API_ (line 133) | GTEST_API_ bool LogIsVisible(LogSeverity severity) {
      function GTEST_API_ (line 154) | GTEST_API_ void Log(LogSeverity severity, const std::string& message,
      function GTEST_API_ (line 191) | GTEST_API_ WithoutMatchers WithoutMatchers::Get() { return WithoutMa...
      function GTEST_API_ (line 193) | GTEST_API_ void IllegalDoDefault(const char* file, int line) {
      function UndoWebSafeEncoding (line 203) | constexpr char UndoWebSafeEncoding(char c) {
      function UnBase64Impl (line 207) | constexpr char UnBase64Impl(char c, const char* const base64, char c...
      function UnBase64Impl (line 215) | constexpr std::array<char, 256> UnBase64Impl(std::index_sequence<I...>,
      function UnBase64 (line 221) | constexpr std::array<char, 256> UnBase64(const char* const base64) {
      function Base64Unescape (line 229) | bool Base64Unescape(const std::string& encoded, std::string* decoded) {

FILE: googlemock/src/gmock-matchers.cc
  type testing (line 44) | namespace testing {
    type internal (line 45) | namespace internal {
      function GTEST_API_ (line 52) | GTEST_API_ std::string FormatMatcherDescription(
      class MaxBipartiteMatchState (line 124) | class MaxBipartiteMatchState {
        method MaxBipartiteMatchState (line 126) | explicit MaxBipartiteMatchState(const MatchMatrix& graph)
        method ElementMatcherPairs (line 132) | ElementMatcherPairs Compute() {
        method TryAugment (line 184) | bool TryAugment(size_t ilhs, ::std::vector<char>* seen) {
      function GTEST_API_ (line 228) | GTEST_API_ ElementMatcherPairs FindMaxBipartiteMatching(const MatchM...
      function LogElementMatcherPairVec (line 232) | static void LogElementMatcherPairVec(const ElementMatcherPairs& pairs,

FILE: googlemock/src/gmock-spec-builders.cc
  type testing (line 65) | namespace testing {
    type internal (line 66) | namespace internal {
      function GTEST_API_ (line 73) | GTEST_API_ void LogWithLocation(testing::internal::LogSeverity sever...
      function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 110) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
      function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 137) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
      function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 157) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
      function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 188) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
      function GTEST_LOCK_EXCLUDED_ (line 212) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function ReportUninterestingCall (line 284) | void ReportUninterestingCall(CallReaction reaction, const std::strin...
      function GTEST_LOCK_EXCLUDED_ (line 319) | GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
      function GTEST_LOCK_EXCLUDED_ (line 332) | GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
      function GTEST_LOCK_EXCLUDED_ (line 343) | GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
      function GTEST_LOCK_EXCLUDED_ (line 360) | GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
      function Expectation (line 376) | Expectation UntypedFunctionMockerBase::GetHandleOf(ExpectationBase* ...
      function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 396) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
      function CallReaction (line 446) | static CallReaction intToCallReaction(int mock_behavior) {
    type MockObjectState (line 464) | struct MockObjectState {
      method MockObjectState (line 465) | MockObjectState()
    class MockObjectRegistry (line 482) | class MockObjectRegistry {
      method StateMap (line 540) | StateMap& states() { return states_; }
    function GTEST_LOCK_EXCLUDED_ (line 561) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
    function GTEST_LOCK_EXCLUDED_ (line 571) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
    function GTEST_LOCK_EXCLUDED_ (line 578) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
    function GTEST_LOCK_EXCLUDED_ (line 585) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
    function GTEST_LOCK_EXCLUDED_ (line 592) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
    function GTEST_LOCK_EXCLUDED_ (line 600) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
    function GTEST_LOCK_EXCLUDED_ (line 613) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
    function GTEST_LOCK_EXCLUDED_ (line 622) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
    function GTEST_LOCK_EXCLUDED_ (line 631) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
    function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 641) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
    function GTEST_LOCK_EXCLUDED_ (line 666) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
    function GTEST_LOCK_EXCLUDED_ (line 670) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
    function GTEST_LOCK_EXCLUDED_ (line 674) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
    function GTEST_LOCK_EXCLUDED_ (line 681) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
    function GTEST_LOCK_EXCLUDED_ (line 691) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
    function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 711) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
    function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 729) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {

FILE: googlemock/src/gmock.cc
  type testing (line 54) | namespace testing {
    type internal (line 55) | namespace internal {
      function ParseGoogleMockFlag (line 95) | static bool ParseGoogleMockFlag(const char* str, const char* flag_name,
      function ParseGoogleMockFlag (line 114) | static bool ParseGoogleMockFlag(const char* str, const char* flag_name,
      function ParseGoogleMockFlag (line 127) | static bool ParseGoogleMockFlag(const char* str, const char* flag_name,
      function InitGoogleMockImpl (line 145) | void InitGoogleMockImpl(int* argc, CharType** argv) {
    function GTEST_API_ (line 203) | GTEST_API_ void InitGoogleMock(int* argc, char** argv) {
    function GTEST_API_ (line 209) | GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv) {
    function GTEST_API_ (line 215) | GTEST_API_ void InitGoogleMock() {

FILE: googlemock/src/gmock_main.cc
  function setup (line 40) | void setup() {
  function loop (line 46) | void loop() { RUN_ALL_TESTS(); }
  function GTEST_API_ (line 64) | GTEST_API_ int main(int argc, char** argv) {

FILE: googlemock/test/gmock-actions_test.cc
  type testing (line 62) | namespace testing {
    function TEST (line 67) | TEST(TypeTraits, Negation) {
    type MyFalse (line 104) | struct MyFalse : std::integral_constant<int, 0> {}
    type MyTrue (line 107) | struct MyTrue : std::integral_constant<int, -1> {}
    function TEST (line 109) | TEST(TypeTraits, Conjunction) {
    function TEST (line 148) | TEST(TypeTraits, Disjunction) {
    function TEST (line 187) | TEST(TypeTraits, IsInvocableRV) {
    function TEST (line 257) | TEST(BuiltInDefaultValueTest, IsNullForPointerTypes) {
    function TEST (line 264) | TEST(BuiltInDefaultValueTest, ExistsForPointerTypes) {
    function TEST (line 272) | TEST(BuiltInDefaultValueTest, IsZeroForNumericTypes) {
    function TEST (line 301) | TEST(BuiltInDefaultValueTest, ExistsForNumericTypes) {
    function TEST (line 325) | TEST(BuiltInDefaultValueTest, IsFalseForBool) {
    function TEST (line 330) | TEST(BuiltInDefaultValueTest, BoolExists) {
    function TEST (line 336) | TEST(BuiltInDefaultValueTest, IsEmptyStringForString) {
    function TEST (line 342) | TEST(BuiltInDefaultValueTest, ExistsForString) {
    function TEST (line 348) | TEST(BuiltInDefaultValueTest, WorksForConstTypes) {
    class MyDefaultConstructible (line 356) | class MyDefaultConstructible {
      method MyDefaultConstructible (line 358) | MyDefaultConstructible() : value_(42) {}
      method value (line 360) | int value() const { return value_; }
    class MyNonDefaultConstructible (line 367) | class MyNonDefaultConstructible {
      method MyNonDefaultConstructible (line 370) | explicit MyNonDefaultConstructible(int a_value) : value_(a_value) {}
      method value (line 372) | int value() const { return value_; }
    function TEST (line 378) | TEST(BuiltInDefaultValueTest, ExistsForDefaultConstructibleType) {
    function TEST (line 382) | TEST(BuiltInDefaultValueTest, IsDefaultConstructedForDefaultConstructi...
    function TEST (line 386) | TEST(BuiltInDefaultValueTest, DoesNotExistForNonDefaultConstructibleTy...
    function TEST (line 391) | TEST(BuiltInDefaultValueDeathTest, IsUndefinedForReferences) {
    function TEST (line 396) | TEST(BuiltInDefaultValueDeathTest, IsUndefinedForNonDefaultConstructib...
    function TEST (line 402) | TEST(DefaultValueTest, IsInitiallyUnset) {
    function TEST (line 409) | TEST(DefaultValueTest, CanBeSetAndUnset) {
    function TEST (line 436) | TEST(DefaultValueDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {
    function TEST (line 448) | TEST(DefaultValueTest, GetWorksForMoveOnlyIfSet) {
    function TEST (line 459) | TEST(DefaultValueTest, GetWorksForVoid) { return DefaultValue<void>::G...
    function TEST (line 464) | TEST(DefaultValueOfReferenceTest, IsInitiallyUnset) {
    function TEST (line 471) | TEST(DefaultValueOfReferenceTest, IsInitiallyNotExisting) {
    function TEST (line 478) | TEST(DefaultValueOfReferenceTest, CanBeSetAndUnset) {
    function TEST (line 503) | TEST(DefaultValueOfReferenceDeathTest, GetReturnsBuiltInDefaultValueWh...
    class MyActionImpl (line 517) | class MyActionImpl : public ActionInterface<MyGlobalFunction> {
      method Perform (line 519) | int Perform(const std::tuple<bool, int>& args) override {
    function TEST (line 524) | TEST(ActionInterfaceTest, CanBeImplementedByDefiningPerform) {
    function TEST (line 529) | TEST(ActionInterfaceTest, MakeAction) {
    function TEST (line 542) | TEST(ActionTest, CanBeConstructedFromActionInterface) {
    function TEST (line 547) | TEST(ActionTest, DelegatesWorkToActionInterface) {
    function TEST (line 555) | TEST(ActionTest, IsCopyable) {
    class IsNotZero (line 581) | class IsNotZero : public ActionInterface<bool(int)> {  // NOLINT
      method Perform (line 583) | bool Perform(const std::tuple<int>& arg) override {
    function TEST (line 588) | TEST(ActionTest, CanBeConvertedToOtherActionType) {
    class ReturnSecondArgumentAction (line 599) | class ReturnSecondArgumentAction {
      method Result (line 605) | Result Perform(const ArgumentTuple& args) {
    class ReturnZeroFromNullaryFunctionAction (line 612) | class ReturnZeroFromNullaryFunctionAction {
      method Result (line 622) | Result Perform(const std::tuple<>&) const {
    function ReturnSecondArgument (line 630) | PolymorphicAction<ReturnSecondArgumentAction> ReturnSecondArgument() {
    function ReturnZeroFromNullaryFunction (line 634) | PolymorphicAction<ReturnZeroFromNullaryFunctionAction>
    function TEST (line 641) | TEST(MakePolymorphicActionTest, ConstructsActionFromImpl) {
    function TEST (line 648) | TEST(MakePolymorphicActionTest, WorksWhenPerformHasOneTemplateParamete...
    function TEST (line 658) | TEST(ReturnTest, WorksForVoid) {
    function TEST (line 664) | TEST(ReturnTest, ReturnsGivenValue) {
    function TEST (line 673) | TEST(ReturnTest, AcceptsStringLiteral) {
    function TEST (line 684) | TEST(ReturnTest, SupportsReferenceLikeReturnType) {
    function TEST (line 711) | TEST(ReturnTest, PrefersConversionOperator) {
    function TEST (line 746) | TEST(ReturnTest, ConversionRequiresConstLvalueReference) {
    function TEST (line 764) | TEST(ReturnTest, ConversionRequiresMutableLvalueReference) {
    function TEST (line 793) | TEST(ReturnTest, MoveOnlyResultType) {
    type Base (line 813) | struct Base {
    type Derived (line 817) | struct Derived : public Base {
    function TEST (line 821) | TEST(ReturnTest, IsCovariant) {
    class FromType (line 835) | class FromType {
      method FromType (line 837) | explicit FromType(bool* is_converted) : converted_(is_converted) {}
    class ToType (line 844) | class ToType {
      method ToType (line 847) | ToType(const FromType& x) { *x.converted() = true; }
    function TEST (line 850) | TEST(ReturnTest, ConvertsArgumentWhenConverted) {
    function TEST (line 863) | TEST(ReturnNullTest, WorksInPointerReturningFunction) {
    function TEST (line 873) | TEST(ReturnNullTest, WorksInSmartPointerReturningFunction) {
    function TEST (line 882) | TEST(ReturnRefTest, WorksForReference) {
    function TEST (line 890) | TEST(ReturnRefTest, IsCovariant) {
    function CanCallReturnRef (line 901) | bool CanCallReturnRef(T&&) {
    function CanCallReturnRef (line 904) | bool CanCallReturnRef(Unused) { return false; }
    function TEST (line 907) | TEST(ReturnRefTest, WorksForNonTemporary) {
    function TEST (line 922) | TEST(ReturnRefTest, DoesNotWorkForTemporary) {
    function TEST (line 938) | TEST(ReturnRefOfCopyTest, WorksForReference) {
    function TEST (line 951) | TEST(ReturnRefOfCopyTest, IsCovariant) {
    function TEST (line 962) | TEST(ReturnRoundRobinTest, WorksForInitList) {
    function TEST (line 974) | TEST(ReturnRoundRobinTest, WorksForVector) {
    class MockClass (line 988) | class MockClass {
      method MockClass (line 990) | MockClass() = default;
      method MockClass (line 1002) | MockClass(const MockClass&) = delete;
      method MockClass (line 1003) | MockClass& operator=(const MockClass&) = delete;
    function TEST (line 1008) | TEST(DoDefaultTest, ReturnsBuiltInDefaultValueByDefault) {
    function TEST (line 1016) | TEST(DoDefaultDeathTest, DiesForUnknowType) {
    function VoidFunc (line 1029) | void VoidFunc(bool /* flag */) {}
    function TEST (line 1031) | TEST(DoDefaultDeathTest, DiesIfUsedInCompositeAction) {
    function TEST (line 1044) | TEST(DoDefaultTest, ReturnsUserSpecifiedPerTypeDefaultValueWhenThereIs...
    function TEST (line 1053) | TEST(DoDefaultTest, DoesWhatOnCallSpecifies) {
    function TEST (line 1061) | TEST(DoDefaultTest, CannotBeUsedInOnCall) {
    function TEST (line 1072) | TEST(SetArgPointeeTest, SetsTheNthPointee) {
    function TEST (line 1091) | TEST(SetArgPointeeTest, AcceptsStringLiteral) {
    function TEST (line 1107) | TEST(SetArgPointeeTest, AcceptsWideStringLiteral) {
    function TEST (line 1126) | TEST(SetArgPointeeTest, AcceptsCharPointer) {
    function TEST (line 1145) | TEST(SetArgPointeeTest, AcceptsWideCharPointer) {
    function TEST (line 1167) | TEST(SetArgumentPointeeTest, SetsTheNthPointee) {
    function Nullary (line 1186) | int Nullary() { return 1; }
    class NullaryFunctor (line 1188) | class NullaryFunctor {
    function VoidNullary (line 1194) | void VoidNullary() { g_done = true; }
    class VoidNullaryFunctor (line 1196) | class VoidNullaryFunctor {
    function Short (line 1201) | short Short(short n) { return n; }
    function Char (line 1202) | char Char(char ch) { return ch; }
    function Unary (line 1206) | bool Unary(int x) { return x < 0; }
    function VoidBinary (line 1210) | void VoidBinary(int, char) { g_done = true; }
    function Ternary (line 1212) | int Ternary(int x, char y, short z) { return x + y + z; }
    function SumOf4 (line 1214) | int SumOf4(int a, int b, int c, int d) { return a + b + c + d; }
    class Foo (line 1216) | class Foo {
      method Foo (line 1218) | Foo() : value_(123) {}
      method Nullary (line 1220) | int Nullary() const { return value_; }
    function TEST (line 1227) | TEST(InvokeWithoutArgsTest, Function) {
    function TEST (line 1244) | TEST(InvokeWithoutArgsTest, Functor) {
    function TEST (line 1262) | TEST(InvokeWithoutArgsTest, Method) {
    function TEST (line 1270) | TEST(IgnoreResultTest, PolymorphicAction) {
    function ReturnOne (line 1277) | int ReturnOne() {
    function TEST (line 1282) | TEST(IgnoreResultTest, MonomorphicAction) {
    function MyNonDefaultConstructible (line 1291) | MyNonDefaultConstructible ReturnMyNonDefaultConstructible(double /* x ...
      method MyNonDefaultConstructible (line 370) | explicit MyNonDefaultConstructible(int a_value) : value_(a_value) {}
      method value (line 372) | int value() const { return value_; }
    function TEST (line 1296) | TEST(IgnoreResultTest, ActionReturningClass) {
    function TEST (line 1304) | TEST(AssignTest, Int) {
    function TEST (line 1311) | TEST(AssignTest, String) {
    function TEST (line 1318) | TEST(AssignTest, CompatibleTypes) {
    function TEST (line 1326) | TEST(DoAll, SupportsRefQualifiedActions) {
    function TEST (line 1344) | TEST(DoAll, ProvidesLvalueReferencesToInitialActions) {
    function TEST (line 1451) | TEST(DoAll, SupportsTypeErasedActions) {
    function TEST (line 1486) | TEST(DoAll, ConvertibleToOnceActionWithUserProvidedActionConversion) {
    function TEST (line 1521) | TEST(WithArgsTest, OneArg) {
    function TEST (line 1528) | TEST(WithArgsTest, TwoArgs) {
    type ConcatAll (line 1535) | struct ConcatAll {
    function TEST (line 1544) | TEST(WithArgsTest, TenArgs) {
    class SubtractAction (line 1553) | class SubtractAction : public ActionInterface<int(int, int)> {
      method Perform (line 1555) | int Perform(const std::tuple<int, int>& args) override {
    function TEST (line 1560) | TEST(WithArgsTest, NonInvokeAction) {
    function TEST (line 1569) | TEST(WithArgsTest, Identity) {
    function TEST (line 1576) | TEST(WithArgsTest, RepeatedArguments) {
    function TEST (line 1583) | TEST(WithArgsTest, ReversedArgumentOrder) {
    function TEST (line 1591) | TEST(WithArgsTest, ArgsOfCompatibleTypes) {
    function TEST (line 1599) | TEST(WithArgsTest, VoidAction) {
    function TEST (line 1606) | TEST(WithArgsTest, ReturnReference) {
    function TEST (line 1613) | TEST(WithArgsTest, InnerActionWithConversion) {
    function TEST (line 1627) | TEST(WithArgsTest, RefQualifiedInnerAction) {
    function TEST (line 1642) | TEST(WithArgsTest, ProvideAsLvalueToWillOnce) {
    class SetErrnoAndReturnTest (line 1658) | class SetErrnoAndReturnTest : public testing::Test {
      method SetUp (line 1660) | void SetUp() override { errno = 0; }
      method TearDown (line 1661) | void TearDown() override { errno = 0; }
    function TEST_F (line 1664) | TEST_F(SetErrnoAndReturnTest, Int) {
    function TEST_F (line 1670) | TEST_F(SetErrnoAndReturnTest, Ptr) {
    function TEST_F (line 1677) | TEST_F(SetErrnoAndReturnTest, CompatibleTypes) {
    function TEST (line 1688) | TEST(ByRefTest, IsCopyable) {
    function TEST (line 1709) | TEST(ByRefTest, ConstValue) {
    function TEST (line 1718) | TEST(ByRefTest, NonConstValue) {
    function TEST (line 1731) | TEST(ByRefTest, ExplicitType) {
    function TEST (line 1760) | TEST(ByRefTest, PrintsCorrectly) {
    type UnaryConstructorClass (line 1768) | struct UnaryConstructorClass {
      method UnaryConstructorClass (line 1769) | explicit UnaryConstructorClass(int v) : value(v) {}
    function TEST (line 1774) | TEST(ReturnNewTest, Unary) {
    function TEST (line 1781) | TEST(ReturnNewTest, UnaryWorksWhenMockMethodHasArgs) {
    function TEST (line 1789) | TEST(ReturnNewTest, UnaryWorksWhenMockMethodReturnsPointerToConst) {
    class TenArgConstructorClass (line 1797) | class TenArgConstructorClass {
      method TenArgConstructorClass (line 1799) | TenArgConstructorClass(int a1, int a2, int a3, int a4, int a5, int a...
    function TEST (line 1806) | TEST(ReturnNewTest, ConstructorThatTakes10Arguments) {
    function UniquePtrSource (line 1815) | std::unique_ptr<int> UniquePtrSource() { return std::make_unique<int>(...
    function VectorUniquePtrSource (line 1817) | std::vector<std::unique_ptr<int>> VectorUniquePtrSource() {
    function TEST (line 1823) | TEST(MockMethodTest, CanReturnMoveOnlyValue_Return) {
    function TEST (line 1845) | TEST(MockMethodTest, CanReturnMoveOnlyValue_DoAllReturn) {
    function TEST (line 1859) | TEST(MockMethodTest, CanReturnMoveOnlyValue_Invoke) {
    function TEST (line 1881) | TEST(MockMethodTest, CanTakeMoveOnlyValue) {
    function TEST (line 1926) | TEST(MockMethodTest, ActionHasRvalueRefQualifiedCallOperator) {
    function TEST (line 1952) | TEST(MockMethodTest, ActionHasMultipleCallOperators) {
    function TEST (line 1981) | TEST(MockMethodTest, MoveOnlyAction) {
    function TEST (line 2019) | TEST(MockMethodTest, ActionReturnsIgnoredValue) {
    function TEST (line 2033) | TEST(MockMethodTest, WillOnceCanAcceptLvalueReference) {
    type StaticAssertSingleArgument (line 2044) | struct StaticAssertSingleArgument {
      method CheckArgs (line 2046) | static constexpr bool CheckArgs() {
    function TEST (line 2061) | TEST(MockMethodTest, ActionSwallowsAllArguments) {
    type ActionWithTemplatedConversionOperators (line 2071) | struct ActionWithTemplatedConversionOperators {
    function TEST (line 2086) | TEST(MockMethodTest, ActionHasTemplatedConversionOperators) {
    function Add (line 2098) | int Add(int val, int& ref, int* ptr) {  // NOLINT
    function Deref (line 2105) | int Deref(std::unique_ptr<int> ptr) { return *ptr; }
    type Double (line 2107) | struct Double {
      method T (line 2109) | T operator()(T t) {
    function UniqueInt (line 2114) | std::unique_ptr<int> UniqueInt(int i) { return std::make_unique<int>(i...
    function TEST (line 2116) | TEST(FunctorActionTest, ActionFromFunction) {
    function TEST (line 2127) | TEST(FunctorActionTest, ActionFromLambda) {
    function TEST (line 2140) | TEST(FunctorActionTest, PolymorphicFunctor) {
    function TEST (line 2147) | TEST(FunctorActionTest, TypeConversion) {
    function TEST (line 2176) | TEST(FunctorActionTest, UnusedArguments) {
    function TEST (line 2186) | TEST(MoveOnlyArgumentsTest, ReturningActions) {
    function ACTION (line 2199) | ACTION(ReturnArity) { return std::tuple_size<args_type>::value; }
    function TEST (line 2201) | TEST(ActionMacro, LargeArity) {

FILE: googlemock/test/gmock-cardinalities_test.cc
  class MockFoo (line 53) | class MockFoo {
    method MockFoo (line 55) | MockFoo() = default;
    method MockFoo (line 59) | MockFoo(const MockFoo&) = delete;
    method MockFoo (line 60) | MockFoo& operator=(const MockFoo&) = delete;
  function TEST (line 64) | TEST(CardinalityTest, IsDefaultConstructable) { Cardinality c; }
  function TEST (line 67) | TEST(CardinalityTest, IsCopyable) {
  function TEST (line 81) | TEST(CardinalityTest, IsOverSaturatedByCallCountWorks) {
  function TEST (line 90) | TEST(CardinalityTest, CanDescribeActualCallCount) {
  function TEST (line 109) | TEST(AnyNumber, Works) {
  function TEST (line 125) | TEST(AnyNumberTest, HasCorrectBounds) {
  function TEST (line 133) | TEST(AtLeastTest, OnNegativeNumber) {
  function TEST (line 141) | TEST(AtLeastTest, OnZero) {
  function TEST (line 154) | TEST(AtLeastTest, OnPositiveNumber) {
  function TEST (line 178) | TEST(AtLeastTest, HasCorrectBounds) {
  function TEST (line 186) | TEST(AtMostTest, OnNegativeNumber) {
  function TEST (line 194) | TEST(AtMostTest, OnZero) {
  function TEST (line 207) | TEST(AtMostTest, OnPositiveNumber) {
  function TEST (line 231) | TEST(AtMostTest, HasCorrectBounds) {
  function TEST (line 239) | TEST(BetweenTest, OnNegativeStart) {
  function TEST (line 247) | TEST(BetweenTest, OnNegativeEnd) {
  function TEST (line 255) | TEST(BetweenTest, OnStartBiggerThanEnd) {
  function TEST (line 264) | TEST(BetweenTest, OnZeroStartAndZeroEnd) {
  function TEST (line 278) | TEST(BetweenTest, OnZeroStartAndNonZeroEnd) {
  function TEST (line 295) | TEST(BetweenTest, OnSameStartAndEnd) {
  function TEST (line 312) | TEST(BetweenTest, OnDifferentStartAndEnd) {
  function TEST (line 332) | TEST(BetweenTest, HasCorrectBounds) {
  function TEST (line 340) | TEST(ExactlyTest, OnNegativeNumber) {
  function TEST (line 348) | TEST(ExactlyTest, OnZero) {
  function TEST (line 361) | TEST(ExactlyTest, OnPositiveNumber) {
  function TEST (line 382) | TEST(ExactlyTest, HasCorrectBounds) {
  class EvenCardinality (line 391) | class EvenCardinality : public CardinalityInterface {
    method IsSatisfiedByCallCount (line 395) | bool IsSatisfiedByCallCount(int call_count) const override {
    method IsSaturatedByCallCount (line 401) | bool IsSaturatedByCallCount(int /* call_count */) const override {
    method DescribeTo (line 406) | void DescribeTo(::std::ostream* ss) const override {
  function TEST (line 411) | TEST(MakeCardinalityTest, ConstructsCardinalityFromInterface) {

FILE: googlemock/test/gmock-function-mocker_test.cc
  type testing (line 60) | namespace testing {
    type gmock_function_mocker_test (line 61) | namespace gmock_function_mocker_test {
      class TemplatedCopyable (line 78) | class TemplatedCopyable {
        method TemplatedCopyable (line 80) | TemplatedCopyable() = default;
        method TemplatedCopyable (line 83) | TemplatedCopyable(const U& other) {}
      class FooInterface (line 86) | class FooInterface {
      class MockFoo (line 145) | class MockFoo : public FooInterface {
        method MockFoo (line 147) | MockFoo() = default;
        method MockFoo (line 212) | MockFoo(const MockFoo&) = delete;
        method MockFoo (line 213) | MockFoo& operator=(const MockFoo&) = delete;
      class LegacyMockFoo (line 216) | class LegacyMockFoo : public FooInterface {
        method LegacyMockFoo (line 218) | LegacyMockFoo() = default;
        method RefQualifiedConstRef (line 275) | int RefQualifiedConstRef() const& override { return 0; }
        method RefQualifiedConstRefRef (line 276) | int RefQualifiedConstRefRef() const&& override { return 0; }
        method RefQualifiedRef (line 277) | int RefQualifiedRef() & override { return 0; }
        method RefQualifiedRefRef (line 278) | int RefQualifiedRefRef() && override { return 0; }
        method RefQualifiedOverloaded (line 279) | int RefQualifiedOverloaded() const& override { return 0; }
        method RefQualifiedOverloaded (line 280) | int RefQualifiedOverloaded() const&& override { return 0; }
        method RefQualifiedOverloaded (line 281) | int RefQualifiedOverloaded() & override { return 0; }
        method RefQualifiedOverloaded (line 282) | int RefQualifiedOverloaded() && override { return 0; }
        method LegacyMockFoo (line 285) | LegacyMockFoo(const LegacyMockFoo&) = delete;
        method LegacyMockFoo (line 286) | LegacyMockFoo& operator=(const LegacyMockFoo&) = delete;
      class FunctionMockerTest (line 292) | class FunctionMockerTest : public testing::Test {
        method FunctionMockerTest (line 294) | FunctionMockerTest() : foo_(&mock_foo_) {}
      function TYPED_TEST (line 303) | TYPED_TEST(FunctionMockerTest, MocksVoidFunction) {
      function TYPED_TEST (line 309) | TYPED_TEST(FunctionMockerTest, MocksNullaryFunction) {
      function TYPED_TEST (line 319) | TYPED_TEST(FunctionMockerTest, MocksUnaryFunction) {
      function TYPED_TEST (line 327) | TYPED_TEST(FunctionMockerTest, MocksBinaryFunction) {
      function TYPED_TEST (line 334) | TYPED_TEST(FunctionMockerTest, MocksDecimalFunction) {
      function TYPED_TEST (line 343) | TYPED_TEST(FunctionMockerTest, MocksFunctionWithNonConstReferenceArg...
      function TYPED_TEST (line 352) | TYPED_TEST(FunctionMockerTest, MocksFunctionWithConstReferenceArgume...
      function TYPED_TEST (line 361) | TYPED_TEST(FunctionMockerTest, MocksFunctionWithConstArgument) {
      function TYPED_TEST (line 368) | TYPED_TEST(FunctionMockerTest, MocksFunctionsOverloadedOnArgumentNum...
      function TYPED_TEST (line 379) | TYPED_TEST(FunctionMockerTest, MocksFunctionsOverloadedOnArgumentTyp...
      function TYPED_TEST (line 390) | TYPED_TEST(FunctionMockerTest, MocksFunctionsOverloadedOnConstnessOf...
      function TYPED_TEST (line 399) | TYPED_TEST(FunctionMockerTest, MocksReturnTypeWithComma) {
      function TYPED_TEST (line 408) | TYPED_TEST(FunctionMockerTest, MocksTypeWithTemplatedCopyCtor) {
      function TYPED_TEST (line 416) | TYPED_TEST(FunctionMockerTest, MocksNullaryFunctionWithCallType) {
      function TYPED_TEST (line 426) | TYPED_TEST(FunctionMockerTest, MocksUnaryFunctionWithCallType) {
      function TYPED_TEST (line 437) | TYPED_TEST(FunctionMockerTest, MocksDecimalFunctionWithCallType) {
      function TYPED_TEST (line 446) | TYPED_TEST(FunctionMockerTest, MocksFunctionsConstFunctionWithCallTy...
      function TYPED_TEST (line 452) | TYPED_TEST(FunctionMockerTest, MocksReturnTypeWithCommaAndCallType) {
      function TEST (line 461) | TEST(FunctionMockerTest, RefQualified) {
      class MockB (line 495) | class MockB {
        method MockB (line 497) | MockB() = default;
        method MockB (line 502) | MockB(const MockB&) = delete;
        method MockB (line 503) | MockB& operator=(const MockB&) = delete;
      class LegacyMockB (line 506) | class LegacyMockB {
        method LegacyMockB (line 508) | LegacyMockB() = default;
        method LegacyMockB (line 513) | LegacyMockB(const LegacyMockB&) = delete;
        method LegacyMockB (line 514) | LegacyMockB& operator=(const LegacyMockB&) = delete;
      class ExpectCallTest (line 518) | class ExpectCallTest : public ::testing::Test {}
      function TYPED_TEST (line 524) | TYPED_TEST(ExpectCallTest, UnmentionedFunctionCanBeCalledAnyNumberOf...
      class StackInterface (line 542) | class StackInterface {
      class MockStack (line 555) | class MockStack : public StackInterface<T> {
        method MockStack (line 557) | MockStack() = default;
        method MockStack (line 569) | MockStack(const MockStack&) = delete;
        method MockStack (line 570) | MockStack& operator=(const MockStack&) = delete;
      class LegacyMockStack (line 574) | class LegacyMockStack : public StackInterface<T> {
        method LegacyMockStack (line 576) | LegacyMockStack() = default;
        method LegacyMockStack (line 588) | LegacyMockStack(const LegacyMockStack&) = delete;
        method LegacyMockStack (line 589) | LegacyMockStack& operator=(const LegacyMockStack&) = delete;
      class TemplateMockTest (line 593) | class TemplateMockTest : public ::testing::Test {}
      function TYPED_TEST (line 599) | TYPED_TEST(TemplateMockTest, Works) {
      function TYPED_TEST (line 619) | TYPED_TEST(TemplateMockTest, MethodWithCommaInReturnTypeWorks) {
      class StackInterfaceWithCallType (line 634) | class StackInterfaceWithCallType {
      class MockStackWithCallType (line 647) | class MockStackWithCallType : public StackInterfaceWithCallType<T> {
        method MockStackWithCallType (line 649) | MockStackWithCallType() {}
        method MockStackWithCallType (line 659) | MockStackWithCallType(const MockStackWithCallType&) = delete;
        method MockStackWithCallType (line 660) | MockStackWithCallType& operator=(const MockStackWithCallType&) = d...
      class LegacyMockStackWithCallType (line 664) | class LegacyMockStackWithCallType : public StackInterfaceWithCallTyp...
        method LegacyMockStackWithCallType (line 666) | LegacyMockStackWithCallType() {}
        method LegacyMockStackWithCallType (line 674) | LegacyMockStackWithCallType(const LegacyMockStackWithCallType&) = ...
        method LegacyMockStackWithCallType (line 675) | LegacyMockStackWithCallType& operator=(const LegacyMockStackWithCa...
      class TemplateMockTestWithCallType (line 680) | class TemplateMockTestWithCallType : public ::testing::Test {}
      function TYPED_TEST (line 688) | TYPED_TEST(TemplateMockTestWithCallType, Works) {
      class MockOverloadedOnArgNumber (line 719) | class MockOverloadedOnArgNumber {
        method MockOverloadedOnArgNumber (line 721) | MockOverloadedOnArgNumber() = default;
        method MockOverloadedOnArgNumber (line 726) | MockOverloadedOnArgNumber(const MockOverloadedOnArgNumber&) = delete;
        method MockOverloadedOnArgNumber (line 727) | MockOverloadedOnArgNumber& operator=(const MockOverloadedOnArgNumb...
      class LegacyMockOverloadedOnArgNumber (line 731) | class LegacyMockOverloadedOnArgNumber {
        method LegacyMockOverloadedOnArgNumber (line 733) | LegacyMockOverloadedOnArgNumber() = default;
        method LegacyMockOverloadedOnArgNumber (line 738) | LegacyMockOverloadedOnArgNumber(const LegacyMockOverloadedOnArgNum...
        method LegacyMockOverloadedOnArgNumber (line 740) | LegacyMockOverloadedOnArgNumber& operator=(
      class OverloadedMockMethodTest (line 745) | class OverloadedMockMethodTest : public ::testing::Test {}
      function TYPED_TEST (line 751) | TYPED_TEST(OverloadedMockMethodTest, CanOverloadOnArgNumberInMacroBo...
      class MockOverloadedOnConstness (line 766) | class MockOverloadedOnConstness {
        method MockOverloadedOnConstness (line 768) | MockOverloadedOnConstness() = default;
        method MockOverloadedOnConstness (line 773) | MockOverloadedOnConstness(const MockOverloadedOnConstness&) = delete;
        method MockOverloadedOnConstness (line 774) | MockOverloadedOnConstness& operator=(const MockOverloadedOnConstne...
      function TEST (line 778) | TEST(MockMethodOverloadedMockMethodTest, CanOverloadOnConstnessInMac...
      function TEST (line 788) | TEST(MockMethodMockFunctionTest, WorksForVoidNullary) {
      function TEST (line 794) | TEST(MockMethodMockFunctionTest, WorksForNonVoidNullary) {
      function TEST (line 801) | TEST(MockMethodMockFunctionTest, WorksForVoidUnary) {
      function TEST (line 807) | TEST(MockMethodMockFunctionTest, WorksForNonVoidBinary) {
      function TEST (line 816) | TEST(MockMethodMockFunctionTest, WorksFor10Arguments) {
      function TEST (line 827) | TEST(MockMethodMockFunctionTest, AsStdFunction) {
      function TEST (line 836) | TEST(MockMethodMockFunctionTest, AsStdFunctionReturnsReference) {
      function TEST (line 846) | TEST(MockMethodMockFunctionTest, AsStdFunctionWithReferenceParameter) {
      function IsMockFunctionTemplateArgumentDeducedTo (line 857) | static constexpr bool IsMockFunctionTemplateArgumentDeducedTo(
      class MockMethodMockFunctionSignatureTest (line 865) | class MockMethodMockFunctionSignatureTest : public Test {}
      function TYPED_TEST (line 873) | TYPED_TEST(MockMethodMockFunctionSignatureTest,
      function TYPED_TEST (line 880) | TYPED_TEST(MockMethodMockFunctionSignatureTest,
      function TYPED_TEST (line 887) | TYPED_TEST(
      type AlternateCallable (line 897) | struct AlternateCallable {}
      function TYPED_TEST (line 899) | TYPED_TEST(MockMethodMockFunctionSignatureTest,
      function TYPED_TEST (line 906) | TYPED_TEST(MockMethodMockFunctionSignatureTest,
      type MockMethodSizes0 (line 914) | struct MockMethodSizes0 {
      type MockMethodSizes1 (line 917) | struct MockMethodSizes1 {
      type MockMethodSizes2 (line 920) | struct MockMethodSizes2 {
      type MockMethodSizes3 (line 923) | struct MockMethodSizes3 {
      type MockMethodSizes4 (line 926) | struct MockMethodSizes4 {
      type LegacyMockMethodSizes0 (line 930) | struct LegacyMockMethodSizes0 {
      type LegacyMockMethodSizes1 (line 933) | struct LegacyMockMethodSizes1 {
      type LegacyMockMethodSizes2 (line 936) | struct LegacyMockMethodSizes2 {
      type LegacyMockMethodSizes3 (line 939) | struct LegacyMockMethodSizes3 {
      type LegacyMockMethodSizes4 (line 942) | struct LegacyMockMethodSizes4 {
      function TEST (line 946) | TEST(MockMethodMockFunctionTest, MockMethodSizeOverhead) {
      function TEST (line 960) | TEST(MockMethodMockFunctionTest, EnsureNoUnusedMemberFunction) {
      type MockMethodNoexceptSpecifier (line 978) | struct MockMethodNoexceptSpecifier {
      function TEST (line 990) | TEST(MockMethodMockFunctionTest, NoexceptSpecifierPreserved) {

FILE: googlemock/test/gmock-internal-utils_test.cc
  type proto2 (line 64) | namespace proto2 {
    class Message (line 65) | class Message
  type testing (line 68) | namespace testing {
    type internal (line 69) | namespace internal {
      function TEST (line 73) | TEST(JoinAsKeyValueTupleTest, JoinsEmptyTuple) {
      function TEST (line 77) | TEST(JoinAsKeyValueTupleTest, JoinsOneTuple) {
      function TEST (line 81) | TEST(JoinAsKeyValueTupleTest, JoinsTwoTuple) {
      function TEST (line 85) | TEST(JoinAsKeyValueTupleTest, JoinsTenTuple) {
      function TEST (line 92) | TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsNoWord) {
      function TEST (line 98) | TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsDigits) {
      function TEST (line 105) | TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsCamelCas...
      function TEST (line 113) | TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContains_Separat...
      function TEST (line 120) | TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameIsMixture) {
      function TEST (line 126) | TEST(GetRawPointerTest, WorksForSmartPointers) {
      function TEST (line 135) | TEST(GetRawPointerTest, WorksForRawPointers) {
      function TEST (line 142) | TEST(GetRawPointerTest, WorksForStdReferenceWrapper) {
      class Base (line 150) | class Base {}
      class Derived (line 151) | class Derived : public Base {}
      function TEST (line 153) | TEST(KindOfTest, Bool) {
      function TEST (line 157) | TEST(KindOfTest, Integer) {
      function TEST (line 177) | TEST(KindOfTest, FloatingPoint) {
      function TEST (line 183) | TEST(KindOfTest, Other) {
      function TEST (line 191) | TEST(LosslessArithmeticConvertibleTest, BoolToBool) {
      function TEST (line 195) | TEST(LosslessArithmeticConvertibleTest, BoolToInteger) {
      function TEST (line 202) | TEST(LosslessArithmeticConvertibleTest, BoolToFloatingPoint) {
      function TEST (line 207) | TEST(LosslessArithmeticConvertibleTest, IntegerToBool) {
      function TEST (line 212) | TEST(LosslessArithmeticConvertibleTest, IntegerToInteger) {
      function TEST (line 246) | TEST(LosslessArithmeticConvertibleTest, IntegerToFloatingPoint) {
      function TEST (line 255) | TEST(LosslessArithmeticConvertibleTest, FloatingPointToBool) {
      function TEST (line 260) | TEST(LosslessArithmeticConvertibleTest, FloatingPointToInteger) {
      function TEST (line 266) | TEST(LosslessArithmeticConvertibleTest, FloatingPointToFloatingPoint) {
      function TEST (line 291) | TEST(TupleMatchesTest, WorksForSize0) {
      function TEST (line 298) | TEST(TupleMatchesTest, WorksForSize1) {
      function TEST (line 306) | TEST(TupleMatchesTest, WorksForSize2) {
      function TEST (line 317) | TEST(TupleMatchesTest, WorksForSize5) {
      function TEST (line 332) | TEST(AssertTest, SucceedsOnTrue) {
      function TEST (line 338) | TEST(AssertTest, FailsFatallyOnFalse) {
      function TEST (line 346) | TEST(ExpectTest, SucceedsOnTrue) {
      function TEST (line 352) | TEST(ExpectTest, FailsNonfatallyOnFalse) {
      class LogIsVisibleTest (line 368) | class LogIsVisibleTest : public ::testing::Test {
        method SetUp (line 370) | void SetUp() override { original_verbose_ = GMOCK_FLAG_GET(verbose...
        method TearDown (line 372) | void TearDown() override { GMOCK_FLAG_SET(verbose, original_verbos...
      function TEST_F (line 377) | TEST_F(LogIsVisibleTest, AlwaysReturnsTrueIfVerbosityIsInfo) {
      function TEST_F (line 383) | TEST_F(LogIsVisibleTest, AlwaysReturnsFalseIfVerbosityIsError) {
      function TEST_F (line 389) | TEST_F(LogIsVisibleTest, WorksWhenVerbosityIsWarning) {
      function TestLogWithSeverity (line 401) | void TestLogWithSeverity(const std::string& verbosity, LogSeverity s...
      function TEST (line 421) | TEST(LogTest, NoStackTraceWhenStackFramesToSkipIsNegative) {
      type MockStackTraceGetter (line 430) | struct MockStackTraceGetter : testing::internal::OsStackTraceGetterI...
        method CurrentStackTrace (line 431) | std::string CurrentStackTrace(int max_depth, int skip_count) overr...
        method UponLeavingGTest (line 435) | void UponLeavingGTest() override {}
      function TEST (line 440) | TEST(LogTest, NoSkippingStackFrameInOptMode) {
      function TEST (line 479) | TEST(LogTest, AllLogsArePrintedWhenVerbosityIsInfo) {
      function TEST (line 486) | TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsWarning) {
      function TEST (line 493) | TEST(LogTest, NoLogsArePrintedWhenVerbosityIsError) {
      function TEST (line 500) | TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsInvalid) {
      function GrabOutput (line 507) | std::string GrabOutput(void (*logger)(), const char* verbosity) {
      class DummyMock (line 516) | class DummyMock {
      function ExpectCallLogger (line 522) | void ExpectCallLogger() {
      function TEST (line 529) | TEST(ExpectCallTest, LogsWhenVerbosityIsInfo) {
      function TEST (line 536) | TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsWarning) {
      function TEST (line 542) | TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsError) {
      function OnCallLogger (line 546) | void OnCallLogger() {
      function TEST (line 552) | TEST(OnCallTest, LogsWhenVerbosityIsInfo) {
      function TEST (line 559) | TEST(OnCallTest, DoesNotLogWhenVerbosityIsWarning) {
      function TEST (line 565) | TEST(OnCallTest, DoesNotLogWhenVerbosityIsError) {
      function OnCallAnyArgumentLogger (line 569) | void OnCallAnyArgumentLogger() {
      function TEST (line 575) | TEST(OnCallTest, LogsAnythingArgument) {
      function TEST (line 584) | TEST(StlContainerViewTest, WorksForStlContainer) {
      function TEST (line 600) | TEST(StlContainerViewTest, WorksForStaticNativeArray) {
      function TEST (line 626) | TEST(StlContainerViewTest, WorksForDynamicNativeArray) {
      function TEST (line 659) | TEST(FunctionTest, Nullary) {
      function TEST (line 669) | TEST(FunctionTest, Unary) {
      function TEST (line 682) | TEST(FunctionTest, Binary) {
      function TEST (line 699) | TEST(FunctionTest, LongArgumentList) {
      function TEST (line 724) | TEST(Base64Unescape, InvalidString) {
      function TEST (line 729) | TEST(Base64Unescape, ShortString) {
      function TEST (line 735) | TEST(Base64Unescape, ShortStringWithPadding) {
      function TEST (line 741) | TEST(Base64Unescape, ShortStringWithoutPadding) {
      function TEST (line 747) | TEST(Base64Unescape, LongStringWithWhiteSpaces) {

FILE: googlemock/test/gmock-matchers-arithmetic_test.cc
  type testing (line 48) | namespace testing {
    type gmock_matchers_test (line 49) | namespace gmock_matchers_test {
      function TEST (line 56) | TEST(Eq2Test, MatchesEqualArguments) {
      function TEST (line 63) | TEST(Eq2Test, CanDescribeSelf) {
      function TEST (line 70) | TEST(Ge2Test, MatchesGreaterThanOrEqualArguments) {
      function TEST (line 78) | TEST(Ge2Test, CanDescribeSelf) {
      function TEST (line 85) | TEST(Gt2Test, MatchesGreaterThanArguments) {
      function TEST (line 93) | TEST(Gt2Test, CanDescribeSelf) {
      function TEST (line 100) | TEST(Le2Test, MatchesLessThanOrEqualArguments) {
      function TEST (line 108) | TEST(Le2Test, CanDescribeSelf) {
      function TEST (line 115) | TEST(Lt2Test, MatchesLessThanArguments) {
      function TEST (line 123) | TEST(Lt2Test, CanDescribeSelf) {
      function TEST (line 130) | TEST(Ne2Test, MatchesUnequalArguments) {
      function TEST (line 138) | TEST(Ne2Test, CanDescribeSelf) {
      function TEST (line 143) | TEST(PairMatchBaseTest, WorksWithMoveOnly) {
      function TEST (line 153) | TEST(IsNan, FloatMatchesNan) {
      function TEST (line 175) | TEST(IsNan, DoubleMatchesNan) {
      function TEST (line 197) | TEST(IsNan, LongDoubleMatchesNan) {
      function TEST (line 219) | TEST(IsNan, NotMatchesNan) {
      function TEST (line 237) | TEST(IsNan, CanDescribeSelf) {
      function TEST (line 249) | TEST(IsNan, CanDescribeSelfWithNot) {
      function TEST (line 262) | TEST(FloatEq2Test, MatchesEqualArguments) {
      function TEST (line 271) | TEST(FloatEq2Test, CanDescribeSelf) {
      function TEST (line 278) | TEST(NanSensitiveFloatEqTest, MatchesEqualArgumentsWithNaN) {
      function TEST (line 290) | TEST(NanSensitiveFloatEqTest, CanDescribeSelfWithNaNs) {
      function TEST (line 297) | TEST(DoubleEq2Test, MatchesEqualArguments) {
      function TEST (line 306) | TEST(DoubleEq2Test, CanDescribeSelf) {
      function TEST (line 313) | TEST(NanSensitiveDoubleEqTest, MatchesEqualArgumentsWithNaN) {
      function TEST (line 325) | TEST(NanSensitiveDoubleEqTest, CanDescribeSelfWithNaNs) {
      function TEST (line 332) | TEST(FloatNear2Test, MatchesEqualArguments) {
      function TEST (line 341) | TEST(FloatNear2Test, CanDescribeSelf) {
      function TEST (line 348) | TEST(NanSensitiveFloatNearTest, MatchesNearbyArgumentsWithNaN) {
      function TEST (line 361) | TEST(NanSensitiveFloatNearTest, CanDescribeSelfWithNaNs) {
      function TEST (line 368) | TEST(DoubleNear2Test, MatchesEqualArguments) {
      function TEST (line 377) | TEST(DoubleNear2Test, CanDescribeSelf) {
      function TEST (line 384) | TEST(NanSensitiveDoubleNearTest, MatchesNearbyArgumentsWithNaN) {
      function TEST (line 397) | TEST(NanSensitiveDoubleNearTest, CanDescribeSelfWithNaNs) {
      function TEST (line 403) | TEST(DistanceFrom, CanDescribeSelf) {
      function TEST (line 412) | TEST(DistanceFrom, CanExplainMatchFailure) {
      function TEST (line 419) | TEST(DistanceFrom, MatchesDoubleWithinRange) {
      function TEST (line 430) | TEST(DistanceFrom, MatchesDoubleRefWithinRange) {
      function TEST (line 441) | TEST(DistanceFrom, CanBeImplicitlyConvertedToMatcher) {
      function TEST (line 451) | TEST(DistanceFrom, CanBeUsedOnCompatibleTypes) {
      class Point (line 473) | class Point {
        method Point (line 475) | Point(double x, double y) : x_(x), y_(y) {}
        method x (line 476) | double x() const { return x_; }
        method y (line 477) | double y() const { return y_; }
      function PointDistance (line 485) | double PointDistance(const Point& lhs, const Point& rhs) {
      function TEST (line 492) | TEST(DistanceFrom, CanBeUsedOnTypeWithCustomDistanceFunction) {
      class Double (line 502) | class Double {
        method Double (line 504) | explicit Double(double value) : value_(value) {}
        method Double (line 505) | Double(const Double& other) = default;
        method value (line 506) | double value() const { return value_; }
        method PrintTo (line 510) | void PrintTo(const Double& value, std::ostream* os) {
      function Double (line 519) | Double DoubleDistance(Double lhs, Double rhs) {
        method Double (line 504) | explicit Double(double value) : value_(value) {}
        method Double (line 505) | Double(const Double& other) = default;
        method value (line 506) | double value() const { return value_; }
        method PrintTo (line 510) | void PrintTo(const Double& value, std::ostream* os) {
      function TEST (line 529) | TEST(DistanceFrom, CanDescribeWithCustomPrinter) {
      function TEST (line 538) | TEST(DistanceFrom, CanCustomizeDistanceAndComparator) {
      class Float (line 548) | class Float {
        method Float (line 550) | explicit Float(float value) : value_(value) {}
        method Float (line 551) | Float(const Float& other) = default;
        method value (line 552) | float value() const { return value_; }
      function Float (line 560) | Float operator-(const Float& lhs, const Float& rhs) {
        method Float (line 550) | explicit Float(float value) : value_(value) {}
        method Float (line 551) | Float(const Float& other) = default;
        method value (line 552) | float value() const { return value_; }
      function Float (line 566) | Float abs(Float value) { return Float(std::abs(value.value())); }
        method Float (line 550) | explicit Float(float value) : value_(value) {}
        method Float (line 551) | Float(const Float& other) = default;
        method value (line 552) | float value() const { return value_; }
      function TEST (line 576) | TEST(DistanceFrom, CanBeUsedWithTypeThatSupportsBothMinusAndAbs) {
      function TEST (line 585) | TEST(NotTest, NegatesMatcher) {
      function TEST (line 593) | TEST(NotTest, CanDescribeSelf) {
      function TEST (line 599) | TEST(NotTest, NotMatcherSafelyCastsMonomorphicMatchers) {
      function AllOfMatches (line 609) | void AllOfMatches(int num, const Matcher<int>& m) {
      function TEST (line 622) | TEST(AllOfTest, MatchesWhenAllMatch) {
      function TEST (line 675) | TEST(AllOfTest, CanDescribeSelf) {
      function TEST (line 699) | TEST(AllOfTest, CanDescribeNegation) {
      function TEST (line 728) | TEST(AllOfTest, AllOfMatcherSafelyCastsMonomorphicMatchers) {
      function TEST_P (line 742) | TEST_P(AllOfTestP, ExplainsResult) {
      function AnyOfMatches (line 788) | static void AnyOfMatches(int num, const Matcher<int>& m) {
      function AnyOfStringMatches (line 797) | static void AnyOfStringMatches(int num, const Matcher<std::string>& ...
      function TEST (line 811) | TEST(AnyOfTest, MatchesWhenAnyMatches) {
      function TEST (line 853) | TEST(AnyOfTest, VariadicMatchesWhenAnyMatches) {
      function TEST (line 872) | TEST(ConditionalTest, MatchesFirstIfCondition) {
      function TEST (line 886) | TEST(ConditionalTest, MatchesSecondIfCondition) {
      function TEST (line 901) | TEST(AnyOfTest, CanDescribeSelf) {
      function TEST (line 922) | TEST(AnyOfTest, CanDescribeNegation) {
      function TEST (line 945) | TEST(AnyOfTest, AnyOfMatcherSafelyCastsMonomorphicMatchers) {
      function TEST_P (line 959) | TEST_P(AnyOfTestP, ExplainsResult) {
      function IsPositive (line 1008) | int IsPositive(double x) { return x > 0 ? 1 : 0; }
      class IsGreaterThan (line 1012) | class IsGreaterThan {
        method IsGreaterThan (line 1014) | explicit IsGreaterThan(int threshold) : threshold_(threshold) {}
      function ReferencesFooAndIsZero (line 1027) | bool ReferencesFooAndIsZero(const int& n) { return (&n == &foo) && (...
      function TEST (line 1031) | TEST(TrulyTest, MatchesWhatSatisfiesThePredicate) {
      function TEST (line 1038) | TEST(TrulyTest, CanBeUsedWithFunctor) {
      class ConvertibleToBool (line 1045) | class ConvertibleToBool {
        method ConvertibleToBool (line 1047) | explicit ConvertibleToBool(int number) : number_(number) {}
      function ConvertibleToBool (line 1054) | ConvertibleToBool IsNotZero(int number) { return ConvertibleToBool(n...
        method ConvertibleToBool (line 1047) | explicit ConvertibleToBool(int number) : number_(number) {}
      function TEST (line 1059) | TEST(TrulyTest, PredicateCanReturnAClassConvertibleToBool) {
      function TEST (line 1066) | TEST(TrulyTest, CanDescribeSelf) {
      function TEST (line 1073) | TEST(TrulyTest, WorksForByRefArguments) {
      function TEST (line 1081) | TEST(TrulyTest, ExplainsFailures) {
      function TEST (line 1089) | TEST(MatchesTest, IsSatisfiedByWhatMatchesTheMatcher) {
      function TEST (line 1096) | TEST(MatchesTest, WorksOnByRefArguments) {
      function TEST (line 1104) | TEST(MatchesTest, WorksWithMatcherOnNonRefType) {
      function TEST (line 1113) | TEST(ValueTest, WorksWithPolymorphicMatcher) {
      function TEST (line 1118) | TEST(ValueTest, WorksWithMonomorphicMatcher) {
      function TEST (line 1129) | TEST(AllArgsTest, WorksForTuple) {
      function TEST (line 1134) | TEST(AllArgsTest, WorksForNonTuple) {
      class AllArgsHelper (line 1139) | class AllArgsHelper {
        method AllArgsHelper (line 1141) | AllArgsHelper() = default;
        method AllArgsHelper (line 1146) | AllArgsHelper(const AllArgsHelper&) = delete;
        method AllArgsHelper (line 1147) | AllArgsHelper& operator=(const AllArgsHelper&) = delete;
      function TEST (line 1150) | TEST(AllArgsTest, WorksInWithClause) {
      class OptionalMatchersHelper (line 1160) | class OptionalMatchersHelper {
        method OptionalMatchersHelper (line 1162) | OptionalMatchersHelper() = default;
        method OptionalMatchersHelper (line 1174) | OptionalMatchersHelper(const OptionalMatchersHelper&) = delete;
        method OptionalMatchersHelper (line 1175) | OptionalMatchersHelper& operator=(const OptionalMatchersHelper&) =...
      function TEST (line 1178) | TEST(AllArgsTest, WorksWithoutMatchers) {
      class FloatingPointTest (line 1201) | class FloatingPointTest : public testing::Test {
        method FloatingPointTest (line 1206) | FloatingPointTest()
        method TestSize (line 1228) | void TestSize() { EXPECT_EQ(sizeof(RawType), sizeof(Bits)); }
        method TestMatches (line 1232) | void TestMatches(
      class FloatingPointNearTest (line 1308) | class FloatingPointNearTest : public FloatingPointTest<RawType> {
        method TestNearMatches (line 1314) | void TestNearMatches(testing::internal::FloatingEqMatcher<RawType> (
      function TEST_F (line 1392) | TEST_F(FloatTest, FloatEqApproximatelyMatchesFloats) { TestMatches(&...
      function TEST_F (line 1394) | TEST_F(FloatTest, NanSensitiveFloatEqApproximatelyMatchesFloats) {
      function TEST_F (line 1398) | TEST_F(FloatTest, FloatEqCannotMatchNaN) {
      function TEST_F (line 1406) | TEST_F(FloatTest, NanSensitiveFloatEqCanMatchNaN) {
      function TEST_F (line 1414) | TEST_F(FloatTest, FloatEqCanDescribeSelf) {
      function TEST_F (line 1428) | TEST_F(FloatTest, NanSensitiveFloatEqCanDescribeSelf) {
      function TEST_F (line 1446) | TEST_F(FloatNearTest, FloatNearMatches) { TestNearMatches(&FloatNear...
      function TEST_F (line 1448) | TEST_F(FloatNearTest, NanSensitiveFloatNearApproximatelyMatchesFloat...
      function TEST_F (line 1452) | TEST_F(FloatNearTest, FloatNearCanDescribeSelf) {
      function TEST_F (line 1468) | TEST_F(FloatNearTest, NanSensitiveFloatNearCanDescribeSelf) {
      function TEST_F (line 1484) | TEST_F(FloatNearTest, FloatNearCannotMatchNaN) {
      function TEST_F (line 1492) | TEST_F(FloatNearTest, NanSensitiveFloatNearCanMatchNaN) {
      function TEST_F (line 1503) | TEST_F(DoubleTest, DoubleEqApproximatelyMatchesDoubles) {
      function TEST_F (line 1507) | TEST_F(DoubleTest, NanSensitiveDoubleEqApproximatelyMatchesDoubles) {
      function TEST_F (line 1511) | TEST_F(DoubleTest, DoubleEqCannotMatchNaN) {
      function TEST_F (line 1519) | TEST_F(DoubleTest, NanSensitiveDoubleEqCanMatchNaN) {
      function TEST_F (line 1527) | TEST_F(DoubleTest, DoubleEqCanDescribeSelf) {
      function TEST_F (line 1541) | TEST_F(DoubleTest, NanSensitiveDoubleEqCanDescribeSelf) {
      function TEST_F (line 1559) | TEST_F(DoubleNearTest, DoubleNearMatches) { TestNearMatches(&DoubleN...
      function TEST_F (line 1561) | TEST_F(DoubleNearTest, NanSensitiveDoubleNearApproximatelyMatchesDou...
      function TEST_F (line 1565) | TEST_F(DoubleNearTest, DoubleNearCanDescribeSelf) {
      function TEST_F (line 1581) | TEST_F(DoubleNearTest, ExplainsResultWhenMatchFails) {
      function TEST_F (line 1595) | TEST_F(DoubleNearTest, NanSensitiveDoubleNearCanDescribeSelf) {
      function TEST_F (line 1611) | TEST_F(DoubleNearTest, DoubleNearCannotMatchNaN) {
      function TEST_F (line 1619) | TEST_F(DoubleNearTest, NanSensitiveDoubleNearCanMatchNaN) {
      function TEST (line 1627) | TEST(NotTest, WorksOnMoveOnlyType) {
      function TEST (line 1633) | TEST(AllOfTest, HugeMatcher) {
      function TEST (line 1640) | TEST(AnyOfTest, HugeMatcher) {
      type adl_test (line 1647) | namespace adl_test {
        function AllOf (line 1662) | bool AllOf(const T1& /*t1*/, const T2& /*t2*/) {
        function TEST (line 1666) | TEST(AllOfTest, DoesNotCallAllOfUnqualified) {
        function AnyOf (line 1672) | bool AnyOf(const T1&, const T2&) {
        function TEST (line 1676) | TEST(AnyOfTest, DoesNotCallAnyOfUnqualified) {
      function TEST (line 1683) | TEST(AllOfTest, WorksOnMoveOnlyType) {
      function TEST (line 1689) | TEST(AnyOfTest, WorksOnMoveOnlyType) {

FILE: googlemock/test/gmock-matchers-comparisons_test.cc
  type gmock_matchers_test (line 50) | namespace gmock_matchers_test {
    function TEST_P (line 55) | TEST_P(MonotonicMatcherTestP, IsPrintable) {
    function TEST (line 61) | TEST(MatchResultListenerTest, StreamingWorks) {
    function TEST (line 77) | TEST(MatchResultListenerTest, CanAccessUnderlyingStream) {
    function TEST (line 84) | TEST(MatchResultListenerTest, IsInterestedWorks) {
    class EvenMatcherImpl (line 94) | class EvenMatcherImpl : public MatcherInterface<int> {
      method MatchAndExplain (line 96) | bool MatchAndExplain(int x,
      method DescribeTo (line 101) | void DescribeTo(ostream* os) const override { *os << "is an even num...
    function TEST (line 109) | TEST(MatcherInterfaceTest, CanBeImplementedUsingPublishedAPI) {
    class NewEvenMatcherImpl (line 115) | class NewEvenMatcherImpl : public MatcherInterface<int> {
      method MatchAndExplain (line 117) | bool MatchAndExplain(int x, MatchResultListener* listener) const ove...
      method DescribeTo (line 129) | void DescribeTo(ostream* os) const override { *os << "is an even num...
    function TEST (line 132) | TEST(MatcherInterfaceTest, CanBeImplementedUsingNewAPI) {
    function TEST (line 143) | TEST(MatcherTest, CanBeDefaultConstructed) { Matcher<double> m; }
    function TEST (line 146) | TEST(MatcherTest, CanBeConstructedFromMatcherInterface) {
    function TEST (line 154) | TEST(MatcherTest, CanBeImplicitlyConstructedFromValue) {
    function TEST (line 161) | TEST(MatcherTest, CanBeImplicitlyConstructedFromNULL) {
    type Undefined (line 170) | struct Undefined {
    function TEST (line 175) | TEST(MatcherTest, CanBeConstructedFromUndefinedVariable) {
    function TEST (line 182) | TEST(MatcherTest, CanAcceptAbstractClass) { Matcher<const Undefined&> ...
    function TEST (line 185) | TEST(MatcherTest, IsCopyable) {
    function TEST (line 199) | TEST(MatcherTest, CanDescribeItself) {
    function TEST_P (line 204) | TEST_P(MatcherTestP, MatchAndExplain) {
    function TEST (line 217) | TEST(StringMatcherTest, CanBeImplicitlyConstructedFromCStringLiteral) {
    function TEST (line 229) | TEST(StringMatcherTest, CanBeImplicitlyConstructedFromString) {
    function TEST (line 242) | TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromCStringLiter...
    function TEST (line 254) | TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromString) {
    function TEST (line 266) | TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromStringView) {
    function TEST (line 279) | TEST(StringMatcherTest,
    function TEST (line 294) | TEST(MakeMatcherTest, ConstructsMatcherFromMatcherInterface) {
    class ReferencesBarOrIsZeroImpl (line 302) | class ReferencesBarOrIsZeroImpl {
      method MatchAndExplain (line 305) | bool MatchAndExplain(const T& x, MatchResultListener* /* listener */...
      method DescribeTo (line 310) | void DescribeTo(ostream* os) const { *os << "g_bar or zero"; }
      method DescribeNegationTo (line 312) | void DescribeNegationTo(ostream* os) const {
    function ReferencesBarOrIsZero (line 319) | PolymorphicMatcher<ReferencesBarOrIsZeroImpl> ReferencesBarOrIsZero() {
    function TEST (line 323) | TEST(MakePolymorphicMatcherTest, ConstructsMatcherUsingOldAPI) {
    class PolymorphicIsEvenImpl (line 341) | class PolymorphicIsEvenImpl {
      method DescribeTo (line 343) | void DescribeTo(ostream* os) const { *os << "is even"; }
      method DescribeNegationTo (line 345) | void DescribeNegationTo(ostream* os) const { *os << "is odd"; }
      method MatchAndExplain (line 348) | bool MatchAndExplain(const T& x, MatchResultListener* listener) const {
    function PolymorphicIsEven (line 360) | PolymorphicMatcher<PolymorphicIsEvenImpl> PolymorphicIsEven() {
    function TEST (line 364) | TEST(MakePolymorphicMatcherTest, ConstructsMatcherUsingNewAPI) {
    function TEST_P (line 391) | TEST_P(MatcherCastTestP, FromPolymorphicMatcher) {
    class IntValue (line 403) | class IntValue {
      method IntValue (line 407) | explicit IntValue(int a_value) : value_(a_value) {}
      method value (line 409) | int value() const { return value_; }
    class MutableIntView (line 418) | class MutableIntView {
      method MutableIntView (line 422) | explicit MutableIntView(int& a_value) : value_(a_value) {}
    function IsPositiveIntValue (line 431) | bool IsPositiveIntValue(const IntValue& foo) { return foo.value() > 0; }
    function IsPositiveMutableIntView (line 434) | bool IsPositiveMutableIntView(MutableIntView foo) { return foo.value()...
    function TEST (line 438) | TEST(MatcherCastTest, FromCompatibleType) {
    function TEST (line 462) | TEST(MatcherCastTest, FromConstReferenceToNonReference) {
    function TEST (line 472) | TEST(MatcherCastTest, FromConstReferenceToReference) {
    function TEST (line 482) | TEST(MatcherCastTest, FromReferenceToNonReference) {
    function TEST (line 496) | TEST(MatcherCastTest, FromNonReferenceToConstReference) {
    function TEST (line 504) | TEST(MatcherCastTest, FromNonReferenceToReference) {
    function TEST (line 514) | TEST(MatcherCastTest, FromSameType) {
    function TEST (line 523) | TEST(MatcherCastTest, FromAValue) {
    function TEST (line 531) | TEST(MatcherCastTest, FromAnImplicitlyConvertibleValue) {
    type NonImplicitlyConstructibleTypeWithOperatorEq (line 538) | struct NonImplicitlyConstructibleTypeWithOperatorEq {
    function TEST (line 554) | TEST(MatcherCastTest, NonImplicitlyConstructibleTypeWithOperatorEq) {
    type convertible_from_any (line 585) | namespace convertible_from_any {
      type ConvertibleFromAny (line 587) | struct ConvertibleFromAny {
        method ConvertibleFromAny (line 588) | ConvertibleFromAny(int a_value) : value(a_value) {}
        method ConvertibleFromAny (line 590) | ConvertibleFromAny(const T& /*a_value*/) : value(-1) {
      function ostream (line 600) | ostream& operator<<(ostream& os, const ConvertibleFromAny& a) {
      function TEST (line 604) | TEST(MatcherCastTest, ConversionConstructorIsUsed) {
      function TEST (line 610) | TEST(MatcherCastTest, FromConvertibleFromAny) {
      function TEST (line 774) | TEST(SafeMatcherCastTest, ConversionConstructorIsUsed) {
      function TEST (line 780) | TEST(SafeMatcherCastTest, FromConvertibleFromAny) {
    type IntReferenceWrapper (line 620) | struct IntReferenceWrapper {
      method IntReferenceWrapper (line 621) | IntReferenceWrapper(const int& a_value) : value(&a_value) {}
    function TEST (line 630) | TEST(MatcherCastTest, ValueIsCopied) {
    class Base (line 663) | class Base {
      method Base (line 666) | Base() = default;
      method Base (line 669) | Base(const Base&) = delete;
      method Base (line 670) | Base& operator=(const Base&) = delete;
    class Derived (line 673) | class Derived : public Base {
      method Derived (line 675) | Derived() : Base() {}
    class OtherDerived (line 679) | class OtherDerived : public Base {}
    function TEST_P (line 684) | TEST_P(SafeMatcherCastTestP, FromPolymorphicMatcher) {
    function TEST (line 698) | TEST(SafeMatcherCastTest, FromLosslesslyConvertibleArithmeticType) {
    function TEST (line 711) | TEST(SafeMatcherCastTest, FromBaseClass) {
    function TEST (line 725) | TEST(SafeMatcherCastTest, FromConstReferenceToNonReference) {
    function TEST (line 735) | TEST(SafeMatcherCastTest, FromConstReferenceToReference) {
    function TEST (line 745) | TEST(SafeMatcherCastTest, FromNonReferenceToConstReference) {
    function TEST (line 754) | TEST(SafeMatcherCastTest, FromNonReferenceToReference) {
    function TEST (line 764) | TEST(SafeMatcherCastTest, FromSameType) {
    type convertible_from_any (line 773) | namespace convertible_from_any {
      type ConvertibleFromAny (line 587) | struct ConvertibleFromAny {
        method ConvertibleFromAny (line 588) | ConvertibleFromAny(int a_value) : value(a_value) {}
        method ConvertibleFromAny (line 590) | ConvertibleFromAny(const T& /*a_value*/) : value(-1) {
      function ostream (line 600) | ostream& operator<<(ostream& os, const ConvertibleFromAny& a) {
      function TEST (line 604) | TEST(MatcherCastTest, ConversionConstructorIsUsed) {
      function TEST (line 610) | TEST(MatcherCastTest, FromConvertibleFromAny) {
      function TEST (line 774) | TEST(SafeMatcherCastTest, ConversionConstructorIsUsed) {
      function TEST (line 780) | TEST(SafeMatcherCastTest, FromConvertibleFromAny) {
    function TEST (line 790) | TEST(SafeMatcherCastTest, ValueIsNotCopied) {
    function TEST (line 797) | TEST(ExpectThat, TakesLiterals) {
    function TEST (line 804) | TEST(ExpectThat, TakesFunctions) {
    function TEST (line 814) | TEST(ATest, MatchesAnyValue) {
    function TEST (line 828) | TEST(ATest, WorksForDerivedClass) {
    function TEST (line 838) | TEST(ATest, CanDescribeSelf) { EXPECT_EQ("is anything", Describe(A<boo...
    function TEST (line 841) | TEST(AnTest, MatchesAnyValue) {
    function TEST (line 856) | TEST(AnTest, CanDescribeSelf) { EXPECT_EQ("is anything", Describe(An<i...
    function TEST (line 860) | TEST(UnderscoreTest, MatchesAnyValue) {
    function TEST (line 875) | TEST(UnderscoreTest, CanDescribeSelf) {
    function TEST (line 881) | TEST(EqTest, MatchesEqualValue) {
    class Unprintable (line 893) | class Unprintable {
      method Unprintable (line 895) | Unprintable() : c_('a') {}
      method dummy_c (line 899) | char dummy_c() { return c_; }
    function TEST (line 905) | TEST(EqTest, CanDescribeSelf) {
    function TEST (line 912) | TEST(EqTest, IsPolymorphic) {
    function TEST (line 923) | TEST(TypedEqTest, ChecksEqualityForGivenType) {
    function TEST (line 934) | TEST(TypedEqTest, CanDescribeSelf) {
    type Type (line 944) | struct Type {
      method IsTypeOf (line 945) | static bool IsTypeOf(const T& /* v */) { return true; }
    function TEST (line 951) | TEST(TypedEqTest, HasSpecifiedType) {
    function TEST (line 958) | TEST(GeTest, ImplementsGreaterThanOrEqual) {
    function TEST (line 966) | TEST(GeTest, CanDescribeSelf) {
    function TEST (line 972) | TEST(GtTest, ImplementsGreaterThan) {
    function TEST (line 980) | TEST(GtTest, CanDescribeSelf) {
    function TEST (line 986) | TEST(LeTest, ImplementsLessThanOrEqual) {
    function TEST (line 994) | TEST(LeTest, CanDescribeSelf) {
    function TEST (line 1000) | TEST(LtTest, ImplementsLessThan) {
    function TEST (line 1008) | TEST(LtTest, CanDescribeSelf) {
    function TEST (line 1014) | TEST(NeTest, ImplementsNotEqual) {
    function TEST (line 1022) | TEST(NeTest, CanDescribeSelf) {
    class MoveOnly (line 1027) | class MoveOnly {
      method MoveOnly (line 1029) | explicit MoveOnly(int i) : i_(i) {}
      method MoveOnly (line 1030) | MoveOnly(const MoveOnly&) = delete;
      method MoveOnly (line 1031) | MoveOnly(MoveOnly&&) = default;
      method MoveOnly (line 1032) | MoveOnly& operator=(const MoveOnly&) = delete;
      method MoveOnly (line 1033) | MoveOnly& operator=(MoveOnly&&) = default;
    type MoveHelper (line 1046) | struct MoveHelper {
    function TEST (line 1052) | TEST(ComparisonBaseTest, DISABLED_WorksWithMoveOnly) {

FILE: googlemock/test/gmock-matchers-containers_test.cc
  type testing (line 55) | namespace testing {
    type gmock_matchers_test (line 56) | namespace gmock_matchers_test {
      function MakeUniquePtrs (line 59) | std::vector<std::unique_ptr<int>> MakeUniquePtrs(const std::vector<i...
      function OfType (line 65) | std::string OfType(const std::string& type_name) {
      function TEST (line 73) | TEST(ContainsTest, WorksWithMoveOnly) {
      function TEST (line 82) | TEST(ElementsAreTest, HugeMatcher) {
      function TEST (line 91) | TEST(ElementsAreTest, HugeMatcherStr) {
      function TEST (line 100) | TEST(ElementsAreTest, HugeMatcherUnordered) {
      function TEST (line 110) | TEST(MatcherAssertionTest, WorksWhenMatcherIsSatisfied) {
      function TEST (line 119) | TEST(MatcherAssertionTest, WorksWhenMatcherIsNotSatisfied) {
      function TEST (line 140) | TEST(MatcherAssertionTest, WorksForByRefArguments) {
      function TEST (line 156) | TEST(MatcherAssertionTest, WorksForMonomorphicMatcher) {
      function TEST (line 175) | TEST(PointeeTest, RawPointer) {
      function TEST (line 185) | TEST(PointeeTest, RawPointerToConst) {
      function TEST (line 195) | TEST(PointeeTest, ReferenceToConstRawPointer) {
      function TEST (line 205) | TEST(PointeeTest, ReferenceToNonConstRawPointer) {
      function TEST (line 217) | TEST(PointeeTest, SmartPointer) {
      function TEST (line 224) | TEST(PointeeTest, SmartPointerToConst) {
      function TEST (line 234) | TEST(PointerTest, RawPointer) {
      function TEST (line 245) | TEST(PointerTest, RawPointerToConst) {
      function TEST (line 256) | TEST(PointerTest, SmartPointer) {
      function TEST (line 264) | TEST(PointerTest, SmartPointerToConst) {
      class ConstPropagatingPtr (line 278) | class ConstPropagatingPtr {
        method ConstPropagatingPtr (line 282) | ConstPropagatingPtr() : val_() {}
        method ConstPropagatingPtr (line 283) | explicit ConstPropagatingPtr(T* t) : val_(t) {}
        method ConstPropagatingPtr (line 284) | ConstPropagatingPtr(const ConstPropagatingPtr& other) : val_(other...
        method T (line 286) | T* get() { return val_; }
        method T (line 287) | T& operator*() { return *val_; }
        method T (line 289) | const T* get() const { return val_; }
        method T (line 290) | const T& operator*() const { return *val_; }
      function TEST (line 298) | TEST(PointeeTest, WorksWithConstPropagatingPointers) {
      function TEST (line 310) | TEST(PointeeTest, NeverMatchesNull) {
      function TEST (line 316) | TEST(PointeeTest, MatchesAgainstAValue) {
      function TEST (line 326) | TEST(PointeeTest, CanDescribeSelf) {
      function TEST_P (line 332) | TEST_P(PointeeTestP, CanExplainMatchResult) {
      function TEST (line 343) | TEST(PointeeTest, AlwaysExplainsPointee) {
      class Uncopyable (line 350) | class Uncopyable {
        method Uncopyable (line 352) | Uncopyable() : value_(-1) {}
        method Uncopyable (line 353) | explicit Uncopyable(int a_value) : value_(a_value) {}
        method value (line 355) | int value() const { return value_; }
        method set_value (line 356) | void set_value(int i) { value_ = i; }
        method Uncopyable (line 360) | Uncopyable(const Uncopyable&) = delete;
        method Uncopyable (line 361) | Uncopyable& operator=(const Uncopyable&) = delete;
      function ValueIsPositive (line 365) | bool ValueIsPositive(const Uncopyable& x) { return x.value() > 0; }
      type AStruct (line 372) | struct AStruct {
        method AStruct (line 373) | AStruct() : x(0), y(1.0), z(5), p(nullptr) {}
        method AStruct (line 374) | AStruct(const AStruct& rhs)
      type DerivedStruct (line 384) | struct DerivedStruct : public AStruct {
      function TEST (line 391) | TEST(FieldTest, WorksForNonConstField) {
      function TEST (line 404) | TEST(FieldTest, WorksForConstField) {
      function TEST (line 418) | TEST(FieldTest, WorksForUncopyableField) {
      function TEST (line 428) | TEST(FieldTest, WorksForPointerField) {
      function TEST (line 445) | TEST(FieldTest, WorksForByRefArgument) {
      function TEST (line 456) | TEST(FieldTest, WorksForArgumentOfSubType) {
      function TEST (line 469) | TEST(FieldTest, WorksForCompatibleMatcherType) {
      function TEST (line 480) | TEST(FieldTest, CanDescribeSelf) {
      function TEST (line 487) | TEST(FieldTest, CanDescribeSelfWithFieldName) {
      function TEST_P (line 496) | TEST_P(FieldTestP, CanExplainMatchResult) {
      function TEST_P (line 509) | TEST_P(FieldTestP, CanExplainMatchResultWithFieldName) {
      function TEST (line 525) | TEST(FieldForPointerTest, WorksForPointerToConst) {
      function TEST (line 535) | TEST(FieldForPointerTest, WorksForPointerToNonConst) {
      function TEST (line 545) | TEST(FieldForPointerTest, WorksForReferenceToConstPointer) {
      function TEST (line 555) | TEST(FieldForPointerTest, DoesNotMatchNull) {
      function TEST (line 562) | TEST(FieldForPointerTest, WorksForArgumentOfSubType) {
      function TEST (line 574) | TEST(FieldForPointerTest, CanDescribeSelf) {
      function TEST (line 581) | TEST(FieldForPointerTest, CanDescribeSelfWithFieldName) {
      function TEST_P (line 590) | TEST_P(FieldForPointerTestP, CanExplainMatchResult) {
      function TEST_P (line 605) | TEST_P(FieldForPointerTestP, CanExplainMatchResultWithFieldName) {
      class AClass (line 622) | class AClass {
        method AClass (line 624) | AClass() : n_(0) {}
        method n (line 627) | int n() const { return n_; }
        method set_n (line 629) | void set_n(int new_n) { n_ = new_n; }
        method set_s (line 636) | void set_s(const std::string& new_s) { s_ = new_s; }
      class DerivedClass (line 651) | class DerivedClass : public AClass {
        method k (line 653) | int k() const { return k_; }
      function TEST (line 663) | TEST(PropertyTest, WorksForNonReferenceProperty) {
      function TEST (line 679) | TEST(PropertyTest, WorksForReferenceToConstProperty) {
      function TEST (line 696) | TEST(PropertyTest, WorksForRefQualifiedProperty) {
      function TEST (line 713) | TEST(PropertyTest, WorksForReferenceToNonConstProperty) {
      function TEST (line 726) | TEST(PropertyTest, WorksForByValueArgument) {
      function TEST (line 739) | TEST(PropertyTest, WorksForArgumentOfSubType) {
      function TEST (line 754) | TEST(PropertyTest, WorksForCompatibleMatcherType) {
      function TEST (line 770) | TEST(PropertyTest, CanDescribeSelf) {
      function TEST (line 778) | TEST(PropertyTest, CanDescribeSelfWithPropertyName) {
      function TEST_P (line 787) | TEST_P(PropertyTestP, CanExplainMatchResult) {
      function TEST_P (line 800) | TEST_P(PropertyTestP, CanExplainMatchResultWithPropertyName) {
      function TEST (line 816) | TEST(PropertyForPointerTest, WorksForPointerToConst) {
      function TEST (line 828) | TEST(PropertyForPointerTest, WorksForPointerToNonConst) {
      function TEST (line 841) | TEST(PropertyForPointerTest, WorksForReferenceToConstPointer) {
      function TEST (line 853) | TEST(PropertyForPointerTest, WorksForReferenceToNonConstProperty) {
      function TEST (line 860) | TEST(PropertyForPointerTest, WorksForArgumentOfSubType) {
      function TEST (line 874) | TEST(PropertyForPointerTest, CanDescribeSelf) {
      function TEST (line 882) | TEST(PropertyForPointerTest, CanDescribeSelfWithPropertyDescription) {
      function TEST_P (line 891) | TEST_P(PropertyForPointerTestP, CanExplainMatchResult) {
      function TEST_P (line 907) | TEST_P(PropertyForPointerTestP, CanExplainMatchResultWithPropertyNam...
      function IntToStringFunction (line 927) | std::string IntToStringFunction(int input) {
      function TEST (line 933) | TEST(ResultOfTest, WorksForFunctionPointers) {
      function TEST (line 941) | TEST(ResultOfTest, CanDescribeItself) {
      function TEST (line 955) | TEST(ResultOfTest, CanDescribeItselfWithResultDescription) {
      function IntFunction (line 965) | int IntFunction(int input) { return input == 42 ? 80 : 90; }
      function TEST_P (line 967) | TEST_P(ResultOfTestP, CanExplainMatchResult) {
      function TEST_P (line 978) | TEST_P(ResultOfTestP, CanExplainMatchResultWithResultDescription) {
      function TEST (line 991) | TEST(ResultOfTest, WorksForNonReferenceResults) {
      function Uncopyable (line 1002) | Uncopyable& RefUncopyableFunction(Uncopyable& obj) {  // NOLINT
        method Uncopyable (line 352) | Uncopyable() : value_(-1) {}
        method Uncopyable (line 353) | explicit Uncopyable(int a_value) : value_(a_value) {}
        method value (line 355) | int value() const { return value_; }
        method set_value (line 356) | void set_value(int i) { value_ = i; }
        method Uncopyable (line 360) | Uncopyable(const Uncopyable&) = delete;
        method Uncopyable (line 361) | Uncopyable& operator=(const Uncopyable&) = delete;
      function TEST (line 1006) | TEST(ResultOfTest, WorksForReferenceToNonConstResults) {
      function TEST (line 1027) | TEST(ResultOfTest, WorksForReferenceToConstResults) {
      function TEST (line 1038) | TEST(ResultOfTest, WorksForCompatibleMatcherTypes) {
      function TEST (line 1048) | TEST(ResultOfDeathTest, DiesOnNullFunctionPointers) {
      function TEST (line 1057) | TEST(ResultOfTest, WorksForFunctionReferences) {
      type Functor (line 1065) | struct Functor {
      function TEST (line 1069) | TEST(ResultOfTest, WorksForFunctors) {
      type PolymorphicFunctor (line 1079) | struct PolymorphicFunctor {
      function TEST (line 1086) | TEST(ResultOfTest, WorksForPolymorphicFunctors) {
      function TEST (line 1098) | TEST(ResultOfTest, WorksForPolymorphicFunctorsIgnoringResultType) {
      function TEST (line 1106) | TEST(ResultOfTest, WorksForLambdas) {
      function TEST (line 1116) | TEST(ResultOfTest, WorksForNonCopyableArguments) {
      type ReferencingFunctor (line 1128) | struct ReferencingFunctor {
        method result_type (line 1130) | result_type operator()(const int& n) { return &n; }
      function TEST (line 1133) | TEST(ResultOfTest, WorksForReferencingCallables) {
      function TEST (line 1145) | TEST(SizeIsTest, ImplementsSizeIs) {
      function TEST (line 1157) | TEST(SizeIsTest, WorksWithMap) {
      function TEST (line 1169) | TEST(SizeIsTest, WorksWithReferences) {
      function TEST (line 1177) | TEST(SizeIsTest, WorksWithMoveOnly) {
      type MinimalistCustomType (line 1185) | struct MinimalistCustomType {
        method size (line 1186) | int size() const { return 1; }
      function TEST (line 1188) | TEST(SizeIsTest, WorksWithMinimalistCustomType) {
      function TEST (line 1194) | TEST(SizeIsTest, CanDescribeSelf) {
      function TEST (line 1200) | TEST(SizeIsTest, ExplainsResult) {
      function TEST (line 1221) | TEST(WhenSortedByTest, WorksForEmptyContainer) {
      function TEST (line 1227) | TEST(WhenSortedByTest, WorksForNonEmptyContainer) {
      function TEST (line 1239) | TEST(WhenSortedByTest, WorksForNonVectorContainer) {
      function TEST (line 1250) | TEST(WhenSortedByTest, WorksForNativeArray) {
      function TEST (line 1259) | TEST(WhenSortedByTest, CanDescribeSelf) {
      function TEST (line 1273) | TEST(WhenSortedByTest, ExplainsMatchResult) {
      function TEST (line 1285) | TEST(WhenSortedTest, WorksForEmptyContainer) {
      function TEST (line 1291) | TEST(WhenSortedTest, WorksForNonEmptyContainer) {
      function TEST (line 1301) | TEST(WhenSortedTest, WorksForMapTypes) {
      function TEST (line 1314) | TEST(WhenSortedTest, WorksForMultiMapTypes) {
      function TEST (line 1330) | TEST(WhenSortedTest, WorksForPolymorphicMatcher) {
      function TEST (line 1338) | TEST(WhenSortedTest, WorksForVectorConstRefMatcher) {
      class Streamlike (line 1351) | class Streamlike {
        class ConstIter (line 1353) | class ConstIter
          method ConstIter (line 1376) | ConstIter(const Streamlike* s, typename std::list<value_type>::i...
          method value_type (line 1379) | const value_type& operator*() const { return *pos_; }
          method value_type (line 1380) | const value_type* operator->() const { return &*pos_; }
          method ConstIter (line 1381) | ConstIter& operator++() {
          class PostIncrProxy (line 1388) | class PostIncrProxy {
            method PostIncrProxy (line 1390) | explicit PostIncrProxy(const value_type& value) : value_(value...
            method value_type (line 1391) | value_type operator*() const { return value_; }
          method PostIncrProxy (line 1396) | PostIncrProxy operator++(int) {
            method PostIncrProxy (line 1390) | explicit PostIncrProxy(const value_type& value) : value_(value...
            method value_type (line 1391) | value_type operator*() const { return value_; }
        method Streamlike (line 1360) | Streamlike(InIter first, InIter last) : remainder_(first, last) {}
        method const_iterator (line 1362) | const_iterator begin() const {
        method const_iterator (line 1365) | const_iterator end() const { return const_iterator(this, remainder...
        class ConstIter (line 1368) | class ConstIter {
          method ConstIter (line 1376) | ConstIter(const Streamlike* s, typename std::list<value_type>::i...
          method value_type (line 1379) | const value_type& operator*() const { return *pos_; }
          method value_type (line 1380) | const value_type* operator->() const { return &*pos_; }
          method ConstIter (line 1381) | ConstIter& operator++() {
          class PostIncrProxy (line 1388) | class PostIncrProxy {
            method PostIncrProxy (line 1390) | explicit PostIncrProxy(const value_type& value) : value_(value...
            method value_type (line 1391) | value_type operator*() const { return value_; }
          method PostIncrProxy (line 1396) | PostIncrProxy operator++(int) {
            method PostIncrProxy (line 1390) | explicit PostIncrProxy(const value_type& value) : value_(value...
            method value_type (line 1391) | value_type operator*() const { return value_; }
      function TEST (line 1429) | TEST(StreamlikeTest, Iteration) {
      function TEST (line 1442) | TEST(BeginEndDistanceIsTest, WorksWithForwardList) {
      function TEST (line 1454) | TEST(BeginEndDistanceIsTest, WorksWithNonStdList) {
      function TEST (line 1460) | TEST(BeginEndDistanceIsTest, CanDescribeSelf) {
      function TEST (line 1467) | TEST(BeginEndDistanceIsTest, WorksWithMoveOnly) {
      function TEST_P (line 1473) | TEST_P(BeginEndDistanceIsTestP, ExplainsResult) {
      function TEST (line 1507) | TEST(WhenSortedTest, WorksForStreamlike) {
      function TEST (line 1516) | TEST(WhenSortedTest, WorksForVectorConstRefMatcherOnStreamlike) {
      function TEST (line 1524) | TEST(IsSupersetOfTest, WorksForNativeArray) {
      function TEST (line 1535) | TEST(IsSupersetOfTest, WorksWithDuplicates) {
      function TEST (line 1543) | TEST(IsSupersetOfTest, WorksForEmpty) {
      function TEST (line 1561) | TEST(IsSupersetOfTest, WorksForStreamlike) {
      function TEST (line 1575) | TEST(IsSupersetOfTest, TakesStlContainer) {
      function TEST (line 1587) | TEST(IsSupersetOfTest, Describe) {
      function TEST (line 1601) | TEST(IsSupersetOfTest, DescribeNegation) {
      function TEST (line 1615) | TEST(IsSupersetOfTest, MatchAndExplain) {
      function TEST (line 1638) | TEST(IsSupersetOfTest, WorksForRhsInitializerList) {
      function TEST (line 1644) | TEST(IsSupersetOfTest, WorksWithMoveOnly) {
      function TEST (line 1652) | TEST(IsSubsetOfTest, WorksForNativeArray) {
      function TEST (line 1663) | TEST(IsSubsetOfTest, WorksWithDuplicates) {
      function TEST (line 1671) | TEST(IsSubsetOfTest, WorksForEmpty) {
      function TEST (line 1689) | TEST(IsSubsetOfTest, WorksForStreamlike) {
      function TEST (line 1701) | TEST(IsSubsetOfTest, TakesStlContainer) {
      function TEST (line 1714) | TEST(IsSubsetOfTest, Describe) {
      function TEST (line 1729) | TEST(IsSubsetOfTest, DescribeNegation) {
      function TEST (line 1743) | TEST(IsSubsetOfTest, MatchAndExplain) {
      function TEST (line 1766) | TEST(IsSubsetOfTest, WorksForRhsInitializerList) {
      function TEST (line 1772) | TEST(IsSubsetOfTest, WorksWithMoveOnly) {
      class CharString (line 1782) | class CharString {
        class const_iterator (line 1786) | class const_iterator {
          method const_iterator (line 1795) | explicit const_iterator(const char* ptr) : ptr_(ptr) {}
          method const_iterator (line 1803) | const_iterator& operator++() {
        method CharString (line 1821) | explicit CharString(const std::string& s) : s_(s) {}
        method const_iterator (line 1824) | const_iterator begin() const { return const_iterator(s_.c_str()); }
          method const_iterator (line 1795) | explicit const_iterator(const char* ptr) : ptr_(ptr) {}
          method const_iterator (line 1803) | const_iterator& operator++() {
        method const_iterator (line 1827) | const_iterator end() const { return const_iterator(s_.c_str() + s_...
          method const_iterator (line 1795) | explicit const_iterator(const char* ptr) : ptr_(ptr) {}
          method const_iterator (line 1803) | const_iterator& operator++() {
      function TEST (line 1835) | TEST(ElementsAreTest, WorksWithContainerThatReturnsTempInIterator) {
      function TEST (line 1843) | TEST(ElementsAreArrayTest, WorksWithContainerThatReturnsTempInIterat...
      class CharString2 (line 1851) | class CharString2 {
        class const_iterator (line 1855) | class const_iterator {
          method const_iterator (line 1865) | const_iterator(const const_iterator&) = default;
          method const_iterator (line 1866) | const_iterator& operator=(const const_iterator&) = delete;
          method const_iterator (line 1869) | explicit const_iterator(const char* ptr) : ptr_(ptr) {}
          method const_iterator (line 1877) | const_iterator& operator++() {
        method CharString2 (line 1895) | explicit CharString2(const std::string& s) : s_(s) {}
        method const_iterator (line 1898) | const_iterator begin() const { return const_iterator(s_.c_str()); }
          method const_iterator (line 1865) | const_iterator(const const_iterator&) = default;
          method const_iterator (line 1866) | const_iterator& operator=(const const_iterator&) = delete;
          method const_iterator (line 1869) | explicit const_iterator(const char* ptr) : ptr_(ptr) {}
          method const_iterator (line 1877) | const_iterator& operator++() {
        method const_iterator (line 1901) | const_iterator end() const { return const_iterator(s_.c_str() + s_...
          method const_iterator (line 1865) | const_iterator(const const_iterator&) = default;
          method const_iterator (line 1866) | const_iterator& operator=(const const_iterator&) = delete;
          method const_iterator (line 1869) | explicit const_iterator(const char* ptr) : ptr_(ptr) {}
          method const_iterator (line 1877) | const_iterator& operator++() {
      function TEST (line 1909) | TEST(ElementsAreTest, WorksWithContainerThatReturnsTempInUnassignabl...
      function TEST (line 1917) | TEST(ElementsAreArrayTest,
      class CharString3 (line 1926) | class CharString3 {
        class const_iterator (line 1930) | class const_iterator {
          method const_iterator (line 1939) | const_iterator(const const_iterator&) = delete;
          method const_iterator (line 1940) | const_iterator& operator=(const const_iterator&) = delete;
          method const_iterator (line 1943) | explicit const_iterator(const char* ptr) : ptr_(ptr) {}
          method const_iterator (line 1951) | const_iterator& operator++() {
        method CharString3 (line 1969) | explicit CharString3(const std::string& s) : s_(s) {}
        method const_iterator (line 1972) | const_iterator begin() const { return const_iterator(s_.c_str()); }
          method const_iterator (line 1939) | const_iterator(const const_iterator&) = delete;
          method const_iterator (line 1940) | const_iterator& operator=(const const_iterator&) = delete;
          method const_iterator (line 1943) | explicit const_iterator(const char* ptr) : ptr_(ptr) {}
          method const_iterator (line 1951) | const_iterator& operator++() {
        method const_iterator (line 1975) | const_iterator end() const { return const_iterator(s_.c_str() + s_...
          method const_iterator (line 1939) | const_iterator(const const_iterator&) = delete;
          method const_iterator (line 1940) | const_iterator& operator=(const const_iterator&) = delete;
          method const_iterator (line 1943) | explicit const_iterator(const char* ptr) : ptr_(ptr) {}
          method const_iterator (line 1951) | const_iterator& operator++() {
      function TEST (line 1983) | TEST(ElementsAreTest, WorksWithContainerThatReturnsTempInUncopyableI...
      function TEST (line 1991) | TEST(ElementsAreArrayTest,
      class CharString4 (line 2000) | class CharString4 {
        class const_iterator (line 2004) | class const_iterator {
          method const_iterator (line 2009) | const_iterator(const const_iterator&) = delete;
          method const_iterator (line 2010) | const_iterator& operator=(const const_iterator&) = delete;
          method const_iterator (line 2013) | explicit const_iterator(const char* ptr) : ptr_(ptr) {}
          method const_iterator (line 2021) | const_iterator& operator++() {
        method CharString4 (line 2039) | explicit CharString4(const std::string& s) : s_(s) {}
        method const_iterator (line 2042) | const_iterator begin() const { return const_iterator(s_.c_str()); }
          method const_iterator (line 2009) | const_iterator(const const_iterator&) = delete;
          method const_iterator (line 2010) | const_iterator& operator=(const const_iterator&) = delete;
          method const_iterator (line 2013) | explicit const_iterator(const char* ptr) : ptr_(ptr) {}
          method const_iterator (line 2021) | const_iterator& operator++() {
        method const_iterator (line 2045) | const_iterator end() const { return const_iterator(s_.c_str() + s_...
          method const_iterator (line 2009) | const_iterator(const const_iterator&) = delete;
          method const_iterator (line 2010) | const_iterator& operator=(const const_iterator&) = delete;
          method const_iterator (line 2013) | explicit const_iterator(const char* ptr) : ptr_(ptr) {}
          method const_iterator (line 2021) | const_iterator& operator++() {
      function TEST (line 2054) | TEST(ElementsAreTest, WorksWithContainerWithIteratorWithNoMemberType...
      function TEST (line 2063) | TEST(ElementsAreArrayTest, WorksWithContainerWithIteratorWithNoMembe...
      function TEST (line 2072) | TEST(ElemensAreStreamTest, WorksForStreamlike) {
      function TEST (line 2079) | TEST(ElemensAreArrayStreamTest, WorksForStreamlike) {
      function TEST (line 2095) | TEST(ElementsAreTest, WorksWithUncopyable) {
      function TEST (line 2102) | TEST(ElementsAreTest, WorksWithMoveOnly) {
      function TEST (line 2111) | TEST(ElementsAreTest, TakesStlContainer) {
      function TEST (line 2126) | TEST(UnorderedElementsAreArrayTest, SucceedsWhenExpected) {
      function TEST (line 2136) | TEST(UnorderedElementsAreArrayTest, VectorBool) {
      function TEST (line 2147) | TEST(UnorderedElementsAreArrayTest, WorksForStreamlike) {
      function TEST (line 2166) | TEST(UnorderedElementsAreArrayTest, TakesStlContainer) {
      function TEST (line 2179) | TEST(UnorderedElementsAreArrayTest, TakesInitializerList) {
      function TEST (line 2185) | TEST(UnorderedElementsAreArrayTest, TakesInitializerListOfCStrings) {
      function TEST (line 2191) | TEST(UnorderedElementsAreArrayTest, TakesInitializerListOfSameTypedM...
      function TEST (line 2199) | TEST(UnorderedElementsAreArrayTest,
      function TEST (line 2211) | TEST(UnorderedElementsAreArrayTest, WorksWithMoveOnly) {
      class UnorderedElementsAreTest (line 2218) | class UnorderedElementsAreTest : public testing::Test {
      function TEST_F (line 2223) | TEST_F(UnorderedElementsAreTest, WorksWithUncopyable) {
      function TEST_F (line 2231) | TEST_F(UnorderedElementsAreTest, SucceedsWhenExpected) {
      function TEST_F (line 2241) | TEST_F(UnorderedElementsAreTest, FailsWhenAnElementMatchesNoMatcher) {
      function TEST_F (line 2254) | TEST_F(UnorderedElementsAreTest, WorksForStreamlike) {
      function TEST_F (line 2265) | TEST_F(UnorderedElementsAreTest, WorksWithMoveOnly) {
      function TEST_F (line 2277) | TEST_F(UnorderedElementsAreTest, Performance) {
      function TEST_F (line 2293) | TEST_F(UnorderedElementsAreTest, PerformanceHalfStrict) {
      function TEST_F (line 2309) | TEST_F(UnorderedElementsAreTest, FailMessageCountWrong) {
      function TEST_F (line 2325) | TEST_F(UnorderedElementsAreTest, FailMessageCountWrongZero) {
      function TEST_F (line 2337) | TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedMatchers) {
      function TEST_F (line 2349) | TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedElements) {
      function TEST_F (line 2361) | TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedMatcherAndEleme...
      function EMString (line 2379) | static std::string EMString(int element, int matcher) {
      function TEST_F (line 2385) | TEST_F(UnorderedElementsAreTest, FailMessageImperfectMatchOnly) {
      function TEST_F (line 2413) | TEST_F(UnorderedElementsAreTest, Describe) {
      function TEST_F (line 2425) | TEST_F(UnorderedElementsAreTest, DescribeNegation) {
      function TEST_P (line 2443) | TEST_P(EachTestP, ExplainsMatchResultCorrectly) {
      function TEST (line 2468) | TEST(EachTest, DescribesItselfCorrectly) {
      function TEST (line 2476) | TEST(EachTest, MatchesVectorWhenAllElementsMatch) {
      function TEST (line 2496) | TEST(EachTest, MatchesMapWhenAllElementsMatch) {
      function TEST (line 2514) | TEST(EachTest, AcceptsMatcher) {
      function TEST (line 2520) | TEST(EachTest, WorksForNativeArrayAsTuple) {
      function TEST (line 2527) | TEST(EachTest, WorksWithMoveOnly) {
      class IsHalfOfMatcher (line 2534) | class IsHalfOfMatcher {
        method MatchAndExplain (line 2537) | bool MatchAndExplain(const std::tuple<T1, T2>& a_pair,
        method DescribeTo (line 2548) | void DescribeTo(ostream* os) const {
        method DescribeNegationTo (line 2552) | void DescribeNegationTo(ostream* os) const {
      function IsHalfOf (line 2557) | PolymorphicMatcher<IsHalfOfMatcher> IsHalfOf() {
      function TEST (line 2561) | TEST(PointwiseTest, DescribesSelf) {
      function TEST (line 2578) | TEST(PointwiseTest, MakesCopyOfRhs) {
      function TEST (line 2592) | TEST(PointwiseTest, WorksForLhsNativeArray) {
      function TEST (line 2602) | TEST(PointwiseTest, WorksForRhsNativeArray) {
      function TEST (line 2613) | TEST(PointwiseTest, WorksForVectorOfBool) {
      function TEST (line 2622) | TEST(PointwiseTest, WorksForRhsInitializerList) {
      function TEST (line 2628) | TEST(PointwiseTest, RejectsWrongSize) {
      function TEST (line 2638) | TEST(PointwiseTest, RejectsWrongContent) {
      function TEST (line 2648) | TEST(PointwiseTest, AcceptsCorrectContent) {
      function TEST (line 2655) | TEST(PointwiseTest, AllowsMonomorphicInnerMatcher) {
      function TEST (line 2674) | TEST(PointwiseTest, WorksWithMoveOnly) {
      function TEST (line 2680) | TEST(UnorderedPointwiseTest, DescribesSelf) {
      function TEST (line 2706) | TEST(UnorderedPointwiseTest, MakesCopyOfRhs) {
      function TEST (line 2720) | TEST(UnorderedPointwiseTest, WorksForLhsNativeArray) {
      function TEST (line 2730) | TEST(UnorderedPointwiseTest, WorksForRhsNativeArray) {
      function TEST (line 2740) | TEST(UnorderedPointwiseTest, WorksForRhsInitializerList) {
      function TEST (line 2746) | TEST(UnorderedPointwiseTest, RejectsWrongSize) {
      function TEST (line 2757) | TEST(UnorderedPointwiseTest, RejectsWrongContent) {
      function TEST (line 2767) | TEST(UnorderedPointwiseTest, AcceptsCorrectContentInSameOrder) {
      function TEST (line 2773) | TEST(UnorderedPointwiseTest, AcceptsCorrectContentInDifferentOrder) {
      function TEST (line 2779) | TEST(UnorderedPointwiseTest, AllowsMonomorphicInnerMatcher) {
      function TEST (line 2791) | TEST(UnorderedPointwiseTest, WorksWithMoveOnly) {
      function TEST (line 2798) | TEST(PointeeTest, WorksOnMoveOnlyType) {
      class PredicateFormatterFromMatcherTest (line 2804) | class PredicateFormatterFromMatcherTest : public ::testing::Test {
        type Behavior (line 2806) | enum Behavior { kInitialSuccess, kAlwaysFail, kFlaky }
        class MockMatcher (line 2811) | class MockMatcher : public MatcherInterface<Behavior> {
          method MatchAndExplain (line 2813) | bool MatchAndExplain(Behavior behavior,
          method DescribeTo (line 2838) | void DescribeTo(ostream* os) const override { *os << "[DescribeT...
          method DescribeNegationTo (line 2840) | void DescribeNegationTo(ostream* os) const override {
        method AssertionResult (line 2845) | AssertionResult RunPredicateFormatter(Behavior behavior) {
      function TEST_F (line 2853) | TEST_F(PredicateFormatterFromMatcherTest, ShortCircuitOnSuccess) {
      function TEST_F (line 2860) | TEST_F(PredicateFormatterFromMatcherTest, NoShortCircuitOnFailure) {
      function TEST_F (line 2870) | TEST_F(PredicateFormatterFromMatcherTest, DetectsFlakyShortCircuit) {
      function TEST (line 2884) | TEST(ElementsAreTest, CanDescribeExpectingNoElement) {
      function TEST (line 2889) | TEST(ElementsAreTest, CanDescribeExpectingOneElement) {
      function TEST (line 2894) | TEST(ElementsAreTest, CanDescribeExpectingManyElements) {
      function TEST (line 2903) | TEST(ElementsAreTest, CanDescribeNegationOfExpectingNoElement) {
      function TEST (line 2908) | TEST(ElementsAreTest, CanDescribeNegationOfExpectingOneElement) {
      function TEST (line 2916) | TEST(ElementsAreTest, CanDescribeNegationOfExpectingManyElements) {
      function TEST (line 2925) | TEST(ElementsAreTest, DoesNotExplainTrivialMatch) {
      function TEST_P (line 2934) | TEST_P(ElementsAreTestP, ExplainsNonTrivialMatch) {
      function TEST (line 2946) | TEST(ElementsAreTest, CanExplainMismatchWrongSize) {
      function TEST_P (line 2957) | TEST_P(ElementsAreTestP, CanExplainMismatchRightSize) {
      function TEST (line 2970) | TEST(ElementsAreTest, MatchesOneElementVector) {
      function TEST (line 2977) | TEST(ElementsAreTest, MatchesOneElementList) {
      function TEST (line 2984) | TEST(ElementsAreTest, MatchesThreeElementVector) {
      function TEST (line 2993) | TEST(ElementsAreTest, MatchesOneElementEqMatcher) {
      function TEST (line 3000) | TEST(ElementsAreTest, MatchesOneElementAnyMatcher) {
      function TEST (line 3007) | TEST(ElementsAreTest, MatchesOneElementValue) {
      function TEST (line 3014) | TEST(ElementsAreTest, MatchesThreeElementsMixedMatchers) {
      function TEST (line 3023) | TEST(ElementsAreTest, MatchesTenElementVector) {
      function TEST (line 3033) | TEST(ElementsAreTest, DoesNotMatchWrongSize) {
      function TEST (line 3042) | TEST(ElementsAreTest, DoesNotMatchWrongValue) {
      function TEST (line 3050) | TEST(ElementsAreTest, DoesNotMatchWrongOrder) {
      function TEST (line 3061) | TEST(ElementsAreTest, WorksForNestedContainer) {
      function TEST (line 3075) | TEST(ElementsAreTest, WorksWithByRefElementMatchers) {
      function TEST (line 3083) | TEST(ElementsAreTest, WorksWithContainerPointerUsingPointee) {
      function TEST (line 3091) | TEST(ElementsAreTest, WorksWithNativeArrayPassedByReference) {
      class NativeArrayPassedAsPointerAndSize (line 3098) | class NativeArrayPassedAsPointerAndSize {
        method NativeArrayPassedAsPointerAndSize (line 3100) | NativeArrayPassedAsPointerAndSize() = default;
        method NativeArrayPassedAsPointerAndSize (line 3105) | NativeArrayPassedAsPointerAndSize(const NativeArrayPassedAsPointer...
        method NativeArrayPassedAsPointerAndSize (line 3107) | NativeArrayPassedAsPointerAndSize& operator=(
      function TEST (line 3111) | TEST(ElementsAreTest, WorksWithNativeArrayPassedAsPointerAndSize) {
      function TEST (line 3122) | TEST(ElementsAreTest, WorksWithTwoDimensionalNativeArray) {
      function TEST (line 3131) | TEST(ElementsAreTest, AcceptsStringLiteral) {
      function TEST (line 3140) | TEST(ElementsAreTest, AcceptsArrayWithUnknownSize) {
      function TEST (line 3153) | TEST(ElementsAreTest, MakesCopyOfArguments) {
      function TEST (line 3171) | TEST(ElementsAreArrayTest, CanBeCreatedWithValueArray) {
      function TEST (line 3181) | TEST(ElementsAreArrayTest, CanBeCreatedWithArraySize) {
      function TEST (line 3192) | TEST(ElementsAreArrayTest, CanBeCreatedWithoutArraySize) {
      function TEST (line 3202) | TEST(ElementsAreArrayTest, CanBeCreatedWithMatcherArray) {
      function TEST (line 3216) | TEST(ElementsAreArrayTest, CanBeCreatedWithVector) {
      function TEST (line 3225) | TEST(ElementsAreArrayTest, TakesInitializerList) {
      function TEST (line 3232) | TEST(ElementsAreArrayTest, TakesInitializerListOfCStrings) {
      function TEST (line 3239) | TEST(ElementsAreArrayTest, TakesInitializerListOfSameTypedMatchers) {
      function TEST (line 3245) | TEST(ElementsAreArrayTest, TakesInitializerListOfDifferentTypedMatch...
      function TEST (line 3256) | TEST(ElementsAreArrayTest, CanBeCreatedWithMatcherVector) {
      function TEST (line 3267) | TEST(ElementsAreArrayTest, CanBeCreatedWithIteratorRange) {
      function TEST (line 3282) | TEST(ElementsAreArrayTest, WorksWithNativeArray) {
      function TEST (line 3291) | TEST(ElementsAreArrayTest, SourceLifeSpan) {
      function TEST (line 3312) | TEST(ContainsTest, ListMatchesWhenElementIsInContainer) {
      function TEST (line 3330) | TEST(ContainsTest, ListDoesNotMatchWhenElementIsNotInContainer) {
      function TEST (line 3337) | TEST(ContainsTest, SetMatchesWhenElementIsInContainer) {
      function TEST (line 3354) | TEST(ContainsTest, SetDoesNotMatchWhenElementIsNotInContainer) {
      function TEST_P (line 3365) | TEST_P(ContainsTestP, ExplainsMatchResultCorrectly) {
      function TEST (line 3380) | TEST(ContainsTest, DescribesItselfCorrectly) {
      function TEST (line 3388) | TEST(ContainsTest, MapMatchesWhenElementIsInContainer) {
      function TEST (line 3404) | TEST(ContainsTest, MapDoesNotMatchWhenElementIsNotInContainer) {
      function TEST (line 3411) | TEST(ContainsTest, ArrayMatchesWhenElementIsInContainer) {
      function TEST (line 3416) | TEST(ContainsTest, ArrayDoesNotMatchWhenElementIsNotInContainer) {
      function TEST (line 3421) | TEST(ContainsTest, AcceptsMatcher) {
      function TEST (line 3427) | TEST(ContainsTest, WorksForNativeArrayAsTuple) {
      function TEST (line 3434) | TEST(ContainsTest, WorksForTwoDimensionalNativeArray) {

FILE: googlemock/test/gmock-matchers-misc_test.cc
  type testing (line 51) | namespace testing {
    type gmock_matchers_test (line 52) | namespace gmock_matchers_test {
      function TEST (line 55) | TEST(AddressTest, NonConst) {
      function TEST (line 70) | TEST(AddressTest, Const) {
      function TEST (line 81) | TEST(AddressTest, MatcherDoesntCopy) {
      function TEST (line 88) | TEST(AddressTest, Describe) {
      class NotCopyable (line 99) | class NotCopyable {
        method NotCopyable (line 101) | explicit NotCopyable(int a_value) : value_(a_value) {}
        method value (line 103) | int value() const { return value_; }
        method NotCopyable (line 116) | NotCopyable(const NotCopyable&) = delete;
        method NotCopyable (line 117) | NotCopyable& operator=(const NotCopyable&) = delete;
      function TEST (line 120) | TEST(ByRefTest, AllowsNotCopyableConstValueInMatchers) {
      function TEST (line 129) | TEST(ByRefTest, AllowsNotCopyableValueInMatchers) {
      function TEST (line 138) | TEST(IsEmptyTest, ImplementsIsEmpty) {
      function TEST (line 147) | TEST(IsEmptyTest, WorksWithString) {
      function TEST (line 156) | TEST(IsEmptyTest, CanDescribeSelf) {
      function TEST (line 162) | TEST(IsEmptyTest, ExplainsResult) {
      function TEST (line 170) | TEST(IsEmptyTest, WorksWithMoveOnly) {
      function TEST (line 176) | TEST(IsTrueTest, IsTrueIsFalse) {
      class ContainerEqTest (line 217) | class ContainerEqTest : public testing::Test {}
      function TYPED_TEST (line 225) | TYPED_TEST(ContainerEqTest, EqualsSelf) {
      function TYPED_TEST (line 234) | TYPED_TEST(ContainerEqTest, ValueMissing) {
      function TYPED_TEST (line 246) | TYPED_TEST(ContainerEqTest, ValueAdded) {
      function TYPED_TEST (line 257) | TYPED_TEST(ContainerEqTest, ValueAddedAndRemoved) {
      function TYPED_TEST (line 271) | TYPED_TEST(ContainerEqTest, DuplicateDifference) {
      function TEST (line 285) | TEST(ContainerEqExtraTest, MultipleValuesMissing) {
      function TEST (line 298) | TEST(ContainerEqExtraTest, MultipleValuesAdded) {
      function TEST (line 310) | TEST(ContainerEqExtraTest, MultipleValuesAddedAndRemoved) {
      function TEST (line 325) | TEST(ContainerEqExtraTest, MultiSetOfIntDuplicateDifference) {
      function TEST (line 339) | TEST(ContainerEqExtraTest, WorksForMaps) {
      function TEST (line 358) | TEST(ContainerEqExtraTest, WorksForNativeArray) {
      function TEST (line 367) | TEST(ContainerEqExtraTest, WorksForTwoDimensionalNativeArray) {
      function TEST (line 381) | TEST(ContainerEqExtraTest, WorksForNativeArrayAsTuple) {
      function TEST (line 394) | TEST(ContainerEqExtraTest, CopiesNativeArrayParameter) {
      class BacktrackingMaxBPMState (line 413) | class BacktrackingMaxBPMState {
        method BacktrackingMaxBPMState (line 416) | explicit BacktrackingMaxBPMState(const Graph* g) : graph_(g) {}
        method ElementMatcherPairs (line 418) | ElementMatcherPairs Compute() {
        method PushMatch (line 435) | void PushMatch(size_t lhs, size_t rhs) {
        method PopMatch (line 444) | void PopMatch() {
        method RecurseInto (line 451) | bool RecurseInto(size_t irhs) {
      function ElementMatcherPairs (line 489) | ElementMatcherPairs FindBacktrackingMaxBPM(const Graph& g) {
      class BacktrackingBPMTest (line 493) | class BacktrackingBPMTest : public ::testing::Test {}
      class BipartiteTest (line 497) | class BipartiteTest : public ::testing::TestWithParam<size_t> {}
      function TEST_P (line 500) | TEST_P(BipartiteTest, Exhaustive) {
      class BipartiteNonSquareTest (line 528) | class BipartiteNonSquareTest
      function TEST_F (line 531) | TEST_F(BipartiteNonSquareTest, SimpleBacktracking) {
      function TEST_P (line 551) | TEST_P(BipartiteNonSquareTest, Exhaustive) {
      class BipartiteRandomTest (line 572) | class BipartiteRandomTest
      function TEST_P (line 576) | TEST_P(BipartiteRandomTest, LargerNets) {
      function TEST (line 608) | TEST(IsReadableTypeNameTest, ReturnsTrueForShortNames) {
      function TEST (line 615) | TEST(IsReadableTypeNameTest, ReturnsTrueForLongNonTemplateNonFunctio...
      function TEST (line 621) | TEST(IsReadableTypeNameTest, ReturnsFalseForLongTemplateNames) {
      function TEST (line 627) | TEST(IsReadableTypeNameTest, ReturnsFalseForLongFunctionTypeNames) {
      function TEST (line 633) | TEST(FormatMatcherDescriptionTest, WorksForEmptyDescription) {
      function TEST_P (line 649) | TEST_P(MatcherTupleTestP, ExplainsMatchFailure) {
      class SampleOptional (line 683) | class SampleOptional {
        method SampleOptional (line 686) | explicit SampleOptional(T value)
        method SampleOptional (line 688) | SampleOptional() : value_(), has_value_(false) {}
        method T (line 690) | const T& operator*() const { return value_; }
      class SampleOptionalWithoutBoolConversion (line 701) | class SampleOptionalWithoutBoolConversion {
        method SampleOptionalWithoutBoolConversion (line 704) | explicit SampleOptionalWithoutBoolConversion(T value)
        method SampleOptionalWithoutBoolConversion (line 706) | SampleOptionalWithoutBoolConversion() : value_(), has_value_(false...
        method has_value (line 707) | bool has_value() const { return has_value_; }
        method T (line 708) | const T& operator*() const { return value_; }
      class OptionalTest (line 716) | class OptionalTest : public testing::Test {}
      function TYPED_TEST (line 724) | TYPED_TEST(OptionalTest, DescribesSelf) {
      function TYPED_TEST (line 729) | TYPED_TEST(OptionalTest, ExplainsSelf) {
      function TYPED_TEST (line 735) | TYPED_TEST(OptionalTest, MatchesNonEmptyOptional) {
      function TYPED_TEST (line 745) | TYPED_TEST(OptionalTest, DoesNotMatchNullopt) {
      function TYPED_TEST (line 751) | TYPED_TEST(OptionalTest, ComposesWithMonomorphicMatchersTakingRefere...
      function TYPED_TEST (line 760) | TYPED_TEST(OptionalTest, ComposesWithMonomorphicMatchersRequiringCon...
      class MoveOnlyOptionalTest (line 770) | class MoveOnlyOptionalTest : public testing::Test {}
      function TYPED_TEST (line 778) | TYPED_TEST(MoveOnlyOptionalTest, WorksWithMoveOnly) {
      class SampleVariantIntString (line 785) | class SampleVariantIntString {
        method SampleVariantIntString (line 787) | SampleVariantIntString(int i) : i_(i), has_int_(true) {}
        method SampleVariantIntString (line 788) | SampleVariantIntString(const std::string& s) : s_(s), has_int_(fal...
        method holds_alternative (line 791) | bool holds_alternative(const SampleVariantIntString& value) {
        method T (line 796) | const T& get(const SampleVariantIntString& value) {
      function TEST (line 809) | TEST(VariantTest, DescribesSelf) {
      function TEST (line 815) | TEST(VariantTest, ExplainsSelf) {
      function TEST (line 825) | TEST(VariantTest, FullMatch) {
      function TEST (line 833) | TEST(VariantTest, TypeDoesNotMatch) {
      function TEST (line 841) | TEST(VariantTest, InnerDoesNotMatch) {
      class SampleAnyType (line 849) | class SampleAnyType {
        method SampleAnyType (line 851) | explicit SampleAnyType(int i) : index_(0), i_(i) {}
        method SampleAnyType (line 852) | explicit SampleAnyType(const std::string& s) : index_(1), s_(s) {}
        method T (line 855) | const T* any_cast(const SampleAnyType* any) {
      function TEST (line 870) | TEST(AnyWithTest, FullMatch) {
      function TEST (line 875) | TEST(AnyWithTest, TestBadCastType) {
      function TEST (line 880) | TEST(AnyWithTest, TestUseInContainers) {
      function TEST (line 896) | TEST(AnyWithTest, TestCompare) {
      function TEST (line 900) | TEST(AnyWithTest, DescribesSelf) {
      function TEST (line 906) | TEST(AnyWithTest, ExplainsSelf) {
      function TEST (line 917) | TEST(ArgsTest, AcceptsZeroTemplateArg) {
      function TEST (line 923) | TEST(ArgsTest, AcceptsOneTemplateArg) {
      function TEST (line 930) | TEST(ArgsTest, AcceptsTwoTemplateArgs) {
      function TEST (line 938) | TEST(ArgsTest, AcceptsRepeatedTemplateArgs) {
      function TEST (line 944) | TEST(ArgsTest, AcceptsDecreasingTemplateArgs) {
      function TEST (line 954) | TEST(ArgsTest, AcceptsMoreTemplateArgsThanArityOfOriginalTuple) {
      function TEST (line 959) | TEST(ArgsTest, CanBeNested) {
      function TEST (line 965) | TEST(ArgsTest, CanMatchTupleByValue) {
      function TEST (line 972) | TEST(ArgsTest, CanMatchTupleByReference) {
      function TEST (line 982) | TEST(ArgsTest, AcceptsTenTemplateArgs) {
      function TEST (line 991) | TEST(ArgsTest, DescirbesSelfCorrectly) {
      function TEST (line 999) | TEST(ArgsTest, DescirbesNestedArgsCorrectly) {
      function TEST (line 1008) | TEST(ArgsTest, DescribesNegationCorrectly) {
      function TEST (line 1016) | TEST(ArgsTest, ExplainsMatchResultWithoutInnerExplanation) {
      class LessThanMatcher (line 1025) | class LessThanMatcher : public MatcherInterface<std::tuple<char, int...
        method DescribeTo (line 1027) | void DescribeTo(::std::ostream* /*os*/) const override {}
        method MatchAndExplain (line 1029) | bool MatchAndExplain(std::tuple<char, int> value,
      function LessThan (line 1040) | Matcher<std::tuple<char, int>> LessThan() {
      function TEST (line 1044) | TEST(ArgsTest, ExplainsMatchResultWithInnerExplanation) {
      function TEST (line 1060) | TEST(MatcherMacroTest, Works) {
      function TEST (line 1104) | TEST(MatcherMacroTest, DescriptionCanReferenceNegationAndParameters) {
      function TEST (line 1115) | TEST(MatcherMacroTest, CanExplainMatchResult) {
      function TEST (line 1138) | TEST(MatcherMacroTest, CanReferenceArgType) {
      type matcher_test (line 1148) | namespace matcher_test {
      function TEST (line 1152) | TEST(MatcherMacroTest, WorksInNamespace) {
      function TEST (line 1163) | TEST(MatcherMacroTest, CanBeComposedUsingValue) {
      function TEST (line 1173) | TEST(MatcherPMacroTest, Works) {
      function TEST (line 1187) | TEST(MatcherPMacroTest, GeneratesCorrectDescription) {
      class UncopyableFoo (line 1199) | class UncopyableFoo {
        method UncopyableFoo (line 1201) | explicit UncopyableFoo(char value) : value_(value) { (void)value_; }
        method UncopyableFoo (line 1203) | UncopyableFoo(const UncopyableFoo&) = delete;
      function TEST (line 1212) | TEST(MatcherPMacroTest, WorksWhenExplicitlyInstantiatedWithReference) {
      function TEST (line 1238) | TEST(MatcherPnMacroTest, CanReferenceParamTypes) {
      function TEST (line 1249) | TEST(MatcherPnMacroTest, WorksWhenExplicitlyInstantiatedWithReferenc...
      function TEST (line 1266) | TEST(MatcherPnMacroTest,
      function TEST (line 1286) | TEST(MatcherPnMacroTest, Works) {
      function TEST (line 1323) | TEST(MatcherPnMacroTest, CanBeOverloadedOnNumberOfParameters) {
      function TEST (line 1363) | TEST(MatcherPnMacroTest, WorksForDifferentParameterTypes) {
      function TEST (line 1380) | TEST(MatcherPnMacroTest, SimpleTypePromotion) {
      function TEST (line 1391) | TEST(MatcherPnMacroTest, TypesAreCorrect) {
      function TEST (line 1441) | TEST(MatcherPnMacroTest, CanUseMatcherTypedParameterInValue) {
      function TEST (line 1450) | TEST(ContainsTimes, ListMatchesWhenElementQuantityMatches) {
      function TEST_P (line 1469) | TEST_P(ContainsTimesP, ExplainsMatchResultCorrectly) {
      function TEST (line 1509) | TEST(ContainsTimes, DescribesItselfCorrectly) {
      function TEST (line 1521) | TEST(AllOfArrayTest, BasicForms) {
      function TEST (line 1563) | TEST(AllOfArrayTest, Matchers) {
      function TEST (line 1576) | TEST(AnyOfArrayTest, BasicForms) {
      function TEST (line 1616) | TEST(AnyOfArrayTest, Matchers) {
      function TEST_P (line 1628) | TEST_P(AnyOfArrayTestP, ExplainsMatchResultCorrectly) {
      function TEST (line 1667) | TEST(MatcherMacroTest, WorksOnMoveOnlyType) {
      function TEST (line 1677) | TEST(MatcherPMacroTest, WorksOnMoveOnlyType) {
      function TEST (line 1685) | TEST(MockMethodMockFunctionTest, EnsureNoUnusedButMarkedUnusedWarnin...
      function TEST (line 1703) | TEST(ThrowsTest, Examples) {
      function TEST (line 1713) | TEST(ThrowsTest, PrintsExceptionWhat) {
      function TEST (line 1719) | TEST(ThrowsTest, DoesNotGenerateDuplicateCatchClauseWarning) {
      function TEST (line 1724) | TEST(ThrowsTest, CallableExecutedExactlyOnce) {
      function TEST (line 1757) | TEST(ThrowsTest, Describe) {
      function TEST (line 1765) | TEST(ThrowsTest, Success) {
      function TEST (line 1773) | TEST(ThrowsTest, FailWrongType) {
      function TEST (line 1782) | TEST(ThrowsTest, FailWrongTypeNonStd) {
      function TEST (line 1790) | TEST(ThrowsTest, FailNoThrow) {
      class ThrowsPredicateTest (line 1797) | class ThrowsPredicateTest
      function TEST_P (line 1800) | TEST_P(ThrowsPredicateTest, Describe) {
      function TEST_P (line 1809) | TEST_P(ThrowsPredicateTest, Success) {
      function TEST_P (line 1817) | TEST_P(ThrowsPredicateTest, FailWrongType) {
      function TEST_P (line 1826) | TEST_P(ThrowsPredicateTest, FailWrongTypeNonStd) {
      function TEST_P (line 1834) | TEST_P(ThrowsPredicateTest, FailNoThrow) {
      function TEST (line 1847) | TEST(ThrowsPredicateCompilesTest, ExceptionMatcherAcceptsBroadType) {
      function TEST (line 1867) | TEST(ThrowsPredicateCompilesTest, MessageMatcherAcceptsNonMatcher) {

FILE: googlemock/test/gmock-matchers_test.h
  function namespace (line 66) | namespace testing {

FILE: googlemock/test/gmock-more-actions_test.cc
  type testing (line 51) | namespace testing {
    type gmock_more_actions_test (line 52) | namespace gmock_more_actions_test {
      function Short (line 70) | inline short Short(short n) { return n; }
      function Char (line 71) | inline char Char(char ch) { return ch; }
      function Nullary (line 74) | int Nullary() { return 1; }
      function Unary (line 78) | bool Unary(int x) { return x < 0; }
      function ByConstRef (line 80) | bool ByConstRef(const std::string& s) { return s == "Hi"; }
      function ReferencesGlobalDouble (line 83) | bool ReferencesGlobalDouble(const double& x) { return &x == &g_doubl...
      type UnaryFunctor (line 85) | struct UnaryFunctor {
      type UnaryMoveOnlyFunctor (line 89) | struct UnaryMoveOnlyFunctor : UnaryFunctor {
        method UnaryMoveOnlyFunctor (line 90) | UnaryMoveOnlyFunctor() = default;
        method UnaryMoveOnlyFunctor (line 91) | UnaryMoveOnlyFunctor(const UnaryMoveOnlyFunctor&) = delete;
        method UnaryMoveOnlyFunctor (line 92) | UnaryMoveOnlyFunctor(UnaryMoveOnlyFunctor&&) = default;
      type OneShotUnaryFunctor (line 95) | struct OneShotUnaryFunctor {
      function Ternary (line 101) | int Ternary(int x, char y, short z) { return x + y + z; }
      function SumOf4 (line 103) | int SumOf4(int a, int b, int c, int d) { return a + b + c + d; }
      function SumOfFirst2 (line 105) | int SumOfFirst2(int a, int b, Unused, Unused) { return a + b; }
      function SumOf5 (line 107) | int SumOf5(int a, int b, int c, int d, int e) { return a + b + c + d...
      type SumOf5Functor (line 109) | struct SumOf5Functor {
      function SumOf6 (line 115) | int SumOf6(int a, int b, int c, int d, int e, int f) {
      type SumOf6Functor (line 119) | struct SumOf6Functor {
      function Concat7 (line 125) | std::string Concat7(const char* s1, const char* s2, const char* s3,
      function Concat8 (line 131) | std::string Concat8(const char* s1, const char* s2, const char* s3,
      function Concat9 (line 137) | std::string Concat9(const char* s1, const char* s2, const char* s3,
      function Concat10 (line 143) | std::string Concat10(const char* s1, const char* s2, const char* s3,
      class Foo (line 150) | class Foo {
        method Foo (line 152) | Foo() : value_(123) {}
        method Nullary (line 154) | int Nullary() const { return value_; }
        method Unary (line 156) | short Unary(long x) { return static_cast<short>(value_ + x); }
        method Binary (line 158) | std::string Binary(const std::string& str, char c) const { return ...
        method Ternary (line 160) | int Ternary(int x, bool y, char z) { return value_ + x + y * z; }
        method SumOf4 (line 162) | int SumOf4(int a, int b, int c, int d) const {
        method SumOfLast2 (line 166) | int SumOfLast2(Unused, Unused, int a, int b) const { return a + b; }
        method SumOf5 (line 168) | int SumOf5(int a, int b, int c, int d, int e) { return a + b + c +...
        method SumOf6 (line 170) | int SumOf6(int a, int b, int c, int d, int e, int f) {
        method Concat7 (line 174) | std::string Concat7(const char* s1, const char* s2, const char* s3,
        method Concat8 (line 180) | std::string Concat8(const char* s1, const char* s2, const char* s3,
        method Concat9 (line 186) | std::string Concat9(const char* s1, const char* s2, const char* s3,
        method Concat10 (line 192) | std::string Concat10(const char* s1, const char* s2, const char* s3,
      function TEST (line 204) | TEST(InvokeTest, Nullary) {
      function TEST (line 210) | TEST(InvokeTest, Unary) {
      function TEST (line 217) | TEST(InvokeTest, Binary) {
      function TEST (line 224) | TEST(InvokeTest, Ternary) {
      function TEST (line 230) | TEST(InvokeTest, FunctionThatTakes4Arguments) {
      function TEST (line 236) | TEST(InvokeTest, FunctionThatTakes5Arguments) {
      function TEST (line 242) | TEST(InvokeTest, FunctionThatTakes6Arguments) {
      function TEST (line 253) | TEST(InvokeTest, FunctionThatTakes7Arguments) {
      function TEST (line 264) | TEST(InvokeTest, FunctionThatTakes8Arguments) {
      function TEST (line 275) | TEST(InvokeTest, FunctionThatTakes9Arguments) {
      function TEST (line 287) | TEST(InvokeTest, FunctionThatTakes10Arguments) {
      function TEST (line 300) | TEST(InvokeTest, FunctionWithUnusedParameters) {
      function TEST (line 312) | TEST(InvokeTest, MethodWithUnusedParameters) {
      function TEST (line 322) | TEST(InvokeTest, Functor) {
      function TEST (line 328) | TEST(InvokeTest, FunctionWithCompatibleType) {
      function TEST (line 336) | TEST(InvokeMethodTest, Nullary) {
      function TEST (line 343) | TEST(InvokeMethodTest, Unary) {
      function TEST (line 350) | TEST(InvokeMethodTest, Binary) {
      function TEST (line 359) | TEST(InvokeMethodTest, Ternary) {
      function TEST (line 366) | TEST(InvokeMethodTest, MethodThatTakes4Arguments) {
      function TEST (line 373) | TEST(InvokeMethodTest, MethodThatTakes5Arguments) {
      function TEST (line 381) | TEST(InvokeMethodTest, MethodThatTakes6Arguments) {
      function TEST (line 390) | TEST(InvokeMethodTest, MethodThatTakes7Arguments) {
      function TEST (line 402) | TEST(InvokeMethodTest, MethodThatTakes8Arguments) {
      function TEST (line 414) | TEST(InvokeMethodTest, MethodThatTakes9Arguments) {
      function TEST (line 427) | TEST(InvokeMethodTest, MethodThatTakes10Arguments) {
      function TEST (line 441) | TEST(InvokeMethodTest, MethodWithCompatibleType) {
      function TEST (line 449) | TEST(WithoutArgsTest, NoArg) {
      function TEST (line 455) | TEST(WithArgTest, OneArg) {
      function TEST (line 461) | TEST(ReturnArgActionTest, WorksForOneArgIntArg0) {
      function TEST (line 466) | TEST(ReturnArgActionTest, WorksForMultiArgBoolArg0) {
      function TEST (line 471) | TEST(ReturnArgActionTest, WorksForMultiArgStringArg2) {
      function TEST (line 476) | TEST(ReturnArgActionTest, WorksForNonConstRefArg0) {
      function TEST (line 482) | TEST(SaveArgActionTest, WorksForSameType) {
      function TEST (line 489) | TEST(SaveArgActionTest, WorksForCompatibleType) {
      type MoveOnly (line 496) | struct MoveOnly {
        method MoveOnly (line 497) | explicit MoveOnly(int v) : i(v) {}
        method MoveOnly (line 498) | MoveOnly(MoveOnly&& o) {
        method MoveOnly (line 502) | MoveOnly& operator=(MoveOnly&& o) {
      function TEST (line 510) | TEST(SaveArgByMoveActionTest, WorksForSameType) {
      function TEST (line 517) | TEST(SaveArgByMoveActionTest, WorksForCompatibleType) {
      function TEST (line 524) | TEST(SaveArgPointeeActionTest, WorksForSameType) {
      function TEST (line 532) | TEST(SaveArgPointeeActionTest, WorksForCompatibleType) {
      function TEST (line 540) | TEST(SetArgRefereeActionTest, WorksForSameType) {
      function TEST (line 547) | TEST(SetArgRefereeActionTest, WorksForCompatibleType) {
      function TEST (line 554) | TEST(SetArgRefereeActionTest, WorksWithExtraArguments) {
      class DeletionTester (line 563) | class DeletionTester {
        method DeletionTester (line 565) | explicit DeletionTester(bool* is_deleted) : is_deleted_(is_deleted) {
      function TEST (line 576) | TEST(DeleteArgActionTest, OneArg) {
      function TEST (line 585) | TEST(DeleteArgActionTest, TenArgs) {
      function TEST (line 598) | TEST(ThrowActionTest, ThrowsGivenExceptionInVoidFunction) {
      class MyException (line 603) | class MyException {}
      function TEST (line 605) | TEST(ThrowActionTest, ThrowsGivenExceptionInNonVoidFunction) {
      function TEST (line 610) | TEST(ThrowActionTest, ThrowsGivenExceptionInNullaryFunction) {
      class Object (line 615) | class Object {
        method Func (line 618) | virtual void Func() {}
      class MockObject (line 621) | class MockObject : public Object {
      function TEST (line 627) | TEST(ThrowActionTest, Times0) {
      function TEST (line 646) | TEST(SetArrayArgumentTest, SetsTheNthArray) {
      function TEST (line 682) | TEST(SetArrayArgumentTest, SetsTheNthArrayWithEmptyRange) {
      function TEST (line 698) | TEST(SetArrayArgumentTest, SetsTheNthArrayWithConvertibleType) {
      function TEST (line 713) | TEST(SetArrayArgumentTest, SetsTheNthArrayWithIteratorArgument) {
      function TEST (line 723) | TEST(ReturnPointeeTest, Works) {
      function TEST (line 735) | TEST(InvokeArgumentTest, Function0) {
      function TEST (line 741) | TEST(InvokeArgumentTest, Functor1) {
      function TEST (line 747) | TEST(InvokeArgumentTest, Functor1MoveOnly) {
      function TEST (line 753) | TEST(InvokeArgumentTest, OneShotFunctor1) {
      function TEST (line 759) | TEST(InvokeArgumentTest, Function5) {
      function TEST (line 766) | TEST(InvokeArgumentTest, Functor5) {
      function TEST (line 773) | TEST(InvokeArgumentTest, Function6) {
      function TEST (line 780) | TEST(InvokeArgumentTest, Functor6) {
      function TEST (line 787) | TEST(InvokeArgumentTest, Function7) {
      function TEST (line 796) | TEST(InvokeArgumentTest, Function8) {
      function TEST (line 805) | TEST(InvokeArgumentTest, Function9) {
      function TEST (line 814) | TEST(InvokeArgumentTest, Function10) {
      function TEST (line 823) | TEST(InvokeArgumentTest, ByPointerFunction) {
      function TEST (line 831) | TEST(InvokeArgumentTest, FunctionWithCStringLiteral) {
      function TEST (line 838) | TEST(InvokeArgumentTest, ByConstReferenceFunction) {
      function TEST (line 849) | TEST(InvokeArgumentTest, ByExplicitConstReferenceFunction) {
      function TEST (line 860) | TEST(InvokeArgumentTest, MoveOnlyType) {
      function TEST (line 877) | TEST(DoAllTest, TwoActions) {
      function TEST (line 886) | TEST(DoAllTest, ThreeActions) {
      function TEST (line 896) | TEST(DoAllTest, FourActions) {
      function TEST (line 909) | TEST(DoAllTest, FiveActions) {
      function TEST (line 923) | TEST(DoAllTest, SixActions) {
      function TEST (line 938) | TEST(DoAllTest, SevenActions) {
      function TEST (line 955) | TEST(DoAllTest, EightActions) {
      function TEST (line 975) | TEST(DoAllTest, NineActions) {
      function TEST (line 996) | TEST(DoAllTest, TenActions) {
      function TEST (line 1020) | TEST(DoAllTest, NoArgs) {
      function TEST (line 1027) | TEST(DoAllTest, MoveOnlyArgs) {
      function TEST (line 1036) | TEST(DoAllTest, ImplicitlyConvertsActionArguments) {
      function ACTION (line 1058) | ACTION(Return5) { return 5; }
      function TEST (line 1060) | TEST(ActionMacroTest, WorksWhenNotReferencingArguments) {
      function ACTION (line 1069) | ACTION(IncrementArg1) { (*arg1)++; }
      function TEST (line 1071) | TEST(ActionMacroTest, WorksWhenReturningVoid) {
      function ACTION (line 1080) | ACTION(IncrementArg2) {
      function TEST (line 1086) | TEST(ActionMacroTest, CanReferenceArgumentType) {
      function ACTION (line 1095) | ACTION(Sum2) {
      function TEST (line 1101) | TEST(ActionMacroTest, CanReferenceArgumentTuple) {
      function Dummy (line 1111) | int Dummy(bool flag) { return flag ? 1 : 0; }
      function ACTION (line 1115) | ACTION(InvokeDummy) {
      function TEST (line 1121) | TEST(ActionMacroTest, CanReferenceMockFunctionType) {
      function ACTION (line 1129) | ACTION(InvokeDummy2) {
      function TEST (line 1135) | TEST(ActionMacroTest, CanReferenceMockFunctionReturnType) {
      function ACTION (line 1142) | ACTION(ReturnAddrOfConstBoolReferenceArg) {
      function TEST (line 1147) | TEST(ActionMacroTest, WorksForConstReferenceArg) {
      function ACTION (line 1154) | ACTION(ReturnAddrOfIntReferenceArg) {
      function TEST (line 1159) | TEST(ActionMacroTest, WorksForNonConstReferenceArg) {
      type action_test (line 1166) | namespace action_test {
        function ACTION (line 1167) | ACTION(Sum) { return arg0 + arg1; }
      function TEST (line 1170) | TEST(ActionMacroTest, WorksInNamespace) {
      function ACTION (line 1177) | ACTION(PlusTwo) { return arg0 + 2; }
      function TEST (line 1179) | TEST(ActionMacroTest, WorksForDifferentArgumentNumbers) {
      function ACTION_P (line 1189) | ACTION_P(Plus, n) { return arg0 + n; }
      function TEST (line 1191) | TEST(ActionPMacroTest, DefinesParameterizedAction) {
      function ACTION_P (line 1198) | ACTION_P(TypedPlus, n) {
      function TEST (line 1204) | TEST(ActionPMacroTest, CanReferenceArgumentAndParameterTypes) {
      function TEST (line 1211) | TEST(ActionPMacroTest, WorksInCompatibleMockFunction) {
      function ACTION (line 1221) | ACTION(OverloadedAction) { return arg0 ? arg1 : "hello"; }
      function ACTION_P (line 1223) | ACTION_P(OverloadedAction, default_value) {
      function ACTION_P2 (line 1227) | ACTION_P2(OverloadedAction, true_value, false_value) {
      function TEST (line 1231) | TEST(ActionMacroTest, CanDefineOverloadedActions) {
      function ACTION_P3 (line 1249) | ACTION_P3(Plus, m, n, k) { return arg0 + m + n + k; }
      function TEST (line 1251) | TEST(ActionPnMacroTest, WorksFor3Parameters) {
      function ACTION_P4 (line 1261) | ACTION_P4(Plus, p0, p1, p2, p3) { return arg0 + p0 + p1 + p2 + p3; }
      function TEST (line 1263) | TEST(ActionPnMacroTest, WorksFor4Parameters) {
      function ACTION_P5 (line 1268) | ACTION_P5(Plus, p0, p1, p2, p3, p4) { return arg0 + p0 + p1 + p2 + p...
      function TEST (line 1270) | TEST(ActionPnMacroTest, WorksFor5Parameters) {
      function ACTION_P6 (line 1275) | ACTION_P6(Plus, p0, p1, p2, p3, p4, p5) {
      function TEST (line 1279) | TEST(ActionPnMacroTest, WorksFor6Parameters) {
      function ACTION_P7 (line 1284) | ACTION_P7(Plus, p0, p1, p2, p3, p4, p5, p6) {
      function TEST (line 1288) | TEST(ActionPnMacroTest, WorksFor7Parameters) {
      function ACTION_P8 (line 1293) | ACTION_P8(Plus, p0, p1, p2, p3, p4, p5, p6, p7) {
      function TEST (line 1297) | TEST(ActionPnMacroTest, WorksFor8Parameters) {
      function ACTION_P9 (line 1303) | ACTION_P9(Plus, p0, p1, p2, p3, p4, p5, p6, p7, p8) {
      function TEST (line 1307) | TEST(ActionPnMacroTest, WorksFor9Parameters) {
      function ACTION_P10 (line 1313) | ACTION_P10(Plus, p0, p1, p2, p3, p4, p5, p6, p7, p8, last_param) {
      function TEST (line 1319) | TEST(ActionPnMacroTest, WorksFor10Parameters) {
      function ACTION_P2 (line 1327) | ACTION_P2(PadArgument, prefix, suffix) {
      function TEST (line 1334) | TEST(ActionPnMacroTest, SimpleTypePromotion) {
      function ACTION_P3 (line 1348) | ACTION_P3(ConcatImpl, a, b, c) {
      function Concat (line 1363) | ConcatImplActionP3<std::string, T1, T2> Concat(const std::string& a,...
      function Concat (line 1382) | ConcatImplActionP3<T1, int, T2> Concat(T1 a, int b, T2 c) {
      function TEST (line 1386) | TEST(ActionPnMacroTest, CanPartiallyRestrictParameterTypes) {
      function ACTION (line 1396) | ACTION(DoFoo) {}
      function ACTION_P (line 1397) | ACTION_P(DoFoo, p) {}
      function ACTION_P2 (line 1398) | ACTION_P2(DoFoo, p0, p1) {}
      function TEST (line 1400) | TEST(ActionPnMacroTest, TypesAreCorrect) {
      function ACTION_P (line 1440) | ACTION_P(Plus1, x) { return x; }
      function ACTION_P2 (line 1441) | ACTION_P2(Plus2, x, y) { return x + y; }
      function ACTION_P3 (line 1442) | ACTION_P3(Plus3, x, y, z) { return x + y + z; }
      function ACTION_P10 (line 1443) | ACTION_P10(Plus10, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
      function TEST (line 1447) | TEST(ActionPnMacroTest, CanExplicitlyInstantiateWithReferenceTypes) {
      class TenArgConstructorClass (line 1467) | class TenArgConstructorClass {
        method TenArgConstructorClass (line 1469) | TenArgConstructorClass(int a1, int a2, int a3, int a4, int a5, int...
      function TEST (line 1481) | TEST(ActionTemplateTest, WorksWithoutValueParam) {
      function TEST (line 1493) | TEST(ActionTemplateTest, WorksWithValueParams) {
      function ACTION_TEMPLATE (line 1501) | ACTION_TEMPLATE(MyDeleteArg, HAS_1_TEMPLATE_PARAMS(int, k),
      class BoolResetter (line 1507) | class BoolResetter {
        method BoolResetter (line 1509) | explicit BoolResetter(bool* value) : value_(value) {}
      function TEST (line 1516) | TEST(ActionTemplateTest, WorksForIntegralTemplateParams) {
      function TEST (line 1533) | TEST(ActionTemplateTest, WorksForTemplateTemplateParameters) {
      type GiantTemplate (line 1543) | struct GiantTemplate {
        method GiantTemplate (line 1545) | explicit GiantTemplate(int a_value) : value(a_value) {}
      function TEST (line 1558) | TEST(ActionTemplateTest, WorksFor10TemplateParameters) {
      function TEST (line 1573) | TEST(ActionTemplateTest, WorksFor10ValueParameters) {
      function ACTION (line 1581) | ACTION(ReturnSum) { return 0; }
      function ACTION_P (line 1583) | ACTION_P(ReturnSum, x) { return x; }
      function TEST (line 1600) | TEST(ActionTemplateTest, CanBeOverloadedOnNumberOfValueParameters) {

FILE: googlemock/test/gmock-nice-strict_test.cc
  class Mock (line 41) | class Mock {
    method Mock (line 43) | Mock() = default;
    method Mock (line 48) | Mock(const Mock&) = delete;
    method Mock (line 49) | Mock& operator=(const Mock&) = delete;
  type testing (line 52) | namespace testing {
    type gmock_nice_strict_test (line 53) | namespace gmock_nice_strict_test {
      class NotDefaultConstructible (line 66) | class NotDefaultConstructible {
        method NotDefaultConstructible (line 68) | explicit NotDefaultConstructible(int) {}
      class CallsMockMethodInDestructor (line 71) | class CallsMockMethodInDestructor {
      class Foo (line 79) | class Foo {
      class MockFoo (line 87) | class MockFoo : public Foo {
        method MockFoo (line 89) | MockFoo() = default;
        method Delete (line 90) | void Delete() { delete this; }
        method MockFoo (line 97) | MockFoo(const MockFoo&) = delete;
        method MockFoo (line 98) | MockFoo& operator=(const MockFoo&) = delete;
      class MockBar (line 101) | class MockBar {
        method MockBar (line 103) | explicit MockBar(const std::string& s) : str_(s) {}
        method MockBar (line 105) | MockBar(char a1, char a2, std::string a3, std::string a4, int a5, ...
        method MockBar (line 122) | MockBar(const MockBar&) = delete;
        method MockBar (line 123) | MockBar& operator=(const MockBar&) = delete;
      class MockBaz (line 126) | class MockBaz {
        class MoveOnly (line 128) | class MoveOnly {
          method MoveOnly (line 130) | MoveOnly() = default;
          method MoveOnly (line 132) | MoveOnly(const MoveOnly&) = delete;
          method MoveOnly (line 133) | MoveOnly& operator=(const MoveOnly&) = delete;
          method MoveOnly (line 135) | MoveOnly(MoveOnly&&) = default;
          method MoveOnly (line 136) | MoveOnly& operator=(MoveOnly&&) = default;
        method MockBaz (line 139) | MockBaz(MoveOnly) {}
      function TEST (line 145) | TEST(RawMockTest, WarningForUninterestingCall) {
      function TEST (line 162) | TEST(RawMockTest, WarningForUninterestingCallAfterDeath) {
      function TEST (line 180) | TEST(RawMockTest, InfoForUninterestingCall) {
      function TEST (line 193) | TEST(RawMockTest, IsNaggy_IsNice_IsStrict) {
      function TEST (line 201) | TEST(NiceMockTest, NoWarningForUninterestingCall) {
      function TEST (line 212) | TEST(NiceMockTest, NoWarningForUninterestingCallAfterDeath) {
      function TEST (line 225) | TEST(NiceMockTest, InfoForUninterestingCall) {
      function TEST (line 241) | TEST(NiceMockTest, AllowsExpectedCall) {
      function TEST (line 251) | TEST(NiceMockTest, ThrowsExceptionForUnknownReturnTypes) {
      function TEST (line 266) | TEST(NiceMockTest, UnexpectedCallFails) {
      function TEST (line 275) | TEST(NiceMockTest, NonDefaultConstructor) {
      function TEST (line 285) | TEST(NiceMockTest, NonDefaultConstructor10) {
      function TEST (line 294) | TEST(NiceMockTest, AllowLeak) {
      function TEST (line 301) | TEST(NiceMockTest, MoveOnlyConstructor) {
      function TEST (line 307) | TEST(NiceMockTest, AcceptsClassNamedMock) {
      function TEST (line 313) | TEST(NiceMockTest, IsNiceInDestructor) {
      function TEST (line 320) | TEST(NiceMockTest, IsNaggy_IsNice_IsStrict) {
      function TEST (line 330) | TEST(NaggyMockTest, WarningForUninterestingCall) {
      function TEST (line 347) | TEST(NaggyMockTest, WarningForUninterestingCallAfterDeath) {
      function TEST (line 367) | TEST(NaggyMockTest, AllowsExpectedCall) {
      function TEST (line 375) | TEST(NaggyMockTest, UnexpectedCallFails) {
      function TEST (line 385) | TEST(NaggyMockTest, NonDefaultConstructor) {
      function TEST (line 395) | TEST(NaggyMockTest, NonDefaultConstructor10) {
      function TEST (line 404) | TEST(NaggyMockTest, AllowLeak) {
      function TEST (line 411) | TEST(NaggyMockTest, MoveOnlyConstructor) {
      function TEST (line 417) | TEST(NaggyMockTest, AcceptsClassNamedMock) {
      function TEST (line 423) | TEST(NaggyMockTest, IsNaggyInDestructor) {
      function TEST (line 439) | TEST(NaggyMockTest, IsNaggy_IsNice_IsStrict) {
      function TEST (line 447) | TEST(StrictMockTest, AllowsExpectedCall) {
      function TEST (line 455) | TEST(StrictMockTest, UnexpectedCallFails) {
      function TEST (line 464) | TEST(StrictMockTest, UninterestingCallFails) {
      function TEST (line 473) | TEST(StrictMockTest, UninterestingCallFailsAfterDeath) {
      function TEST (line 485) | TEST(StrictMockTest, NonDefaultConstructor) {
      function TEST (line 495) | TEST(StrictMockTest, NonDefaultConstructor10) {
      function TEST (line 504) | TEST(StrictMockTest, AllowLeak) {
      function TEST (line 511) | TEST(StrictMockTest, MoveOnlyConstructor) {
      function TEST (line 517) | TEST(StrictMockTest, AcceptsClassNamedMock) {
      function TEST (line 523) | TEST(StrictMockTest, IsStrictInDestructor) {
      function TEST (line 533) | TEST(StrictMockTest, IsNaggy_IsNice_IsStrict) {

FILE: googlemock/test/gmock-port_test.cc
  function TEST (line 42) | TEST(DummyTest, Dummy) {}

FILE: googlemock/test/gmock-pp-string_test.cc
  type testing (line 38) | namespace testing {
    function SameExceptSpaces (line 43) | ::testing::Matcher<const std::string&> SameExceptSpaces(const std::str...
    function TEST (line 58) | TEST(Macros, Cat) {
    function TEST (line 63) | TEST(Macros, Narg) {
    function TEST (line 75) | TEST(Macros, Comma) {
    function TEST (line 81) | TEST(Macros, IsEmpty) {
    function TEST (line 91) | TEST(Macros, If) {
    function TEST (line 96) | TEST(Macros, HeadTail) {
    function TEST (line 106) | TEST(Macros, Parentheses) {
    function TEST (line 122) | TEST(Macros, Increment) {
    function TEST (line 135) | TEST(Macros, Repeat) {
    function TEST (line 164) | TEST(Macros, ForEach) {

FILE: googlemock/test/gmock-pp_test.cc
  type testing (line 9) | namespace testing {
    type internal (line 10) | namespace internal {
      type gmockpp (line 11) | namespace gmockpp {
        type Test (line 55) | struct Test {

FILE: googlemock/test/gmock-spec-builders_test.cc
  type testing (line 48) | namespace testing {
    class Incomplete (line 64) | class Incomplete
    class MockIncomplete (line 66) | class MockIncomplete {
    function TEST (line 76) | TEST(MockMethodTest, CanInstantiateWithIncompleteArgType) {
    function PrintTo (line 87) | void PrintTo(const Incomplete& /* x */, ::std::ostream* os) {
    class Result (line 91) | class Result {}
    class NonDefaultConstructible (line 94) | class NonDefaultConstructible {
      method NonDefaultConstructible (line 96) | explicit NonDefaultConstructible(int /* dummy */) {}
    class MockA (line 99) | class MockA {
      method MockA (line 101) | MockA() = default;
      method MockA (line 110) | MockA(const MockA&) = delete;
      method MockA (line 111) | MockA& operator=(const MockA&) = delete;
    class MockB (line 114) | class MockB {
      method MockB (line 116) | MockB() = default;
      method MockB (line 122) | MockB(const MockB&) = delete;
      method MockB (line 123) | MockB& operator=(const MockB&) = delete;
    class ReferenceHoldingMock (line 126) | class ReferenceHoldingMock {
      method ReferenceHoldingMock (line 128) | ReferenceHoldingMock() = default;
      method ReferenceHoldingMock (line 133) | ReferenceHoldingMock(const ReferenceHoldingMock&) = delete;
      method ReferenceHoldingMock (line 134) | ReferenceHoldingMock& operator=(const ReferenceHoldingMock&) = delete;
    class CC (line 144) | class CC {
    class MockCC (line 149) | class MockCC : public CC {
      method MockCC (line 151) | MockCC() = default;
      method MockCC (line 156) | MockCC(const MockCC&) = delete;
      method MockCC (line 157) | MockCC& operator=(const MockCC&) = delete;
    function TEST (line 161) | TEST(OnCallSyntaxTest, CompilesWithMethodNameExpandedFromMacro) {
    function TEST (line 168) | TEST(OnCallSyntaxTest, WorksWithMethodNameExpandedFromMacro) {
    function TEST (line 175) | TEST(ExpectCallSyntaxTest, CompilesWithMethodNameExpandedFromMacro) {
    function TEST (line 182) | TEST(ExpectCallSyntaxTest, WorksWithMethodNameExpandedFromMacro) {
    function TEST (line 192) | TEST(OnCallSyntaxTest, EvaluatesFirstArgumentOnce) {
    function TEST (line 200) | TEST(OnCallSyntaxTest, EvaluatesSecondArgumentOnce) {
    function TEST (line 210) | TEST(OnCallSyntaxTest, WithIsOptional) {
    function TEST (line 217) | TEST(OnCallSyntaxTest, WithCanAppearAtMostOnce) {
    function TEST (line 230) | TEST(OnCallSyntaxTest, WillByDefaultIsMandatory) {
    function TEST (line 241) | TEST(OnCallSyntaxTest, WillByDefaultCanAppearAtMostOnce) {
    function TEST (line 253) | TEST(ExpectCallSyntaxTest, EvaluatesFirstArgumentOnce) {
    function TEST (line 262) | TEST(ExpectCallSyntaxTest, EvaluatesSecondArgumentOnce) {
    function TEST (line 273) | TEST(ExpectCallSyntaxTest, WithIsOptional) {
    function TEST (line 280) | TEST(ExpectCallSyntaxTest, WithCanAppearAtMostOnce) {
    function TEST (line 292) | TEST(ExpectCallSyntaxTest, WithMustBeFirstClause) {
    function TEST (line 312) | TEST(ExpectCallSyntaxTest, TimesCanBeInferred) {
    function TEST (line 324) | TEST(ExpectCallSyntaxTest, TimesCanAppearAtMostOnce) {
    function TEST (line 337) | TEST(ExpectCallSyntaxTest, TimesMustBeBeforeInSequence) {
    function TEST (line 350) | TEST(ExpectCallSyntaxTest, InSequenceIsOptional) {
    function TEST (line 361) | TEST(ExpectCallSyntaxTest, InSequenceCanAppearMultipleTimes) {
    function TEST (line 370) | TEST(ExpectCallSyntaxTest, InSequenceMustBeBeforeAfter) {
    function TEST (line 384) | TEST(ExpectCallSyntaxTest, InSequenceMustBeBeforeWillOnce) {
    function TEST (line 397) | TEST(ExpectCallSyntaxTest, AfterMustBeBeforeWillOnce) {
    function TEST (line 409) | TEST(ExpectCallSyntaxTest, WillIsOptional) {
    function TEST (line 419) | TEST(ExpectCallSyntaxTest, WillCanAppearMultipleTimes) {
    function TEST (line 429) | TEST(ExpectCallSyntaxTest, WillMustBeBeforeWillRepeatedly) {
    function TEST (line 441) | TEST(ExpectCallSyntaxTest, WillRepeatedlyIsOptional) {
    function TEST (line 452) | TEST(ExpectCallSyntaxTest, WillRepeatedlyCannotAppearMultipleTimes) {
    function TEST (line 464) | TEST(ExpectCallSyntaxTest, WillRepeatedlyMustBeBeforeRetiresOnSaturati...
    function TEST (line 474) | TEST(ExpectCallSyntaxTest, RetiresOnSaturationIsOptional) {
    function TEST (line 484) | TEST(ExpectCallSyntaxTest, RetiresOnSaturationCannotAppearMultipleTime...
    function TEST (line 496) | TEST(ExpectCallSyntaxTest, DefaultCardinalityIsOnce) {
    function TEST (line 522) | TEST(ExpectCallSyntaxTest, DoesNotWarnOnAdequateActionCount) {
    function TEST (line 552) | TEST(ExpectCallSyntaxTest, WarnsOnTooManyActions) {
    function TEST (line 607) | TEST(ExpectCallSyntaxTest, WarnsOnTooFewActions) {
    function TEST (line 623) | TEST(ExpectCallSyntaxTest, WarningIsErrorWithFlag) {
    function TEST (line 685) | TEST(OnCallTest, TakesBuiltInDefaultActionWhenNoOnCall) {
    function TEST (line 694) | TEST(OnCallTest, TakesBuiltInDefaultActionWhenNoOnCallMatches) {
    function TEST (line 703) | TEST(OnCallTest, PicksLastMatchingOnCall) {
    function TEST (line 716) | TEST(ExpectCallTest, AllowsAnyCallWhenNoSpec) {
    function TEST (line 729) | TEST(ExpectCallTest, PicksLastMatchingExpectCall) {
    function TEST (line 738) | TEST(ExpectCallTest, CatchesTooFewCalls) {
    function TEST (line 754) | TEST(ExpectCallTest, InfersCardinalityWhenThereIsNoWillRepeatedly) {
    function TEST (line 782) | TEST(ExpectCallTest, InfersCardinality1WhenThereIsWillRepeatedly) {
    function TEST (line 812) | TEST(ExpectCallTest, NonMoveableType) {
    function TEST (line 853) | TEST(ExpectCallTest, NthMatchTakesNthAction) {
    function TEST (line 865) | TEST(ExpectCallTest, TakesRepeatedActionWhenWillListIsExhausted) {
    function TEST (line 878) | TEST(ExpectCallTest, TakesDefaultActionWhenWillListIsExhausted) {
    function TEST (line 908) | TEST(FunctionMockerMessageTest, ReportsExpectCallLocationForExhaustedA...
    function TEST (line 922) | TEST(FunctionMockerMessageTest,
    function TEST (line 938) | TEST(UninterestingCallTest, DoesDefaultAction) {
    function TEST (line 952) | TEST(UnexpectedCallTest, DoesDefaultAction) {
    function TEST (line 975) | TEST(UnexpectedCallTest, GeneratesFailureForVoidFunction) {
    function TEST (line 1024) | TEST(UnexpectedCallTest, GeneartesFailureForNonVoidFunction) {
    function TEST (line 1044) | TEST(UnexpectedCallTest, RetiredExpectation) {
    function TEST (line 1056) | TEST(UnexpectedCallTest, UnmatchedArguments) {
    function TEST (line 1068) | TEST(UnexpectedCallTest, UnsatisfiedPrerequisites) {
    function TEST (line 1113) | TEST(UndefinedReturnValueTest,
    function TEST (line 1128) | TEST(ExcessiveCallTest, DoesDefaultAction) {
    function TEST (line 1153) | TEST(ExcessiveCallTest, GeneratesFailureForVoidFunction) {
    function TEST (line 1167) | TEST(ExcessiveCallTest, GeneratesFailureForNonVoidFunction) {
    function TEST (line 1183) | TEST(InSequenceTest, AllExpectationInScopeAreInSequence) {
    function TEST (line 1202) | TEST(InSequenceTest, NestedInSequence) {
    function TEST (line 1227) | TEST(InSequenceTest, ExpectationsOutOfScopeAreNotAffected) {
    function TEST (line 1249) | TEST(SequenceTest, AnyOrderIsOkByDefault) {
    function TEST (line 1275) | TEST(SequenceTest, CallsMustBeInStrictOrderWhenSaidSo1) {
    function TEST (line 1295) | TEST(SequenceTest, CallsMustBeInStrictOrderWhenSaidSo2) {
    class PartialOrderTest (line 1311) | class PartialOrderTest : public testing::Test {
      method PartialOrderTest (line 1313) | PartialOrderTest() {
    function TEST_F (line 1332) | TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag1) {
    function TEST_F (line 1343) | TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag2) {
    function TEST_F (line 1353) | TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag3) {
    function TEST_F (line 1363) | TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag4) {
    function TEST (line 1373) | TEST(SequenceTest, Retirement) {
    function TEST (line 1388) | TEST(ExpectationTest, ConstrutorsWork) {
    function TEST (line 1420) | TEST(ExpectationTest, AssignmentWorks) {
    function TEST (line 1435) | TEST(ExpectationSetTest, MemberTypesAreCorrect) {
    function TEST (line 1439) | TEST(ExpectationSetTest, ConstructorsWork) {
    function TEST (line 1468) | TEST(ExpectationSetTest, AssignmentWorks) {
    function TEST (line 1478) | TEST(ExpectationSetTest, InsertionWorks) {
    function TEST (line 1498) | TEST(ExpectationSetTest, SizeWorks) {
    function TEST (line 1512) | TEST(ExpectationSetTest, IsEnumerable) {
    function TEST (line 1526) | TEST(AfterTest, SucceedsWhenPartialOrderIsSatisfied) {
    function TEST (line 1538) | TEST(AfterTest, SucceedsWhenTotalOrderIsSatisfied) {
    function TEST (line 1554) | TEST(AfterTest, CallsMustBeInStrictOrderWhenSpecifiedSo1) {
    function TEST (line 1574) | TEST(AfterTest, CallsMustBeInStrictOrderWhenSpecifiedSo2) {
    function TEST (line 1595) | TEST(AfterTest, CallsMustSatisfyPartialOrderWhenSpecifiedSo) {
    function TEST (line 1615) | TEST(AfterTest, CallsMustSatisfyPartialOrderWhenSpecifiedSo2) {
    function TEST (line 1635) | TEST(AfterTest, CanBeUsedWithInSequence) {
    function TEST (line 1652) | TEST(AfterTest, CanBeCalledManyTimes) {
    function TEST (line 1666) | TEST(AfterTest, AcceptsUpToFiveArguments) {
    function TEST (line 1684) | TEST(AfterTest, AcceptsDuplicatedInput) {
    function TEST (line 1709) | TEST(AfterTest, ChangesToExpectationSetHaveNoEffectAfterwards) {
    function TEST (line 1725) | TEST(DeletingMockEarlyTest, Success1) {
    function TEST (line 1750) | TEST(DeletingMockEarlyTest, Success2) {
    function ACTION_P (line 1775) | ACTION_P(Delete, ptr) { delete ptr; }
    function TEST (line 1779) | TEST(DeletingMockEarlyTest, CanDeleteSelfInActionReturningVoid) {
    function TEST (line 1785) | TEST(DeletingMockEarlyTest, CanDeleteSelfInActionReturningValue) {
    function TEST (line 1792) | TEST(DeletingMockEarlyTest, Failure1) {
    function TEST (line 1812) | TEST(DeletingMockEarlyTest, Failure2) {
    class EvenNumberCardinality (line 1831) | class EvenNumberCardinality : public CardinalityInterface {
      method IsSatisfiedByCallCount (line 1835) | bool IsSatisfiedByCallCount(int call_count) const override {
      method IsSaturatedByCallCount (line 1841) | bool IsSaturatedByCallCount(int /* call_count */) const override {
      method DescribeTo (line 1846) | void DescribeTo(::std::ostream* os) const override {
    function Cardinality (line 1851) | Cardinality EvenNumber() { return Cardinality(new EvenNumberCardinalit...
    function TEST (line 1853) | TEST(ExpectationBaseTest,
    type Printable (line 1871) | struct Printable {}
    type Unprintable (line 1877) | struct Unprintable {
      method Unprintable (line 1878) | Unprintable() : value(0) {}
    class MockC (line 1882) | class MockC {
      method MockC (line 1884) | MockC() = default;
      method MockC (line 1891) | MockC(const MockC&) = delete;
      method MockC (line 1892) | MockC& operator=(const MockC&) = delete;
    class VerboseFlagPreservingFixture (line 1895) | class VerboseFlagPreservingFixture : public testing::Test {
      method VerboseFlagPreservingFixture (line 1897) | VerboseFlagPreservingFixture()
      method VerboseFlagPreservingFixture (line 1907) | VerboseFlagPreservingFixture(const VerboseFlagPreservingFixture&) = ...
      method VerboseFlagPreservingFixture (line 1908) | VerboseFlagPreservingFixture& operator=(const VerboseFlagPreservingF...
    function TEST (line 1917) | TEST(FunctionCallMessageTest,
    function TEST (line 1931) | TEST(FunctionCallMessageTest,
    function TEST (line 1962) | TEST(FunctionCallMessageTest,
    class GMockVerboseFlagTest (line 1993) | class GMockVerboseFlagTest : public VerboseFlagPreservingFixture {
      method VerifyOutput (line 1999) | void VerifyOutput(const std::string& output, bool should_print,
      method TestExpectedCall (line 2018) | void TestExpectedCall(bool should_print) {
      method TestUninterestingCallOnNaggyMock (line 2044) | void TestUninterestingCallOnNaggyMock(bool should_print) {
    function TEST_F (line 2080) | TEST_F(GMockVerboseFlagTest, Info) {
    function TEST_F (line 2088) | TEST_F(GMockVerboseFlagTest, Warning) {
    function TEST_F (line 2096) | TEST_F(GMockVerboseFlagTest, Error) {
    function TEST_F (line 2104) | TEST_F(GMockVerboseFlagTest, InvalidFlagIsTreatedAsWarning) {
    class PrintMeNot (line 2115) | class PrintMeNot {}
    function PrintTo (line 2117) | void PrintTo(PrintMeNot /* dummy */, ::std::ostream* /* os */) {
    class LogTestHelper (line 2122) | class LogTestHelper {
      method LogTestHelper (line 2124) | LogTestHelper() = default;
      method LogTestHelper (line 2129) | LogTestHelper(const LogTestHelper&) = delete;
      method LogTestHelper (line 2130) | LogTestHelper& operator=(const LogTestHelper&) = delete;
    class GMockLogTest (line 2133) | class GMockLogTest : public VerboseFlagPreservingFixture {
    function TEST_F (line 2138) | TEST_F(GMockLogTest, DoesNotPrintGoodCallInternallyIfVerbosityIsWarnin...
    function TEST_F (line 2144) | TEST_F(GMockLogTest, DoesNotPrintGoodCallInternallyIfVerbosityIsError) {
    function TEST_F (line 2150) | TEST_F(GMockLogTest, DoesNotPrintWarningInternallyIfVerbosityIsError) {
    function TEST (line 2158) | TEST(AllowLeakTest, AllowsLeakingUnusedMockObject) {
    function TEST (line 2163) | TEST(AllowLeakTest, CanBeCalledBeforeOnCall) {
    function TEST (line 2170) | TEST(AllowLeakTest, CanBeCalledAfterOnCall) {
    function TEST (line 2176) | TEST(AllowLeakTest, CanBeCalledBeforeExpectCall) {
    function TEST (line 2183) | TEST(AllowLeakTest, CanBeCalledAfterExpectCall) {
    function TEST (line 2189) | TEST(AllowLeakTest, WorksWhenBothOnCallAndExpectCallArePresent) {
    function TEST (line 2198) | TEST(VerifyAndClearExpectationsTest, NoMethodHasExpectations) {
    function TEST (line 2211) | TEST(VerifyAndClearExpectationsTest, SomeMethodsHaveExpectationsAndSuc...
    function TEST (line 2226) | TEST(VerifyAndClearExpectationsTest, SomeMethodsHaveExpectationsAndFai...
    function TEST (line 2242) | TEST(VerifyAndClearExpectationsTest, AllMethodsHaveExpectations) {
    function TEST (line 2258) | TEST(VerifyAndClearExpectationsTest, AMethodHasManyExpectations) {
    function TEST (line 2276) | TEST(VerifyAndClearExpectationsTest, CanCallManyTimes) {
    function TEST (line 2295) | TEST(VerifyAndClearTest, NoMethodHasDefaultActions) {
    function TEST (line 2304) | TEST(VerifyAndClearTest, SomeMethodsHaveDefaultActions) {
    function TEST (line 2316) | TEST(VerifyAndClearTest, AllMethodsHaveDefaultActions) {
    function TEST (line 2332) | TEST(VerifyAndClearTest, AMethodHasManyDefaultActions) {
    function TEST (line 2347) | TEST(VerifyAndClearTest, CanCallManyTimes) {
    function TEST (line 2361) | TEST(VerifyAndClearTest, Success) {
    function TEST (line 2377) | TEST(VerifyAndClearTest, Failure) {
    function TEST (line 2396) | TEST(VerifyAndClearTest, Const) {
    function TEST (line 2414) | TEST(VerifyAndClearTest, CanSetDefaultActionsAndExpectationsAfterwards) {
    function TEST (line 2431) | TEST(VerifyAndClearTest, DoesNotAffectOtherMockObjects) {
    function TEST (line 2457) | TEST(VerifyAndClearTest,
    function TEST (line 2477) | TEST(VerifyAndClearTest,
    function TEST (line 2501) | TEST(SynchronizationTest, CanCallMockMethodInAction) {
    function TEST (line 2519) | TEST(ParameterlessExpectationsTest, CanSetExpectationsWithoutMatchers) {
    function TEST (line 2539) | TEST(ParameterlessExpectationsTest, CanSetExpectationsForOverloadedMet...
    type MockWithConstMethods (line 2549) | struct MockWithConstMethods {
    function TEST (line 2555) | TEST(ParameterlessExpectationsTest, CanSetExpectationsForConstMethods) {
    class MockConstOverload (line 2564) | class MockConstOverload {
    function TEST (line 2570) | TEST(ParameterlessExpectationsTest,
  function main (line 2591) | int main(int argc, char** argv) {

FILE: googlemock/test/gmock_ex_test.cc
  class NonDefaultConstructible (line 45) | class NonDefaultConstructible {
    method NonDefaultConstructible (line 47) | explicit NonDefaultConstructible(int /* dummy */) {}
  class MockFoo (line 50) | class MockFoo {
  function TEST (line 57) | TEST(DefaultValueTest, ThrowsRuntimeErrorWhenNoDefaultValue) {

FILE: googlemock/test/gmock_leak_test.py
  class GMockLeakTest (line 52) | class GMockLeakTest(gmock_test_utils.TestCase):
    method testCatchesLeakedMockByDefault (line 54) | def testCatchesLeakedMockByDefault(self):
    method testDoesNotCatchLeakedMockWhenDisabled (line 65) | def testDoesNotCatchLeakedMockWhenDisabled(self):
    method testCatchesLeakedMockWhenEnabled (line 80) | def testCatchesLeakedMockWhenEnabled(self):
    method testCatchesLeakedMockWhenEnabledWithExplictFlagValue (line 94) | def testCatchesLeakedMockWhenEnabledWithExplictFlagValue(self):
    method testCatchesMultipleLeakedMocks (line 103) | def testCatchesMultipleLeakedMocks(self):

FILE: googlemock/test/gmock_leak_test_.cc
  class FooInterface (line 41) | class FooInterface {
  class MockFoo (line 47) | class MockFoo : public FooInterface {
    method MockFoo (line 49) | MockFoo() = default;
    method MockFoo (line 54) | MockFoo(const MockFoo&) = delete;
    method MockFoo (line 55) | MockFoo& operator=(const MockFoo&) = delete;
  function TEST (line 58) | TEST(LeakTest, LeakedMockWithExpectCallCausesFailureWhenLeakCheckingIsEn...
  function TEST (line 71) | TEST(LeakTest, LeakedMockWithOnCallCausesFailureWhenLeakCheckingIsEnable...
  function TEST (line 83) | TEST(LeakTest, CatchesMultipleLeakedMockObjects) {

FILE: googlemock/test/gmock_link_test.h
  function class (line 196) | class Interface {
  function class (line 210) | class Mock : public Interface {
  function class (line 229) | class InvokeHelper {
  function class (line 239) | class FieldHelper {
  function ACTION (line 439) | ACTION(Return1) { return 1; }
  function namespace (line 450) | namespace {
  function namespace (line 462) | namespace {

FILE: googlemock/test/gmock_output_test.py
  function ToUnixLineEnding (line 58) | def ToUnixLineEnding(s):
  function RemoveReportHeaderAndFooter (line 64) | def RemoveReportHeaderAndFooter(output):
  function RemoveLocations (line 75) | def RemoveLocations(output):
  function NormalizeErrorMarker (line 91) | def NormalizeErrorMarker(output):
  function RemoveMemoryAddresses (line 97) | def RemoveMemoryAddresses(output):
  function RemoveTestNamesOfLeakedMocks (line 103) | def RemoveTestNamesOfLeakedMocks(output):
  function GetLeakyTests (line 109) | def GetLeakyTests(output):
  function GetNormalizedOutputAndLeakyTests (line 118) | def GetNormalizedOutputAndLeakyTests(output):
  function GetShellCommandOutput (line 137) | def GetShellCommandOutput(cmd):
  function GetNormalizedCommandOutputAndLeakyTests (line 143) | def GetNormalizedCommandOutputAndLeakyTests(cmd):
  class GMockOutputTest (line 155) | class GMockOutputTest(gmock_test_utils.TestCase):
    method testOutput (line 157) | def testOutput(self):

FILE: googlemock/test/gmock_output_test_.cc
  class MockFoo (line 53) | class MockFoo {
    method MockFoo (line 55) | MockFoo() = default;
    method MockFoo (line 62) | MockFoo(const MockFoo&) = delete;
    method MockFoo (line 63) | MockFoo& operator=(const MockFoo&) = delete;
  class GMockOutputTest (line 66) | class GMockOutputTest : public testing::Test {
  function TEST_F (line 71) | TEST_F(GMockOutputTest, ExpectedCall) {
  function TEST_F (line 80) | TEST_F(GMockOutputTest, ExpectedCallToVoidFunction) {
  function TEST_F (line 89) | TEST_F(GMockOutputTest, ExplicitActionsRunOut) {
  function TEST_F (line 95) | TEST_F(GMockOutputTest, UnexpectedCall) {
  function TEST_F (line 102) | TEST_F(GMockOutputTest, UnexpectedCallToVoidFunction) {
  function TEST_F (line 109) | TEST_F(GMockOutputTest, ExcessiveCall) {
  function TEST_F (line 116) | TEST_F(GMockOutputTest, ExcessiveCallToVoidFunction) {
  function TEST_F (line 123) | TEST_F(GMockOutputTest, UninterestingCall) {
  function TEST_F (line 127) | TEST_F(GMockOutputTest, UninterestingCallToVoidFunction) {
  function TEST_F (line 131) | TEST_F(GMockOutputTest, RetiredExpectation) {
  function TEST_F (line 140) | TEST_F(GMockOutputTest, UnsatisfiedPrerequisite) {
  function TEST_F (line 154) | TEST_F(GMockOutputTest, UnsatisfiedPrerequisites) {
  function TEST_F (line 167) | TEST_F(GMockOutputTest, UnsatisfiedWith) {
  function TEST_F (line 171) | TEST_F(GMockOutputTest, UnsatisfiedExpectation) {
  function TEST_F (line 178) | TEST_F(GMockOutputTest, MismatchArguments) {
  function TEST_F (line 186) | TEST_F(GMockOutputTest, MismatchWith) {
  function TEST_F (line 193) | TEST_F(GMockOutputTest, MismatchArgumentsAndWith) {
  function TEST_F (line 200) | TEST_F(GMockOutputTest, UnexpectedCallWithDefaultAction) {
  function TEST_F (line 210) | TEST_F(GMockOutputTest, ExcessiveCallWithDefaultAction) {
  function TEST_F (line 223) | TEST_F(GMockOutputTest, UninterestingCallWithDefaultAction) {
  function TEST_F (line 231) | TEST_F(GMockOutputTest, ExplicitActionsRunOutWithDefaultAction) {
  function TEST_F (line 239) | TEST_F(GMockOutputTest, CatchesLeakedMocks) {
  function TEST_F (line 260) | TEST_F(GMockOutputTest, PrintsMatcher) {
  function TestCatchesLeakedMocksInAdHocTests (line 265) | void TestCatchesLeakedMocksInAdHocTests() {
  function main (line 275) | int main(int argc, char** argv) {

FILE: googlemock/test/gmock_stress_test.cc
  type testing (line 36) | namespace testing {
    class MockFoo (line 49) | class MockFoo {
    function JoinAndDelete (line 57) | void JoinAndDelete(ThreadWithParam<T>* t) {
    type Dummy (line 62) | struct Dummy {}
    function TestConcurrentMockObjects (line 66) | void TestConcurrentMockObjects(Dummy /* dummy */) {
    type Helper1Param (line 88) | struct Helper1Param {
    function Helper1 (line 93) | void Helper1(Helper1Param param) {
    function TestConcurrentCallsOnSameObject (line 113) | void TestConcurrentCallsOnSameObject(Dummy /* dummy */) {
    function Helper2 (line 141) | void Helper2(MockFoo* foo) {
    function TestPartiallyOrderedExpectationsWithThreads (line 149) | void TestPartiallyOrderedExpectationsWithThreads(Dummy /* dummy */) {
    function TEST (line 184) | TEST(StressTest, CanUseGMockWithThreads) {
  function main (line 219) | int main(int argc, char** argv) {

FILE: googlemock/test/gmock_test.cc
  function TestInitGoogleMock (line 48) | void TestInitGoogleMock(const Char* (&argv)[M], const Char* (&new_argv)[N],
  function TEST (line 64) | TEST(InitGoogleMockTest, ParsesInvalidCommandLine) {
  function TEST (line 72) | TEST(InitGoogleMockTest, ParsesEmptyCommandLine) {
  function TEST (line 80) | TEST(InitGoogleMockTest, ParsesSingleFlag) {
  function TEST (line 88) | TEST(InitGoogleMockTest, ParsesMultipleFlags) {
  function TEST (line 101) | TEST(InitGoogleMockTest, ParsesUnrecognizedFlag) {
  function TEST (line 109) | TEST(InitGoogleMockTest, ParsesGoogleMockFlagAndUnrecognizedFlag) {
  function TEST (line 118) | TEST(WideInitGoogleMockTest, ParsesInvalidCommandLine) {
  function TEST (line 126) | TEST(WideInitGoogleMockTest, ParsesEmptyCommandLine) {
  function TEST (line 134) | TEST(WideInitGoogleMockTest, ParsesSingleFlag) {
  function TEST (line 142) | TEST(WideInitGoogleMockTest, ParsesMultipleFlags) {
  function TEST (line 155) | TEST(WideInitGoogleMockTest, ParsesUnrecognizedFlag) {
  function TEST (line 163) | TEST(WideInitGoogleMockTest, ParsesGoogleMockFlagAndUnrecognizedFlag) {
  function TEST (line 175) | TEST(FlagTest, IsAccessibleInCode) {

FILE: googlemock/test/gmock_test_utils.py
  function GetSourceDir (line 38) | def GetSourceDir():
  function GetTestExecutablePath (line 44) | def GetTestExecutablePath(executable_name):
  function GetExitStatus (line 60) | def GetExitStatus(exit_code):
  function Main (line 88) | def Main():

FILE: googletest/include/gtest/gtest-assertion-result.h
  function namespace (line 52) | namespace testing {

FILE: googletest/include/gtest/gtest-death-test.h
  function namespace (line 52) | namespace testing {

FILE: googletest/include/gtest/gtest-matchers.h
  function namespace (line 66) | namespace testing {
  function DescribeImpl (line 348) | void DescribeImpl(const MatcherBase& m, std::ostream* os,
  function MatcherDescriberInterface (line 358) | const MatcherDescriberInterface* GetDescriberImpl(
  function VTable (line 374) | VTable* GetVTable() {
  function Destroy (line 390) | void Destroy() {
  function IsInlined (line 397) | constexpr bool IsInlined() {
  function M (line 405) | static const M& Get(const MatcherBase& m) {
  function Init (line 412) | static void Init(MatcherBase& m, M impl) {
  function M (line 421) | static const M& Get(const MatcherBase& m) {
  function M (line 435) | static const M& Get(const MatcherBase& m) {
  function Init (line 438) | static void Init(MatcherBase& m, M* impl) {
  function explicit (line 509) | explicit Matcher(const MatcherInterface<const std::string&>* impl)
  function explicit (line 533) | explicit Matcher(const MatcherInterface<std::string>* impl)
  function explicit (line 559) | explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
  function explicit (line 587) | explicit Matcher(const MatcherInterface<internal::StringView>* impl)
  function DescribeTo (line 650) | void DescribeTo(::std::ostream* os) const override { impl_.DescribeTo(os...
  function DescribeNegationTo (line 652) | void DescribeNegationTo(::std::ostream* os) const override {
  function MatchAndExplain (line 656) | bool MatchAndExplain(T x, MatchResultListener* listener) const override {
  function namespace (line 690) | namespace internal {
  function DescribeTo (line 859) | void DescribeTo(::std::ostream* os) const {
  function DescribeNegationTo (line 864) | void DescribeNegationTo(::std::ostream* os) const {
  function PolymorphicMatcher (line 878) | inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
  function PolymorphicMatcher (line 890) | inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(

FILE: googletest/include/gtest/gtest-message.h
  function namespace (line 73) | namespace testing {
  function namespace (line 235) | namespace internal {

FILE: googletest/include/gtest/gtest-param-test.h
  function class (line 157) | class BaseTest : public ::testing::Test {
  function namespace (line 185) | namespace testing {
  function internal (line 360) | inline internal::ParamGenerator<bool> Bool() { return Values(false, true...

FILE: googletest/include/gtest/gtest-printers.h
  function namespace (line 137) | namespace testing {
  function else (line 204) | struct FunctionPointerPrinter {
  function else (line 219) | struct PointerPrinter {
  function namespace (line 233) | namespace internal_stream_operator_without_lexical_name_lookup {
  type ConvertibleToIntegerPrinter (line 280) | struct ConvertibleToIntegerPrinter {
  type ConvertibleToStringViewPrinter (line 293) | struct ConvertibleToStringViewPrinter {
  type ConvertibleToAbslStringifyPrinter (line 302) | struct ConvertibleToAbslStringifyPrinter {
  type RawBytesPrinter (line 316) | struct RawBytesPrinter {
  type FallbackPrinter (line 328) | struct FallbackPrinter {
  function ostream (line 356) | ostream* os) {
  function string (line 467) | string FormatForComparisonFailureMessage(const T1& value,
  function ostream (line 494) | ostream* os) {
  function PrintTo (line 505) | inline void PrintTo(char c, ::std::ostream* os) {
  function PrintTo (line 513) | inline void PrintTo(bool x, ::std::ostream* os) {
  function PrintTo (line 527) | inline void PrintTo(char16_t c, ::std::ostream* os) {
  function PrintTo (line 533) | inline void PrintTo(char8_t c, ::std::ostream* os) {
  function PrintTo (line 627) | inline void PrintTo(float f, ::std::ostream* os) {
  function PrintTo (line 634) | inline void PrintTo(double d, ::std::ostream* os) {
  function PrintTo (line 643) | inline void PrintTo(char* s, ::std::ostream* os) {
  function PrintTo (line 649) | inline void PrintTo(const signed char* s, ::std::ostream* os) {
  function PrintTo (line 652) | inline void PrintTo(signed char* s, ::std::ostream* os) {
  function PrintTo (line 655) | inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
  function PrintTo (line 658) | inline void PrintTo(unsigned char* s, ::std::ostream* os) {
  function PrintTo (line 664) | inline void PrintTo(char8_t* s, ::std::ostream* os) {
  function PrintTo (line 670) | inline void PrintTo(char16_t* s, ::std::ostream* os) {
  function PrintTo (line 675) | inline void PrintTo(char32_t* s, ::std::ostream* os) {
  function PrintTo (line 687) | inline void PrintTo(wchar_t* s, ::std::ostream* os) {
  function PrintTo (line 708) | inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
  function PrintTo (line 711) | inline void PrintTo(::std::string_view s, ::std::ostream* os) {
  function PrintTo (line 718) | inline void PrintTo(const ::std::u8string& s, ::std::ostream* os) {
  function PrintTo (line 721) | inline void PrintTo(::std::u8string_view s, ::std::ostream* os) {
  function PrintTo (line 728) | inline void PrintTo(const ::std::u16string& s, ::std::ostream* os) {
  function PrintTo (line 731) | inline void PrintTo(::std::u16string_view s, ::std::ostream* os) {
  function PrintTo (line 737) | inline void PrintTo(const ::std::u32string& s, ::std::ostream* os) {
  function PrintTo (line 740) | inline void PrintTo(::std::u32string_view s, ::std::ostream* os) {
  function PrintTo (line 747) | inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
  function PrintTo (line 750) | inline void PrintTo(::std::wstring_view s, ::std::ostream* os) {
  function PrintTo (line 761) | void PrintTo(internal::StringView sp, ::std::ostream* os) {
  function PrintTo (line 766) | inline void PrintTo(std::nullptr_t, ::std::ostream* os) { *os << "(nullp...
  function PrintTo (line 769) | inline void PrintTo(const std::type_info& info, std::ostream* os) {
  function PrintTo (line 830) | inline void PrintTo(std::strong_ordering ordering, std::ostream* os) {
  function PrintTo (line 838) | inline void PrintTo(std::partial_ordering ordering, std::ostream* os) {
  function PrintTo (line 846) | inline void PrintTo(std::weak_ordering ordering, std::ostream* os) {
  function ostream (line 859) | ostream* os) {
  function Print (line 901) | static void Print(const T& value, ::std::ostream* os) {
  function Print (line 1051) | static void Print(const T& value, ::std::ostream* os) {
  function ostream (line 1180) | ostream* os) {
  function ostream (line 1189) | ostream* os) {
  type std (line 1196) | typedef ::std::vector<::std::string> Strings;
  function string (line 1229) | string PrintToString(const T& value) {

FILE: googletest/include/gtest/gtest-spi.h
  function namespace (line 43) | namespace testing {

FILE: googletest/include/gtest/gtest-test-part.h
  function namespace (line 49) | namespace testing {
  function class (line 135) | class GTEST_API_ [[nodiscard]] TestPartResultArray {
  function class (line 156) | class GTEST_API_ [[nodiscard]] TestPartResultReporterInterface {
  function namespace (line 163) | namespace internal {

FILE: googletest/include/gtest/gtest.h
  function namespace (line 165) | namespace testing {
  function class (line 1402) | class [[nodiscard]] EqHelper {
  type AssertHelperData (line 1637) | struct AssertHelperData {
  function ParamType (line 1702) | [[nodiscard]] static const ParamType& GetParam() {
  function class (line 2078) | class GTEST_API_ [[nodiscard]] ScopedTrace {
  function StaticAssertTypeEq (line 2162) | bool StaticAssertTypeEq() noexcept {
  function class (line 2311) | class FactoryImpl : public internal::TestFactoryBase {
  function RUN_ALL_TESTS (line 2341) | inline int RUN_ALL_TESTS() { return ::testing::UnitTest::GetInstance()->...

FILE: googletest/include/gtest/gtest_pred_impl.h
  function namespace (line 43) | namespace testing {

FILE: googletest/include/gtest/internal/gtest-death-test-internal.h
  function namespace (line 53) | namespace testing {

FILE: googletest/include/gtest/internal/gtest-filepath.h
  function pathname_ (line 73) | FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) {}
  function explicit (line 76) | explicit FilePath(std::string pathname) : pathname_(std::move(pathname)) {
  function Set (line 89) | void Set(const FilePath& rhs) { pathname_ = rhs.pathname_; }

FILE: googletest/include/gtest/internal/gtest-internal.h
  function namespace (line 97) | namespace proto2 {
  function namespace (line 101) | namespace testing {
  type typename (line 768) | typedef typename Tests::Head Head;
  function AlwaysFalse (line 816) | inline bool AlwaysFalse() { return !AlwaysTrue(); }
  function ConstCharPtr (line 821) | struct GTEST_API_ ConstCharPtr {
  type TrueWithString (line 829) | struct TrueWithString {
  function class (line 842) | class GTEST_API_ [[nodiscard]] Random {
  type IsContainer (line 914) | typedef int IsContainer;
  type IsNotContainer (line 925) | typedef char IsNotContainer;
  function IsContainerTest (line 927) | IsContainerTest(long /* dummy */) {
  function ArrayEq (line 992) | bool ArrayEq(const T& lhs, const U& rhs) {
  function ArrayEq (line 998) | bool ArrayEq(const T (&lhs)[N], const U (&rhs)[N]) {
  function CopyArray (line 1032) | void CopyArray(const T& from, U* to) {
  function CopyArray (line 1038) | void CopyArray(const T (&from)[N], U (*to)[N]) {
  type RelationToSourceReference (line 1056) | struct RelationToSourceReference {}
  type RelationToSourceCopy (line 1057) | struct RelationToSourceCopy {}
  type Element (line 1072) | typedef Element* iterator;
  type Element (line 1073) | typedef const Element* const_iterator;
  function InitCopy (line 1108) | void InitCopy(const Element* array, size_t a_size) {
  function InitRef (line 1117) | void InitRef(const Element* array, size_t a_size) {
  type FlatTupleConstructTag (line 1151) | struct FlatTupleConstructTag {}
  function InstantiateTestCase_P_IsDeprecated (line 1232) | [[deprecated(
  function TypedTestCase_P_IsDeprecated (line 1239) | [[deprecated(
  function TypedTestCaseIsDeprecated (line 1246) | [[deprecated(
  function RegisterTypedTestCase_P_IsDeprecated (line 1253) | [[deprecated(
  function InstantiateTypedTestCase_P_IsDeprecated (line 1260) | [[deprecated(
  function namespace (line 1270) | namespace std {
  function namespace (line 1318) | namespace testing {

FILE: googletest/include/gtest/internal/gtest-param-util.h
  type PrintToStringParamName (line 73) | struct PrintToStringParamName {
  type T (line 133) | typedef const T& reference;
  type difference_type (line 134) | typedef ptrdiff_t difference_type;
  function impl_ (line 137) | ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {}

FILE: googletest/include/gtest/internal/gtest-port.h
  type GTEST_CRITICAL_SECTION (line 392) | typedef struct _CRITICAL_SECTION GTEST_CRITICAL_SECTION;
  type GTEST_CRITICAL_SECTION (line 397) | typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
  function namespace (line 915) | namespace testing {
  function To (line 1147) | To ImplicitCast_(To x) {
  function class (line 1205) | class GTEST_API_ [[nodiscard]] AutoHandle {
  function class (line 1288) | class [[nodiscard]] ThreadWithParamBase {
  function Join (line 1335) | void Join() {
  function Run (line 1342) | void Run() override {
  function class (line 1384) | class GTEST_API_ [[nodiscard]] Mutex {
  function class (line 1437) | class [[nodiscard]] GTestMutexLock {
  type GTestMutexLock (line 1449) | typedef GTestMutexLock MutexLock;
  function class (line 1453) | class [[nodiscard]] ThreadLocalValueHolderBase {
  function class (line 1460) | class [[nodiscard]] ThreadLocalBase {
  function class (line 1480) | class GTEST_API_ [[nodiscard]] ThreadLocalRegistry {
  function class (line 1492) | class GTEST_API_ [[nodiscard]] ThreadWithParamBase {
  function Run (line 1525) | void Run() override { func_(param_); }
  function explicit (line 1570) | explicit ThreadLocal(const T& value)
  function T (line 1575) | T* pointer() { return GetOrCreateValue(); }
  function T (line 1576) | const T* pointer() const { return GetOrCreateValue(); }
  function set (line 1578) | void set(const T& value) { *pointer() = value; }
  function explicit (line 1586) | explicit ValueHolder(const T& value) : value_(value) {}
  function T (line 1588) | T* pointer() { return &value_; }
  function T (line 1596) | T* GetOrCreateValue() const {
  function ThreadLocalValueHolderBase (line 1602) | ThreadLocalValueHolderBase* NewValueForCurrentThread() const override {
  function class (line 1606) | class ValueHolderFactory {
  function class (line 1617) | class DefaultValueHolderFactory : public ValueHolderFactory {
  function class (line 1628) | class InstanceValueHolderFactory : public ValueHolderFactory {
  function class (line 1652) | class [[nodiscard]] MutexBase {
  function class (line 1710) | class [[nodiscard]] Mutex : public MutexBase {
  function class (line 1728) | class [[nodiscard]] GTestMutexLock {
  type GTestMutexLock (line 1740) | typedef GTestMutexLock MutexLock;
  function class (line 1748) | class GTEST_API_ [[nodiscard]] ThreadLocalValueHolderBase {
  function DeleteThreadLocalValue (line 1755) | inline void DeleteThreadLocalValue(void* value_holder) {
  function GTEST_API_ (line 1761) | GTEST_API_ [[nodiscard]] ThreadLocal {
  function set (line 1781) | void set(const T& value) { *pointer() = value; }
  function explicit (line 1788) | explicit ValueHolder(const T& value) : value_(value) {}
  function T (line 1790) | T* pointer() { return &value_; }
  function pthread_key_t (line 1798) | static pthread_key_t CreateKey() {
  function T (line 1807) | T* GetOrCreateValue() const {
  function class (line 1820) | class ValueHolderFactory {
  function class (line 1831) | class DefaultValueHolderFactory : public ValueHolderFactory {
  function class (line 1842) | class InstanceValueHolderFactory : public ValueHolderFactory {
  function class (line 1874) | class [[nodiscard]] Mutex {
  function class (line 1892) | class [[nodiscard]] GTestMutexLock {
  type GTestMutexLock (line 1897) | typedef GTestMutexLock MutexLock;
  function GTEST_API_ (line 1900) | GTEST_API_ [[nodiscard]] ThreadLocal {
  function IsAlpha (line 1934) | inline bool IsAlpha(char ch) {
  function IsAlNum (line 1937) | inline bool IsAlNum(char ch) {
  function IsDigit (line 1940) | inline bool IsDigit(char ch) {
  function IsLower (line 1943) | inline bool IsLower(char ch) {
  function IsSpace (line 1946) | inline bool IsSpace(char ch) {
  function IsUpper (line 1949) | inline bool IsUpper(char ch) {
  function IsXDigit (line 1952) | inline bool IsXDigit(char ch) {
  function IsXDigit (line 1956) | inline bool IsXDigit(char8_t ch) {
  function IsXDigit (line 1960) | inline bool IsXDigit(char16_t ch) {
  function IsXDigit (line 1964) | inline bool IsXDigit(char32_t ch) {
  function IsXDigit (line 1968) | inline bool IsXDigit(wchar_t ch) {
  function ToLower (line 1973) | inline char ToLower(char ch) {
  function ToUpper (line 1976) | inline char ToUpper(char ch) {
  function std (line 1980) | inline std::string StripTrailingSpaces(std::string str) {
  function namespace (line 1992) | namespace posix {
  function namespace (line 2356) | namespace testing {
  function namespace (line 2369) | namespace testing {

FILE: googletest/include/gtest/internal/gtest-string.h
  function namespace (line 59) | namespace testing {

FILE: googletest/include/gtest/internal/gtest-type-util.h
  function namespace (line 54) | namespace testing {

FILE: googletest/samples/prime_tables.h
  function class (line 40) | class PrimeTable {
  function class (line 53) | class OnTheFlyPrimeTable : public PrimeTable {
  function class (line 77) | class PreCalculatedPrimeTable : public PrimeTable {
  function IsPrime (line 87) | bool IsPrime(int n) const override {
  function GetNextPrime (line 91) | int GetNextPrime(int p) const override {

FILE: googletest/samples/sample1.cc
  function Factorial (line 35) | int Factorial(int n) {
  function IsPrime (line 45) | bool IsPrime(int n) {

FILE: googletest/samples/sample10_unittest.cc
  class Water (line 45) | class Water {
    method allocated (line 60) | static int allocated() { return allocated_; }
  class LeakChecker (line 72) | class LeakChecker : public EmptyTestEventListener {
    method OnTestStart (line 75) | void OnTestStart(const TestInfo& /* test_info */) override {
    method OnTestEnd (line 80) | void OnTestEnd(const TestInfo& /* test_info */) override {
  function TEST (line 92) | TEST(ListenersTest, DoesNotLeak) {
  function TEST (line 99) | TEST(ListenersTest, LeaksWater) {
  function main (line 105) | int main(int argc, char** argv) {

FILE: googletest/samples/sample1_unittest.cc
  function TEST (line 76) | TEST(FactorialTest, Negative) {
  function TEST (line 100) | TEST(FactorialTest, Zero) { EXPECT_EQ(1, Factorial(0)); }
  function TEST (line 103) | TEST(FactorialTest, Positive) {
  function TEST (line 113) | TEST(IsPrimeTest, Negative) {
  function TEST (line 122) | TEST(IsPrimeTest, Trivial) {
  function TEST (line 130) | TEST(IsPrimeTest, Positive) {

FILE: googletest/samples/sample2.h
  function class (line 38) | class MyString {

FILE: googletest/samples/sample2_unittest.cc
  function TEST (line 47) | TEST(MyString, DefaultConstructor) {
  function TEST (line 78) | TEST(MyString, ConstructorFromCString) {
  function TEST (line 85) | TEST(MyString, CopyConstructor) {
  function TEST (line 92) | TEST(MyString, Set) {

FILE: googletest/samples/sample3-inl.h
  function QueueNode (line 54) | QueueNode* next() { return next_; }
  function QueueNode (line 55) | const QueueNode* next() const { return next_; }
  function Clear (line 81) | void Clear() {
  function QueueNode (line 104) | const QueueNode<E>* Head() const { return head_; }
  function QueueNode (line 108) | const QueueNode<E>* Last() const { return last_; }
  function Enqueue (line 114) | void Enqueue(const E& element) {
  function E (line 129) | E* Dequeue() {

FILE: googletest/samples/sample3_unittest.cc
  class QueueTestSmpl3 (line 67) | class QueueTestSmpl3 : public testing::Test {
    method SetUp (line 73) | void SetUp() override {
    method Double (line 87) | static int Double(int n) { return 2 * n; }
    method MapTester (line 90) | void MapTester(const Queue<int>* q) {
  function TEST_F (line 117) | TEST_F(QueueTestSmpl3, DefaultConstructor) {
  function TEST_F (line 123) | TEST_F(QueueTestSmpl3, Dequeue) {
  function TEST_F (line 141) | TEST_F(QueueTestSmpl3, Map) {

FILE: googletest/samples/sample4.h
  function class (line 35) | class Counter {

FILE: googletest/samples/sample4_unittest.cc
  function TEST (line 37) | TEST(Counter, Increment) {

FILE: googletest/samples/sample5_unittest.cc
  class QuickTest (line 62) | class QuickTest : public testing::Test {
    method SetUp (line 66) | void SetUp() override { start_time_ = time(nullptr); }
    method TearDown (line 70) | void TearDown() override {
  class IntegerFunctionTest (line 87) | class IntegerFunctionTest : public QuickTest {
  function TEST_F (line 95) | TEST_F(IntegerFunctionTest, Factorial) {
  function TEST_F (line 112) | TEST_F(IntegerFunctionTest, IsPrime) {
  class QueueTest (line 137) | class QueueTest : public QuickTest {
    method SetUp (line 139) | void SetUp() override {
  function TEST_F (line 165) | TEST_F(QueueTest, DefaultConstructor) { EXPECT_EQ(0u, q0_.Size()); }
  function TEST_F (line 168) | TEST_F(QueueTest, Dequeue) {

FILE: googletest/samples/sample6_unittest.cc
  function PrimeTable (line 45) | PrimeTable* CreatePrimeTable<OnTheFlyPrimeTable>() {
  function PrimeTable (line 50) | PrimeTable* CreatePrimeTable<PreCalculatedPrimeTable>() {
  class PrimeTableTest (line 56) | class PrimeTableTest : public testing::Test {
    method PrimeTableTest (line 60) | PrimeTableTest() : table_(CreatePrimeTable<T>()) {}
  function TYPED_TEST (line 95) | TYPED_TEST(PrimeTableTest, ReturnsFalseForNonPrimes) {
  function TYPED_TEST (line 111) | TYPED_TEST(PrimeTableTest, ReturnsTrueForPrimes) {
  function TYPED_TEST (line 120) | TYPED_TEST(PrimeTableTest, CanGetNextPrime) {
  class PrimeTableTest2 (line 152) | class PrimeTableTest2 : public PrimeTableTest<T> {}
  function TYPED_TEST_P (line 161) | TYPED_TEST_P(PrimeTableTest2, ReturnsFalseForNonPrimes) {
  function TYPED_TEST_P (line 170) | TYPED_TEST_P(PrimeTableTest2, ReturnsTrueForPrimes) {
  function TYPED_TEST_P (line 179) | TYPED_TEST_P(PrimeTableTest2, CanGetNextPrime) {

FILE: googletest/samples/sample7_unittest.cc
  function PrimeTable (line 51) | PrimeTable* CreateOnTheFlyPrimeTable() { return new OnTheFlyPrimeTable(); }
  function PrimeTable (line 54) | PrimeTable* CreatePreCalculatedPrimeTable() {
  class PrimeTableTestSmpl7 (line 62) | class PrimeTableTestSmpl7 : public TestWithParam<CreatePrimeTableFunc*> {
    method SetUp (line 65) | void SetUp() override { table_ = (*GetParam())(); }
    method TearDown (line 66) | void TearDown() override {
  function TEST_P (line 75) | TEST_P(PrimeTableTestSmpl7, ReturnsFalseForNonPrimes) {
  function TEST_P (line 84) | TEST_P(PrimeTableTestSmpl7, ReturnsTrueForPrimes) {
  function TEST_P (line 93) | TEST_P(PrimeTableTestSmpl7, CanGetNextPrime) {

FILE: googletest/samples/sample8_unittest.cc
  class HybridPrimeTable (line 48) | class HybridPrimeTable : public PrimeTable {
    method HybridPrimeTable (line 50) | HybridPrimeTable(bool force_on_the_fly, int max_precalculated)
    method IsPrime (line 61) | bool IsPrime(int n) const override {
    method GetNextPrime (line 68) | int GetNextPrime(int p) const override {
  class PrimeTableTest (line 92) | class PrimeTableTest : public TestWithParam< ::std::tuple<bool, int> > {
    method SetUp (line 94) | void SetUp() override {
    method TearDown (line 100) | void TearDown() override {
  function TEST_P (line 107) | TEST_P(PrimeTableTest, ReturnsFalseForNonPrimes) {
  function TEST_P (line 122) | TEST_P(PrimeTableTest, ReturnsTrueForPrimes) {
  function TEST_P (line 131) | TEST_P(PrimeTableTest, CanGetNextPrime) {

FILE: googletest/samples/sample9_unittest.cc
  class TersePrinter (line 47) | class TersePrinter : public EmptyTestEventListener {
    method OnTestProgramStart (line 50) | void OnTestProgramStart(const UnitTest& /* unit_test */) override {}
    method OnTestProgramEnd (line 53) | void OnTestProgramEnd(const UnitTest& unit_test) override {
    method OnTestStart (line 59) | void OnTestStart(const TestInfo& test_info) override {
    method OnTestPartResult (line 66) | void OnTestPartResult(const TestPartResult& test_part_result) override {
    method OnTestEnd (line 75) | void OnTestEnd(const TestInfo& test_info) override {
  function TEST (line 82) | TEST(CustomOutputTest, PrintsMessage) {
  function TEST (line 86) | TEST(CustomOutputTest, Succeeds) {
  function TEST (line 90) | TEST(CustomOutputTest, Fails) {
  function main (line 96) | int main(int argc, char** argv) {

FILE: googletest/src/gtest-assertion-result.cc
  type testing (line 41) | namespace testing {
    function AssertionResult (line 59) | AssertionResult AssertionResult::operator!() const {
    function AssertionResult (line 66) | AssertionResult AssertionSuccess() { return AssertionResult(true); }
    function AssertionResult (line 69) | AssertionResult AssertionFailure() { return AssertionResult(false); }
    function AssertionResult (line 73) | AssertionResult AssertionFailure(const Message& message) {

FILE: googletest/src/gtest-death-test.cc
  type testing (line 94) | namespace testing {
    type internal (line 142) | namespace internal {
      function InDeathTestChild (line 155) | bool InDeathTestChild() {
      function ExitSummary (line 213) | static std::string ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 239) | bool ExitedUnsuccessfully(int exit_status) {
      function DeathTestThreadWarning (line 248) | static std::string DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 286) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 293) | [[noreturn]] static void DeathTestAbort(const std::string& message) {
      function GetLastErrnoDescription (line 346) | std::string GetLastErrnoDescription() {
      function FailFromInternalError (line 354) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 406) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 408) | DeathTestImpl(const char* a_statement, Matcher<const std::string&>...
        method spawned (line 424) | bool spawned() const { return spawned_; }
        method set_spawned (line 425) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 426) | int status() const { return status_; }
        method set_status (line 427) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 428) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 429) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 430) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 431) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 432) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 433) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 540) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      function CreateArgvFromArgs (line 633) | static std::vector<char*> CreateArgvFromArgs(std::vector<std::string...
      class WindowsDeathTest (line 673) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 675) | WindowsDeathTest(const char* a_statement, Matcher<const std::strin...
      class FuchsiaDeathTest (line 833) | class FuchsiaDeathTest : public DeathTestImpl {
        method FuchsiaDeathTest (line 835) | FuchsiaDeathTest(const char* a_statement, Matcher<const std::strin...
      class ForkingDeathTest (line 1056) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 1064) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 1092) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 1094) | NoExecDeathTest(const char* a_statement, Matcher<const std::string...
      class ExecDeathTest (line 1147) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 1149) | ExecDeathTest(const char* a_statement, Matcher<const std::string&>...
        method GetArgvsForDeathTestChildProcess (line 1157) | static ::std::vector<std::string> GetArgvsForDeathTestChildProcess...
      type ExecDeathTestArgs (line 1174) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 1185) | static int ExecDeathTestChildMain(void* child_arg) {
      function GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ (line 1231) | GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
      function GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ (line 1239) | GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
      function pid_t (line 1256) | static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
    type internal (line 207) | namespace internal {
      function InDeathTestChild (line 155) | bool InDeathTestChild() {
      function ExitSummary (line 213) | static std::string ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 239) | bool ExitedUnsuccessfully(int exit_status) {
      function DeathTestThreadWarning (line 248) | static std::string DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 286) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 293) | [[noreturn]] static void DeathTestAbort(const std::string& message) {
      function GetLastErrnoDescription (line 346) | std::string GetLastErrnoDescription() {
      function FailFromInternalError (line 354) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 406) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 408) | DeathTestImpl(const char* a_statement, Matcher<const std::string&>...
        method spawned (line 424) | bool spawned() const { return spawned_; }
        method set_spawned (line 425) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 426) | int status() const { return status_; }
        method set_status (line 427) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 428) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 429) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 430) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 431) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 432) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 433) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 540) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      function CreateArgvFromArgs (line 633) | static std::vector<char*> CreateArgvFromArgs(std::vector<std::string...
      class WindowsDeathTest (line 673) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 675) | WindowsDeathTest(const char* a_statement, Matcher<const std::strin...
      class FuchsiaDeathTest (line 833) | class FuchsiaDeathTest : public DeathTestImpl {
        method FuchsiaDeathTest (line 835) | FuchsiaDeathTest(const char* a_statement, Matcher<const std::strin...
      class ForkingDeathTest (line 1056) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 1064) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 1092) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 1094) | NoExecDeathTest(const char* a_statement, Matcher<const std::string...
      class ExecDeathTest (line 1147) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 1149) | ExecDeathTest(const char* a_statement, Matcher<const std::string&>...
        method GetArgvsForDeathTestChildProcess (line 1157) | static ::std::vector<std::string> GetArgvsForDeathTestChildProcess...
      type ExecDeathTestArgs (line 1174) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 1185) | static int ExecDeathTestChildMain(void* child_arg) {
      function GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ (line 1231) | GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
      function GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ (line 1239) | GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
      function pid_t (line 1256) | static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
    function GetStatusFileDescriptor (line 1471) | static int GetStatusFileDescriptor(unsigned int parent_process_id,
    function InternalRunDeathTestFlag (line 1533) | InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
  type testing (line 138) | namespace testing {
    type internal (line 142) | namespace internal {
      function InDeathTestChild (line 155) | bool InDeathTestChild() {
      function ExitSummary (line 213) | static std::string ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 239) | bool ExitedUnsuccessfully(int exit_status) {
      function DeathTestThreadWarning (line 248) | static std::string DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 286) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 293) | [[noreturn]] static void DeathTestAbort(const std::string& message) {
      function GetLastErrnoDescription (line 346) | std::string GetLastErrnoDescription() {
      function FailFromInternalError (line 354) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 406) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 408) | DeathTestImpl(const char* a_statement, Matcher<const std::string&>...
        method spawned (line 424) | bool spawned() const { return spawned_; }
        method set_spawned (line 425) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 426) | int status() const { return status_; }
        method set_status (line 427) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 428) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 429) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 430) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 431) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 432) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 433) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 540) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      function CreateArgvFromArgs (line 633) | static std::vector<char*> CreateArgvFromArgs(std::vector<std::string...
      class WindowsDeathTest (line 673) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 675) | WindowsDeathTest(const char* a_statement, Matcher<const std::strin...
      class FuchsiaDeathTest (line 833) | class FuchsiaDeathTest : public DeathTestImpl {
        method FuchsiaDeathTest (line 835) | FuchsiaDeathTest(const char* a_statement, Matcher<const std::strin...
      class ForkingDeathTest (line 1056) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 1064) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 1092) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 1094) | NoExecDeathTest(const char* a_statement, Matcher<const std::string...
      class ExecDeathTest (line 1147) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 1149) | ExecDeathTest(const char* a_statement, Matcher<const std::string&>...
        method GetArgvsForDeathTestChildProcess (line 1157) | static ::std::vector<std::string> GetArgvsForDeathTestChildProcess...
      type ExecDeathTestArgs (line 1174) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 1185) | static int ExecDeathTestChildMain(void* child_arg) {
      function GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ (line 1231) | GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
      function GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ (line 1239) | GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
      function pid_t (line 1256) | static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
    type internal (line 207) | namespace internal {
      function InDeathTestChild (line 155) | bool InDeathTestChild() {
      function ExitSummary (line 213) | static std::string ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 239) | bool ExitedUnsuccessfully(int exit_status) {
      function DeathTestThreadWarning (line 248) | static std::string DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 286) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 293) | [[noreturn]] static void DeathTestAbort(const std::string& message) {
      function GetLastErrnoDescription (line 346) | std::string GetLastErrnoDescription() {
      function FailFromInternalError (line 354) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 406) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 408) | DeathTestImpl(const char* a_statement, Matcher<const std::string&>...
        method spawned (line 424) | bool spawned() const { return spawned_; }
        method set_spawned (line 425) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 426) | int status() const { return status_; }
        method set_status (line 427) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 428) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 429) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 430) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 431) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 432) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 433) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 540) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      function CreateArgvFromArgs (line 633) | static std::vector<char*> CreateArgvFromArgs(std::vector<std::string...
      class WindowsDeathTest (line 673) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 675) | WindowsDeathTest(const char* a_statement, Matcher<const std::strin...
      class FuchsiaDeathTest (line 833) | class FuchsiaDeathTest : public DeathTestImpl {
        method FuchsiaDeathTest (line 835) | FuchsiaDeathTest(const char* a_statement, Matcher<const std::strin...
      class ForkingDeathTest (line 1056) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 1064) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 1092) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 1094) | NoExecDeathTest(const char* a_statement, Matcher<const std::string...
      class ExecDeathTest (line 1147) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 1149) | ExecDeathTest(const char* a_statement, Matcher<const std::string&>...
        method GetArgvsForDeathTestChildProcess (line 1157) | static ::std::vector<std::string> GetArgvsForDeathTestChildProcess...
      type ExecDeathTestArgs (line 1174) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 1185) | static int ExecDeathTestChildMain(void* child_arg) {
      function GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ (line 1231) | GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
      function GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ (line 1239) | GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
      function pid_t (line 1256) | static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
    function GetStatusFileDescriptor (line 1471) | static int GetStatusFileDescriptor(unsigned int parent_process_id,
    function InternalRunDeathTestFlag (line 1533) | InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {

FILE: googletest/src/gtest-filepath.cc
  type testing (line 65) | namespace testing {
    type internal (line 66) | namespace internal {
      function IsPathSeparator (line 92) | static bool IsPathSeparator(char c) {
      function FilePath (line 101) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 130) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 199) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 210) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 227) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 242) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 312) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 377) | FilePath FilePath::RemoveTrailingPathSeparator() const {

FILE: googletest/src/gtest-internal-inl.h
  function namespace (line 76) | namespace testing {

FILE: googletest/src/gtest-matchers.cc
  type testing (line 42) | namespace testing {

FILE: googletest/src/gtest-port.cc
  type testing (line 97) | namespace testing {
    type internal (line 98) | namespace internal {
      function T (line 104) | T ReadProcFileField(const std::string& filename, int field) {
      function GetThreadCount (line 117) | size_t GetThreadCount() {
      function GetThreadCount (line 125) | size_t GetThreadCount() {
      function GetThreadCount (line 160) | size_t GetThreadCount() {
      function GetThreadCount (line 183) | size_t GetThreadCount() {
      function GetThreadCount (line 220) | size_t GetThreadCount() {
      function GetThreadCount (line 238) | size_t GetThreadCount() {
      function GetThreadCount (line 251) | size_t GetThreadCount() {
      function GetThreadCount (line 266) | size_t GetThreadCount() {
      class MemoryIsNotDeallocated (line 358) | class MemoryIsNotDeallocated {
        method MemoryIsNotDeallocated (line 360) | MemoryIsNotDeallocated() : old_crtdbg_flag_(0) {
        method MemoryIsNotDeallocated (line 375) | MemoryIsNotDeallocated(const MemoryIsNotDeallocated&) = delete;
        method MemoryIsNotDeallocated (line 376) | MemoryIsNotDeallocated& operator=(const MemoryIsNotDeallocated&) =...
      class ThreadWithParamSupport (line 429) | class ThreadWithParamSupport : public ThreadWithParamBase {
        method HANDLE (line 431) | static HANDLE CreateThread(Runnable* runnable,
        type ThreadMainParam (line 451) | struct ThreadMainParam {
          method ThreadMainParam (line 452) | ThreadMainParam(Runnable* runnable, Notification* thread_can_start)
        method DWORD (line 459) | static DWORD WINAPI ThreadMain(void* ptr) {
        method ThreadWithParamSupport (line 471) | ThreadWithParamSupport(const ThreadWithParamSupport&) = delete;
        method ThreadWithParamSupport (line 472) | ThreadWithParamSupport& operator=(const ThreadWithParamSupport&) =...
      class ThreadLocalRegistryImpl (line 493) | class ThreadLocalRegistryImpl {
        method ThreadLocalValueHolderBase (line 497) | static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
        method OnThreadLocalDestroyed (line 530) | static void OnThreadLocalDestroyed(
        method OnThreadExit (line 557) | static void OnThreadExit(DWORD thread_id) {
        type WatcherThreadParams (line 591) | struct WatcherThreadParams {
        method StartWatcherThreadFor (line 597) | static void StartWatcherThreadFor(DWORD thread_id) {
        method DWORD (line 635) | static DWORD WINAPI WatcherThreadFunc(LPVOID param) {
        method ThreadIdToThreadLocals (line 648) | static ThreadIdToThreadLocals* GetThreadLocalsMapLocked() {
      function ThreadLocalValueHolderBase (line 667) | ThreadLocalValueHolderBase* ThreadLocalRegistry::GetValueOnCurrentTh...
      function IsInSet (line 757) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 764) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 765) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 768) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 769) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 770) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 776) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 782) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function FormatRegexSyntaxError (line 815) | static std::string FormatRegexSyntaxError(const char* regex, int ind...
      function ValidateRegex (line 823) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 883) | bool MatchRepetitionAndRegexAtHead(bool escaped, char c, char repeat,
      function MatchRegexAtHead (line 907) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 941) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 1004) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 1022) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const...
      function EndsWithPathSeparator (line 1061) | bool EndsWithPathSeparator(const std::string& path) {
      class CapturedStream (line 1069) | class CapturedStream {
        method CapturedStream (line 1072) | explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method GetCapturedString (line 1158) | std::string GetCapturedString() {
        method CapturedStream (line 1183) | CapturedStream(const CapturedStream&) = delete;
        method CapturedStream (line 1184) | CapturedStream& operator=(const CapturedStream&) = delete;
      function CaptureStream (line 1193) | static void CaptureStream(int fd, const char* stream_name,
      function GetCapturedStream (line 1203) | static std::string GetCapturedStream(CapturedStream** captured_strea...
      function CaptureStdout (line 1222) | void CaptureStdout() {
      function CaptureStderr (line 1227) | void CaptureStderr() {
      function GetCapturedStdout (line 1232) | std::string GetCapturedStdout() {
      function GetCapturedStderr (line 1237) | std::string GetCapturedStderr() {
      function GetFileSize (line 1243) | size_t GetFileSize(FILE* file) {
      function ReadEntireFile (line 1248) | std::string ReadEntireFile(FILE* file) {
      function GetInjectableArgvs (line 1275) | std::vector<std::string> GetInjectableArgvs() {
      function SetInjectableArgvs (line 1282) | void SetInjectableArgvs(const std::vector<std::string>* new_argvs) {
      function SetInjectableArgvs (line 1287) | void SetInjectableArgvs(const std::vector<std::string>& new_argvs) {
      function ClearInjectableArgvs (line 1292) | void ClearInjectableArgvs() {
      type posix (line 1299) | namespace posix {
        function Abort (line 1300) | void Abort() {
      function FlagToEnvVar (line 1310) | static std::string FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 1325) | bool ParseInt32(const Message& src_text, const char* str, int32_t* v...
      function BoolFromGTestEnv (line 1367) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32FromGTestEnv (line 1381) | int32_t Int32FromGTestEnv(const char* flag, int32_t default_value) {
      function OutputFlagAlsoCheckEnvVar (line 1413) | std::string OutputFlagAlsoCheckEnvVar() {

FILE: googletest/src/gtest-printers.cc
  type testing (line 59) | namespace testing {
    function GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ (line 66) | GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
    function PrintBytesInObjectToImpl (line 89) | void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t c...
    function ToChar32 (line 116) | char32_t ToChar32(CharType in) {
    type internal (line 123) | namespace internal {
      function PrintBytesInObjectTo (line 130) | void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
      type CharFormat (line 140) | enum CharFormat { kAsIs, kHexEscape, kSpecialEscape }
      function IsPrintableAscii (line 145) | inline bool IsPrintableAscii(char32_t c) { return 0x20 <= c && c <= ...
      function CharFormat (line 151) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 200) | static CharFormat PrintAsStringLiteralTo(char32_t c, ostream* os) {
      function CharFormat (line 231) | static CharFormat PrintAsStringLiteralTo(char c, ostream* os) {
      function CharFormat (line 236) | static CharFormat PrintAsStringLiteralTo(char8_t c, ostream* os) {
      function CharFormat (line 241) | static CharFormat PrintAsStringLiteralTo(char16_t c, ostream* os) {
      function CharFormat (line 245) | static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) {
      function PrintCharAndCodeTo (line 253) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 276) | void PrintTo(unsigned char c, ::std::ostream* os) { PrintCharAndCode...
      function PrintTo (line 277) | void PrintTo(signed char c, ::std::ostream* os) { PrintCharAndCodeTo...
      function PrintTo (line 281) | void PrintTo(wchar_t wc, ostream* os) { PrintCharAndCodeTo(wc, os); }
      function PrintTo (line 284) | void PrintTo(char32_t c, ::std::ostream* os) {
      function PrintTo (line 291) | void PrintTo(__uint128_t v, ::std::ostream* os) {
      function PrintTo (line 324) | void PrintTo(__int128_t v, ::std::ostream* os) {
      function GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ (line 339) | GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDR...
      function GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ (line 368) | GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDR...
      function UniversalPrintArray (line 394) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function UniversalPrintArray (line 401) | void UniversalPrintArray(const char8_t* begin, size_t len, ostream* ...
      function UniversalPrintArray (line 408) | void UniversalPrintArray(const char16_t* begin, size_t len, ostream*...
      function UniversalPrintArray (line 414) | void UniversalPrintArray(const char32_t* begin, size_t len, ostream*...
      function UniversalPrintArray (line 420) | void UniversalPrintArray(const wchar_t* begin, size_t len, ostream* ...
      function PrintCStringTo (line 428) | void PrintCStringTo(const Char* s, ostream* os) {
      function PrintTo (line 439) | void PrintTo(const char* s, ostream* os) { PrintCStringTo(s, os); }
      function PrintTo (line 442) | void PrintTo(const char8_t* s, ostream* os) { PrintCStringTo(s, os); }
      function PrintTo (line 445) | void PrintTo(const char16_t* s, ostream* os) { PrintCStringTo(s, os); }
      function PrintTo (line 447) | void PrintTo(const char32_t* s, ostream* os) { PrintCStringTo(s, os); }
      function PrintTo (line 457) | void PrintTo(const wchar_t* s, ostream* os) { PrintCStringTo(s, os); }
      function ContainsUnprintableControlCodes (line 462) | bool ContainsUnprintableControlCodes(const char* str, size_t length) {
      function IsUTF8TrailByte (line 481) | bool IsUTF8TrailByte(unsigned char t) { return 0x80 <= t && t <= 0xb...
      function IsValidUTF8 (line 483) | bool IsValidUTF8(const char* str, size_t length) {
      function ConditionalPrintAsText (line 516) | void ConditionalPrintAsText(const char* str, size_t length, ostream*...
      function PrintStringTo (line 525) | void PrintStringTo(::std::string_view s, ostream* os) {
      function PrintU8StringTo (line 534) | void PrintU8StringTo(::std::u8string_view s, ostream* os) {
      function PrintU16StringTo (line 539) | void PrintU16StringTo(::std::u16string_view s, ostream* os) {
      function PrintU32StringTo (line 543) | void PrintU32StringTo(::std::u32string_view s, ostream* os) {
      function PrintWideStringTo (line 548) | void PrintWideStringTo(::std::wstring_view s, ostream* os) {

FILE: googletest/src/gtest-test-part.cc
  type testing (line 43) | namespace testing {
    function TestPartResult (line 72) | const TestPartResult& TestPartResultArray::GetTestPartResult(int index...
    type internal (line 86) | namespace internal {

FILE: googletest/src/gtest-typed-test.cc
  type testing (line 38) | namespace testing {
    type internal (line 39) | namespace internal {
      function SplitIntoTestNames (line 48) | static std::vector<std::string> SplitIntoTestNames(const char* src) {

FILE: googletest/src/gtest.cc
  type testing (line 170) | namespace testing {
    type internal (line 208) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    function GetDefaultFailFast (line 250) | static bool GetDefaultFailFast() {
    type internal (line 417) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    type internal (line 1009) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    function Message (line 1341) | Message& Message::operator<<(const wchar_t* wide_c_str) {
    function Message (line 1344) | Message& Message::operator<<(wchar_t* wide_c_str) {
    function Message (line 1351) | Message& Message::operator<<(const ::std::wstring& wstr) {
    type internal (line 1363) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    function AssertionResult (line 1787) | AssertionResult FloatLE(const char* expr1, const char* expr2, float val1,
    function AssertionResult (line 1794) | AssertionResult DoubleLE(const char* expr1, const char* expr2, double ...
    type internal (line 1799) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    function IsSubstringPred (line 1861) | bool IsSubstringPred(const char* needle, const char* haystack) {
    function IsSubstringPred (line 1867) | bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {
    function IsSubstringPred (line 1875) | bool IsSubstringPred(const StringType& needle, const StringType& hayst...
    function AssertionResult (line 1884) | AssertionResult IsSubstringImpl(bool expected_to_be_substring,
    function AssertionResult (line 1908) | AssertionResult IsSubstring(const char* needle_expr, const char* hayst...
    function AssertionResult (line 1913) | AssertionResult IsSubstring(const char* needle_expr, const char* hayst...
    function AssertionResult (line 1918) | AssertionResult IsNotSubstring(const char* needle_expr,
    function AssertionResult (line 1924) | AssertionResult IsNotSubstring(const char* needle_expr,
    function AssertionResult (line 1930) | AssertionResult IsSubstring(const char* needle_expr, const char* hayst...
    function AssertionResult (line 1936) | AssertionResult IsNotSubstring(const char* needle_expr,
    function AssertionResult (line 1944) | AssertionResult IsSubstring(const char* needle_expr, const char* hayst...
    function AssertionResult (line 1950) | AssertionResult IsNotSubstring(const char* needle_expr,
    type internal (line 1958) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    function TestPartResult (line 2335) | const TestPartResult& TestResult::GetTestPartResult(int i) const {
    function TestProperty (line 2343) | const TestProperty& TestResult::GetTestProperty(int i) const {
    function ArrayAsVector (line 2399) | std::vector<std::string> ArrayAsVector(const char* const (&array)[kSiz...
    function GetReservedAttributesForElement (line 2403) | static std::vector<std::string> GetReservedAttributesForElement(
    function GetReservedOutputAttributesForElement (line 2421) | static std::vector<std::string> GetReservedOutputAttributesForElement(
    function FormatWordList (line 2437) | static std::string FormatWordList(const std::vector<std::string>& word...
    function ValidateTestPropertyName (line 2451) | static bool ValidateTestPropertyName(
    function TestPartSkipped (line 2481) | static bool TestPartSkipped(const TestPartResult& result) {
    function TestPartFatallyFailed (line 2499) | static bool TestPartFatallyFailed(const TestPartResult& result) {
    function TestPartNonfatallyFailed (line 2509) | static bool TestPartNonfatallyFailed(const TestPartResult& result) {
    type internal (line 2556) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    type internal (line 2639) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    type internal (line 2815) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    function TestInfo (line 3019) | const TestInfo* TestSuite::GetTestInfo(int i) const {
    function TestInfo (line 3026) | TestInfo* TestSuite::GetMutableTestInfo(int i) {
    function FormatCountableNoun (line 3163) | static std::string FormatCountableNoun(int count, const char* singular...
    function FormatTestCount (line 3170) | static std::string FormatTestCount(int test_count) {
    function FormatTestSuiteCount (line 3175) | static std::string FormatTestSuiteCount(int test_suite_count) {
    type internal (line 3202) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    function TestEventListener (line 5212) | TestEventListener* TestEventListeners::Release(TestEventListener* list...
    function TestEventListener (line 5222) | TestEventListener* TestEventListeners::repeater() { return repeater_; }
    function UnitTest (line 5273) | UnitTest* UnitTest::GetInstance() {
    function TestSuite (line 5379) | const TestSuite* UnitTest::GetTestSuite(int i) const {
    function TestCase (line 5385) | const TestCase* UnitTest::GetTestCase(int i) const {
    function TestResult (line 5392) | const TestResult& UnitTest::ad_hoc_test_result() const {
    function TestSuite (line 5398) | TestSuite* UnitTest::GetMutableTestSuite(int i) {
    function TestEventListeners (line 5420) | TestEventListeners& UnitTest::listeners() { return *impl()->listeners(...
    function Environment (line 5432) | Environment* UnitTest::AddEnvironment(Environment* env) {
    function GTEST_LOCK_EXCLUDED_ (line 5449) | GTEST_LOCK_EXCLUDED_(mutex_) {
    function GTEST_LOCK_EXCLUDED_ (line 5635) | GTEST_LOCK_EXCLUDED_(mutex_) {
    function GTEST_LOCK_EXCLUDED_ (line 5643) | GTEST_LOCK_EXCLUDED_(mutex_) {
    function GTEST_LOCK_EXCLUDED_ (line 5652) | GTEST_LOCK_EXCLUDED_(mutex_) {
    function GTEST_LOCK_EXCLUDED_ (line 5663) | GTEST_LOCK_EXCLUDED_(mutex_) {
    function GTEST_LOCK_EXCLUDED_ (line 5676) | GTEST_LOCK_EXCLUDED_(mutex_) {
    function GTEST_LOCK_EXCLUDED_ (line 5682) | GTEST_LOCK_EXCLUDED_(mutex_) {
    type internal (line 5687) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    function InitGoogleTest (line 7009) | void InitGoogleTest(int* argc, char** argv) {
    function InitGoogleTest (line 7019) | void InitGoogleTest(int* argc, wchar_t** argv) {
    function InitGoogleTest (line 7029) | void InitGoogleTest() {
    function GetDirFromEnv (line 7049) | static std::string GetDirFromEnv(
    function TempDir (line 7065) | std::string TempDir() {
    function GetCurrentExecutableDirectory (line 7080) | static std::string GetCurrentExecutableDirectory() {
    function SrcDir (line 7087) | std::string SrcDir() {
    function GTEST_LOCK_EXCLUDED_ (line 7117) | GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
  type testing (line 416) | namespace testing {
    type internal (line 208) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    function GetDefaultFailFast (line 250) | static bool GetDefaultFailFast() {
    type internal (line 417) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    type internal (line 1009) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    function Message (line 1341) | Message& Message::operator<<(const wchar_t* wide_c_str) {
    function Message (line 1344) | Message& Message::operator<<(wchar_t* wide_c_str) {
    function Message (line 1351) | Message& Message::operator<<(const ::std::wstring& wstr) {
    type internal (line 1363) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    function AssertionResult (line 1787) | AssertionResult FloatLE(const char* expr1, const char* expr2, float val1,
    function AssertionResult (line 1794) | AssertionResult DoubleLE(const char* expr1, const char* expr2, double ...
    type internal (line 1799) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    function IsSubstringPred (line 1861) | bool IsSubstringPred(const char* needle, const char* haystack) {
    function IsSubstringPred (line 1867) | bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {
    function IsSubstringPred (line 1875) | bool IsSubstringPred(const StringType& needle, const StringType& hayst...
    function AssertionResult (line 1884) | AssertionResult IsSubstringImpl(bool expected_to_be_substring,
    function AssertionResult (line 1908) | AssertionResult IsSubstring(const char* needle_expr, const char* hayst...
    function AssertionResult (line 1913) | AssertionResult IsSubstring(const char* needle_expr, const char* hayst...
    function AssertionResult (line 1918) | AssertionResult IsNotSubstring(const char* needle_expr,
    function AssertionResult (line 1924) | AssertionResult IsNotSubstring(const char* needle_expr,
    function AssertionResult (line 1930) | AssertionResult IsSubstring(const char* needle_expr, const char* hayst...
    function AssertionResult (line 1936) | AssertionResult IsNotSubstring(const char* needle_expr,
    function AssertionResult (line 1944) | AssertionResult IsSubstring(const char* needle_expr, const char* hayst...
    function AssertionResult (line 1950) | AssertionResult IsNotSubstring(const char* needle_expr,
    type internal (line 1958) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    function TestPartResult (line 2335) | const TestPartResult& TestResult::GetTestPartResult(int i) const {
    function TestProperty (line 2343) | const TestProperty& TestResult::GetTestProperty(int i) const {
    function ArrayAsVector (line 2399) | std::vector<std::string> ArrayAsVector(const char* const (&array)[kSiz...
    function GetReservedAttributesForElement (line 2403) | static std::vector<std::string> GetReservedAttributesForElement(
    function GetReservedOutputAttributesForElement (line 2421) | static std::vector<std::string> GetReservedOutputAttributesForElement(
    function FormatWordList (line 2437) | static std::string FormatWordList(const std::vector<std::string>& word...
    function ValidateTestPropertyName (line 2451) | static bool ValidateTestPropertyName(
    function TestPartSkipped (line 2481) | static bool TestPartSkipped(const TestPartResult& result) {
    function TestPartFatallyFailed (line 2499) | static bool TestPartFatallyFailed(const TestPartResult& result) {
    function TestPartNonfatallyFailed (line 2509) | static bool TestPartNonfatallyFailed(const TestPartResult& result) {
    type internal (line 2556) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    type internal (line 2639) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    type internal (line 2815) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    function TestInfo (line 3019) | const TestInfo* TestSuite::GetTestInfo(int i) const {
    function TestInfo (line 3026) | TestInfo* TestSuite::GetMutableTestInfo(int i) {
    function FormatCountableNoun (line 3163) | static std::string FormatCountableNoun(int count, const char* singular...
    function FormatTestCount (line 3170) | static std::string FormatTestCount(int test_count) {
    function FormatTestSuiteCount (line 3175) | static std::string FormatTestSuiteCount(int test_suite_count) {
    type internal (line 3202) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    function TestEventListener (line 5212) | TestEventListener* TestEventListeners::Release(TestEventListener* list...
    function TestEventListener (line 5222) | TestEventListener* TestEventListeners::repeater() { return repeater_; }
    function UnitTest (line 5273) | UnitTest* UnitTest::GetInstance() {
    function TestSuite (line 5379) | const TestSuite* UnitTest::GetTestSuite(int i) const {
    function TestCase (line 5385) | const TestCase* UnitTest::GetTestCase(int i) const {
    function TestResult (line 5392) | const TestResult& UnitTest::ad_hoc_test_result() const {
    function TestSuite (line 5398) | TestSuite* UnitTest::GetMutableTestSuite(int i) {
    function TestEventListeners (line 5420) | TestEventListeners& UnitTest::listeners() { return *impl()->listeners(...
    function Environment (line 5432) | Environment* UnitTest::AddEnvironment(Environment* env) {
    function GTEST_LOCK_EXCLUDED_ (line 5449) | GTEST_LOCK_EXCLUDED_(mutex_) {
    function GTEST_LOCK_EXCLUDED_ (line 5635) | GTEST_LOCK_EXCLUDED_(mutex_) {
    function GTEST_LOCK_EXCLUDED_ (line 5643) | GTEST_LOCK_EXCLUDED_(mutex_) {
    function GTEST_LOCK_EXCLUDED_ (line 5652) | GTEST_LOCK_EXCLUDED_(mutex_) {
    function GTEST_LOCK_EXCLUDED_ (line 5663) | GTEST_LOCK_EXCLUDED_(mutex_) {
    function GTEST_LOCK_EXCLUDED_ (line 5676) | GTEST_LOCK_EXCLUDED_(mutex_) {
    function GTEST_LOCK_EXCLUDED_ (line 5682) | GTEST_LOCK_EXCLUDED_(mutex_) {
    type internal (line 5687) | namespace internal {
      function FILE (line 220) | static FILE* OpenFileForWriting(const std::string& output_file) {
      function GTestIsInitialized (line 443) | static bool GTestIsInitialized() { return !GetArgvs().empty(); }
      function SumOverTestSuiteList (line 448) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
      function TestSuitePassed (line 458) | static bool TestSuitePassed(const TestSuite* test_suite) {
      function TestSuiteFailed (line 463) | static bool TestSuiteFailed(const TestSuite* test_suite) {
      function ShouldRunTestSuite (line 469) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
      function ShouldEmitStackTraceForResultType (line 477) | bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
      class FailureTest (line 525) | class FailureTest : public Test {
        method FailureTest (line 527) | explicit FailureTest(const CodeLocation& loc, std::string error_me...
        method TestBody (line 533) | void TestBody() override {
      function InsertSyntheticTestCase (line 561) | void InsertSyntheticTestCase(const std::string& name, CodeLocation l...
      function RegisterTypeParameterizedTestSuite (line 606) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
      function RegisterTypeParameterizedTestSuiteInstantiation (line 612) | void RegisterTypeParameterizedTestSuiteInstantiation(const char* cas...
      function GetArgvs (line 675) | ::std::vector<std::string> GetArgvs() {
      function FilePath (line 689) | FilePath GetCurrentExecutableName() {
      function PatternMatchesString (line 757) | static bool PatternMatchesString(const std::string& name_str,
      function IsGlobPattern (line 806) | bool IsGlobPattern(const std::string& pattern) {
      class UnitTestFilter (line 811) | class UnitTestFilter {
        method UnitTestFilter (line 813) | UnitTestFilter() = default;
        method UnitTestFilter (line 816) | explicit UnitTestFilter(const std::string& filter) {
        method MatchesName (line 834) | bool MatchesName(const std::string& name) const {
      class PositiveAndNegativeUnitTestFilter (line 849) | class PositiveAndNegativeUnitTestFilter {
        method PositiveAndNegativeUnitTestFilter (line 856) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filt...
        method MatchesTest (line 886) | bool MatchesTest(const std::string& test_suite_name,
        method MatchesName (line 897) | bool MatchesName(const std::string& name) const {
      function FormatSehExceptionMessage (line 924) | static std::string FormatSehExceptionMessage(DWORD exception_code,
      function TypeId (line 1020) | TypeId GetTestTypeId() { return GetTypeId<Test>(); }
      function AssertionResult (line 1029) | static AssertionResult HasOneFailure(const char* /* results_expr */,
      function TestPartResultReporterInterface (line 1101) | TestPartResultReporterInterface*
      function TestPartResultReporterInterface (line 1115) | TestPartResultReporterInterface*
      class Timer (line 1207) | class Timer {
        method Timer (line 1209) | Timer() : start_(clock::now()) {}
        method TimeInMillis (line 1212) | TimeInMillis Elapsed() {
      function TimeInMillis (line 1232) | TimeInMillis GetTimeInMillis() {
      function LPCWSTR (line 1248) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
      function StreamWideCharsToMessage (line 1294) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
      function SplitString (line 1309) | void SplitString(const ::std::string& str, char delimiter,
      type edit_distance (line 1365) | namespace edit_distance {
        function CalculateOptimalEdits (line 1366) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
        class InternalStrings (line 1426) | class InternalStrings {
          method GetId (line 1428) | size_t GetId(const std::string& str) {
        function CalculateOptimalEdits (line 1442) | std::vector<EditType> CalculateOptimalEdits(
        class Hunk (line 1464) | class Hunk {
          method Hunk (line 1466) | Hunk(size_t left_start, size_t right_start)
          method PushLine (line 1473) | void PushLine(char edit, const char* line) {
          method PrintTo (line 1491) | void PrintTo(std::ostream* os) {
          method has_edits (line 1501) | bool has_edits() const { return adds_ || removes_; }
          method FlushEdits (line 1504) | void FlushEdits() {
          method PrintHeader (line 1513) | void PrintHeader(std::ostream* ss) const {
        function CreateUnifiedDiff (line 1541) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
      function SplitEscapedString (line 1611) | std::vector<std::string> SplitEscapedString(const std::string& str) {
      function AssertionResult (line 1651) | AssertionResult EqFailure(const char* lhs_expression,
      function GetBoolAssertionFailureMessage (line 1683) | std::string GetBoolAssertionFailureMessage(
      function AssertionResult (line 1699) | AssertionResult DoubleNearPredFormat(const char* expr1, const char* ...
      function AssertionResult (line 1752) | AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
      function AssertionResult (line 1802) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 1814) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
      function AssertionResult (line 1826) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function AssertionResult (line 1839) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
      function AssertionResult (line 1965) | AssertionResult HRESULTFailureHelper(const char* expr, const char* e...
      function AssertionResult (line 2005) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NO...
      function AssertionResult (line 2012) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NO...
      function ChopLowBits (line 2050) | inline uint32_t ChopLowBits(uint32_t* bits, int n) {
      function CodePointToUtf8 (line 2062) | std::string CodePointToUtf8(uint32_t code_point) {
      function IsUtf16SurrogatePair (line 2097) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
      function CreateCodePointFromUtf16SurrogatePair (line 2103) | inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
      function WideStringToUtf8 (line 2129) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
      function AssertionResult (line 2174) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
      function AssertionResult (line 2186) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
      function StringStreamToString (line 2289) | std::string StringStreamToString(::std::stringstream* ss) {
      function AppendUserMessage (line 2308) | std::string AppendUserMessage(const std::string& gtest_msg,
      function ReportFailureInUnknownLocation (line 2558) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
      function FormatCxxExceptionMessage (line 2644) | static std::string FormatCxxExceptionMessage(const char* description,
      function Result (line 2675) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::...
      function Result (line 2694) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*me...
      function TestInfo (line 2835) | TestInfo* MakeAndRegisterTestInfo(
      function ReportInvalidTestSuiteType (line 2847) | void ReportInvalidTestSuiteType(const char* test_suite_name,
      type GTestColor (line 3204) | enum class GTestColor { kDefault, kRed, kGreen, kYellow }
      function PrintTestPartResultToString (line 3208) | static std::string PrintTestPartResultToString(
      function PrintTestPartResult (line 3220) | static void PrintTestPartResult(const TestPartResult& test_part_resu...
      function WORD (line 3243) | static WORD GetColorAttribute(GTestColor color) {
      function GetBitOffset (line 3256) | static int GetBitOffset(WORD color_mask) {
      function WORD (line 3267) | static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
      function ShouldUseColor (line 3308) | bool ShouldUseColor(bool stdout_is_tty) {
      function ColoredPrintf (line 3351) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
      function PrintFullTestCommentIfPresent (line 3403) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
      class PrettyUnitTestResultPrinter (line 3422) | class PrettyUnitTestResultPrinter : public TestEventListener {
        method PrettyUnitTestResultPrinter (line 3424) | PrettyUnitTestResultPrinter() = default;
        method PrintTestName (line 3425) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3430) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnEnvironmentsSetUpEnd (line 3433) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnEnvironmentsTearDownEnd (line 3452) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3454) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class BriefUnitTestResultPrinter (line 3730) | class BriefUnitTestResultPrinter : public TestEventListener {
        method BriefUnitTestResultPrinter (line 3732) | BriefUnitTestResultPrinter() = default;
        method PrintTestName (line 3733) | static void PrintTestName(const char* test_suite, const char* test) {
        method OnTestProgramStart (line 3738) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
        method OnTestIterationStart (line 3739) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 3741) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 3742) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) overrid...
        method OnTestCaseStart (line 3744) | void OnTestCaseStart(const TestCase& /*test_case*/) override {}
        method OnTestSuiteStart (line 3746) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
        method OnTestStart (line 3749) | void OnTestStart(const TestInfo& /*test_info*/) override {}
        method OnTestDisabled (line 3750) | void OnTestDisabled(const TestInfo& /*test_info*/) override {}
        method OnTestCaseEnd (line 3755) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
        method OnTestSuiteEnd (line 3757) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
        method OnEnvironmentsTearDownStart (line 3760) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 3761) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestProgramEnd (line 3763) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
      class TestEventRepeater (line 3835) | class TestEventRepeater : public TestEventListener {
        method TestEventRepeater (line 3837) | TestEventRepeater() : forwarding_enabled_(true) {}
        method forwarding_enabled (line 3844) | bool forwarding_enabled() const { return forwarding_enabled_; }
        method set_forwarding_enabled (line 3845) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = e...
        method TestEventRepeater (line 3877) | TestEventRepeater(const TestEventRepeater&) = delete;
        method TestEventRepeater (line 3878) | TestEventRepeater& operator=(const TestEventRepeater&) = delete;
      function TestEventListener (line 3889) | TestEventListener* TestEventRepeater::Release(TestEventListener* lis...
      class XmlUnitTestResultPrinter (line 3967) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
        method IsNormalizableWhitespace (line 3981) | static bool IsNormalizableWhitespace(unsigned char c) {
        method IsValidXmlCharacter (line 3987) | static bool IsValidXmlCharacter(unsigned char c) {
        method EscapeXmlAttribute (line 4001) | static std::string EscapeXmlAttribute(const std::string& str) {
        method EscapeXmlText (line 4006) | static std::string EscapeXmlText(const char* str) {
        method XmlUnitTestResultPrinter (line 4058) | XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
        method XmlUnitTestResultPrinter (line 4059) | XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter...
      function FormatTimeInMillisAsSeconds (line 4174) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
      function PortableLocaltime (line 4187) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
      function FormatEpochTimeInMillisAsIso8601 (line 4208) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
      class JsonUnitTestResultPrinter (line 4524) | class JsonUnitTestResultPrinter : public EmptyTestEventListener {
        method JsonUnitTestResultPrinter (line 4586) | JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
        method JsonUnitTestResultPrinter (line 4587) | JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrint...
      function FormatTimeInMillisAsDuration (line 4652) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
      function FormatEpochTimeInMillisAsRFC3339 (line 4660) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
      function Indent (line 4673) | static inline std::string Indent(size_t width) {
      function GTEST_LOCK_EXCLUDED_ (line 5089) | GTEST_LOCK_EXCLUDED_(mutex_) {
      function GTEST_LOCK_EXCLUDED_ (line 5138) | GTEST_LOCK_EXCLUDED_(mutex_) {
      class ScopedPrematureExitFile (line 5153) | class ScopedPrematureExitFile {
        method ScopedPrematureExitFile (line 5155) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
        method ScopedPrematureExitFile (line 5185) | ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
        method ScopedPrematureExitFile (line 5186) | ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&)...
      function TestSuite (line 5859) | TestSuite* UnitTestImpl::GetTestSuite(
      function SetUpEnvironment (line 5903) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
      function TearDownEnvironment (line 5904) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
      function AppendToTestWarningsOutputFile (line 5909) | static void AppendToTestWarningsOutputFile(const std::string& str) {
      function WriteToShardStatusFileIfNeeded (line 6182) | void WriteToShardStatusFileIfNeeded() {
      function ShouldShard (line 6205) | bool ShouldShard(const char* total_shards_env, const char* shard_ind...
      function Int32FromEnvOrDie (line 6249) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
      function ShouldRunTestOnShard (line 6267) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int tes...
      function PrintOnOneLine (line 6360) | static void PrintOnOneLine(const char* str, int max_length) {
      function OsStackTraceGetterInterface (line 6449) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
      function TestResult (line 6462) | TestResult* UnitTestImpl::current_test_result() {
      function GTEST_NO_INLINE_ (line 6508) | GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
      class ClassUniqueToAlwaysTrue (line 6518) | class ClassUniqueToAlwaysTrue {}
      function IsTrue (line 6521) | bool IsTrue(bool condition) { return condition; }
      function AlwaysTrue (line 6523) | bool AlwaysTrue() {
      function SkipPrefix (line 6535) | bool SkipPrefix(const char* prefix, const char** pstr) {
      function ParseFlag (line 6587) | static bool ParseFlag(const char* str, const char* flag_name, bool* ...
      function ParseFlag (line 6603) | bool ParseFlag(const char* str, const char* flag_name, int32_t* valu...
      function ParseFlag (line 6620) | static bool ParseFlag(const char* str, const char* flag_name, String...
      function HasGoogleTestFlagPrefix (line 6638) | static bool HasGoogleTestFlagPrefix(const char* str) {
      function PrintColorEncoded (line 6655) | static void PrintColorEncoded(const char* str) {
      function ParseGoogleTestFlag (line 6785) | static bool ParseGoogleTestFlag(const char* const arg) {
      function LoadFlagsFromFile (line 6822) | static void LoadFlagsFromFile(const std::string& path) {
      function ParseGoogleTestFlagsOnlyImpl (line 6843) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
      function ParseGoogleTestFlagsOnly (line 6898) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
      function ParseGoogleTestFlagsOnly (line 6962) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
      function InitGoogleTestImpl (line 6971) | void InitGoogleTestImpl(int* argc, CharType** argv) {
    function InitGoogleTest (line 7009) | void InitGoogleTest(int* argc, char** argv) {
    function InitGoogleTest (line 7019) | void InitGoogleTest(int* argc, wchar_t** argv) {
    function InitGoogleTest (line 7029) | void InitGoogleTest() {
    function GetDirFromEnv (line 7049) | static std::string GetDirFromEnv(
    function TempDir (line 7065) | std::string TempDir() {
    function GetCurrentExecutableDirectory (line 7080) | static std::string GetCurrentExecutableDirectory() {
    function SrcDir (line 7087) | std::string SrcDir() {
    function GTEST_LOCK_EXCLUDED_ (line 7117) | GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {

FILE: googletest/src/gtest_main.cc
  function setup (line 42) | void setup() { testing::InitGoogleTest(); }
  function loop (line 44) | void loop() { RUN_ALL_TESTS(); }
  function GTEST_API_ (line 53) | GTEST_API_ int main() {
  function GTEST_API_ (line 61) | GTEST_API_ int main(int argc, char **argv) {

FILE: googletest/test/googletest-break-on-failure-unittest.py
  function Run (line 77) | def Run(command):
  class GTestBreakOnFailureUnitTest (line 90) | class GTestBreakOnFailureUnitTest(gtest_test_utils.TestCase):
    method RunAndVerify (line 98) | def RunAndVerify(self, env_var_value, flag_value, expect_seg_fault):
    method testDefaultBehavior (line 148) | def testDefaultBehavior(self):
    method testEnvVar (line 153) | def testEnvVar(self):
    method testFlag (line 159) | def testFlag(self):
    method testFlagOverridesEnvVar (line 165) | def testFlagOverridesEnvVar(self):
    method testBreakOnFailureOverridesThrowOnFailure (line 173) | def testBreakOnFailureOverridesThrowOnFailure(self):
    method testCatchExceptionsDoesNotInterfere (line 184) | def testCatchExceptionsDoesNotInterfere(self):

FILE: googletest/test/googletest-break-on-failure-unittest_.cc
  function TEST (line 50) | TEST(Foo, Bar) { EXPECT_EQ(2, 3); }
  function LONG (line 54) | LONG WINAPI
  function main (line 62) | int main(int argc, char** argv) {

FILE: googletest/test/googletest-catch-exceptions-test.py
  class CatchSehExceptionsTest (line 85) | class CatchSehExceptionsTest(gtest_test_utils.TestCase):
    method TestSehExceptions (line 88) | def TestSehExceptions(self, test_output):
    method testCatchesSehExceptionsWithCxxExceptionsEnabled (line 120) | def testCatchesSehExceptionsWithCxxExceptionsEnabled(self):
    method testCatchesSehExceptionsWithCxxExceptionsDisabled (line 123) | def testCatchesSehExceptionsWithCxxExceptionsDisabled(self):
  class CatchCxxExceptionsTest (line 127) | class CatchCxxExceptionsTest(gtest_test_utils.TestCase):
    method testCatchesCxxExceptionsInFixtureConstructor (line 136) | def testCatchesCxxExceptionsInFixtureConstructor(self):
    method testCatchesCxxExceptionsInFixtureDestructor (line 158) | def testCatchesCxxExceptionsInFixtureDestructor(self):
    method testCatchesCxxExceptionsInSetUpTestCase (line 173) | def testCatchesCxxExceptionsInSetUpTestCase(self):
    method testCatchesCxxExceptionsInTearDownTestCase (line 211) | def testCatchesCxxExceptionsInTearDownTestCase(self):
    method testCatchesCxxExceptionsInSetUp (line 219) | def testCatchesCxxExceptionsInSetUp(self):
    method testCatchesCxxExceptionsInTearDown (line 250) | def testCatchesCxxExceptionsInTearDown(self):
    method testCatchesCxxExceptionsInTestBody (line 268) | def testCatchesCxxExceptionsInTestBody(self):
    method testCatchesNonStdCxxExceptions (line 291) | def testCatchesNonStdCxxExceptions(self):
    method testUnhandledCxxExceptionsAbortTheProgram (line 297) | def testUnhandledCxxExceptionsAbortTheProgram(self):

FILE: googletest/test/googletest-catch-exceptions-test_.cc
  class SehExceptionInConstructorTest (line 53) | class SehExceptionInConstructorTest : public Test {
    method SehExceptionInConstructorTest (line 55) | SehExceptionInConstructorTest() { RaiseException(42, 0, 0, NULL); }
  function TEST_F (line 58) | TEST_F(SehExceptionInConstructorTest, ThrowsExceptionInConstructor) {}
  class SehExceptionInDestructorTest (line 60) | class SehExceptionInDestructorTest : public Test {
  function TEST_F (line 65) | TEST_F(SehExceptionInDestructorTest, ThrowsExceptionInDestructor) {}
  class SehExceptionInSetUpTestSuiteTest (line 67) | class SehExceptionInSetUpTestSuiteTest : public Test {
    method SetUpTestSuite (line 69) | static void SetUpTestSuite() { RaiseException(42, 0, 0, NULL); }
  function TEST_F (line 72) | TEST_F(SehExceptionInSetUpTestSuiteTest, ThrowsExceptionInSetUpTestSuite...
  class SehExceptionInTearDownTestSuiteTest (line 74) | class SehExceptionInTearDownTestSuiteTest : public Test {
    method TearDownTestSuite (line 76) | static void TearDownTestSuite() { RaiseException(42, 0, 0, NULL); }
  function TEST_F (line 79) | TEST_F(SehExceptionInTearDownTestSuiteTest,
  class SehExceptionInSetUpTest (line 82) | class SehExceptionInSetUpTest : public Test {
    method SetUp (line 84) | virtual void SetUp() { RaiseException(42, 0, 0, NULL); }
  function TEST_F (line 87) | TEST_F(SehExceptionInSetUpTest, ThrowsExceptionInSetUp) {}
  class SehExceptionInTearDownTest (line 89) | class SehExceptionInTearDownTest : public Test {
    method TearDown (line 91) | virtual void TearDown() { RaiseException(42, 0, 0, NULL); }
  function TEST_F (line 94) | TEST_F(SehExceptionInTearDownTest, ThrowsExceptionInTearDown) {}
  function TEST (line 96) | TEST(SehExceptionTest, ThrowsSehException) { RaiseException(42, 0, 0, NU...
  class CxxExceptionInConstructorTest (line 102) | class CxxExceptionInConstructorTest : public Test {
    method CxxExceptionInConstructorTest (line 104) | CxxExceptionInConstructorTest() {
    method TearDownTestSuite (line 111) | static void TearDownTestSuite() {
    method SetUp (line 123) | void SetUp() override {
    method TearDown (line 128) | void TearDown() override {
  function TEST_F (line 134) | TEST_F(CxxExceptionInConstructorTest, ThrowsExceptionInConstructor) {
  class CxxExceptionInSetUpTestSuiteTest (line 139) | class CxxExceptionInSetUpTestSuiteTest : public Test {
    method CxxExceptionInSetUpTestSuiteTest (line 141) | CxxExceptionInSetUpTestSuiteTest() {
    method SetUpTestSuite (line 147) | static void SetUpTestSuite() {
    method TearDownTestSuite (line 151) | static void TearDownTestSuite() {
    method SetUp (line 164) | void SetUp() override {
    method TearDown (line 170) | void TearDown() override {
  function TEST_F (line 177) | TEST_F(CxxExceptionInSetUpTestSuiteTest, ThrowsExceptionInSetUpTestSuite) {
  class CxxExceptionInTearDownTestSuiteTest (line 183) | class CxxExceptionInTearDownTestSuiteTest : public Test {
    method TearDownTestSuite (line 185) | static void TearDownTestSuite() {
  function TEST_F (line 190) | TEST_F(CxxExceptionInTearDownTestSuiteTest,
  class CxxExceptionInSetUpTest (line 193) | class CxxExceptionInSetUpTest : public Test {
    method TearDownTestSuite (line 195) | static void TearDownTestSuite() {
    method SetUp (line 208) | void SetUp() override { throw std::runtime_error("Standard C++ excepti...
    method TearDown (line 210) | void TearDown() override {
  function TEST_F (line 217) | TEST_F(CxxExceptionInSetUpTest, ThrowsExceptionInSetUp) {
  class CxxExceptionInTearDownTest (line 222) | class CxxExceptionInTearDownTest : public Test {
    method TearDownTestSuite (line 224) | static void TearDownTestSuite() {
    method TearDown (line 237) | void TearDown() override {
  function TEST_F (line 242) | TEST_F(CxxExceptionInTearDownTest, ThrowsExceptionInTearDown) {}
  class CxxExceptionInTestBodyTest (line 244) | class CxxExceptionInTestBodyTest : public Test {
    method TearDownTestSuite (line 246) | static void TearDownTestSuite() {
    method TearDown (line 259) | void TearDown() override {
  function TEST_F (line 266) | TEST_F(CxxExceptionInTestBodyTest, ThrowsStdCxxException) {
  function TEST (line 270) | TEST(CxxExceptionTest, ThrowsNonStdCxxException) { throw "C-string"; }
  function TerminateHandler (line 275) | void TerminateHandler() {
  function main (line 283) | int main(int argc, char** argv) {

FILE: googletest/test/googletest-color-test.py
  function SetEnvVar (line 44) | def SetEnvVar(env_var, value):
  function UsesColor (line 53) | def UsesColor(term, color_env_var, color_flag):
  class GTestColorTest (line 67) | class GTestColorTest(gtest_test_utils.TestCase):
    method testNoEnvVarNoFlag (line 69) | def testNoEnvVarNoFlag(self):
    method testFlagOnly (line 87) | def testFlagOnly(self):
    method testEnvVarOnly (line 98) | def testEnvVarOnly(self):
    method testEnvVarAndFlag (line 109) | def testEnvVarAndFlag(self):
    method testAliasesOfYesAndNo (line 116) | def testAliasesOfYesAndNo(self):

FILE: googletest/test/googletest-color-test_.cc
  function TEST (line 45) | TEST(GTestColorTest, Dummy) {}
  function main (line 47) | int main(int argc, char** argv) {

FILE: googletest/test/googletest-death-test-test.cc
  type testing (line 80) | namespace testing {
    type internal (line 81) | namespace internal {
      class ReplaceDeathTestFactory (line 85) | class ReplaceDeathTestFactory {
        method ReplaceDeathTestFactory (line 87) | explicit ReplaceDeathTestFactory(DeathTestFactory* new_factory)
  function DieWithMessage (line 112) | void DieWithMessage(const ::std::string& message) {
  function DieInside (line 127) | void DieInside(const ::std::string& function) {
  class TestForDeathTest (line 133) | class TestForDeathTest : public testing::Test {
    method TestForDeathTest (line 135) | TestForDeathTest() : original_dir_(FilePath::GetCurrentDir()) {}
    method StaticMemberFunction (line 140) | static void StaticMemberFunction() { DieInside("StaticMemberFunction"); }
    method MemberFunction (line 143) | void MemberFunction() {
  class MayDie (line 153) | class MayDie {
    method MayDie (line 155) | explicit MayDie(bool should_die) : should_die_(should_die) {}
    method MemberFunction (line 158) | void MemberFunction() const {
  function GlobalFunction (line 168) | void GlobalFunction() { DieInside("GlobalFunction"); }
  function NonVoidFunction (line 171) | int NonVoidFunction() {
  function DieIf (line 177) | void DieIf(bool should_die) {
  function DieIfLessThan (line 182) | bool DieIfLessThan(int x, int y) {
  function DeathTestSubroutine (line 190) | void DeathTestSubroutine() {
  function DieInDebugElse12 (line 196) | int DieInDebugElse12(int* sideeffect) {
  function DieInCRTDebugElse12 (line 211) | int DieInCRTDebugElse12(int* sideeffect) {
  function TEST (line 231) | TEST(ExitStatusPredicateTest, ExitedWithCode) {
  function NormalExitStatus (line 246) | static int NormalExitStatus(int exit_code) {
  function KilledExitStatus (line 261) | static int KilledExitStatus(int signum) {
  function TEST (line 273) | TEST(ExitStatusPredicateTest, ExitedWithCode) {
  function TEST (line 289) | TEST(ExitStatusPredicateTest, KilledBySignal) {
  function TEST_F (line 314) | TEST_F(TestForDeathTest, SingleStatement) {
  function TEST_F (line 339) | TEST_F(TestForDeathTest, SwitchStatement) {
  function TEST_F (line 357) | TEST_F(TestForDeathTest, StaticMemberFunctionFastStyle) {
  function TEST_F (line 364) | TEST_F(TestForDeathTest, MemberFunctionFastStyle) {
  function ChangeToRootDir (line 370) | void ChangeToRootDir() { posix::ChDir(GTEST_PATH_SEP_); }
  function TEST_F (line 374) | TEST_F(TestForDeathTest, FastDeathTestInChangedDir) {
  function SigprofAction (line 385) | void SigprofAction(int, siginfo_t*, void*) { /* no op */
  function SetSigprofActionAndTimer (line 389) | void SetSigprofActionAndTimer() {
  function DisableSigprofActionAndTimer (line 406) | void DisableSigprofActionAndTimer(struct sigaction* old_signal_action) {
  function TEST_F (line 420) | TEST_F(TestForDeathTest, FastSigprofActionSet) {
  function TEST_F (line 429) | TEST_F(TestForDeathTest, ThreadSafeSigprofActionSet) {
  function TEST_F (line 441) | TEST_F(TestForDeathTest, StaticMemberFunctionThreadsafeStyle) {
  function TEST_F (line 446) | TEST_F(TestForDeathTest, MemberFunctionThreadsafeStyle) {
  function TEST_F (line 452) | TEST_F(TestForDeathTest, ThreadsafeDeathTestInLoop) {
  function TEST_F (line 459) | TEST_F(TestForDeathTest, ThreadsafeDeathTestInChangedDir) {
  function TEST_F (line 469) | TEST_F(TestForDeathTest, MixedStyles) {
  function SetPthreadFlag (line 480) | void SetPthreadFlag() { pthread_flag = true; }
  function TEST_F (line 482) | TEST_F(TestForDeathTest, DoesNotExecuteAtforkHooks) {
  function TEST_F (line 495) | TEST_F(TestForDeathTest, MethodOfAnotherClass) {
  function TEST_F (line 501) | TEST_F(TestForDeathTest, GlobalFunction) {
  function TEST_F (line 507) | TEST_F(TestForDeathTest, AcceptsAnythingConvertibleToRE) {
  function TEST_F (line 523) | TEST_F(TestForDeathTest, NonVoidFunction) {
  function TEST_F (line 528) | TEST_F(TestForDeathTest, FunctionWithParameter) {
  function TEST_F (line 534) | TEST_F(TestForDeathTest, OutsideFixture) { DeathTestSubroutine(); }
  function TEST_F (line 537) | TEST_F(TestForDeathTest, InsideLoop) {
  function TEST_F (line 544) | TEST_F(TestForDeathTest, CompoundStatement) {
  function TEST_F (line 555) | TEST_F(TestForDeathTest, DoesNotDie) {
  function TEST_F (line 560) | TEST_F(TestForDeathTest, ErrorMessageMismatch) {
  function ExpectDeathTestHelper (line 571) | void ExpectDeathTestHelper(bool* aborted) {
  function TEST_F (line 578) | TEST_F(TestForDeathTest, EXPECT_DEATH) {
  function TEST_F (line 585) | TEST_F(TestForDeathTest, ASSERT_DEATH) {
  function TEST_F (line 598) | TEST_F(TestForDeathTest, SingleEvaluation) {
  function TEST_F (line 609) | TEST_F(TestForDeathTest, RunawayIsFailure) {
  function TEST_F (line 616) | TEST_F(TestForDeathTest, ReturnIsFailure) {
  function TEST_F (line 628) | TEST_F(TestForDeathTest, TestExpectDebugDeath) {
  function TEST_F (line 661) | TEST_F(TestForDeathTest, CRTDebugDeath) {
  function TEST_F (line 676) | TEST_F(TestForDeathTest, TestAssertDebugDeath) {
  function ExpectDebugDeathHelper (line 697) | void ExpectDebugDeathHelper(bool* aborted) {
  function TEST (line 704) | TEST(PopUpDeathTest, DoesNotShowPopUpOnAbort) {
  function TEST_F (line 721) | TEST_F(TestForDeathTest, ExpectDebugDeathDoesNotAbort) {
  function AssertDebugDeathHelper (line 727) | void AssertDebugDeathHelper(bool* aborted) {
  function TEST_F (line 738) | TEST_F(TestForDeathTest, AssertDebugDeathAborts) {
  function TEST_F (line 745) | TEST_F(TestForDeathTest, AssertDebugDeathAborts2) {
  function TEST_F (line 752) | TEST_F(TestForDeathTest, AssertDebugDeathAborts3) {
  function TEST_F (line 759) | TEST_F(TestForDeathTest, AssertDebugDeathAborts4) {
  function TEST_F (line 766) | TEST_F(TestForDeathTest, AssertDebugDeathAborts5) {
  function TEST_F (line 773) | TEST_F(TestForDeathTest, AssertDebugDeathAborts6) {
  function TEST_F (line 780) | TEST_F(TestForDeathTest, AssertDebugDeathAborts7) {
  function TEST_F (line 787) | TEST_F(TestForDeathTest, AssertDebugDeathAborts8) {
  function TEST_F (line 794) | TEST_F(TestForDeathTest, AssertDebugDeathAborts9) {
  function TEST_F (line 801) | TEST_F(TestForDeathTest, AssertDebugDeathAborts10) {
  function TestExitMacros (line 811) | static void TestExitMacros() {
  function TEST_F (line 845) | TEST_F(TestForDeathTest, ExitMacros) { TestExitMacros(); }
  function TEST_F (line 847) | TEST_F(TestForDeathTest, ExitMacrosUsingFork) {
  function TEST_F (line 852) | TEST_F(TestForDeathTest, InvalidStyle) {
  function TEST_F (line 861) | TEST_F(TestForDeathTest, DeathTestFailedOutput) {
  function TEST_F (line 869) | TEST_F(TestForDeathTest, DeathTestUnexpectedReturnOutput) {
  function TEST_F (line 883) | TEST_F(TestForDeathTest, DeathTestBadExitCodeOutput) {
  function TEST_F (line 894) | TEST_F(TestForDeathTest, DeathTestMultiLineMatchFail) {
  function TEST_F (line 905) | TEST_F(TestForDeathTest, DeathTestMultiLineMatchPass) {
  class MockDeathTestFactory (line 912) | class MockDeathTestFactory : public DeathTestFactory {
    method AssumeRoleCalls (line 924) | int AssumeRoleCalls() const { return assume_role_calls_; }
    method WaitCalls (line 925) | int WaitCalls() const { return wait_calls_; }
    method PassedCalls (line 926) | size_t PassedCalls() const { return passed_args_.size(); }
    method PassedArgument (line 927) | bool PassedArgument(int n) const {
    method AbortCalls (line 930) | size_t AbortCalls() const { return abort_args_.size(); }
    method AbortArgument (line 931) | DeathTest::AbortReason AbortArgument(int n) const {
    method TestDeleted (line 934) | bool TestDeleted() const { return test_deleted_; }
  class MockDeathTest (line 967) | class MockDeathTest : public DeathTest {
    method MockDeathTest (line 969) | MockDeathTest(MockDeathTestFactory* parent, TestRole role, int status,
    method TestRole (line 973) | TestRole AssumeRole() override {
    method Wait (line 977) | int Wait() override {
    method Passed (line 981) | bool Passed(bool exit_status_ok) override {
    method Abort (line 985) | void Abort(AbortReason reason) override {
  class MacroLogicDeathTest (line 1039) | class MacroLogicDeathTest : public testing::Test {
    method SetUpTestSuite (line 1044) | static void SetUpTestSuite() {
    method TearDownTestSuite (line 1049) | static void TearDownTestSuite() {
    method RunReturningDeathTest (line 1059) | static void RunReturningDeathTest(bool* flag) {
  function TEST_F (line 1074) | TEST_F(MacroLogicDeathTest, NothingHappens) {
  function TEST_F (line 1089) | TEST_F(MacroLogicDeathTest, ChildExitsSuccessfully) {
  function TEST_F (line 1104) | TEST_F(MacroLogicDeathTest, ChildExitsUnsuccessfully) {
  function TEST_F (line 1120) | TEST_F(MacroLogicDeathTest, ChildPerformsReturn) {
  function TEST_F (line 1136) | TEST_F(MacroLogicDeathTest, ChildDoesNotDie) {
  function TEST (line 1158) | TEST(SuccessRegistrationDeathTest, NoSuccessPart) {
  function TEST (line 1163) | TEST(StreamingAssertionsDeathTest, DeathTest) {
  function TEST (line 1180) | TEST(GetLastErrnoDescription, GetLastErrnoDescriptionWorks) {
  function TEST (line 1188) | TEST(AutoHandleTest, AutoHandleWorks) {
  function TEST (line 1227) | TEST(ParseNaturalNumberTest, RejectsInvalidFormat) {
  function TEST (line 1244) | TEST(ParseNaturalNumberTest, RejectsOverflownNumbers) {
  function TEST (line 1254) | TEST(ParseNaturalNumberTest, AcceptsValidNumbers) {
  function TEST (line 1271) | TEST(ParseNaturalNumberTest, AcceptsTypeLimits) {
  function TEST (line 1301) | TEST(ParseNaturalNumberTest, WorksForShorterIntegers) {
  function TEST (line 1312) | TEST(EnvironmentTest, HandleFitsIntoSizeT) {
  function TEST (line 1319) | TEST(ConditionalDeathMacrosDeathTest, ExpectsDeathWhenDeathTestsAvailabl...
  function TEST (line 1330) | TEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInFastStyle) {
  function TEST (line 1342) | TEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInThreadSafeSty...
  function DieWithMessage (line 1354) | void DieWithMessage(const char* message) {
  function TEST (line 1360) | TEST(MatcherDeathTest, DoesNotBreakBareRegexMatching) {
  function TEST (line 1370) | TEST(MatcherDeathTest, MonomorphicMatcherMatches) {
  function TEST (line 1375) | TEST(MatcherDeathTest, MonomorphicMatcherDoesNotMatch) {
  function TEST (line 1383) | TEST(MatcherDeathTest, PolymorphicMatcherMatches) {
  function TEST (line 1388) | TEST(MatcherDeathTest, PolymorphicMatcherDoesNotMatch) {
  function TEST (line 1407) | TEST(ConditionalDeathMacrosTest, WarnsWhenDeathTestsNotAvailable) {
  function FuncWithAssert (line 1436) | void FuncWithAssert(int* n) {
  function TEST (line 1443) | TEST(ConditionalDeathMacrosTest, AssertDeatDoesNotReturnhIfUnsupported) {
  function TEST (line 1467) | TEST(ConditionalDeathMacrosSyntaxDeathTest, SingleStatement) {
  function TEST (line 1492) | TEST(ConditionalDeathMacrosSyntaxDeathTest, SwitchStatement) {
  function TEST (line 1510) | TEST(NotADeathTest, Test) { SUCCEED(); }

FILE: googletest/test/googletest-death-test_ex_test.cc
  function TEST (line 50) | TEST(CxxExceptionDeathTest, ExceptionIsFailure) {
  class TestException (line 60) | class TestException : public std::exception {
  function TEST (line 65) | TEST(CxxExceptionDeathTest, PrintsMessageForStdExceptions) {
  function TEST (line 78) | TEST(SehExceptionDeasTest, CatchExceptionsDoesNotInterfere) {
  function main (line 87) | int main(int argc, char** argv) {

FILE: googletest/test/googletest-env-var-test.py
  function AssertEq (line 46) | def AssertEq(expected, actual):
  function SetEnvVar (line 53) | def SetEnvVar(env_var, value):
  function GetFlag (line 62) | def GetFlag(flag):
  function TestFlag (line 71) | def TestFlag(flag, test_val, default_val):
  class GTestEnvVarTest (line 81) | class GTestEnvVarTest(gtest_test_utils.TestCase):
    method testEnvVarAffectsFlag (line 83) | def testEnvVarAffectsFlag(self):
    method testXmlOutputFile (line 104) | def testXmlOutputFile(self):
    method testXmlOutputFileOverride (line 111) | def testXmlOutputFileOverride(self):

FILE: googletest/test/googletest-env-var-test_.cc
  type testing (line 40) | namespace testing {
    function TEST (line 45) | TEST(GTestEnvVarTest, Dummy) {}
    function PrintFlag (line 47) | void PrintFlag(const char* flag) {
  function main (line 120) | int main(int argc, char** argv) {

FILE: googletest/test/googletest-fail-if-no-test-linked-test-with-disabled-test_.cc
  function TEST (line 38) | TEST(SomeTest, DISABLED_Test1) {}

FILE: googletest/test/googletest-fail-if-no-test-linked-test-with-enabled-test_.cc
  function TEST (line 38) | TEST(SomeTest, Test1) {}

FILE: googletest/test/googletest-fail-if-no-test-linked-test.py
  class GTestFailIfNoTestLinkedTest (line 44) | class GTestFailIfNoTestLinkedTest(gtest_test_utils.TestCase):
    method Run (line 47) | def Run(self, program_name, flag=None, env=None):
    method testSucceedsIfNoTestLinkedAndFlagNotSpecified (line 66) | def testSucceedsIfNoTestLinkedAndFlagNotSpecified(self):
    method testSucceedsIfNoTestLinkedAndFlagNotSpecifiedWithWarningFile (line 72) | def testSucceedsIfNoTestLinkedAndFlagNotSpecifiedWithWarningFile(self):
    method testFailsIfNoTestLinkedAndFlagSpecified (line 85) | def testFailsIfNoTestLinkedAndFlagSpecified(self):
    method testSucceedsIfEnabledTestLinkedAndFlagNotSpecified (line 101) | def testSucceedsIfEnabledTestLinkedAndFlagNotSpecified(self):
    method testSucceedsIfEnabledTestLinkedAndFlagSpecified (line 116) | def testSucceedsIfEnabledTestLinkedAndFlagSpecified(self):
    method testSucceedsIfDisabledTestLinkedAndFlagNotSpecified (line 132) | def testSucceedsIfDisabledTestLinkedAndFlagNotSpecified(self):
    method testSucceedsIfDisabledTestLinkedAndFlagSpecified (line 147) | def testSucceedsIfDisabledTestLinkedAndFlagSpecified(self):

FILE: googletest/test/googletest-fail-if-no-test-selected-test.py
  class GTestFailIfNoTestSelectedTest (line 43) | class GTestFailIfNoTestSelectedTest(gtest_test_utils.TestCase):
    method Run (line 46) | def Run(self, program_name, flags=None, env=None):
    method testSucceedsWhenFlagIsNotSetAndOnlyDisabledTestsPresent (line 65) | def testSucceedsWhenFlagIsNotSetAndOnlyDisabledTestsPresent(self):
    method testFailsWhenFlagIsSetAndOnlyDisabledTestsPresent (line 71) | def testFailsWhenFlagIsSetAndOnlyDisabledTestsPresent(self):
    method testSucceedsWhenFlagIsSetAndEnabledTestsPresent (line 80) | def testSucceedsWhenFlagIsSetAndEnabledTestsPresent(self):

FILE: googletest/test/googletest-failfast-unittest.py
  function SetEnvVar (line 83) | def SetEnvVar(env_var, value):
  function RunAndReturnOutput (line 92) | def RunAndReturnOutput(test_suite=None, fail_fast=None, run_disabled=Fal...
  class GTestFailFastUnitTest (line 117) | class GTestFailFastUnitTest(gtest_test_utils.TestCase):
    method testDefaultBehavior (line 120) | def testDefaultBehavior(self):
    method testGoogletestFlag (line 126) | def testGoogletestFlag(self):
    method testGoogletestEnvVar (line 135) | def testGoogletestEnvVar(self):
    method testBazelEnvVar (line 151) | def testBazelEnvVar(self):
    method testFlagOverridesEnvVar (line 167) | def testFlagOverridesEnvVar(self):
    method testGoogletestEnvVarOverridesBazelEnvVar (line 178) | def testGoogletestEnvVarOverridesBazelEnvVar(self):
    method testEventListener (line 191) | def testEventListener(self):
    method assertXmlResultCount (line 226) | def assertXmlResultCount(self, result, count, xml):
    method assertXmlStatusCount (line 234) | def assertXmlStatusCount(self, status, count, xml):
    method assertFailFastXmlAndTxtOutput (line 242) | def assertFailFastXmlAndTxtOutput(
    method assertFailFastBehavior (line 269) | def assertFailFastBehavior(
    method assertNotFailFastBehavior (line 291) | def assertNotFailFastBehavior(
    method testFlag_HasFixtureTest (line 313) | def testFlag_HasFixtureTest(self):
    method testFlag_HasSimpleTest (line 330) | def testFlag_HasSimpleTest(self):
    method testFlag_HasParametersTest (line 347) | def testFlag_HasParametersTest(self):
    method testFlag_HasDisabledTest (line 364) | def testFlag_HasDisabledTest(self):
    method testFlag_HasDisabledRunDisabledTest (line 383) | def testFlag_HasDisabledRunDisabledTest(self):
    method testFlag_HasDisabledSuiteTest (line 402) | def testFlag_HasDisabledSuiteTest(self):
    method testFlag_HasDisabledSuiteRunDisabledTest (line 421) | def testFlag_HasDisabledSuiteRunDisabledTest(self):
    method testFlag_HasDeathTest (line 442) | def testFlag_HasDeathTest(self):

FILE: googletest/test/googletest-failfast-unittest_.cc
  class HasFixtureTest (line 45) | class HasFixtureTest : public testing::Test {}
  function TEST_F (line 47) | TEST_F(HasFixtureTest, Test0) {}
  function TEST_F (line 49) | TEST_F(HasFixtureTest, Test1) { FAIL() << "Expected failure."; }
  function TEST_F (line 51) | TEST_F(HasFixtureTest, Test2) { FAIL() << "Expected failure."; }
  function TEST_F (line 53) | TEST_F(HasFixtureTest, Test3) { FAIL() << "Expected failure."; }
  function TEST_F (line 55) | TEST_F(HasFixtureTest, Test4) { FAIL() << "Expected failure."; }
  function TEST (line 59) | TEST(HasSimpleTest, Test0) {}
  function TEST (line 61) | TEST(HasSimpleTest, Test1) { FAIL() << "Expected failure."; }
  function TEST (line 63) | TEST(HasSimpleTest, Test2) { FAIL() << "Expected failure."; }
  function TEST (line 65) | TEST(HasSimpleTest, Test3) { FAIL() << "Expected failure."; }
  function TEST (line 67) | TEST(HasSimpleTest, Test4) { FAIL() << "Expected failure."; }
  function TEST (line 71) | TEST(HasDisabledTest, Test0) {}
  function TEST (line 73) | TEST(HasDisabledTest, DISABLED_Test1) { FAIL() << "Expected failure."; }
  function TEST (line 75) | TEST(HasDisabledTest, Test2) { FAIL() << "Expected failure."; }
  function TEST (line 77) | TEST(HasDisabledTest, Test3) { FAIL() << "Expected failure."; }
  function TEST (line 79) | TEST(HasDisabledTest, Test4) { FAIL() << "Expected failure."; }
  function TEST (line 83) | TEST(HasDeathTest, Test0) { EXPECT_DEATH_IF_SUPPORTED(exit(1), ".*"); }
  function TEST (line 85) | TEST(HasDeathTest, Test1) {
  function TEST (line 89) | TEST(HasDeathTest, Test2) {
  function TEST (line 93) | TEST(HasDeathTest, Test3) {
  function TEST (line 97) | TEST(HasDeathTest, Test4) {
  function TEST (line 103) | TEST(DISABLED_HasDisabledSuite, Test0) {}
  function TEST (line 105) | TEST(DISABLED_HasDisabledSuite, Test1) { FAIL() << "Expected failure."; }
  function TEST (line 107) | TEST(DISABLED_HasDisabledSuite, Test2) { FAIL() << "Expected failure."; }
  function TEST (line 109) | TEST(DISABLED_HasDisabledSuite, Test3) { FAIL() << "Expected failure."; }
  function TEST (line 111) | TEST(DISABLED_HasDisabledSuite, Test4) { FAIL() << "Expected failure."; }
  class HasParametersTest (line 115) | class HasParametersTest : public testing::TestWithParam<int> {}
  function TEST_P (line 117) | TEST_P(HasParametersTest, Test1) { FAIL() << "Expected failure."; }
  function TEST_P (line 119) | TEST_P(HasParametersTest, Test2) { FAIL() << "Expected failure."; }
  class MyTestListener (line 124) | class MyTestListener : public ::testing::EmptyTestEventListener {
    method OnTestSuiteStart (line 125) | void OnTestSuiteStart(const ::testing::TestSuite& test_suite) override {
    method OnTestStart (line 129) | void OnTestStart(const ::testing::TestInfo& test_info) override {
    method OnTestPartResult (line 134) | void OnTestPartResult(
    method OnTestEnd (line 140) | void OnTestEnd(const ::testing::TestInfo& test_info) override {
    method OnTestSuiteEnd (line 145) | void OnTestSuiteEnd(const ::testing::TestSuite& test_suite) override {
  function TEST (line 150) | TEST(HasSkipTest, Test0) { SUCCEED() << "Expected success."; }
  function TEST (line 152) | TEST(HasSkipTest, Test1) { GTEST_SKIP() << "Expected skip."; }
  function TEST (line 154) | TEST(HasSkipTest, Test2) { FAIL() << "Expected failure."; }
  function TEST (line 156) | TEST(HasSkipTest, Test3) { FAIL() << "Expected failure."; }
  function TEST (line 158) | TEST(HasSkipTest, Test4) { FAIL() << "Expected failure."; }
  function main (line 162) | int main(int argc, char** argv) {

FILE: googletest/test/googletest-filepath-test.cc
  type testing (line 50) | namespace testing {
    type internal (line 51) | namespace internal {
      function remove (line 57) | int remove(const char* path) {
      function _rmdir (line 64) | int _rmdir(const char* path) {
      function TEST (line 75) | TEST(GetCurrentDirTest, ReturnsCurrentDir) {
      function TEST (line 99) | TEST(IsEmptyTest, ReturnsTrueForEmptyPath) {
      function TEST (line 103) | TEST(IsEmptyTest, ReturnsFalseForNonEmptyPath) {
      function TEST (line 111) | TEST(RemoveDirectoryNameTest, WhenEmptyName) {
      function TEST (line 116) | TEST(RemoveDirectoryNameTest, ButNoDirectory) {
      function TEST (line 121) | TEST(RemoveDirectoryNameTest, RootFileShouldGiveFileName) {
      function TEST (line 127) | TEST(RemoveDirectoryNameTest, WhereThereIsNoFileName) {
      function TEST (line 133) | TEST(RemoveDirectoryNameTest, ShouldGiveFileName) {
      function TEST (line 140) | TEST(RemoveDirectoryNameTest, ShouldAlsoGiveFileName) {
      function TEST (line 153) | TEST(RemoveDirectoryNameTest, RootFileShouldGiveFileNameForAlternate...
      function TEST (line 158) | TEST(RemoveDirectoryNameTest, WhereThereIsNoFileNameForAlternateSepa...
      function TEST (line 163) | TEST(RemoveDirectoryNameTest, ShouldGiveFileNameForAlternateSeparato...
      function TEST (line 168) | TEST(RemoveDirectoryNameTest, ShouldAlsoGiveFileNameForAlternateSepa...
      function TEST (line 176) | TEST(RemoveFileNameTest, EmptyName) {
      function TEST (line 186) | TEST(RemoveFileNameTest, ButNoFile) {
      function TEST (line 192) | TEST(RemoveFileNameTest, GivesDirName) {
      function TEST (line 198) | TEST(RemoveFileNameTest, GivesDirAndSubDirName) {
      function TEST (line 206) | TEST(RemoveFileNameTest, GivesRootDir) {
      function TEST (line 217) | TEST(RemoveFileNameTest, ButNoFileForAlternateSeparator) {
      function TEST (line 223) | TEST(RemoveFileNameTest, GivesDirNameForAlternateSeparator) {
      function TEST (line 229) | TEST(RemoveFileNameTest, GivesDirAndSubDirNameForAlternateSeparator) {
      function TEST (line 235) | TEST(RemoveFileNameTest, GivesRootDirForAlternateSeparator) {
      function TEST (line 241) | TEST(MakeFileNameTest, GenerateWhenNumberIsZero) {
      function TEST (line 247) | TEST(MakeFileNameTest, GenerateFileNameNumberGtZero) {
      function TEST (line 253) | TEST(MakeFileNameTest, GenerateFileNameWithSlashNumberIsZero) {
      function TEST (line 259) | TEST(MakeFileNameTest, GenerateFileNameWithSlashNumberGtZero) {
      function TEST (line 265) | TEST(MakeFileNameTest, GenerateWhenNumberIsZeroAndDirIsEmpty) {
      function TEST (line 271) | TEST(MakeFileNameTest, GenerateWhenNumberIsNotZeroAndDirIsEmpty) {
      function TEST (line 277) | TEST(ConcatPathsTest, WorksWhenDirDoesNotEndWithPathSep) {
      function TEST (line 282) | TEST(ConcatPathsTest, WorksWhenPath1EndsWithPathSep) {
      function TEST (line 288) | TEST(ConcatPathsTest, Path1BeingEmpty) {
      function TEST (line 293) | TEST(ConcatPathsTest, Path2BeingEmpty) {
      function TEST (line 298) | TEST(ConcatPathsTest, BothPathBeingEmpty) {
      function TEST (line 303) | TEST(ConcatPathsTest, Path1ContainsPathSep) {
      function TEST (line 310) | TEST(ConcatPathsTest, Path2ContainsPathSep) {
      function TEST (line 318) | TEST(ConcatPathsTest, Path2EndsWithPathSep) {
      function TEST (line 325) | TEST(RemoveTrailingPathSeparatorTest, EmptyString) {
      function TEST (line 330) | TEST(RemoveTrailingPathSeparatorTest, FileNoSlashString) {
      function TEST (line 335) | TEST(RemoveTrailingPathSeparatorTest, ShouldRemoveTrailingSeparator) {
      function TEST (line 345) | TEST(RemoveTrailingPathSeparatorTest, ShouldRemoveLastSeparator) {
      function TEST (line 353) | TEST(RemoveTrailingPathSeparatorTest, ShouldReturnUnmodified) {
      function TEST (line 359) | TEST(DirectoryTest, RootDirectoryExists) {
      function TEST (line 373) | TEST(DirectoryTest, RootOfWrongDriveDoesNotExists) {
      function TEST (line 392) | TEST(DirectoryTest, EmptyPathDirectoryDoesNotExist) {
      function TEST (line 397) | TEST(DirectoryTest, CurrentDirectoryExists) {
      function TEST (line 412) | TEST(NormalizeTest, MultipleConsecutiveSeparatorsInMidstring) {
      function TEST (line 424) | TEST(NormalizeTest, MultipleConsecutiveSeparatorsAtStringStart) {
      function TEST (line 439) | TEST(NormalizeTest, MultipleConsecutiveSeparatorsAtStringEnd) {
      function TEST (line 453) | TEST(NormalizeTest, MixAlternateSeparatorAtStringEnd) {
      function TEST (line 462) | TEST(AssignmentOperatorTest, DefaultAssignedToNonDefault) {
      function TEST (line 470) | TEST(AssignmentOperatorTest, NonDefaultAssignedToDefault) {
      function TEST (line 478) | TEST(AssignmentOperatorTest, ConstAssignedToNonConst) {
      class DirectoryCreationTest (line 485) | class DirectoryCreationTest : public Test {
        method SetUp (line 487) | void SetUp() override {
        method TearDown (line 504) | void TearDown() override {
        method CreateTextFile (line 511) | void CreateTextFile(const char* filename) {
      function TEST_F (line 526) | TEST_F(DirectoryCreationTest, CreateDirectoriesRecursively) {
      function TEST_F (line 532) | TEST_F(DirectoryCreationTest, CreateDirectoriesForAlreadyExistingPat...
      function TEST_F (line 539) | TEST_F(DirectoryCreationTest, CreateDirectoriesAndUniqueFilename) {
      function TEST_F (line 558) | TEST_F(DirectoryCreationTest, CreateDirectoriesFail) {
      function TEST (line 566) | TEST(NoDirectoryCreationTest, CreateNoDirectoriesForDefaultXmlFile) {
      function TEST (line 571) | TEST(FilePathTest, DefaultConstructor) {
      function TEST (line 576) | TEST(FilePathTest, CharAndCopyConstructors) {
      function TEST (line 584) | TEST(FilePathTest, StringConstructor) {
      function TEST (line 589) | TEST(FilePathTest, Set) {
      function TEST (line 597) | TEST(FilePathTest, ToString) {
      function TEST (line 602) | TEST(FilePathTest, RemoveExtension) {
      function TEST (line 608) | TEST(FilePathTest, RemoveExtensionWhenThereIsNoExtension) {
      function TEST (line 612) | TEST(FilePathTest, IsDirectory) {
      function TEST (line 620) | TEST(FilePathTest, IsAbsolutePath) {
      function TEST (line 640) | TEST(FilePathTest, IsRootDirectory) {

FILE: googletest/test/googletest-filter-unittest.py
  function SetEnvVar (line 186) | def SetEnvVar(env_var, value):
  function RunAndReturnOutput (line 195) | def RunAndReturnOutput(args=None):
  function RunAndExtractTestList (line 203) | def RunAndExtractTestList(args=None):
  function RunAndExtractDisabledBannerList (line 222) | def RunAndExtractDisabledBannerList(args=None):
  function InvokeWithModifiedEnv (line 233) | def InvokeWithModifiedEnv(extra_env, function, *args, **kwargs):
  function RunWithSharding (line 244) | def RunWithSharding(total_shards, shard_index, command):
  class GTestFilterUnitTest (line 257) | class GTestFilterUnitTest(gtest_test_utils.TestCase):
    method AssertSetEqual (line 262) | def AssertSetEqual(self, lhs, rhs):
    method AssertPartitionIsValid (line 271) | def AssertPartitionIsValid(self, set_var, list_of_sets):
    method AdjustForParameterizedTests (line 280) | def AdjustForParameterizedTests(self, tests_to_run):
    method RunAndVerify (line 289) | def RunAndVerify(self, gtest_filter, tests_to_run):
    method RunAndVerifyWithSharding (line 319) | def RunAndVerifyWithSharding(
    method RunAndVerifyAllowingDisabled (line 364) | def RunAndVerifyAllowingDisabled(self, gtest_filter, tests_to_run):
    method setUp (line 385) | def setUp(self):
    method testDefaultBehavior (line 398) | def testDefaultBehavior(self):
    method testDefaultBehaviorWithShards (line 403) | def testDefaultBehaviorWithShards(self):
    method testEmptyFilter (line 412) | def testEmptyFilter(self):
    method testBadFilter (line 419) | def testBadFilter(self):
    method testBadFilterWithWarningFile (line 425) | def testBadFilterWithWarningFile(self):
    method testFullName (line 441) | def testFullName(self):
    method testUniversalFilters (line 448) | def testUniversalFilters(self):
    method testFilterByTestCase (line 457) | def testFilterByTestCase(self):
    method testFilterByTest (line 468) | def testFilterByTest(self):
    method testFilterDisabledTests (line 473) | def testFilterDisabledTests(self):
    method testWildcardInTestCaseName (line 505) | def testWildcardInTestCaseName(self):
    method testWildcardInTestName (line 522) | def testWildcardInTestName(self):
    method testFilterWithoutDot (line 527) | def testFilterWithoutDot(self):
    method testTwoPatterns (line 540) | def testTwoPatterns(self):
    method testThreePatterns (line 555) | def testThreePatterns(self):
    method testNegativeFilters (line 589) | def testNegativeFilters(self):
    method testFlagOverridesEnvVar (line 662) | def testFlagOverridesEnvVar(self):
    method testShardStatusFileIsCreated (line 672) | def testShardStatusFileIsCreated(self):
    method testShardStatusFileIsCreatedWithListTests (line 687) | def testShardStatusFileIsCreatedWithListTests(self):
    method testDisabledBanner (line 715) | def testDisabledBanner(self):
    method testShardingWorksWithDeathTests (line 739) | def testShardingWorksWithDeathTests(self):

FILE: googletest/test/googletest-filter-unittest_.cc
  class FooTest (line 45) | class FooTest : public testing::Test {}
  function TEST_F (line 47) | TEST_F(FooTest, Abc) {}
  function TEST_F (line 49) | TEST_F(FooTest, Xyz) { FAIL() << "Expected failure."; }
  function TEST (line 53) | TEST(BarTest, TestOne) {}
  function TEST (line 55) | TEST(BarTest, TestTwo) {}
  function TEST (line 57) | TEST(BarTest, TestThree) {}
  function TEST (line 59) | TEST(BarTest, DISABLED_TestFour) { FAIL() << "Expected failure."; }
  function TEST (line 61) | TEST(BarTest, DISABLED_TestFive) { FAIL() << "Expected failure."; }
  function TEST (line 65) | TEST(BazTest, TestOne) { FAIL() << "Expected failure."; }
  function TEST (line 67) | TEST(BazTest, TestA) {}
  function TEST (line 69) | TEST(BazTest, TestB) {}
  function TEST (line 71) | TEST(BazTest, DISABLED_TestC) { FAIL() << "Expected failure."; }
  function TEST (line 75) | TEST(HasDeathTest, Test1) { EXPECT_DEATH_IF_SUPPORTED(exit(1), ".*"); }
  function TEST (line 79) | TEST(HasDeathTest, Test2) { EXPECT_DEATH_IF_SUPPORTED(exit(1), ".*"); }
  function TEST (line 83) | TEST(DISABLED_FoobarTest, Test1) { FAIL() << "Expected failure."; }
  function TEST (line 85) | TEST(DISABLED_FoobarTest, DISABLED_Test2) { FAIL() << "Expected failure....
  function TEST (line 89) | TEST(DISABLED_FoobarbazTest, TestA) { FAIL() << "Expected failure."; }
  class ParamTest (line 91) | class ParamTest : public testing::TestWithParam<int> {}
  function TEST_P (line 93) | TEST_P(ParamTest, TestX) {}
  function TEST_P (line 95) | TEST_P(ParamTest, TestY) {}
  function main (line 102) | int main(int argc, char **argv) {

FILE: googletest/test/googletest-global-environment-unittest.py
  function RunAndReturnOutput (line 42) | def RunAndReturnOutput(args=None):
  class GTestGlobalEnvironmentUnitTest (line 55) | class GTestGlobalEnvironmentUnitTest(gtest_test_utils.TestCase):
    method testEnvironmentSetUpFails (line 58) | def testEnvironmentSetUpFails(self):
    method testEnvironmentSetUpAndTornDownForEachRepeat (line 75) | def testEnvironmentSetUpAndTornDownForEachRepeat(self):
    method testEnvironmentSetUpAndTornDownOnce (line 106) | def testEnvironmentSetUpAndTornDownOnce(self):

FILE: googletest/test/googletest-global-environment-unittest_.cc
  class FailingEnvironment (line 40) | class FailingEnvironment final : public ::testing::Environment {
    method SetUp (line 42) | void SetUp() override { FAIL() << "Canned environment setup error"; }
  function TEST (line 50) | TEST(SomeTest, DoesFoo) { FAIL() << "Unexpected call"; }
  function main (line 54) | int main(int argc, char** argv) {

FILE: googletest/test/googletest-json-outfiles-test.py
  class GTestJsonOutFilesTest (line 116) | class GTestJsonOutFilesTest(gtest_test_utils.TestCase):
    method setUp (line 119) | def setUp(self):
    method tearDown (line 128) | def tearDown(self):
    method DeleteFilesAndDir (line 131) | def DeleteFilesAndDir(self):
    method testOutfile1 (line 145) | def testOutfile1(self):
    method testOutfile2 (line 148) | def testOutfile2(self):
    method _TestOutFile (line 151) | def _TestOutFile(self, test_name, expected):

FILE: googletest/test/googletest-json-output-unittest.py
  class GTestJsonOutputUnitTest (line 716) | class GTestJsonOutputUnitTest(gtest_test_utils.TestCase):
    method testNonEmptyJsonOutput (line 723) | def testNonEmptyJsonOutput(self):
    method testNoTestJsonOutput (line 731) | def testNoTestJsonOutput(self):
    method testTimestampValue (line 740) | def testTimestampValue(self):
    method testDefaultOutputFile (line 771) | def testDefaultOutputFile(self):
    method testSuppressedJsonOutput (line 798) | def testSuppressedJsonOutput(self):
    method testFilteredTestJsonOutput (line 834) | def testFilteredTestJsonOutput(self):
    method _GetJsonOutput (line 848) | def _GetJsonOutput(self, gtest_prog_name, extra_args, expected_exit_co...
    method _TestJsonOutput (line 885) | def _TestJsonOutput(

FILE: googletest/test/googletest-list-tests-unittest.py
  function Run (line 120) | def Run(args):
  class GTestListTestsUnitTest (line 131) | class GTestListTestsUnitTest(gtest_test_utils.TestCase):
    method RunAndVerify (line 134) | def RunAndVerify(self, flag_value, expected_output_re, other_flag):
    method testDefaultBehavior (line 186) | def testDefaultBehavior(self):
    method testFlag (line 191) | def testFlag(self):
    method testOverrideNonFilterFlags (line 201) | def testOverrideNonFilterFlags(self):
    method testWithFilterFlags (line 210) | def testWithFilterFlags(self):

FILE: googletest/test/googletest-list-tests-unittest_.cc
  function TEST (line 45) | TEST(Foo, Bar1) {}
  function TEST (line 47) | TEST(Foo, Bar2) {}
  function TEST (line 49) | TEST(Foo, DISABLED_Bar3) {}
  function TEST (line 51) | TEST(Abc, Xyz) {}
  function TEST (line 53) | TEST(Abc, Def) {}
  function TEST (line 55) | TEST(FooBar, Baz) {}
  class FooTest (line 57) | class FooTest : public testing::Test {}
  function TEST_F (line 59) | TEST_F(FooTest, Test1) {}
  function TEST_F (line 61) | TEST_F(FooTest, DISABLED_Test2) {}
  function TEST_F (line 63) | TEST_F(FooTest, Test3) {}
  function TEST (line 65) | TEST(FooDeathTest, Test1) {}
  class MyType (line 69) | class MyType {
    method MyType (line 71) | explicit MyType(const std::string& a_value) : value_(a_value) {}
  function PrintTo (line 80) | void PrintTo(const MyType& x, std::ostream* os) { *os << x.value(); }
  class ValueParamTest (line 82) | class ValueParamTest : public testing::TestWithParam<MyType> {}
  function TEST_P (line 84) | TEST_P(ValueParamTest, TestA) {}
  function TEST_P (line 86) | TEST_P(ValueParamTest, TestB) {}
  class VeryLoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooogName (line 103) | class
  class TypedTest (line 108) | class TypedTest : public testing::Test {}
  class MyArray (line 111) | class MyArray {}
  function TYPED_TEST (line 120) | TYPED_TEST(TypedTest, TestA) {}
  function TYPED_TEST (line 122) | TYPED_TEST(TypedTest, TestB) {}
  class TypeParamTest (line 127) | class TypeParamTest : public testing::Test {}
  function TYPED_TEST_P (line 131) | TYPED_TEST_P(TypeParamTest, TestA) {}
  function TYPED_TEST_P (line 133) | TYPED_TEST_P(TypeParamTest, TestB) {}
  function main (line 139) | int main(int argc, char** argv) {

FILE: googletest/test/googletest-listener-test.cc
  type testing (line 48) | namespace testing {
    type internal (line 49) | namespace internal {
      class EventRecordingListener (line 51) | class EventRecordingListener : public TestEventListener {
        method EventRecordingListener (line 53) | explicit EventRecordingListener(const char* name) : name_(name) {}
        method OnTestProgramStart (line 56) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {
        method OnTestIterationStart (line 60) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 68) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 72) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {
        method OnTestCaseStart (line 76) | void OnTestCaseStart(const TestCase& /*test_case*/) override {
        method OnTestStart (line 81) | void OnTestStart(const TestInfo& /*test_info*/) override {
        method OnTestPartResult (line 85) | void OnTestPartResult(const TestPartResult& /*test_part_result*/) ...
        method OnTestEnd (line 89) | void OnTestEnd(const TestInfo& /*test_info*/) override {
        method OnTestCaseEnd (line 94) | void OnTestCaseEnd(const TestCase& /*test_case*/) override {
        method OnEnvironmentsTearDownStart (line 99) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 103) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestIterationEnd (line 107) | void OnTestIterationEnd(const UnitTest& /*unit_test*/,
        method OnTestProgramEnd (line 115) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {
        method GetFullMethodName (line 120) | std::string GetFullMethodName(const char* name) { return name_ + "...
      class EventRecordingListener2 (line 126) | class EventRecordingListener2 : public TestEventListener {
        method EventRecordingListener2 (line 128) | explicit EventRecordingListener2(const char* name) : name_(name) {}
        method OnTestProgramStart (line 131) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {
        method OnTestIterationStart (line 135) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
        method OnEnvironmentsSetUpStart (line 143) | void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) overr...
        method OnEnvironmentsSetUpEnd (line 147) | void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {
        method OnTestSuiteStart (line 151) | void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {
        method OnTestStart (line 155) | void OnTestStart(const TestInfo& /*test_info*/) override {
        method OnTestPartResult (line 159) | void OnTestPartResult(const TestPartResult& /*test_part_result*/) ...
        method OnTestEnd (line 163) | void OnTestEnd(const TestInfo& /*test_info*/) override {
        method OnTestSuiteEnd (line 167) | void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {
        method OnEnvironmentsTearDownStart (line 171) | void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) ov...
        method OnEnvironmentsTearDownEnd (line 175) | void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) over...
        method OnTestIterationEnd (line 179) | void OnTestIterationEnd(const UnitTest& /*unit_test*/,
        method OnTestProgramEnd (line 187) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {
        method GetFullMethodName (line 192) | std::string GetFullMethodName(const char* name) { return name_ + "...
      class EnvironmentInvocationCatcher (line 197) | class EnvironmentInvocationCatcher : public Environment {
        method SetUp (line 199) | void SetUp() override { g_events->push_back("Environment::SetUp"); }
        method TearDown (line 201) | void TearDown() override { g_events->push_back("Environment::TearD...
      class ListenerTest (line 204) | class ListenerTest : public Test {
        method SetUpTestSuite (line 206) | static void SetUpTestSuite() {
        method TearDownTestSuite (line 210) | static void TearDownTestSuite() {
        method SetUp (line 214) | void SetUp() override { g_events->push_back("ListenerTest::SetUp"); }
        method TearDown (line 216) | void TearDown() override { g_events->push_back("ListenerTest::Tear...
      function TEST_F (line 219) | TEST_F(ListenerTest, DoesFoo) {
      function TEST_F (line 226) | TEST_F(ListenerTest, DoesBar) {
  function VerifyResults (line 239) | void VerifyResults(const std::vector<std::string>& data,
  function main (line 262) | int main(int argc, char** argv) {

FILE: googletest/test/googletest-message-test.cc
  type AbslStringifiablePoint (line 48) | struct AbslStringifiablePoint {
    method AbslStringify (line 50) | void AbslStringify(Sink& sink, const AbslStringifiablePoint& p) {
  function TEST (line 62) | TEST(MessageTest, DefaultConstructor) {
  function TEST (line 68) | TEST(MessageTest, CopyConstructor) {
  function TEST (line 75) | TEST(MessageTest, ConstructsFromCString) {
  function TEST (line 81) | TEST(MessageTest, StreamsFloat) {
  function TEST (line 89) | TEST(MessageTest, StreamsDouble) {
  function TEST (line 99) | TEST(MessageTest, StreamsPointer) {
  function TEST (line 106) | TEST(MessageTest, StreamsNullPointer) {
  function TEST (line 112) | TEST(MessageTest, StreamsCString) {
  function TEST (line 117) | TEST(MessageTest, StreamsNullCString) {
  function TEST (line 123) | TEST(MessageTest, StreamsString) {
  function TEST (line 129) | TEST(MessageTest, StreamsStringWithEmbeddedNUL) {
  function TEST (line 138) | TEST(MessageTest, StreamsNULChar) {
  function TEST (line 143) | TEST(MessageTest, StreamsInt) {
  function TEST (line 149) | TEST(MessageTest, StreamsAbslStringify) {
  function TEST (line 156) | TEST(MessageTest, StreamsBasicIoManip) {
  function TEST (line 165) | TEST(MessageTest, GetString) {
  function TEST (line 172) | TEST(MessageTest, StreamsToOStream) {
  function TEST (line 180) | TEST(MessageTest, DoesNotTakeUpMuchStackSpace) {

FILE: googletest/test/googletest-options-test.cc
  type testing (line 54) | namespace testing {
    type internal (line 55) | namespace internal {
      function FilePath (line 59) | FilePath GetAbsolutePathOf(const FilePath& relative_path) {
      function TEST (line 65) | TEST(XmlOutputTest, GetOutputFormatDefault) {
      function TEST (line 70) | TEST(XmlOutputTest, GetOutputFormat) {
      function TEST (line 75) | TEST(XmlOutputTest, GetOutputFileDefault) {
      function TEST (line 81) | TEST(XmlOutputTest, GetOutputFileSingleFile) {
      function TEST (line 87) | TEST(XmlOutputTest, GetOutputFileFromDirectoryPath) {
      function TEST (line 102) | TEST(OutputFileHelpersTest, GetCurrentExecutableName) {
      class XmlOutputChangeDirTest (line 131) | class XmlOutputChangeDirTest : public Test {
        method SetUp (line 133) | void SetUp() override {
        method TearDown (line 141) | void TearDown() override {
      function TEST_F (line 148) | TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithDefault) {
      function TEST_F (line 156) | TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithDefault...
      function TEST_F (line 164) | TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativ...
      function TEST_F (line 172) | TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativ...
      function TEST_F (line 189) | TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsolut...
      function TEST_F (line 201) | TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsolut...

FILE: googletest/test/googletest-output-test.py
  function ToUnixLineEnding (line 96) | def ToUnixLineEnding(s):
  function RemoveLocations (line 102) | def RemoveLocations(test_output):
  function RemoveStackTraceDetails (line 122) | def RemoveStackTraceDetails(output):
  function RemoveStackTraces (line 131) | def RemoveStackTraces(output):
  function RemoveTime (line 138) | def RemoveTime(output):
  function RemoveTypeInfoDetails (line 144) | def RemoveTypeInfoDetails(test_output):
  function NormalizeToCurrentPlatform (line 158) | def NormalizeToCurrentPlatform(test_output):
  function RemoveTestCounts (line 172) | def RemoveTestCounts(output):
  function RemoveMatchingTests (line 184) | def RemoveMatchingTests(test_output, pattern):
  function NormalizeOutput (line 208) | def NormalizeOutput(output):
  function GetShellCommandOutput (line 218) | def GetShellCommandOutput(env_cmd):
  function GetCommandOutput (line 239) | def GetCommandOutput(env_cmd):
  function GetOutputOfAllCommands (line 259) | def GetOutputOfAllCommands():
  class GTestOutputTest (line 284) | class GTestOutputTest(gtest_test_utils.TestCase):
    method RemoveUnsupportedTests (line 286) | def RemoveUnsupportedTests(self, test_output):
    method testOutput (line 306) | def testOutput(self):

FILE: googletest/test/googletest-output-test_.cc
  function TestEq1 (line 60) | void TestEq1(int x) { ASSERT_EQ(1, x); }
  function TryTestSubroutine (line 64) | void TryTestSubroutine() {
  function TEST (line 78) | TEST(PassingTest, PassingTest1) {}
  function TEST (line 80) | TEST(PassingTest, PassingTest2) {}
  class FailingParamTest (line 84) | class FailingParamTest : public testing::TestWithParam<int> {}
  function TEST_P (line 86) | TEST_P(FailingParamTest, Fails) { EXPECT_EQ(1, GetParam()); }
  class EmptyBasenameParamInst (line 95) | class EmptyBasenameParamInst : public testing::TestWithParam<int> {}
  function TEST_P (line 97) | TEST_P(EmptyBasenameParamInst, Passes) { EXPECT_EQ(1, GetParam()); }
  function TEST (line 103) | TEST(NonfatalFailureTest, EscapesStringOperands) {
  function TEST (line 111) | TEST(NonfatalFailureTest, DiffForLongStrings) {
  function TEST (line 117) | TEST(FatalFailureTest, FatalFailureInSubroutine) {
  function TEST (line 124) | TEST(FatalFailureTest, FatalFailureInNestedSubroutine) {
  function TEST (line 141) | TEST(FatalFailureTest, NonfatalFailureInSubroutine) {
  function TEST (line 148) | TEST(LoggingTest, InterleavingLoggingAndAssertions) {
  function SubWithoutTrace (line 161) | void SubWithoutTrace(int n) {
  function SubWithTrace (line 167) | void SubWithTrace(int n) {
  function TEST (line 173) | TEST(SCOPED_TRACETest, AcceptedValues) {
  function TEST (line 184) | TEST(SCOPED_TRACETest, ObeysScopes) {
  function TEST (line 203) | TEST(SCOPED_TRACETest, WorksInLoop) {
  function TEST (line 214) | TEST(SCOPED_TRACETest, WorksInSubroutine) {
  function TEST (line 222) | TEST(SCOPED_TRACETest, CanBeNested) {
  function TEST (line 231) | TEST(SCOPED_TRACETest, CanBeRepeated) {
  type CheckPoints (line 283) | struct CheckPoints {
  function ThreadWithScopedTrace (line 289) | static void ThreadWithScopedTrace(CheckPoints* check_points) {
  function TEST (line 303) | TEST(SCOPED_TRACETest, WorksConcurrently) {
  function TEST (line 327) | TEST(ScopedTraceTest, WithExplicitFileAndLine) {
  function TEST (line 332) | TEST(DisabledTestsWarningTest,
  function AdHocTest (line 343) | void AdHocTest() {
  function RunAllTests (line 350) | int RunAllTests() {
  class NonFatalFailureInFixtureConstructorTest (line 356) | class NonFatalFailureInFixtureConstructorTest : public testing::Test {
    method NonFatalFailureInFixtureConstructorTest (line 358) | NonFatalFailureInFixtureConstructorTest() {
    method SetUp (line 367) | void SetUp() override { ADD_FAILURE() << "Expected failure #2, in SetU...
    method TearDown (line 369) | void TearDown() override {
  function TEST_F (line 374) | TEST_F(NonFatalFailureInFixtureConstructorTest, FailureInConstructor) {
  class FatalFailureInFixtureConstructorTest (line 379) | class FatalFailureInFixtureConstructorTest : public testing::Test {
    method FatalFailureInFixtureConstructorTest (line 381) | FatalFailureInFixtureConstructorTest() {
    method SetUp (line 390) | void SetUp() override {
    method TearDown (line 396) | void TearDown() override {
    method Init (line 403) | void Init() { FAIL() << "Expected failure #1, in the test fixture c'to...
  function TEST_F (line 406) | TEST_F(FatalFailureInFixtureConstructorTest, FailureInConstructor) {
  class NonFatalFailureInSetUpTest (line 413) | class NonFatalFailureInSetUpTest : public testing::Test {
    method SetUp (line 417) | void SetUp() override {
    method TearDown (line 422) | void TearDown() override { FAIL() << "Expected failure #3, in TearDown...
    method Deinit (line 425) | void Deinit() { FAIL() << "Expected failure #4, in the test fixture d'...
  function TEST_F (line 428) | TEST_F(NonFatalFailureInSetUpTest, FailureInSetUp) {
  class FatalFailureInSetUpTest (line 433) | class FatalFailureInSetUpTest : public testing::Test {
    method SetUp (line 437) | void SetUp() override {
    method TearDown (line 442) | void TearDown() override { FAIL() << "Expected failure #2, in TearDown...
    method Deinit (line 445) | void Deinit() { FAIL() << "Expected failure #3, in the test fixture d'...
  function TEST_F (line 448) | TEST_F(FatalFailureInSetUpTest, FailureInSetUp) {
  function TEST (line 453) | TEST(AddFailureAtTest, MessageContainsSpecifiedFileAndLineNumber) {
  function TEST (line 457) | TEST(GtestFailAtTest, MessageContainsSpecifiedFileAndLineNumber) {
  type foo (line 471) | namespace foo {
    class MixedUpTestSuiteTest (line 473) | class MixedUpTestSuiteTest : public testing::Test {}
    function TEST_F (line 475) | TEST_F(MixedUpTestSuiteTest, FirstTestFromNamespaceFoo) {}
    function TEST_F (line 476) | TEST_F(MixedUpTestSuiteTest, SecondTestFromNamespaceFoo) {}
    class MixedUpTestSuiteWithSameTestNameTest (line 478) | class MixedUpTestSuiteWithSameTestNameTest : public testing::Test {}
    function TEST_F (line 480) | TEST_F(MixedUpTestSuiteWithSameTestNameTest,
  type bar (line 485) | namespace bar {
    class MixedUpTestSuiteTest (line 487) | class MixedUpTestSuiteTest : public testing::Test {}
    function TEST_F (line 491) | TEST_F(MixedUpTestSuiteTest, ThisShouldFail) {}
    function TEST_F (line 492) | TEST_F(MixedUpTestSuiteTest, ThisShouldFailToo) {}
    class MixedUpTestSuiteWithSameTestNameTest (line 494) | class MixedUpTestSuiteWithSameTestNameTest : public testing::Test {}
    function TEST_F (line 498) | TEST_F(MixedUpTestSuiteWithSameTestNameTest,
  class TEST_F_before_TEST_in_same_test_case (line 508) | class TEST_F_before_TEST_in_same_test_case : public testing::Test {}
  function TEST_F (line 510) | TEST_F(TEST_F_before_TEST_in_same_test_case, DefinedUsingTEST_F) {}
  function TEST (line 514) | TEST(TEST_F_before_TEST_in_same_test_case, DefinedUsingTESTAndShouldFail...
  class TEST_before_TEST_F_in_same_test_case (line 516) | class TEST_before_TEST_F_in_same_test_case : public testing::Test {}
  function TEST (line 518) | TEST(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST) {}
  function TEST_F (line 522) | TEST_F(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST_FAndShould...
  function TEST (line 528) | TEST(ExpectNonfatalFailureTest, CanReferenceGlobalVariables) {
  function TEST (line 537) | TEST(ExpectNonfatalFailureTest, CanReferenceLocalVariables) {
  function TEST (line 547) | TEST(ExpectNonfatalFailureTest, SucceedsWhenThereIsOneNonfatalFailure) {
  function TEST (line 554) | TEST(ExpectNonfatalFailureTest, FailsWhenThereIsNoNonfatalFailure) {
  function TEST (line 561) | TEST(ExpectNonfatalFailureTest, FailsWhenThereAreTwoNonfatalFailures) {
  function TEST (line 573) | TEST(ExpectNonfatalFailureTest, FailsWhenThereIsOneFatalFailure) {
  function TEST (line 580) | TEST(ExpectNonfatalFailureTest, FailsWhenStatementReturns) {
  function TEST (line 589) | TEST(ExpectNonfatalFailureTest, FailsWhenStatementThrows) {
  function TEST (line 600) | TEST(ExpectFatalFailureTest, CanReferenceGlobalVariables) {
  function TEST (line 609) | TEST(ExpectFatalFailureTest, CanReferenceLocalStaticVariables) {
  function TEST (line 618) | TEST(ExpectFatalFailureTest, SucceedsWhenThereIsOneFatalFailure) {
  function TEST (line 625) | TEST(ExpectFatalFailureTest, FailsWhenThereIsNoFatalFailure) {
  function FatalFailure (line 631) | void FatalFailure() { FAIL() << "Expected fatal failure."; }
  function TEST (line 635) | TEST(ExpectFatalFailureTest, FailsWhenThereAreTwoFatalFailures) {
  function TEST (line 647) | TEST(ExpectFatalFailureTest, FailsWhenThereIsOneNonfatalFailure) {
  function TEST (line 654) | TEST(ExpectFatalFailureTest, FailsWhenStatementReturns) {
  function TEST (line 663) | TEST(ExpectFatalFailureTest, FailsWhenStatementThrows) {
  function ParamNameFunc (line 675) | std::string ParamNameFunc(const testing::TestParamInfo<std::string>& inf...
  class ParamTest (line 679) | class ParamTest : public testing::TestWithParam<std::string> {}
  function TEST_P (line 681) | TEST_P(ParamTest, Success) { EXPECT_EQ("a", GetParam()); }
  function TEST_P (line 683) | TEST_P(ParamTest, Failure) { EXPECT_EQ("b", GetParam()) << "Expected fai...
  class DetectNotInstantiatedTest (line 693) | class DetectNotInstantiatedTest : public testing::TestWithParam<int> {}
  function TEST_P (line 694) | TEST_P(DetectNotInstantiatedTest, Used) {}
  class TypedTest (line 700) | class TypedTest : public testing::Test {}
  function TYPED_TEST (line 704) | TYPED_TEST(TypedTest, Success) { EXPECT_EQ(0, TypeParam()); }
  function TYPED_TEST (line 706) | TYPED_TEST(TypedTest, Failure) {
  class TypedTestWithNames (line 713) | class TypedTestWithNames : public testing::Test {}
  class TypedTestNames (line 715) | class TypedTestNames {
    method GetName (line 718) | static std::string GetName(int i) {
  function TYPED_TEST (line 728) | TYPED_TEST(TypedTestWithNames, Success) {}
  function TYPED_TEST (line 730) | TYPED_TEST(TypedTestWithNames, Failure) { FAIL(); }
  class TypedTestP (line 733) | class TypedTestP : public testing::Test {}
  function TYPED_TEST_P (line 737) | TYPED_TEST_P(TypedTestP, Success) { EXPECT_EQ(0U, TypeParam()); }
  function TYPED_TEST_P (line 739) | TYPED_TEST_P(TypedTestP, Failure) {
  class TypedTestPNames (line 748) | class TypedTestPNames {
    method GetName (line 751) | static std::string GetName(int i) {
  class DetectNotInstantiatedTypesTest (line 765) | class DetectNotInstantiatedTypesTest : public testing::Test {}
  function TYPED_TEST_P (line 767) | TYPED_TEST_P(DetectNotInstantiatedTypesTest, Used) {
  function TEST (line 784) | TEST(ADeathTest, ShouldRunFirst) {}
  class ATypedDeathTest (line 790) | class ATypedDeathTest : public testing::Test {}
  function TYPED_TEST (line 795) | TYPED_TEST(ATypedDeathTest, ShouldRunFirst) {}
  class ATypeParamDeathTest (line 801) | class ATypeParamDeathTest : public testing::Test {}
  function TYPED_TEST_P (line 805) | TYPED_TEST_P(ATypeParamDeathTest, ShouldRunFirst) {}
  class ExpectFailureTest (line 815) | class ExpectFailureTest : public testing::Test {
    type FailureMode (line 817) | enum FailureMode { FATAL_FAILURE, NONFATAL_FAILURE }
    method AddFailure (line 818) | static void AddFailure(FailureMode failure) {
  function TEST_F (line 827) | TEST_F(ExpectFailureTest, ExpectFatalFailure) {
  function TEST_F (line 843) | TEST_F(ExpectFailureTest, ExpectNonFatalFailure) {
  class ExpectFailureWithThreadsTest (line 859) | class ExpectFailureWithThreadsTest : public ExpectFailureTest {
    method AddFailureInOtherThread (line 861) | static void AddFailureInOtherThread(FailureMode failure) {
  function TEST_F (line 867) | TEST_F(ExpectFailureWithThreadsTest, ExpectFatalFailure) {
  function TEST_F (line 874) | TEST_F(ExpectFailureWithThreadsTest, ExpectNonFatalFailure) {
  function TEST_F (line 885) | TEST_F(ScopedFakeTestPartResultReporterTest, InterceptOnlyCurrentThread) {
  function TEST_F (line 901) | TEST_F(ExpectFailureTest, ExpectFatalFailureOnAllThreads) {
  function TEST_F (line 915) | TEST_F(ExpectFailureTest, ExpectNonFatalFailureOnAllThreads) {
  class DynamicFixture (line 931) | class DynamicFixture : public testing::Test {
    method DynamicFixture (line 933) | DynamicFixture() { printf("DynamicFixture()\n"); }
    method SetUp (line 935) | void SetUp() override { printf("DynamicFixture::SetUp\n"); }
    method TearDown (line 936) | void TearDown() override { printf("DynamicFixture::TearDown\n"); }
    method SetUpTestSuite (line 938) | static void SetUpTestSuite() { printf("DynamicFixture::SetUpTestSuite\...
    method TearDownTestSuite (line 939) | static void TearDownTestSuite() {
  class DynamicTest (line 945) | class DynamicTest : public DynamicFixture {
    method TestBody (line 947) | void TestBody() override { EXPECT_TRUE(Pass); }
  class FooEnvironment (line 984) | class FooEnvironment : public testing::Environment {
    method SetUp (line 986) | void SetUp() override { printf("%s", "FooEnvironment::SetUp() called.\...
    method TearDown (line 988) | void TearDown() override {
  class BarEnvironment (line 994) | class BarEnvironment : public testing::Environment {
    method SetUp (line 996) | void SetUp() override { printf("%s", "BarEnvironment::SetUp() called.\...
    method TearDown (line 998) | void TearDown() override {
  class TestSuiteThatFailsToSetUp (line 1004) | class TestSuiteThatFailsToSetUp : public testing::Test {
    method SetUpTestSuite (line 1006) | static void SetUpTestSuite() { EXPECT_TRUE(false); }
  function TEST_F (line 1008) | TEST_F(TestSuiteThatFailsToSetUp, ShouldNotRun) { std::abort(); }
  class TestSuiteThatSkipsInSetUp (line 1010) | class TestSuiteThatSkipsInSetUp : public testing::Test {
    method SetUpTestSuite (line 1012) | static void SetUpTestSuite() { GTEST_SKIP() << "Skip entire test suite...
  function TEST_F (line 1014) | TEST_F(TestSuiteThatSkipsInSetUp, ShouldNotRun) { std::abort(); }
  function main (line 1021) | int main(int argc, char** argv) {

FILE: googletest/test/googletest-param-test-invalid-name1-test.py
  function Assert (line 39) | def Assert(condition):
  function TestExitCodeAndOutput (line 44) | def TestExitCodeAndOutput(command):
  class GTestParamTestInvalidName1Test (line 56) | class GTestParamTestInvalidName1Test(gtest_test_utils.TestCase):
    method testExitCodeAndOutput (line 58) | def testExitCodeAndOutput(self):

FILE: googletest/test/googletest-param-test-invalid-name1-test_.cc
  class DummyTest (line 33) | class DummyTest : public ::testing::TestWithParam<const char *> {}
  function TEST_P (line 35) | TEST_P(DummyTest, Dummy) {}
  function main (line 43) | int main(int argc, char *argv[]) {

FILE: googletest/test/googletest-param-test-invalid-name2-test.py
  function Assert (line 39) | def Assert(condition):
  function TestExitCodeAndOutput (line 44) | def TestExitCodeAndOutput(command):
  class GTestParamTestInvalidName2Test (line 56) | class GTestParamTestInvalidName2Test(gtest_test_utils.TestCase):
    method testExitCodeAndOutput (line 58) | def testExitCodeAndOutput(self):

FILE: googletest/test/googletest-param-test-invalid-name2-test_.cc
  class DummyTest (line 35) | class DummyTest : public ::testing::TestWithParam<const char *> {}
  function StringParamTestSuffix (line 37) | std::string StringParamTestSuffix(
  function TEST_P (line 42) | TEST_P(DummyTest, Dummy) {}
  function main (line 49) | int main(int argc, char *argv[]) {

FILE: googletest/test/googletest-param-test-test.cc
  function PrintValue (line 77) | ::std::string PrintValue(const T& value) {
  function VerifyGenerator (line 85) | void VerifyGenerator(const ParamGenerator<T>& generator,
  function VerifyGeneratorIsEmpty (line 125) | void VerifyGeneratorIsEmpty(const ParamGenerator<T>& generator) {
  function TEST (line 142) | TEST(IteratorTest, ParamIteratorConformsToForwardIteratorConcept) {
  function TEST (line 177) | TEST(RangeTest, IntRangeWithDefaultStep) {
  function TEST (line 185) | TEST(RangeTest, IntRangeSingleValue) {
  function TEST (line 193) | TEST(RangeTest, IntRangeEmpty) {
  function TEST (line 200) | TEST(RangeTest, IntRangeWithCustomStep) {
  function TEST (line 210) | TEST(RangeTest, IntRangeWithCustomStepOverUpperBound) {
  class DogAdder (line 218) | class DogAdder {
    method DogAdder (line 220) | explicit DogAdder(const char* a_value) : value_(a_value) {}
    method DogAdder (line 221) | DogAdder(const DogAdder& other) : value_(other.value_.c_str()) {}
    method DogAdder (line 223) | DogAdder operator=(const DogAdder& other) {
    method DogAdder (line 227) | DogAdder operator+(const DogAdder& other) const {
  function TEST (line 239) | TEST(RangeTest, WorksWithACustomType) {
  class IntWrapper (line 253) | class IntWrapper {
    method IntWrapper (line 255) | explicit IntWrapper(int a_value) : value_(a_value) {}
    method IntWrapper (line 256) | IntWrapper(const IntWrapper& other) : value_(other.value_) {}
    method IntWrapper (line 258) | IntWrapper operator=(const IntWrapper& other) {
    method IntWrapper (line 263) | IntWrapper operator+(int other) const { return IntWrapper(value_ + oth...
    method value (line 267) | int value() const { return value_; }
  function TEST (line 273) | TEST(RangeTest, WorksWithACustomTypeWithDifferentIncrementType) {
  function TEST (line 288) | TEST(ValuesInTest, ValuesInArray) {
  function TEST (line 296) | TEST(ValuesInTest, ValuesInConstArray) {
  function TEST (line 304) | TEST(ValuesInTest, ValuesInSingleElementArray) {
  function TEST (line 312) | TEST(ValuesInTest, ValuesInVector) {
  function TEST (line 325) | TEST(ValuesInTest, ValuesInIteratorRange) {
  function TEST (line 339) | TEST(ValuesInTest, ValuesInSingleElementIteratorRange) {
  function TEST (line 351) | TEST(ValuesInTest, ValuesInEmptyIteratorRange) {
  function TEST (line 360) | TEST(ValuesTest, ValuesWorks) {
  function TEST (line 369) | TEST(ValuesTest, ValuesWorksForValuesOfCompatibleTypes) {
  function TEST (line 376) | TEST(ValuesTest, ValuesWorksForMaxLengthList) {
  function TEST (line 393) | TEST(ValuesTest, ValuesWithSingleParameter) {
  function TEST (line 401) | TEST(BoolTest, BoolWorks) {
  function TEST (line 409) | TEST(CombineTest, CombineWithTwoParameters) {
  function TEST (line 422) | TEST(CombineTest, CombineWithThreeParameters) {
  function TEST (line 436) | TEST(CombineTest, CombineWithFirstParameterSingleValue) {
  function TEST (line 448) | TEST(CombineTest, CombineWithSecondParameterSingleValue) {
  function TEST (line 459) | TEST(CombineTest, CombineWithFirstParameterEmptyRange) {
  function TEST (line 467) | TEST(CombineTest, CombineWithSecondParameterEmptyRange) {
  function TEST (line 475) | TEST(CombineTest, CombineWithMaxNumberOfParameters) {
  class NonDefaultConstructAssignString (line 490) | class NonDefaultConstructAssignString {
    method NonDefaultConstructAssignString (line 492) | NonDefaultConstructAssignString(const std::string& s) : str_(s) {}
    method NonDefaultConstructAssignString (line 493) | NonDefaultConstructAssignString() = delete;
    method NonDefaultConstructAssignString (line 494) | NonDefaultConstructAssignString(const NonDefaultConstructAssignString&) =
    method NonDefaultConstructAssignString (line 496) | NonDefaultConstructAssignString& operator=(
  function TEST (line 506) | TEST(CombineTest, NonDefaultConstructAssign) {
  class ConstructFromT (line 534) | class ConstructFromT {
    method ConstructFromT (line 536) | explicit ConstructFromT(const T& t) : t_(t) {}
    method ConstructFromT (line 539) | ConstructFromT(Args&&... args) : t_(std::forward<Args>(args)...) {}
    method T (line 543) | const T& get() const { return t_; }
  function TEST (line 549) | TEST(ConvertTest, CombineWithTwoParameters) {
  function TEST (line 561) | TEST(ConvertTest, NonDefaultConstructAssign) {
  function TEST (line 591) | TEST(ConvertTest, WithConverterLambdaAndDeducedType) {
  function TEST (line 605) | TEST(ConvertTest, WithConverterLambdaAndExplicitType) {
  function TEST (line 625) | TEST(ConvertTest, WithConverterFunctionPointer) {
  function TEST (line 640) | TEST(ConvertTest, WithConverterFunctionReference) {
  function TEST (line 658) | TEST(ParamGeneratorTest, AssignmentWorks) {
  class TestGenerationEnvironment (line 677) | class TestGenerationEnvironment : public ::testing::Environment {
    method TestGenerationEnvironment (line 679) | static TestGenerationEnvironment* Instance() {
    method FixtureConstructorExecuted (line 684) | void FixtureConstructorExecuted() { fixture_constructor_count_++; }
    method SetUpExecuted (line 685) | void SetUpExecuted() { set_up_count_++; }
    method TearDownExecuted (line 686) | void TearDownExecuted() { tear_down_count_++; }
    method TestBodyExecuted (line 687) | void TestBodyExecuted() { test_body_count_++; }
    method TearDown (line 689) | void TearDown() override {
    method TestGenerationEnvironment (line 720) | TestGenerationEnvironment()
    method TestGenerationEnvironment (line 731) | TestGenerationEnvironment(const TestGenerationEnvironment&) = delete;
    method TestGenerationEnvironment (line 732) | TestGenerationEnvironment& operator=(const TestGenerationEnvironment&) =
  class TestGenerationTest (line 738) | class TestGenerationTest : public TestWithParam<int> {
    method TestGenerationTest (line 747) | TestGenerationTest() {
    method SetUp (line 751) | void SetUp() override {
    method TearDown (line 755) | void TearDown() override {
    method SetUpTestSuite (line 760) | static void SetUpTestSuite() {
    method TearDownTestSuite (line 781) | static void TearDownTestSuite() {
    method TestGenerationTest (line 798) | TestGenerationTest(const TestGenerationTest&) = delete;
    method TestGenerationTest (line 799) | TestGenerationTest& operator=(const TestGenerationTest&) = delete;
  function TEST_P (line 803) | TEST_P(TestGenerationTest, TestsExpandedAndRun) {
  class GeneratorEvaluationTest (line 821) | class GeneratorEvaluationTest : public TestWithParam<int> {
    method param_value (line 823) | static int param_value() { return param_value_; }
    method set_param_value (line 824) | static void set_param_value(int param_value) { param_value_ = param_va...
  function TEST_P (line 831) | TEST_P(GeneratorEvaluationTest, GeneratorsEvaluatedInMain) {
  class ExternalGeneratorTest (line 840) | class ExternalGeneratorTest : public TestWithParam<int> {}
  function TEST_P (line 841) | TEST_P(ExternalGeneratorTest, ExternalGenerator) {
  function TEST_P (line 853) | TEST_P(ExternalInstantiationTest, IsMultipleOf33) {
  class MultipleInstantiationTest (line 859) | class MultipleInstantiationTest : public TestWithParam<int> {}
  function TEST_P (line 860) | TEST_P(MultipleInstantiationTest, AllowsMultipleInstances) {}
  function TEST_P (line 869) | TEST_P(InstantiationInMultipleTranslationUnitsTest, IsMultipleOf42) {
  class SeparateInstanceTest (line 877) | class SeparateInstanceTest : public TestWithParam<int> {
    method SeparateInstanceTest (line 879) | SeparateInstanceTest() : count_(0) {}
    method TearDownTestSuite (line 881) | static void TearDownTestSuite() {
  function TEST_P (line 895) | TEST_P(SeparateInstanceTest, TestsRunInSeparateInstances) {
  class NamingTest (line 906) | class NamingTest : public TestWithParam<int> {}
  function TEST_P (line 908) | TEST_P(NamingTest, TestsReportCorrectNamesAndParameters) {
  class MacroNamingTest (line 924) | class MacroNamingTest : public TestWithParam<int> {}
  function TEST_P (line 929) | TEST_P(PREFIX_WITH_MACRO(NamingTest), PREFIX_WITH_FOO(SomeTestName)) {
  class MacroNamingTestNonParametrized (line 940) | class MacroNamingTestNonParametrized : public ::testing::Test {}
  function TEST_F (line 942) | TEST_F(PREFIX_WITH_MACRO(NamingTestNonParametrized),
  function TEST (line 951) | TEST(MacroNameing, LookupNames) {
  class CustomFunctorNamingTest (line 984) | class CustomFunctorNamingTest : public TestWithParam<std::string> {}
  function TEST_P (line 985) | TEST_P(CustomFunctorNamingTest, CustomTestNames) {}
  type CustomParamNameFunctor (line 987) | struct CustomParamNameFunctor {
  function CustomParamNameFunction (line 1002) | inline std::string CustomParamNameFunction(
  class CustomFunctionNamingTest (line 1007) | class CustomFunctionNamingTest : public TestWithParam<std::string> {}
  function TEST_P (line 1008) | TEST_P(CustomFunctionNamingTest, CustomTestNames) {}
  class CustomLambdaNamingTest (line 1020) | class CustomLambdaNamingTest : public TestWithParam<std::string> {}
  function TEST_P (line 1021) | TEST_P(CustomLambdaNamingTest, CustomTestNames) {}
  function TEST (line 1029) | TEST(CustomNamingTest, CheckNameRegistry) {
  class CustomIntegerNamingTest (line 1049) | class CustomIntegerNamingTest : public TestWithParam<int> {}
  function TEST_P (line 1051) | TEST_P(CustomIntegerNamingTest, TestsReportCorrectNames) {
  type CustomStruct (line 1064) | struct CustomStruct {
    method CustomStruct (line 1065) | explicit CustomStruct(int value) : x(value) {}
  class CustomStructNamingTest (line 1074) | class CustomStructNamingTest : public TestWithParam<CustomStruct> {}
  function TEST_P (line 1076) | TEST_P(CustomStructNamingTest, TestsReportCorrectNames) {
  type StatefulNamingFunctor (line 1090) | struct StatefulNamingFunctor {
    method StatefulNamingFunctor (line 1091) | StatefulNamingFunctor() : sum(0) {}
  class StatefulNamingTest (line 1100) | class StatefulNamingTest : public ::testing::TestWithParam<int> {
    method StatefulNamingTest (line 1102) | StatefulNamingTest() : sum_(0) {}
  function TEST_P (line 1106) | TEST_P(StatefulNamingTest, TestsReportCorrectNames) {
  class Unstreamable (line 1122) | class Unstreamable {
    method Unstreamable (line 1124) | explicit Unstreamable(int value) : value_(value) {}
  class CommentTest (line 1132) | class CommentTest : public TestWithParam<Unstreamable> {}
  function TEST_P (line 1134) | TEST_P(CommentTest, TestsCorrectlyReportUnstreamableParams) {
  class NonParameterizedBaseTest (line 1148) | class NonParameterizedBaseTest : public ::testing::Test {
    method NonParameterizedBaseTest (line 1150) | NonParameterizedBaseTest() : n_(17) {}
  class ParameterizedDerivedTest (line 1156) | class ParameterizedDerivedTest : public NonParameterizedBaseTest,
    method ParameterizedDerivedTest (line 1159) | ParameterizedDerivedTest() : count_(0) {}
  function TEST_F (line 1166) | TEST_F(NonParameterizedBaseTest, FixtureIsInitialized) { EXPECT_EQ(17, n...
  function TEST_P (line 1168) | TEST_P(ParameterizedDerivedTest, SeesSequence) {
  class ParameterizedDeathTest (line 1174) | class ParameterizedDeathTest : public ::testing::TestWithParam<int> {}
  function TEST_F (line 1176) | TEST_F(ParameterizedDeathTest, GetParamDiesFromTestF) {
  type MyEnums (line 1184) | enum MyEnums {
  class MyEnumTest (line 1190) | class MyEnumTest : public testing::TestWithParam<MyEnums> {}
  function TEST_P (line 1192) | TEST_P(MyEnumTest, ChecksParamMoreThanZero) { EXPECT_GE(10, GetParam()); }
  type works_here (line 1196) | namespace works_here {
    class NotUsedTest (line 1198) | class NotUsedTest : public testing::TestWithParam<int> {}
    class NotUsedTypeTest (line 1203) | class NotUsedTypeTest : public testing::Test {}
    class NotInstantiatedTest (line 1207) | class NotInstantiatedTest : public testing::TestWithParam<int> {}
    function TEST_P (line 1211) | TEST_P(NotInstantiatedTest, Used) {}
    function TEST_P (line 1215) | TEST_P(OtherName, Used) {}
    class NotInstantiatedTypeTest (line 1219) | class NotInstantiatedTypeTest : public testing::Test {}
    function TYPED_TEST_P (line 1224) | TYPED_TEST_P(NotInstantiatedTypeTest, Used) {}
  function main (line 1228) | int main(int argc, char** argv) {

FILE: googletest/test/googletest-param-test-test.h
  function class (line 42) | class ExternalInstantiationTest : public ::testing::TestWithParam<int> {}
  function class (line 46) | class InstantiationInMultipleTranslationUnitsTest

FILE: googletest/test/googletest-port-test.cc
  type testing (line 54) | namespace testing {
    type internal (line 55) | namespace internal {
      function TEST (line 57) | TEST(IsXDigitTest, WorksForNarrowAscii) {
      function TEST (line 70) | TEST(IsXDigitTest, ReturnsFalseForNarrowNonAscii) {
      function TEST (line 75) | TEST(IsXDigitTest, WorksForWideAscii) {
      function TEST (line 88) | TEST(IsXDigitTest, ReturnsFalseForWideNonAscii) {
      class Base (line 94) | class Base {
        method Base (line 96) | Base() : member_(0) {}
        method Base (line 97) | explicit Base(int n) : member_(n) {}
        method Base (line 98) | Base(const Base&) = default;
        method Base (line 99) | Base& operator=(const Base&) = default;
        method member (line 101) | int member() { return member_; }
      class Derived (line 107) | class Derived : public Base {
        method Derived (line 109) | explicit Derived(int n) : Base(n) {}
      function TEST (line 112) | TEST(ImplicitCastTest, ConvertsPointers) {
      function TEST (line 117) | TEST(ImplicitCastTest, CanUseInheritance) {
      class Castable (line 123) | class Castable {
        method Castable (line 125) | explicit Castable(bool* converted) : converted_(converted) {}
      function TEST (line 135) | TEST(ImplicitCastTest, CanUseNonConstCastOperator) {
      class ConstCastable (line 142) | class ConstCastable {
        method ConstCastable (line 144) | explicit ConstCastable(bool* converted) : converted_(converted) {}
      function TEST (line 154) | TEST(ImplicitCastTest, CanUseConstCastOperatorOnConstValues) {
      class ConstAndNonConstCastable (line 161) | class ConstAndNonConstCastable {
        method ConstAndNonConstCastable (line 163) | ConstAndNonConstCastable(bool* converted, bool* const_converted)
      function TEST (line 179) | TEST(ImplicitCastTest, CanSelectBetweenConstAndNonConstCasrAppropria...
      class To (line 195) | class To {
        method To (line 197) | To(bool* converted) { *converted = true; }
      function TEST (line 200) | TEST(ImplicitCastTest, CanUseImplicitConstructor) {
      function TEST (line 214) | TEST(GtestCheckSyntaxTest, BehavesLikeASingleStatement) {
      function TEST (line 233) | TEST(GtestCheckSyntaxTest, WorksWithSwitch) {
      function TEST (line 247) | TEST(FormatFileLocationTest, FormatsFileLocation) {
      function TEST (line 252) | TEST(FormatFileLocationTest, FormatsUnknownFile) {
      function TEST (line 258) | TEST(FormatFileLocationTest, FormatsUknownLine) {
      function TEST (line 262) | TEST(FormatFileLocationTest, FormatsUknownFileAndLine) {
      function TEST (line 267) | TEST(FormatCompilerIndependentFileLocationTest, FormatsFileLocation) {
      function TEST (line 271) | TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownFile) {
      function TEST (line 276) | TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownLine) {
      function TEST (line 280) | TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownFileAnd...
      function TEST (line 296) | TEST(GetThreadCountTest, ReturnsCorrectValue) {
      function TEST (line 354) | TEST(GetThreadCountTest, ReturnsZeroWhenUnableToCountThreads) {
      function TEST (line 359) | TEST(GtestCheckDeathTest, DiesWithCorrectOutputOnFailure) {
      function TEST (line 377) | TEST(GtestCheckDeathTest, LivesSilentlyOnSuccess) {
      function TEST (line 392) | TEST(RegexEngineSelectionTest, SelectsCorrectRegexEngine) {
      class RETest (line 405) | class RETest : public ::testing::Test {}
      function TYPED_TEST (line 414) | TYPED_TEST(RETest, ImplicitConstructorWorks) {
      function TYPED_TEST (line 426) | TYPED_TEST(RETest, RejectsInvalidRegex) {
      function TYPED_TEST (line 433) | TYPED_TEST(RETest, FullMatchWorks) {
      function TYPED_TEST (line 446) | TYPED_TEST(RETest, PartialMatchWorks) {
      function TEST (line 461) | TEST(IsInSetTest, NulCharIsNotInAnySet) {
      function TEST (line 467) | TEST(IsInSetTest, WorksForNonNulChars) {
      function TEST (line 475) | TEST(IsAsciiDigitTest, IsFalseForNonDigit) {
      function TEST (line 484) | TEST(IsAsciiDigitTest, IsTrueForDigit) {
      function TEST (line 491) | TEST(IsAsciiPunctTest, IsFalseForNonPunct) {
      function TEST (line 499) | TEST(IsAsciiPunctTest, IsTrueForPunct) {
      function TEST (line 505) | TEST(IsRepeatTest, IsFalseForNonRepeatChar) {
      function TEST (line 513) | TEST(IsRepeatTest, IsTrueForRepeatChar) {
      function TEST (line 519) | TEST(IsAsciiWhiteSpaceTest, IsFalseForNonWhiteSpace) {
      function TEST (line 527) | TEST(IsAsciiWhiteSpaceTest, IsTrueForWhiteSpace) {
      function TEST (line 536) | TEST(IsAsciiWordCharTest, IsFalseForNonWordChar) {
      function TEST (line 544) | TEST(IsAsciiWordCharTest, IsTrueForLetter) {
      function TEST (line 551) | TEST(IsAsciiWordCharTest, IsTrueForDigit) {
      function TEST (line 558) | TEST(IsAsciiWordCharTest, IsTrueForUnderscore) {
      function TEST (line 562) | TEST(IsValidEscapeTest, IsFalseForNonPrintable) {
      function TEST (line 567) | TEST(IsValidEscapeTest, IsFalseForDigit) {
      function TEST (line 572) | TEST(IsValidEscapeTest, IsFalseForWhiteSpace) {
      function TEST (line 577) | TEST(IsValidEscapeTest, IsFalseForSomeLetter) {
      function TEST (line 582) | TEST(IsValidEscapeTest, IsTrueForPunct) {
      function TEST (line 593) | TEST(IsValidEscapeTest, IsTrueForSomeLetter) {
      function TEST (line 602) | TEST(AtomMatchesCharTest, EscapedPunct) {
      function TEST (line 614) | TEST(AtomMatchesCharTest, Escaped_d) {
      function TEST (line 623) | TEST(AtomMatchesCharTest, Escaped_D) {
      function TEST (line 632) | TEST(AtomMatchesCharTest, Escaped_s) {
      function TEST (line 643) | TEST(AtomMatchesCharTest, Escaped_S) {
      function TEST (line 652) | TEST(AtomMatchesCharTest, Escaped_w) {
      function TEST (line 664) | TEST(AtomMatchesCharTest, Escaped_W) {
      function TEST (line 675) | TEST(AtomMatchesCharTest, EscapedWhiteSpace) {
      function TEST (line 694) | TEST(AtomMatchesCharTest, UnescapedDot) {
      function TEST (line 703) | TEST(AtomMatchesCharTest, UnescapedChar) {
      function TEST (line 713) | TEST(ValidateRegexTest, GeneratesFailureAndReturnsFalseForInvalid) {
      function TEST (line 749) | TEST(ValidateRegexTest, ReturnsTrueForValid) {
      function TEST (line 760) | TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrOne) {
      function TEST (line 772) | TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrMany) {
      function TEST (line 783) | TEST(MatchRepetitionAndRegexAtHeadTest, WorksForOneOrMany) {
      function TEST (line 794) | TEST(MatchRegexAtHeadTest, ReturnsTrueForEmptyRegex) {
      function TEST (line 799) | TEST(MatchRegexAtHeadTest, WorksWhenDollarIsInRegex) {
      function TEST (line 806) | TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithEscapeSequence) {
      function TEST (line 814) | TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithRepetition) {
      function TEST (line 823) | TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithRepetionOfEscapeS...
      function TEST (line 833) | TEST(MatchRegexAtHeadTest, MatchesSequentially) {
      function TEST (line 839) | TEST(MatchRegexAnywhereTest, ReturnsFalseWhenStringIsNull) {
      function TEST (line 843) | TEST(MatchRegexAnywhereTest, WorksWhenRegexStartsWithCaret) {
      function TEST (line 852) | TEST(MatchRegexAnywhereTest, ReturnsFalseWhenNoMatch) {
      function TEST (line 857) | TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingPrefix) {
      function TEST (line 863) | TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingNonPrefix) {
      function TEST (line 869) | TEST(RETest, ImplicitConstructorWorks) {
      function TEST (line 878) | TEST(RETest, RejectsInvalidRegex) {
      function TEST (line 890) | TEST(RETest, FullMatchWorks) {
      function TEST (line 906) | TEST(RETest, PartialMatchWorks) {
      function TEST (line 923) | TEST(CaptureTest, CapturesStdout) {
      function TEST (line 933) | TEST(CaptureTest, CapturesStderr) {
      function TEST (line 944) | TEST(CaptureTest, CapturesStdoutAndStderr) {
      function TEST (line 953) | TEST(CaptureDeathTest, CannotReenterStdoutCapture) {
      function TEST (line 965) | TEST(ThreadLocalTest, DefaultConstructorInitializesToDefaultValues) {
      function TEST (line 973) | TEST(ThreadLocalTest, SingleParamConstructorInitializesToParam) {
      class NoDefaultConstructor (line 982) | class NoDefaultConstructor {
        method NoDefaultConstructor (line 984) | explicit NoDefaultConstructor(const char*) {}
        method NoDefaultConstructor (line 985) | NoDefaultConstructor(const NoDefaultConstructor&) = default;
      function TEST (line 988) | TEST(ThreadLocalTest, ValueDefaultContructorIsNotRequiredForParamVer...
      function TEST (line 993) | TEST(ThreadLocalTest, GetAndPointerReturnSameValue) {
      function TEST (line 1003) | TEST(ThreadLocalTest, PointerAndConstPointerReturnSameValue) {
      function AddTwo (line 1016) | void AddTwo(int* param) { *param += 2; }
      function TEST (line 1018) | TEST(ThreadWithParamTest, ConstructorExecutesThreadFunc) {
      function TEST (line 1025) | TEST(MutexDeathTest, AssertHeldShouldAssertWhenNotLocked) {
      function TEST (line 1039) | TEST(MutexTest, AssertHeldShouldNotAssertWhenLocked) {
      class AtomicCounterWithMutex (line 1045) | class AtomicCounterWithMutex {
        method AtomicCounterWithMutex (line 1047) | explicit AtomicCounterWithMutex(Mutex& mutex)
        method Increment (line 1050) | void Increment() {
        method value (line 1084) | int value() const { return value_; }
      function CountingThreadFunc (line 1092) | void CountingThreadFunc(pair<AtomicCounterWithMutex*, int> param) {
      function TEST (line 1097) | TEST(MutexTest, OnlyOneThreadCanLockAtATime) {
      function RunFromThread (line 1124) | void RunFromThread(void(func)(T), T param) {
      function RetrieveThreadLocalValue (line 1129) | void RetrieveThreadLocalValue(
      function TEST (line 1134) | TEST(ThreadLocalTest, ParameterizedConstructorSetsDefault) {
      class DestructorCall (line 1149) | class DestructorCall {
        method DestructorCall (line 1151) | DestructorCall() {
        method CheckDestroyed (line 1159) | bool CheckDestroyed() const {
        method ReportDestroyed (line 1167) | void ReportDestroyed() {
        method ResetList (line 1176) | static void ResetList() {
        method DestructorCall (line 1190) | DestructorCall(const DestructorCall&) = delete;
        method DestructorCall (line 1191) | DestructorCall& operator=(const DestructorCall&) = delete;
      class DestructorTracker (line 1199) | class DestructorTracker {
        method DestructorTracker (line 1201) | DestructorTracker() : index_(GetNewIndex()) {}
        method DestructorTracker (line 1202) | DestructorTracker(const DestructorTracker& /* rhs */)
        method GetNewIndex (line 1211) | static size_t GetNewIndex() {
      function CallThreadLocalGet (line 1220) | void CallThreadLocalGet(ThreadParam thread_local_param) {
      function TEST (line 1226) | TEST(ThreadLocalTest, DestroysManagedObjectForOwnThreadWhenDying) {
      function TEST (line 1248) | TEST(ThreadLocalTest, DestroysManagedObjectAtThreadExit) {
      function TEST (line 1272) | TEST(ThreadLocalTest, ThreadLocalMutationsAffectOnlyCurrentThread) {
      function TEST (line 1286) | TEST(WindowsTypesTest, HANDLEIsVoidStar) {
      function TEST (line 1291) | TEST(WindowsTypesTest, _CRITICAL_SECTIONIs_CRITICAL_SECTION) {
      function TEST (line 1295) | TEST(WindowsTypesTest, CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION) {

FILE: googletest/test/googletest-printers-test.cc
  type AnonymousEnum (line 78) | enum AnonymousEnum { kAE1 = -1, kAE2 = 1 }
  type EnumWithoutPrinter (line 81) | enum EnumWithoutPrinter { kEWP1 = -2, kEWP2 = 42 }
  type EnumWithStreaming (line 84) | enum EnumWithStreaming { kEWS1 = 10 }
  type EnumWithPrintTo (line 91) | enum EnumWithPrintTo { kEWPT1 = 1 }
  function PrintTo (line 93) | void PrintTo(EnumWithPrintTo e, std::ostream* os) {
  class BiggestIntConvertible (line 98) | class BiggestIntConvertible {
  class ParentClass (line 105) | class ParentClass {}
  class ChildClassWithStreamOperator (line 106) | class ChildClassWithStreamOperator : public ParentClass {}
  class ChildClassWithoutStreamOperator (line 107) | class ChildClassWithoutStreamOperator : public ParentClass {}
  class UnprintableTemplateInGlobal (line 117) | class UnprintableTemplateInGlobal {
    method UnprintableTemplateInGlobal (line 119) | UnprintableTemplateInGlobal() : value_() {}
  class StreamableInGlobal (line 126) | class StreamableInGlobal {
    method StreamableInGlobal (line 128) | StreamableInGlobal() = default;
    method StreamableInGlobal (line 129) | StreamableInGlobal(const StreamableInGlobal&) = default;
    method StreamableInGlobal (line 130) | StreamableInGlobal& operator=(const StreamableInGlobal&) = default;
  type Point (line 144) | struct Point {
    method AbslStringify (line 146) | void AbslStringify(Sink& sink, const Point& p) {
  type foo (line 155) | namespace foo {
    class UnprintableInFoo (line 158) | class UnprintableInFoo {
      method UnprintableInFoo (line 160) | UnprintableInFoo() : z_(0) { memcpy(xy_, "\xEF\x12\x0\x0\x34\xAB\x0\...
      method z (line 161) | double z() const { return z_; }
    type PrintableViaPrintTo (line 169) | struct PrintableViaPrintTo {
      method PrintableViaPrintTo (line 170) | PrintableViaPrintTo() : value() {}
    function PrintTo (line 174) | void PrintTo(const PrintableViaPrintTo& x, ::std::ostream* os) {
    type PointerPrintable (line 179) | struct PointerPrintable {}
    class PrintableViaPrintToTemplate (line 188) | class PrintableViaPrintToTemplate {
      method PrintableViaPrintToTemplate (line 190) | explicit PrintableViaPrintToTemplate(const T& a_value) : value_(a_va...
      method T (line 192) | const T& value() const { return value_; }
    function PrintTo (line 199) | void PrintTo(const PrintableViaPrintToTemplate<T>& x, ::std::ostream* ...
    class StreamableTemplateInFoo (line 205) | class StreamableTemplateInFoo {
      method StreamableTemplateInFoo (line 207) | StreamableTemplateInFoo() : value_() {}
      method T (line 209) | const T& value() const { return value_; }
    type TemplatedStreamableInFoo (line 223) | struct TemplatedStreamableInFoo {}
    function OutputStream (line 226) | OutputStream& operator<<(OutputStream& os,
    type StreamableInLocal (line 232) | struct StreamableInLocal {}
    class PathLike (line 240) | class PathLike {
      type iterator (line 242) | struct iterator {
      method PathLike (line 252) | PathLike() = default;
      method iterator (line 254) | iterator begin() const { return iterator(); }
      method iterator (line 255) | iterator end() const { return iterator(); }
  type testing (line 264) | namespace testing {
    class Wrapper (line 267) | class Wrapper {
      method Wrapper (line 269) | explicit Wrapper(T&& value) : value_(std::forward<T>(value)) {}
      method T (line 271) | const T& value() const { return value_; }
    type internal (line 279) | namespace internal {
      class UniversalPrinter<Wrapper<T>> (line 281) | class UniversalPrinter<Wrapper<T>> {
        method Print (line 283) | static void Print(const Wrapper<T>& w, ::std::ostream* os) {
    type gtest_printers_test (line 291) | namespace gtest_printers_test {
      function Print (line 315) | std::string Print(const T& value) {
      function PrintByRef (line 325) | std::string PrintByRef(const T& value) {
      function TEST (line 333) | TEST(PrintEnumTest, AnonymousEnum) {
      function TEST (line 338) | TEST(PrintEnumTest, EnumWithoutPrinter) {
      function TEST (line 343) | TEST(PrintEnumTest, EnumWithStreaming) {
      function TEST (line 348) | TEST(PrintEnumTest, EnumWithPrintTo) {
      function TEST (line 355) | TEST(PrintClassTest, AbslStringify) { EXPECT_EQ("(10, 20)", Print(Po...
      function TEST (line 360) | TEST(PrintClassTest, BiggestIntConvertible) {
      function TEST (line 367) | TEST(PrintCharTest, PlainChar) {
      function TEST (line 387) | TEST(PrintCharTest, SignedChar) {
      function TEST (line 393) | TEST(PrintCharTest, UnsignedChar) {
      function TEST (line 398) | TEST(PrintCharTest, Char16) { EXPECT_EQ("U+0041", Print(u'A')); }
      function TEST (line 400) | TEST(PrintCharTest, Char32) { EXPECT_EQ("U+0041", Print(U'A')); }
      function TEST (line 403) | TEST(PrintCharTest, Char8) { EXPECT_EQ("U+0041", Print(u8'A')); }
      function TEST (line 409) | TEST(PrintBuiltInTypeTest, Bool) {
      function TEST (line 415) | TEST(PrintBuiltInTypeTest, Wchar_t) {
      function TEST (line 437) | TEST(PrintTypeSizeTest, Wchar_t) {
      function TEST (line 442) | TEST(PrintBuiltInTypeTest, Integer) {
      function TEST (line 472) | TEST(PrintBuiltInTypeTest, Size_t) {
      function TEST (line 482) | TEST(PrintBuiltInTypeTest, Int128) {
      function TEST (line 499) | TEST(PrintBuiltInTypeTest, FloatingPoints) {
      function TEST (line 513) | TEST(PrintBuiltInTypeTest, TypeInfo) {
      function PrintPointer (line 525) | static std::string PrintPointer(const void* p) {
      function TEST (line 534) | TEST(PrintCStringTest, Const) {
      function TEST (line 540) | TEST(PrintCStringTest, NonConst) {
      function TEST (line 547) | TEST(PrintCStringTest, Null) {
      function TEST (line 553) | TEST(PrintCStringTest, EscapesProperly) {
      function TEST (line 563) | TEST(PrintU8StringTest, Const) {
      function TEST (line 569) | TEST(PrintU8StringTest, NonConst) {
      function TEST (line 576) | TEST(PrintU8StringTest, Null) {
      function TEST (line 584) | TEST(PrintU8StringTest, EscapesProperly) {
      function TEST (line 595) | TEST(PrintU16StringTest, Const) {
      function TEST (line 601) | TEST(PrintU16StringTest, NonConst) {
      function TEST (line 608) | TEST(PrintU16StringTest, Null) {
      function TEST (line 614) | TEST(PrintU16StringTest, EscapesProperly) {
      function TEST (line 623) | TEST(PrintU32StringTest, Const) {
      function TEST (line 629) | TEST(PrintU32StringTest, NonConst) {
      function TEST (line 636) | TEST(PrintU32StringTest, Null) {
      function TEST (line 642) | TEST(PrintU32StringTest, EscapesProperly) {
      function TEST (line 659) | TEST(PrintWideCStringTest, Const) {
      function TEST (line 665) | TEST(PrintWideCStringTest, NonConst) {
      function TEST (line 672) | TEST(PrintWideCStringTest, Null) {
      function TEST (line 678) | TEST(PrintWideCStringTest, EscapesProperly) {
      function TEST (line 692) | TEST(PrintCharPointerTest, SignedChar) {
      function TEST (line 700) | TEST(PrintCharPointerTest, ConstSignedChar) {
      function TEST (line 708) | TEST(PrintCharPointerTest, UnsignedChar) {
      function TEST (line 716) | TEST(PrintCharPointerTest, ConstUnsignedChar) {
      function TEST (line 726) | TEST(PrintPointerToBuiltInTypeTest, Bool) {
      function TEST (line 734) | TEST(PrintPointerToBuiltInTypeTest, Void) {
      function TEST (line 742) | TEST(PrintPointerToBuiltInTypeTest, ConstVoid) {
      function TEST (line 750) | TEST(PrintPointerToPointerTest, IntPointerPointer) {
      function MyFunction (line 759) | void MyFunction(int /* n */) {}
      function TEST (line 761) | TEST(PrintPointerTest, NonMemberFunctionPointer) {
      function AssertionResult (line 776) | AssertionResult HasPrefix(const StringType& str, const StringType& p...
      type Foo (line 791) | struct Foo {
        method MyMethod (line 794) | int MyMethod(char x) { return x + 1; }
        method MyVirtualMethod (line 795) | virtual char MyVirtualMethod(int /* n */) { return 'a'; }
      function TEST (line 800) | TEST(PrintPointerTest, MemberVariablePointer) {
      function TEST (line 811) | TEST(PrintPointerTest, MemberFunctionPointer) {
      function PrintArrayHelper (line 826) | std::string PrintArrayHelper(T (&a)[N]) {
      function TEST (line 831) | TEST(PrintArrayTest, OneDimensionalArray) {
      function TEST (line 837) | TEST(PrintArrayTest, TwoDimensionalArray) {
      function TEST (line 843) | TEST(PrintArrayTest, ConstArray) {
      function TEST (line 849) | TEST(PrintArrayTest, CharArrayWithNoTerminatingNul) {
      function TEST (line 856) | TEST(PrintArrayTest, CharArrayWithTerminatingNul) {
      function TEST (line 863) | TEST(PrintArrayTest, Char8ArrayWithNoTerminatingNul) {
      function TEST (line 870) | TEST(PrintArrayTest, Char8ArrayWithTerminatingNul) {
      function TEST (line 877) | TEST(PrintArrayTest, Char16ArrayWithNoTerminatingNul) {
      function TEST (line 885) | TEST(PrintArrayTest, Char16ArrayWithTerminatingNul) {
      function TEST (line 891) | TEST(PrintArrayTest, Char32ArrayWithNoTerminatingNul) {
      function TEST (line 899) | TEST(PrintArrayTest, Char32ArrayWithTerminatingNul) {
      function TEST (line 905) | TEST(PrintArrayTest, WCharArrayWithNoTerminatingNul) {
      function TEST (line 912) | TEST(PrintArrayTest, WCharArrayWithTerminatingNul) {
      function TEST (line 918) | TEST(PrintArrayTest, ObjectArray) {
      function TEST (line 924) | TEST(PrintArrayTest, BigArray) {
      function TEST (line 933) | TEST(PrintStringTest, StringInStdNamespace) {
      function TEST (line 940) | TEST(PrintStringTest, StringViewInStdNamespace) {
      function TEST (line 947) | TEST(PrintStringTest, StringAmbiguousHex) {
      function TEST (line 967) | TEST(PrintWideStringTest, StringInStdNamespace) {
      function TEST (line 976) | TEST(PrintWideStringTest, StringViewInStdNamespace) {
      function TEST (line 985) | TEST(PrintWideStringTest, StringAmbiguousHex) {
      function TEST (line 998) | TEST(PrintStringTest, U8String) {
      function TEST (line 1004) | TEST(PrintStringTest, U8StringView) {
      function TEST (line 1011) | TEST(PrintStringTest, U16String) {
      function TEST (line 1017) | TEST(PrintStringTest, U16StringView) {
      function TEST (line 1023) | TEST(PrintStringTest, U32String) {
      function TEST (line 1029) | TEST(PrintStringTest, U32StringView) {
      class AllowsGenericStreaming (line 1041) | class AllowsGenericStreaming {}
      function TEST (line 1050) | TEST(PrintTypeWithGenericStreamingTest, NonTemplateType) {
      class AllowsGenericStreamingTemplate (line 1058) | class AllowsGenericStreamingTemplate {}
      function TEST (line 1067) | TEST(PrintTypeWithGenericStreamingTest, TemplateType) {
      class AllowsGenericStreamingAndImplicitConversionTemplate (line 1076) | class AllowsGenericStreamingAndImplicitConversionTemplate {
      function TEST (line 1088) | TEST(PrintTypeWithGenericStreamingTest, TypeImplicitlyConvertible) {
      function TEST (line 1097) | TEST(PrintStringViewTest, SimpleStringView) {
      function TEST (line 1102) | TEST(PrintStringViewTest, UnprintableCharacters) {
      function TEST (line 1112) | TEST(PrintStlContainerTest, EmptyDeque) {
      function TEST (line 1117) | TEST(PrintStlContainerTest, NonEmptyDeque) {
      function TEST (line 1124) | TEST(PrintStlContainerTest, OneElementHashMap) {
      function TEST (line 1130) | TEST(PrintStlContainerTest, HashMultiMap) {
      function TEST (line 1142) | TEST(PrintStlContainerTest, HashSet) {
      function TEST (line 1148) | TEST(PrintStlContainerTest, HashMultiSet) {
      function TEST (line 1177) | TEST(PrintStlContainerTest, List) {
      function TEST (line 1183) | TEST(PrintStlContainerTest, Map) {
      function TEST (line 1191) | TEST(PrintStlContainerTest, MultiMap) {
      function TEST (line 1205) | TEST(PrintStlContainerTest, Set) {
      function TEST (line 1211) | TEST(PrintStlContainerTest, MultiSet) {
      function TEST (line 1217) | TEST(PrintStlContainerTest, SinglyLinkedList) {
      function TEST (line 1223) | TEST(PrintStlContainerTest, Pair) {
      function TEST (line 1228) | TEST(PrintStlContainerTest, Vector) {
      function TEST (line 1235) | TEST(PrintStlContainerTest, StdSpan) {
      function TEST (line 1246) | TEST(PrintStlContainerTest, LongSequence) {
      function TEST (line 1255) | TEST(PrintStlContainerTest, NestedContainer) {
      function TEST (line 1267) | TEST(PrintStlContainerTest, OneDimensionalNativeArray) {
      function TEST (line 1273) | TEST(PrintStlContainerTest, TwoDimensionalNativeArray) {
      type iterator (line 1281) | struct iterator {
      function TEST (line 1285) | TEST(PrintStlContainerTest, Iterator) {
      type const_iterator (line 1292) | struct const_iterator {
      function TEST (line 1296) | TEST(PrintStlContainerTest, ConstIterator) {
      function TEST (line 1304) | TEST(PrintStdTupleTest, VariousSizes) {
      function TEST (line 1331) | TEST(PrintStdTupleTest, NestedTuple) {
      function TEST (line 1337) | TEST(PrintNullptrT, Basic) { EXPECT_EQ("(nullptr)", Print(nullptr)); }
      function TEST (line 1339) | TEST(PrintReferenceWrapper, Printable) {
      function TEST (line 1345) | TEST(PrintReferenceWrapper, Unprintable) {
      function TEST (line 1360) | TEST(PrintUnprintableTypeTest, InGlobalNamespace) {
      function TEST (line 1365) | TEST(PrintUnprintableTypeTest, InUserNamespace) {
      type Big (line 1372) | struct Big {
        method Big (line 1373) | Big() { memset(array, 0, sizeof(array)); }
      function TEST (line 1377) | TEST(PrintUnpritableTypeTest, BigObject) {
      function TEST (line 1392) | TEST(PrintStreamableTypeTest, InGlobalNamespace) {
      function TEST (line 1399) | TEST(PrintStreamableTypeTest, TemplateTypeInUserNamespace) {
      function TEST (line 1404) | TEST(PrintStreamableTypeTest, TypeInUserNamespaceWithTemplatedStream...
      function TEST (line 1409) | TEST(PrintStreamableTypeTest, SubclassUsesSuperclassStreamOperator) {
      function TEST (line 1420) | TEST(PrintStreamableTypeTest, PathLikeInUserNamespace) {
      function TEST (line 1428) | TEST(PrintPrintableTypeTest, InUserNamespace) {
      function TEST (line 1434) | TEST(PrintPrintableTypeTest, PointerInUserNamespace) {
      function TEST (line 1440) | TEST(PrintPrintableTypeTest, TemplateInUserNamespace) {
      function TEST (line 1447) | TEST(PrintReferenceTest, PrintsAddressAndValue) {
      function TEST (line 1464) | TEST(PrintReferenceTest, HandlesFunctionPointer) {
      function TEST (line 1479) | TEST(PrintReferenceTest, HandlesMemberFunctionPointer) {
      function TEST (line 1493) | TEST(PrintReferenceTest, HandlesMemberVariablePointer) {
      function TEST (line 1504) | TEST(FormatForComparisonFailureMessageTest, WorksForScalar) {
      function TEST (line 1509) | TEST(FormatForComparisonFailureMessageTest, WorksForNonCharPointer) {
      function TEST (line 1516) | TEST(FormatForComparisonFailureMessageTest, FormatsNonCharArrayAsPoi...
      function TEST (line 1528) | TEST(FormatForComparisonFailureMessageTest, WorksForCharPointerVsPoi...
      function TEST (line 1545) | TEST(FormatForComparisonFailureMessageTest, WorksForWCharPointerVsPo...
      function TEST (line 1565) | TEST(FormatForComparisonFailureMessageTest, WorksForCharPointerVsStd...
      function TEST (line 1579) | TEST(FormatForComparisonFailureMessageTest, WorksForWCharPointerVsSt...
      function TEST (line 1597) | TEST(FormatForComparisonFailureMessageTest, WorksForCharArrayVsPoint...
      function TEST (line 1605) | TEST(FormatForComparisonFailureMessageTest, WorksForCharArrayVsCharA...
      function TEST (line 1612) | TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsPoin...
      function TEST (line 1620) | TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsWCha...
      function TEST (line 1630) | TEST(FormatForComparisonFailureMessageTest, WorksForCharArrayVsStdSt...
      function TEST (line 1638) | TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsStdW...
      function TEST (line 1654) | TEST(PrintToStringTest, WorksForScalar) { EXPECT_PRINT_TO_STRING_(12...
      function TEST (line 1656) | TEST(PrintToStringTest, WorksForPointerToConstChar) {
      function TEST (line 1661) | TEST(PrintToStringTest, WorksForPointerToNonConstChar) {
      function TEST (line 1667) | TEST(PrintToStringTest, EscapesForPointerToConstChar) {
      function TEST (line 1672) | TEST(PrintToStringTest, EscapesForPointerToNonConstChar) {
      function TEST (line 1678) | TEST(PrintToStringTest, WorksForArray) {
      function TEST (line 1683) | TEST(PrintToStringTest, WorksForCharArray) {
      function TEST (line 1688) | TEST(PrintToStringTest, WorksForCharArrayWithEmbeddedNul) {
      function TEST (line 1696) | TEST(PrintToStringTest, ContainsNonLatin) {
      function TEST (line 1708) | TEST(PrintToStringTest, PrintStreamableInLocal) {
      function TEST (line 1713) | TEST(PrintToStringTest, PrintReferenceToStreamableInLocal) {
      function TEST (line 1719) | TEST(PrintToStringTest, PrintReferenceToStreamableInGlobal) {
      function TEST (line 1726) | TEST(PrintToStringTest, AbslStringify) {
      function TEST (line 1731) | TEST(IsValidUTF8Test, IllFormedUTF8) {
      function TEST (line 1794) | TEST(UniversalTersePrintTest, WorksForNonReference) {
      function TEST (line 1800) | TEST(UniversalTersePrintTest, WorksForReference) {
      function TEST (line 1807) | TEST(UniversalTersePrintTest, WorksForCString) {
      function TEST (line 1824) | TEST(UniversalPrintTest, WorksForNonReference) {
      function TEST (line 1830) | TEST(UniversalPrintTest, WorksForReference) {
      function TEST (line 1837) | TEST(UniversalPrintTest, WorksForPairWithConst) {
      function TEST (line 1844) | TEST(UniversalPrintTest, WorksForCString) {
      function TEST (line 1861) | TEST(UniversalPrintTest, WorksForCharArray) {
      function TEST (line 1873) | TEST(UniversalPrintTest, IncompleteType) {
      function TEST (line 1880) | TEST(UniversalPrintTest, SmartPointers) {
      function TEST (line 1932) | TEST(UniversalPrintTest, StringViewNonZeroTerminated) {
      function TEST (line 1948) | TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsEmpty...
      function TEST (line 1953) | TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsOneTu...
      function TEST (line 1960) | TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsTwoTu...
      function TEST (line 1968) | TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsTerse...
      class PrintAnyTest (line 1977) | class PrintAnyTest : public ::testing::Test {
        method ExpectedTypeName (line 1980) | static std::string ExpectedTypeName() {
      function TEST_F (line 1989) | TEST_F(PrintAnyTest, Empty) {
      function TEST_F (line 1994) | TEST_F(PrintAnyTest, NonEmpty) {
      function TEST (line 2007) | TEST(PrintOptionalTest, Basic) {
      type NonPrintable (line 2017) | struct NonPrintable {
      function TEST (line 2021) | TEST(PrintOneofTest, Basic) {
      function TEST (line 2033) | TEST(PrintOrderingTest, Basic) {
      class string_ref (line 2052) | class string_ref
        method string_ref (line 2078) | string_ref(const char* data, size_t size) : data_(data), size_(siz...
        method string_ptr (line 2080) | string_ptr operator&() const noexcept { return {data_, size_}; }
      class string_ptr (line 2057) | class string_ptr {
        method string_ptr (line 2059) | string_ptr(const char* data, size_t size) : data_(data), size_(siz...
        method string_ptr (line 2061) | string_ptr& operator++() noexcept {
      class string_ref (line 2076) | class string_ref {
        method string_ref (line 2078) | string_ref(const char* data, size_t size) : data_(data), size_(siz...
        method string_ptr (line 2080) | string_ptr operator&() const noexcept { return {data_, size_}; }
      function string_ref (line 2095) | string_ref string_ptr::operator*() const noexcept { return {data_, s...
        method string_ref (line 2078) | string_ref(const char* data, size_t size) : data_(data), size_(siz...
        method string_ptr (line 2080) | string_ptr operator&() const noexcept { return {data_, size_}; }
      function TEST (line 2097) | TEST(string_ref, compare) {

FILE: googletest/test/googletest-setuptestsuite-test.py
  class GTestSetUpTestSuiteTest (line 41) | class GTestSetUpTestSuiteTest(gtest_test_utils.TestCase):
    method testSetupErrorAndTearDownError (line 43) | def testSetupErrorAndTearDownError(self):

FILE: googletest/test/googletest-setuptestsuite-test_.cc
  class SetupFailTest (line 32) | class SetupFailTest : public ::testing::Test {
    method SetUpTestSuite (line 34) | static void SetUpTestSuite() { ASSERT_STREQ("", "SET_UP_FAIL"); }
  function TEST_F (line 37) | TEST_F(SetupFailTest, NoopPassingTest) {}
  class TearDownFailTest (line 39) | class TearDownFailTest : public ::testing::Test {
    method TearDownTestSuite (line 41) | static void TearDownTestSuite() { ASSERT_STREQ("", "TEAR_DOWN_FAIL"); }
  function TEST_F (line 44) | TEST_F(TearDownFailTest, NoopPassingTest) {}

FILE: googletest/test/googletest-shuffle-test.py
  function AlsoRunDisabledTestsFlag (line 56) | def AlsoRunDisabledTestsFlag():
  function FilterFlag (line 60) | def FilterFlag(test_filter):
  function RepeatFlag (line 64) | def RepeatFlag(n):
  function ShuffleFlag (line 68) | def ShuffleFlag():
  function RandomSeedFlag (line 72) | def RandomSeedFlag(n):
  function RunAndReturnOutput (line 76) | def RunAndReturnOutput(extra_env, args):
  function GetTestsForAllIterations (line 85) | def GetTestsForAllIterations(extra_env, args):
  function GetTestCases (line 108) | def GetTestCases(tests):
  function CalculateTestLists (line 128) | def CalculateTestLists():
  class GTestShuffleUnitTest (line 179) | class GTestShuffleUnitTest(gtest_test_utils.TestCase):
    method setUp (line 182) | def setUp(self):
    method testShufflePreservesNumberOfTests (line 185) | def testShufflePreservesNumberOfTests(self):
    method testShuffleChangesTestOrder (line 191) | def testShuffleChangesTestOrder(self):
    method testShuffleChangesTestCaseOrder (line 203) | def testShuffleChangesTestCaseOrder(self):
    method testShuffleDoesNotRepeatTest (line 221) | def testShuffleDoesNotRepeatTest(self):
    method testShuffleDoesNotCreateNewTest (line 247) | def testShuffleDoesNotCreateNewTest(self):
    method testShuffleIncludesAllTests (line 257) | def testShuffleIncludesAllTests(self):
    method testShuffleLeavesDeathTestsAtFront (line 269) | def testShuffleLeavesDeathTestsAtFront(self):
    method _VerifyTestCasesDoNotInterleave (line 280) | def _VerifyTestCasesDoNotInterleave(self, tests):
    method testShuffleDoesNotInterleaveTestCases (line 292) | def testShuffleDoesNotInterleaveTestCases(self):
    method testShuffleRestoresOrderAfterEachIteration (line 298) | def testShuffleRestoresOrderAfterEachIteration(self):
    method testShuffleGeneratesNewOrderInEachIteration (line 336) | def testShuffleGeneratesNewOrderInEachIteration(self):
    method testShuffleShardedTestsPreservesPartition (line 354) | def testShuffleShardedTestsPreservesPartition(self):

FILE: googletest/test/googletest-shuffle-test_.cc
  class A (line 46) | class A : public Test {}
  function TEST_F (line 47) | TEST_F(A, A) {}
  function TEST_F (line 48) | TEST_F(A, B) {}
  function TEST (line 50) | TEST(ADeathTest, A) {}
  function TEST (line 51) | TEST(ADeathTest, B) {}
  function TEST (line 52) | TEST(ADeathTest, C) {}
  function TEST (line 54) | TEST(B, A) {}
  function TEST (line 55) | TEST(B, B) {}
  function TEST (line 56) | TEST(B, C) {}
  function TEST (line 57) | TEST(B, DISABLED_D) {}
  function TEST (line 58) | TEST(B, DISABLED_E) {}
  function TEST (line 60) | TEST(BDeathTest, A) {}
  function TEST (line 61) | TEST(BDeathTest, B) {}
  function TEST (line 63) | TEST(C, A) {}
  function TEST (line 64) | TEST(C, B) {}
  function TEST (line 65) | TEST(C, C) {}
  function TEST (line 66) | TEST(C, DISABLED_D) {}
  function TEST (line 68) | TEST(CDeathTest, A) {}
  function TEST (line 70) | TEST(DISABLED_D, A) {}
  function TEST (line 71) | TEST(DISABLED_D, DISABLED_B) {}
  class TestNamePrinter (line 75) | class TestNamePrinter : public EmptyTestEventListener {
    method OnTestIterationStart (line 77) | void OnTestIterationStart(const UnitTest& /* unit_test */,
    method OnTestStart (line 82) | void OnTestStart(const TestInfo& test_info) override {
  function main (line 89) | int main(int argc, char** argv) {

FILE: googletest/test/googletest-test-part-test.cc
  class TestPartResultTest (line 43) | class TestPartResultTest : public Test {
    method TestPartResultTest (line 45) | TestPartResultTest()
  function TEST_F (line 54) | TEST_F(TestPartResultTest, ConstructorWorks) {
  function TEST_F (line 70) | TEST_F(TestPartResultTest, ResultAccessorsWork) {
  function TEST_F (line 104) | TEST_F(TestPartResultTest, type) {
  function TEST_F (line 112) | TEST_F(TestPartResultTest, file_name) {
  function TEST_F (line 119) | TEST_F(TestPartResultTest, line_number) {
  function TEST_F (line 126) | TEST_F(TestPartResultTest, message) {
  function TEST_F (line 132) | TEST_F(TestPartResultTest, Passed) {
  function TEST_F (line 140) | TEST_F(TestPartResultTest, Failed) {
  function TEST_F (line 148) | TEST_F(TestPartResultTest, Skipped) {
  function TEST_F (line 156) | TEST_F(TestPartResultTest, FatallyFailed) {
  function TEST_F (line 164) | TEST_F(TestPartResultTest, NonfatallyFailed) {
  class TestPartResultArrayTest (line 173) | class TestPartResultArrayTest : public Test {
    method TestPartResultArrayTest (line 175) | TestPartResultArrayTest()
  function TEST_F (line 183) | TEST_F(TestPartResultArrayTest, InitialSizeIsZero) {
  function TEST_F (line 190) | TEST_F(TestPartResultArrayTest, ContainsGivenResultAfterAppend) {
  function TEST_F (line 199) | TEST_F(TestPartResultArrayTest, ContainsGivenResultsAfterTwoAppends) {
  function TEST_F (line 212) | TEST_F(TestPartResultArrayDeathTest, DiesWhenIndexIsOutOfBound) {

FILE: googletest/test/googletest-throw-on-failure-test.py
  function SetEnvVar (line 57) | def SetEnvVar(env_var, value):
  function Run (line 75) | def Run(command):
  class ThrowOnFailureTest (line 84) | class ThrowOnFailureTest(gtest_test_utils.TestCase):
    method RunAndVerify (line 87) | def RunAndVerify(self, env_var_value, flag_value, should_fail):
    method testDefaultBehavior (line 139) | def testDefaultBehavior(self):
    method testThrowOnFailureEnvVar (line 144) | def testThrowOnFailureEnvVar(self):
    method testThrowOnFailureFlag (line 150) | def testThrowOnFailureFlag(self):
    method testThrowOnFailureFlagOverridesEnvVar (line 156) | def testThrowOnFailureFlagOverridesEnvVar(self):

FILE: googletest/test/googletest-throw-on-failure-test_.cc
  function TerminateHandler (line 46) | void TerminateHandler() {
  function main (line 52) | int main(int argc, char** argv) {

FILE: googletest/test/googletest-uninitialized-test.py
  function Assert (line 41) | def Assert(condition):
  function AssertEq (line 46) | def AssertEq(expected, actual):
  function TestExitCodeAndOutput (line 53) | def TestExitCodeAndOutput(command):
  class GTestUninitializedTest (line 63) | class GTestUninitializedTest(gtest_test_utils.TestCase):
    method testExitCodeAndOutput (line 65) | def testExitCodeAndOutput(self):

FILE: googletest/test/googletest-uninitialized-test_.cc
  function TEST (line 32) | TEST(DummyTest, Dummy) {
  function main (line 39) | int main() { return RUN_ALL_TESTS(); }

FILE: googletest/test/gtest-typed-test_test.cc
  class CommonTest (line 47) | class CommonTest : public Test {
    method SetUpTestSuite (line 51) | static void SetUpTestSuite() { shared_ = new T(5); }
    method TearDownTestSuite (line 53) | static void TearDownTestSuite() {
    method CommonTest (line 66) | CommonTest() : value_(1) {}
    method SetUp (line 70) | void SetUp() override {
    method TearDown (line 75) | void TearDown() override {
  function TYPED_TEST (line 95) | TYPED_TEST(CommonTest, ValuesAreCorrect) {
  function TYPED_TEST (line 115) | TYPED_TEST(CommonTest, ValuesAreStillCorrect) {
  class TypedTest1 (line 129) | class TypedTest1 : public Test {}
  function TYPED_TEST (line 134) | TYPED_TEST(TypedTest1, A) {}
  class TypedTest2 (line 137) | class TypedTest2 : public Test {}
  function TYPED_TEST (line 145) | TYPED_TEST(TypedTest2, A) {}
  type library1 (line 149) | namespace library1 {
    class NumericTest (line 152) | class NumericTest : public Test {}
    function TYPED_TEST (line 157) | TYPED_TEST(NumericTest, DefaultIsZero) { EXPECT_EQ(0, TypeParam()); }
  class TypedTestWithNames (line 163) | class TypedTestWithNames : public Test {}
  class TypedTestNames (line 165) | class TypedTestNames {
    method GetName (line 168) | static std::string GetName(int i) {
  function TYPED_TEST (line 180) | TYPED_TEST(TypedTestWithNames, TestSuiteName) {
  class TypedTestSuitePStateTest (line 200) | class TypedTestSuitePStateTest : public Test {
    method SetUp (line 202) | void SetUp() override {
  function TEST_F (line 211) | TEST_F(TypedTestSuitePStateTest, SucceedsForMatchingList) {
  function TEST_F (line 219) | TEST_F(TypedTestSuitePStateTest, IgnoresOrderAndSpaces) {
  function TEST_F (line 227) | TEST_F(TypedTestSuitePStateDeathTest, DetectsDuplicates) {
  function TEST_F (line 233) | TEST_F(TypedTestSuitePStateDeathTest, DetectsExtraTest) {
  function TEST_F (line 239) | TEST_F(TypedTestSuitePStateDeathTest, DetectsMissedTest) {
  function TEST_F (line 247) | TEST_F(TypedTestSuitePStateDeathTest, DetectsTestAfterRegistration) {
  class DerivedTest (line 259) | class DerivedTest : public CommonTest<T> {}
  function TYPED_TEST_P (line 263) | TYPED_TEST_P(DerivedTest, ValuesAreCorrect) {
  function TYPED_TEST_P (line 275) | TYPED_TEST_P(DerivedTest, ValuesAreStillCorrect) {
  class TypeParametrizedTestWithNames (line 292) | class TypeParametrizedTestWithNames : public Test {}
  function TYPED_TEST_P (line 296) | TYPED_TEST_P(TypeParametrizedTestWithNames, TestSuiteName) {
  class TypeParametrizedTestNames (line 313) | class TypeParametrizedTestNames {
    method GetName (line 316) | static std::string GetName(int i) {
  class TypedTestP1 (line 333) | class TypedTestP1 : public Test {}
  function TYPED_TEST_P (line 341) | TYPED_TEST_P(TypedTestP1, A) {}
  function TYPED_TEST_P (line 342) | TYPED_TEST_P(TypedTestP1, B) {}
  class TypedTestP2 (line 351) | class TypedTestP2 : public Test {}
  function TYPED_TEST_P (line 357) | TYPED_TEST_P(TypedTestP2, A) {}
  type library2 (line 384) | namespace library2 {
    class NumericTest (line 387) | class NumericTest : public Test {}
    function TYPED_TEST_P (line 391) | TYPED_TEST_P(NumericTest, DefaultIsZero) { EXPECT_EQ(0, TypeParam()); }
    function TYPED_TEST_P (line 393) | TYPED_TEST_P(NumericTest, ZeroIsLessThanOne) {
    class TrimmedTest (line 406) | class TrimmedTest : public Test {}
    function TYPED_TEST_P (line 408) | TYPED_TEST_P(TrimmedTest, Test1) { EXPECT_STREQ("Test1", GetTestName()...
    function TYPED_TEST_P (line 409) | TYPED_TEST_P(TrimmedTest, Test2) { EXPECT_STREQ("Test2", GetTestName()...
    function TYPED_TEST_P (line 410) | TYPED_TEST_P(TrimmedTest, Test3) { EXPECT_STREQ("Test3", GetTestName()...
    function TYPED_TEST_P (line 411) | TYPED_TEST_P(TrimmedTest, Test4) { EXPECT_STREQ("Test4", GetTestName()...
    function TYPED_TEST_P (line 412) | TYPED_TEST_P(TrimmedTest, Test5) { EXPECT_STREQ("Test5", GetTestName()...
    type MyPair (line 416) | struct MyPair {}

FILE: googletest/test/gtest-unittest-api_test.cc
  type testing (line 43) | namespace testing {
    type internal (line 44) | namespace internal {
      type LessByName (line 47) | struct LessByName {
      class UnitTestHelper (line 53) | class UnitTestHelper {
        method TestSuite (line 57) | static TestSuite const** GetSortedTestSuites() {
        method TestSuite (line 72) | static const TestSuite* FindTestSuite(const char* name) {
        method TestInfo (line 84) | static TestInfo const** GetSortedTests(const TestSuite* test_suite) {
      class TestSuiteWithCommentTest (line 98) | class TestSuiteWithCommentTest : public Test {}
      function TYPED_TEST (line 100) | TYPED_TEST(TestSuiteWithCommentTest, Dummy) {}
      function TEST (line 108) | TEST(ApiTest, UnitTestImmutableAccessorsWork) {
      function AssertionResult (line 132) | AssertionResult IsNull(const char* str) {
      function TEST (line 139) | TEST(ApiTest, TestSuiteImmutableAccessorsWork) {
      function TEST (line 200) | TEST(ApiTest, TestSuiteDisabledAccessorsWork) {
      function TEST (line 221) | TEST(ApiTest, DISABLED_Dummy1) {}
      function TEST (line 222) | TEST(DISABLED_Test, Dummy2) {}
      class FinalSuccessChecker (line 224) | class FinalSuccessChecker : public Environment {
        method TearDown (line 226) | void TearDown() override {
  function main (line 322) | int main(int argc, char** argv) {

FILE: googletest/test/gtest_assert_by_exception_test.cc
  class ThrowListener (line 40) | class ThrowListener : public testing::EmptyTestEventListener {
    method OnTestPartResult (line 41) | void OnTestPartResult(const testing::TestPartResult& result) override {
  function Fail (line 52) | void Fail(const char* msg) {
  function AssertFalse (line 58) | static void AssertFalse() { ASSERT_EQ(2, 3) << "Expected failure"; }
  function TEST (line 62) | TEST(Test, Test) {
  function TEST (line 96) | TEST(Test, Test2) { kTestForContinuingTest = 1; }
  function main (line 98) | int main(int argc, char** argv) {

FILE: googletest/test/gtest_dirs_test.cc
  class SetEnv (line 14) | class SetEnv {
    method SetEnv (line 19) | SetEnv(const char* name, const char* value) : name_(name) {
  class MakeTempDir (line 47) | class MakeTempDir {
    method MakeTempDir (line 51) | explicit MakeTempDir(const std::string& testname) {
  function StartsWith (line 67) | bool StartsWith(const std::string& str, const std::string& prefix) {
  function TEST (line 71) | TEST(TempDirTest, InEnvironment) {
  function TEST (line 80) | TEST(TempDirTest, NotInEnvironment) {
  function TEST (line 85) | TEST(SrcDirTest, InEnvironment) {
  function TEST (line 94) | TEST(SrcDirTest, NotInEnvironment) {

FILE: googletest/test/gtest_environment_test.cc
  type FailureType (line 41) | enum FailureType { NO_FAILURE, NON_FATAL_FAILURE, FATAL_FAILURE }
  class MyEnvironment (line 51) | class MyEnvironment : public testing::Environment {
    method SetUp (line 56) | void SetUp() override {
    method TearDown (line 72) | void TearDown() override {
    method set_failure_in_set_up (line 79) | void set_failure_in_set_up(FailureType type) { failure_in_set_up_ = ty...
  function TEST (line 87) | TEST(FooTest, Bar) { test_was_run = true; }
  function Check (line 90) | void Check(bool condition, const char* msg) {
  function RunAllTests (line 101) | int RunAllTests(MyEnvironment* env, FailureType failure) {
  function MyEnvironment (line 112) | MyEnvironment* RegisterTestEnv() {
    method SetUp (line 56) | void SetUp() override {
    method TearDown (line 72) | void TearDown() override {
    method set_failure_in_set_up (line 79) | void set_failure_in_set_up(FailureType type) { failure_in_set_up_ = ty...
  function TestGlobalSetUp (line 121) | void TestGlobalSetUp() {
  function TestTestsRun (line 135) | void TestTestsRun() {
  function TestNoTestsRunSetUpFailure (line 149) | void TestNoTestsRunSetUpFailure() {
  function TestNoTestsSkipsSetUp (line 163) | void TestNoTestsSkipsSetUp() {
  function main (line 177) | int main(int argc, char** argv) {

FILE: googletest/test/gtest_help_test.py
  function is_bsd_based_os (line 51) | def is_bsd_based_os() -> bool:
  function run_with_flag (line 110) | def run_with_flag(flag):
  class GTestHelpTest (line 127) | class GTestHelpTest(gtest_test_utils.TestCase):
    method test_prints_help_with_full_flag (line 130) | def test_prints_help_with_full_flag(self):
    method test_runs_tests_without_help_flag (line 157) | def test_runs_tests_without_help_flag(self):
    method test_runs_tests_with_gtest_internal_flag (line 168) | def test_runs_tests_with_gtest_internal_flag(self):

FILE: googletest/test/gtest_help_test_.cc
  function TEST (line 38) | TEST(HelpFlagTest, ShouldNotBeRun) {
  function TEST (line 43) | TEST(DeathTest, UsedByPythonScriptToDetectSupportForDeathTestsInThisBina...

FILE: googletest/test/gtest_json_test_utils.py
  function normalize (line 35) | def normalize(obj):

FILE: googletest/test/gtest_list_output_unittest.py
  class GTestListTestsOutputUnitTest (line 226) | class GTestListTestsOutputUnitTest(gtest_test_utils.TestCase):
    method testXml (line 229) | def testXml(self):
    method testJSON (line 237) | def testJSON(self):
    method _GetOutput (line 245) | def _GetOutput(self, out_format):
    method _TestOutput (line 270) | def _TestOutput(self, test_format, expected_output):

FILE: googletest/test/gtest_list_output_unittest_.cc
  function TEST (line 43) | TEST(FooTest, Test1) {}
  function TEST (line 45) | TEST(FooTest, Test2) {}
  class FooTestFixture (line 47) | class FooTestFixture : public ::testing::Test {}
  function TEST_F (line 48) | TEST_F(FooTestFixture, Test3) {}
  function TEST_F (line 49) | TEST_F(FooTestFixture, Test4) {}
  class ValueParamTest (line 51) | class ValueParamTest : public ::testing::TestWithParam<int> {}
  function TEST_P (line 52) | TEST_P(ValueParamTest, Test5) {}
  function TEST_P (line 53) | TEST_P(ValueParamTest, Test6) {}
  class TypedTest (line 57) | class TypedTest : public ::testing::Test {}
  function TYPED_TEST (line 60) | TYPED_TEST(TypedTest, Test7) {}
  function TYPED_TEST (line 61) | TYPED_TEST(TypedTest, Test8) {}
  class TypeParameterizedTestSuite (line 64) | class TypeParameterizedTestSuite : public ::testing::Test {}
  function TYPED_TEST_P (line 66) | TYPED_TEST_P(TypeParameterizedTestSuite, Test9) {}
  function TYPED_TEST_P (line 67) | TYPED_TEST_P(TypeParameterizedTestSuite, Test10) {}
  function main (line 73) | int main(int argc, char **argv) {

FILE: googletest/test/gtest_main_unittest.cc
  function TEST (line 37) | TEST(GTestMainTest, ShouldSucceed) {}

FILE: googletest/test/gtest_no_test_unittest.cc
  function main (line 35) | int main(int argc, char **argv) {

FILE: googletest/test/gtest_pred_impl_unittest.cc
  type Bool (line 54) | struct Bool {
    method Bool (line 55) | explicit Bool(int val) : value(val != 0) {}
    method Bool (line 59) | Bool operator+(const Bool& rhs) const { return Bool(value + rhs.value); }
  function PredFunction1 (line 75) | bool PredFunction1(T1 v1) {
  function PredFunction1Int (line 81) | bool PredFunction1Int(int v1) { return v1 > 0; }
  function PredFunction1Bool (line 82) | bool PredFunction1Bool(Bool v1) { return v1 > 0; }
  type PredFunctor1 (line 85) | struct PredFunctor1 {
  function PredFormatFunction1 (line 94) | testing::AssertionResult PredFormatFunction1(const char* e1, const T1& v...
  type PredFormatFunctor1 (line 102) | struct PredFormatFunctor1 {
  class Predicate1Test (line 111) | class Predicate1Test : public testing::Test {
    method SetUp (line 113) | void SetUp() override {
    method TearDown (line 119) | void TearDown() override {
  function TEST_F (line 154) | TEST_F(EXPECT_PRED1Test, FunctionOnBuiltInTypeSuccess) {
  function TEST_F (line 161) | TEST_F(EXPECT_PRED1Test, FunctionOnUserTypeSuccess) {
  function TEST_F (line 168) | TEST_F(EXPECT_PRED1Test, FunctorOnBuiltInTypeSuccess) {
  function TEST_F (line 175) | TEST_F(EXPECT_PRED1Test, FunctorOnUserTypeSuccess) {
  function TEST_F (line 182) | TEST_F(EXPECT_PRED1Test, FunctionOnBuiltInTypeFailure) {
  function TEST_F (line 193) | TEST_F(EXPECT_PRED1Test, FunctionOnUserTypeFailure) {
  function TEST_F (line 204) | TEST_F(EXPECT_PRED1Test, FunctorOnBuiltInTypeFailure) {
  function TEST_F (line 215) | TEST_F(EXPECT_PRED1Test, FunctorOnUserTypeFailure) {
  function TEST_F (line 226) | TEST_F(ASSERT_PRED1Test, FunctionOnBuiltInTypeSuccess) {
  function TEST_F (line 233) | TEST_F(ASSERT_PRED1Test, FunctionOnUserTypeSuccess) {
  function TEST_F (line 240) | TEST_F(ASSERT_PRED1Test, FunctorOnBuiltInTypeSuccess) {
  function TEST_F (line 247) | TEST_F(ASSERT_PRED1Test, FunctorOnUserTypeSuccess) {
  function TEST_F (line 254) | TEST_F(ASSERT_PRED1Test, FunctionOnBuiltInTypeFailure) {
  function TEST_F (line 266) | TEST_F(ASSERT_PRED1Test, FunctionOnUserTypeFailure) {
  function TEST_F (line 278) | TEST_F(ASSERT_PRED1Test, FunctorOnBuiltInTypeFailure) {
  function TEST_F (line 290) | TEST_F(ASSERT_PRED1Test, FunctorOnUserTypeFailure) {
  function TEST_F (line 302) | TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnBuiltInTypeSuccess) {
  function TEST_F (line 309) | TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnUserTypeSuccess) {
  function TEST_F (line 316) | TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnBuiltInTypeSuccess) {
  function TEST_F (line 323) | TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnUserTypeSuccess) {
  function TEST_F (line 330) | TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnBuiltInTypeFailure) {
  function TEST_F (line 341) | TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnUserTypeFailure) {
  function TEST_F (line 352) | TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnBuiltInTypeFailure) {
  function TEST_F (line 363) | TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnUserTypeFailure) {
  function TEST_F (line 374) | TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnBuiltInTypeSuccess) {
  function TEST_F (line 381) | TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnUserTypeSuccess) {
  function TEST_F (line 388) | TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnBuiltInTypeSuccess) {
  function TEST_F (line 395) | TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnUserTypeSuccess) {
  function TEST_F (line 402) | TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnBuiltInTypeFailure) {
  function TEST_F (line 414) | TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnUserTypeFailure) {
  function TEST_F (line 426) | TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnBuiltInTypeFailure) {
  function TEST_F (line 438) | TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnUserTypeFailure) {
  function PredFunction2 (line 451) | bool PredFunction2(T1 v1, T2 v2) {
  function PredFunction2Int (line 457) | bool PredFunction2Int(int v1, int v2) { return v1 + v2 > 0; }
  function PredFunction2Bool (line 458) | bool PredFunction2Bool(Bool v1, Bool v2) { return v1 + v2 > 0; }
  type PredFunctor2 (line 461) | struct PredFunctor2 {
  function PredFormatFunction2 (line 470) | testing::AssertionResult PredFormatFunction2(const char* e1, const char*...
  type PredFormatFunctor2 (line 480) | struct PredFormatFunctor2 {
  class Predicate2Test (line 490) | class Predicate2Test : public testing::Test {
    method SetUp (line 492) | void SetUp() override {
    method TearDown (line 498) | void TearDown() override {
  function TEST_F (line 537) | TEST_F(EXPECT_PRED2Test, FunctionOnBuiltInTypeSuccess) {
  function TEST_F (line 544) | TEST_F(EXPECT_PRED2Test, FunctionOnUserTypeSuccess) {
  function TEST_F (line 551) | TEST_F(EXPECT_PRED2Test, FunctorOnBuiltInTypeSuccess) {
  function TEST_F (line 558) | TEST_F(EXPECT_PRED2Test, FunctorOnUserTypeSuccess) {
  function TEST_F (line 565) | TEST_F(EXPECT_PRED2Test, FunctionOnBuiltInTypeFailure) {
  function TEST_F (line 576) | TEST_F(EXPECT_PRED2Test, FunctionOnUserTypeFailure) {
  function TEST_F (line 587) | TEST_F(EXPECT_PRED2Test, FunctorOnBuiltInTypeFailure) {
  function TEST_F (line 598) | TEST_F(EXPECT_PRED2Test, FunctorOnUserTypeFailure) {
  function TEST_F (line 609) | TEST_F(ASSERT_PRED2Test, FunctionOnBuiltInTypeSuccess) {
  function TEST_F (line 616) | TEST_F(ASSERT_PRED2Test, FunctionOnUserTypeSuccess) {
  function TEST_F (line 623) | TEST_F(ASSERT_PRED2Test, FunctorOnBuiltInTypeSuccess) {
  function TEST_F (line 630) | TEST_F(ASSERT_PRED2Test, FunctorOnUserTypeSuccess) {
  function TEST_F (line 637) | TEST_F(ASSERT_PRED2Test, FunctionOnBuiltInTypeFailure) {
  function TEST_F (line 649) | TEST_F(ASSERT_PRED2Test, FunctionOnUserTypeFailure) {
  function TEST_F (line 661) | TEST_F(ASSERT_PRED2Test, FunctorOnBuiltInTypeFailure) {
  function TEST_F (line 673) | TEST_F(ASSERT_PRED2Test, FunctorOnUserTypeFailure) {
  function TEST_F (line 685) | TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnBuiltInTypeSuccess) {
  function TEST_F (line 692) | TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnUserTypeSuccess) {
  function TEST_F (line 699) | TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnBuiltInTypeSuccess) {
  function TEST_F (line 706) | TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnUserTypeSuccess) {
  function TEST_F (line 713) | TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnBuiltInTypeFailure) {
  function TEST_F (line 724) | TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnUserTypeFailure) {
  function TEST_F (line 735) | TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnBuiltInTypeFailure) {
  function TEST_F (line 746) | TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnUserTypeFailure) {
  function TEST_F (line 757) | TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnBuiltInTypeSuccess) {
  function TEST_F (line 764) | TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnUserTypeSuccess) {
  function TEST_F (line 771) | TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnBuiltInTypeSuccess) {
  function TEST_F (line 778) | TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnUserTypeSuccess) {
  function TEST_F (line 785) | TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnBuiltInTypeFailure) {
  function TEST_F (line 797) | TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnUserTypeFailure) {
  function TEST_F (line 809) | TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnBuiltInTypeFailure) {
  function TEST_F (line 821) | TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnUserTypeFailure) {
  function PredFunction3 (line 834) | bool PredFunction3(T1 v1, T2 v2, T3 v3) {
  function PredFunction3Int (line 840) | bool PredFunction3Int(int v1, int v2, int v3) { return v1 + v2 + v3 > 0; }
  function PredFunction3Bool (line 841) | bool PredFunction3Bool(Bool v1, Bool v2, Bool v3) { return v1 + v2 + v3 ...
  type PredFunctor3 (line 844) | struct PredFunctor3 {
  function PredFormatFunction3 (line 853) | testing::AssertionResult PredFormatFunction3(const char* e1, const char*...
  type PredFormatFunctor3 (line 865) | struct PredFormatFunctor3 {
  class Predicate3Test (line 876) | class Predicate3Test : public testing::Test {
    method SetUp (line 878) | void SetUp() override {
    method TearDown (line 884) | void TearDown() override {
  function TEST_F (line 927) | TEST_F(EXPECT_PRED3Test, FunctionOnBuiltInTypeSuccess) {
  function TEST_F (line 934) | TEST_F(EXPECT_PRED3Test, FunctionOnUserTypeSuccess) {
  function TEST_F (line 941) | TEST_F(EXPECT_PRED3Test, FunctorOnBuiltInTypeSuccess) {
  function TEST_F (line 948) | TEST_F(EXPECT_PRED3Test, FunctorOnUserTypeSuccess) {
  function TEST_F (line 955) | TEST_F(EXPECT_PRED3Test, FunctionOnBuiltInTypeFailure) {
  function TEST_F (line 966) | TEST_F(EXPECT_PRED3Test, FunctionOnUserTypeFailure) {
  function TEST_F (line 977) | TEST_F(EXPECT_PRED3Test, FunctorOnBuiltInTypeFailure) {
  function TEST_F (line 988) | TEST_F(EXPECT_PRED3Test, FunctorOnUserTypeFailure) {
  function TEST_F (line 999) | TEST_F(ASSERT_PRED3Test, FunctionOnBuiltInTypeSuccess) {
  function TEST_F (line 1006) | TEST_F(ASSERT_PRED3Test, FunctionOnUserTypeSuccess) {
  function TEST_F (line 1013) | TEST_F(ASSERT_PRED3Test, FunctorOnBuiltInTypeSuccess) {
  function TEST_F (line 1020) | TEST_F(ASSERT_PRED3Test, FunctorOnUserTypeSuccess) {
  function TEST_F (line 1027) | TEST_F(ASSERT_PRED3Test, FunctionOnBuiltInTypeFailure) {
  function TEST_F (line 1039) | TEST_F(ASSERT_PRED3Test, FunctionOnUserTypeFailure) {
  function TEST_F (line 1051) | TEST_F(ASSERT_PRED3Test, FunctorOnBuiltInTypeFailure) {
  function TEST_F (line 1063) | TEST_F(ASSERT_PRED3Test, FunctorOnUserTypeFailure) {
  function TEST_F (line 1075) | TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnBuiltInTypeSuccess) {
  function TEST_F (line 1082) | TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnUserTypeSuccess) {
  function TEST_F (line 1090) | TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnBuiltInTypeSuccess) {
  function TEST_F (line 1097) | TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnUserTypeSuccess) {
  function TEST_F (line 1105) | TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnBuiltInTypeFailure) {
  function TEST_F (line 1116) | TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnUserTypeFailure) {
  function TEST_F (line 1128) | TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnBuiltInTypeFailure) {
  function TEST_F (line 1139) | TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnUserTypeFailure) {
  function TEST_F (line 1151) | TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnBuiltInTypeSuccess) {
  function TEST_F (line 1158) | TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnUserTypeSuccess) {
  function TEST_F (line 1166) | TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnBuiltInTypeSuccess) {
  function TEST_F (line 1173) | TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnUserTypeSuccess) {
  function TEST_F (line 1181) | TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnBuiltInTypeFailure) {
  function TEST_F (line 1193) | TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnUserTypeFailure) {
  function TEST_F (line 1206) | TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnBuiltInTypeFailure) {
  function TEST_F (line 1218) | TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnUserTypeFailure) {
  function PredFunction4 (line 1232) | bool PredFunction4(T1 v1, T2 v2, T3 v3, T4 v4) {
  function PredFunction4Int (line 1238) | bool PredFunction4Int(int v1, int v2, int v3, int v4) {
  function PredFunction4Bool (line 1241) | bool PredFunction4Bool(Bool v1, Bool v2, Bool v3, Bool v4) {
  type PredFunctor4 (line 1246) | struct PredFunctor4 {
  function PredFormatFunction4 (line 1255) | testing::AssertionResult PredFormatFunction4(const char* e1, const char*...
  type PredFormatFunctor4 (line 1268) | struct PredFormatFunctor4 {
  class Predicate4Test (line 1280) | class Predicate4Test : public testing::Test {
    method SetUp (line 1282) | void SetUp() override {
    method TearDown (line 1288) | void TearDown() override {
  function TEST_F (line 1335) | TEST_F(EXPECT_PRED4Test, FunctionOnBuiltInTypeSuccess) {
  function TEST_F (line 1342) | TEST_F(EXPECT_PRED4Test, FunctionOnUserTypeSuccess) {
  function TEST_F (line 1350) | TEST_F(EXPECT_PRED4Test, FunctorOnBuiltInTypeSuccess) {
  function TEST_F (line 1357) | TEST_F(EXPECT_PRED4Test, FunctorOnUserTypeSuccess) {
  function TEST_F (line 1365) | TEST_F(EXPECT_PRED4Test, FunctionOnBuiltInTypeFailure) {
  function TEST_F (line 1376) | TEST_F(EXPECT_PRED4Test, FunctionOnUserTypeFailure) {
  function TEST_F (line 1388) | TEST_F(EXPECT_PRED4Test, FunctorOnBuiltInTypeFailure) {
  function TEST_F (line 1399) | TEST_F(EXPECT_PRED4Test, FunctorOnUserTypeFailure) {
  function TEST_F (line 1411) | TEST_F(ASSERT_PRED4Test, FunctionOnBuiltInTypeSuccess) {
  function TEST_F (line 1418) | TEST_F(ASSERT_PRED4Test, FunctionOnUserTypeSuccess) {
  function TEST_F (line 1426) | TEST_F(ASSERT_PRED4Test, FunctorOnBuiltInTypeSuccess) {
  function TEST_F (line 1433) | TEST_F(ASSERT_PRED4Test, FunctorOnUserTypeSuccess) {
  function TEST_F (line 1441) | TEST_F(ASSERT_PRED4Test, FunctionOnBuiltInTypeFailure) {
  function TEST_F (line 1453) | TEST_F(ASSERT_PRED4Test, FunctionOnUserTypeFailure) {
  function TEST_F (line 1466) | TEST_F(ASSERT_PRED4Test, FunctorOnBuiltInTypeFailure) {
  function TEST_F (line 1478) | TEST_F(ASSERT_PRED4Test, FunctorOnUserTypeFailure) {
  function TEST_F (line 1491) | TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnBuiltInTypeSuccess) {
  function TEST_F (line 1498) | TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnUserTypeSuccess) {
  function TEST_F (line 1506) | TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnBuiltInTypeSuccess) {
  function TEST_F (line 1513) | TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnUserTypeSuccess) {
  function TEST_F (line 1521) | TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnBuiltInTypeFailure) {
  function TEST_F (line 1532) | TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnUserTypeFailure) {
  function TEST_F (line 1544) | TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnBuiltInTypeFailure) {
  function TEST_F (line 1555) | TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnUserTypeFailure) {
  function TEST_F (line 1567) | TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnBuiltInTypeSuccess) {
  function TEST_F (line 1574) | TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnUserTypeSuccess) {
  function TEST_F (line 1582) | TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnBuiltInTypeSuccess) {
  function TEST_F (line 1589) | TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnUserTypeSuccess) {
  function TEST_F (line 1597) | TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnBuiltInTypeFailure) {
  function TEST_F (line 1609) | TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnUserTypeFailure) {
  function TEST_F (line 1622) | TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnBuiltInTypeFailure) {
  function TEST_F (line 1634) | TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnUserTypeFailure) {
  function PredFunction5 (line 1648) | bool PredFunction5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {
  function PredFunction5Int (line 1654) | bool PredFunction5Int(int v1, int v2, int v3, int v4, int v5) {
  function PredFunction5Bool (line 1657) | bool PredFunction5Bool(Bool v1, Bool v2, Bool v3, Bool v4, Bool v5) {
  type PredFunctor5 (line 1662) | struct PredFunctor5 {
  function PredFormatFunction5 (line 1672) | testing::AssertionResult PredFormatFunction5(const char* e1, const char*...
  type PredFormatFunctor5 (line 1686) | struct PredFormatFunctor5 {
  class Predicate5Test (line 1699) | class Predicate5Test : public testing::Test {
    method SetUp (line 1701) | void SetUp() override {
    method TearDown (line 1707) | void TearDown() override {
  function TEST_F (line 1758) | TEST_F(EXPECT_PRED5Test, FunctionOnBuiltInTypeSuccess) {
  function TEST_F (line 1765) | TEST_F(EXPECT_PRED5Test, FunctionOnUserTypeSuccess) {
  function TEST_F (line 1773) | TEST_F(EXPECT_PRED5Test, FunctorOnBuiltInTypeSuccess) {
  function TEST_F (line 1780) | TEST_F(EXPECT_PRED5Test, FunctorOnUserTypeSuccess) {
  function TEST_F (line 1788) | TEST_F(EXPECT_PRED5Test, FunctionOnBuiltInTypeFailure) {
  function TEST_F (line 1799) | TEST_F(EXPECT_PRED5Test, FunctionOnUserTypeFailure) {
  function TEST_F (line 1811) | TEST_F(EXPECT_PRED5Test, FunctorOnBuiltInTypeFailure) {
  function TEST_F (line 1822) | TEST_F(EXPECT_PRED5Test, FunctorOnUserTypeFailure) {
  function TEST_F (line 1834) | TEST_F(ASSERT_PRED5Test, FunctionOnBuiltInTypeSuccess) {
  function TEST_F (line 1841) | TEST_F(ASSERT_PRED5Test, FunctionOnUserTypeSuccess) {
  function TEST_F (line 1849) | TEST_F(ASSERT_PRED5Test, FunctorOnBuiltInTypeSuccess) {
  function TEST_F (line 1856) | TEST_F(ASSERT_PRED5Test, FunctorOnUserTypeSuccess) {
  function TEST_F (line 1864) | TEST_F(ASSERT_PRED5Test, FunctionOnBuiltInTypeFailure) {
  function TEST_F (line 1876) | TEST_F(ASSERT_PRED5Test, FunctionOnUserTypeFailure) {
  function TEST_F (line 1889) | TEST_F(ASSERT_PRED5Test, FunctorOnBuiltInTypeFailure) {
  function TEST_F (line 1901) | TEST_F(ASSERT_PRED5Test, FunctorOnUserTypeFailure) {
  function TEST_F (line 1914) | TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnBuiltInTypeSuccess) {
  function TEST_F (line 1921) | TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnUserTypeSuccess) {
  function TEST_F (line 1929) | TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnBuiltInTypeSuccess) {
  function TEST_F (line 1936) | TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnUserTypeSuccess) {
  function TEST_F (line 1944) | TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnBuiltInTypeFailure) {
  function TEST_F (line 1956) | TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnUserTypeFailure) {
  function TEST_F (line 1968) | TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnBuiltInTypeFailure) {
  function TEST_F (line 1980) | TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnUserTypeFailure) {
  function TEST_F (line 1992) | TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnBuiltInTypeSuccess) {
  function TEST_F (line 1999) | TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnUserTypeSuccess) {
  function TEST_F (line 2007) | TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnBuiltInTypeSuccess) {
  function TEST_F (line 2014) | TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnUserTypeSuccess) {
  function TEST_F (line 2022) | TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnBuiltInTypeFailure) {
  function TEST_F (line 2035) | TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnUserTypeFailure) {
  function TEST_F (line 2048) | TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnBuiltInTypeFailure) {
  function TEST_F (line 2061) | TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnUserTypeFailure) {

FILE: googletest/test/gtest_premature_exit_test.cc
  class PrematureExitTest (line 46) | class PrematureExitTest : public Test {
    method FileExists (line 49) | static bool FileExists(const char* filepath) {
    method PrematureExitTest (line 55) | PrematureExitTest() {
    method PrematureExitFileExists (line 65) | bool PrematureExitFileExists() const {
  function TEST_F (line 79) | TEST_F(PrematureExitDeathTest, FileExistsDuringExecutionOfDeathTest) {
  function TEST_F (line 99) | TEST_F(PrematureExitTest, PrematureExitFileExistsDuringTestExecution) {
  function main (line 111) | int main(int argc, char** argv) {

FILE: googletest/test/gtest_prod_test.cc
  function TEST (line 38) | TEST(PrivateCodeTest, CanAccessPrivateMembers) {
  function TEST_F (line 50) | TEST_F(PrivateCodeFixtureTest, CanAccessPrivateMembers) {

FILE: googletest/test/gtest_repeat_test.cc
  class MyEnvironment (line 62) | class MyEnvironment : public testing::Environment {
    method SetUp (line 64) | void SetUp() override { g_environment_set_up_count++; }
    method TearDown (line 65) | void TearDown() override { g_environment_tear_down_count++; }
  function TEST (line 72) | TEST(FooTest, ShouldFail) {
  function TEST (line 81) | TEST(FooTest, ShouldPass) { g_should_pass_count++; }
  function TEST (line 88) | TEST(BarDeathTest, ThreadSafeAndFast) {
  class MyParamTest (line 102) | class MyParamTest : public testing::TestWithParam<int> {}
  function TEST_P (line 104) | TEST_P(MyParamTest, ShouldPass) {
  function ResetCounts (line 112) | void ResetCounts() {
  function CheckCounts (line 123) | void CheckCounts(int expected) {
  function TestRepeatUnspecified (line 133) | void TestRepeatUnspecified() {
  function TestRepeat (line 140) | void TestRepeat(int repeat) {
  function TestRepeatWithEmptyFilter (line 151) | void TestRepeatWithEmptyFilter(int repeat) {
  function TestRepeatWithFilterForSuccessfulTests (line 163) | void TestRepeatWithFilterForSuccessfulTests(int repeat) {
  function TestRepeatWithFilterForFailedTests (line 180) | void TestRepeatWithFilterForFailedTests(int repeat) {
  function main (line 197) | int main(int argc, char **argv) {

FILE: googletest/test/gtest_skip_check_output_test.py
  class SkipEntireEnvironmentTest (line 47) | class SkipEntireEnvironmentTest(gtest_test_utils.TestCase):
    method testSkipEntireEnvironmentTest (line 49) | def testSkipEntireEnvironmentTest(self):

FILE: googletest/test/gtest_skip_environment_check_output_test.py
  class SkipEntireEnvironmentTest (line 47) | class SkipEntireEnvironmentTest(gtest_test_utils.TestCase):
    method testSkipEntireEnvironmentTest (line 49) | def testSkipEntireEnvironmentTest(self):

FILE: googletest/test/gtest_skip_in_environment_setup_test.cc
  class SetupEnvironment (line 37) | class SetupEnvironment : public testing::Environment {
    method SetUp (line 39) | void SetUp() override { GTEST_SKIP() << "Skipping the entire environme...
  function TEST (line 42) | TEST(Test, AlwaysFails) { EXPECT_EQ(true, false); }
  function main (line 44) | int main(int argc, char **argv) {

FILE: googletest/test/gtest_skip_test.cc
  function TEST (line 37) | TEST(SkipTest, DoesSkip) {
  class Fixture (line 42) | class Fixture : public Test {
    method SetUp (line 44) | void SetUp() override {
  function TEST_F (line 49) | TEST_F(Fixture, SkipsOneTest) { EXPECT_EQ(5, 7); }
  function TEST_F (line 51) | TEST_F(Fixture, SkipsAnotherTest) { EXPECT_EQ(99, 100); }

FILE: googletest/test/gtest_sole_header_test.cc
  function Subroutine (line 38) | void Subroutine() { EXPECT_EQ(42, 42); }
  function TEST (line 40) | TEST(NoFatalFailureTest, ExpectNoFatalFailure) {
  function TEST (line 47) | TEST(NoFatalFailureTest, AssertNoFatalFailure) {

FILE: googletest/test/gtest_stress_test.cc
  type testing (line 43) | namespace testing {
    function IdToKey (line 57) | std::string IdToKey(int id, const char* suffix) {
    function IdToString (line 63) | std::string IdToString(int id) {
    function ExpectKeyAndValueWereRecordedForId (line 69) | void ExpectKeyAndValueWereRecordedForId(
    function ManyAsserts (line 81) | void ManyAsserts(int id) {
    function CheckTestFailureCount (line 109) | void CheckTestFailureCount(int expected_failures) {
    function TEST (line 119) | TEST(StressTest, CanUseScopedTraceAndAssertionsInManyThreads) {
    function FailingThread (line 153) | void FailingThread(bool is_fatal) {
    function GenerateFatalFailureInAnotherThread (line 162) | void GenerateFatalFailureInAnotherThread(bool is_fatal) {
    function TEST (line 167) | TEST(NoFatalFailureTest, ExpectNoFatalFailureIgnoresFailuresInOtherThr...
    function AssertNoFatalFailureIgnoresFailuresInOtherThreads (line 175) | void AssertNoFatalFailureIgnoresFailuresInOtherThreads() {
    function TEST (line 178) | TEST(NoFatalFailureTest, AssertNoFatalFailureIgnoresFailuresInOtherThr...
    function TEST (line 187) | TEST(FatalFailureTest, ExpectFatalFailureIgnoresFailuresInOtherThreads) {
    function TEST (line 194) | TEST(FatalFailureOnAllThreadsTest, ExpectFatalFailureOnAllThreads) {
    function TEST (line 205) | TEST(NonFatalFailureTest, ExpectNonFatalFailureIgnoresFailuresInOtherT...
    function TEST (line 213) | TEST(NonFatalFailureOnAllThreadsTest, ExpectNonFatalFailureOnAllThread...
  function main (line 227) | int main(int argc, char** argv) {
  function TEST (line 238) | TEST(StressTest,
  function main (line 241) | int main(int argc, char **argv) {

FILE: googletest/test/gtest_test_macro_stack_footprint_test.cc
  function main (line 83) | int main(int argc, char **argv) {

FILE: googletest/test/gtest_test_utils.py
  function SetEnvVar (line 56) | def SetEnvVar(env_var, value):
  function _ParseAndStripGTestFlags (line 78) | def _ParseAndStripGTestFlags(argv):
  function GetFlag (line 105) | def GetFlag(flag):
  function GetSourceDir (line 116) | def GetSourceDir():
  function GetBuildDir (line 122) | def GetBuildDir():
  function _RemoveTempDir (line 130) | def _RemoveTempDir():
  function GetTempDir (line 137) | def GetTempDir():
  function GetTestExecutablePath (line 144) | def GetTestExecutablePath(executable_name, build_dir=None):
  function GetExitStatus (line 177) | def GetExitStatus(exit_code):
  class Subprocess (line 197) | class Subprocess:
    method __init__ (line 199) | def __init__(self, command, working_dir=None, capture_stderr=True, env...
  function Main (line 250) | def Main():

FILE: googletest/test/gtest_testbridge_test.py
  function Assert (line 41) | def Assert(condition):
  class GTestTestFilterTest (line 46) | class GTestTestFilterTest(gtest_test_utils.TestCase):
    method testTestExecutionIsFiltered (line 48) | def testTestExecutionIsFiltered(self):

FILE: googletest/test/gtest_testbridge_test_.cc
  function TEST (line 38) | TEST(TestFilterTest, TestThatSucceeds) {}
  function TEST (line 40) | TEST(TestFilterTest, TestThatFails) {

FILE: googletest/test/gtest_throw_on_failure_ex_test.cc
  function Fail (line 44) | void Fail(const char* msg) {
  function TestFailureThrowsRuntimeError (line 52) | void TestFailureThrowsRuntimeError() {
  function main (line 79) | int main(int argc, char** argv) {

FILE: googletest/test/gtest_unittest.cc
  function TEST (line 39) | TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) {
  type ConvertibleGlobalType (line 76) | struct ConvertibleGlobalType {
  type testing (line 91) | namespace testing {
    type internal (line 92) | namespace internal {
      class StreamingListenerTest (line 96) | class StreamingListenerTest : public Test {
        class FakeSocketWriter (line 98) | class FakeSocketWriter : public StreamingListener::AbstractSocketW...
          method Send (line 101) | void Send(const std::string& message) override { output_ += mess...
        method StreamingListenerTest (line 106) | StreamingListenerTest()
      function TEST_F (line 121) | TEST_F(StreamingListenerTest, OnTestProgramEnd) {
      function TEST_F (line 127) | TEST_F(StreamingListenerTest, OnTestIterationEnd) {
      function TEST_F (line 133) | TEST_F(StreamingListenerTest, OnTestSuiteStart) {
      function TEST_F (line 139) | TEST_F(StreamingListenerTest, OnTestSuiteEnd) {
      function TEST_F (line 145) | TEST_F(StreamingListenerTest, OnTestStart) {
      function TEST_F (line 151) | TEST_F(StreamingListenerTest, OnTestEnd) {
      function TEST_F (line 157) | TEST_F(StreamingListenerTest, OnTestPartResult) {
      class TestEventListenersAccessor (line 172) | class TestEventListenersAccessor {
        method TestEventListener (line 174) | static TestEventListener* GetRepeater(TestEventListeners* listener...
        method SetDefaultResultPrinter (line 178) | static void SetDefaultResultPrinter(TestEventListeners* listeners,
        method SetDefaultXmlGenerator (line 182) | static void SetDefaultXmlGenerator(TestEventListeners* listeners,
        method EventForwardingEnabled (line 187) | static bool EventForwardingEnabled(const TestEventListeners& liste...
        method SuppressEventForwarding (line 191) | static void SuppressEventForwarding(TestEventListeners* listeners) {
      class UnitTestRecordPropertyTestHelper (line 196) | class UnitTestRecordPropertyTestHelper : public Test {
        method UnitTestRecordPropertyTestHelper (line 198) | UnitTestRecordPropertyTestHelper() = default;
        method UnitTestRecordProperty (line 201) | void UnitTestRecordProperty(const char* key, const std::string& va...
    function TEST (line 4291) | TEST(SuccessfulAssertionTest, SUCCEED) {
    function TEST (line 4298) | TEST(SuccessfulAssertionTest, EXPECT) {
    function TEST (line 4304) | TEST(SuccessfulAssertionTest, EXPECT_STR) {
    function TEST (line 4310) | TEST(SuccessfulAssertionTest, ASSERT) {
    function TEST (line 4316) | TEST(SuccessfulAssertionTest, ASSERT_STR) {
    class TestInfoTest (line 5306) | class TestInfoTest : public Test {
      method TestInfo (line 5308) | static const TestInfo* GetTestInfo(const char* test_name) {
      method TestResult (line 5319) | static const TestResult* GetTestResult(const TestInfo* test_info) {
    function TEST_F (line 5325) | TEST_F(TestInfoTest, Names) {
    function TEST_F (line 5333) | TEST_F(TestInfoTest, result) {
    function TEST (line 5351) | TEST(CodeLocationForTEST, Verify) {
    class CodeLocationForTESTF (line 5355) | class CodeLocationForTESTF : public Test {}
    function TEST_F (line 5357) | TEST_F(CodeLocationForTESTF, Verify) {
    class CodeLocationForTESTP (line 5361) | class CodeLocationForTESTP : public TestWithParam<int> {}
    function TEST_P (line 5363) | TEST_P(CodeLocationForTESTP, Verify) {
    class CodeLocationForTYPEDTEST (line 5370) | class CodeLocationForTYPEDTEST : public Test {}
    function TYPED_TEST (line 5374) | TYPED_TEST(CodeLocationForTYPEDTEST, Verify) {
    class CodeLocationForTYPEDTESTP (line 5379) | class CodeLocationForTYPEDTESTP : public Test {}
    function TYPED_TEST_P (line 5383) | TYPED_TEST_P(CodeLocationForTYPEDTESTP, Verify) {
    class SetUpTestCaseTest (line 5397) | class SetUpTestCaseTest : public Test {
      method SetUpTestCase (line 5401) | static void SetUpTestCase() {
      method TearDownTestCase (line 5418) | static void TearDownTestCase() {
      method SetUp (line 5432) | void SetUp() override {
    function TEST_F (line 5449) | TEST_F(SetUpTestCaseTest, Test1) { EXPECT_STRNE(nullptr, shared_resour...
    function TEST_F (line 5452) | TEST_F(SetUpTestCaseTest, Test2) { EXPECT_STREQ("123", shared_resource...
    class SetUpTestSuiteTest (line 5456) | class SetUpTestSuiteTest : public Test {
      method SetUpTestSuite (line 5460) | static void SetUpTestSuite() {
      method TearDownTestSuite (line 5477) | static void TearDownTestSuite() {
      method SetUp (line 5491) | void SetUp() override {
    function TEST_F (line 5508) | TEST_F(SetUpTestSuiteTest, TestSetupTestSuite1) {
    function TEST_F (line 5513) | TEST_F(SetUpTestSuiteTest, TestSetupTestSuite2) {
    type Flags (line 5520) | struct Flags {
      method Flags (line 5522) | Flags()
      method Flags (line 5545) | static Flags AlsoRunDisabledTests(bool also_run_disabled_tests) {
      method Flags (line 5553) | static Flags BreakOnFailure(bool break_on_failure) {
      method Flags (line 5561) | static Flags CatchExceptions(bool catch_exceptions) {
      method Flags (line 5569) | static Flags DeathTestUseFork(bool death_test_use_fork) {
      method Flags (line 5577) | static Flags FailFast(bool fail_fast) {
      method Flags (line 5585) | static Flags Filter(const char* filter) {
      method Flags (line 5593) | static Flags ListTests(bool list_tests) {
      method Flags (line 5601) | static Flags Output(const char* output) {
      method Flags (line 5609) | static Flags Brief(bool brief) {
      method Flags (line 5617) | static Flags PrintTime(bool print_time) {
      method Flags (line 5625) | static Flags RandomSeed(int32_t random_seed) {
      method Flags (line 5633) | static Flags Repeat(int32_t repeat) {
      method Flags (line 5641) | static Flags RecreateEnvironmentsWhenRepeating(
      method Flags (line 5651) | static Flags Shuffle(bool shuffle) {
      method Flags (line 5659) | static Flags StackTraceDepth(int32_t stack_trace_depth) {
      method Flags (line 5667) | static Flags StreamResultTo(const char* stream_result_to) {
      method Flags (line 5675) | static Flags ThrowOnFailure(bool throw_on_failure) {
    class ParseFlagsTest (line 5702) | class ParseFlagsTest : public Test {
      method SetUp (line 5705) | void SetUp() override {
      method AssertStringArrayEq (line 5727) | static void AssertStringArrayEq(int size1, CharType** array1, int si...
      method CheckFlags (line 5737) | static void CheckFlags(const Flags& expected) {
      method TestParsingFlags (line 5765) | static void TestParsingFlags(int argc1, const CharType** argv1, int ...
    function TEST_F (line 5817) | TEST_F(ParseFlagsTest, Empty) {
    function TEST_F (line 5826) | TEST_F(ParseFlagsTest, NoFlag) {
    function TEST_F (line 5835) | TEST_F(ParseFlagsTest, FailFast) {
    function TEST_F (line 5844) | TEST_F(ParseFlagsTest, FilterEmpty) {
    function TEST_F (line 5853) | TEST_F(ParseFlagsTest, FilterNonEmpty) {
    function TEST_F (line 5862) | TEST_F(ParseFlagsTest, BreakOnFailureWithoutValue) {
    function TEST_F (line 5871) | TEST_F(ParseFlagsTest, BreakOnFailureFalse_0) {
    function TEST_F (line 5880) | TEST_F(ParseFlagsTest, BreakOnFailureFalse_f) {
    function TEST_F (line 5889) | TEST_F(ParseFlagsTest, BreakOnFailureFalse_F) {
    function TEST_F (line 5899) | TEST_F(ParseFlagsTest, BreakOnFailureTrue) {
    function TEST_F (line 5908) | TEST_F(ParseFlagsTest, CatchExceptions) {
    function TEST_F (line 5917) | TEST_F(ParseFlagsTest, DeathTestUseFork) {
    function TEST_F (line 5927) | TEST_F(ParseFlagsTest, DuplicatedFlags) {
    function TEST_F (line 5937) | TEST_F(ParseFlagsTest, UnrecognizedFlag) {
    function TEST_F (line 5951) | TEST_F(ParseFlagsTest, ListTestsFlag) {
    function TEST_F (line 5960) | TEST_F(ParseFlagsTest, ListTestsTrue) {
    function TEST_F (line 5969) | TEST_F(ParseFlagsTest, ListTestsFalse) {
    function TEST_F (line 5978) | TEST_F(ParseFlagsTest, ListTestsFalse_f) {
    function TEST_F (line 5987) | TEST_F(ParseFlagsTest, ListTestsFalse_F) {
    function TEST_F (line 5996) | TEST_F(ParseFlagsTest, OutputXml) {
    function TEST_F (line 6005) | TEST_F(ParseFlagsTest, OutputXmlFile) {
    function TEST_F (line 6014) | TEST_F(ParseFlagsTest, OutputXmlDirectory) {
    function TEST_F (line 6025) | TEST_F(ParseFlagsTest, BriefFlag) {
    function TEST_F (line 6034) | TEST_F(ParseFlagsTest, BriefFlagTrue) {
    function TEST_F (line 6043) | TEST_F(ParseFlagsTest, BriefFlagFalse) {
    function TEST_F (line 6052) | TEST_F(ParseFlagsTest, PrintTimeFlag) {
    function TEST_F (line 6061) | TEST_F(ParseFlagsTest, PrintTimeTrue) {
    function TEST_F (line 6070) | TEST_F(ParseFlagsTest, PrintTimeFalse) {
    function TEST_F (line 6079) | TEST_F(ParseFlagsTest, PrintTimeFalse_f) {
    function TEST_F (line 6088) | TEST_F(ParseFlagsTest, PrintTimeFalse_F) {
    function TEST_F (line 6097) | TEST_F(ParseFlagsTest, RandomSeed) {
    function TEST_F (line 6106) | TEST_F(ParseFlagsTest, Repeat) {
    function TEST_F (line 6115) | TEST_F(ParseFlagsTest, RecreateEnvironmentsWhenRepeating) {
    function TEST_F (line 6129) | TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFlag) {
    function TEST_F (line 6139) | TEST_F(ParseFlagsTest, AlsoRunDisabledTestsTrue) {
    function TEST_F (line 6150) | TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFalse) {
    function TEST_F (line 6161) | TEST_F(ParseFlagsTest, ShuffleWithoutValue) {
    function TEST_F (line 6170) | TEST_F(ParseFlagsTest, ShuffleFalse_0) {
    function TEST_F (line 6179) | TEST_F(ParseFlagsTest, ShuffleTrue) {
    function TEST_F (line 6188) | TEST_F(ParseFlagsTest, StackTraceDepth) {
    function TEST_F (line 6196) | TEST_F(ParseFlagsTest, StreamResultTo) {
    function TEST_F (line 6207) | TEST_F(ParseFlagsTest, ThrowOnFailureWithoutValue) {
    function TEST_F (line 6216) | TEST_F(ParseFlagsTest, ThrowOnFailureFalse_0) {
    function TEST_F (line 6226) | TEST_F(ParseFlagsTest, ThrowOnFailureTrue) {
    function TEST_F (line 6235) | TEST_F(ParseFlagsTest, FilterBad) {
    function TEST_F (line 6254) | TEST_F(ParseFlagsTest, OutputEmpty) {
    function TEST_F (line 6273) | TEST_F(ParseFlagsTest, AbseilPositionalFlags) {
    function TEST_F (line 6286) | TEST_F(ParseFlagsTest, UnrecognizedFlags) {
    function TEST_F (line 6297) | TEST_F(ParseFlagsTest, WideStrings) {
    class FlagfileTest (line 6317) | class FlagfileTest : public ParseFlagsTest {
      method SetUp (line 6319) | void SetUp() override {
      method TearDown (line 6329) | void TearDown() override {
      method CreateFlagfile (line 6334) | internal::FilePath CreateFlagfile(const char* contents) {
    function TEST_F (line 6348) | TEST_F(FlagfileTest, Empty) {
    function TEST_F (line 6361) | TEST_F(FlagfileTest, FilterNonEmpty) {
    function TEST_F (line 6375) | TEST_F(FlagfileTest, SeveralFlags) {
    class CurrentTestInfoTest (line 6397) | class CurrentTestInfoTest : public Test {
      method SetUpTestSuite (line 6401) | static void SetUpTestSuite() {
      method TearDownTestSuite (line 6410) | static void TearDownTestSuite() {
    function TEST_F (line 6419) | TEST_F(CurrentTestInfoTest, WorksForFirstTestInATestSuite) {
    function TEST_F (line 6433) | TEST_F(CurrentTestInfoTest, WorksForSecondTestInATestSuite) {
  class TestingVector (line 289) | class TestingVector : public std::vector<int> {}
  function TEST (line 303) | TEST(GetRandomSeedFromFlagTest, HandlesZero) {
  function TEST (line 309) | TEST(GetRandomSeedFromFlagTest, PreservesValidSeed) {
  function TEST (line 317) | TEST(GetRandomSeedFromFlagTest, NormalizesInvalidSeed) {
  function TEST (line 327) | TEST(GetNextRandomSeedTest, WorksForValidInput) {
  function ClearCurrentTestPartResults (line 340) | static void ClearCurrentTestPartResults() {
  function TEST (line 347) | TEST(GetTypeIdTest, ReturnsSameValueForSameType) {
  class SubClassOfTest (line 352) | class SubClassOfTest : public Test {}
  class AnotherSubClassOfTest (line 353) | class AnotherSubClassOfTest : public Test {}
  function TEST (line 355) | TEST(GetTypeIdTest, ReturnsDifferentValuesForDifferentTypes) {
  function TEST (line 366) | TEST(GetTestTypeIdTest, ReturnsTheSameValueInsideOrOutsideOfGoogleTest) {
  function TEST (line 374) | TEST(CanonicalizeForStdLibVersioning, LeavesUnversionedNamesUnchanged) {
  function TEST (line 383) | TEST(CanonicalizeForStdLibVersioning, ElidesDoubleUnderNames) {
  function TEST (line 397) | TEST(FormatTimeInMillisAsSecondsTest, FormatsZero) {
  function TEST (line 401) | TEST(FormatTimeInMillisAsSecondsTest, FormatsPositiveNumber) {
  function TEST (line 413) | TEST(FormatTimeInMillisAsSecondsTest, FormatsNegativeNumber) {
  class FormatEpochTimeInMillisAsIso8601Test (line 434) | class FormatEpochTimeInMillisAsIso8601Test : public Test {
    method SetUp (line 442) | void SetUp() override {
    method TearDown (line 456) | void TearDown() override {
    method SetTimeZone (line 461) | static void SetTimeZone(const char* time_zone) {
  function TEST_F (line 495) | TEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsTwoDigitSegments) {
  function TEST_F (line 500) | TEST_F(FormatEpochTimeInMillisAsIso8601Test, IncludesMillisecondsAfterDo...
  function TEST_F (line 505) | TEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsLeadingZeroes) {
  function TEST_F (line 510) | TEST_F(FormatEpochTimeInMillisAsIso8601Test, Prints24HourTime) {
  function TEST_F (line 515) | TEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsEpochStart) {
  function TEST (line 528) | TEST(NullLiteralTest, LHSAllowsNullLiterals) {
  type ConvertToAll (line 545) | struct ConvertToAll {
  type ConvertToPointer (line 552) | struct ConvertToPointer {
  type ConvertToAllButNoPointers (line 559) | struct ConvertToAllButNoPointers {
  type MyType (line 567) | struct MyType {}
  function TEST (line 570) | TEST(NullLiteralTest, ImplicitConversion) {
  function TEST (line 587) | TEST(NullLiteralTest, NoConversionNoWarning) {
  function TEST (line 607) | TEST(CodePointToUtf8Test, CanEncodeNul) {
  function TEST (line 612) | TEST(CodePointToUtf8Test, CanEncodeAscii) {
  function TEST (line 621) | TEST(CodePointToUtf8Test, CanEncode8To11Bits) {
  function TEST (line 634) | TEST(CodePointToUtf8Test, CanEncode12To16Bits) {
  function TEST (line 649) | TEST(CodePointToUtf8Test, CanEncode17To21Bits) {
  function TEST (line 661) | TEST(CodePointToUtf8Test, CanEncodeInvalidCodePoint) {
  function TEST (line 670) | TEST(WideStringToUtf8Test, CanEncodeNul) {
  function TEST (line 676) | TEST(WideStringToUtf8Test, CanEncodeAscii) {
  function TEST (line 685) | TEST(WideStringToUtf8Test, CanEncode8To11Bits) {
  function TEST (line 698) | TEST(WideStringToUtf8Test, CanEncode12To16Bits) {
  function TEST (line 711) | TEST(WideStringToUtf8Test, StopsOnNulCharacter) {
  function TEST (line 717) | TEST(WideStringToUtf8Test, StopsWhenLengthLimitReached) {
  function TEST (line 725) | TEST(WideStringToUtf8Test, CanEncode17To21Bits) {
  function TEST (line 736) | TEST(WideStringToUtf8Test, CanEncodeInvalidCodePoint) {
  function TEST (line 743) | TEST(WideStringToUtf8Test, CanEncodeValidUtf16SUrrogatePairs) {
  function TEST (line 750) | TEST(WideStringToUtf8Test, CanEncodeInvalidUtf16SurrogatePair) {
  function TEST (line 765) | TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
  function TEST (line 777) | TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
  function TEST (line 790) | TEST(RandomDeathTest, GeneratesCrashesOnInvalidRange) {
  function TEST (line 800) | TEST(RandomTest, GeneratesNumbersWithinRange) {
  function TEST (line 813) | TEST(RandomTest, RepeatsWhenReseeded) {
  function IsPositive (line 834) | static bool IsPositive(int n) { return n > 0; }
  function TEST (line 836) | TEST(ContainerUtilityTest, CountIf) {
  function Accumulate (line 853) | static void Accumulate(int n) { g_sum += n; }
  function TEST (line 855) | TEST(ContainerUtilityTest, ForEach) {
  function TEST (line 874) | TEST(ContainerUtilityTest, GetElementOr) {
  function TEST (line 886) | TEST(ContainerUtilityDeathTest, ShuffleRange) {
  class VectorShuffleTest (line 907) | class VectorShuffleTest : public Test {
    method VectorShuffleTest (line 911) | VectorShuffleTest() : random_(1) {
    method VectorIsCorrupt (line 917) | static bool VectorIsCorrupt(const TestingVector& vector) {
    method VectorIsNotCorrupt (line 936) | static bool VectorIsNotCorrupt(const TestingVector& vector) {
    method RangeIsShuffled (line 940) | static bool RangeIsShuffled(const TestingVector& vector, int begin, in...
    method RangeIsUnshuffled (line 949) | static bool RangeIsUnshuffled(const TestingVector& vector, int begin,
    method VectorIsShuffled (line 954) | static bool VectorIsShuffled(const TestingVector& vector) {
    method VectorIsUnshuffled (line 958) | static bool VectorIsUnshuffled(const TestingVector& vector) {
  function TEST_F (line 968) | TEST_F(VectorShuffleTest, HandlesEmptyRange) {
  function TEST_F (line 990) | TEST_F(VectorShuffleTest, HandlesRangeOfSizeOne) {
  function TEST_F (line 1010) | TEST_F(VectorShuffleTest, ShufflesEntireVector) {
  function TEST_F (line 1021) | TEST_F(VectorShuffleTest, ShufflesStartOfVector) {
  function TEST_F (line 1032) | TEST_F(VectorShuffleTest, ShufflesEndOfVector) {
  function TEST_F (line 1042) | TEST_F(VectorShuffleTest, ShufflesMiddleOfVector) {
  function TEST_F (line 1053) | TEST_F(VectorShuffleTest, ShufflesRepeatably) {
  function TEST (line 1074) | TEST(AssertHelperTest, AssertHelperIsSmall) {
  function TEST (line 1081) | TEST(StringTest, EndsWithCaseInsensitive) {
  function TEST (line 1098) | TEST(StringTest, CaseInsensitiveWideCStringEquals) {
  function TEST (line 1112) | TEST(StringTest, ShowWideCString) {
  function TEST (line 1119) | TEST(StringTest, AnsiAndUtf16Null) {
  function TEST (line 1124) | TEST(StringTest, AnsiAndUtf16ConvertBasic) {
  function TEST (line 1133) | TEST(StringTest, AnsiAndUtf16ConvertPathChars) {
  function TEST (line 1146) | TEST(TestPropertyTest, StringValue) {
  function TEST (line 1153) | TEST(TestPropertyTest, ReplaceStringValue) {
  function AddFatalFailure (line 1163) | static void AddFatalFailure() { FAIL() << "Expected fatal failure."; }
  function AddNonfatalFailure (line 1165) | static void AddNonfatalFailure() {
  class ScopedFakeTestPartResultReporterTest (line 1169) | class ScopedFakeTestPartResultReporterTest : public Test {
    type FailureMode (line 1171) | enum FailureMode { FATAL_FAILURE, NONFATAL_FAILURE }
    method AddFailure (line 1172) | static void AddFailure(FailureMode failure) {
  function TEST_F (line 1183) | TEST_F(ScopedFakeTestPartResultReporterTest, InterceptsTestFailures) {
  function TEST_F (line 1198) | TEST_F(ScopedFakeTestPartResultReporterTest, DeprecatedConstructor) {
  class ScopedFakeTestPartResultReporterWithThreadsTest (line 1210) | class ScopedFakeTestPartResultReporterWithThreadsTest
    method AddFailureInOtherThread (line 1213) | static void AddFailureInOtherThread(FailureMode failure) {
  function TEST_F (line 1219) | TEST_F(ScopedFakeTestPartResultReporterWithThreadsTest,
  function TEST_F (line 1246) | TEST_F(ExpectFatalFailureTest, CatchesFatalFaliure) {
  function TEST_F (line 1250) | TEST_F(ExpectFatalFailureTest, AcceptsStdStringObject) {
  function TEST_F (line 1255) | TEST_F(ExpectFatalFailureTest, CatchesFatalFailureOnAllThreads) {
  function NonVoidFunction (line 1270) | int NonVoidFunction() {
  function TEST_F (line 1276) | TEST_F(ExpectFatalFailureTest, CanBeUsedInNonVoidFunction) {
  function DoesNotAbortHelper (line 1283) | void DoesNotAbortHelper(bool* aborted) {
  function TEST_F (line 1295) | TEST_F(ExpectFatalFailureTest, DoesNotAbort) {
  function TEST_F (line 1308) | TEST_F(ExpectFatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) {
  function TEST_F (line 1331) | TEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailure) {
  function TEST_F (line 1335) | TEST_F(ExpectNonfatalFailureTest, AcceptsStdStringObject) {
  function TEST_F (line 1340) | TEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailureOnAllThreads) {
  function TEST_F (line 1350) | TEST_F(ExpectNonfatalFailureTest, AcceptsMacroThatExpandsToUnprotectedCo...
  function TEST_F (line 1371) | TEST_F(ExpectFailureWithThreadsTest, ExpectFatalFailureOnAllThreads) {
  function TEST_F (line 1376) | TEST_F(ExpectFailureWithThreadsTest, ExpectNonFatalFailureOnAllThreads) {
  function TEST (line 1385) | TEST(TestPropertyTest, ConstructorWorks) {
  function TEST (line 1391) | TEST(TestPropertyTest, SetValue) {
  class TestResultTest (line 1402) | class TestResultTest : public Test {
    method SetUp (line 1412) | void SetUp() override {
    method TearDown (line 1446) | void TearDown() override {
    method CompareTestPartResult (line 1456) | static void CompareTestPartResult(const TestPartResult& expected,
  function TEST_F (line 1471) | TEST_F(TestResultTest, total_part_count) {
  function TEST_F (line 1478) | TEST_F(TestResultTest, Passed) {
  function TEST_F (line 1485) | TEST_F(TestResultTest, Failed) {
  function TEST_F (line 1495) | TEST_F(TestResultDeathTest, GetTestPartResult) {
  function TEST (line 1503) | TEST(TestResultPropertyTest, NoPropertiesFoundWhenNoneAreAdded) {
  function TEST (line 1509) | TEST(TestResultPropertyTest, OnePropertyFoundWhenAdded) {
  function TEST (line 1520) | TEST(TestResultPropertyTest, MultiplePropertiesFoundWhenAdded) {
  function TEST (line 1537) | TEST(TestResultPropertyTest, OverridesValuesForDuplicateKeys) {
  function TEST (line 1559) | TEST(TestResultPropertyTest, GetTestProperty) {
  class GTestFlagSaverTest (line 1597) | class GTestFlagSaverTest : public Test {
    method SetUpTestSuite (line 1602) | static void SetUpTestSuite() {
    method TearDownTestSuite (line 1627) | static void TearDownTestSuite() {
    method VerifyAndModifyFlags (line 1634) | void VerifyAndModifyFlags() {
  function TEST_F (line 1685) | TEST_F(GTestFlagSaverTest, ModifyGTestFlags) { VerifyAndModifyFlags(); }
  function TEST_F (line 1689) | TEST_F(GTestFlagSaverTest, VerifyGTestFlags) { VerifyAndModifyFlags(); }
  function SetEnv (line 1694) | static void SetEnv(const char* name, const char* value) {
  function TEST (line 1738) | TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenVariableIsNotSet) {
  function TEST (line 1747) | TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueOverflows) {
  function TEST (line 1759) | TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueIsInvalid) {
  function TEST (line 1774) | TEST(Int32FromGTestEnvTest, ParsesAndReturnsValidValue) {
  function TEST (line 1787) | TEST(ParseInt32FlagTest, ReturnsFalseForInvalidFlag) {
  function TEST (line 1798) | TEST(ParseInt32FlagTest, ReturnsDefaultWhenValueOverflows) {
  function TEST (line 1812) | TEST(ParseInt32FlagTest, ReturnsDefaultWhenValueIsInvalid) {
  function TEST (line 1826) | TEST(ParseInt32FlagTest, ParsesAndReturnsValidValue) {
  function TEST (line 1839) | TEST(Int32FromEnvOrDieTest, ParsesAndReturnsValidValue) {
  function TEST (line 1850) | TEST(Int32FromEnvOrDieDeathTest, AbortsOnFailure) {
  function TEST (line 1858) | TEST(Int32FromEnvOrDieDeathTest, AbortsOnInt32Overflow) {
  function TEST (line 1866) | TEST(ShouldRunTestOnShardTest, IsPartitionWhenThereIsOneShard) {
  class ShouldShardTest (line 1874) | class ShouldShardTest : public testing::Test {
    method SetUp (line 1876) | void SetUp() override {
    method TearDown (line 1881) | void TearDown() override {
  function TEST_F (line 1892) | TEST_F(ShouldShardTest, ReturnsFalseWhenNeitherEnvVarIsSet) {
  function TEST_F (line 1901) | TEST_F(ShouldShardTest, ReturnsFalseWhenTotalShardIsOne) {
  function TEST_F (line 1912) | TEST_F(ShouldShardTest, WorksWhenShardEnvVarsAreValid) {
  function TEST_F (line 1934) | TEST_F(ShouldShardDeathTest, AbortsWhenShardingEnvVarsAreInvalid) {
  function TEST (line 1954) | TEST(ShouldRunTestOnShardTest, IsPartitionWhenThereAreFiveShards) {
  function TEST (line 1997) | TEST(UnitTestTest, CanGetOriginalWorkingDir) {
  function TEST (line 2002) | TEST(UnitTestTest, ReturnsPlausibleTimestamp) {
  function ExpectNonFatalFailureRecordingPropertyWithReservedKey (line 2010) | void ExpectNonFatalFailureRecordingPropertyWithReservedKey(
  function ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest (line 2017) | void ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
  function ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestSuite (line 2025) | void ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest...
  function ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestSuite (line 2034) | void ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestS...
  class UnitTestRecordPropertyTest (line 2043) | class UnitTestRecordPropertyTest
    method SetUpTestSuite (line 2046) | static void SetUpTestSuite() {
  function TEST_F (line 2076) | TEST_F(UnitTestRecordPropertyTest, OnePropertyFoundWhenAdded) {
  function TEST_F (line 2087) | TEST_F(UnitTestRecordPropertyTest, MultiplePropertiesFoundWhenAdded) {
  function TEST_F (line 2103) | TEST_F(UnitTestRecordPropertyTest, OverridesValuesForDuplicateKeys) {
  function TEST_F (line 2122) | TEST_F(UnitTestRecordPropertyTest,
  function TEST_F (line 2135) | TEST_F(UnitTestRecordPropertyTest,
  class UnitTestRecordPropertyTestEnvironment (line 2143) | class UnitTestRecordPropertyTestEnvironment : public Environment {
    method TearDown (line 2145) | void TearDown() override {
  function IsEven (line 2178) | bool IsEven(int n) { return (n % 2) == 0; }
  type IsEvenFunctor (line 2181) | struct IsEvenFunctor {
  function AssertionResult (line 2187) | AssertionResult AssertIsEven(const char* expr, int n) {
  function AssertionResult (line 2199) | AssertionResult ResultIsEven(int n) {
  function AssertionResult (line 2209) | AssertionResult ResultIsEvenNoExplanation(int n) {
  type AssertIsEvenFunctor (line 2218) | struct AssertIsEvenFunctor {
    method AssertionResult (line 2219) | AssertionResult operator()(const char* expr, int n) {
  function SumIsEven2 (line 2225) | bool SumIsEven2(int n1, int n2) { return IsEven(n1 + n2); }
  type SumIsEven3Functor (line 2229) | struct SumIsEven3Functor {
  function AssertionResult (line 2235) | AssertionResult AssertSumIsEven4(const char* e1, const char* e2, const c...
  type AssertSumIsEven5Functor (line 2252) | struct AssertSumIsEven5Functor {
    method AssertionResult (line 2253) | AssertionResult operator()(const char* e1, const char* e2, const char*...
  function TEST (line 2272) | TEST(Pred1Test, WithoutFormat) {
  function TEST (line 2287) | TEST(Pred1Test, WithFormat) {
  function TEST (line 2306) | TEST(Pred1Test, SingleEvaluationOnFailure) {
  function TEST (line 2325) | TEST(PredTest, WithoutFormat) {
  function TEST (line 2346) | TEST(PredTest, WithFormat) {
  function TEST (line 2372) | TEST(PredTest, SingleEvaluationOnFailure) {
  function TEST (line 2419) | TEST(PredTest, ExpectPredEvalFailure) {
  function IsPositive (line 2432) | bool IsPositive(double x) { return x > 0; }
  function IsNegative (line 2435) | bool IsNegative(T x) {
  function GreaterThan (line 2440) | bool GreaterThan(T1 x1, T2 x2) {
  function TEST (line 2446) | TEST(PredicateAssertionTest, AcceptsOverloadedFunction) {
  function TEST (line 2454) | TEST(PredicateAssertionTest, AcceptsTemplateFunction) {
  function AssertionResult (line 2464) | AssertionResult IsPositiveFormat(const char* /* expr */, int n) {
  function AssertionResult (line 2468) | AssertionResult IsPositiveFormat(const char* /* expr */, double x) {
  function AssertionResult (line 2473) | AssertionResult IsNegativeFormat(const char* /* expr */, T x) {
  function AssertionResult (line 2478) | AssertionResult EqualsFormat(const char* /* expr1 */, const char* /* exp...
  function TEST (line 2486) | TEST(PredicateFormatAssertionTest, AcceptsOverloadedFunction) {
  function TEST (line 2493) | TEST(PredicateFormatAssertionTest, AcceptsTemplateFunction) {
  function TEST (line 2501) | TEST(StringAssertionTest, ASSERT_STREQ) {
  function TEST (line 2513) | TEST(StringAssertionTest, ASSERT_STREQ_Null) {
  function TEST (line 2519) | TEST(StringAssertionTest, ASSERT_STREQ_Null2) {
  function TEST (line 2524) | TEST(StringAssertionTest, ASSERT_STRNE) {
  function TEST (line 2536) | TEST(StringAssertionTest, ASSERT_STRCASEEQ) {
  function TEST (line 2545) | TEST(StringAssertionTest, ASSERT_STRCASENE) {
  function TEST (line 2557) | TEST(StringAssertionTest, STREQ_Wide) {
  function TEST (line 2585) | TEST(StringAssertionTest, STRNE_Wide) {
  function TEST (line 2616) | TEST(IsSubstringTest, ReturnsCorrectResultForCString) {
  function TEST (line 2627) | TEST(IsSubstringTest, ReturnsCorrectResultForWideCString) {
  function TEST (line 2639) | TEST(IsSubstringTest, GeneratesCorrectMessageForCString) {
  function TEST (line 2651) | TEST(IsSubstringTest, ReturnsCorrectResultsForStdString) {
  function TEST (line 2659) | TEST(IsSubstringTest, ReturnsCorrectResultForStdWstring) {
  function TEST (line 2666) | TEST(IsSubstringTest, GeneratesCorrectMessageForWstring) {
  function TEST (line 2683) | TEST(IsNotSubstringTest, ReturnsCorrectResultForCString) {
  function TEST (line 2690) | TEST(IsNotSubstringTest, ReturnsCorrectResultForWideCString) {
  function TEST (line 2697) | TEST(IsNotSubstringTest, GeneratesCorrectMessageForWideCString) {
  function TEST (line 2709) | TEST(IsNotSubstringTest, ReturnsCorrectResultsForStdString) {
  function TEST (line 2716) | TEST(IsNotSubstringTest, GeneratesCorrectMessageForStdString) {
  function TEST (line 2730) | TEST(IsNotSubstringTest, ReturnsCorrectResultForStdWstring) {
  class FloatingPointTest (line 2741) | class FloatingPointTest : public Test {
    type TestValues (line 2744) | struct TestValues {
    method SetUp (line 2763) | void SetUp() override {
    method TestSize (line 2808) | void TestSize() { EXPECT_EQ(sizeof(RawType), sizeof(Bits)); }
  function TEST_F (line 2821) | TEST_F(FloatTest, Size) { TestSize(); }
  function TEST_F (line 2824) | TEST_F(FloatTest, Zeros) {
  function TEST_F (line 2835) | TEST_F(FloatTest, AlmostZeros) {
  function TEST_F (line 2856) | TEST_F(FloatTest, SmallDiff) {
  function TEST_F (line 2863) | TEST_F(FloatTest, LargeDiff) {
  function TEST_F (line 2871) | TEST_F(FloatTest, Infinity) {
  function TEST_F (line 2886) | TEST_F(FloatTest, NaN) {
  function TEST_F (line 2908) | TEST_F(FloatTest, Reflexive) {
  function TEST_F (line 2915) | TEST_F(FloatTest, Commutative) {
  function TEST_F (line 2925) | TEST_F(FloatTest, EXPECT_NEAR) {
  function TEST_F (line 2951) | TEST_F(FloatTest, ASSERT_NEAR) {
  function TEST_F (line 2960) | TEST_F(FloatTest, FloatLESucceeds) {
  function TEST_F (line 2969) | TEST_F(FloatTest, FloatLEFails) {
  function TEST_F (line 3002) | TEST_F(DoubleTest, Size) { TestSize(); }
  function TEST_F (line 3005) | TEST_F(DoubleTest, Zeros) {
  function TEST_F (line 3016) | TEST_F(DoubleTest, AlmostZeros) {
  function TEST_F (line 3038) | TEST_F(DoubleTest, SmallDiff) {
  function TEST_F (line 3045) | TEST_F(DoubleTest, LargeDiff) {
  function TEST_F (line 3053) | TEST_F(DoubleTest, Infinity) {
  function TEST_F (line 3068) | TEST_F(DoubleTest, NaN) {
  function TEST_F (line 3085) | TEST_F(DoubleTest, Reflexive) {
  function TEST_F (line 3092) | TEST_F(DoubleTest, Commutative) {
  function TEST_F (line 3102) | TEST_F(DoubleTest, EXPECT_NEAR) {
  function TEST_F (line 3135) | TEST_F(DoubleTest, ASSERT_NEAR) {
  function TEST_F (line 3144) | TEST_F(DoubleTest, DoubleLESucceeds) {
  function TEST_F (line 3153) | TEST_F(DoubleTest, DoubleLEFails) {
  function TEST (line 3187) | TEST(DisabledTest, DISABLED_TestShouldNotRun) {
  function TEST (line 3193) | TEST(DisabledTest, NotDISABLED_TestShouldRun) { EXPECT_EQ(1, 1); }
  function TEST (line 3197) | TEST(DISABLED_TestSuite, TestShouldNotRun) {
  function TEST (line 3203) | TEST(DISABLED_TestSuite, DISABLED_TestShouldNotRun) {
  class DisabledTestsTest (line 3209) | class DisabledTestsTest : public Test {
    method SetUpTestSuite (line 3211) | static void SetUpTestSuite() {
    method TearDownTestSuite (line 3216) | static void TearDownTestSuite() {
  function TEST_F (line 3222) | TEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_1) {
  function TEST_F (line 3226) | TEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_2) {
  class TypedTest (line 3233) | class TypedTest : public Test {}
  function TYPED_TEST (line 3238) | TYPED_TEST(TypedTest, DISABLED_ShouldNotRun) {
  class DISABLED_TypedTest (line 3243) | class DISABLED_TypedTest : public Test {}
  function TYPED_TEST (line 3247) | TYPED_TEST(DISABLED_TypedTest, ShouldNotRun) {
  class TypedTestP (line 3254) | class TypedTestP : public Test {}
  function TYPED_TEST_P (line 3258) | TYPED_TEST_P(TypedTestP, DISABLED_ShouldNotRun) {
  class DISABLED_TypedTestP (line 3268) | class DISABLED_TypedTestP : public Test {}
  function TYPED_TEST_P (line 3272) | TYPED_TEST_P(DISABLED_TypedTestP, ShouldNotRun) {
  class SingleEvaluationTest (line 3283) | class SingleEvaluationTest : public Test {
    method CompareAndIncrementCharPtrs (line 3288) | static void CompareAndIncrementCharPtrs() { ASSERT_STREQ(p1_++, p2_++); }
    method CompareAndIncrementInts (line 3292) | static void CompareAndIncrementInts() { ASSERT_NE(a_++, b_++); }
    method SingleEvaluationTest (line 3295) | SingleEvaluationTest() {
  function TEST_F (line 3320) | TEST_F(SingleEvaluationTest, FailedASSERT_STREQ) {
  function TEST_F (line 3328) | TEST_F(SingleEvaluationTest, ASSERT_STR) {
  function TEST_F (line 3342) | TEST_F(SingleEvaluationTest, FailedASSERT_NE) {
  function TEST_F (line 3350) | TEST_F(SingleEvaluationTest, OtherCases) {
  function ThrowAnInteger (line 3391) | void ThrowAnInteger() { throw 1; }
  function ThrowRuntimeError (line 3392) | void ThrowRuntimeError(const char* what) { throw std::runtime_error(what...
  function TEST_F (line 3395) | TEST_F(SingleEvaluationTest, ExceptionTests) {
  class NoFatalFailureTest (line 3457) | class NoFatalFailureTest : public Test {
    method Succeeds (line 3459) | void Succeeds() {}
    method FailsNonFatal (line 3460) | void FailsNonFatal() { ADD_FAILURE() << "some non-fatal failure"; }
    method Fails (line 3461) | void Fails() { FAIL() << "some fatal failure"; }
    method DoAssertNoFatalFailureOnFails (line 3463) | void DoAssertNoFatalFailureOnFails() {
    method DoExpectNoFatalFailureOnFails (line 3468) | void DoExpectNoFatalFailureOnFails() {
  function TEST_F (line 3474) | TEST_F(NoFatalFailureTest, NoFailure) {
  function TEST_F (line 3479) | TEST_F(NoFatalFailureTest, NonFatalIsNoFailure) {
  function TEST_F (line 3486) | TEST_F(NoFatalFailureTest, AssertNoFatalFailureOnFatalFailure) {
  function TEST_F (line 3503) | TEST_F(NoFatalFailureTest, ExpectNoFatalFailureOnFatalFailure) {
  function TEST_F (line 3524) | TEST_F(NoFatalFailureTest, MessageIsStreamable) {
  function EditsToString (line 3543) | std::string EditsToString(const std::vector<EditType>& edits) {
  function CharsToIndices (line 3552) | std::vector<size_t> CharsToIndices(const std::string& str) {
  function CharsToLines (line 3560) | std::vector<std::string> CharsToLines(const std::string& str) {
  function TEST (line 3568) | TEST(EditDistance, TestSuites) {
  function TEST (line 3618) | TEST(AssertionTest, EqFailure) {
  function TEST (line 3668) | TEST(AssertionTest, EqFailureWithDiff) {
  function TEST (line 3688) | TEST(AssertionTest, AppendUserMessage) {
  function TEST (line 3704) | TEST(AssertionTest, ASSERT_TRUE) {
  function TEST (line 3710) | TEST(AssertionTest, AssertTrueWithAssertionResult) {
  function TEST (line 3727) | TEST(AssertionTest, ASSERT_FALSE) {
  function TEST (line 3736) | TEST(AssertionTest, AssertFalseWithAssertionResult) {
  function TEST (line 3760) | TEST(ExpectTest, ASSERT_EQ_Double) {
  function TEST (line 3769) | TEST(AssertionTest, ASSERT_EQ) {
  function TEST (line 3781) | TEST(AssertionTest, ASSERT_EQ_NULL) {
  function TEST (line 3795) | TEST(ExpectTest, ASSERT_EQ_0) {
  function TEST (line 3806) | TEST(AssertionTest, ASSERT_NE) {
  function TEST (line 3814) | TEST(AssertionTest, ASSERT_LE) {
  function TEST (line 3821) | TEST(AssertionTest, ASSERT_LT) {
  function TEST (line 3827) | TEST(AssertionTest, ASSERT_GE) {
  function TEST (line 3834) | TEST(AssertionTest, ASSERT_GT) {
  function ThrowNothing (line 3841) | void ThrowNothing() {}
  function TEST (line 3844) | TEST(AssertionTest, ASSERT_THROW) {
  function TEST (line 3870) | TEST(AssertionTest, ASSERT_NO_THROW) {
  function TEST (line 3884) | TEST(AssertionTest, ASSERT_ANY_THROW) {
  function TEST (line 3895) | TEST(AssertionTest, AssertPrecedence) {
  function TestEq1 (line 3902) | void TestEq1(int x) { ASSERT_EQ(1, x); }
  function TEST (line 3905) | TEST(AssertionTest, NonFixtureSubroutine) {
  class Uncopyable (line 3910) | class Uncopyable {
    method Uncopyable (line 3912) | explicit Uncopyable(int a_value) : value_(a_value) {}
    method value (line 3914) | int value() const { return value_; }
  function IsPositiveUncopyable (line 3931) | bool IsPositiveUncopyable(const Uncopyable& x) { return x.value() > 0; }
  function TestAssertNonPositive (line 3934) | void TestAssertNonPositive() {
  function TestAssertEqualsUncopyable (line 3939) | void TestAssertEqualsUncopyable() {
  function TEST (line 3946) | TEST(AssertionTest, AssertWorksWithUncopyableObject) {
  function TEST (line 3959) | TEST(AssertionTest, ExpectWorksWithUncopyableObject) {
  type NamedEnum (line 3972) | enum NamedEnum { kE1 = 0, kE2 = 1 }
  function TEST (line 3974) | TEST(AssertionTest, NamedEnum) {
  function TEST (line 4010) | TEST(AssertionTest, AnonymousEnum) {
  function HRESULT (line 4047) | static HRESULT UnexpectedHRESULTFailure() { return E_UNEXPECTED; }
  function HRESULT (line 4049) | static HRESULT OkHRESULTSuccess() { return S_OK; }
  function HRESULT (line 4051) | static HRESULT FalseHRESULTSuccess() { return S_FALSE; }
  function TEST (line 4057) | TEST(HRESULTAssertionTest, EXPECT_HRESULT_SUCCEEDED) {
  function TEST (line 4066) | TEST(HRESULTAssertionTest, ASSERT_HRESULT_SUCCEEDED) {
  function TEST (line 4075) | TEST(HRESULTAssertionTest, EXPECT_HRESULT_FAILED) {
  function TEST (line 4086) | TEST(HRESULTAssertionTest, ASSERT_HRESULT_FAILED) {
  function TEST (line 4103) | TEST(HRESULTAssertionTest, Streaming) {
  function TEST (line 4138) | TEST(AssertionSyntaxTest, BasicAssertionsBehavesLikeSingleStatement) {
  function TEST (line 4162) | TEST(ExpectThrowTest, DoesNotGenerateUnreachableCodeWarning) {
  type testing (line 4288) | namespace testing {
    type internal (line 92) | namespace internal {
      class StreamingListenerTest (line 96) | class StreamingListenerTest : public Test {
        class FakeSocketWriter (line 98) | class FakeSocketWriter : public StreamingListener::AbstractSocketW...
          method Send (line 101) | void Send(const std::string& message) override { output_ += mess...
        method StreamingListenerTest (line 106) | StreamingListenerTest()
      function TEST_F (line 121) | TEST_F(StreamingListenerTest, OnTestProgramEnd) {
      function TEST_F (line 127) | TEST_F(StreamingListenerTest, OnTestIterationEnd) {
      function TEST_F (line 133) | TEST_F(StreamingListenerTest, OnTestSuiteStart) {
      function TEST_F (line 139) | TEST_F(StreamingListenerTest, OnTestSuiteEnd) {
      function TEST_F (line 145) | TEST_F(StreamingListenerTest, OnTestStart) {
      function TEST_F (line 151) | TEST_F(StreamingListenerTest, OnTestEnd) {
      function TEST_F (line 157) | TEST_F(StreamingListenerTest, OnTestPartResult) {
      class TestEventListenersAccessor (line 172) | class TestEventListenersAccessor {
        method TestEventListener (line 174) | static TestEventListener* GetRepeater(TestEventListeners* listener...
        method SetDefaultResultPrinter (line 178) | static void SetDefaultResultPrinter(TestEventListeners* listeners,
        method SetDefaultXmlGenerator (line 182) | static void SetDefaultXmlGenerator(TestEventListeners* listeners,
        method EventForwardingEnabled (line 187) | static bool EventForwardingEnabled(const TestEventListeners& liste...
        method SuppressEventForwarding (line 191) | static void SuppressEventForwarding(TestEventListeners* listeners) {
      class UnitTestRecordPropertyTestHelper (line 196) | class UnitTestRecordPropertyTestHelper : public Test {
        method UnitTestRecordPropertyTestHelper (line 198) | UnitTestRecordPropertyTestHelper() = default;
        method UnitTestRecordProperty (line 201) | void UnitTestRecordProperty(const char* key, const std::string& va...
    function TEST (line 4291) | TEST(SuccessfulAssertionTest, SUCCEED) {
    function TEST (line 4298) | TEST(SuccessfulAssertionTest, EXPECT) {
    function TEST (line 4304) | TEST(SuccessfulAssertionTest, EXPECT_STR) {
    function TEST (line 4310) | TEST(SuccessfulAssertionTest, ASSERT) {
    function TEST (line 4316) | TEST(SuccessfulAssertionTest, ASSERT_STR) {
    class TestInfoTest (line 5306) | class TestInfoTest : public Test {
      method TestInfo (line 5308) | static const TestInfo* GetTestInfo(const char* test_name) {
      method TestResult (line 5319) | static const TestResult* GetTestResult(const TestInfo* test_info) {
    function TEST_F (line 5325) | TEST_F(TestInfoTest, Names) {
    function TEST_F (line 5333) | TEST_F(TestInfoTest, result) {
    function TEST (line 5351) | TEST(CodeLocationForTEST, Verify) {
    class CodeLocationForTESTF (line 5355) | class CodeLocationForTESTF : public Test {}
    function TEST_F (line 5357) | TEST_F(CodeLocationForTESTF, Verify) {
    class CodeLocationForTESTP (line 5361) | class CodeLocationForTESTP : public TestWithParam<int> {}
    function TEST_P (line 5363) | TEST_P(CodeLocationForTESTP, Verify) {
    class CodeLocationForTYPEDTEST (line 5370) | class CodeLocationForTYPEDTEST : public Test {}
    function TYPED_TEST (line 5374) | TYPED_TEST(CodeLocationForTYPEDTEST, Verify) {
    class CodeLocationForTYPEDTESTP (line 5379) | class CodeLocationForTYPEDTESTP : public Test {}
    function TYPED_TEST_P (line 5383) | TYPED_TEST_P(CodeLocationForTYPEDTESTP, Verify) {
    class SetUpTestCaseTest (line 5397) | class SetUpTestCaseTest : public Test {
      method SetUpTestCase (line 5401) | static void SetUpTestCase() {
      method TearDownTestCase (line 5418) | static void TearDownTestCase() {
      method SetUp (line 5432) | void SetUp() override {
    function TEST_F (line 5449) | TEST_F(SetUpTestCaseTest, Test1) { EXPECT_STRNE(nullptr, shared_resour...
    function TEST_F (line 5452) | TEST_F(SetUpTestCaseTest, Test2) { EXPECT_STREQ("123", shared_resource...
    class SetUpTestSuiteTest (line 5456) | class SetUpTestSuiteTest : public Test {
      method SetUpTestSuite (line 5460) | static void SetUpTestSuite() {
      method TearDownTestSuite (line 5477) | static void TearDownTestSuite() {
      method SetUp (line 5491) | void SetUp() override {
    function TEST_F (line 5508) | TEST_F(SetUpTestSuiteTest, TestSetupTestSuite1) {
    function TEST_F (line 5513) | TEST_F(SetUpTestSuiteTest, TestSetupTestSuite2) {
    type Flags (line 5520) | struct Flags {
      method Flags (line 5522) | Flags()
      method Flags (line 5545) | static Flags AlsoRunDisabledTests(bool also_run_disabled_tests) {
      method Flags (line 5553) | static Flags BreakOnFailure(bool break_on_failure) {
      method Flags (line 5561) | static Flags CatchExceptions(bool catch_exceptions) {
      method Flags (line 5569) | static Flags DeathTestUseFork(bool death_test_use_fork) {
      method Flags (line 5577) | static Flags FailFast(bool fail_fast) {
      method Flags (line 5585) | static Flags Filter(const char* filter) {
      method Flags (line 5593) | static Flags ListTests(bool list_tests) {
      method Flags (line 5601) | static Flags Output(const char* output) {
      method Flags (line 5609) | static Flags Brief(bool brief) {
      method Flags (line 5617) | static Flags PrintTime(bool print_time) {
      method Flags (line 5625) | static Flags RandomSeed(int32_t random_seed) {
      method Flags (line 5633) | static Flags Repeat(int32_t repeat) {
      method Flags (line 5641) | static Flags RecreateEnvironmentsWhenRepeating(
      method Flags (line 5651) | static Flags Shuffle(bool shuffle) {
      method Flags (line 5659) | static Flags StackTraceDepth(int32_t stack_trace_depth) {
      method Flags (line 5667) | static Flags StreamResultTo(const char* stream_result_to) {
      method Flags (line 5675) | static Flags ThrowOnFailure(bool throw_on_failure) {
    class ParseFlagsTest (line 5702) | class ParseFlagsTest : public Test {
      method SetUp (line 5705) | void SetUp() override {
      method AssertStringArrayEq (line 5727) | static void AssertStringArrayEq(int size1, CharType** array1, int si...
      method CheckFlags (line 5737) | static void CheckFlags(const Flags& expected) {
      method TestParsingFlags (line 5765) | static void TestParsingFlags(int argc1, const CharType** argv1, int ...
    function TEST_F (line 5817) | TEST_F(ParseFlagsTest, Empty) {
    function TEST_F (line 5826) | TEST_F(ParseFlagsTest, NoFlag) {
    function TEST_F (line 5835) | TEST_F(ParseFlagsTest, FailFast) {
    function TEST_F (line 5844) | TEST_F(ParseFlagsTest, FilterEmpty) {
    function TEST_F (line 5853) | TEST_F(ParseFlagsTest, FilterNonEmpty) {
    function TEST_F (line 5862) | TEST_F(ParseFlagsTest, BreakOnFailureWithoutValue) {
    function TEST_F (line 5871) | TEST_F(ParseFlagsTest, BreakOnFailureFalse_0) {
    function TEST_F (line 5880) | TEST_F(ParseFlagsTest, BreakOnFailureFalse_f) {
    function TEST_F (line 5889) | TEST_F(ParseFlagsTest, BreakOnFailureFalse_F) {
    function TEST_F (line 5899) | TEST_F(ParseFlagsTest, BreakOnFailureTrue) {
    function TEST_F (line 5908) | TEST_F(ParseFlagsTest, CatchExceptions) {
    function TEST_F (line 5917) | TEST_F(ParseFlagsTest, DeathTestUseFork) {
    function TEST_F (line 5927) | TEST_F(ParseFlagsTest, DuplicatedFlags) {
    function TEST_F (line 5937) | TEST_F(ParseFlagsTest, UnrecognizedFlag) {
    function TEST_F (line 5951) | TEST_F(ParseFlagsTest, ListTestsFlag) {
    function TEST_F (line 5960) | TEST_F(ParseFlagsTest, ListTestsTrue) {
    function TEST_F (line 5969) | TEST_F(ParseFlagsTest, ListTestsFalse) {
    function TEST_F (line 5978) | TEST_F(ParseFlagsTest, ListTestsFalse_f) {
    function TEST_F (line 5987) | TEST_F(ParseFlagsTest, ListTestsFalse_F) {
    function TEST_F (line 5996) | TEST_F(ParseFlagsTest, OutputXml) {
    function TEST_F (line 6005) | TEST_F(ParseFlagsTest, OutputXmlFile) {
    function TEST_F (line 6014) | TEST_F(ParseFlagsTest, OutputXmlDirectory) {
    function TEST_F (line 6025) | TEST_F(ParseFlagsTest, BriefFlag) {
    function TEST_F (line 6034) | TEST_F(ParseFlagsTest, BriefFlagTrue) {
    function TEST_F (line 6043) | TEST_F(ParseFlagsTest, BriefFlagFalse) {
    function TEST_F (line 6052) | TEST_F(ParseFlagsTest, PrintTimeFlag) {
    function TEST_F (line 6061) | TEST_F(ParseFlagsTest, PrintTimeTrue) {
    function TEST_F (line 6070) | TEST_F(ParseFlagsTest, PrintTimeFalse) {
    function TEST_F (line 6079) | TEST_F(ParseFlagsTest, PrintTimeFalse_f) {
    function TEST_F (line 6088) | TEST_F(ParseFlagsTest, PrintTimeFalse_F) {
    function TEST_F (line 6097) | TEST_F(ParseFlagsTest, RandomSeed) {
    function TEST_F (line 6106) | TEST_F(ParseFlagsTest, Repeat) {
    function TEST_F (line 6115) | TEST_F(ParseFlagsTest, RecreateEnvironmentsWhenRepeating) {
    function TEST_F (line 6129) | TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFlag) {
    function TEST_F (line 6139) | TEST_F(ParseFlagsTest, AlsoRunDisabledTestsTrue) {
    function TEST_F (line 6150) | TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFalse) {
    function TEST_F (line 6161) | TEST_F(ParseFlagsTest, ShuffleWithoutValue) {
    function TEST_F (line 6170) | TEST_F(ParseFlagsTest, ShuffleFalse_0) {
    function TEST_F (line 6179) | TEST_F(ParseFlagsTest, ShuffleTrue) {
    function TEST_F (line 6188) | TEST_F(ParseFlagsTest, StackTraceDepth) {
    function TEST_F (line 6196) | TEST_F(ParseFlagsTest, StreamResultTo) {
    function TEST_F (line 6207) | TEST_F(ParseFlagsTest, ThrowOnFailureWithoutValue) {
    function TEST_F (line 6216) | TEST_F(ParseFlagsTest, ThrowOnFailureFalse_0) {
    function TEST_F (line 6226) | TEST_F(ParseFlagsTest, ThrowOnFailureTrue) {
    function TEST_F (line 6235) | TEST_F(ParseFlagsTest, FilterBad) {
    function TEST_F (line 6254) | TEST_F(ParseFlagsTest, OutputEmpty) {
    function TEST_F (line 6273) | TEST_F(ParseFlagsTest, AbseilPositionalFlags) {
    function TEST_F (line 6286) | TEST_F(ParseFlagsTest, UnrecognizedFlags) {
    function TEST_F (line 6297) | TEST_F(ParseFlagsTest, WideStrings) {
    class FlagfileTest (line 6317) | class FlagfileTest : public ParseFlagsTest {
      method SetUp (line 6319) | void SetUp() override {
      method TearDown (line 6329) | void TearDown() override {
      method CreateFlagfile (line 6334) | internal::FilePath CreateFlagfile(const char* contents) {
    function TEST_F (line 6348) | TEST_F(FlagfileTest, Empty) {
    function TEST_F (line 6361) | TEST_F(FlagfileTest, FilterNonEmpty) {
    function TEST_F (line 6375) | TEST_F(FlagfileTest, SeveralFlags) {
    class CurrentTestInfoTest (line 6397) | class CurrentTestInfoTest : public Test {
      method SetUpTestSuite (line 6401) | static void SetUpTestSuite() {
      method TearDownTestSuite (line 6410) | static void TearDownTestSuite() {
    function TEST_F (line 6419) | TEST_F(CurrentTestInfoTest, WorksForFirstTestInATestSuite) {
    function TEST_F (line 6433) | TEST_F(CurrentTestInfoTest, WorksForSecondTestInATestSuite) {
  function TEST (line 4327) | TEST(AssertionWithMessageTest, EXPECT) {
  function TEST (line 4351) | TEST(AssertionWithMessageTest, ASSERT) {
  function TEST (line 4361) | TEST(AssertionWithMessageTest, ASSERT_STR) {
  function TEST (line 4369) | TEST(AssertionWithMessageTest, ASSERT_FLOATING) {
  function TEST (line 4377) | TEST(AssertionWithMessageTest, ASSERT_FALSE) {
  function TEST (line 4388) | TEST(AssertionWithMessageTest, FAIL) { EXPECT_FATAL_FAILURE(FAIL() << 0,...
  function TEST (line 4391) | TEST(AssertionWithMessageTest, SUCCEED) { SUCCEED() << "Success == " << ...
  function TEST (line 4394) | TEST(AssertionWithMessageTest, ASSERT_TRUE) {
  function TEST (line 4407) | TEST(AssertionWithMessageTest, WideStringMessage) {
  function TEST (line 4422) | TEST(ExpectTest, EXPECT_TRUE) {
  function TEST (line 4437) | TEST(ExpectTest, ExpectTrueWithAssertionResult) {
  function TEST (line 4451) | TEST(ExpectTest, EXPECT_FALSE) {
  function TEST (line 4466) | TEST(ExpectTest, ExpectFalseWithAssertionResult) {
  function TEST (line 4485) | TEST(ExpectTest, EXPECT_EQ) {
  function TEST (line 4500) | TEST(ExpectTest, EXPECT_EQ_Double) {
  function TEST (line 4509) | TEST(ExpectTest, EXPECT_EQ_NULL) {
  function TEST (line 4523) | TEST(ExpectTest, EXPECT_EQ_0) {
  function TEST (line 4534) | TEST(ExpectTest, EXPECT_NE) {
  function TEST (line 4553) | TEST(ExpectTest, EXPECT_LE) {
  function TEST (line 4562) | TEST(ExpectTest, EXPECT_LT) {
  function TEST (line 4570) | TEST(ExpectTest, EXPECT_GE) {
  function TEST (line 4579) | TEST(ExpectTest, EXPECT_GT) {
  function TEST (line 4589) | TEST(ExpectTest, EXPECT_THROW) {
  function TEST (line 4608) | TEST(ExpectTest, EXPECT_NO_THROW) {
  function TEST (line 4622) | TEST(ExpectTest, EXPECT_ANY_THROW) {
  function TEST (line 4632) | TEST(ExpectTest, ExpectPrecedence) {
  function TEST (line 4641) | TEST(StreamableToStringTest, Scalar) {
  function TEST (line 4646) | TEST(StreamableToStringTest, Pointer) {
  function TEST (line 4653) | TEST(StreamableToStringTest, NullPointer) {
  function TEST (line 4659) | TEST(StreamableToStringTest, CString) {
  function TEST (line 4664) | TEST(StreamableToStringTest, NullCString) {
  function TEST (line 4672) | TEST(StreamableTest, string) {
  function TEST (line 4680) | TEST(StreamableTest, stringWithEmbeddedNUL) {
  function TEST (line 4691) | TEST(StreamableTest, NULChar) {
  function TEST (line 4700) | TEST(StreamableTest, int) { EXPECT_FATAL_FAILURE(FAIL() << 900913, "9009...
  function TEST (line 4707) | TEST(StreamableTest, NullCharPtr) {
  function TEST (line 4713) | TEST(StreamableTest, BasicIoManip) {
  function AddFailureHelper (line 4724) | void AddFailureHelper(bool* aborted) {
  function TEST (line 4731) | TEST(MacroTest, ADD_FAILURE) {
  function TEST (line 4738) | TEST(MacroTest, ADD_FAILURE_AT) {
  function TEST (line 4753) | TEST(MacroTest, FAIL) {
  function TEST (line 4760) | TEST(MacroTest, GTEST_FAIL_AT) {
  function TEST (line 4773) | TEST(MacroTest, SUCCEED) {
  function TEST (line 4786) | TEST(EqAssertionTest, Bool) {
  function TEST (line 4797) | TEST(EqAssertionTest, Int) {
  function TEST (line 4803) | TEST(EqAssertionTest, Time_T) {
  function TEST (line 4810) | TEST(EqAssertionTest, Char) {
  function TEST (line 4818) | TEST(EqAssertionTest, WideChar) {
  function TEST (line 4837) | TEST(EqAssertionTest, StdString) {
  function TEST (line 4866) | TEST(EqAssertionTest, StdWideString) {
  function TEST (line 4904) | TEST(EqAssertionTest, CharPointer) {
  function TEST (line 4924) | TEST(EqAssertionTest, WideCharPointer) {
  function TEST (line 4946) | TEST(EqAssertionTest, OtherPointer) {
  class UnprintableChar (line 4954) | class UnprintableChar {
    method UnprintableChar (line 4956) | explicit UnprintableChar(char ch) : char_(ch) {}
  function TEST (line 4979) | TEST(ComparisonAssertionTest, AcceptsUnprintableArgs) {
  class Foo (line 5015) | class Foo {
    method Foo (line 5017) | Foo() = default;
    method Bar (line 5020) | int Bar() const { return 1; }
  function TEST (line 5030) | TEST(FRIEND_TEST_Test, TEST) { ASSERT_EQ(1, Foo().Bar()); }
  class FRIEND_TEST_Test2 (line 5033) | class FRIEND_TEST_Test2 : public Test {
  function TEST_F (line 5040) | TEST_F(FRIEND_TEST_Test2, TEST_F) { ASSERT_EQ(1, foo.Bar()); }
  class TestLifeCycleTest (line 5048) | class TestLifeCycleTest : public Test {
    method TestLifeCycleTest (line 5052) | TestLifeCycleTest() { count_++; }
    method count (line 5059) | int count() const { return count_; }
  function TEST_F (line 5068) | TEST_F(TestLifeCycleTest, Test1) {
  function TEST_F (line 5075) | TEST_F(TestLifeCycleTest, Test2) {
  function TEST (line 5086) | TEST(AssertionResultTest, CopyConstructorWorksWhenNotOptimied) {
  function TEST (line 5102) | TEST(AssertionResultTest, ConstructionWorks) {
  function TEST (line 5125) | TEST(AssertionResultTest, NegationWorks) {
  function TEST (line 5135) | TEST(AssertionResultTest, StreamingWorks) {
  function TEST (line 5141) | TEST(AssertionResultTest, CanStreamOstreamManipulators) {
  function TEST (line 5149) | TEST(AssertionResultTest, ConstructibleFromContextuallyConvertibleToBool) {
  type ConvertibleToAssertionResult (line 5160) | struct ConvertibleToAssertionResult {
  function TEST (line 5164) | TEST(AssertionResultTest, ConstructibleFromImplicitlyConvertible) {
  class Base (line 5171) | class Base {
    method Base (line 5173) | explicit Base(int an_x) : x_(an_x) {}
    method x (line 5174) | int x() const { return x_; }
  function TEST (line 5186) | TEST(MessageTest, CanStreamUserTypeInGlobalNameSpace) {
  class MyTypeInUnnamedNameSpace (line 5197) | class MyTypeInUnnamedNameSpace : public Base {
    method MyTypeInUnnamedNameSpace (line 5199) | explicit MyTypeInUnnamedNameSpace(int an_x) : Base(an_x) {}
  function TEST (line 5211) | TEST(MessageTest, CanStreamUserTypeInUnnamedNameSpace) {
  type namespace1 (line 5221) | namespace namespace1 {
    class MyTypeInNameSpace1 (line 5222) | class MyTypeInNameSpace1 : public Base {
      method MyTypeInNameSpace1 (line 5224) | explicit MyTypeInNameSpace1(int an_x) : Base(an_x) {}
  function TEST (line 5234) | TEST(MessageTest, CanStreamUserTypeInUserNameSpace) {
  type namespace2 (line 5244) | namespace namespace2 {
    class MyTypeInNameSpace2 (line 5245) | class MyTypeInNameSpace2 : public ::Base {
      method MyTypeInNameSpace2 (line 5247) | explicit MyTypeInNameSpace2(int an_x) : Base(an_x) {}
  function TEST (line 5259) | TEST(MessageTest, CanStreamUserTypeInUserNameSpaceWithStreamOperatorInGl...
  function TEST (line 5268) | TEST(MessageTest, NullPointers) {
  function TEST (line 5282) | TEST(MessageTest, WideStrings) {
  type testing (line 5302) | namespace testing {
    type internal (line 92) | namespace internal {
      class StreamingListenerTest (line 96) | class StreamingListenerTest : public Test {
        class FakeSocketWriter (line 98) | class FakeSocketWriter : public StreamingListener::AbstractSocketW...
          method Send (line 101) | void Send(const std::string& message) override { output_ += mess...
        method StreamingListenerTest (line 106) | StreamingListenerTest()
      function TEST_F (line 121) | TEST_F(StreamingListenerTest, OnTestProgramEnd) {
      function TEST_F (line 127) | TEST_F(StreamingListenerTest, OnTestIterationEnd) {
      function TEST_F (line 133) | TEST_F(StreamingListenerTest, OnTestSuiteStart) {
      function TEST_F (line 139) | TEST_F(StreamingListenerTest, OnTestSuiteEnd) {
      function TEST_F (line 145) | TEST_F(StreamingListenerTest, OnTestStart) {
      function TEST_F (line 151) | TEST_F(StreamingListenerTest, OnTestEnd) {
      function TEST_F (line 157) | TEST_F(StreamingListenerTest, OnTestPartResult) {
      class TestEventListenersAccessor (line 172) | class TestEventListenersAccessor {
        method TestEventListener (line 174) | static TestEventListener* GetRepeater(TestEventListeners* listener...
        method SetDefaultResultPrinter (line 178) | static void SetDefaultResultPrinter(TestEventListeners* listeners,
        method SetDefaultXmlGenerator (line 182) | static void SetDefaultXmlGenerator(TestEventListeners* listeners,
        method EventForwardingEnabled (line 187) | static bool EventForwardingEnabled(const TestEventListeners& liste...
        method SuppressEventForwarding (line 191) | static void SuppressEventForwarding(TestEventListeners* listeners) {
      class UnitTestRecordPropertyTestHelper (line 196) | class UnitTestRecordPropertyTestHelper : public Test {
        method UnitTestRecordPropertyTestHelper (line 198) | UnitTestRecordPropertyTestHelper() = default;
        method UnitTestRecordProperty (line 201) | void UnitTestRecordProperty(const char* key, const std::string& va...
    function TEST (line 4291) | TEST(SuccessfulAssertionTest, SUCCEED) {
    function TEST (line 4298) | TEST(SuccessfulAssertionTest, EXPECT) {
    function TEST (line 4304) | TEST(SuccessfulAssertionTest, EXPECT_STR) {
    function TEST (line 4310) | TEST(SuccessfulAssertionTest, ASSERT) {
    function TEST (line 4316) | TEST(SuccessfulAssertionTest, ASSERT_STR) {
    class TestInfoTest (line 5306) | class TestInfoTest : public Test {
      method TestInfo (line 5308) | static const TestInfo* GetTestInfo(const char* test_name) {
      method TestResult (line 5319) | static const TestResult* GetTestResult(const TestInfo* test_info) {
    function TEST_F (line 5325) | TEST_F(TestInfoTest, Names) {
    function TEST_F (line 5333) | TEST_F(TestInfoTest, result) {
    function TEST (line 5351) | TEST(CodeLocationForTEST, Verify) {
    class CodeLocationForTESTF (line 5355) | class CodeLocationForTESTF : public Test {}
    function TEST_F (line 5357) | TEST_F(CodeLocationForTESTF, Verify) {
    class CodeLocationForTESTP (line 5361) | class CodeLocationForTESTP : public TestWithParam<int> {}
    function TEST_P (line 5363) | TEST_P(CodeLocationForTESTP, Verify) {
    class CodeLocationForTYPEDTEST (line 5370) | class CodeLocationForTYPEDTEST : public Test {}
    function TYPED_TEST (line 5374) | TYPED_TEST(CodeLocationForTYPEDTEST, Verify) {
    class CodeLocationForTYPEDTESTP (line 5379) | class CodeLocationForTYPEDTESTP : public Test {}
    function TYPED_TEST_P (line 5383) | TYPED_TEST_P(CodeLocationForTYPEDTESTP, Verify) {
    class SetUpTestCaseTest (line 5397) | class SetUpTestCaseTest : public Test {
      method SetUpTestCase (line 5401) | static void SetUpTestCase() {
      method TearDownTestCase (line 5418) | static void TearDownTestCase() {
      method SetUp (line 5432) | void SetUp() override {
    function TEST_F (line 5449) | TEST_F(SetUpTestCaseTest, Test1) { EXPECT_STRNE(nullptr, shared_resour...
    function TEST_F (line 5452) | TEST_F(SetUpTestCaseTest, Test2) { EXPECT_STREQ("123", shared_resource...
    class SetUpTestSuiteTest (line 5456) | class SetUpTestSuiteTest : public Test {
      method SetUpTestSuite (line 5460) | static void SetUpTestSuite() {
      method TearDownTestSuite (line 5477) | static void TearDownTestSuite() {
      method SetUp (line 5491) | void SetUp() override {
    function TEST_F (line 5508) | TEST_F(SetUpTestSuiteTest, TestSetupTestSuite1) {
    function TEST_F (line 5513) | TEST_F(SetUpTestSuiteTest, TestSetupTestSuite2) {
    type Flags (line 5520) | struct Flags {
      method Flags (line 5522) | Flags()
      method Flags (line 5545) | static Flags AlsoRunDisabledTests(bool also_run_disabled_tests) {
      method Flags (line 5553) | static Flags BreakOnFailure(bool break_on_failure) {
      method Flags (line 5561) | static Flags CatchExceptions(bool catch_exceptions) {
      method Flags (line 5569) | static Flags DeathTestUseFork(bool death_test_use_fork) {
      method Flags (line 5577) | static Flags FailFast(bool fail_fast) {
      method Flags (line 5585) | static Flags Filter(const char* filter) {
      method Flags (line 5593) | static Flags ListTests(bool list_tests) {
      method Flags (line 5601) | static Flags Output(const char* output) {
      method Flags (line 5609) | static Flags Brief(bool brief) {
      method Flags (line 5617) | static Flags PrintTime(bool print_time) {
      method Flags (line 5625) | static Flags RandomSeed(int32_t random_seed) {
      method Flags (line 5633) | static Flags Repeat(int32_t repeat) {
      method Flags (line 5641) | static Flags RecreateEnvironmentsWhenRepeating(
      method Flags (line 5651) | static Flags Shuffle(bool shuffle) {
      method Flags (line 5659) | static Flags StackTraceDepth(int32_t stack_trace_depth) {
      method Flags (line 5667) | static Flags StreamResultTo(const char* stream_result_to) {
      method Flags (line 5675) | static Flags ThrowOnFailure(bool throw_on_failure) {
    class ParseFlagsTest (line 5702) | class ParseFlagsTest : public Test {
      method SetUp (line 5705) | void SetUp() override {
      method AssertStringArrayEq (line 5727) | static void AssertStringArrayEq(int size1, CharType** array1, int si...
      method CheckFlags (line 5737) | static void CheckFlags(const Flags& expected) {
      method TestParsingFlags (line 5765) | static void TestParsingFlags(int argc1, const CharType** argv1, int ...
    function TEST_F (line 5817) | TEST_F(ParseFlagsTest, Empty) {
    function TEST_F (line 5826) | TEST_F(ParseFlagsTest, NoFlag) {
    function TEST_F (line 5835) | TEST_F(ParseFlagsTest, FailFast) {
    function TEST_F (line 5844) | TEST_F(ParseFlagsTest, FilterEmpty) {
    function TEST_F (line 5853) | TEST_F(ParseFlagsTest, FilterNonEmpty) {
    function TEST_F (line 5862) | TEST_F(ParseFlagsTest, BreakOnFailureWithoutValue) {
    function TEST_F (line 5871) | TEST_F(ParseFlagsTest, BreakOnFailureFalse_0) {
    function TEST_F (line 5880) | TEST_F(ParseFlagsTest, BreakOnFailureFalse_f) {
    function TEST_F (line 5889) | TEST_F(ParseFlagsTest, BreakOnFailureFalse_F) {
    function TEST_F (line 5899) | TEST_F(ParseFlagsTest, BreakOnFailureTrue) {
    function TEST_F (line 5908) | TEST_F(ParseFlagsTest, CatchExceptions) {
    function TEST_F (line 5917) | TEST_F(ParseFlagsTest, DeathTestUseFork) {
    function TEST_F (line 5927) | TEST_F(ParseFlagsTest, DuplicatedFlags) {
    function TEST_F (line 5937) | TEST_F(ParseFlagsTest, UnrecognizedFlag) {
    function TEST_F (line 5951) | TEST_F(ParseFlagsTest, ListTestsFlag) {
    function TEST_F (line 5960) | TEST_F(ParseFlagsTest, ListTestsTrue) {
    function TEST_F (line 5969) | TEST_F(ParseFlagsTest, ListTestsFalse) {
    function TEST_F (line 5978) | TEST_F(ParseFlagsTest, ListTestsFalse_f) {
    function TEST_F (line 5987) | TEST_F(ParseFlagsTest, ListTestsFalse_F) {
    function TEST_F (line 5996) | TEST_F(ParseFlagsTest, OutputXml) {
    function TEST_F (line 6005) | TEST_F(ParseFlagsTest, OutputXmlFile) {
    function TEST_F (line 6014) | TEST_F(ParseFlagsTest, OutputXmlDirectory) {
    function TEST_F (line 6025) | TEST_F(ParseFlagsTest, BriefFlag) {
    function TEST_F (line 6034) | TEST_F(ParseFlagsTest, BriefFlagTrue) {
    function TEST_F (line 6043) | TEST_F(ParseFlagsTest, BriefFlagFalse) {
    function TEST_F (line 6052) | TEST_F(ParseFlagsTest, PrintTimeFlag) {
    function TEST_F (line 6061) | TEST_F(ParseFlagsTest, PrintTimeTrue) {
    function TEST_F (line 6070) | TEST_F(ParseFlagsTest, PrintTimeFalse) {
    function TEST_F (line 6079) | TEST_F(ParseFlagsTest, PrintTimeFalse_f) {
    function TEST_F (line 6088) | TEST_F(ParseFlagsTest, PrintTimeFalse_F) {
    function TEST_F (line 6097) | TEST_F(ParseFlagsTest, RandomSeed) {
    function TEST_F (line 6106) | TEST_F(ParseFlagsTest, Repeat) {
    function TEST_F (line 6115) | TEST_F(ParseFlagsTest, RecreateEnvironmentsWhenRepeating) {
    function TEST_F (line 6129) | TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFlag) {
    function TEST_F (line 6139) | TEST_F(ParseFlagsTest, AlsoRunDisabledTestsTrue) {
    function TEST_F (line 6150) | TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFalse) {
    function TEST_F (line 6161) | TEST_F(ParseFlagsTest, ShuffleWithoutValue) {
    function TEST_F (line 6170) | TEST_F(ParseFlagsTest, ShuffleFalse_0) {
    function TEST_F (line 6179) | TEST_F(ParseFlagsTest, ShuffleTrue) {
    function TEST_F (line 6188) | TEST_F(ParseFlagsTest, StackTraceDepth) {
    function TEST_F (line 6196) | TEST_F(ParseFlagsTest, StreamResultTo) {
    function TEST_F (line 6207) | TEST_F(ParseFlagsTest, ThrowOnFailureWithoutValue) {
    function TEST_F (line 6216) | TEST_F(ParseFlagsTest, ThrowOnFailureFalse_0) {
    function TEST_F (line 6226) | TEST_F(ParseFlagsTest, ThrowOnFailureTrue) {
    function TEST_F (line 6235) | TEST_F(ParseFlagsTest, FilterBad) {
    function TEST_F (line 6254) | TEST_F(ParseFlagsTest, OutputEmpty) {
    function TEST_F (line 6273) | TEST_F(ParseFlagsTest, AbseilPositionalFlags) {
    function TEST_F (line 6286) | TEST_F(ParseFlagsTest, UnrecognizedFlags) {
    function TEST_F (line 6297) | TEST_F(ParseFlagsTest, WideStrings) {
    class FlagfileTest (line 6317) | class FlagfileTest : public ParseFlagsTest {
      method SetUp (line 6319) | void SetUp() override {
      method TearDown (line 6329) | void TearDown() override {
      method CreateFlagfile (line 6334) | internal::FilePath CreateFlagfile(const char* contents) {
    function TEST_F (line 6348) | TEST_F(FlagfileTest, Empty) {
    function TEST_F (line 6361) | TEST_F(FlagfileTest, FilterNonEmpty) {
    function TEST_F (line 6375) | TEST_F(FlagfileTest, SeveralFlags) {
    class CurrentTestInfoTest (line 6397) | class CurrentTestInfoTest : public Test {
      method SetUpTestSuite (line 6401) | static void SetUpTestSuite() {
      method TearDownTestSuite (line 6410) | static void TearDownTestSuite() {
    function TEST_F (line 6419) | TEST_F(CurrentTestInfoTest, WorksForFirstTestInATestSuite) {
    function TEST_F (line 6433) | TEST_F(CurrentTestInfoTest, WorksForSecondTestInATestSuite) {
  type my_namespace (line 6447) | namespace my_namespace {
    type testing (line 6448) | namespace testing {
      class Test (line 6452) | class Test {}
      class Message (line 6456) | class Message {}
      class AssertionResult (line 6461) | class AssertionResult {}
      function TEST (line 6464) | TEST(NestedTestingNamespaceTest, Success) {
      function TEST (line 6469) | TEST(NestedTestingNamespaceTest, Failure) {
  class ProtectedFixtureMethodsTest (line 6481) | class ProtectedFixtureMethodsTest : public Test {
    method SetUp (line 6483) | void SetUp() override { Test::SetUp(); }
    method TearDown (line 6484) | void TearDown() override { Test::TearDown(); }
  function TEST (line 6489) | TEST(StreamingAssertionsTest, Unconditional) {
  function TEST (line 6501) | TEST(StreamingAssertionsTest, Truth) {
  function TEST (line 6510) | TEST(StreamingAssertionsTest, Truth2) {
  function TEST (line 6524) | TEST(StreamingAssertionsTest, IntegerEquals) {
  function TEST (line 6533) | TEST(StreamingAssertionsTest, IntegerLessThan) {
  function TEST (line 6542) | TEST(StreamingAssertionsTest, StringsEqual) {
  function TEST (line 6551) | TEST(StreamingAssertionsTest, StringsNotEqual) {
  function TEST (line 6560) | TEST(StreamingAssertionsTest, StringsEqualIgnoringCase) {
  function TEST (line 6569) | TEST(StreamingAssertionsTest, StringNotEqualIgnoringCase) {
  function TEST (line 6578) | TEST(StreamingAssertionsTest, FloatingPointEquals) {
  function TEST (line 6589) | TEST(StreamingAssertionsTest, Throw) {
  function TEST (line 6600) | TEST(StreamingAssertionsTest, NoThrow) {
  function TEST (line 6610) | TEST(StreamingAssertionsTest, AnyThrow) {
  function TEST (line 6624) | TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsYes) {
  function TEST (line 6636) | TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsAliasOfYes) {
  function TEST (line 6649) | TEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsNo) {
  function TEST (line 6661) | TEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsInvalid) {
  function TEST (line 6674) | TEST(ColoredOutputTest, UsesColorsWhenStdoutIsTty) {
  function TEST (line 6682) | TEST(ColoredOutputTest, UsesColorsWhenTermSupportsColors) {
  class StaticAssertTypeEqTestHelper (line 6765) | class StaticAssertTypeEqTestHelper {
    method StaticAssertTypeEqTestHelper (line 6767) | StaticAssertTypeEqTestHelper() { StaticAssertTypeEq<bool, T>(); }
  function TEST (line 6770) | TEST(StaticAssertTypeEqTest, WorksInClass) {
  function TEST (line 6778) | TEST(StaticAssertTypeEqTest, CompilesForEqualTypes) {
  function TEST (line 6783) | TEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsNoFailure) {
  function FailFatally (line 6787) | static void FailFatally() { FAIL(); }
  function TEST (line 6789) | TEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsOnlyFatalFailure) {
  function TEST (line 6796) | TEST(HasNonfatalFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) {
  function TEST (line 6803) | TEST(HasNonfatalFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFail...
  function HasNonfatalFailureHelper (line 6812) | static bool HasNonfatalFailureHelper() {
  function TEST (line 6816) | TEST(HasNonfatalFailureTest, WorksOutsideOfTestBody) {
  function TEST (line 6820) | TEST(HasNonfatalFailureTest, WorksOutsideOfTestBody2) {
  function TEST (line 6827) | TEST(HasFailureTest, ReturnsFalseWhenThereIsNoFailure) {
  function TEST (line 6831) | TEST(HasFailureTest, ReturnsTrueWhenThereIsFatalFailure) {
  function TEST (line 6838) | TEST(HasFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) {
  function TEST (line 6845) | TEST(HasFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) {
  function HasFailureHelper (line 6854) | static bool HasFailureHelper() { return testing::Test::HasFailure(); }
  function TEST (line 6856) | TEST(HasFailureTest, WorksOutsideOfTestBody) {
  function TEST (line 6860) | TEST(HasFailureTest, WorksOutsideOfTestBody2) {
  class TestListener (line 6867) | class TestListener : public EmptyTestEventListener {
    method TestListener (line 6869) | TestListener() : on_start_counter_(nullptr), is_destroyed_(nullptr) {}
    method TestListener (line 6870) | TestListener(int* on_start_counter, bool* is_destroyed)
    method OnTestProgramStart (line 6878) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {
  function TEST (line 6888) | TEST(TestEventListenersTest, ConstructionWorks) {
  function TEST (line 6898) | TEST(TestEventListenersTest, DestructionWorks) {
  function TEST (line 6924) | TEST(TestEventListenersTest, Append) {
  class SequenceTestingListener (line 6941) | class SequenceTestingListener : public EmptyTestEventListener {
    method SequenceTestingListener (line 6943) | SequenceTestingListener(std::vector<std::string>* vector, const char* id)
    method OnTestProgramStart (line 6947) | void OnTestProgramStart(const UnitTest& /*unit_test*/) override {
    method OnTestProgramEnd (line 6951) | void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {
    method OnTestIterationStart (line 6955) | void OnTestIterationStart(const UnitTest& /*unit_test*/,
    method OnTestIterationEnd (line 6960) | void OnTestIterationEnd(const UnitTest& /*unit_test*/,
    method GetEventDescription (line 6966) | std::string GetEventDescription(const char* method) {
    method SequenceTestingListener (line 6975) | SequenceTestingListener(const SequenceTestingListener&) = delete;
    method SequenceTestingListener (line 6976) | SequenceTestingListener& operator=(const SequenceTestingListener&) = d...
  function TEST (line 6979) | TEST(EventListenerTest, AppendKeepsOrder) {
  function TEST (line 7020) | TEST(TestEventListenersTest, Release) {
  function TEST (line 7041) | TEST(EventListenerTest, SuppressEventForwarding) {
  function TEST (line 7057) | TEST(EventListenerDeathTest, EventsNotForwardedInDeathTestSubprocesses) {
  function TEST (line 7070) | TEST(EventListenerTest, default_result_printer) {
  function TEST (line 7101) | TEST(EventListenerTest, RemovingDefaultResultPrinterWorks) {
  function TEST (line 7129) | TEST(EventListenerTest, default_xml_generator) {
  function TEST (line 7160) | TEST(EventListenerTest, RemovingDefaultXmlGeneratorWorks) {
  function GTEST_TEST (line 7190) | GTEST_TEST(AlternativeNameTest, Works) {  // GTEST_TEST is the same as T...
  class ConversionHelperBase (line 7236) | class ConversionHelperBase {}
  class ConversionHelperDerived (line 7237) | class ConversionHelperDerived : public ConversionHelperBase {}
  type HasDebugStringMethods (line 7239) | struct HasDebugStringMethods {
    method DebugString (line 7240) | std::string DebugString() const { return ""; }
    method ShortDebugString (line 7241) | std::string ShortDebugString() const { return ""; }
  type InheritsDebugStringMethods (line 7244) | struct InheritsDebugStringMethods : public HasDebugStringMethods {}
  type WrongTypeDebugStringMethod (line 7246) | struct WrongTypeDebugStringMethod {
    method DebugString (line 7247) | std::string DebugString() const { return ""; }
    method ShortDebugString (line 7248) | int ShortDebugString() const { return 1; }
  type NotConstDebugStringMethod (line 7251) | struct NotConstDebugStringMethod {
    method DebugString (line 7252) | std::string DebugString() { return ""; }
    method ShortDebugString (line 7253) | std::string ShortDebugString() const { return ""; }
  type MissingDebugStringMethod (line 7256) | struct MissingDebugStringMethod {
    method DebugString (line 7257) | std::string DebugString() { return ""; }
  type IncompleteType (line 7260) | struct IncompleteType
  function TEST (line 7264) | TEST(HasDebugStringAndShortDebugStringTest, ValueIsCompileTimeConstant) {
  function TEST (line 7289) | TEST(HasDebugStringAndShortDebugStringTest,
  function TEST (line 7297) | TEST(HasDebugStringAndShortDebugStringTest,
  function TestGTestRemoveReferenceAndConst (line 7307) | void TestGTestRemoveReferenceAndConst() {
  function TEST (line 7312) | TEST(RemoveReferenceToConstTest, Works) {
  function TestGTestReferenceToConst (line 7323) | void TestGTestReferenceToConst() {
  function TEST (line 7328) | TEST(GTestReferenceToConstTest, Works) {
  class NonContainer (line 7337) | class NonContainer {}
  function TEST (line 7339) | TEST(IsContainerTestTest, WorksForNonContainer) {
  function TEST (line 7345) | TEST(IsContainerTestTest, WorksForContainer) {
  type ConstOnlyContainerWithPointerIterator (line 7351) | struct ConstOnlyContainerWithPointerIterator {
  type ConstOnlyContainerWithClassIterator (line 7357) | struct ConstOnlyContainerWithClassIterator {
    type const_iterator (line 7358) | struct const_iterator {
  function TEST (line 7366) | TEST(IsContainerTestTest, ConstOnlyContainer) {
  type AHashTable (line 7374) | struct AHashTable {
  type NotReallyAHashTable (line 7377) | struct NotReallyAHashTable {
  function TEST (line 7381) | TEST(IsHashTable, Basic) {
  function TEST (line 7390) | TEST(ArrayEqTest, WorksForDegeneratedArrays) {
  function TEST (line 7395) | TEST(ArrayEqTest, WorksForOneDimensionalArrays) {
  function TEST (line 7407) | TEST(ArrayEqTest, WorksForTwoDimensionalArrays) {
  function TEST (line 7421) | TEST(ArrayAwareFindTest, WorksForOneDimensionalArray) {
  function TEST (line 7427) | TEST(ArrayAwareFindTest, WorksForTwoDimensionalArray) {
  function TEST (line 7438) | TEST(CopyArrayTest, WorksForDegeneratedArrays) {
  function TEST (line 7444) | TEST(CopyArrayTest, WorksForOneDimensionalArrays) {
  function TEST (line 7457) | TEST(CopyArrayTest, WorksForTwoDimensionalArrays) {
  function TEST (line 7472) | TEST(NativeArrayTest, ConstructorFromArrayWorks) {
  function TEST (line 7479) | TEST(NativeArrayTest, CreatesAndDeletesCopyOfArrayWhenAskedTo) {
  function TEST (line 7494) | TEST(NativeArrayTest, TypeMembersAreCorrect) {
  function TEST (line 7502) | TEST(NativeArrayTest, MethodsWork) {
  function TEST (line 7528) | TEST(NativeArrayTest, WorksForTwoDimensionalArray) {
  function TEST (line 7536) | TEST(ElemFromList, Basic) {
  function TEST (line 7550) | TEST(FlatTuple, Basic) {
  function AddIntToString (line 7569) | std::string AddIntToString(int i, const std::string& s) {
  function TEST (line 7574) | TEST(FlatTuple, Apply) {
  type ConstructionCounting (line 7597) | struct ConstructionCounting {
    method ConstructionCounting (line 7598) | ConstructionCounting() { ++default_ctor_calls; }
    method ConstructionCounting (line 7600) | ConstructionCounting(const ConstructionCounting&) { ++copy_ctor_calls; }
    method ConstructionCounting (line 7601) | ConstructionCounting(ConstructionCounting&&) noexcept { ++move_ctor_ca...
    method ConstructionCounting (line 7602) | ConstructionCounting& operator=(const ConstructionCounting&) {
    method ConstructionCounting (line 7606) | ConstructionCounting& operator=(ConstructionCounting&&) noexcept {
    method Reset (line 7611) | static void Reset() {
  function TEST (line 7635) | TEST(FlatTuple, ConstructorCalls) {
  function TEST (line 7709) | TEST(FlatTuple, ManyTypes) {
  function TEST (line 7736) | TEST(SkipPrefixTest, SkipsWhenPrefixMatches) {
  function TEST (line 7748) | TEST(SkipPrefixTest, DoesNotSkipWhenPrefixDoesNotMatch) {
  function TEST (line 7761) | TEST(AdHocTestResultTest, AdHocTestResultForUnitTestDoesNotShowFailure) {
  class DynamicUnitTestFixture (line 7767) | class DynamicUnitTestFixture : public testing::Test {}
  class DynamicTest (line 7769) | class DynamicTest : public DynamicUnitTestFixture {
    method TestBody (line 7770) | void TestBody() override { EXPECT_TRUE(true); }
  function TEST (line 7777) | TEST(RegisterTest, WasRegistered) {
  function TEST (line 7796) | TEST(PatternGlobbingTest, MatchesFilterLinearRuntime) {
  function TEST (line 7810) | TEST(PatternGlobbingTest, MatchesFilterWithMultiplePatterns) {
  function TEST (line 7819) | TEST(PatternGlobbingTest, MatchesFilterEdgeCases) {

FILE: googletest/test/gtest_xml_outfile1_test_.cc
  class PropertyOne (line 35) | class PropertyOne : public testing::Test {
    method SetUp (line 37) | void SetUp() override { RecordProperty("SetUpProp", 1); }
    method TearDown (line 38) | void TearDown() override { RecordProperty("TearDownProp", 1); }
  function TEST_F (line 41) | TEST_F(PropertyOne, TestSomeProperties) {

FILE: googletest/test/gtest_xml_outfile2_test_.cc
  class PropertyTwo (line 37) | class PropertyTwo : public testing::Test {
    method SetUp (line 39) | void SetUp() override { RecordProperty("SetUpProp", 2); }
    method TearDown (line 40) | void TearDown() override { RecordProperty("TearDownProp", 2); }
  function TEST_F (line 43) | TEST_F(PropertyTwo, TestInt64ConvertibleProperties) {

FILE: googletest/test/gtest_xml_outfiles_test.py
  class GTestXMLOutFilesTest (line 81) | class GTestXMLOutFilesTest(gtest_xml_test_utils.GTestXMLTestCase):
    method setUp (line 84) | def setUp(self):
    method tearDown (line 93) | def tearDown(self):
    method DeleteFilesAndDir (line 96) | def DeleteFilesAndDir(self):
    method testOutfile1 (line 110) | def testOutfile1(self):
    method testOutfile2 (line 113) | def testOutfile2(self):
    method _TestOutFile (line 116) | def _TestOutFile(self, test_name, expected_xml):

FILE: googletest/test/gtest_xml_output_unittest.py
  class GTestXMLOutputUnitTest (line 292) | class GTestXMLOutputUnitTest(gtest_xml_test_utils.GTestXMLTestCase):
    method testNonEmptyXmlOutput (line 299) | def testNonEmptyXmlOutput(self):
    method testNoTestXmlOutput (line 307) | def testNoTestXmlOutput(self):
    method testTimestampValue (line 316) | def testTimestampValue(self):
    method testDefaultOutputFile (line 344) | def testDefaultOutputFile(self):
    method testSuppressedXmlOutput (line 371) | def testSuppressedXmlOutput(self):
    method testFilteredTestXmlOutput (line 407) | def testFilteredTestXmlOutput(self):
    method testShardedTestXmlOutput (line 421) | def testShardedTestXmlOutput(self):
    method _GetXmlOutput (line 435) | def _GetXmlOutput(
    method _TestXmlOutput (line 478) | def _TestXmlOutput(

FILE: googletest/test/gtest_xml_output_unittest_.cc
  class SuccessfulTest (line 51) | class SuccessfulTest : public Test {}
  function TEST_F (line 53) | TEST_F(SuccessfulTest, Succeeds) {
  class FailedTest (line 58) | class FailedTest : public Test {
  function TEST_F (line 61) | TEST_F(FailedTest, Fails) {
  class DisabledTest (line 65) | class DisabledTest : public Test {
  function TEST_F (line 68) | TEST_F(DisabledTest, DISABLED_test_not_run) {
  class SkippedTest (line 72) | class SkippedTest : public Test {
  function TEST_F (line 75) | TEST_F(SkippedTest, Skipped) {
  function TEST_F (line 79) | TEST_F(SkippedTest, SkippedWithMessage) {
  function TEST_F (line 83) | TEST_F(SkippedTest, SkippedAfterFailure) {
  function TEST (line 88) | TEST(MixedResultTest, Succeeds) {
  function TEST (line 93) | TEST(MixedResultTest, Fails) {
  function TEST (line 98) | TEST(MixedResultTest, DISABLED_test) {
  function TEST (line 102) | TEST(XmlQuotingTest, OutputsCData) {
  function TEST (line 109) | TEST(InvalidCharactersTest, InvalidCharactersInMessage) {
  class PropertyRecordingTest (line 113) | class PropertyRecordingTest : public Test {
    method SetUpTestSuite (line 115) | static void SetUpTestSuite() {
    method TearDownTestSuite (line 119) | static void TearDownTestSuite() {
  function TEST_F (line 125) | TEST_F(PropertyRecordingTest, OneProperty) {
  function TEST_F (line 129) | TEST_F(PropertyRecordingTest, IntValuedProperty) {
  function TEST_F (line 133) | TEST_F(PropertyRecordingTest, ThreeProperties) {
  function TEST_F (line 139) | TEST_F(PropertyRecordingTest, TwoValuesForOneKeyUsesLastValue) {
  function TEST (line 144) | TEST(NoFixtureTest, RecordProperty) {
  function ExternalUtilityThatCallsRecordProperty (line 148) | void ExternalUtilityThatCallsRecordProperty(const std::string& key, int ...
  function ExternalUtilityThatCallsRecordProperty (line 152) | void ExternalUtilityThatCallsRecordProperty(const std::string& key,
  function TEST (line 157) | TEST(NoFixtureTest, ExternalUtilityThatCallsRecordIntValuedProperty) {
  function TEST (line 161) | TEST(NoFixtureTest, ExternalUtilityThatCallsRecordStringValuedProperty) {
  class SetupFailTest (line 167) | class SetupFailTest : public ::testing::Test {
    method SetUpTestSuite (line 169) | static void SetUpTestSuite() { ASSERT_EQ(1, 2); }
  function TEST_F (line 172) | TEST_F(SetupFailTest, NoopPassingTest) {}
  class TearDownFailTest (line 174) | class TearDownFailTest : public ::testing::Test {
    method TearDownTestSuite (line 176) | static void TearDownTestSuite() { ASSERT_EQ(1, 2); }
  function TEST_F (line 179) | TEST_F(TearDownFailTest, NoopPassingTest) {}
  class ValueParamTest (line 183) | class ValueParamTest : public TestWithParam<int> {}
  function TEST_P (line 184) | TEST_P(ValueParamTest, HasValueParamAttribute) {}
  function TEST_P (line 185) | TEST_P(ValueParamTest, AnotherTestThatHasValueParamAttribute) {}
  class TypedTest (line 190) | class TypedTest : public Test {}
  function TYPED_TEST (line 193) | TYPED_TEST(TypedTest, HasTypeParamAttribute) {}
  class TypeParameterizedTestSuite (line 198) | class TypeParameterizedTestSuite : public Test {}
  function TYPED_TEST_P (line 200) | TYPED_TEST_P(TypeParameterizedTestSuite, HasTypeParamAttribute) {}
  function main (line 206) | int main(int argc, char** argv) {

FILE: googletest/test/gtest_xml_test_utils.py
  class GTestXMLTestCase (line 39) | class GTestXMLTestCase(gtest_test_utils.TestCase):
    method AssertEquivalentNodes (line 42) | def AssertEquivalentNodes(self, expected_node, actual_node):
    method _GetChildren (line 131) | def _GetChildren(self, element):
    method NormalizeXml (line 186) | def NormalizeXml(self, element):

FILE: googletest/test/production.h
  function class (line 38) | class PrivateCode {