Optional find dependency in installed cmake config. (#7099)

* Find dependency only when xgboost is built as static library.
* Resolve msvc warning.
* Add test for linking shared library.

.github/workflows/main.yml

@@ -87,14 +87,14 @@ jobs:
       run: |
         conda info
         conda list
-    - name: Build and install XGBoost
+    - name: Build and install XGBoost static library
       shell: bash -l {0}
       run: |
         mkdir build
         cd build
         cmake .. -DBUILD_STATIC_LIB=ON -DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX -GNinja
         ninja -v install
-    - name: Build and run C API demo
+    - name: Build and run C API demo with static
       shell: bash -l {0}
       run: |
         cd demo/c-api/
@@ -104,6 +104,26 @@ jobs:
         ninja -v
         cd ..
         ./build/api-demo
+        rm -rf ./build
+        cd ../..
+    - name: Build and install XGBoost shared library
+      shell: bash -l {0}
+      run: |
+        cd build
+        cmake .. -DBUILD_STATIC_LIB=OFF -DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX -GNinja
+        ninja -v install
+    - name: Build and run C API demo with shared
+      shell: bash -l {0}
+      run: |
+        cd demo/c-api/
+        mkdir build
+        cd build
+        cmake .. -GNinja -DCMAKE_PREFIX_PATH=$CONDA_PREFIX
+        ninja -v
+        cd ..
+        ./build/api-demo
+        cd ../../
+        ./tests/ci_build/verify_link.sh ./demo/c-api/build/api-demo
 
   lint:
     runs-on: ubuntu-latest

CMakeLists.txt

@@ -119,7 +119,7 @@ if (USE_SANITIZER)
 endif (USE_SANITIZER)
 
 if (USE_CUDA)
-  SET(USE_OPENMP ON CACHE BOOL "CUDA requires OpenMP" FORCE)
+  set(USE_OPENMP ON CACHE BOOL "CUDA requires OpenMP" FORCE)
   # `export CXX=' is ignored by CMake CUDA.
   set(CMAKE_CUDA_HOST_COMPILER ${CMAKE_CXX_COMPILER})
   message(STATUS "Configured CUDA host compiler: ${CMAKE_CUDA_HOST_COMPILER}")
@@ -150,27 +150,26 @@ if (USE_OPENMP)
   find_package(OpenMP REQUIRED)
 endif (USE_OPENMP)
 
+if (USE_NCCL)
+  find_package(Nccl REQUIRED)
+endif (USE_NCCL)
+
 # dmlc-core
 msvc_use_static_runtime()
 add_subdirectory(${xgboost_SOURCE_DIR}/dmlc-core)
-set_target_properties(dmlc PROPERTIES
+
-  CXX_STANDARD 14
-  CXX_STANDARD_REQUIRED ON
-  POSITION_INDEPENDENT_CODE ON)
 if (MSVC)
-  target_compile_options(dmlc PRIVATE
-                         -D_CRT_SECURE_NO_WARNINGS -D_CRT_SECURE_NO_DEPRECATE)
   if (TARGET dmlc_unit_tests)
     target_compile_options(dmlc_unit_tests PRIVATE
                            -D_CRT_SECURE_NO_WARNINGS -D_CRT_SECURE_NO_DEPRECATE)
   endif (TARGET dmlc_unit_tests)
 endif (MSVC)
-if (ENABLE_ALL_WARNINGS)
-  target_compile_options(dmlc PRIVATE -Wall -Wextra)
-endif (ENABLE_ALL_WARNINGS)
 
 # rabit
 add_subdirectory(rabit)
+if (RABIT_BUILD_MPI)
+  find_package(MPI REQUIRED)
+endif (RABIT_BUILD_MPI)
 
 # core xgboost
 add_subdirectory(${xgboost_SOURCE_DIR}/src)
@@ -181,6 +180,11 @@ if (R_LIB)
   add_subdirectory(${xgboost_SOURCE_DIR}/R-package)
 endif (R_LIB)
 
+# This creates its own shared library `xgboost4j'.
+if (JVM_BINDINGS)
+  add_subdirectory(${xgboost_SOURCE_DIR}/jvm-packages)
+endif (JVM_BINDINGS)
+
 # Plugin
 add_subdirectory(${xgboost_SOURCE_DIR}/plugin)
 
@@ -191,50 +195,37 @@ else (BUILD_STATIC_LIB)
   add_library(xgboost SHARED)
 endif (BUILD_STATIC_LIB)
 target_link_libraries(xgboost PRIVATE objxgboost)
-
-if (USE_CUDA)
-  xgboost_set_cuda_flags(xgboost)
-endif (USE_CUDA)
-
-#-- Hide all C++ symbols
-if (HIDE_CXX_SYMBOLS)
-  foreach(target objxgboost xgboost dmlc)
-    set_target_properties(${target} PROPERTIES C_VISIBILITY_PRESET hidden)
-    set_target_properties(${target} PROPERTIES CXX_VISIBILITY_PRESET hidden)
-    set_target_properties(${target} PROPERTIES CUDA_VISIBILITY_PRESET hidden)
-  endforeach()
-endif (HIDE_CXX_SYMBOLS)
-
 target_include_directories(xgboost
   INTERFACE
   $<INSTALL_INTERFACE:$<INSTALL_PREFIX>/include>
   $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>)
-
-# This creates its own shared library `xgboost4j'.
-if (JVM_BINDINGS)
-  add_subdirectory(${xgboost_SOURCE_DIR}/jvm-packages)
-endif (JVM_BINDINGS)
 #-- End shared library
 
 #-- CLI for xgboost
 add_executable(runxgboost ${xgboost_SOURCE_DIR}/src/cli_main.cc)
 target_link_libraries(runxgboost PRIVATE objxgboost)
-if (USE_NVTX)
-  enable_nvtx(runxgboost)
-endif (USE_NVTX)
-
 target_include_directories(runxgboost
   PRIVATE
   ${xgboost_SOURCE_DIR}/include
   ${xgboost_SOURCE_DIR}/dmlc-core/include
-  ${xgboost_SOURCE_DIR}/rabit/include)
+  ${xgboost_SOURCE_DIR}/rabit/include
-set_target_properties(
+)
-  runxgboost PROPERTIES
+set_target_properties(runxgboost PROPERTIES OUTPUT_NAME xgboost)
-  OUTPUT_NAME xgboost
-  CXX_STANDARD 14
-  CXX_STANDARD_REQUIRED ON)
 #-- End CLI for xgboost
 
+# Common setup for all targets
+foreach(target xgboost objxgboost dmlc runxgboost)
+  xgboost_target_properties(${target})
+  xgboost_target_link_libraries(${target})
+  xgboost_target_defs(${target})
+endforeach()
+
+if (JVM_BINDINGS)
+  xgboost_target_properties(xgboost4j)
+  xgboost_target_link_libraries(xgboost4j)
+  xgboost_target_defs(xgboost4j)
+endif (JVM_BINDINGS)
+
 set_output_directory(runxgboost ${xgboost_SOURCE_DIR})
 set_output_directory(xgboost ${xgboost_SOURCE_DIR}/lib)
 # Ensure these two targets do not build simultaneously, as they produce outputs with conflicting names
@@ -307,12 +298,18 @@ install(
 if (GOOGLE_TEST)
   enable_testing()
   # Unittests.
+  add_executable(testxgboost)
+  target_link_libraries(testxgboost PRIVATE objxgboost)
+  xgboost_target_properties(testxgboost)
+  xgboost_target_link_libraries(testxgboost)
+  xgboost_target_defs(testxgboost)
+
   add_subdirectory(${xgboost_SOURCE_DIR}/tests/cpp)
+
   add_test(
     NAME TestXGBoostLib
     COMMAND testxgboost
     WORKING_DIRECTORY ${xgboost_BINARY_DIR})
-
   # CLI tests
   configure_file(
     ${xgboost_SOURCE_DIR}/tests/cli/machine.conf.in

R-package/src/Makevars.in

@@ -21,5 +21,5 @@ PKG_CXXFLAGS= @OPENMP_CXXFLAGS@ @ENDIAN_FLAG@ -pthread
 PKG_LIBS = @OPENMP_CXXFLAGS@ @OPENMP_LIB@ @ENDIAN_FLAG@ @BACKTRACE_LIB@ -pthread
 OBJECTS= ./xgboost_R.o ./xgboost_custom.o ./xgboost_assert.o ./init.o \
          $(PKGROOT)/amalgamation/xgboost-all0.o $(PKGROOT)/amalgamation/dmlc-minimum0.o \
-         $(PKGROOT)/rabit/src/engine.o $(PKGROOT)/rabit/src/c_api.o \
+         $(PKGROOT)/rabit/src/engine.o $(PKGROOT)/rabit/src/rabit_c_api.o \
          $(PKGROOT)/rabit/src/allreduce_base.o

R-package/src/Makevars.win

@@ -33,7 +33,7 @@ PKG_CXXFLAGS= $(SHLIB_OPENMP_CXXFLAGS) $(SHLIB_PTHREAD_FLAGS)
 PKG_LIBS = $(SHLIB_OPENMP_CXXFLAGS) $(SHLIB_PTHREAD_FLAGS)
 OBJECTS= ./xgboost_R.o ./xgboost_custom.o ./xgboost_assert.o ./init.o \
          $(PKGROOT)/amalgamation/xgboost-all0.o $(PKGROOT)/amalgamation/dmlc-minimum0.o \
-         $(PKGROOT)/rabit/src/engine.o $(PKGROOT)/rabit/src/c_api.o \
+         $(PKGROOT)/rabit/src/engine.o $(PKGROOT)/rabit/src/rabit_c_api.o \
          $(PKGROOT)/rabit/src/allreduce_base.o
 
 $(OBJECTS) : xgblib

cmake/Utils.cmake

@@ -130,9 +130,6 @@ endmacro()
 
 # Set CUDA related flags to target.  Must be used after code `format_gencode_flags`.
 function(xgboost_set_cuda_flags target)
-  find_package(OpenMP REQUIRED)
-  target_link_libraries(${target} PUBLIC OpenMP::OpenMP_CXX)
-
   target_compile_options(${target} PRIVATE
     $<$<COMPILE_LANGUAGE:CUDA>:--expt-extended-lambda>
     $<$<COMPILE_LANGUAGE:CUDA>:--expt-relaxed-constexpr>
@@ -156,7 +153,7 @@ function(xgboost_set_cuda_flags target)
   endif (USE_NVTX)
 
   target_compile_definitions(${target} PRIVATE -DXGBOOST_USE_CUDA=1 -DTHRUST_IGNORE_CUB_VERSION_CHECK=1)
-  target_include_directories(${target} PRIVATE ${xgboost_SOURCE_DIR}/cub/)
+  target_include_directories(${target} PRIVATE ${xgboost_SOURCE_DIR}/cub/ ${xgboost_SOURCE_DIR}/gputreeshap)
 
   if (MSVC)
     target_compile_options(${target} PRIVATE
@@ -167,16 +164,111 @@ function(xgboost_set_cuda_flags target)
     CUDA_STANDARD 14
     CUDA_STANDARD_REQUIRED ON
     CUDA_SEPARABLE_COMPILATION OFF)
+endfunction(xgboost_set_cuda_flags)
 
-  if (HIDE_CXX_SYMBOLS)
+macro(xgboost_link_nccl target)
-    target_compile_options(${target} PRIVATE
+  if (BUILD_STATIC_LIB)
-      $<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=-fvisibility=hidden>)
+    target_include_directories(${target} PUBLIC ${NCCL_INCLUDE_DIR})
-  endif (HIDE_CXX_SYMBOLS)
+    target_compile_definitions(${target} PUBLIC -DXGBOOST_USE_NCCL=1)
-
+    target_link_libraries(${target} PUBLIC ${NCCL_LIBRARY})
-  if (USE_NCCL)
+  else ()
-    find_package(Nccl REQUIRED)
     target_include_directories(${target} PRIVATE ${NCCL_INCLUDE_DIR})
     target_compile_definitions(${target} PRIVATE -DXGBOOST_USE_NCCL=1)
-    target_link_libraries(${target} PUBLIC ${NCCL_LIBRARY})
+    target_link_libraries(${target} PRIVATE ${NCCL_LIBRARY})
+  endif (BUILD_STATIC_LIB)
+endmacro(xgboost_link_nccl)
+
+# compile options
+macro(xgboost_target_properties target)
+  set_target_properties(${target} PROPERTIES
+    CXX_STANDARD 14
+    CXX_STANDARD_REQUIRED ON
+    POSITION_INDEPENDENT_CODE ON)
+  if (HIDE_CXX_SYMBOLS)
+    #-- Hide all C++ symbols
+    set_target_properties(${target} PROPERTIES
+      C_VISIBILITY_PRESET hidden
+      CXX_VISIBILITY_PRESET hidden
+      CUDA_VISIBILITY_PRESET hidden
+    )
+  endif (HIDE_CXX_SYMBOLS)
+
+  if (ENABLE_ALL_WARNINGS)
+    target_compile_options(${target} PUBLIC
+      $<IF:$<COMPILE_LANGUAGE:CUDA>,-Xcompiler=-Wall -Xcompiler=-Wextra,-Wall -Wextra>
+    )
+  endif(ENABLE_ALL_WARNINGS)
+
+  target_compile_options(${target}
+    PRIVATE
+    $<$<AND:$<CXX_COMPILER_ID:MSVC>,$<COMPILE_LANGUAGE:CXX>>:/MP>
+    $<$<AND:$<NOT:$<CXX_COMPILER_ID:MSVC>>,$<COMPILE_LANGUAGE:CXX>>:-funroll-loops>)
+
+  if (MSVC)
+    target_compile_options(${target} PRIVATE
+      $<$<NOT:$<COMPILE_LANGUAGE:CUDA>>:/utf-8>
+      -D_CRT_SECURE_NO_WARNINGS
+      -D_CRT_SECURE_NO_DEPRECATE
+      )
+  endif (MSVC)
+
+  if (WIN32 AND MINGW)
+    target_compile_options(${target} PUBLIC -static-libstdc++)
+  endif (WIN32 AND MINGW)
+endmacro(xgboost_target_properties)
+
+# Custom definitions used in xgboost.
+macro(xgboost_target_defs target)
+  if (NOT ${target} STREQUAL "dmlc") # skip dmlc core for custom logging.
+    target_compile_definitions(${target}
+      PRIVATE
+      -DDMLC_LOG_CUSTOMIZE=1
+      $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:_MWAITXINTRIN_H_INCLUDED>)
+  endif ()
+  if (USE_DEBUG_OUTPUT)
+    target_compile_definitions(${target} PRIVATE -DXGBOOST_USE_DEBUG_OUTPUT=1)
+  endif (USE_DEBUG_OUTPUT)
+  if (XGBOOST_MM_PREFETCH_PRESENT)
+    target_compile_definitions(${target}
+      PRIVATE
+      -DXGBOOST_MM_PREFETCH_PRESENT=1)
+  endif(XGBOOST_MM_PREFETCH_PRESENT)
+  if (XGBOOST_BUILTIN_PREFETCH_PRESENT)
+    target_compile_definitions(${target}
+      PRIVATE
+      -DXGBOOST_BUILTIN_PREFETCH_PRESENT=1)
+  endif (XGBOOST_BUILTIN_PREFETCH_PRESENT)
+endmacro(xgboost_target_defs)
+
+# handles dependencies
+macro(xgboost_target_link_libraries target)
+  if (BUILD_STATIC_LIB)
+    target_link_libraries(${target} PUBLIC Threads::Threads ${CMAKE_THREAD_LIBS_INIT})
+  else()
+    target_link_libraries(${target} PRIVATE Threads::Threads ${CMAKE_THREAD_LIBS_INIT})
+  endif (BUILD_STATIC_LIB)
+
+  if (USE_OPENMP)
+    if (BUILD_STATIC_LIB)
+      target_link_libraries(${target} PUBLIC OpenMP::OpenMP_CXX)
+    else()
+      target_link_libraries(${target} PRIVATE OpenMP::OpenMP_CXX)
+    endif (BUILD_STATIC_LIB)
+  endif (USE_OPENMP)
+
+  if (USE_CUDA)
+    xgboost_set_cuda_flags(${target})
+  endif (USE_CUDA)
+
+  if (USE_NCCL)
+    xgboost_link_nccl(${target})
   endif (USE_NCCL)
-endfunction(xgboost_set_cuda_flags)
+
+  if (USE_NVTX)
+    enable_nvtx(${target})
+  endif (USE_NVTX)
+
+  if (RABIT_BUILD_MPI)
+    target_link_libraries(${target} PRIVATE MPI::MPI_CXX)
+  endif (RABIT_BUILD_MPI)
+endmacro(xgboost_target_link_libraries)

cmake/xgboost-config.cmake.in

@@ -1,21 +1,22 @@
 @PACKAGE_INIT@
 
-include(CMakeFindDependencyMacro)
-
 set(USE_OPENMP @USE_OPENMP@)
 set(USE_CUDA @USE_CUDA@)
 set(USE_NCCL @USE_NCCL@)
+set(XGBOOST_BUILD_STATIC_LIB @BUILD_STATIC_LIB@)
 
-find_dependency(Threads)
+include(CMakeFindDependencyMacro)
-if(USE_OPENMP)
+
-  find_dependency(OpenMP)
+if (XGBOOST_BUILD_STATIC_LIB)
-endif()
+  find_dependency(Threads)
-if(USE_CUDA)
+  if(USE_OPENMP)
-  find_dependency(CUDA)
+    find_dependency(OpenMP)
-endif()
+  endif()
-if(USE_NCCL)
+  if(USE_CUDA)
-  find_dependency(Nccl)
+    find_dependency(CUDA)
-endif()
+  endif()
+  # nccl should be linked statically if xgboost is built as static library.
+endif (XGBOOST_BUILD_STATIC_LIB)
 
 if(NOT TARGET xgboost::xgboost)
   include(${CMAKE_CURRENT_LIST_DIR}/XGBoostTargets.cmake)

demo/c-api/CMakeLists.txt

@@ -1,5 +1,14 @@
 cmake_minimum_required(VERSION 3.13)
-project(api-demo LANGUAGES C CXX VERSION 0.0.1)
+project(api-demo LANGUAGES C VERSION 0.0.1)
 find_package(xgboost REQUIRED)
+
+# xgboost is built as static libraries, all cxx dependencies need to be linked into the
+# executable.
+if (XGBOOST_BUILD_STATIC_LIB)
+  enable_language(CXX)
+  # find again for those  cxx libraries.
+  find_package(xgboost REQUIRED)
+endif(XGBOOST_BUILD_STATIC_LIB)
+
 add_executable(api-demo c-api-demo.c)
 target_link_libraries(api-demo PRIVATE xgboost::xgboost)

rabit/CMakeLists.txt

@@ -4,7 +4,7 @@ find_package(Threads REQUIRED)
 
 set(RABIT_SOURCES
   ${CMAKE_CURRENT_LIST_DIR}/src/allreduce_base.cc
-  ${CMAKE_CURRENT_LIST_DIR}/src/c_api.cc)
+  ${CMAKE_CURRENT_LIST_DIR}/src/rabit_c_api.cc)
 
 if (RABIT_BUILD_MPI)
   list(APPEND RABIT_SOURCES ${CMAKE_CURRENT_LIST_DIR}/src/engine_mpi.cc)

src/CMakeLists.txt

@@ -14,8 +14,6 @@ target_sources(objxgboost PRIVATE ${RABIT_SOURCES})
 if (USE_CUDA)
   file(GLOB_RECURSE CUDA_SOURCES *.cu *.cuh)
   target_sources(objxgboost PRIVATE ${CUDA_SOURCES})
-  xgboost_set_cuda_flags(objxgboost)
-  target_link_libraries(objxgboost PRIVATE GPUTreeShap)
 endif (USE_CUDA)
 
 target_include_directories(objxgboost
@@ -23,66 +21,11 @@ target_include_directories(objxgboost
   ${xgboost_SOURCE_DIR}/include
   ${xgboost_SOURCE_DIR}/dmlc-core/include
   ${xgboost_SOURCE_DIR}/rabit/include)
-target_compile_options(objxgboost
-  PRIVATE
-  $<$<AND:$<CXX_COMPILER_ID:MSVC>,$<COMPILE_LANGUAGE:CXX>>:/MP>
-  $<$<AND:$<NOT:$<CXX_COMPILER_ID:MSVC>>,$<COMPILE_LANGUAGE:CXX>>:-funroll-loops>)
-if (WIN32 AND MINGW)
-  target_compile_options(objxgboost PUBLIC -static-libstdc++)
-endif (WIN32 AND MINGW)
 
-if (MSVC)
-  target_compile_options(objxgboost PRIVATE
-    $<$<NOT:$<COMPILE_LANGUAGE:CUDA>>:/utf-8>
-    -D_CRT_SECURE_NO_WARNINGS
-    -D_CRT_SECURE_NO_DEPRECATE
-  )
-endif (MSVC)
-
-if (ENABLE_ALL_WARNINGS)
-  target_compile_options(objxgboost PUBLIC
-    $<IF:$<COMPILE_LANGUAGE:CUDA>,-Xcompiler=-Wall -Xcompiler=-Wextra,-Wall -Wextra>)
-endif (ENABLE_ALL_WARNINGS)
 if (LOG_CAPI_INVOCATION)
-  target_compile_definitions(objxgboost PUBLIC -DLOG_CAPI_INVOCATION=1)
+  target_compile_definitions(objxgboost PRIVATE -DLOG_CAPI_INVOCATION=1)
 endif (LOG_CAPI_INVOCATION)
 
-set_target_properties(objxgboost PROPERTIES
-  POSITION_INDEPENDENT_CODE ON
-  CXX_STANDARD 14
-  CXX_STANDARD_REQUIRED ON)
-target_compile_definitions(objxgboost
-  PRIVATE
-  -DDMLC_LOG_CUSTOMIZE=1  # enable custom logging
-  $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:_MWAITXINTRIN_H_INCLUDED>)
-if (USE_DEBUG_OUTPUT)
-  target_compile_definitions(objxgboost PRIVATE -DXGBOOST_USE_DEBUG_OUTPUT=1)
-endif (USE_DEBUG_OUTPUT)
-
-if (XGBOOST_MM_PREFETCH_PRESENT)
-  target_compile_definitions(objxgboost
-    PRIVATE
-    -DXGBOOST_MM_PREFETCH_PRESENT=1)
-endif(XGBOOST_MM_PREFETCH_PRESENT)
-if (XGBOOST_BUILTIN_PREFETCH_PRESENT)
-  target_compile_definitions(objxgboost
-    PRIVATE
-    -DXGBOOST_BUILTIN_PREFETCH_PRESENT=1)
-endif (XGBOOST_BUILTIN_PREFETCH_PRESENT)
-
-find_package(Threads REQUIRED)
-target_link_libraries(objxgboost PUBLIC Threads::Threads ${CMAKE_THREAD_LIBS_INIT})
-
-if (USE_OPENMP OR USE_CUDA)  # CUDA requires OpenMP
-  find_package(OpenMP REQUIRED)
-  target_link_libraries(objxgboost PUBLIC OpenMP::OpenMP_CXX)
-endif (USE_OPENMP OR USE_CUDA)
-
-if (RABIT_BUILD_MPI)
-  find_package(MPI REQUIRED)
-  target_link_libraries(objxgboost PUBLIC MPI::MPI_CXX)
-endif (RABIT_BUILD_MPI)
-
 # For MSVC: Call msvc_use_static_runtime() once again to completely
 # replace /MD with /MT. See https://github.com/dmlc/xgboost/issues/4462
 # for issues caused by mixing of /MD and /MT flags

tests/ci_build/verify_link.sh

@@ -0,0 +1,18 @@
+# Make sure the dependencies of XGBoost don't appear in directly downstream project.
+# Pass the executable as argument for this script
+
+if readelf -d $1 | grep "omp";
+then
+    echo "Found openmp in direct dependency"
+    exit -1
+else
+    exit 0
+fi
+
+if readelf -d $1 | grep "pthread";
+then
+    echo "Found pthread in direct dependency"
+    exit -1
+else
+    exit 0
+fi

tests/cpp/CMakeLists.txt

@@ -18,28 +18,12 @@ if (NOT PLUGIN_UPDATER_ONEAPI)
   list(REMOVE_ITEM TEST_SOURCES ${ONEAPI_TEST_SOURCES})
 endif (NOT PLUGIN_UPDATER_ONEAPI)
 
-add_executable(testxgboost ${TEST_SOURCES}
+target_sources(testxgboost PRIVATE ${TEST_SOURCES} ${xgboost_SOURCE_DIR}/plugin/example/custom_obj.cc)
-  ${xgboost_SOURCE_DIR}/plugin/example/custom_obj.cc)
-target_link_libraries(testxgboost PRIVATE objxgboost)
-
-if (USE_CUDA)
-  xgboost_set_cuda_flags(testxgboost)
 
+if (USE_CUDA AND PLUGIN_RMM)
   find_package(CUDA)
   target_include_directories(testxgboost PRIVATE ${CUDA_INCLUDE_DIRS})
-endif (USE_CUDA)
+endif (USE_CUDA AND PLUGIN_RMM)
-
-if (MSVC)
-  target_compile_options(testxgboost PRIVATE
-    $<$<NOT:$<COMPILE_LANGUAGE:CUDA>>:/utf-8>
-    -D_CRT_SECURE_NO_WARNINGS
-    -D_CRT_SECURE_NO_DEPRECATE
-  )
-endif (MSVC)
-if (ENABLE_ALL_WARNINGS)
-  target_compile_options(testxgboost PUBLIC
-    $<IF:$<COMPILE_LANGUAGE:CUDA>,-Xcompiler=-Wall -Xcompiler=-Wextra,-Wall -Wextra>)
-endif (ENABLE_ALL_WARNINGS)
 
 target_include_directories(testxgboost
   PRIVATE
@@ -47,10 +31,6 @@ target_include_directories(testxgboost
   ${xgboost_SOURCE_DIR}/include
   ${xgboost_SOURCE_DIR}/dmlc-core/include
   ${xgboost_SOURCE_DIR}/rabit/include)
-set_target_properties(
-  testxgboost PROPERTIES
-  CXX_STANDARD 14
-  CXX_STANDARD_REQUIRED ON)
 target_link_libraries(testxgboost
   PRIVATE
   ${GTEST_LIBRARIES})

tests/cpp/common/test_io.cc

@@ -11,6 +11,15 @@
 
 namespace xgboost {
 namespace common {
+TEST(MemoryFixSizeBuffer, Seek) {
+  size_t constexpr kSize { 64 };
+  std::vector<int32_t> memory( kSize );
+  rabit::utils::MemoryFixSizeBuffer buf(memory.data(), memory.size());
+  buf.Seek(rabit::utils::MemoryFixSizeBuffer::kSeekEnd);
+  size_t end = buf.Tell();
+  ASSERT_EQ(end, kSize);
+}
+
 TEST(IO, FileExtension) {
   std::string filename {u8"model.json"};
   auto ext = FileExtension(filename);

tests/cpp/rabit/test_io.cc

@@ -1,18 +0,0 @@
-/*!
- *  Copyright (c) 2019 by Contributors
- */
-#include <gtest/gtest.h>
-#include <rabit/internal/io.h>
-
-#include <vector>
-
-namespace rabit {
-TEST(MemoryFixSizeBuffer, Seek) {
-  size_t constexpr kSize { 64 };
-  std::vector<int32_t> memory( kSize );
-  utils::MemoryFixSizeBuffer buf(memory.data(), memory.size());
-  buf.Seek(utils::MemoryFixSizeBuffer::kSeekEnd);
-  size_t end = buf.Tell();
-  ASSERT_EQ(end, kSize);
-}
-}  // namespace rabit