testing::ParseFlagsTest Class Reference

Inheritance diagram for testing::ParseFlagsTest:

Protected Member Functions
void	SetUp () override
Protected Member Functions inherited from testing::Test
	Test ()
virtual void	SetUp ()
virtual void	TearDown ()

Static Protected Member Functions
template<typename CharType >
static void	AssertStringArrayEq (int size1, CharType **array1, int size2, CharType **array2)
static void	CheckFlags (const Flags &expected)
template<typename CharType >
static void	TestParsingFlags (int argc1, const CharType **argv1, int argc2, const CharType **argv2, const Flags &expected, bool should_print_help)

Additional Inherited Members
Public Member Functions inherited from testing::Test
virtual	~Test ()
Static Public Member Functions inherited from testing::Test
static void	SetUpTestSuite ()
static void	TearDownTestSuite ()
static void	TearDownTestCase ()
static void	SetUpTestCase ()
static bool	HasFatalFailure ()
static bool	HasNonfatalFailure ()
static bool	IsSkipped ()
static bool	HasFailure ()
static void	RecordProperty (const std::string &key, const std::string &value)
static void	RecordProperty (const std::string &key, int value)

Detailed Description

Definition at line 5738 of file gtest_unittest.cc.

Member Function Documentation

AssertStringArrayEq()

template<typename CharType >

static void testing::ParseFlagsTest::AssertStringArrayEq ( int  size1, CharType **  array1, int  size2, CharType **  array2  )

inlinestaticprotected

Definition at line 5762 of file gtest_unittest.cc.

                                                     {
    ASSERT_EQ(size1, size2) << " Array sizes different.";
 
    for (int i = 0; i != size1; i++) {
      ASSERT_STREQ(array1[i], array2[i]) << " where i == " << i;
    }
  }

CheckFlags()

static void testing::ParseFlagsTest::CheckFlags ( const Flags &  expected )

inlinestaticprotected

Definition at line 5772 of file gtest_unittest.cc.

                                                {
    EXPECT_EQ(expected.also_run_disabled_tests,
              GTEST_FLAG(also_run_disabled_tests));
    EXPECT_EQ(expected.break_on_failure, GTEST_FLAG(break_on_failure));
    EXPECT_EQ(expected.catch_exceptions, GTEST_FLAG(catch_exceptions));
    EXPECT_EQ(expected.death_test_use_fork, GTEST_FLAG(death_test_use_fork));
    EXPECT_EQ(expected.fail_fast, GTEST_FLAG(fail_fast));
    EXPECT_STREQ(expected.filter, GTEST_FLAG(filter).c_str());
    EXPECT_EQ(expected.list_tests, GTEST_FLAG(list_tests));
    EXPECT_STREQ(expected.output, GTEST_FLAG(output).c_str());
    EXPECT_EQ(expected.brief, GTEST_FLAG(brief));
    EXPECT_EQ(expected.print_time, GTEST_FLAG(print_time));
    EXPECT_EQ(expected.random_seed, GTEST_FLAG(random_seed));
    EXPECT_EQ(expected.repeat, GTEST_FLAG(repeat));
    EXPECT_EQ(expected.shuffle, GTEST_FLAG(shuffle));
    EXPECT_EQ(expected.stack_trace_depth, GTEST_FLAG(stack_trace_depth));
    EXPECT_STREQ(expected.stream_result_to,
                 GTEST_FLAG(stream_result_to).c_str());
    EXPECT_EQ(expected.throw_on_failure, GTEST_FLAG(throw_on_failure));
  }

SetUp()

void testing::ParseFlagsTest::SetUp ( )

inlineoverrideprotectedvirtual

Reimplemented from testing::Test.

Definition at line 5741 of file gtest_unittest.cc.

                        {
    GTEST_FLAG(also_run_disabled_tests) = false;
    GTEST_FLAG(break_on_failure) = false;
    GTEST_FLAG(catch_exceptions) = false;
    GTEST_FLAG(death_test_use_fork) = false;
    GTEST_FLAG(fail_fast) = false;
    GTEST_FLAG(filter) = "";
    GTEST_FLAG(list_tests) = false;
    GTEST_FLAG(output) = "";
    GTEST_FLAG(brief) = false;
    GTEST_FLAG(print_time) = true;
    GTEST_FLAG(random_seed) = 0;
    GTEST_FLAG(repeat) = 1;
    GTEST_FLAG(shuffle) = false;
    GTEST_FLAG(stack_trace_depth) = kMaxStackTraceDepth;
    GTEST_FLAG(stream_result_to) = "";
    GTEST_FLAG(throw_on_failure) = false;
  }

TestParsingFlags()

template<typename CharType >

static void testing::ParseFlagsTest::TestParsingFlags ( int  argc1, const CharType **  argv1, int  argc2, const CharType **  argv2, const Flags &  expected, bool  should_print_help  )

inlinestaticprotected

Definition at line 5797 of file gtest_unittest.cc.

                                                                              {
    const bool saved_help_flag = ::testing::internal::g_help_flag;
    ::testing::internal::g_help_flag = false;
 
# if GTEST_HAS_STREAM_REDIRECTION
    CaptureStdout();
# endif
 
    // Parses the command line.
    internal::ParseGoogleTestFlagsOnly(&argc1, const_cast<CharType**>(argv1));
 
# if GTEST_HAS_STREAM_REDIRECTION
    const std::string captured_stdout = GetCapturedStdout();
# endif
 
    // Verifies the flag values.
    CheckFlags(expected);
 
    // Verifies that the recognized flags are removed from the command
    // line.
    AssertStringArrayEq(argc1 + 1, argv1, argc2 + 1, argv2);
 
    // ParseGoogleTestFlagsOnly should neither set g_help_flag nor print the
    // help message for the flags it recognizes.
    EXPECT_EQ(should_print_help, ::testing::internal::g_help_flag);
 
# if GTEST_HAS_STREAM_REDIRECTION
    const char* const expected_help_fragment =
        "This program contains tests written using";
    if (should_print_help) {
      EXPECT_PRED_FORMAT2(IsSubstring, expected_help_fragment, captured_stdout);
    } else {
      EXPECT_PRED_FORMAT2(IsNotSubstring,
                          expected_help_fragment, captured_stdout);
    }
# endif  // GTEST_HAS_STREAM_REDIRECTION
 
    ::testing::internal::g_help_flag = saved_help_flag;
  }

---

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

• /media/home/debian/src/github/tesseract-ocr/tesseract/unittest/third_party/googletest/googletest/test/gtest_unittest.cc