From 11b82d1195a1719f3aa4c8566b5933599a0934b9 Mon Sep 17 00:00:00 2001
From: Felix Exner <feex@universal-robots.com>
Date: Fri, 10 Jan 2025 14:50:58 +0100
Subject: [PATCH] Update c++ dependency using target_compile_features

---
 CMakeLists.txt                             | 11 +----
 CMakeModules/DefineCXX11CompilerFlag.cmake | 55 ----------------------
 CMakeModules/DefineCXX14CompilerFlag.cmake | 55 ----------------------
 CMakeModules/DefineCXX17CompilerFlag.cmake | 55 ----------------------
 examples/CMakeLists.txt                    | 19 +-------
 tests/CMakeLists.txt                       | 33 +------------
 6 files changed, 4 insertions(+), 224 deletions(-)
 delete mode 100644 CMakeModules/DefineCXX11CompilerFlag.cmake
 delete mode 100644 CMakeModules/DefineCXX14CompilerFlag.cmake
 delete mode 100644 CMakeModules/DefineCXX17CompilerFlag.cmake

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 878ffede2..bdf9d1f39 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0.2)
+cmake_minimum_required(VERSION 3.14.0)
 project(ur_client_library)
 
 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules/" ${CMAKE_MODULE_PATH})
@@ -10,13 +10,6 @@ endif()
 
 option(WITH_ASAN "Compile with address sanitizer support" OFF)
 
-##
-## Check C++11 support / enable global pedantic and Wall
-##
-include(DefineCXX17CompilerFlag)
-DEFINE_CXX_17_COMPILER_FLAG(CXX17_FLAG)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -pedantic")
-
 add_library(urcl SHARED
     src/comm/tcp_socket.cpp
     src/comm/tcp_server.cpp
@@ -52,7 +45,7 @@ add_library(urcl SHARED
 )
 add_library(ur_client_library::urcl ALIAS urcl)
 target_compile_options(urcl PRIVATE -Wall -Wextra -Wno-unused-parameter)
-target_compile_options(urcl PUBLIC ${CXX17_FLAG})
+target_compile_features(urcl PUBLIC cxx_std_17)
 if(WITH_ASAN)
   target_compile_options(urcl PUBLIC -fsanitize=address)
   target_link_options(urcl PUBLIC -fsanitize=address)
diff --git a/CMakeModules/DefineCXX11CompilerFlag.cmake b/CMakeModules/DefineCXX11CompilerFlag.cmake
deleted file mode 100644
index f362e364a..000000000
--- a/CMakeModules/DefineCXX11CompilerFlag.cmake
+++ /dev/null
@@ -1,55 +0,0 @@
-# DefineCXX11CompilerFlag
-# -----------------------
-#
-# Tries to find the compiler flag which can be used to enable C++11 on the current compiler.
-# If the flag is not found, the macro will issue an cmake error.
-#
-# DEFINE_CXX_11_COMPILER_FLAG(<var>)
-#
-# ::
-#
-#   <var>  - variable to store the resulting flag
-#
-# Use this to find the compiler option to enable C++11 compilation. This is usefull
-# on cmake versions / use cases which do not support CXX_STANDARD.
-# Use this in conjunction with target_compiler_option():
-#
-# include(DefineCXX11CompilerFlag)
-# DEFINE_CXX_11_COMPILER_FLAG(CXX11_FLAG)
-# ...
-# target_compile_options(topt PUBLIC ${CXX11_FLAG})
-# ...
-#
-# The following variables may be set before calling this macro to modify
-# the way the check is run:
-#
-# ::
-#
-#   CMAKE_REQUIRED_QUIET = execute quietly without messages
-#
-
-include(CheckCXXCompilerFlag)
-
-macro (DEFINE_CXX_11_COMPILER_FLAG _RESULT)
-  if(NOT DEFINED "${_RESULT}")
-
-    if(NOT CMAKE_REQUIRED_QUIET)
-      message(STATUS "Performing C++11 Test")
-    endif()
-
-    # Check for default argument (all newer compilers)
-    CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
-    if(COMPILER_SUPPORTS_CXX11)
-      set(${_RESULT} "-std=c++11" CACHE INTERNAL "C++11 flag")
-    else()
-      # Check for older version (before 2011)
-      CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)
-      if(COMPILER_SUPPORTS_CXX0X)
-	set(${_RESULT} "-std=c++0x" CACHE INTERNAL "C++11 flag")
-      else()
-	message(FATAL_ERROR "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")
-      endif()
-    endif()
-
-  endif()
-endmacro()
diff --git a/CMakeModules/DefineCXX14CompilerFlag.cmake b/CMakeModules/DefineCXX14CompilerFlag.cmake
deleted file mode 100644
index c76f2caea..000000000
--- a/CMakeModules/DefineCXX14CompilerFlag.cmake
+++ /dev/null
@@ -1,55 +0,0 @@
-# DefineCXX14CompilerFlag
-# -----------------------
-#
-# Tries to find the compiler flag which can be used to enable C++14 on the current compiler.
-# If the flag is not found, the macro will issue an cmake error.
-#
-# DEFINE_CXX_14_COMPILER_FLAG(<var>)
-#
-# ::
-#
-#   <var>  - variable to store the resulting flag
-#
-# Use this to find the compiler option to enable C++14 compilation. This is usefull
-# on cmake versions / use cases which do not support CXX_STANDARD.
-# Use this in conjunction with target_compiler_option():
-#
-# include(DefineCXX14CompilerFlag)
-# DEFINE_CXX_14_COMPILER_FLAG(CXX14_FLAG)
-# ...
-# target_compile_options(topt PUBLIC ${CXX14_FLAG})
-# ...
-#
-# The following variables may be set before calling this macro to modify
-# the way the check is run:
-#
-# ::
-#
-#   CMAKE_REQUIRED_QUIET = execute quietly without messages
-#
-
-include(CheckCXXCompilerFlag)
-
-macro (DEFINE_CXX_14_COMPILER_FLAG _RESULT)
-  if(NOT DEFINED "${_RESULT}")
-
-    if(NOT CMAKE_REQUIRED_QUIET)
-      message(STATUS "Performing C++14 Test")
-    endif()
-
-    # Check for default argument (all newer compilers)
-    CHECK_CXX_COMPILER_FLAG("-std=c++14" COMPILER_SUPPORTS_CXX14)
-    if(COMPILER_SUPPORTS_CXX14)
-      set(${_RESULT} "-std=c++14" CACHE INTERNAL "C++14 flag")
-    else()
-      # Check for older version (like gcc-4.8.4)
-      CHECK_CXX_COMPILER_FLAG("-std=c++1y" COMPILER_SUPPORTS_CXX1Y)
-      if(COMPILER_SUPPORTS_CXX1Y)
-	set(${_RESULT} "-std=c++1y" CACHE INTERNAL "C++14 flag")
-      else()
-	message(FATAL_ERROR "The compiler ${CMAKE_CXX_COMPILER} has no C++14 support. Please use a different C++ compiler.")
-      endif()
-    endif()
-
-  endif()
-endmacro()
diff --git a/CMakeModules/DefineCXX17CompilerFlag.cmake b/CMakeModules/DefineCXX17CompilerFlag.cmake
deleted file mode 100644
index 37a6058b0..000000000
--- a/CMakeModules/DefineCXX17CompilerFlag.cmake
+++ /dev/null
@@ -1,55 +0,0 @@
-# DefineCXX17CompilerFlag
-# -----------------------
-#
-# Tries to find the compiler flag which can be used to enable C++17 on the current compiler.
-# If the flag is not found, the macro will issue an cmake error.
-#
-# DEFINE_CXX_17_COMPILER_FLAG(<var>)
-#
-# ::
-#
-#   <var>  - variable to store the resulting flag
-#
-# Use this to find the compiler option to enable C++17 compilation. This is usefull
-# on cmake versions / use cases which do not support CXX_STANDARD.
-# Use this in conjunction with target_compiler_option():
-#
-# include(DefineCXX17CompilerFlag)
-# DEFINE_CXX_17_COMPILER_FLAG(CXX17_FLAG)
-# ...
-# target_compile_options(topt PUBLIC ${CXX17_FLAG})
-# ...
-#
-# The following variables may be set before calling this macro to modify
-# the way the check is run:
-#
-# ::
-#
-#   CMAKE_REQUIRED_QUIET = execute quietly without messages
-#
-
-include(CheckCXXCompilerFlag)
-
-macro (DEFINE_CXX_17_COMPILER_FLAG _RESULT)
-  if(NOT DEFINED "${_RESULT}")
-
-    if(NOT CMAKE_REQUIRED_QUIET)
-      message(STATUS "Performing C++17 Test")
-    endif()
-
-    # Check for default argument (all newer compilers)
-    CHECK_CXX_COMPILER_FLAG("-std=c++17" COMPILER_SUPPORTS_CXX17)
-    if(COMPILER_SUPPORTS_CXX17)
-      set(${_RESULT} "-std=c++17" CACHE INTERNAL "C++17 flag")
-    else()
-      # Check for older version (before 2017)
-      CHECK_CXX_COMPILER_FLAG("-std=c++1z" COMPILER_SUPPORTS_CXX1Z)
-      if(COMPILER_SUPPORTS_CXX1Z)
-	set(${_RESULT} "-std=c++1z" CACHE INTERNAL "C++17 flag")
-      else()
-	message(FATAL_ERROR "The compiler ${CMAKE_CXX_COMPILER} has no C++17 support. Please use a different C++ compiler.")
-      endif()
-    endif()
-
-  endif()
-endmacro()
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index e68cd4928..79fc67fa7 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -1,66 +1,49 @@
-cmake_minimum_required(VERSION 3.0.2)
+cmake_minimum_required(VERSION 3.14.0)
 project(ur_driver_examples)
 
 # find_package(ur_client_library REQUIRED)
 
-# #
-# # Check C++11 support / enable global pedantic and Wall
-# #
-include(DefineCXX17CompilerFlag)
-DEFINE_CXX_17_COMPILER_FLAG(CXX17_FLAG)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -pedantic")
 
 add_executable(driver_example
   full_driver.cpp)
-target_compile_options(driver_example PUBLIC ${CXX17_FLAG})
 target_link_libraries(driver_example ur_client_library::urcl)
 
 add_executable(primary_pipeline_example
   primary_pipeline.cpp)
-target_compile_options(primary_pipeline_example PUBLIC ${CXX17_FLAG})
 target_link_libraries(primary_pipeline_example ur_client_library::urcl)
 
 add_executable(primary_pipeline_calibration_example
   primary_pipeline_calibration.cpp)
-target_compile_options(primary_pipeline_calibration_example PUBLIC ${CXX17_FLAG})
 target_link_libraries(primary_pipeline_calibration_example ur_client_library::urcl)
 
 add_executable(rtde_client_example
   rtde_client.cpp)
-target_compile_options(rtde_client_example PUBLIC ${CXX17_FLAG})
 target_link_libraries(rtde_client_example ur_client_library::urcl)
 
 add_executable(dashboard_example
   dashboard_example.cpp)
-target_compile_options(dashboard_example PUBLIC ${CXX17_FLAG})
 target_link_libraries(dashboard_example ur_client_library::urcl)
 
 add_executable(spline_example
 spline_example.cpp)
-target_compile_options(spline_example PUBLIC ${CXX17_FLAG})
 target_link_libraries(spline_example ur_client_library::urcl)
 
 add_executable(tool_contact_example
 tool_contact_example.cpp)
-target_compile_options(tool_contact_example PUBLIC ${CXX17_FLAG})
 target_link_libraries(tool_contact_example ur_client_library::urcl)
 
 add_executable(freedrive_example
 freedrive_example.cpp)
-target_compile_options(freedrive_example PUBLIC ${CXX17_FLAG})
 target_link_libraries(freedrive_example ur_client_library::urcl)
 
 add_executable(force_mode_example
 force_mode_example.cpp)
-target_compile_options(force_mode_example PUBLIC ${CXX17_FLAG})
 target_link_libraries(force_mode_example ur_client_library::urcl)
 
 add_executable(script_sender_example
 script_sender.cpp)
-target_compile_options(script_sender_example PUBLIC ${CXX17_FLAG})
 target_link_libraries(script_sender_example ur_client_library::urcl)
 
 add_executable(trajectory_point_interface_example
 trajectory_point_interface.cpp)
-target_compile_options(trajectory_point_interface_example PUBLIC ${CXX17_FLAG})
 target_link_libraries(trajectory_point_interface_example ur_client_library::urcl)
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index db831f054..72da98804 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0.2)
+cmake_minimum_required(VERSION 3.14.0)
 
 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../CMakeModules/" ${CMAKE_MODULE_PATH})
 
@@ -21,9 +21,6 @@ if (NOT TARGET ur_client_library::urcl)
   find_package(ur_client_library REQUIRED)
 endif()
 
-# Check C++11 support
-include(DefineCXX17CompilerFlag)
-DEFINE_CXX_17_COMPILER_FLAG(CXX17_FLAG)
 
 
 # Build Tests
@@ -31,7 +28,6 @@ if (INTEGRATION_TESTS)
   # Integration tests require a robot reachable at 192.168.56.101. Therefore, they have to be
   # activated separately.
   add_executable(rtde_tests test_rtde_client.cpp)
-  target_compile_options(rtde_tests PRIVATE ${CXX17_FLAG})
   target_include_directories(rtde_tests PRIVATE ${GTEST_INCLUDE_DIRS})
   target_link_libraries(rtde_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
   gtest_add_tests(TARGET      rtde_tests
@@ -39,14 +35,12 @@ if (INTEGRATION_TESTS)
   )
 
   add_executable(dashboard_client_tests test_dashboard_client.cpp)
-  target_compile_options(dashboard_client_tests PRIVATE ${CXX17_FLAG})
   target_include_directories(dashboard_client_tests PRIVATE ${GTEST_INCLUDE_DIRS})
   target_link_libraries(dashboard_client_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
   gtest_add_tests(TARGET      dashboard_client_tests
   )
 
   add_executable(spline_tests test_spline_interpolation.cpp)
-  target_compile_options(spline_tests PRIVATE ${CXX17_FLAG})
   target_include_directories(spline_tests PRIVATE ${GTEST_INCLUDE_DIRS})
   target_link_libraries(spline_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
   gtest_add_tests(TARGET      spline_tests
@@ -54,7 +48,6 @@ if (INTEGRATION_TESTS)
   )
 
   add_executable(ur_driver_tests test_ur_driver.cpp)
-  target_compile_options(ur_driver_tests PRIVATE ${CXX17_FLAG})
   target_include_directories(ur_driver_tests PRIVATE ${GTEST_INCLUDE_DIRS})
   target_link_libraries(ur_driver_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
   gtest_add_tests(TARGET      ur_driver_tests
@@ -66,168 +59,144 @@ endif()
 
 
 add_executable(primary_parser_tests test_primary_parser.cpp)
-target_compile_options(primary_parser_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(primary_parser_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(primary_parser_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET      primary_parser_tests
 )
 
 add_executable(rtde_data_package_tests test_rtde_data_package.cpp)
-target_compile_options(rtde_data_package_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(rtde_data_package_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(rtde_data_package_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET      rtde_data_package_tests
 )
 
 add_executable(rtde_parser_tests test_rtde_parser.cpp)
-target_compile_options(rtde_parser_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(rtde_parser_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(rtde_parser_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET      rtde_parser_tests
 )
 
 add_executable(tcp_server_tests test_tcp_server.cpp)
-target_compile_options(tcp_server_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(tcp_server_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(tcp_server_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET      tcp_server_tests
 )
 
 add_executable(script_sender_tests test_script_sender.cpp)
-target_compile_options(script_sender_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(script_sender_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(script_sender_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET      script_sender_tests
 )
 
 add_executable(reverse_interface_tests test_reverse_interface.cpp)
-target_compile_options(reverse_interface_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(reverse_interface_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(reverse_interface_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET reverse_interface_tests
 )
 
 add_executable(trajectory_point_interface_tests test_trajectory_point_interface.cpp)
-target_compile_options(trajectory_point_interface_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(trajectory_point_interface_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(trajectory_point_interface_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET trajectory_point_interface_tests
 )
 
 add_executable(rtde_control_package_pause_tests test_rtde_control_package_pause.cpp)
-target_compile_options(rtde_control_package_pause_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(rtde_control_package_pause_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(rtde_control_package_pause_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET rtde_control_package_pause_tests
 )
 
 add_executable(rtde_control_package_start_tests test_rtde_control_package_start.cpp)
-target_compile_options(rtde_control_package_start_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(rtde_control_package_start_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(rtde_control_package_start_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET rtde_control_package_start_tests
 )
 
 add_executable(rtde_control_package_setup_outputs_tests test_rtde_control_package_setup_outputs.cpp)
-target_compile_options(rtde_control_package_setup_outputs_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(rtde_control_package_setup_outputs_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(rtde_control_package_setup_outputs_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET rtde_control_package_setup_outputs_tests
 )
 
 add_executable(rtde_control_package_setup_inputs_tests test_rtde_control_package_setup_inputs.cpp)
-target_compile_options(rtde_control_package_setup_inputs_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(rtde_control_package_setup_inputs_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(rtde_control_package_setup_inputs_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET rtde_control_package_setup_inputs_tests
 )
 
 add_executable(rtde_get_urcontrol_version_tests test_rtde_get_urcontrol_version.cpp)
-target_compile_options(rtde_get_urcontrol_version_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(rtde_get_urcontrol_version_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(rtde_get_urcontrol_version_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET rtde_get_urcontrol_version_tests
 )
 
 add_executable(rtde_request_protocol_version_tests test_rtde_request_protocol_version.cpp)
-target_compile_options(rtde_request_protocol_version_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(rtde_request_protocol_version_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(rtde_request_protocol_version_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET rtde_request_protocol_version_tests
 )
 
 add_executable(rtde_writer_tests test_rtde_writer.cpp)
-target_compile_options(rtde_writer_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(rtde_writer_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(rtde_writer_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET rtde_writer_tests
 )
 
 add_executable(version_information_tests test_version_information.cpp)
-target_compile_options(version_information_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(version_information_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(version_information_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET version_information_tests
 )
 
 add_executable(bin_parser_tests test_bin_parser.cpp)
-target_compile_options(bin_parser_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(bin_parser_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(bin_parser_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET bin_parser_tests
 )
 
 add_executable(package_serializer_tests test_package_serializer.cpp)
-target_compile_options(package_serializer_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(package_serializer_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(package_serializer_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET package_serializer_tests
 )
 
 add_executable(tcp_socket_tests test_tcp_socket.cpp)
-target_compile_options(tcp_socket_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(tcp_socket_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(tcp_socket_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET tcp_socket_tests
 )
 
 add_executable(stream_tests test_stream.cpp)
-target_compile_options(stream_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(stream_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(stream_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET stream_tests
 )
 
 add_executable(producer_tests test_producer.cpp)
-target_compile_options(producer_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(producer_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(producer_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET producer_tests
 )
 
 add_executable(pipeline_tests test_pipeline.cpp)
-target_compile_options(pipeline_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(pipeline_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(pipeline_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET pipeline_tests
 )
 
 add_executable(script_command_interface_tests test_script_command_interface.cpp)
-target_compile_options(script_command_interface_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(script_command_interface_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(script_command_interface_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET script_command_interface_tests
 )
 
 add_executable(robot_receive_timeout_tests test_robot_receive_timeout.cpp)
-target_compile_options(robot_receive_timeout_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(robot_receive_timeout_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(robot_receive_timeout_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET robot_receive_timeout_tests
 )
 
 add_executable(control_mode_tests test_control_mode.cpp)
-target_compile_options(control_mode_tests PRIVATE ${CXX17_FLAG})
 target_include_directories(control_mode_tests PRIVATE ${GTEST_INCLUDE_DIRS})
 target_link_libraries(control_mode_tests PRIVATE ur_client_library::urcl ${GTEST_LIBRARIES})
 gtest_add_tests(TARGET control_mode_tests