Merge branch 'master' into python3-tests

.clang-format

+# Run manually to reformat a file:
+# clang-format -i --style=file <file>
+Language:        Cpp
+BasedOnStyle:  Google

.travis.yml

@@ -18,8 +18,9 @@ matrix:
     - os: linux
       compiler: clang
       sudo : true
+      env: TEST_CLANG_FORMAT="yes"
       install: ./ci/install-linux.sh && ./ci/log-config.sh
-      script: ./ci/build-linux-bazel.sh
+      script: ./ci/test_format.sh && ./ci/build-linux-bazel.sh
     - os: linux
       group: deprecated-2017Q4
       compiler: gcc
@@ -65,6 +66,7 @@ addons:
     packages:
     - g++-4.9
     - clang-3.9
+    - clang-format-3.9
 
 notifications:
   email: false

CONTRIBUTING.md

@@ -79,6 +79,7 @@ itself is a valuable contribution.
 To keep the source consistent, readable, diffable and easy to merge,
 we use a fairly rigid coding style, as defined by the [google-styleguide](https://github.com/google/styleguide) project.  All patches will be expected
 to conform to the style outlined [here](https://google.github.io/styleguide/cppguide.html). 
+Use [.clang-format](https://github.com/google/googletest/blob/master/.clang-format) to check your formatting
 
 ## Requirements for Contributors ###
 

README.md

@@ -107,7 +107,7 @@ package (as described below):
   * GNU-compatible Make or gmake
   * POSIX-standard shell
   * POSIX(-2) Regular Expressions (regex.h)
-  * A C++98-standard-compliant compiler
+  * A C++11-standard-compliant compiler
 
 ### Windows Requirements ###
 

ci/test_format.sh

+#!/bin/bash
+echo "clang-format - checking Code Formatting..."
+
+if [[ "${TRAVIS_OS_NAME}" == "linux" ]] && \
+   [[ "${TEST_CLANG_FORMAT}" == "yes" ]]; then
+
+    RETURN=0
+    CLANG_FORMAT="clang-format-3.9"
+
+    which clang-format-3.9
+
+    if [ ! -f ".clang-format" ]; then
+        echo ".clang-format file not found!"
+        exit 1
+    fi
+
+    FILES=`git diff master --name-only | grep -E "\.(cc|cpp|h)$"`
+
+    for FILE in $FILES; do
+
+        $CLANG_FORMAT $FILE | cmp  $FILE >/dev/null
+
+        if [ $? -ne 0 ]; then
+            echo "[!] Clang-Format Found INCORRECT FORMATTING. Please re-format and re-submit.  The following file failed: $FILE" >&2
+            RETURN=1
+        fi
+
+    done
+
+    exit $RETURN
+fi
+
+exit 0

googletest/include/gtest/internal/gtest-internal.h

@@ -1189,6 +1189,18 @@ class NativeArray {
   GTEST_DISALLOW_ASSIGN_(NativeArray);
 };
 
+class AdditionalMessage {
+ public:
+  AdditionalMessage(const char* message) : msg(message) {}
+  void set(const std::string& message) { msg = message; }
+  operator bool() const { return true; }
+
+  const std::string& get() const { return msg; }
+
+ private:
+  std::string msg;
+};
+
 }  // namespace internal
 }  // namespace testing
 
@@ -1216,43 +1228,58 @@ class NativeArray {
 
 #define GTEST_TEST_THROW_(statement, expected_exception, fail)      \
   GTEST_AMBIGUOUS_ELSE_BLOCKER_                                     \
-  if (::testing::internal::ConstCharPtr gtest_msg = "") { \
+  if (::testing::internal::AdditionalMessage message = "") {        \
     bool gtest_caught_expected = false;                             \
+    try {                                                           \
       try {                                                         \
         GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);  \
-    } \
-    catch (expected_exception const&) { \
+      } catch (expected_exception const&) {                         \
         gtest_caught_expected = true;                               \
+        throw;                                                      \
       }                                                             \
-    catch (...) { \
-      gtest_msg.value = \
-          "Expected: " #statement " throws an exception of type " \
-          #expected_exception ".\n  Actual: it throws a different type."; \
+    } catch (const std::exception& e) {                             \
+      if (!gtest_caught_expected) {                                 \
+        message.set(                                                \
+            "it throws a different type "                           \
+            "with message: " +                                      \
+            std::string(e.what()));                                 \
         goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
       }                                                             \
+    } catch (...) {                                                 \
+      if (!gtest_caught_expected) {                                 \
+        message.set("it throws a different type.");                 \
+        goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
+      }                                                             \
+    }                                                               \
     if (!gtest_caught_expected) {                                   \
-      gtest_msg.value = \
-          "Expected: " #statement " throws an exception of type " \
-          #expected_exception ".\n  Actual: it throws nothing."; \
+      message.set("it throws nothing.");                            \
       goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);   \
     }                                                               \
   } else                                                            \
-    GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__): \
-      fail(gtest_msg.value)
+    GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__)           \
+        : fail(("Expected: " #statement                             \
+                " throws an exception of type " #expected_exception \
+                ".\n  Actual: " +                                   \
+                message.get())                                      \
+                   .c_str())
 
 #define GTEST_TEST_NO_THROW_(statement, fail)                            \
   GTEST_AMBIGUOUS_ELSE_BLOCKER_                                          \
-  if (::testing::internal::AlwaysTrue()) { \
+  if (::testing::internal::AdditionalMessage message = ".") {            \
     try {                                                                \
       GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);         \
-    } \
-    catch (...) { \
+    } catch (const std::exception& e) {                                  \
+      message.set(std::string(": ") + e.what());                         \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__);      \
+    } catch (...) {                                                      \
       goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__);      \
     }                                                                    \
   } else                                                                 \
-    GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \
-      fail("Expected: " #statement " doesn't throw an exception.\n" \
-           "  Actual: it throws.")
+    GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__)              \
+        : fail(("Expected: " #statement " doesn't throw an exception.\n" \
+                "  Actual: it throws" +                                  \
+                message.get())                                           \
+                   .c_str())
 
 #define GTEST_TEST_ANY_THROW_(statement, fail) \
   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \

googletest/test/gtest_unittest.cc

@@ -3328,6 +3328,7 @@ TEST_F(SingleEvaluationTest, OtherCases) {
 void ThrowAnInteger() {
   throw 1;
 }
+void ThrowAnException(const char* what) { throw std::runtime_error(what); }
 
 // Tests that assertion arguments are evaluated exactly once.
 TEST_F(SingleEvaluationTest, ExceptionTests) {
@@ -3370,6 +3371,26 @@ TEST_F(SingleEvaluationTest, ExceptionTests) {
   // failed EXPECT_ANY_THROW
   EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(a_++), "it doesn't");
   EXPECT_EQ(7, a_);
+
+  // failed EXPECT_THROW std::exception, throws different
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(
+                              {  // NOLINT
+                                a_++;
+                                ThrowAnInteger();
+                              },
+                              std::exception),
+                          "throws a different type");
+  EXPECT_EQ(8, a_);
+
+  // failed EXPECT_THROW, throws std::exception
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(
+                              {  // NOLINT
+                                a_++;
+                                ThrowAnException("blablubb");
+                              },
+                              bool),
+                          "throws a different type with message: blablubb");
+  EXPECT_EQ(9, a_);
 }
 
 #endif  // GTEST_HAS_EXCEPTIONS
@@ -3802,6 +3823,11 @@ TEST(AssertionTest, ASSERT_THROW) {
       ASSERT_THROW(ThrowNothing(), bool),
       "Expected: ThrowNothing() throws an exception of type bool.\n"
       "  Actual: it throws nothing.");
+
+  EXPECT_FATAL_FAILURE(
+      ASSERT_THROW(ThrowAnException("b"), bool),
+      "Expected: ThrowAnException(\"b\") throws an exception of type bool.\n"
+      "  Actual: it throws a different type with message: b");
 }
 
 // Tests ASSERT_NO_THROW.
@@ -3810,6 +3836,9 @@ TEST(AssertionTest, ASSERT_NO_THROW) {
   EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()),
                        "Expected: ThrowAnInteger() doesn't throw an exception."
                        "\n  Actual: it throws.");
+  EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnException("blablubb")),
+                       "Expected: ThrowAnException(\"blablubb\") doesn't throw"
+                       " an exception.\n  Actual: it throws: blablubb");
 }
 
 // Tests ASSERT_ANY_THROW.
@@ -4536,13 +4565,17 @@ TEST(ExpectTest, EXPECT_GT) {
 // Tests EXPECT_THROW.
 TEST(ExpectTest, EXPECT_THROW) {
   EXPECT_THROW(ThrowAnInteger(), int);
+  EXPECT_THROW(ThrowAnException(""), std::exception);
   EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool),
                           "Expected: ThrowAnInteger() throws an exception of "
                           "type bool.\n  Actual: it throws a different type.");
-  EXPECT_NONFATAL_FAILURE(
-      EXPECT_THROW(ThrowNothing(), bool),
-      "Expected: ThrowNothing() throws an exception of type bool.\n"
-      "  Actual: it throws nothing.");
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowNothing(), bool),
+                          "Expected: ThrowNothing() throws an exception of "
+                          "type bool.\n  Actual: it throws nothing.");
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnException("buuh"), bool),
+                          "Expected: ThrowAnException(\"buuh\") throws an "
+                          "exception of type bool.\n  Actual: "
+                          "it throws a different type with message: buuh");
 }
 
 // Tests EXPECT_NO_THROW.
@@ -4551,6 +4584,9 @@ TEST(ExpectTest, EXPECT_NO_THROW) {
   EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()),
                           "Expected: ThrowAnInteger() doesn't throw an "
                           "exception.\n  Actual: it throws.");
+  EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnException("blah")),
+                          "Expected: ThrowAnException(\"blah\") doesn't "
+                          "throw an exception.\n  Actual: it throws: blah");
 }
 
 // Tests EXPECT_ANY_THROW.