testing::internal::UnitTestOptions Class Reference

#include <gtest-internal-inl.h>

Static Public Member Functions
static std::string	GetOutputFormat ()
static std::string	GetAbsolutePathToOutputFile ()
static bool	PatternMatchesString (const char *pattern, const char *str)
static bool	FilterMatchesTest (const std::string &test_case_name, const std::string &test_name)
static bool	MatchesFilter (const std::string &name, const char *filter)

Detailed Description

Definition at line 369 of file gtest-internal-inl.h.

Member Function Documentation

FilterMatchesTest()

bool testing::internal::UnitTestOptions::FilterMatchesTest ( const std::string & test_case_name, const std::string & test_name )

static

Definition at line 519 of file gtest.cc.

                                                                    {
  const std::string& full_name = test_case_name + "." + test_name.c_str();
 
  // Split --gtest_filter at '-', if there is one, to separate into
  // positive filter and negative filter portions
  const char* const p = GTEST_FLAG(filter).c_str();
  const char* const dash = strchr(p, '-');
  std::string positive;
  std::string negative;
  if (dash == NULL) {
    positive = GTEST_FLAG(filter).c_str();  // Whole string is a positive filter
    negative = "";
  } else {
    positive = std::string(p, dash);   // Everything up to the dash
    negative = std::string(dash + 1);  // Everything after the dash
    if (positive.empty()) {
      // Treat '-test1' as the same as '*-test1'
      positive = kUniversalFilter;
    }
  }
 
  // A filter is a colon-separated list of patterns.  It matches a
  // test if any pattern in it matches the test.
  return (MatchesFilter(full_name, positive.c_str()) &&
          !MatchesFilter(full_name, negative.c_str()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetAbsolutePathToOutputFile()

std::string testing::internal::UnitTestOptions::GetAbsolutePathToOutputFile ( )

static

Definition at line 438 of file gtest.cc.

                                                       {
  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
  if (gtest_output_flag == NULL)
    return "";
 
  std::string format = GetOutputFormat();
  if (format.empty())
    format = std::string(kDefaultOutputFormat);
 
  const char* const colon = strchr(gtest_output_flag, ':');
  if (colon == NULL)
    return internal::FilePath::MakeFileName(
        internal::FilePath(
            UnitTest::GetInstance()->original_working_dir()),
        internal::FilePath(kDefaultOutputFile), 0,
        format.c_str()).string();
 
  internal::FilePath output_name(colon + 1);
  if (!output_name.IsAbsolutePath())
    // TODO(wan@google.com): on Windows \some\path is not an absolute
    // path (as its meaning depends on the current drive), yet the
    // following logic for turning it into an absolute path is wrong.
    // Fix it.
    output_name = internal::FilePath::ConcatPaths(
        internal::FilePath(UnitTest::GetInstance()->original_working_dir()),
        internal::FilePath(colon + 1));
 
  if (!output_name.IsDirectory())
    return output_name.string();
 
  internal::FilePath result(internal::FilePath::GenerateUniqueFileName(
      output_name, internal::GetCurrentExecutableName(),
      GetOutputFormat().c_str()));
  return result.string();
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetOutputFormat()

std::string testing::internal::UnitTestOptions::GetOutputFormat ( )

static

Definition at line 426 of file gtest.cc.

                                           {
  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
  if (gtest_output_flag == NULL) return std::string("");
 
  const char* const colon = strchr(gtest_output_flag, ':');
  return (colon == NULL) ?
      std::string(gtest_output_flag) :
      std::string(gtest_output_flag, colon - gtest_output_flag);
}

Here is the caller graph for this function:

MatchesFilter()

bool testing::internal::UnitTestOptions::MatchesFilter ( const std::string & name, const char * filter )

static

Definition at line 496 of file gtest.cc.

                                               {
  const char *cur_pattern = filter;
  for (;;) {
    if (PatternMatchesString(cur_pattern, name.c_str())) {
      return true;
    }
 
    // Finds the next pattern in the filter.
    cur_pattern = strchr(cur_pattern, ':');
 
    // Returns if no more pattern can be found.
    if (cur_pattern == NULL) {
      return false;
    }
 
    // Skips the pattern separater (the ':' character).
    cur_pattern++;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PatternMatchesString()

bool testing::internal::UnitTestOptions::PatternMatchesString ( const char * pattern, const char * str )

static

Definition at line 479 of file gtest.cc.

                                                            {
  switch (*pattern) {
    case '\0':
    case ':':  // Either ':' or '\0' marks the end of the pattern.
      return *str == '\0';
    case '?':  // Matches any single character.
      return *str != '\0' && PatternMatchesString(pattern + 1, str + 1);
    case '*':  // Matches any string (possibly empty) of characters.
      return (*str != '\0' && PatternMatchesString(pattern, str + 1)) ||
          PatternMatchesString(pattern + 1, str);
    default:  // Non-special character.  Matches itself.
      return *pattern == *str &&
          PatternMatchesString(pattern + 1, str + 1);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• libraries/fc/include/fc/crypto/webauthn_json/thirdparty/gtest/googletest/src/gtest-internal-inl.h
• libraries/fc/include/fc/crypto/webauthn_json/thirdparty/gtest/googletest/src/gtest.cc