Merge branch 'master' into patch-1
This commit is contained in:
		
						commit
						b756c6c48b
					
				@ -1313,13 +1313,14 @@ AssertionResult EqFailure(const char* lhs_expression,
 | 
			
		||||
                          const std::string& rhs_value,
 | 
			
		||||
                          bool ignoring_case) {
 | 
			
		||||
  Message msg;
 | 
			
		||||
  msg << "      Expected: " << lhs_expression;
 | 
			
		||||
  msg << "Expected equality of these values:";
 | 
			
		||||
  msg << "\n  " << lhs_expression;
 | 
			
		||||
  if (lhs_value != lhs_expression) {
 | 
			
		||||
    msg << "\n      Which is: " << lhs_value;
 | 
			
		||||
    msg << "\n    Which is: " << lhs_value;
 | 
			
		||||
  }
 | 
			
		||||
  msg << "\nTo be equal to: " << rhs_expression;
 | 
			
		||||
  msg << "\n  " << rhs_expression;
 | 
			
		||||
  if (rhs_value != rhs_expression) {
 | 
			
		||||
    msg << "\n      Which is: " << rhs_value;
 | 
			
		||||
    msg << "\n    Which is: " << rhs_value;
 | 
			
		||||
  }
 | 
			
		||||
 | 
			
		||||
  if (ignoring_case) {
 | 
			
		||||
 | 
			
		||||
@ -5,8 +5,9 @@ Value of: false
 | 
			
		||||
  Actual: false
 | 
			
		||||
Expected: true
 | 
			
		||||
gtest_output_test_.cc:#: Failure
 | 
			
		||||
      Expected: 2
 | 
			
		||||
To be equal to: 3
 | 
			
		||||
Expected equality of these values:
 | 
			
		||||
  2
 | 
			
		||||
  3
 | 
			
		||||
[0;32m[==========] [mRunning 66 tests from 29 test cases.
 | 
			
		||||
[0;32m[----------] [mGlobal test environment set-up.
 | 
			
		||||
FooEnvironment::SetUp() called.
 | 
			
		||||
@ -34,21 +35,24 @@ BarEnvironment::SetUp() called.
 | 
			
		||||
[0;32m[----------] [m2 tests from NonfatalFailureTest
 | 
			
		||||
[0;32m[ RUN      ] [mNonfatalFailureTest.EscapesStringOperands
 | 
			
		||||
gtest_output_test_.cc:#: Failure
 | 
			
		||||
      Expected: kGoldenString
 | 
			
		||||
      Which is: "\"Line"
 | 
			
		||||
To be equal to: actual
 | 
			
		||||
      Which is: "actual \"string\""
 | 
			
		||||
Expected equality of these values:
 | 
			
		||||
  kGoldenString
 | 
			
		||||
    Which is: "\"Line"
 | 
			
		||||
  actual
 | 
			
		||||
    Which is: "actual \"string\""
 | 
			
		||||
gtest_output_test_.cc:#: Failure
 | 
			
		||||
      Expected: golden
 | 
			
		||||
      Which is: "\"Line"
 | 
			
		||||
To be equal to: actual
 | 
			
		||||
      Which is: "actual \"string\""
 | 
			
		||||
Expected equality of these values:
 | 
			
		||||
  golden
 | 
			
		||||
    Which is: "\"Line"
 | 
			
		||||
  actual
 | 
			
		||||
    Which is: "actual \"string\""
 | 
			
		||||
[0;31m[  FAILED  ] [mNonfatalFailureTest.EscapesStringOperands
 | 
			
		||||
[0;32m[ RUN      ] [mNonfatalFailureTest.DiffForLongStrings
 | 
			
		||||
gtest_output_test_.cc:#: Failure
 | 
			
		||||
      Expected: golden_str
 | 
			
		||||
      Which is: "\"Line\0 1\"\nLine 2"
 | 
			
		||||
To be equal to: "Line 2"
 | 
			
		||||
Expected equality of these values:
 | 
			
		||||
  golden_str
 | 
			
		||||
    Which is: "\"Line\0 1\"\nLine 2"
 | 
			
		||||
  "Line 2"
 | 
			
		||||
With diff:
 | 
			
		||||
@@ -1,2 @@
 | 
			
		||||
-\"Line\0 1\"
 | 
			
		||||
@ -59,16 +63,18 @@ With diff:
 | 
			
		||||
[0;32m[ RUN      ] [mFatalFailureTest.FatalFailureInSubroutine
 | 
			
		||||
(expecting a failure that x should be 1)
 | 
			
		||||
gtest_output_test_.cc:#: Failure
 | 
			
		||||
      Expected: 1
 | 
			
		||||
To be equal to: x
 | 
			
		||||
      Which is: 2
 | 
			
		||||
Expected equality of these values:
 | 
			
		||||
  1
 | 
			
		||||
  x
 | 
			
		||||
    Which is: 2
 | 
			
		||||
[0;31m[  FAILED  ] [mFatalFailureTest.FatalFailureInSubroutine
 | 
			
		||||
[0;32m[ RUN      ] [mFatalFailureTest.FatalFailureInNestedSubroutine
 | 
			
		||||
(expecting a failure that x should be 1)
 | 
			
		||||
gtest_output_test_.cc:#: Failure
 | 
			
		||||
      Expected: 1
 | 
			
		||||
To be equal to: x
 | 
			
		||||
      Which is: 2
 | 
			
		||||
Expected equality of these values:
 | 
			
		||||
  1
 | 
			
		||||
  x
 | 
			
		||||
    Which is: 2
 | 
			
		||||
[0;31m[  FAILED  ] [mFatalFailureTest.FatalFailureInNestedSubroutine
 | 
			
		||||
[0;32m[ RUN      ] [mFatalFailureTest.NonfatalFailureInSubroutine
 | 
			
		||||
(expecting a failure on false)
 | 
			
		||||
@ -107,39 +113,44 @@ This failure is expected, and shouldn't have a trace.
 | 
			
		||||
[0;32m[ RUN      ] [mSCOPED_TRACETest.WorksInLoop
 | 
			
		||||
(expected to fail)
 | 
			
		||||
gtest_output_test_.cc:#: Failure
 | 
			
		||||
      Expected: 2
 | 
			
		||||
To be equal to: n
 | 
			
		||||
      Which is: 1
 | 
			
		||||
Expected equality of these values:
 | 
			
		||||
  2
 | 
			
		||||
  n
 | 
			
		||||
    Which is: 1
 | 
			
		||||
Google Test trace:
 | 
			
		||||
gtest_output_test_.cc:#: i = 1
 | 
			
		||||
gtest_output_test_.cc:#: Failure
 | 
			
		||||
      Expected: 1
 | 
			
		||||
To be equal to: n
 | 
			
		||||
      Which is: 2
 | 
			
		||||
Expected equality of these values:
 | 
			
		||||
  1
 | 
			
		||||
  n
 | 
			
		||||
    Which is: 2
 | 
			
		||||
Google Test trace:
 | 
			
		||||
gtest_output_test_.cc:#: i = 2
 | 
			
		||||
[0;31m[  FAILED  ] [mSCOPED_TRACETest.WorksInLoop
 | 
			
		||||
[0;32m[ RUN      ] [mSCOPED_TRACETest.WorksInSubroutine
 | 
			
		||||
(expected to fail)
 | 
			
		||||
gtest_output_test_.cc:#: Failure
 | 
			
		||||
      Expected: 2
 | 
			
		||||
To be equal to: n
 | 
			
		||||
      Which is: 1
 | 
			
		||||
Expected equality of these values:
 | 
			
		||||
  2
 | 
			
		||||
  n
 | 
			
		||||
    Which is: 1
 | 
			
		||||
Google Test trace:
 | 
			
		||||
gtest_output_test_.cc:#: n = 1
 | 
			
		||||
gtest_output_test_.cc:#: Failure
 | 
			
		||||
      Expected: 1
 | 
			
		||||
To be equal to: n
 | 
			
		||||
      Which is: 2
 | 
			
		||||
Expected equality of these values:
 | 
			
		||||
  1
 | 
			
		||||
  n
 | 
			
		||||
    Which is: 2
 | 
			
		||||
Google Test trace:
 | 
			
		||||
gtest_output_test_.cc:#: n = 2
 | 
			
		||||
[0;31m[  FAILED  ] [mSCOPED_TRACETest.WorksInSubroutine
 | 
			
		||||
[0;32m[ RUN      ] [mSCOPED_TRACETest.CanBeNested
 | 
			
		||||
(expected to fail)
 | 
			
		||||
gtest_output_test_.cc:#: Failure
 | 
			
		||||
      Expected: 1
 | 
			
		||||
To be equal to: n
 | 
			
		||||
      Which is: 2
 | 
			
		||||
Expected equality of these values:
 | 
			
		||||
  1
 | 
			
		||||
  n
 | 
			
		||||
    Which is: 2
 | 
			
		||||
Google Test trace:
 | 
			
		||||
gtest_output_test_.cc:#: n = 2
 | 
			
		||||
gtest_output_test_.cc:#: 
 | 
			
		||||
@ -437,9 +448,10 @@ Expected: 1 fatal failure
 | 
			
		||||
[0;32m[       OK ] [mTypedTest/0.Success
 | 
			
		||||
[0;32m[ RUN      ] [mTypedTest/0.Failure
 | 
			
		||||
gtest_output_test_.cc:#: Failure
 | 
			
		||||
      Expected: 1
 | 
			
		||||
To be equal to: TypeParam()
 | 
			
		||||
      Which is: 0
 | 
			
		||||
Expected equality of these values:
 | 
			
		||||
  1
 | 
			
		||||
  TypeParam()
 | 
			
		||||
    Which is: 0
 | 
			
		||||
Expected failure
 | 
			
		||||
[0;31m[  FAILED  ] [mTypedTest/0.Failure, where TypeParam = int
 | 
			
		||||
[0;32m[----------] [m2 tests from Unsigned/TypedTestP/0, where TypeParam = unsigned char
 | 
			
		||||
@ -447,10 +459,11 @@ Expected failure
 | 
			
		||||
[0;32m[       OK ] [mUnsigned/TypedTestP/0.Success
 | 
			
		||||
[0;32m[ RUN      ] [mUnsigned/TypedTestP/0.Failure
 | 
			
		||||
gtest_output_test_.cc:#: Failure
 | 
			
		||||
      Expected: 1U
 | 
			
		||||
      Which is: 1
 | 
			
		||||
To be equal to: TypeParam()
 | 
			
		||||
      Which is: '\0'
 | 
			
		||||
Expected equality of these values:
 | 
			
		||||
  1U
 | 
			
		||||
    Which is: 1
 | 
			
		||||
  TypeParam()
 | 
			
		||||
    Which is: '\0'
 | 
			
		||||
Expected failure
 | 
			
		||||
[0;31m[  FAILED  ] [mUnsigned/TypedTestP/0.Failure, where TypeParam = unsigned char
 | 
			
		||||
[0;32m[----------] [m2 tests from Unsigned/TypedTestP/1, where TypeParam = unsigned int
 | 
			
		||||
@ -458,10 +471,11 @@ Expected failure
 | 
			
		||||
[0;32m[       OK ] [mUnsigned/TypedTestP/1.Success
 | 
			
		||||
[0;32m[ RUN      ] [mUnsigned/TypedTestP/1.Failure
 | 
			
		||||
gtest_output_test_.cc:#: Failure
 | 
			
		||||
      Expected: 1U
 | 
			
		||||
      Which is: 1
 | 
			
		||||
To be equal to: TypeParam()
 | 
			
		||||
      Which is: 0
 | 
			
		||||
Expected equality of these values:
 | 
			
		||||
  1U
 | 
			
		||||
    Which is: 1
 | 
			
		||||
  TypeParam()
 | 
			
		||||
    Which is: 0
 | 
			
		||||
Expected failure
 | 
			
		||||
[0;31m[  FAILED  ] [mUnsigned/TypedTestP/1.Failure, where TypeParam = unsigned int
 | 
			
		||||
[0;32m[----------] [m4 tests from ExpectFailureTest
 | 
			
		||||
@ -597,18 +611,20 @@ Expected non-fatal failure.
 | 
			
		||||
[0;32m[----------] [m1 test from PrintingFailingParams/FailingParamTest
 | 
			
		||||
[0;32m[ RUN      ] [mPrintingFailingParams/FailingParamTest.Fails/0
 | 
			
		||||
gtest_output_test_.cc:#: Failure
 | 
			
		||||
      Expected: 1
 | 
			
		||||
To be equal to: GetParam()
 | 
			
		||||
      Which is: 2
 | 
			
		||||
Expected equality of these values:
 | 
			
		||||
  1
 | 
			
		||||
  GetParam()
 | 
			
		||||
    Which is: 2
 | 
			
		||||
[0;31m[  FAILED  ] [mPrintingFailingParams/FailingParamTest.Fails/0, where GetParam() = 2
 | 
			
		||||
[0;32m[----------] [m2 tests from PrintingStrings/ParamTest
 | 
			
		||||
[0;32m[ RUN      ] [mPrintingStrings/ParamTest.Success/a
 | 
			
		||||
[0;32m[       OK ] [mPrintingStrings/ParamTest.Success/a
 | 
			
		||||
[0;32m[ RUN      ] [mPrintingStrings/ParamTest.Failure/a
 | 
			
		||||
gtest_output_test_.cc:#: Failure
 | 
			
		||||
      Expected: "b"
 | 
			
		||||
To be equal to: GetParam()
 | 
			
		||||
      Which is: "a"
 | 
			
		||||
Expected equality of these values:
 | 
			
		||||
  "b"
 | 
			
		||||
  GetParam()
 | 
			
		||||
    Which is: "a"
 | 
			
		||||
Expected failure
 | 
			
		||||
[0;31m[  FAILED  ] [mPrintingStrings/ParamTest.Failure/a, where GetParam() = "a"
 | 
			
		||||
[0;32m[----------] [mGlobal test environment tear-down
 | 
			
		||||
@ -678,16 +694,18 @@ Expected fatal failure.
 | 
			
		||||
[ RUN      ] FatalFailureTest.FatalFailureInSubroutine
 | 
			
		||||
(expecting a failure that x should be 1)
 | 
			
		||||
gtest_output_test_.cc:#: Failure
 | 
			
		||||
      Expected: 1
 | 
			
		||||
To be equal to: x
 | 
			
		||||
      Which is: 2
 | 
			
		||||
Expected equality of these values:
 | 
			
		||||
  1
 | 
			
		||||
  x
 | 
			
		||||
    Which is: 2
 | 
			
		||||
[  FAILED  ] FatalFailureTest.FatalFailureInSubroutine (? ms)
 | 
			
		||||
[ RUN      ] FatalFailureTest.FatalFailureInNestedSubroutine
 | 
			
		||||
(expecting a failure that x should be 1)
 | 
			
		||||
gtest_output_test_.cc:#: Failure
 | 
			
		||||
      Expected: 1
 | 
			
		||||
To be equal to: x
 | 
			
		||||
      Which is: 2
 | 
			
		||||
Expected equality of these values:
 | 
			
		||||
  1
 | 
			
		||||
  x
 | 
			
		||||
    Which is: 2
 | 
			
		||||
[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine (? ms)
 | 
			
		||||
[ RUN      ] FatalFailureTest.NonfatalFailureInSubroutine
 | 
			
		||||
(expecting a failure on false)
 | 
			
		||||
 | 
			
		||||
@ -2429,8 +2429,9 @@ TEST(StringAssertionTest, ASSERT_STREQ) {
 | 
			
		||||
  const char p2[] = "good";
 | 
			
		||||
  ASSERT_STREQ(p1, p2);
 | 
			
		||||
 | 
			
		||||
  EXPECT_FATAL_FAILURE(ASSERT_STREQ("bad", "good"),
 | 
			
		||||
                       "Expected: \"bad\"");
 | 
			
		||||
  EXPECT_FATAL_FAILURE(
 | 
			
		||||
      ASSERT_STREQ("bad", "good"),
 | 
			
		||||
      "Expected equality of these values:\n  \"bad\"\n  \"good\"");
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
// Tests ASSERT_STREQ with NULL arguments.
 | 
			
		||||
@ -3528,35 +3529,39 @@ TEST(AssertionTest, EqFailure) {
 | 
			
		||||
      EqFailure("foo", "bar", foo_val, bar_val, false)
 | 
			
		||||
      .failure_message());
 | 
			
		||||
  EXPECT_STREQ(
 | 
			
		||||
      "      Expected: foo\n"
 | 
			
		||||
      "      Which is: 5\n"
 | 
			
		||||
      "To be equal to: bar\n"
 | 
			
		||||
      "      Which is: 6",
 | 
			
		||||
      "Expected equality of these values:\n"
 | 
			
		||||
      "  foo\n"
 | 
			
		||||
      "    Which is: 5\n"
 | 
			
		||||
      "  bar\n"
 | 
			
		||||
      "    Which is: 6",
 | 
			
		||||
      msg1.c_str());
 | 
			
		||||
 | 
			
		||||
  const std::string msg2(
 | 
			
		||||
      EqFailure("foo", "6", foo_val, bar_val, false)
 | 
			
		||||
      .failure_message());
 | 
			
		||||
  EXPECT_STREQ(
 | 
			
		||||
      "      Expected: foo\n"
 | 
			
		||||
      "      Which is: 5\n"
 | 
			
		||||
      "To be equal to: 6",
 | 
			
		||||
      "Expected equality of these values:\n"
 | 
			
		||||
      "  foo\n"
 | 
			
		||||
      "    Which is: 5\n"
 | 
			
		||||
      "  6",
 | 
			
		||||
      msg2.c_str());
 | 
			
		||||
 | 
			
		||||
  const std::string msg3(
 | 
			
		||||
      EqFailure("5", "bar", foo_val, bar_val, false)
 | 
			
		||||
      .failure_message());
 | 
			
		||||
  EXPECT_STREQ(
 | 
			
		||||
      "      Expected: 5\n"
 | 
			
		||||
      "To be equal to: bar\n"
 | 
			
		||||
      "      Which is: 6",
 | 
			
		||||
      "Expected equality of these values:\n"
 | 
			
		||||
      "  5\n"
 | 
			
		||||
      "  bar\n"
 | 
			
		||||
      "    Which is: 6",
 | 
			
		||||
      msg3.c_str());
 | 
			
		||||
 | 
			
		||||
  const std::string msg4(
 | 
			
		||||
      EqFailure("5", "6", foo_val, bar_val, false).failure_message());
 | 
			
		||||
  EXPECT_STREQ(
 | 
			
		||||
      "      Expected: 5\n"
 | 
			
		||||
      "To be equal to: 6",
 | 
			
		||||
      "Expected equality of these values:\n"
 | 
			
		||||
      "  5\n"
 | 
			
		||||
      "  6",
 | 
			
		||||
      msg4.c_str());
 | 
			
		||||
 | 
			
		||||
  const std::string msg5(
 | 
			
		||||
@ -3564,10 +3569,11 @@ TEST(AssertionTest, EqFailure) {
 | 
			
		||||
                std::string("\"x\""), std::string("\"y\""),
 | 
			
		||||
                true).failure_message());
 | 
			
		||||
  EXPECT_STREQ(
 | 
			
		||||
      "      Expected: foo\n"
 | 
			
		||||
      "      Which is: \"x\"\n"
 | 
			
		||||
      "To be equal to: bar\n"
 | 
			
		||||
      "      Which is: \"y\"\n"
 | 
			
		||||
      "Expected equality of these values:\n"
 | 
			
		||||
      "  foo\n"
 | 
			
		||||
      "    Which is: \"x\"\n"
 | 
			
		||||
      "  bar\n"
 | 
			
		||||
      "    Which is: \"y\"\n"
 | 
			
		||||
      "Ignoring case",
 | 
			
		||||
      msg5.c_str());
 | 
			
		||||
}
 | 
			
		||||
@ -3580,11 +3586,12 @@ TEST(AssertionTest, EqFailureWithDiff) {
 | 
			
		||||
  const std::string msg1(
 | 
			
		||||
      EqFailure("left", "right", left, right, false).failure_message());
 | 
			
		||||
  EXPECT_STREQ(
 | 
			
		||||
      "      Expected: left\n"
 | 
			
		||||
      "      Which is: "
 | 
			
		||||
      "Expected equality of these values:\n"
 | 
			
		||||
      "  left\n"
 | 
			
		||||
      "    Which is: "
 | 
			
		||||
      "1\\n2XXX\\n3\\n5\\n6\\n7\\n8\\n9\\n10\\n11\\n12XXX\\n13\\n14\\n15\n"
 | 
			
		||||
      "To be equal to: right\n"
 | 
			
		||||
      "      Which is: 1\\n2\\n3\\n4\\n5\\n6\\n7\\n8\\n9\\n11\\n12\\n13\\n14\n"
 | 
			
		||||
      "  right\n"
 | 
			
		||||
      "    Which is: 1\\n2\\n3\\n4\\n5\\n6\\n7\\n8\\n9\\n11\\n12\\n13\\n14\n"
 | 
			
		||||
      "With diff:\n@@ -1,5 +1,6 @@\n 1\n-2XXX\n+2\n 3\n+4\n 5\n 6\n"
 | 
			
		||||
      "@@ -7,8 +8,6 @@\n 8\n 9\n-10\n 11\n-12XXX\n+12\n 13\n 14\n-15\n",
 | 
			
		||||
      msg1.c_str());
 | 
			
		||||
@ -3679,9 +3686,10 @@ TEST(ExpectTest, ASSERT_EQ_Double) {
 | 
			
		||||
TEST(AssertionTest, ASSERT_EQ) {
 | 
			
		||||
  ASSERT_EQ(5, 2 + 3);
 | 
			
		||||
  EXPECT_FATAL_FAILURE(ASSERT_EQ(5, 2*3),
 | 
			
		||||
                       "      Expected: 5\n"
 | 
			
		||||
                       "To be equal to: 2*3\n"
 | 
			
		||||
                       "      Which is: 6");
 | 
			
		||||
                       "Expected equality of these values:\n"
 | 
			
		||||
                       "  5\n"
 | 
			
		||||
                       "  2*3\n"
 | 
			
		||||
                       "    Which is: 6");
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
// Tests ASSERT_EQ(NULL, pointer).
 | 
			
		||||
@ -3698,7 +3706,7 @@ TEST(AssertionTest, ASSERT_EQ_NULL) {
 | 
			
		||||
  // A failure.
 | 
			
		||||
  static int n = 0;
 | 
			
		||||
  EXPECT_FATAL_FAILURE(ASSERT_EQ(NULL, &n),
 | 
			
		||||
                       "To be equal to: &n\n");
 | 
			
		||||
                       "  &n\n    Which is:");
 | 
			
		||||
}
 | 
			
		||||
#endif  // GTEST_CAN_COMPARE_NULL
 | 
			
		||||
 | 
			
		||||
@ -3714,7 +3722,7 @@ TEST(ExpectTest, ASSERT_EQ_0) {
 | 
			
		||||
 | 
			
		||||
  // A failure.
 | 
			
		||||
  EXPECT_FATAL_FAILURE(ASSERT_EQ(0, 5.6),
 | 
			
		||||
                       "Expected: 0");
 | 
			
		||||
                       "  0\n  5.6");
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
// Tests ASSERT_NE.
 | 
			
		||||
@ -3813,7 +3821,7 @@ void TestEq1(int x) {
 | 
			
		||||
// Tests calling a test subroutine that's not part of a fixture.
 | 
			
		||||
TEST(AssertionTest, NonFixtureSubroutine) {
 | 
			
		||||
  EXPECT_FATAL_FAILURE(TestEq1(2),
 | 
			
		||||
                       "To be equal to: x");
 | 
			
		||||
                       "Which is: 2");
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
// An uncopyable class.
 | 
			
		||||
@ -3862,7 +3870,8 @@ TEST(AssertionTest, AssertWorksWithUncopyableObject) {
 | 
			
		||||
  EXPECT_FATAL_FAILURE(TestAssertNonPositive(),
 | 
			
		||||
    "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
 | 
			
		||||
  EXPECT_FATAL_FAILURE(TestAssertEqualsUncopyable(),
 | 
			
		||||
    "Expected: x\n      Which is: 5\nTo be equal to: y\n      Which is: -1");
 | 
			
		||||
                       "Expected equality of these values:\n"
 | 
			
		||||
                       "  x\n    Which is: 5\n  y\n    Which is: -1");
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
// Tests that uncopyable objects can be used in expects.
 | 
			
		||||
@ -3874,7 +3883,8 @@ TEST(AssertionTest, ExpectWorksWithUncopyableObject) {
 | 
			
		||||
    "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
 | 
			
		||||
  EXPECT_EQ(x, x);
 | 
			
		||||
  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y),
 | 
			
		||||
    "Expected: x\n      Which is: 5\nTo be equal to: y\n      Which is: -1");
 | 
			
		||||
                          "Expected equality of these values:\n"
 | 
			
		||||
                          "  x\n    Which is: 5\n  y\n    Which is: -1");
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
enum NamedEnum {
 | 
			
		||||
@ -3950,7 +3960,7 @@ TEST(AssertionTest, AnonymousEnum) {
 | 
			
		||||
 | 
			
		||||
  // ICE's in C++Builder.
 | 
			
		||||
  EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseB),
 | 
			
		||||
                       "To be equal to: kCaseB");
 | 
			
		||||
                       "kCaseB");
 | 
			
		||||
  EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),
 | 
			
		||||
                       "Which is: 42");
 | 
			
		||||
# endif
 | 
			
		||||
@ -4390,9 +4400,10 @@ TEST(ExpectTest, ExpectFalseWithAssertionResult) {
 | 
			
		||||
TEST(ExpectTest, EXPECT_EQ) {
 | 
			
		||||
  EXPECT_EQ(5, 2 + 3);
 | 
			
		||||
  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2*3),
 | 
			
		||||
                          "      Expected: 5\n"
 | 
			
		||||
                          "To be equal to: 2*3\n"
 | 
			
		||||
                          "      Which is: 6");
 | 
			
		||||
                          "Expected equality of these values:\n"
 | 
			
		||||
                          "  5\n"
 | 
			
		||||
                          "  2*3\n"
 | 
			
		||||
                          "    Which is: 6");
 | 
			
		||||
  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2 - 3),
 | 
			
		||||
                          "2 - 3");
 | 
			
		||||
}
 | 
			
		||||
@ -4423,7 +4434,7 @@ TEST(ExpectTest, EXPECT_EQ_NULL) {
 | 
			
		||||
  // A failure.
 | 
			
		||||
  int n = 0;
 | 
			
		||||
  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(NULL, &n),
 | 
			
		||||
                          "To be equal to: &n\n");
 | 
			
		||||
                          "&n\n");
 | 
			
		||||
}
 | 
			
		||||
#endif  // GTEST_CAN_COMPARE_NULL
 | 
			
		||||
 | 
			
		||||
@ -4439,7 +4450,7 @@ TEST(ExpectTest, EXPECT_EQ_0) {
 | 
			
		||||
 | 
			
		||||
  // A failure.
 | 
			
		||||
  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(0, 5.6),
 | 
			
		||||
                          "Expected: 0");
 | 
			
		||||
                          "Expected equality of these values:\n  0\n  5.6");
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
// Tests EXPECT_NE.
 | 
			
		||||
@ -4539,7 +4550,7 @@ TEST(ExpectTest, EXPECT_ANY_THROW) {
 | 
			
		||||
TEST(ExpectTest, ExpectPrecedence) {
 | 
			
		||||
  EXPECT_EQ(1 < 2, true);
 | 
			
		||||
  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(true, true && false),
 | 
			
		||||
                          "To be equal to: true && false");
 | 
			
		||||
                          "true && false");
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@ -4686,7 +4697,7 @@ TEST(EqAssertionTest, Bool) {
 | 
			
		||||
  EXPECT_FATAL_FAILURE({
 | 
			
		||||
      bool false_value = false;
 | 
			
		||||
      ASSERT_EQ(false_value, true);
 | 
			
		||||
    }, "To be equal to: true");
 | 
			
		||||
    }, "Which is: false");
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
// Tests using int values in {EXPECT|ASSERT}_EQ.
 | 
			
		||||
@ -4720,10 +4731,11 @@ TEST(EqAssertionTest, WideChar) {
 | 
			
		||||
  EXPECT_EQ(L'b', L'b');
 | 
			
		||||
 | 
			
		||||
  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'\0', L'x'),
 | 
			
		||||
                          "      Expected: L'\0'\n"
 | 
			
		||||
                          "      Which is: L'\0' (0, 0x0)\n"
 | 
			
		||||
                          "To be equal to: L'x'\n"
 | 
			
		||||
                          "      Which is: L'x' (120, 0x78)");
 | 
			
		||||
                          "Expected equality of these values:\n"
 | 
			
		||||
                          "  L'\0'\n"
 | 
			
		||||
                          "    Which is: L'\0' (0, 0x0)\n"
 | 
			
		||||
                          "  L'x'\n"
 | 
			
		||||
                          "    Which is: L'x' (120, 0x78)");
 | 
			
		||||
 | 
			
		||||
  static wchar_t wchar;
 | 
			
		||||
  wchar = L'b';
 | 
			
		||||
@ -4731,7 +4743,7 @@ TEST(EqAssertionTest, WideChar) {
 | 
			
		||||
                          "wchar");
 | 
			
		||||
  wchar = 0x8119;
 | 
			
		||||
  EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<wchar_t>(0x8120), wchar),
 | 
			
		||||
                       "To be equal to: wchar");
 | 
			
		||||
                       "wchar");
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
// Tests using ::std::string values in {EXPECT|ASSERT}_EQ.
 | 
			
		||||
@ -4760,8 +4772,8 @@ TEST(EqAssertionTest, StdString) {
 | 
			
		||||
  static ::std::string str3(str1);
 | 
			
		||||
  str3.at(2) = '\0';
 | 
			
		||||
  EXPECT_FATAL_FAILURE(ASSERT_EQ(str1, str3),
 | 
			
		||||
                       "To be equal to: str3\n"
 | 
			
		||||
                       "      Which is: \"A \\0 in the middle\"");
 | 
			
		||||
                       "  str3\n"
 | 
			
		||||
                       "    Which is: \"A \\0 in the middle\"");
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
#if GTEST_HAS_STD_WSTRING
 | 
			
		||||
@ -4881,7 +4893,7 @@ TEST(EqAssertionTest, CharPointer) {
 | 
			
		||||
  ASSERT_EQ(p1, p1);
 | 
			
		||||
 | 
			
		||||
  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
 | 
			
		||||
                          "To be equal to: p2");
 | 
			
		||||
                          "p2");
 | 
			
		||||
  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
 | 
			
		||||
                          "p2");
 | 
			
		||||
  EXPECT_FATAL_FAILURE(ASSERT_EQ(reinterpret_cast<char*>(0x1234),
 | 
			
		||||
@ -4903,7 +4915,7 @@ TEST(EqAssertionTest, WideCharPointer) {
 | 
			
		||||
  EXPECT_EQ(p0, p0);
 | 
			
		||||
 | 
			
		||||
  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
 | 
			
		||||
                          "To be equal to: p2");
 | 
			
		||||
                          "p2");
 | 
			
		||||
  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
 | 
			
		||||
                          "p2");
 | 
			
		||||
  void* pv3 = (void*)0x1234;  // NOLINT
 | 
			
		||||
 | 
			
		||||
@ -64,20 +64,23 @@ EXPECTED_NON_EMPTY_XML = """<?xml version="1.0" encoding="UTF-8"?>
 | 
			
		||||
  </testsuite>
 | 
			
		||||
  <testsuite name="FailedTest" tests="1" failures="1" disabled="0" errors="0" time="*">
 | 
			
		||||
    <testcase name="Fails" status="run" time="*" classname="FailedTest">
 | 
			
		||||
      <failure message="gtest_xml_output_unittest_.cc:*
      Expected: 1
To be equal to: 2" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
 | 
			
		||||
      Expected: 1
 | 
			
		||||
To be equal to: 2%(stack)s]]></failure>
 | 
			
		||||
      <failure message="gtest_xml_output_unittest_.cc:*
Expected equality of these values:
  1
  2" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
 | 
			
		||||
Expected equality of these values:
 | 
			
		||||
  1
 | 
			
		||||
  2%(stack)s]]></failure>
 | 
			
		||||
    </testcase>
 | 
			
		||||
  </testsuite>
 | 
			
		||||
  <testsuite name="MixedResultTest" tests="3" failures="1" disabled="1" errors="0" time="*">
 | 
			
		||||
    <testcase name="Succeeds" status="run" time="*" classname="MixedResultTest"/>
 | 
			
		||||
    <testcase name="Fails" status="run" time="*" classname="MixedResultTest">
 | 
			
		||||
      <failure message="gtest_xml_output_unittest_.cc:*
      Expected: 1
To be equal to: 2" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
 | 
			
		||||
      Expected: 1
 | 
			
		||||
To be equal to: 2%(stack)s]]></failure>
 | 
			
		||||
      <failure message="gtest_xml_output_unittest_.cc:*
      Expected: 2
To be equal to: 3" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
 | 
			
		||||
      Expected: 2
 | 
			
		||||
To be equal to: 3%(stack)s]]></failure>
 | 
			
		||||
      <failure message="gtest_xml_output_unittest_.cc:*
Expected equality of these values:
  1
  2" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
 | 
			
		||||
Expected equality of these values:
 | 
			
		||||
  1
 | 
			
		||||
  2%(stack)s]]></failure>
 | 
			
		||||
      <failure message="gtest_xml_output_unittest_.cc:*
Expected equality of these values:
  2
  3" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
 | 
			
		||||
Expected equality of these values:
 | 
			
		||||
  2
 | 
			
		||||
  3%(stack)s]]></failure>
 | 
			
		||||
    </testcase>
 | 
			
		||||
    <testcase name="DISABLED_test" status="notrun" time="*" classname="MixedResultTest"/>
 | 
			
		||||
  </testsuite>
 | 
			
		||||
 | 
			
		||||
		Loading…
	
	
			
			x
			
			
		
	
		Reference in New Issue
	
	Block a user