diff --git a/CMakeLists.txt b/CMakeLists.txt
index d9d2d7cc8..b7ee23d1b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -10,7 +10,7 @@ cmake_policy(SET CMP0063 NEW)
 
 if ((${CMAKE_VERSION} VERSION_GREATER 3.13) OR (${CMAKE_VERSION} VERSION_EQUAL 3.13))
   cmake_policy(SET CMP0077 NEW)
-endif ((${CMAKE_VERSION} VERSION_GREATER 3.13) OR (${CMAKE_VERSION} VERSION_EQUAL 3.13))
+endif()
 
 message(STATUS "CMake version ${CMAKE_VERSION}")
 
@@ -88,80 +88,80 @@ option(ADD_PKGCONFIG "Add xgboost.pc into system." ON)
 #-- Checks for building XGBoost
 if (USE_DEBUG_OUTPUT AND (NOT (CMAKE_BUILD_TYPE MATCHES Debug)))
   message(SEND_ERROR "Do not enable `USE_DEBUG_OUTPUT' with release build.")
-endif (USE_DEBUG_OUTPUT AND (NOT (CMAKE_BUILD_TYPE MATCHES Debug)))
+endif()
 if (USE_NCCL AND NOT (USE_CUDA))
   message(SEND_ERROR "`USE_NCCL` must be enabled with `USE_CUDA` flag.")
-endif (USE_NCCL AND NOT (USE_CUDA))
+endif()
 if (USE_DEVICE_DEBUG AND NOT (USE_CUDA))
   message(SEND_ERROR "`USE_DEVICE_DEBUG` must be enabled with `USE_CUDA` flag.")
-endif (USE_DEVICE_DEBUG AND NOT (USE_CUDA))
+endif()
 if (BUILD_WITH_SHARED_NCCL AND (NOT USE_NCCL))
   message(SEND_ERROR "Build XGBoost with -DUSE_NCCL=ON to enable BUILD_WITH_SHARED_NCCL.")
-endif (BUILD_WITH_SHARED_NCCL AND (NOT USE_NCCL))
+endif()
 if (JVM_BINDINGS AND R_LIB)
   message(SEND_ERROR "`R_LIB' is not compatible with `JVM_BINDINGS' as they both have customized configurations.")
-endif (JVM_BINDINGS AND R_LIB)
+endif()
 if (R_LIB AND GOOGLE_TEST)
   message(WARNING "Some C++ unittests will fail with `R_LIB` enabled,
  as R package redirects some functions to R runtime implementation.")
-endif (R_LIB AND GOOGLE_TEST)
+endif()
 if (PLUGIN_RMM AND NOT (USE_CUDA))
   message(SEND_ERROR "`PLUGIN_RMM` must be enabled with `USE_CUDA` flag.")
-endif (PLUGIN_RMM AND NOT (USE_CUDA))
+endif()
 if (PLUGIN_RMM AND NOT ((CMAKE_CXX_COMPILER_ID STREQUAL "Clang") OR (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")))
   message(SEND_ERROR "`PLUGIN_RMM` must be used with GCC or Clang compiler.")
-endif (PLUGIN_RMM AND NOT ((CMAKE_CXX_COMPILER_ID STREQUAL "Clang") OR (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")))
+endif()
 if (PLUGIN_RMM AND NOT (CMAKE_SYSTEM_NAME STREQUAL "Linux"))
   message(SEND_ERROR "`PLUGIN_RMM` must be used with Linux.")
-endif (PLUGIN_RMM AND NOT (CMAKE_SYSTEM_NAME STREQUAL "Linux"))
+endif()
 if (ENABLE_ALL_WARNINGS)
   if ((NOT CMAKE_CXX_COMPILER_ID MATCHES "Clang") AND (NOT CMAKE_CXX_COMPILER_ID STREQUAL "GNU"))
     message(SEND_ERROR "ENABLE_ALL_WARNINGS is only available for Clang and GCC.")
-  endif ((NOT CMAKE_CXX_COMPILER_ID MATCHES "Clang") AND (NOT CMAKE_CXX_COMPILER_ID STREQUAL "GNU"))
-endif (ENABLE_ALL_WARNINGS)
+  endif()
+endif()
 if (BUILD_STATIC_LIB AND (R_LIB OR JVM_BINDINGS))
   message(SEND_ERROR "Cannot build a static library libxgboost.a when R or JVM packages are enabled.")
-endif (BUILD_STATIC_LIB AND (R_LIB OR JVM_BINDINGS))
+endif()
 if (PLUGIN_FEDERATED)
   if (CMAKE_CROSSCOMPILING)
     message(SEND_ERROR "Cannot cross compile with federated learning support")
-  endif ()
+  endif()
   if (BUILD_STATIC_LIB)
     message(SEND_ERROR "Cannot build static lib with federated learning support")
-  endif ()
+  endif()
   if (R_LIB OR JVM_BINDINGS)
     message(SEND_ERROR "Cannot enable federated learning support when R or JVM packages are enabled.")
-  endif ()
+  endif()
   if (WIN32)
     message(SEND_ERROR "Federated learning not supported for Windows platform")
-  endif ()
-endif ()
+  endif()
+endif()
 
 #-- Removed options
 if (USE_AVX)
   message(SEND_ERROR  "The option `USE_AVX` is deprecated as experimental AVX features have been removed from XGBoost.")
-endif (USE_AVX)
+endif()
 if (PLUGIN_LZ4)
   message(SEND_ERROR  "The option `PLUGIN_LZ4` is removed from XGBoost.")
-endif (PLUGIN_LZ4)
+endif()
 if (RABIT_BUILD_MPI)
   message(SEND_ERROR "The option `RABIT_BUILD_MPI` has been removed from XGBoost.")
-endif (RABIT_BUILD_MPI)
+endif()
 if (USE_S3)
   message(SEND_ERROR "The option `USE_S3` has been removed from XGBoost")
-endif (USE_S3)
+endif()
 if (USE_AZURE)
   message(SEND_ERROR "The option `USE_AZURE` has been removed from XGBoost")
-endif (USE_AZURE)
+endif()
 if (USE_HDFS)
   message(SEND_ERROR "The option `USE_HDFS` has been removed from XGBoost")
-endif (USE_HDFS)
+endif()
 
 #-- Sanitizer
 if (USE_SANITIZER)
   include(cmake/Sanitizer.cmake)
   enable_sanitizers("${ENABLED_SANITIZERS}")
-endif (USE_SANITIZER)
+endif()
 
 if (USE_CUDA)
   set(USE_OPENMP ON CACHE BOOL "CUDA requires OpenMP" FORCE)
@@ -178,7 +178,7 @@ if (USE_CUDA)
   add_subdirectory(${PROJECT_SOURCE_DIR}/gputreeshap)
 
   find_package(CUDAToolkit REQUIRED)
-endif (USE_CUDA)
+endif()
 
 if (FORCE_COLORED_OUTPUT AND (CMAKE_GENERATOR STREQUAL "Ninja") AND
     ((CMAKE_CXX_COMPILER_ID STREQUAL "GNU") OR
@@ -204,11 +204,11 @@ if (USE_OPENMP)
       set(OpenMP_CXX_LIB_NAMES omp)
       set(OpenMP_omp_LIBRARY ${HOMEBREW_LIBOMP_PREFIX}/lib/libomp.dylib)
       find_package(OpenMP REQUIRED)
-    endif ()
+    endif()
   else ()
     find_package(OpenMP REQUIRED)
-  endif ()
-endif (USE_OPENMP)
+  endif()
+endif()
 #Add for IBM i
 if (${CMAKE_SYSTEM_NAME} MATCHES "OS400")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
@@ -217,21 +217,21 @@ endif()
 
 if (USE_NCCL)
   find_package(Nccl REQUIRED)
-endif (USE_NCCL)
+endif()
 
 # dmlc-core
 msvc_use_static_runtime()
 if (FORCE_SHARED_CRT)
   set(DMLC_FORCE_SHARED_CRT ON)
-endif ()
+endif()
 add_subdirectory(${xgboost_SOURCE_DIR}/dmlc-core)
 
 if (MSVC)
   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)
+  endif()
+endif()
 
 # rabit
 add_subdirectory(rabit)
@@ -243,12 +243,12 @@ target_link_libraries(objxgboost PUBLIC dmlc)
 # Exports some R specific definitions and objects
 if (R_LIB)
   add_subdirectory(${xgboost_SOURCE_DIR}/R-package)
-endif (R_LIB)
+endif()
 
 # This creates its own shared library `xgboost4j'.
 if (JVM_BINDINGS)
   add_subdirectory(${xgboost_SOURCE_DIR}/jvm-packages)
-endif (JVM_BINDINGS)
+endif()
 
 # Plugin
 add_subdirectory(${xgboost_SOURCE_DIR}/plugin)
@@ -264,14 +264,14 @@ if (PLUGIN_RMM)
   list(APPEND rmm_link_libs CUDA::cudart_static)
   set_target_properties(rmm::rmm PROPERTIES INTERFACE_LINK_LIBRARIES "${rmm_link_libs}")
   get_target_property(rmm_link_libs rmm::rmm INTERFACE_LINK_LIBRARIES)
-endif (PLUGIN_RMM)
+endif()
 
 #-- library
 if (BUILD_STATIC_LIB)
   add_library(xgboost STATIC)
 else (BUILD_STATIC_LIB)
   add_library(xgboost SHARED)
-endif (BUILD_STATIC_LIB)
+endif()
 target_link_libraries(xgboost PRIVATE objxgboost)
 target_include_directories(xgboost
   INTERFACE
@@ -298,8 +298,8 @@ if (BUILD_DEPRECATED_CLI)
     set_output_directory(runxgboost ${xgboost_BINARY_DIR})
   else ()
     set_output_directory(runxgboost ${xgboost_SOURCE_DIR})
-  endif (KEEP_BUILD_ARTIFACTS_IN_BINARY_DIR)
-endif (BUILD_DEPRECATED_CLI)
+  endif()
+endif()
 #-- End CLI for xgboost
 
 # Common setup for all targets
@@ -313,18 +313,18 @@ if (JVM_BINDINGS)
   xgboost_target_properties(xgboost4j)
   xgboost_target_link_libraries(xgboost4j)
   xgboost_target_defs(xgboost4j)
-endif (JVM_BINDINGS)
+endif()
 
 if (KEEP_BUILD_ARTIFACTS_IN_BINARY_DIR)
   set_output_directory(xgboost ${xgboost_BINARY_DIR}/lib)
 else ()
   set_output_directory(xgboost ${xgboost_SOURCE_DIR}/lib)
-endif ()
+endif()
 
 # Ensure these two targets do not build simultaneously, as they produce outputs with conflicting names
 if (BUILD_DEPRECATED_CLI)
   add_dependencies(xgboost runxgboost)
-endif (BUILD_DEPRECATED_CLI)
+endif()
 
 #-- Installing XGBoost
 if (R_LIB)
@@ -332,18 +332,18 @@ if (R_LIB)
   set_target_properties(xgboost PROPERTIES PREFIX "")
   if (APPLE)
     set_target_properties(xgboost PROPERTIES SUFFIX ".so")
-  endif (APPLE)
+  endif()
   setup_rpackage_install_target(xgboost "${CMAKE_CURRENT_BINARY_DIR}/R-package-install")
   set(CMAKE_INSTALL_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/dummy_inst")
-endif (R_LIB)
+endif()
 if (MINGW)
   set_target_properties(xgboost PROPERTIES PREFIX "")
-endif (MINGW)
+endif()
 
 if (BUILD_C_DOC)
   include(cmake/Doc.cmake)
   run_doxygen()
-endif (BUILD_C_DOC)
+endif()
 
 include(CPack)
 
@@ -364,14 +364,14 @@ if (BUILD_STATIC_LIB)
     set(INSTALL_TARGETS xgboost runxgboost objxgboost dmlc)
   else()
     set(INSTALL_TARGETS xgboost objxgboost dmlc)
-  endif (BUILD_DEPRECATED_CLI)
+  endif()
 else (BUILD_STATIC_LIB)
   if (BUILD_DEPRECATED_CLI)
     set(INSTALL_TARGETS xgboost runxgboost)
   else(BUILD_DEPRECATED_CLI)
     set(INSTALL_TARGETS xgboost)
-  endif (BUILD_DEPRECATED_CLI)
-endif (BUILD_STATIC_LIB)
+  endif()
+endif()
 
 install(TARGETS ${INSTALL_TARGETS}
   EXPORT XGBoostTargets
@@ -428,8 +428,8 @@ if (GOOGLE_TEST)
     set_tests_properties(TestXGBoostCLI
       PROPERTIES
       PASS_REGULAR_EXPRESSION ".*test-rmse:0.087.*")
-  endif (BUILD_DEPRECATED_CLI)
-endif (GOOGLE_TEST)
+  endif()
+endif()
 
 # For MSVC: Call msvc_use_static_runtime() once again to completely
 # replace /MD with /MT. See https://github.com/dmlc/xgboost/issues/4462
@@ -443,4 +443,4 @@ if (ADD_PKGCONFIG)
   install(
     FILES ${xgboost_BINARY_DIR}/xgboost.pc
     DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
-endif (ADD_PKGCONFIG)
+endif()
diff --git a/cmake/Doc.cmake b/cmake/Doc.cmake
index 2ffa005ff..7c3d05c00 100644
--- a/cmake/Doc.cmake
+++ b/cmake/Doc.cmake
@@ -3,7 +3,7 @@ function (run_doxygen)
 
   if (NOT DOXYGEN_DOT_FOUND)
     message(FATAL_ERROR "Command `dot` not found.  Please install graphviz.")
-  endif (NOT DOXYGEN_DOT_FOUND)
+  endif()
 
   configure_file(
     ${xgboost_SOURCE_DIR}/doc/Doxyfile.in
diff --git a/cmake/Sanitizer.cmake b/cmake/Sanitizer.cmake
index 77d7c93c1..919d5c695 100644
--- a/cmake/Sanitizer.cmake
+++ b/cmake/Sanitizer.cmake
@@ -14,7 +14,7 @@ macro(enable_sanitizer sanitizer)
     set(SAN_COMPILE_FLAGS "${SAN_COMPILE_FLAGS} -fsanitize=thread")
     if (TSan_FOUND)
       link_libraries(${TSan_LIBRARY})
-    endif (TSan_FOUND)
+    endif()
 
   elseif(${sanitizer} MATCHES "leak")
     find_package(LSan)
diff --git a/cmake/Utils.cmake b/cmake/Utils.cmake
index f215c3eca..686a545d0 100644
--- a/cmake/Utils.cmake
+++ b/cmake/Utils.cmake
@@ -121,7 +121,7 @@ function(format_gencode_flags flags out)
     set(${out} "${${out}}--generate-code=arch=compute_${ver},code=compute_${ver};")
     set(${out} "${${out}}" PARENT_SCOPE)
     message(STATUS "CUDA GEN_CODE: ${GEN_CODE}")
-  endif (CMAKE_VERSION VERSION_GREATER_EQUAL "3.18")
+  endif()
 endfunction(format_gencode_flags flags)
 
 # Set CUDA related flags to target.  Must be used after code `format_gencode_flags`.
@@ -136,11 +136,11 @@ function(xgboost_set_cuda_flags target)
   if (USE_PER_THREAD_DEFAULT_STREAM)
     target_compile_options(${target} PRIVATE
             $<$<COMPILE_LANGUAGE:CUDA>:--default-stream per-thread>)
-  endif (USE_PER_THREAD_DEFAULT_STREAM)
+  endif()
 
   if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.18")
     set_property(TARGET ${target} PROPERTY CUDA_ARCHITECTURES ${CMAKE_CUDA_ARCHITECTURES})
-  endif (CMAKE_VERSION VERSION_GREATER_EQUAL "3.18")
+  endif()
 
   if (FORCE_COLORED_OUTPUT)
     if (FORCE_COLORED_OUTPUT AND (CMAKE_GENERATOR STREQUAL "Ninja") AND
@@ -149,7 +149,7 @@ function(xgboost_set_cuda_flags target)
       target_compile_options(${target} PRIVATE
         $<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=-fdiagnostics-color=always>)
     endif()
-  endif (FORCE_COLORED_OUTPUT)
+  endif()
 
   if (USE_DEVICE_DEBUG)
     target_compile_options(${target} PRIVATE
@@ -157,11 +157,11 @@ function(xgboost_set_cuda_flags target)
   else (USE_DEVICE_DEBUG)
     target_compile_options(${target} PRIVATE
       $<$<COMPILE_LANGUAGE:CUDA>:-lineinfo>)
-  endif (USE_DEVICE_DEBUG)
+  endif()
 
   if (USE_NVTX)
     target_compile_definitions(${target} PRIVATE -DXGBOOST_USE_NVTX=1)
-  endif (USE_NVTX)
+  endif()
 
   target_compile_definitions(${target} PRIVATE -DXGBOOST_USE_CUDA=1)
   target_include_directories(
@@ -172,7 +172,7 @@ function(xgboost_set_cuda_flags target)
   if (MSVC)
     target_compile_options(${target} PRIVATE
       $<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=/utf-8>)
-  endif (MSVC)
+  endif()
 
   set_target_properties(${target} PROPERTIES
     CUDA_STANDARD 17
@@ -190,7 +190,7 @@ macro(xgboost_link_nccl target)
     target_include_directories(${target} PRIVATE ${NCCL_INCLUDE_DIR})
     target_compile_definitions(${target} PRIVATE -DXGBOOST_USE_NCCL=1)
     target_link_libraries(${target} PRIVATE ${NCCL_LIBRARY})
-  endif (BUILD_STATIC_LIB)
+  endif()
 endmacro(xgboost_link_nccl)
 
 # compile options
@@ -207,7 +207,7 @@ macro(xgboost_target_properties target)
       CXX_VISIBILITY_PRESET hidden
       CUDA_VISIBILITY_PRESET hidden
     )
-  endif (HIDE_CXX_SYMBOLS)
+  endif()
 
   if (ENABLE_ALL_WARNINGS)
     target_compile_options(${target} PUBLIC
@@ -215,7 +215,7 @@ macro(xgboost_target_properties target)
       -Xcompiler=-Wall -Xcompiler=-Wextra -Xcompiler=-Wno-expansion-to-defined,
       -Wall -Wextra -Wno-expansion-to-defined>
     )
-  endif(ENABLE_ALL_WARNINGS)
+  endif()
 
   target_compile_options(${target}
     PRIVATE
@@ -228,11 +228,11 @@ macro(xgboost_target_properties target)
       -D_CRT_SECURE_NO_WARNINGS
       -D_CRT_SECURE_NO_DEPRECATE
     )
-  endif (MSVC)
+  endif()
 
   if (WIN32 AND MINGW)
     target_compile_options(${target} PUBLIC -static-libstdc++)
-  endif (WIN32 AND MINGW)
+  endif()
 endmacro(xgboost_target_properties)
 
 # Custom definitions used in xgboost.
@@ -242,24 +242,24 @@ macro(xgboost_target_defs target)
       PRIVATE
       -DDMLC_LOG_CUSTOMIZE=1
       $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:_MWAITXINTRIN_H_INCLUDED>)
-  endif ()
+  endif()
   if (USE_DEBUG_OUTPUT)
     target_compile_definitions(${target} PRIVATE -DXGBOOST_USE_DEBUG_OUTPUT=1)
-  endif (USE_DEBUG_OUTPUT)
+  endif()
   if (XGBOOST_MM_PREFETCH_PRESENT)
     target_compile_definitions(${target}
       PRIVATE
       -DXGBOOST_MM_PREFETCH_PRESENT=1)
-  endif(XGBOOST_MM_PREFETCH_PRESENT)
+  endif()
   if (XGBOOST_BUILTIN_PREFETCH_PRESENT)
     target_compile_definitions(${target}
       PRIVATE
       -DXGBOOST_BUILTIN_PREFETCH_PRESENT=1)
-  endif (XGBOOST_BUILTIN_PREFETCH_PRESENT)
+  endif()
 
   if (PLUGIN_RMM)
     target_compile_definitions(objxgboost PUBLIC -DXGBOOST_USE_RMM=1)
-  endif (PLUGIN_RMM)
+  endif()
 endmacro(xgboost_target_defs)
 
 # handles dependencies
@@ -268,34 +268,34 @@ macro(xgboost_target_link_libraries target)
     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)
+  endif()
 
   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)
+    endif()
+  endif()
 
   if (USE_CUDA)
     xgboost_set_cuda_flags(${target})
     target_link_libraries(${target} PUBLIC CUDA::cudart_static)
-  endif (USE_CUDA)
+  endif()
 
   if (PLUGIN_RMM)
     target_link_libraries(${target} PRIVATE rmm::rmm)
-  endif (PLUGIN_RMM)
+  endif()
 
   if (USE_NCCL)
     xgboost_link_nccl(${target})
-  endif (USE_NCCL)
+  endif()
 
   if (USE_NVTX)
     target_link_libraries(${target} PRIVATE CUDA::nvToolsExt)
-  endif (USE_NVTX)
+  endif()
 
   if (MINGW)
     target_link_libraries(${target} PRIVATE wsock32 ws2_32)
-  endif (MINGW)
+  endif()
 endmacro(xgboost_target_link_libraries)
diff --git a/cmake/modules/FindNVML.cmake b/cmake/modules/FindNVML.cmake
index a4bed0019..a7061aa29 100644
--- a/cmake/modules/FindNVML.cmake
+++ b/cmake/modules/FindNVML.cmake
@@ -1,6 +1,6 @@
 if (NVML_LIBRARY)
   unset(NVML_LIBRARY CACHE)
-endif(NVML_LIBRARY)
+endif()
 
 set(NVML_LIB_NAME nvml)
 
diff --git a/cmake/modules/FindNccl.cmake b/cmake/modules/FindNccl.cmake
index 5f06f96b8..6fd2ed981 100644
--- a/cmake/modules/FindNccl.cmake
+++ b/cmake/modules/FindNccl.cmake
@@ -39,7 +39,7 @@ if (NCCL_LIBRARY)
   if(NOT USE_NCCL_LIB_PATH)
     # Don't cache NCCL_LIBRARY to enable switching between static and shared.
     unset(NCCL_LIBRARY CACHE)
-  endif(NOT USE_NCCL_LIB_PATH)
+  endif()
 endif()
 
 if (BUILD_WITH_SHARED_NCCL)
@@ -48,7 +48,7 @@ if (BUILD_WITH_SHARED_NCCL)
 else ()
   # libnccl_static.a
   set(NCCL_LIB_NAME nccl_static)
-endif (BUILD_WITH_SHARED_NCCL)
+endif()
 
 find_path(NCCL_INCLUDE_DIR
   NAMES nccl.h
diff --git a/demo/c-api/basic/CMakeLists.txt b/demo/c-api/basic/CMakeLists.txt
index 32e2bc432..f0cc8a744 100644
--- a/demo/c-api/basic/CMakeLists.txt
+++ b/demo/c-api/basic/CMakeLists.txt
@@ -7,7 +7,7 @@ if (XGBOOST_BUILD_STATIC_LIB)
   enable_language(CXX)
   # find again for those  cxx libraries.
   find_package(xgboost REQUIRED)
-endif(XGBOOST_BUILD_STATIC_LIB)
+endif()
 
 add_executable(api-demo c-api-demo.c)
 target_link_libraries(api-demo PRIVATE xgboost::xgboost)
diff --git a/demo/c-api/inference/CMakeLists.txt b/demo/c-api/inference/CMakeLists.txt
index 6aa8f1dd2..70ddb256c 100644
--- a/demo/c-api/inference/CMakeLists.txt
+++ b/demo/c-api/inference/CMakeLists.txt
@@ -8,7 +8,7 @@ if (XGBOOST_BUILD_STATIC_LIB)
   enable_language(CXX)
   # find again for those  cxx libraries.
   find_package(xgboost REQUIRED)
-endif(XGBOOST_BUILD_STATIC_LIB)
+endif()
 
 add_executable(inference-demo inference.c)
 target_link_libraries(inference-demo PRIVATE xgboost::xgboost)
diff --git a/jvm-packages/CMakeLists.txt b/jvm-packages/CMakeLists.txt
index 247c44378..f89970dea 100644
--- a/jvm-packages/CMakeLists.txt
+++ b/jvm-packages/CMakeLists.txt
@@ -7,13 +7,13 @@ list(APPEND JVM_SOURCES
 if (USE_CUDA)
   list(APPEND JVM_SOURCES
     ${PROJECT_SOURCE_DIR}/jvm-packages/xgboost4j-gpu/src/native/xgboost4j-gpu.cu)
-endif (USE_CUDA)
+endif()
 
 add_library(xgboost4j SHARED ${JVM_SOURCES} ${XGBOOST_OBJ_SOURCES})
 
 if (ENABLE_ALL_WARNINGS)
   target_compile_options(xgboost4j PUBLIC -Wall -Wextra)
-endif (ENABLE_ALL_WARNINGS)
+endif()
 
 target_link_libraries(xgboost4j PRIVATE objxgboost)
 target_include_directories(xgboost4j
diff --git a/plugin/CMakeLists.txt b/plugin/CMakeLists.txt
index 7026238e3..3a1889d2e 100644
--- a/plugin/CMakeLists.txt
+++ b/plugin/CMakeLists.txt
@@ -1,6 +1,6 @@
 if (PLUGIN_DENSE_PARSER)
   target_sources(objxgboost PRIVATE ${xgboost_SOURCE_DIR}/plugin/dense_parser/dense_libsvm.cc)
-endif (PLUGIN_DENSE_PARSER)
+endif()
 
 if (PLUGIN_UPDATER_ONEAPI)
   add_library(oneapi_plugin OBJECT
@@ -21,14 +21,14 @@ if (PLUGIN_UPDATER_ONEAPI)
   if (USE_OPENMP)
     find_package(OpenMP REQUIRED)
     target_link_libraries(oneapi_plugin PUBLIC OpenMP::OpenMP_CXX)
-  endif (USE_OPENMP)
+  endif()
   # Get compilation and link flags of oneapi_plugin and propagate to objxgboost
   target_link_libraries(objxgboost PUBLIC oneapi_plugin)
   # Add all objects of oneapi_plugin to objxgboost
   target_sources(objxgboost INTERFACE $<TARGET_OBJECTS:oneapi_plugin>)
-endif (PLUGIN_UPDATER_ONEAPI)
+endif()
 
 # Add the Federate Learning plugin if enabled.
 if (PLUGIN_FEDERATED)
   add_subdirectory(federated)
-endif (PLUGIN_FEDERATED)
+endif()
diff --git a/rabit/CMakeLists.txt b/rabit/CMakeLists.txt
index 977d4867e..f1adcb6e0 100644
--- a/rabit/CMakeLists.txt
+++ b/rabit/CMakeLists.txt
@@ -10,6 +10,6 @@ if (RABIT_MOCK)
   list(APPEND RABIT_SOURCES ${CMAKE_CURRENT_LIST_DIR}/src/engine_mock.cc)
 else ()
   list(APPEND RABIT_SOURCES ${CMAKE_CURRENT_LIST_DIR}/src/engine.cc)
-endif ()
+endif()
 
 set(RABIT_SOURCES ${RABIT_SOURCES} PARENT_SCOPE)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 4624c643c..9b2a803ab 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -14,7 +14,7 @@ target_sources(objxgboost PRIVATE ${RABIT_SOURCES})
 if (USE_CUDA)
   file(GLOB_RECURSE CUDA_SOURCES *.cu *.cuh)
   target_sources(objxgboost PRIVATE ${CUDA_SOURCES})
-endif (USE_CUDA)
+endif()
 
 target_include_directories(objxgboost
   PRIVATE
@@ -24,7 +24,7 @@ target_include_directories(objxgboost
 
 if (LOG_CAPI_INVOCATION)
   target_compile_definitions(objxgboost PRIVATE -DLOG_CAPI_INVOCATION=1)
-endif (LOG_CAPI_INVOCATION)
+endif()
 
 # For MSVC: Call msvc_use_static_runtime() once again to completely
 # replace /MD with /MT. See https://github.com/dmlc/xgboost/issues/4462
diff --git a/tests/cpp/CMakeLists.txt b/tests/cpp/CMakeLists.txt
index 51cdecd9d..1aebcc2ef 100644
--- a/tests/cpp/CMakeLists.txt
+++ b/tests/cpp/CMakeLists.txt
@@ -1,22 +1,22 @@
 if (USE_DMLC_GTEST)
   if (NOT TARGET gtest)
     message(FATAL_ERROR "USE_DMLC_GTEST=ON but dmlc-core didn't bundle gtest")
-  endif (NOT TARGET gtest)
+  endif()
   set(GTEST_LIBRARIES gtest)
 else (USE_DMLC_GTEST)
   find_package(GTest REQUIRED)
-endif (USE_DMLC_GTEST)
+endif()
 file(GLOB_RECURSE TEST_SOURCES "*.cc")
 
 if (USE_CUDA)
   file(GLOB_RECURSE CUDA_TEST_SOURCES "*.cu")
   list(APPEND TEST_SOURCES ${CUDA_TEST_SOURCES})
-endif (USE_CUDA)
+endif()
 
 file(GLOB_RECURSE ONEAPI_TEST_SOURCES "plugin/*_oneapi.cc")
 if (NOT PLUGIN_UPDATER_ONEAPI)
   list(REMOVE_ITEM TEST_SOURCES ${ONEAPI_TEST_SOURCES})
-endif (NOT PLUGIN_UPDATER_ONEAPI)
+endif()
 
 if (PLUGIN_FEDERATED)
   target_include_directories(testxgboost PRIVATE ${xgboost_SOURCE_DIR}/plugin/federated)
@@ -24,14 +24,14 @@ if (PLUGIN_FEDERATED)
 else (PLUGIN_FEDERATED)
   file(GLOB_RECURSE FEDERATED_TEST_SOURCES "plugin/*_federated_*.*")
   list(REMOVE_ITEM TEST_SOURCES ${FEDERATED_TEST_SOURCES})
-endif (PLUGIN_FEDERATED)
+endif()
 
 target_sources(testxgboost PRIVATE ${TEST_SOURCES} ${xgboost_SOURCE_DIR}/plugin/example/custom_obj.cc)
 
 if (USE_CUDA AND PLUGIN_RMM)
   find_package(CUDA)
   target_include_directories(testxgboost PRIVATE ${CUDA_INCLUDE_DIRS})
-endif (USE_CUDA AND PLUGIN_RMM)
+endif()
 
 target_include_directories(testxgboost
   PRIVATE