Add CMakeLists.txt for tests, resolve some gcc and clang warnings

CMakeLists.txt

@@ -23,6 +23,8 @@ target_link_libraries(boost_sort
 
 if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
 
+  include(CTest)
+  enable_testing()
   add_subdirectory(test)
 
 endif()

include/boost/sort/spreadsort/detail/float_sort.hpp

@@ -775,7 +775,7 @@ namespace spreadsort {
     inline typename boost::disable_if_c< sizeof(boost::uintmax_t) >=
       sizeof(Div_type), void >::type
     float_sort(RandomAccessIter first, RandomAccessIter last, Div_type,
-               Right_shift rshift)
+               Right_shift /* rshift */)
     {
       boost::sort::pdqsort(first, last);
     }
@@ -816,7 +816,7 @@ namespace spreadsort {
     inline typename boost::disable_if_c< sizeof(boost::uintmax_t) >=
       sizeof(Div_type), void >::type
     float_sort(RandomAccessIter first, RandomAccessIter last, Div_type,
-               Right_shift rshift, Compare comp)
+               Right_shift /* rshift */, Compare comp)
     {
       boost::sort::pdqsort(first, last, comp);
     }

include/boost/sort/spreadsort/detail/integer_sort.hpp

@@ -433,7 +433,7 @@ namespace spreadsort {
       || sizeof(Div_type) <= sizeof(boost::uintmax_t), void >::type
     //defaulting to boost::sort::pdqsort when integer_sort won't work
     integer_sort(RandomAccessIter first, RandomAccessIter last, Div_type,
-                Right_shift shift, Compare comp)
+                Right_shift /* shift */, Compare comp)
     {
       boost::sort::pdqsort(first, last, comp);
     }
@@ -475,7 +475,7 @@ namespace spreadsort {
       || sizeof(Div_type) <= sizeof(boost::uintmax_t), void >::type
     //defaulting to boost::sort::pdqsort when integer_sort won't work
     integer_sort(RandomAccessIter first, RandomAccessIter last, Div_type,
-                Right_shift shift)
+                Right_shift /* shift */)
     {
       boost::sort::pdqsort(first, last);
     }

include/boost/sort/spreadsort/detail/string_sort.hpp

@@ -747,7 +747,7 @@ namespace spreadsort {
     inline typename boost::disable_if_c< sizeof(Unsigned_char_type) <= 2, void
                                                                        >::type
     string_sort(RandomAccessIter first, RandomAccessIter last,
-                Get_char get_character, Get_length length, Unsigned_char_type)
+                Get_char /* get_character */, Get_length /* length */, Unsigned_char_type)
     {
       // Use boost::sort::pdqsort if the char_type is too large for string_sort.
       boost::sort::pdqsort(first, last);
@@ -774,7 +774,7 @@ namespace spreadsort {
     inline typename boost::enable_if_c< (sizeof(Unsigned_char_type) > 2), void
                                         >::type
     string_sort(RandomAccessIter first, RandomAccessIter last,
-        Get_char get_character, Get_length length, Compare comp, Unsigned_char_type)
+        Get_char /* get_character */, Get_length /* length */, Compare comp, Unsigned_char_type)
     {
       // Use boost::sort::pdqsort if the char_type is too large for string_sort.
       boost::sort::pdqsort(first, last, comp);
@@ -800,7 +800,7 @@ namespace spreadsort {
     inline typename boost::disable_if_c< sizeof(Unsigned_char_type) <= 2, void
                                                                        >::type
     reverse_string_sort(RandomAccessIter first, RandomAccessIter last,
-        Get_char get_character, Get_length length, Compare comp, Unsigned_char_type)
+        Get_char /* get_character */, Get_length /* length */, Compare comp, Unsigned_char_type)
     {
       // Use boost::sort::pdqsort if the char_type is too large for string_sort.
       boost::sort::pdqsort(first, last, comp);

test/CMakeLists.txt

@@ -0,0 +1,60 @@
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+  # warning level 4
+  add_compile_options(/W4)
+endif()
+
+if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  add_compile_options(-Wall -Wextra -Wpedantic)
+endif()
+
+if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+  add_compile_options(-Wall -Wextra -Wpedantic)
+endif()
+
+add_executable(float_sort_test float_sort_test.cpp)
+target_include_directories(float_sort_test PRIVATE ../include)
+add_test(NAME float_sort_test COMMAND $<TARGET_FILE:float_sort_test>)
+
+add_executable(integer_sort_test integer_sort_test.cpp)
+target_include_directories(integer_sort_test PRIVATE ../include)
+add_test(NAME integer_sort_test COMMAND $<TARGET_FILE:integer_sort_test>)
+
+add_executable(sort_detail_test sort_detail_test.cpp)
+target_include_directories(sort_detail_test PRIVATE ../include)
+add_test(NAME sort_detail_test COMMAND $<TARGET_FILE:sort_detail_test>)
+
+add_executable(string_sort_test string_sort_test.cpp)
+target_include_directories(string_sort_test PRIVATE ../include)
+add_test(NAME string_sort_test COMMAND $<TARGET_FILE:string_sort_test>)
+
+add_executable(test_block_indirect_sort test_block_indirect_sort.cpp)
+target_include_directories(test_block_indirect_sort PRIVATE ../include)
+add_test(NAME test_block_indirect_sort COMMAND $<TARGET_FILE:test_block_indirect_sort>)
+
+add_executable(test_flat_stable_sort test_flat_stable_sort.cpp)
+target_include_directories(test_flat_stable_sort PRIVATE ../include)
+add_test(NAME test_flat_stable_sort COMMAND $<TARGET_FILE:test_flat_stable_sort>)
+
+add_executable(test_insert_sort test_insert_sort.cpp)
+target_include_directories(test_insert_sort PRIVATE ../include)
+add_test(NAME test_insert_sort COMMAND $<TARGET_FILE:test_insert_sort>)
+
+add_executable(test_parallel_stable_sort test_parallel_stable_sort.cpp)
+target_include_directories(test_parallel_stable_sort PRIVATE ../include)
+add_test(NAME test_parallel_stable_sort COMMAND $<TARGET_FILE:test_parallel_stable_sort>)
+
+add_executable(test_pdqsort test_pdqsort.cpp)
+target_include_directories(test_pdqsort PRIVATE ../include)
+add_test(NAME test_pdqsort COMMAND $<TARGET_FILE:test_pdqsort>)
+
+add_executable(test_sample_sort test_sample_sort.cpp)
+target_include_directories(test_sample_sort PRIVATE ../include)
+add_test(NAME test_sample_sort COMMAND $<TARGET_FILE:test_sample_sort>)
+
+add_executable(test_spinsort test_spinsort.cpp)
+target_include_directories(test_spinsort PRIVATE ../include)
+add_test(NAME test_spinsort COMMAND $<TARGET_FILE:test_spinsort>)

test/sort_detail_test.cpp

@@ -70,7 +70,7 @@ void get_min_count_test()
 {
   const unsigned min_log_size = log_mean_bin_size + log_min_split_count;
   size_t prev_min_count = absolute_min_count;
-  for (int log_range = 0; log_range <= max_int_bits; ++log_range) {
+  for (unsigned log_range = 0; log_range <= max_int_bits; ++log_range) {
     size_t min_count = get_min_count<log_mean_bin_size, log_min_split_count, 
                                      log_finishing_count>(log_range);
     BOOST_CHECK(min_count >= prev_min_count);
@@ -83,7 +83,7 @@ void get_min_count_test()
       int iterations = rough_log_2_size(min_count) - min_log_size;
       BOOST_CHECK(iterations >= 1);
       int base_iterations = max_splits - log_min_split_count;
-      int covered_log_range = 0;
+      unsigned covered_log_range = 0;
       if (iterations > base_iterations) {
         covered_log_range += max_splits * (iterations - base_iterations);
       } else {

test/test_pdqsort.cpp

@@ -52,19 +52,19 @@ std::vector<uint32_t> shuffled_16_values(size_t size, std::mt19937_64& rng) {
     return v;
 }
 
-std::vector<uint32_t> all_equal(size_t size, std::mt19937_64& rng) {
+std::vector<uint32_t> all_equal(size_t size, std::mt19937_64&) {
     std::vector<uint32_t> v; v.reserve(size);
     for (uint32_t i = 0; i < size; ++i) v.push_back(0);
     return v;
 }
 
-std::vector<uint32_t> ascending(size_t size, std::mt19937_64& rng) {
+std::vector<uint32_t> ascending(size_t size, std::mt19937_64&) {
     std::vector<uint32_t> v; v.reserve(size);
     for (uint32_t i = 0; i < size; ++i) v.push_back(i);
     return v;
 }
 
-std::vector<uint32_t> descending(size_t size, std::mt19937_64& rng) {
+std::vector<uint32_t> descending(size_t size, std::mt19937_64&) {
     std::vector<uint32_t> v; v.reserve(size);
     for (uint32_t i = size - 1; ; --i) {
         v.push_back(i);
@@ -73,21 +73,21 @@ std::vector<uint32_t> descending(size_t size, std::mt19937_64& rng) {
     return v;
 }
 
-std::vector<uint32_t> pipe_organ(size_t size, std::mt19937_64& rng) {
+std::vector<uint32_t> pipe_organ(size_t size, std::mt19937_64&) {
     std::vector<uint32_t> v; v.reserve(size);
     for (uint32_t i = 0; i < size/2; ++i) v.push_back(i);
     for (uint32_t i = size/2; i < size; ++i) v.push_back(size - i);
     return v;
 }
 
-std::vector<uint32_t> push_front(size_t size, std::mt19937_64& rng) {
+std::vector<uint32_t> push_front(size_t size, std::mt19937_64&) {
     std::vector<uint32_t> v; v.reserve(size);
     for (uint32_t i = 1; i < size; ++i) v.push_back(i);
     v.push_back(0);
     return v;
 }
 
-std::vector<uint32_t> push_middle(size_t size, std::mt19937_64& rng) {
+std::vector<uint32_t> push_middle(size_t size, std::mt19937_64&) {
     std::vector<uint32_t> v; v.reserve(size);
     for (uint32_t i = 0; i < size; ++i) {
         if (i != size/2) v.push_back(i);