Merge pull request #1338 from stefanosoffia/master

CMakeLists.txt

@@ -12,39 +12,12 @@ enable_testing()
 include(CMakeDependentOption)
 include(GNUInstallDirs)
 
-option(BUILD_GTEST "Builds the googletest subproject" OFF)
-
 #Note that googlemock target already builds googletest
 option(BUILD_GMOCK "Builds the googlemock subproject" ON)
+option(INSTALL_GTEST "Enable installation of googletest. (Projects embedding googletest may want to turn this OFF.)" ON)
 
-cmake_dependent_option(INSTALL_GTEST "Enable installation of googletest. (Projects embedding googletest may want to turn this OFF.)" ON "BUILD_GTEST OR BUILD_GMOCK" OFF)
-cmake_dependent_option(INSTALL_GMOCK "Enable installation of googlemock. (Projects embedding googlemock may want to turn this OFF.)" ON "BUILD_GMOCK" OFF)
-
-if(WIN32)
-  set(INSTALL_CMAKE_DIR "cmake" CACHE PATH "CMake exported targets")
-else()
-  set(INSTALL_CMAKE_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/gtest" CACHE PATH "CMake exported targets")
-endif()
-
-set(googletest_install_targets)
 if(BUILD_GMOCK)
   add_subdirectory( googlemock )
-elseif(BUILD_GTEST)
+else()
   add_subdirectory( googletest )
 endif()
-
-if(googletest_install_targets)
-  include(CMakePackageConfigHelpers)
-  configure_package_config_file(
-    "${CMAKE_CURRENT_LIST_DIR}/cmake/googletestConfig.cmake.in"
-    "${CMAKE_CURRENT_BINARY_DIR}/googletestConfig.cmake"
-    INSTALL_DESTINATION "${INSTALL_CMAKE_DIR}")
-  write_basic_package_version_file(
-    ${CMAKE_CURRENT_BINARY_DIR}/googletestConfigVersion.cmake
-    VERSION "${GOOGLETEST_VERSION}"
-    COMPATIBILITY SameMajorVersion)
-  install(FILES
-    ${CMAKE_CURRENT_BINARY_DIR}/googletestConfig.cmake
-    ${CMAKE_CURRENT_BINARY_DIR}/googletestConfigVersion.cmake
-    DESTINATION "${INSTALL_CMAKE_DIR}")
-endif()

cmake/googletestConfig.cmake.in

-@PACKAGE_INIT@
-
-set(googletest_BUILD_SHARED_LIBS @BUILD_SHARED_LIBS@)
-
-set(googletest_NAMESPACE_TARGETS)
-set(googletest_ALL_INCLUDE_DIRS)
-
-foreach(target @googletest_install_targets@)
-  include(${CMAKE_CURRENT_LIST_DIR}/${target}ConfigInternal.cmake)
-
-  add_library(googletest::${target} INTERFACE IMPORTED)
-  set_target_properties(googletest::${target}
-    PROPERTIES
-      INTERFACE_LINK_LIBRARIES googletest_${target}
-      IMPORTED_GLOBAL ON)
-  if(googletest_BUILD_SHARED_LIBS)
-    set_target_properties(googletest::${target}
-      PROPERTIES
-        INTERFACE_COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1")
-  endif()
-  add_library(${target} ALIAS googletest::${target})
-
-  get_target_property(${target}_INCLUDE_DIRS googletest_${target} INTERFACE_INCLUDE_DIRECTORIES)
-
-  list(APPEND googletest_ALL_INCLUDE_DIRS ${${target}_INCLUDE_DIRS})
-  list(APPEND googletest_NAMESPACE_TARGETS googletest::${target})
-endforeach()
-
-list(REMOVE_DUPLICATES googletest_ALL_INCLUDE_DIRS)
-set(GOOGLETEST_INCLUDE_DIRS ${googletest_ALL_INCLUDE_DIRS})
-
-list(REMOVE_DUPLICATES googletest_NAMESPACE_TARGETS)
-set(GOOGLETEST_LIBRARIES ${googletest_NAMESPACE_TARGETS})
-
-set(GOOGLETEST_VERSION "@GOOGLETEST_VERSION@")

googlemock/CMakeLists.txt

@@ -54,15 +54,11 @@ add_subdirectory("${gtest_dir}" "${gmock_BINARY_DIR}/gtest")
 
 # These commands only run if this is the main project
 if(CMAKE_PROJECT_NAME STREQUAL "gmock" OR CMAKE_PROJECT_NAME STREQUAL "googletest-distribution")
-
   # BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to
   # make it prominent in the GUI.
   option(BUILD_SHARED_LIBS "Build shared libraries (DLLs)." OFF)
-
 else()
-
   mark_as_advanced(gmock_build_tests)
-
 endif()
 
 # Although Google Test's CMakeLists.txt calls this function, the
@@ -71,12 +67,13 @@ endif()
 config_compiler_and_linker()  # from ${gtest_dir}/cmake/internal_utils.cmake
 
 # Adds Google Mock's and Google Test's header directories to the search path.
-include_directories("${gmock_SOURCE_DIR}/include"
-                    "${gmock_SOURCE_DIR}"
-                    "${gtest_SOURCE_DIR}/include"
-                    # This directory is needed to build directly from Google
-                    # Test sources.
-                    "${gtest_SOURCE_DIR}")
+set(gmock_build_include_dirs
+  "${gmock_SOURCE_DIR}/include"
+  "${gmock_SOURCE_DIR}"
+  "${gtest_SOURCE_DIR}/include"
+  # This directory is needed to build directly from Google Test sources.
+  "${gtest_SOURCE_DIR}")
+include_directories(${gmock_build_include_dirs})
 
 # Summary of tuple support for Microsoft Visual Studio:
 # Compiler    version(MS)  version(cmake)  Support
@@ -111,69 +108,26 @@ if (MSVC)
               src/gmock_main.cc)
 else()
   cxx_library(gmock "${cxx_strict}" src/gmock-all.cc)
-  target_link_libraries(gmock gtest)
+  target_link_libraries(gmock PUBLIC gtest)
   cxx_library(gmock_main "${cxx_strict}" src/gmock_main.cc)
-  target_link_libraries(gmock_main gmock)
+  target_link_libraries(gmock_main PUBLIC gmock)
 endif()
-
 # If the CMake version supports it, attach header directory information
 # to the targets for when we are part of a parent build (ie being pulled
 # in via add_subdirectory() rather than being a standalone build).
 if (DEFINED CMAKE_VERSION AND NOT "${CMAKE_VERSION}" VERSION_LESS "2.8.11")
-  target_include_directories(gmock SYSTEM
-    INTERFACE
-      $<BUILD_INTERFACE:${gmock_SOURCE_DIR}/include>
-      $<BUILD_INTERFACE:${gmock_SOURCE_DIR}>
-      $<BUILD_INTERFACE:${gtest_SOURCE_DIR}/include>
-      $<BUILD_INTERFACE:${gtest_SOURCE_DIR}>
-      $<INSTALL_INTERFACE:include>)
-  target_include_directories(gmock_main SYSTEM
-    INTERFACE
-      $<BUILD_INTERFACE:${gmock_SOURCE_DIR}/include>
-      $<BUILD_INTERFACE:${gmock_SOURCE_DIR}>
-      $<BUILD_INTERFACE:${gtest_SOURCE_DIR}/include>
-      $<BUILD_INTERFACE:${gtest_SOURCE_DIR}>
-      $<INSTALL_INTERFACE:include>)
+  target_include_directories(gmock SYSTEM INTERFACE
+    "$<BUILD_INTERFACE:${gmock_build_include_dirs}>"
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
+  target_include_directories(gmock_main SYSTEM INTERFACE
+    "$<BUILD_INTERFACE:${gmock_build_include_dirs}>"
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
 endif()
 
 ########################################################################
 #
 # Install rules
-if(INSTALL_GMOCK)
-  install(TARGETS gmock
-    EXPORT gmockConfigInternal
-    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
-    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
-    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}")
-  install(EXPORT gmockConfigInternal
-    DESTINATION "${INSTALL_CMAKE_DIR}"
-    NAMESPACE googletest_)
-  install(TARGETS gmock_main
-    EXPORT gmock_mainConfigInternal
-    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
-    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
-    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}")
-  install(EXPORT gmock_mainConfigInternal
-    DESTINATION "${INSTALL_CMAKE_DIR}"
-    NAMESPACE googletest_)
-  set(googletest_install_targets
-    ${googletest_install_targets} gmock gmock_main PARENT_SCOPE)
-
-  install(DIRECTORY "${gmock_SOURCE_DIR}/include/gmock"
-    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
-
-  # configure and install pkgconfig files
-  configure_file(
-    cmake/gmock.pc.in
-    "${gmock_BINARY_DIR}/gmock.pc"
-    @ONLY)
-  configure_file(
-    cmake/gmock_main.pc.in
-    "${gmock_BINARY_DIR}/gmock_main.pc"
-    @ONLY)
-  install(FILES "${gmock_BINARY_DIR}/gmock.pc" "${gmock_BINARY_DIR}/gmock_main.pc"
-    DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
-endif()
+install_project(gmock gmock_main)
 
 ########################################################################
 #
@@ -240,13 +194,13 @@ if (gmock_build_tests)
     endif()
   else()
     cxx_library(gmock_main_no_exception "${cxx_no_exception}" src/gmock_main.cc)
-    target_link_libraries(gmock_main_no_exception gmock)
+    target_link_libraries(gmock_main_no_exception PUBLIC gmock)
 
     cxx_library(gmock_main_no_rtti "${cxx_no_rtti}" src/gmock_main.cc)
-    target_link_libraries(gmock_main_no_rtti gmock)
+    target_link_libraries(gmock_main_no_rtti PUBLIC gmock)
 
     cxx_library(gmock_main_use_own_tuple "${cxx_use_own_tuple}" src/gmock_main.cc)
-    target_link_libraries(gmock_main_use_own_tuple gmock)
+    target_link_libraries(gmock_main_use_own_tuple PUBLIC gmock)
   endif()
   cxx_test_with_flags(gmock-more-actions_no_exception_test "${cxx_no_exception}"
     gmock_main_no_exception test/gmock-more-actions_test.cc)

googletest/CMakeLists.txt

@@ -85,10 +85,30 @@ include(cmake/internal_utils.cmake)
 
 config_compiler_and_linker()  # Defined in internal_utils.cmake.
 
+# Create the CMake package file descriptors.
+if (INSTALL_GTEST)
+  include(CMakePackageConfigHelpers)
+  set(cmake_package_name GTest)
+  set(targets_export_name ${cmake_package_name}Targets CACHE INTERNAL "")
+  set(generated_dir "${CMAKE_CURRENT_BINARY_DIR}/generated" CACHE INTERNAL "")
+  set(cmake_files_install_dir "${CMAKE_INSTALL_LIBDIR}/cmake/${cmake_package_name}")
+  set(version_file "${generated_dir}/${cmake_package_name}ConfigVersion.cmake")
+  write_basic_package_version_file(${version_file} COMPATIBILITY AnyNewerVersion)
+  install(EXPORT ${targets_export_name}
+    NAMESPACE ${cmake_package_name}::
+    DESTINATION ${cmake_files_install_dir})
+  set(config_file "${generated_dir}/${cmake_package_name}Config.cmake")
+  configure_package_config_file("${gtest_SOURCE_DIR}/cmake/Config.cmake.in"
+    "${config_file}" INSTALL_DESTINATION ${cmake_files_install_dir})
+  install(FILES ${version_file} ${config_file}
+    DESTINATION ${cmake_files_install_dir})
+endif()
+
 # Where Google Test's .h files can be found.
-include_directories(
+set(gtest_build_include_dirs
   "${gtest_SOURCE_DIR}/include"
   "${gtest_SOURCE_DIR}")
+include_directories(${gtest_build_include_dirs})
 
 # Summary of tuple support for Microsoft Visual Studio:
 # Compiler    version(MS)  version(cmake)  Support
@@ -112,62 +132,23 @@ endif()
 # aggressive about warnings.
 cxx_library(gtest "${cxx_strict}" src/gtest-all.cc)
 cxx_library(gtest_main "${cxx_strict}" src/gtest_main.cc)
-target_link_libraries(gtest_main gtest)
-
 # If the CMake version supports it, attach header directory information
 # to the targets for when we are part of a parent build (ie being pulled
 # in via add_subdirectory() rather than being a standalone build).
 if (DEFINED CMAKE_VERSION AND NOT "${CMAKE_VERSION}" VERSION_LESS "2.8.11")
-  target_include_directories(gtest SYSTEM
-    INTERFACE
-      $<BUILD_INTERFACE:${gtest_SOURCE_DIR}/include>
-      $<BUILD_INTERFACE:${gtest_SOURCE_DIR}>
-      $<INSTALL_INTERFACE:include>)
-  target_include_directories(gtest_main SYSTEM
-    INTERFACE
-      $<BUILD_INTERFACE:${gtest_SOURCE_DIR}/include>
-      $<BUILD_INTERFACE:${gtest_SOURCE_DIR}>
-      $<INSTALL_INTERFACE:include>)
+  target_include_directories(gtest SYSTEM INTERFACE
+    "$<BUILD_INTERFACE:${gtest_build_include_dirs}>"
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
+  target_include_directories(gtest_main SYSTEM INTERFACE
+    "$<BUILD_INTERFACE:${gtest_build_include_dirs}>"
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
 endif()
+target_link_libraries(gtest_main PUBLIC gtest)
 
 ########################################################################
 #
 # Install rules
-if(INSTALL_GTEST)
-  install(TARGETS gtest
-    EXPORT gtestConfigInternal
-    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
-    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
-    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}")
-  install(EXPORT gtestConfigInternal
-    DESTINATION "${INSTALL_CMAKE_DIR}"
-    NAMESPACE googletest_)
-  install(TARGETS gtest_main
-    EXPORT gtest_mainConfigInternal
-    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
-    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
-    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}")
-  install(EXPORT gtest_mainConfigInternal
-    DESTINATION "${INSTALL_CMAKE_DIR}"
-    NAMESPACE googletest_)
-  set(googletest_install_targets
-    ${googletest_install_targets} gtest gtest_main PARENT_SCOPE)
-
-  install(DIRECTORY "${gtest_SOURCE_DIR}/include/gtest"
-    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
-
-  # configure and install pkgconfig files
-  configure_file(
-    cmake/gtest.pc.in
-    "${gtest_BINARY_DIR}/gtest.pc"
-    @ONLY)
-  configure_file(
-    cmake/gtest_main.pc.in
-    "${gtest_BINARY_DIR}/gtest_main.pc"
-    @ONLY)
-  install(FILES "${gtest_BINARY_DIR}/gtest.pc" "${gtest_BINARY_DIR}/gtest_main.pc"
-    DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
-endif()
+install_project(gtest gtest_main)
 
 ########################################################################
 #

googletest/cmake/Config.cmake.in

+@PACKAGE_INIT@
+include(CMakeFindDependencyMacro)
+if (@GTEST_HAS_PTHREAD@)
+  set(THREADS_PREFER_PTHREAD_FLAG @THREADS_PREFER_PTHREAD_FLAG@)
+  find_dependency(Threads)
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/@targets_export_name@.cmake")
+check_required_components("@project_name@")

googletest/cmake/internal_utils.cmake

@@ -171,9 +171,18 @@ function(cxx_library_with_type name type cxx_flags)
     set_target_properties(${name}
       PROPERTIES
       COMPILE_DEFINITIONS "GTEST_CREATE_SHARED_LIBRARY=1")
+    if (NOT "${CMAKE_VERSION}" VERSION_LESS "2.8.11")
+      target_compile_definitions(${name} INTERFACE
+        $<INSTALL_INTERFACE:GTEST_LINKED_AS_SHARED_LIBRARY=1>)
+    endif()
   endif()
   if (DEFINED GTEST_HAS_PTHREAD)
-    target_link_libraries(${name} ${CMAKE_THREAD_LIBS_INIT})
+    if ("${CMAKE_VERSION}" VERSION_LESS "3.1.0")
+      set(threads_spec ${CMAKE_THREAD_LIBS_INIT})
+    else()
+      set(threads_spec Threads::Threads)
+    endif()
+    target_link_libraries(${name} PUBLIC ${threads_spec})
   endif()
 endfunction()
 
@@ -283,3 +292,27 @@ function(py_test name)
     endif (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 3.1)
   endif(PYTHONINTERP_FOUND)
 endfunction()
+
+# install_project(targets...)
+#
+# Installs the specified targets and configures the associated pkgconfig files.
+function(install_project)
+  if(INSTALL_GTEST)
+    install(DIRECTORY "${PROJECT_SOURCE_DIR}/include/"
+      DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
+    # Install the project targets.
+    install(TARGETS ${ARGN}
+      EXPORT ${targets_export_name}
+      RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
+      ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+      LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}")
+    # Configure and install pkgconfig files.
+    foreach(t ${ARGN})
+      set(configured_pc "${generated_dir}/${t}.pc")
+      configure_file("${PROJECT_SOURCE_DIR}/cmake/${t}.pc.in"
+        "${configured_pc}" @ONLY)
+      install(FILES "${configured_pc}"
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+    endforeach()
+  endif()
+endfunction()