CMake and Travis config updates (#93)

* clean cmake usage
* reduce duplication
* deduplication
* Go travis
* Address review comments

.travis.yml

@@ -1,14 +1,9 @@
 language: cpp
+dist: trusty
+sudo: false
 
 matrix:
   include:
-  - os: linux
-    compiler: gcc
-    addons:
-      apt:
-        sources: ['ubuntu-toolchain-r-test']
-        packages: ['g++-5']
-    env: COMPILER=g++-5
   - os: linux
     compiler: gcc
     addons:
@@ -20,15 +15,11 @@ matrix:
     compiler: clang
     addons:
       apt:
-        sources: ['ubuntu-toolchain-r-test', 'llvm-toolchain-precise-3.8']
+        sources: ['ubuntu-toolchain-r-test', 'llvm-toolchain-trusty-4.0']
-        packages: ['clang-3.8']
+        packages: ['clang-4.0', 'libstdc++-4.9-dev']
-    env: COMPILER=clang++-3.8
+    env: COMPILER=clang++-4.0
   - os: osx
-    osx_image: xcode7.3
+    osx_image: xcode8.3
-    compiler: clang
-    env: COMPILER=clang++
-  - os: osx
-    osx_image: xcode8
     compiler: clang
     env: COMPILER=clang++
   - os: linux
@@ -53,7 +44,6 @@ notifications:
 
 install:
   - echo ${PATH}
-  - ./travis.sh
   - cmake --version
   - export CXX=${COMPILER}
   - echo ${CXX}

CMakeLists.txt

@@ -1,12 +1,13 @@
 #
 # uvw
 #
+cmake_minimum_required(VERSION 3.2)
 
 #
 # Building in-tree is not allowed (we take care of your craziness).
 #
 
-if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
+if(CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR)
     message(FATAL_ERROR "Prevented in-tree built. Please create a build directory outside of the source code and call cmake from there. Thank you.")
 endif()
 
@@ -14,78 +15,46 @@ endif()
 # Project configuration
 #
 
-project(uvw)
+project(uvw
-cmake_minimum_required(VERSION 3.4)
+        VERSION 1.1.1)
 
 if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE Debug)
-endif(NOT CMAKE_BUILD_TYPE)
+endif()
 
-set(PROJECT_NAME "uvw")
-set(PROJECT_VERSION_MAJOR 1)
-set(PROJECT_VERSION_MINOR 1)
-set(PROJECT_VERSION_PATCH 1)
-set(PROJECT_VERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH})
 set(SETTINGS_ORGANIZATION "Michele Caini")
 set(SETTINGS_APPLICATION ${PROJECT_NAME})
 set(PROJECT_AUTHOR "Michele Caini")
-set(PROJECT_YEAR_COPYRIGHT "2017")
 set(PROJECT_AUTHOR_EMAIL "michele.caini@gmail.com")
 
-set(PROJECT_BUILD_MESSAGE ${PROJECT_NAME} " v" ${PROJECT_VERSION} " (" ${CMAKE_BUILD_TYPE} ")")
-set(COPYRIGHT_BUILD_MESSAGE "Copyright (c) " ${PROJECT_YEAR_COPYRIGHT} " " ${PROJECT_AUTHOR}  " <" ${PROJECT_AUTHOR_EMAIL} ">")
-
 message("*")
-message("* " ${PROJECT_BUILD_MESSAGE})
+message("* ${PROJECT_NAME} v${PROJECT_VERSION} (${CMAKE_BUILD_TYPE})")
-message("* " ${COPYRIGHT_BUILD_MESSAGE})
+message("* Copyright (c) 2017 ${PROJECT_AUTHOR} <${PROJECT_AUTHOR_EMAIL}>")
 message("*")
 
-if(APPLE)
-    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-undefined,dynamic_lookup")
-else(APPLE)
-    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined")
-endif(APPLE)
-
 set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 if(NOT WIN32)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
-endif(NOT WIN32)
+endif()
 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g -DDEBUG")
 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -Os -DRELEASE")
 
-add_definitions(
-    -DPROJECT_NAME=${PROJECT_NAME}
-    -DPROJECT_VERSION=${PROJECT_VERSION}
-)
-
 #
 # CMake configuration
 #
 
-set(PROJECT_CMAKE_MODULES cmake/modules)
+set(PROJECT_CMAKE_IN ${uvw_SOURCE_DIR}/cmake/in)
-set(PROJECT_CMAKE_IN cmake/in)
+set(PROJECT_DEPS_DIR ${uvw_SOURCE_DIR}/deps)
-set(PROJECT_BUILD_DIR build)
+set(PROJECT_SRC_DIR ${uvw_SOURCE_DIR}/src)
-set(PROJECT_DEPS_DIR deps)
-set(PROJECT_DOCS_DIR docs)
-set(PROJECT_SRC_DIR src)
-set(PROJECT_TEST_DIR test)
 
-set(PROJECT_RUNTIME_OUTPUT_DIRECTORY bin)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY bin)
-
-set(
-    CMAKE_MODULE_PATH
-    ${CMAKE_MODULE_PATH}
-    ${CMAKE_SOURCE_DIR}/${PROJECT_CMAKE_MODULES}
-)
-
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_RUNTIME_OUTPUT_DIRECTORY})
 
 #
-# Enable test support using ctest
+# Enable test support using ctest-like interface
 #
 
-enable_testing()
+option(BUILD_TESTING "Enable testing with ctest." ON)
 
 #
 # Referenced packages
@@ -95,14 +64,13 @@ set(THREADS_PREFER_PTHREAD_FLAG ON)
 
 find_package(Threads REQUIRED)
 find_package(Doxygen 1.8)
-find_package(LibRt)
 
 #
 # Download and unpack dependencies
 #
 
-set(GOOGLETEST_DEPS_DIR ${CMAKE_SOURCE_DIR}/${PROJECT_DEPS_DIR}/googletest)
+set(GOOGLETEST_DEPS_DIR ${PROJECT_DEPS_DIR}/googletest)
-set(LIBUV_DEPS_DIR ${CMAKE_SOURCE_DIR}/${PROJECT_DEPS_DIR}/libuv)
+set(LIBUV_DEPS_DIR ${PROJECT_DEPS_DIR}/libuv)
 
 # gtest, gtest_main, gmock and gmock_main targets are available from now on
 configure_file(${PROJECT_CMAKE_IN}/googletest.in ${GOOGLETEST_DEPS_DIR}/CMakeLists.txt)
@@ -122,11 +90,14 @@ find_library(libuv_shared NAMES uv libuv PATHS ${LIBUV_DEPS_DIR}/src PATH_SUFFIX
 # Referenced directories and targets
 #
 
-if(${DOXYGEN_FOUND})
+if(DOXYGEN_FOUND)
-    add_subdirectory(${PROJECT_DOCS_DIR})
+    add_subdirectory(docs)
-endif(${DOXYGEN_FOUND})
+endif()
 
-add_subdirectory(${PROJECT_TEST_DIR})
+if(BUILD_TESTING)
+    enable_testing()
+    add_subdirectory(test)
+endif()
 
 #
 # Keep your stuff and go further away, foolish.
@@ -141,8 +112,8 @@ set(CPACK_PACKAGE_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION
 set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "uvw")
 set(CPACK_PACKAGE_FILE_NAME ${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION})
 set(CPACK_SOURCE_PACKAGE_FILE_NAME ${CPACK_PACKAGE_FILE_NAME}-src)
-set(CPACK_RESOURCE_FILE_LICENSE ${CMAKE_SOURCE_DIR}/LICENSE)
+set(CPACK_RESOURCE_FILE_LICENSE ${uvw_SOURCE_DIR}/LICENSE)
-set(CPACK_RESOURCE_FILE_README ${CMAKE_SOURCE_DIR}/README.md)
+set(CPACK_RESOURCE_FILE_README ${uvw_SOURCE_DIR}/README.md)
 set(CPACK_GENERATOR TGZ)
 set(CPACK_SOURCE_GENERATOR TGZ)
 set(CPACK_PACKAGING_INSTALL_DIRECTORY "uvw-${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}")

cmake/in/googletest.in

@@ -1,5 +1,5 @@
 project(googletest-download NONE)
-cmake_minimum_required(VERSION 3.4)
+cmake_minimum_required(VERSION 3.2)
 
 include(ExternalProject)
 

cmake/in/libuv.in

@@ -1,5 +1,5 @@
 project(libuv-download NONE)
-cmake_minimum_required(VERSION 3.4)
+cmake_minimum_required(VERSION 3.2)
 
 include(ExternalProject)
 

cmake/modules/FindLibRt.cmake

@@ -1,32 +0,0 @@
-# FindLibRt
-# --------
-#
-# Find the native realtime includes and library.
-#
-# Result Variables
-# ^^^^^^^^^^^^^^^^
-#
-# This module defines the following variables:
-#
-# ::
-#
-#   LIBRT_INCLUDE_DIRS  - where to find time.h, etc.
-#   LIBRT_LIBRARIES     - List of libraries when using librt.
-#   LIBRT_FOUND         - True if realtime library found.
-#
-# Hints
-# ^^^^^
-#
-# A user may set ``LIBRT_ROOT`` to a realtime installation root to tell this
-# module where to look.
-
-find_path(
-    LIBRT_INCLUDE_DIRS
-    NAMES time.h
-    PATHS ${LIBRT_ROOT}/include/
-)
-
-find_library(LIBRT_LIBRARIES rt)
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(LibRt DEFAULT_MSG LIBRT_LIBRARIES LIBRT_INCLUDE_DIRS)
-mark_as_advanced(LIBRT_INCLUDE_DIRS LIBRT_LIBRARIES)

test/CMakeLists.txt

@@ -2,290 +2,75 @@
 # Tests configuration
 #
 
-set(UVW_SRC_DIR ${CMAKE_SOURCE_DIR}/${PROJECT_SRC_DIR})
+set(UVW_SRC_DIR ${PROJECT_SRC_DIR})
+
+if(WIN32)
+    set(WINSOCK2 ws2_32)
+elseif(NOT APPLE)
+    find_library(LIBRT rt)
+endif()
 
 set(
     COMMON_LINK_LIBS
-    gtest
     gtest_main
+    ${LIBRT}
     ${libuv_static}
     Threads::Threads
+    ${WINSOCK2}
 )
 
-if(${LIBRT_FOUND})
-    list(APPEND COMMON_LINK_LIBS ${LIBRT_LIBRARIES})
-endif(${LIBRT_FOUND})
-
-if(WIN32)
-    list(APPEND COMMON_LINK_LIBS ws2_32)
-endif(WIN32)
-
 add_library(odr OBJECT odr.cpp)
 target_include_directories(odr PRIVATE ${UVW_SRC_DIR})
 
+macro(ADD_UVW_TEST TEST_NAME TEST_SOURCE)
+    add_executable(${TEST_NAME} $<TARGET_OBJECTS:odr> ${TEST_SOURCE})
+    target_include_directories(${TEST_NAME} PRIVATE ${UVW_SRC_DIR})
+    target_link_libraries(${TEST_NAME} PRIVATE ${COMMON_LINK_LIBS})
+    add_test(NAME ${TEST_NAME} COMMAND ${TEST_NAME})
+endmacro()
+
+macro(ADD_UVW_DIR_TEST TEST_NAME TEST_SOURCE)
+    ADD_UVW_TEST(${TEST_NAME} ${TEST_SOURCE})
+    string(TOUPPER "${TEST_NAME}" TEST_NAME_UPPER)
+    set(TEST_DIR_VAR "TARGET_${TEST_NAME_UPPER}_DIR")
+    set(TEST_DIR ${CMAKE_CURRENT_BINARY_DIR}/${TEST_NAME})
+    file(MAKE_DIRECTORY ${TEST_DIR})
+    target_compile_definitions(${TEST_NAME} PRIVATE ${TEST_DIR_VAR}="${TEST_DIR}")
+endmacro()
+
+macro(ADD_UVW_LIB_TEST TEST_NAME TEST_SOURCE)
+    ADD_UVW_TEST(${TEST_NAME} ${TEST_SOURCE})
+    target_link_libraries(${TEST_NAME} PRIVATE ${CMAKE_DL_LIBS})
+    target_compile_definitions(${TEST_NAME} PRIVATE TARGET_LIB_SO="${libuv_shared}")
+endmacro()
+
 # List of available targets
 
-set(TARGET_MAIN main)
+ADD_UVW_TEST(main main.cpp)
-set(TARGET_ASYNC async)
+ADD_UVW_TEST(async uvw/async.cpp)
-set(TARGET_CHECK check)
+ADD_UVW_TEST(check uvw/check.cpp)
-set(TARGET_DNS dns)
+ADD_UVW_TEST(dns uvw/dns.cpp)
-set(TARGET_EMITTER emitter)
+ADD_UVW_TEST(emitter uvw/emitter.cpp)
-set(TARGET_FILE_REQ file_req)
+ADD_UVW_DIR_TEST(file_req uvw/file_req.cpp)
-set(TARGET_FS_EVENT fs_event)
+ADD_UVW_DIR_TEST(fs_event uvw/fs_event.cpp)
-set(TARGET_FS_POLL fs_poll)
+ADD_UVW_DIR_TEST(fs_poll uvw/fs_poll.cpp)
-set(TARGET_FS_REQ fs_req)
+ADD_UVW_DIR_TEST(fs_req uvw/fs_req.cpp)
-set(TARGET_HANDLE handle)
+ADD_UVW_TEST(handle uvw/handle.cpp)
-set(TARGET_IDLE idle)
+ADD_UVW_TEST(idle uvw/idle.cpp)
-set(TARGET_LIB lib)
+ADD_UVW_LIB_TEST(lib uvw/lib.cpp)
-set(TARGET_LOOP loop)
+ADD_UVW_TEST(loop uvw/loop.cpp)
-set(TARGET_PIPE pipe)
+ADD_UVW_TEST(pipe uvw/pipe.cpp)
-set(TARGET_POLL poll)
+ADD_UVW_TEST(poll uvw/poll.cpp)
-set(TARGET_PREPARE prepare)
+ADD_UVW_TEST(prepare uvw/prepare.cpp)
-set(TARGET_PROCESS process)
+ADD_UVW_TEST(process uvw/process.cpp)
-set(TARGET_REQUEST request)
+ADD_UVW_TEST(request uvw/request.cpp)
-set(TARGET_RESOURCE resource)
+ADD_UVW_TEST(resource uvw/resource.cpp)
-set(TARGET_SIGNAL signal)
+ADD_UVW_TEST(signal uvw/signal.cpp)
-set(TARGET_STREAM stream)
+ADD_UVW_TEST(stream uvw/stream.cpp)
-set(TARGET_TCP tcp)
+ADD_UVW_TEST(tcp uvw/tcp.cpp)
-set(TARGET_THREAD thread)
+ADD_UVW_TEST(thread uvw/thread.cpp)
-set(TARGET_TIMER timer)
+ADD_UVW_TEST(timer uvw/timer.cpp)
-set(TARGET_TTY tty)
+ADD_UVW_TEST(tty uvw/tty.cpp)
-set(TARGET_UDP udp)
+ADD_UVW_TEST(udp uvw/udp.cpp)
-set(TARGET_UTIL util)
+ADD_UVW_TEST(util uvw/util.cpp)
-set(TARGET_WORK work)
+ADD_UVW_TEST(work uvw/work.cpp)
-
-# Test TARGET_MAIN
-
-set(TARGET_MAIN_SOURCES $<TARGET_OBJECTS:odr> main.cpp)
-add_executable(${TARGET_MAIN} ${TARGET_MAIN_SOURCES})
-target_include_directories(${TARGET_MAIN} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_MAIN} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_MAIN} COMMAND ${TARGET_MAIN})
-
-# Test TARGET_ASYNC
-
-set(TARGET_ASYNC_SOURCES $<TARGET_OBJECTS:odr> uvw/async.cpp)
-add_executable(${TARGET_ASYNC} ${TARGET_ASYNC_SOURCES})
-target_include_directories(${TARGET_ASYNC} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_ASYNC} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_ASYNC} COMMAND ${TARGET_ASYNC})
-
-# Test TARGET_CHECK
-
-set(TARGET_CHECK_SOURCES $<TARGET_OBJECTS:odr> uvw/check.cpp)
-add_executable(${TARGET_CHECK} ${TARGET_CHECK_SOURCES})
-target_include_directories(${TARGET_CHECK} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_CHECK} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_CHECK} COMMAND ${TARGET_CHECK})
-
-# Test TARGET_DNS
-
-set(TARGET_DNS_SOURCES $<TARGET_OBJECTS:odr> uvw/dns.cpp)
-add_executable(${TARGET_DNS} ${TARGET_DNS_SOURCES})
-target_include_directories(${TARGET_DNS} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_DNS} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_DNS} COMMAND ${TARGET_DNS})
-
-# Test TARGET_EMITTER
-
-set(TARGET_EMITTER_SOURCES $<TARGET_OBJECTS:odr> uvw/emitter.cpp)
-add_executable(${TARGET_EMITTER} ${TARGET_EMITTER_SOURCES})
-target_include_directories(${TARGET_EMITTER} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_EMITTER} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_EMITTER} COMMAND ${TARGET_EMITTER})
-
-# Test TARGET_FILE_REQ
-
-set(TARGET_FILE_REQ_SOURCES $<TARGET_OBJECTS:odr> uvw/file_req.cpp)
-set(TARGET_FILE_REQ_DIR ${CMAKE_CURRENT_BINARY_DIR}/file_req)
-file(MAKE_DIRECTORY ${TARGET_FILE_REQ_DIR})
-add_executable(${TARGET_FILE_REQ} ${TARGET_FILE_REQ_SOURCES})
-target_include_directories(${TARGET_FILE_REQ} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_FILE_REQ} PRIVATE ${COMMON_LINK_LIBS})
-target_compile_definitions(${TARGET_FILE_REQ} PRIVATE TARGET_FILE_REQ_DIR="${TARGET_FILE_REQ_DIR}")
-add_test(NAME ${TARGET_FILE_REQ} COMMAND ${TARGET_FILE_REQ})
-
-# Test TARGET_FS_EVENT
-
-set(TARGET_FS_EVENT_SOURCES $<TARGET_OBJECTS:odr> uvw/fs_event.cpp)
-set(TARGET_FS_EVENT_DIR ${CMAKE_CURRENT_BINARY_DIR}/fs_event)
-file(MAKE_DIRECTORY ${TARGET_FS_EVENT_DIR})
-add_executable(${TARGET_FS_EVENT} ${TARGET_FS_EVENT_SOURCES})
-target_include_directories(${TARGET_FS_EVENT} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_FS_EVENT} PRIVATE ${COMMON_LINK_LIBS})
-target_compile_definitions(${TARGET_FS_EVENT} PRIVATE TARGET_FS_EVENT_DIR="${TARGET_FS_EVENT_DIR}")
-add_test(NAME ${TARGET_FS_EVENT} COMMAND ${TARGET_FS_EVENT})
-
-# Test TARGET_FS_POLL
-
-set(TARGET_FS_POLL_SOURCES $<TARGET_OBJECTS:odr> uvw/fs_poll.cpp)
-set(TARGET_FS_POLL_DIR ${CMAKE_CURRENT_BINARY_DIR}/fs_poll)
-file(MAKE_DIRECTORY ${TARGET_FS_POLL_DIR})
-add_executable(${TARGET_FS_POLL} ${TARGET_FS_POLL_SOURCES})
-target_include_directories(${TARGET_FS_POLL} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_FS_POLL} PRIVATE ${COMMON_LINK_LIBS})
-target_compile_definitions(${TARGET_FS_POLL} PRIVATE TARGET_FS_POLL_DIR="${TARGET_FS_POLL_DIR}")
-add_test(NAME ${TARGET_FS_POLL} COMMAND ${TARGET_FS_POLL})
-
-# Test TARGET_FS_REQ
-
-set(TARGET_FS_REQ_SOURCES $<TARGET_OBJECTS:odr> uvw/fs_req.cpp)
-set(TARGET_FS_REQ_DIR ${CMAKE_CURRENT_BINARY_DIR}/fs_req)
-file(MAKE_DIRECTORY ${TARGET_FS_REQ_DIR})
-add_executable(${TARGET_FS_REQ} ${TARGET_FS_REQ_SOURCES})
-target_include_directories(${TARGET_FS_REQ} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_FS_REQ} PRIVATE ${COMMON_LINK_LIBS})
-target_compile_definitions(${TARGET_FS_REQ} PRIVATE TARGET_FS_REQ_DIR="${TARGET_FS_REQ_DIR}")
-add_test(NAME ${TARGET_FS_REQ} COMMAND ${TARGET_FS_REQ})
-
-# Test TARGET_HANDLE
-
-set(TARGET_HANDLE_SOURCES $<TARGET_OBJECTS:odr> uvw/handle.cpp)
-add_executable(${TARGET_HANDLE} ${TARGET_HANDLE_SOURCES})
-target_include_directories(${TARGET_HANDLE} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_HANDLE} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_HANDLE} COMMAND ${TARGET_HANDLE})
-
-# Test TARGET_IDLE
-
-set(TARGET_IDLE_SOURCES $<TARGET_OBJECTS:odr> uvw/idle.cpp)
-add_executable(${TARGET_IDLE} ${TARGET_IDLE_SOURCES})
-target_include_directories(${TARGET_IDLE} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_IDLE} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_IDLE} COMMAND ${TARGET_IDLE})
-
-# Test TARGET_LIB
-
-set(TARGET_LIB_SOURCES $<TARGET_OBJECTS:odr> uvw/lib.cpp)
-add_executable(${TARGET_LIB} ${TARGET_LIB_SOURCES})
-target_include_directories(${TARGET_LIB} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_LIB} PRIVATE ${COMMON_LINK_LIBS} ${CMAKE_DL_LIBS})
-target_compile_definitions(${TARGET_LIB} PRIVATE TARGET_LIB_SO="${libuv_shared}")
-add_test(NAME ${TARGET_LIB} COMMAND ${TARGET_LIB})
-
-# Test TARGET_LOOP
-
-set(TARGET_LOOP_SOURCES $<TARGET_OBJECTS:odr> uvw/loop.cpp)
-add_executable(${TARGET_LOOP} ${TARGET_LOOP_SOURCES})
-target_include_directories(${TARGET_LOOP} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_LOOP} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_LOOP} COMMAND ${TARGET_LOOP})
-
-# Test TARGET_PIPE
-
-set(TARGET_PIPE_SOURCES $<TARGET_OBJECTS:odr> uvw/pipe.cpp)
-add_executable(${TARGET_PIPE} ${TARGET_PIPE_SOURCES})
-target_include_directories(${TARGET_PIPE} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_PIPE} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_PIPE} COMMAND ${TARGET_PIPE})
-
-# Test TARGET_POLL
-
-set(TARGET_POLL_SOURCES $<TARGET_OBJECTS:odr> uvw/poll.cpp)
-add_executable(${TARGET_POLL} ${TARGET_POLL_SOURCES})
-target_include_directories(${TARGET_POLL} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_POLL} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_POLL} COMMAND ${TARGET_POLL})
-
-# Test TARGET_PREPARE
-
-set(TARGET_PREPARE_SOURCES $<TARGET_OBJECTS:odr> uvw/prepare.cpp)
-add_executable(${TARGET_PREPARE} ${TARGET_PREPARE_SOURCES})
-target_include_directories(${TARGET_PREPARE} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_PREPARE} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_PREPARE} COMMAND ${TARGET_PREPARE})
-
-# Test TARGET_PROCESS
-
-set(TARGET_PROCESS_SOURCES $<TARGET_OBJECTS:odr> uvw/process.cpp)
-add_executable(${TARGET_PROCESS} ${TARGET_PROCESS_SOURCES})
-target_include_directories(${TARGET_PROCESS} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_PROCESS} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_PROCESS} COMMAND ${TARGET_PROCESS})
-
-# Test TARGET_REQUEST
-
-set(TARGET_REQUEST_SOURCES $<TARGET_OBJECTS:odr> uvw/request.cpp)
-add_executable(${TARGET_REQUEST} ${TARGET_REQUEST_SOURCES})
-target_include_directories(${TARGET_REQUEST} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_REQUEST} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_REQUEST} COMMAND ${TARGET_REQUEST})
-
-# Test TARGET_RESOURCE
-set(TARGET_RESOURCE_SOURCES $<TARGET_OBJECTS:odr> uvw/resource.cpp)
-add_executable(${TARGET_RESOURCE} ${TARGET_RESOURCE_SOURCES})
-target_include_directories(${TARGET_RESOURCE} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_RESOURCE} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_RESOURCE} COMMAND ${TARGET_RESOURCE})
-
-# Test TARGET_SIGNAL
-
-set(TARGET_SIGNAL_SOURCES $<TARGET_OBJECTS:odr> uvw/signal.cpp)
-add_executable(${TARGET_SIGNAL} ${TARGET_SIGNAL_SOURCES})
-target_include_directories(${TARGET_SIGNAL} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_SIGNAL} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_SIGNAL} COMMAND ${TARGET_SIGNAL})
-
-# Test TARGET_STREAM
-
-set(TARGET_STREAM_SOURCES $<TARGET_OBJECTS:odr> uvw/stream.cpp)
-add_executable(${TARGET_STREAM} ${TARGET_STREAM_SOURCES})
-target_include_directories(${TARGET_STREAM} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_STREAM} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_STREAM} COMMAND ${TARGET_STREAM})
-
-# Test TARGET_TCP
-
-set(TARGET_TCP_SOURCES $<TARGET_OBJECTS:odr> uvw/tcp.cpp)
-add_executable(${TARGET_TCP} ${TARGET_TCP_SOURCES})
-target_include_directories(${TARGET_TCP} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_TCP} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_TCP} COMMAND ${TARGET_TCP})
-
-# Test TARGET_THREAD
-
-set(TARGET_THREAD_SOURCES $<TARGET_OBJECTS:odr> uvw/thread.cpp)
-add_executable(${TARGET_THREAD} ${TARGET_THREAD_SOURCES})
-target_include_directories(${TARGET_THREAD} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_THREAD} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_THREAD} COMMAND ${TARGET_THREAD})
-
-# Test TARGET_TIMER
-
-set(TARGET_TIMER_SOURCES $<TARGET_OBJECTS:odr> uvw/timer.cpp)
-add_executable(${TARGET_TIMER} ${TARGET_TIMER_SOURCES})
-target_include_directories(${TARGET_TIMER} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_TIMER} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_TIMER} COMMAND ${TARGET_TIMER})
-
-# Test TARGET_TTY
-
-set(TARGET_TTY_SOURCES $<TARGET_OBJECTS:odr> uvw/tty.cpp)
-add_executable(${TARGET_TTY} ${TARGET_TTY_SOURCES})
-target_include_directories(${TARGET_TTY} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_TTY} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_TTY} COMMAND ${TARGET_TTY})
-
-# Test TARGET_UDP
-
-set(TARGET_UDP_SOURCES $<TARGET_OBJECTS:odr> uvw/udp.cpp)
-add_executable(${TARGET_UDP} ${TARGET_UDP_SOURCES})
-target_include_directories(${TARGET_UDP} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_UDP} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_UDP} COMMAND ${TARGET_UDP})
-
-# Test TARGET_UTIL
-
-set(TARGET_UTIL_SOURCES $<TARGET_OBJECTS:odr> uvw/util.cpp)
-add_executable(${TARGET_UTIL} ${TARGET_UTIL_SOURCES})
-target_include_directories(${TARGET_UTIL} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_UTIL} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_UTIL} COMMAND ${TARGET_UTIL})
-
-# Test TARGET_WORK
-
-set(TARGET_WORK_SOURCES $<TARGET_OBJECTS:odr> uvw/work.cpp)
-add_executable(${TARGET_WORK} ${TARGET_WORK_SOURCES})
-target_include_directories(${TARGET_WORK} PRIVATE ${UVW_SRC_DIR})
-target_link_libraries(${TARGET_WORK} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_WORK} COMMAND ${TARGET_WORK})

travis.sh

@@ -1,16 +0,0 @@
-#!/usr/bin/env bash
-
-USER_PATH_DIR=~/bin
-TEMP_DIR=~/.cmake
-mkdir -p ${USER_PATH_DIR}
-mkdir -p ${TEMP_DIR}
-
-if [ "$TRAVIS_OS_NAME" == "linux" ]; then
-    curl -s https://cmake.org/files/v3.8/cmake-3.8.2-Linux-x86_64.tar.gz | tar -xz -C ${TEMP_DIR}
-    ln -s ${TEMP_DIR}/cmake-3.8.2-Linux-x86_64/bin/cmake ${USER_PATH_DIR}
-fi
-
-if [ "$TRAVIS_OS_NAME" == "osx" ]; then
-    curl -s https://cmake.org/files/v3.8/cmake-3.8.2-Darwin-x86_64.tar.gz | tar -xz -C ${TEMP_DIR}
-    "${TEMP_DIR}/cmake-3.8.2-Darwin-x86_64/CMake.app/Contents/bin/cmake-gui" --install=${USER_PATH_DIR}
-fi