Update CMake config and tests from the master branch

test/CMakeLists.txt

@@ -1,24 +1,15 @@
-set(FMT_GMOCK_DIR ../gmock)
-
-include_directories(.. ${FMT_GMOCK_DIR})
-
-# Links target with cppformat and any libraries passed as extra arguments.
-function (target_link_cppformat target)
-  target_link_libraries(${target} cppformat ${ARGN})
-  if (BUILD_SHARED_LIBS)
-    set_target_properties(${target} PROPERTIES COMPILE_FLAGS -DFMT_SHARED)
-  endif ()
-endfunction ()
+#------------------------------------------------------------------------------
+# Build the google test library
 
 # We compile Google Test ourselves instead of using pre-compiled libraries.
 # See the Google Test FAQ "Why is it not recommended to install a
 # pre-compiled copy of Google Test (for example, into /usr/local)?"
 # at http://code.google.com/p/googletest/wiki/FAQ for more details.
-
 add_library(gmock STATIC
-  ${FMT_GMOCK_DIR}/gmock-gtest-all.cc ${FMT_GMOCK_DIR}/gmock/gmock.h
-  ${FMT_GMOCK_DIR}/gtest/gtest.h ${FMT_GMOCK_DIR}/gtest/gtest-spi.h)
-target_include_directories(gmock INTERFACE ${FMT_GMOCK_DIR})
+  gmock-gtest-all.cc gmock/gmock.h gtest/gtest.h gtest/gtest-spi.h)
+target_compile_options(gmock PUBLIC ${CPP11_FLAG})
+target_include_directories(gmock PUBLIC .)
+
 find_package(Threads)
 if (Threads_FOUND)
   target_link_libraries(gmock ${CMAKE_THREAD_LIBS_INIT})
@@ -26,20 +17,8 @@ else ()
   target_compile_definitions(gmock PUBLIC GTEST_HAS_PTHREAD=0)
 endif ()
 
-# Check if variadic templates are working and not affected by GCC bug 39653:
-# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=39653
-check_cxx_source_compiles("
-  template <class T, class ...Types>
-  struct S { typedef typename S<Types...>::type type; };
-  int main() {}" FMT_VARIADIC_TEMPLATES)
-
-# Check if initializer lists are supported.
-check_cxx_source_compiles("
-  #include <initializer_list>
-  int main() {}" FMT_INITIALIZER_LIST)
-
-if (NOT FMT_VARIADIC_TEMPLATES OR NOT FMT_INITIALIZER_LIST)
-  add_definitions(-DGTEST_LANG_CXX11=0)
+if (NOT SUPPORTS_VARIADIC_TEMPLATES OR NOT SUPPORTS_INITIALIZER_LIST)
+  target_compile_definitions(gmock PUBLIC GTEST_LANG_CXX11=0)
 endif ()
 
 # Workaround a bug in implementation of variadic templates in MSVC11.
@@ -52,18 +31,39 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
   target_compile_definitions(gmock PUBLIC GTEST_USE_OWN_TR1_TUPLE=1)
 endif ()
 
+#------------------------------------------------------------------------------
+# Build the actual library tests
+
 set(TEST_MAIN_SRC test-main.cc gtest-extra.cc gtest-extra.h util.cc)
 add_library(test-main STATIC ${TEST_MAIN_SRC})
-target_link_cppformat(test-main gmock)
+target_compile_definitions(test-main PUBLIC
+  FMT_USE_FILE_DESCRIPTORS=$<BOOL:${HAVE_OPEN}>)
+target_link_libraries(test-main gmock cppformat)
+
+# Workaround GTest bug https://github.com/google/googletest/issues/705.
+check_cxx_compiler_flag(
+  -fno-delete-null-pointer-checks HAVE_FNO_DELETE_NULL_POINTER_CHECKS)
+if (HAVE_FNO_DELETE_NULL_POINTER_CHECKS)
+  target_compile_options(test-main PUBLIC -fno-delete-null-pointer-checks)
+endif ()
+
+# relax pedantic flags for the tests
+# TODO: fix warnings in tests to make this redundant. (e.g. -Wshadow,...)
+if (CMAKE_COMPILER_IS_GNUCXX OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+  set(PEDANTIC_COMPILE_FLAGS -Wall -Wextra -pedantic -Wno-long-long -Wno-variadic-macros)
+endif ()
 
 # Adds a test.
-# Usage: add_fmt_test(name [CUSTOM_LINK] srcs...)
+# Usage: add_fmt_test(name srcs...)
 function(add_fmt_test name)
-  cmake_parse_arguments(add_fmt_test CUSTOM_LINK "" "" ${ARGN})
-  add_executable(${name} ${name}.cc ${add_fmt_test_UNPARSED_ARGUMENTS})
+  add_executable(${name} ${name}.cc ${ARGN})
   target_link_libraries(${name} test-main)
-  if (NOT add_fmt_test_CUSTOM_LINK)
-    target_link_cppformat(${name})
+  # define if certain c++ features can be used
+  target_compile_definitions(${name} PRIVATE
+    FMT_USE_TYPE_TRAITS=$<BOOL:${SUPPORTS_TYPE_TRAITS}>
+    FMT_USE_ENUM_BASE=$<BOOL:${SUPPORTS_ENUM_BASE}>)
+  if (FMT_PEDANTIC)
+    target_compile_options(${name} PRIVATE ${PEDANTIC_COMPILE_FLAGS})
   endif ()
   add_test(NAME ${name} COMMAND ${name})
 endfunction()
@@ -71,56 +71,22 @@ endfunction()
 add_fmt_test(assert-test)
 add_fmt_test(gtest-extra-test)
 add_fmt_test(format-test)
-if (FMT_PEDANTIC AND MSVC)
-  set_target_properties(format-test PROPERTIES COMPILE_FLAGS /W4)
-endif ()
-
-add_fmt_test(format-impl-test CUSTOM_LINK)
+add_fmt_test(format-impl-test)
 add_fmt_test(printf-test)
-foreach (target format-test printf-test)
-  if (FMT_PEDANTIC AND CMAKE_COMPILER_IS_GNUCXX)
-    set_target_properties(${target} PROPERTIES COMPILE_FLAGS
-      "-Wall -Wextra -pedantic -Wno-long-long -Wno-variadic-macros")
-  endif ()
-  if (CPP11_FLAG)
-    set_target_properties(${target} PROPERTIES COMPILE_FLAGS ${CPP11_FLAG})
-  endif ()
-endforeach ()
 add_fmt_test(util-test mock-allocator.h)
-if (CPP11_FLAG)
-  set_target_properties(util-test PROPERTIES COMPILE_FLAGS ${CPP11_FLAG})
+add_fmt_test(macro-test)
+
+# Enable stricter options for one test to make sure that the header is free of
+# warnings.
+# TODO: make all tests warning free and add this flag to PEDANTIC_COMPILE_FLAGS
+if (FMT_PEDANTIC AND MSVC)
+  target_compile_options(format-test PRIVATE /W4)
 endif ()
 
-check_cxx_source_compiles("
-  enum C : char {A};
-  int main() {}"
-  HAVE_ENUM_BASE)
-if (HAVE_ENUM_BASE)
-  set_target_properties(util-test
-    PROPERTIES COMPILE_DEFINITIONS "FMT_USE_ENUM_BASE=1")
-endif ()
-
-foreach (src ${FMT_SOURCES})
-  set(FMT_TEST_SOURCES ${FMT_TEST_SOURCES} ../${src})
-endforeach ()
-
-check_cxx_source_compiles("
-  #include <type_traits>
-  class C { void operator=(const C&); };
-  int main() { static_assert(!std::is_copy_assignable<C>::value, \"\"); }"
-  HAVE_TYPE_TRAITS)
-if (HAVE_TYPE_TRAITS)
-  foreach (target format-test util-test)
-    set_target_properties(${target}
-      PROPERTIES COMPILE_DEFINITIONS "FMT_USE_TYPE_TRAITS=1")
-  endforeach ()
-endif ()
-
-add_executable(macro-test macro-test.cc ${FMT_TEST_SOURCES} ${TEST_MAIN_SRC})
-target_link_libraries(macro-test gmock)
-
 if (HAVE_OPEN)
-  add_executable(posix-mock-test posix-mock-test.cc ../format.cc ${TEST_MAIN_SRC})
+  add_executable(posix-mock-test posix-mock-test.cc ../cppformat/format.cc ${TEST_MAIN_SRC})
+  target_include_directories(posix-mock-test PRIVATE ${PROJECT_SOURCE_DIR})
+  target_compile_definitions(posix-mock-test PRIVATE FMT_USE_FILE_DESCRIPTORS=1)
   target_link_libraries(posix-mock-test gmock)
   add_test(NAME posix-mock-test COMMAND posix-mock-test)
   add_fmt_test(posix-test)
@@ -128,28 +94,28 @@ endif ()
 
 add_executable(header-only-test
   header-only-test.cc header-only-test2.cc test-main.cc)
-set_target_properties(header-only-test
-  PROPERTIES COMPILE_DEFINITIONS "FMT_HEADER_ONLY=1")
 target_link_libraries(header-only-test gmock)
+if (TARGET cppformat-header-only)
+  target_link_libraries(header-only-test cppformat-header-only)
+else ()
+  target_include_directories(header-only-test PRIVATE ${PROJECT_SOURCE_DIR})
+  target_compile_definitions(header-only-test PRIVATE FMT_HEADER_ONLY=1)
+endif ()
 
 # Test that the library can be compiled with exceptions disabled.
 check_cxx_compiler_flag(-fno-exceptions HAVE_FNO_EXCEPTIONS_FLAG)
 if (HAVE_FNO_EXCEPTIONS_FLAG)
-  add_library(noexception-test STATIC ../format.cc)
-  set_target_properties(noexception-test
-    PROPERTIES COMPILE_FLAGS -fno-exceptions)
-endif ()
-
-# Test compilation with default flags.
-if (FMT_TEST_DEFAULT_FLAGS)
-  file(GLOB src RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cc *.h)
-  foreach (s ${FMT_SOURCES})
-    set(src ${src} ../${s})
-  endforeach ()
-  add_library(testformat STATIC ${src})
+  add_library(noexception-test ../cppformat/format.cc)
+  target_compile_options(noexception-test PRIVATE -fno-exceptions)
 endif ()
 
 if (FMT_PEDANTIC)
+  # Test that the library compiles without windows.h.
+  if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
+    add_library(no-windows-h-test ../cppformat/format.cc)
+    target_compile_definitions(no-windows-h-test PRIVATE FMT_USE_WINDOWS_H=0)
+  endif ()
+
   add_test(compile-test ${CMAKE_CTEST_COMMAND}
     --build-and-test
     "${CMAKE_CURRENT_SOURCE_DIR}/compile-test"
@@ -157,8 +123,24 @@ if (FMT_PEDANTIC)
     --build-generator ${CMAKE_GENERATOR}
     --build-makeprogram ${CMAKE_MAKE_PROGRAM})
 
-  # Test that the library compiles without windows.h.
-  add_library(no-windows-h-test ../format.cc)
-  set_target_properties(no-windows-h-test
-    PROPERTIES COMPILE_DEFINITIONS "FMT_USE_WINDOWS_H=0")
+  # test if the targets are findable from the build directory
+  add_test(find-package-test ${CMAKE_CTEST_COMMAND}
+    -C ${CMAKE_BUILD_TYPE}
+    --build-and-test
+    "${CMAKE_CURRENT_SOURCE_DIR}/find-package-test"
+    "${CMAKE_CURRENT_BINARY_DIR}/find-package-test"
+    --build-generator ${CMAKE_GENERATOR}
+    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
+    --build-options "-Dcppformat_DIR=${PROJECT_BINARY_DIR}"
+                    "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
+
+  # test if the targets are findable when add_subdirectory is used
+  add_test(add-subdirectory-test ${CMAKE_CTEST_COMMAND}
+    -C ${CMAKE_BUILD_TYPE}
+    --build-and-test
+    "${CMAKE_CURRENT_SOURCE_DIR}/add-subdirectory-test"
+    "${CMAKE_CURRENT_BINARY_DIR}/add-subdirectory-test"
+    --build-generator ${CMAKE_GENERATOR}
+    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
+    --build-options "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
 endif ()

test/add-subdirectory-test/CMakeLists.txt

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 2.8.12)
+
+project(cppformat-test)
+
+add_subdirectory(../.. cppformat)
+
+add_executable(library-test "main.cpp")
+target_link_libraries(library-test cppformat)
+
+if (TARGET cppformat-header-only)
+  add_executable(header-only-test "main.cpp")
+  target_link_libraries(header-only-test cppformat-header-only)
+endif ()

test/add-subdirectory-test/main.cpp

@@ -0,0 +1,8 @@
+#include "cppformat/format.h"
+
+int main(int argc, char** argv)
+{
+  for(int i = 0; i < argc; ++i)
+    fmt::print("{}: {}\n", i, argv[i]);
+  return 0;
+}

test/assert-test.cc

@@ -25,7 +25,7 @@
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "format.h"
+#include "cppformat/format.h"
 #include "gtest/gtest.h"
 
 #if GTEST_HAS_DEATH_TEST

test/compile-test/CMakeLists.txt

@@ -5,23 +5,41 @@ cmake_minimum_required(VERSION 2.8)
 include(CheckCXXSourceCompiles)
 set(CMAKE_REQUIRED_INCLUDES ${CMAKE_CURRENT_SOURCE_DIR}/../..)
 
-function (expect_compile_error code)
-  check_cxx_source_compiles("
-  #include \"format.cc\"
-  #include \"posix.h\"
+function (generate_source result fragment)
+  set(${result} "
+  #define FMT_HEADER_ONLY 1
+  #include \"cppformat/format.h\"
   int main() {
-    ${code}
+    ${fragment}
   }
-  " compiles)
-  set (does_compile ${compiles})
+  " PARENT_SCOPE)
+endfunction ()
+
+function (expect_compile code)
+  generate_source(source "${code}")
+  check_cxx_source_compiles("${source}" compiles)
+  if (NOT compiles)
+    message(FATAL_ERROR "Compile error for: ${code}")
+  endif ()
   # Unset the CMake cache variable compiles. Otherwise the compile test will
   # just use cached information next time it runs.
   unset(compiles CACHE)
-  if (does_compile)
+endfunction ()
+
+function (expect_compile_error code)
+  generate_source(source "${code}")
+  check_cxx_source_compiles("${source}" compiles)
+  if (compiles)
     message(FATAL_ERROR "No compile error for: ${code}")
   endif ()
+  # Unset the CMake cache variable compiles. Otherwise the compile test will
+  # just use cached information next time it runs.
+  unset(compiles CACHE)
 endfunction ()
 
+# check if the source file skeleton compiles
+expect_compile("")
+
 # MakeArg doesn't accept [const] volatile char *.
 expect_compile_error("volatile char s[] = \"test\"; (fmt::internal::MakeArg<char>)(s);")
 expect_compile_error("const volatile char s[] = \"test\"; (fmt::internal::MakeArg<char>)(s);")

test/find-package-test/CMakeLists.txt

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 2.8.12)
+
+project(cppformat-test)
+
+find_package(cppformat REQUIRED)
+
+add_executable(library-test "main.cpp")
+target_link_libraries(library-test cppformat)
+
+if (TARGET cppformat-header-only)
+  add_executable(header-only-test "main.cpp")
+  target_link_libraries(header-only-test cppformat-header-only)
+endif ()

test/find-package-test/main.cpp

@@ -0,0 +1,8 @@
+#include "cppformat/format.h"
+
+int main(int argc, char** argv)
+{
+  for(int i = 0; i < argc; ++i)
+    fmt::print("{}: {}\n", i, argv[i]);
+  return 0;
+}

test/format-impl-test.cc

@@ -29,7 +29,7 @@
 #include "test-assert.h"
 
 // Include format.cc instead of format.h to test implementation-specific stuff.
-#include "format.cc"
+#include "cppformat/format.cc"
 
 #include <cstring>
 

test/format-test.cc

@@ -45,7 +45,7 @@
 // Test that the library compiles if None is defined to 0 as done by xlib.h.
 #define None 0
 
-#include "format.h"
+#include "cppformat/format.h"
 #include "util.h"
 #include "mock-allocator.h"
 #include "gtest-extra.h"

test/gtest-extra.h

@@ -31,14 +31,14 @@
 #include <string>
 #include <gtest/gtest.h>
 
-#include "format.h"
+#include "cppformat/format.h"
 
 #ifndef FMT_USE_FILE_DESCRIPTORS
 # define FMT_USE_FILE_DESCRIPTORS 0
 #endif
 
 #if FMT_USE_FILE_DESCRIPTORS
-# include "posix.h"
+# include "cppformat/posix.h"
 #endif
 
 #define FMT_TEST_THROW_(statement, expected_exception, expected_message, fail) \

test/gtest/gtest-spi.h

@@ -0,0 +1,232 @@
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// Utilities for testing Google Test itself and code that uses Google Test
+// (e.g. frameworks built on top of Google Test).
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_SPI_H_
+#define GTEST_INCLUDE_GTEST_GTEST_SPI_H_
+
+#include "gtest/gtest.h"
+
+namespace testing {
+
+// This helper class can be used to mock out Google Test failure reporting
+// so that we can test Google Test or code that builds on Google Test.
+//
+// An object of this class appends a TestPartResult object to the
+// TestPartResultArray object given in the constructor whenever a Google Test
+// failure is reported. It can either intercept only failures that are
+// generated in the same thread that created this object or it can intercept
+// all generated failures. The scope of this mock object can be controlled with
+// the second argument to the two arguments constructor.
+class GTEST_API_ ScopedFakeTestPartResultReporter
+    : public TestPartResultReporterInterface {
+ public:
+  // The two possible mocking modes of this object.
+  enum InterceptMode {
+    INTERCEPT_ONLY_CURRENT_THREAD,  // Intercepts only thread local failures.
+    INTERCEPT_ALL_THREADS           // Intercepts all failures.
+  };
+
+  // The c'tor sets this object as the test part result reporter used
+  // by Google Test.  The 'result' parameter specifies where to report the
+  // results. This reporter will only catch failures generated in the current
+  // thread. DEPRECATED
+  explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result);
+
+  // Same as above, but you can choose the interception scope of this object.
+  ScopedFakeTestPartResultReporter(InterceptMode intercept_mode,
+                                   TestPartResultArray* result);
+
+  // The d'tor restores the previous test part result reporter.
+  virtual ~ScopedFakeTestPartResultReporter();
+
+  // Appends the TestPartResult object to the TestPartResultArray
+  // received in the constructor.
+  //
+  // This method is from the TestPartResultReporterInterface
+  // interface.
+  virtual void ReportTestPartResult(const TestPartResult& result);
+ private:
+  void Init();
+
+  const InterceptMode intercept_mode_;
+  TestPartResultReporterInterface* old_reporter_;
+  TestPartResultArray* const result_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);
+};
+
+namespace internal {
+
+// A helper class for implementing EXPECT_FATAL_FAILURE() and
+// EXPECT_NONFATAL_FAILURE().  Its destructor verifies that the given
+// TestPartResultArray contains exactly one failure that has the given
+// type and contains the given substring.  If that's not the case, a
+// non-fatal failure will be generated.
+class GTEST_API_ SingleFailureChecker {
+ public:
+  // The constructor remembers the arguments.
+  SingleFailureChecker(const TestPartResultArray* results,
+                       TestPartResult::Type type,
+                       const string& substr);
+  ~SingleFailureChecker();
+ private:
+  const TestPartResultArray* const results_;
+  const TestPartResult::Type type_;
+  const string substr_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);
+};
+
+}  // namespace internal
+
+}  // namespace testing
+
+// A set of macros for testing Google Test assertions or code that's expected
+// to generate Google Test fatal failures.  It verifies that the given
+// statement will cause exactly one fatal Google Test failure with 'substr'
+// being part of the failure message.
+//
+// There are two different versions of this macro. EXPECT_FATAL_FAILURE only
+// affects and considers failures generated in the current thread and
+// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
+//
+// The verification of the assertion is done correctly even when the statement
+// throws an exception or aborts the current function.
+//
+// Known restrictions:
+//   - 'statement' cannot reference local non-static variables or
+//     non-static members of the current object.
+//   - 'statement' cannot return a value.
+//   - You cannot stream a failure message to this macro.
+//
+// Note that even though the implementations of the following two
+// macros are much alike, we cannot refactor them to use a common
+// helper macro, due to some peculiarity in how the preprocessor
+// works.  The AcceptsMacroThatExpandsToUnprotectedComma test in
+// gtest_unittest.cc will fail to compile if we do that.
+#define EXPECT_FATAL_FAILURE(statement, substr) \
+  do { \
+    class GTestExpectFatalFailureHelper {\
+     public:\
+      static void Execute() { statement; }\
+    };\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
+      GTestExpectFatalFailureHelper::Execute();\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
+  do { \
+    class GTestExpectFatalFailureHelper {\
+     public:\
+      static void Execute() { statement; }\
+    };\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ALL_THREADS, &gtest_failures);\
+      GTestExpectFatalFailureHelper::Execute();\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+// A macro for testing Google Test assertions or code that's expected to
+// generate Google Test non-fatal failures.  It asserts that the given
+// statement will cause exactly one non-fatal Google Test failure with 'substr'
+// being part of the failure message.
+//
+// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
+// affects and considers failures generated in the current thread and
+// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
+//
+// 'statement' is allowed to reference local variables and members of
+// the current object.
+//
+// The verification of the assertion is done correctly even when the statement
+// throws an exception or aborts the current function.
+//
+// Known restrictions:
+//   - You cannot stream a failure message to this macro.
+//
+// Note that even though the implementations of the following two
+// macros are much alike, we cannot refactor them to use a common
+// helper macro, due to some peculiarity in how the preprocessor
+// works.  If we do that, the code won't compile when the user gives
+// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that
+// expands to code containing an unprotected comma.  The
+// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc
+// catches that.
+//
+// For the same reason, we have to write
+//   if (::testing::internal::AlwaysTrue()) { statement; }
+// instead of
+//   GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
+// to avoid an MSVC warning on unreachable code.
+#define EXPECT_NONFATAL_FAILURE(statement, substr) \
+  do {\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
+        (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
+      if (::testing::internal::AlwaysTrue()) { statement; }\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
+  do {\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
+        (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
+          &gtest_failures);\
+      if (::testing::internal::AlwaysTrue()) { statement; }\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_SPI_H_

test/header-only-test.cc

@@ -25,4 +25,4 @@
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "format.h"
+#include "cppformat/format.h"

test/header-only-test2.cc

@@ -25,4 +25,4 @@
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "format.h"
+#include "cppformat/format.h"

test/macro-test.cc

@@ -29,7 +29,7 @@
 #include <gtest/gtest.h>
 
 #define FMT_USE_VARIADIC_TEMPLATES 0
-#include "format.h"
+#include "cppformat/format.h"
 
 #define IDENTITY(x) x
 

test/posix-mock-test.cc

@@ -29,7 +29,7 @@
 #define _CRT_SECURE_NO_WARNINGS
 
 #include "posix-mock.h"
-#include "posix.cc"
+#include "cppformat/posix.cc"
 
 #include <errno.h>
 #include <fcntl.h>

test/posix-test.cc

@@ -28,7 +28,7 @@
 #include <cstring>
 
 #include "gtest-extra.h"
-#include "posix.h"
+#include "cppformat/posix.h"
 #include "util.h"
 
 #ifdef fileno

test/printf-test.cc

@@ -29,7 +29,7 @@
 #include <climits>
 #include <cstring>
 
-#include "format.h"
+#include "cppformat/format.h"
 #include "gtest-extra.h"
 #include "util.h"
 

test/util-test.cc

@@ -47,7 +47,7 @@
 # include <windows.h>
 #endif
 
-#include "format.h"
+#include "cppformat/format.h"
 
 #undef max
 

test/util.h

@@ -29,7 +29,7 @@
 #include <cstdio>
 #include <string>
 
-#include "posix.h"
+#include "cppformat/posix.h"
 
 enum {BUFFER_SIZE = 256};