Test sort_by_key with custom struct values

Author: jszuppe

test/test_sort_by_key.cpp

@@ -15,6 +15,16 @@
 #include <boost/compute/algorithm/sort_by_key.hpp>
 #include <boost/compute/algorithm/is_sorted.hpp>
 #include <boost/compute/container/vector.hpp>
+#include <boost/compute/types/struct.hpp>
+
+struct custom_struct
+{
+    boost::compute::int_ x;
+    boost::compute::int_ y;
+    boost::compute::float2_ zw;
+};
+
+BOOST_COMPUTE_ADAPT_STRUCT(custom_struct, custom_struct, (x, y, zw))
 
 #include "check_macros.hpp"
 #include "context_setup.hpp"
@@ -69,15 +79,15 @@ BOOST_AUTO_TEST_CASE(sort_int_2)
 BOOST_AUTO_TEST_CASE(sort_char_by_int)
 {
     int keys_data[] = { 6, 2, 1, 3, 4, 7, 5, 0 };
-    char values_data[] = { 'g', 'c', 'b', 'd', 'e', 'h', 'f', 'a' };
+    compute::char_ values_data[] = { 'g', 'c', 'b', 'd', 'e', 'h', 'f', 'a' };
 
     compute::vector<int> keys(keys_data, keys_data + 8, queue);
-    compute::vector<char> values(values_data, values_data + 8, queue);
+    compute::vector<compute::char_> values(values_data, values_data + 8, queue);
 
     compute::sort_by_key(keys.begin(), keys.end(), values.begin(), queue);
 
     CHECK_RANGE_EQUAL(int, 8, keys, (0, 1, 2, 3, 4, 5, 6, 7));
-    CHECK_RANGE_EQUAL(char, 8, values, ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'));
+    CHECK_RANGE_EQUAL(compute::char_, 8, values, ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'));
 }
 
 BOOST_AUTO_TEST_CASE(sort_int_and_float)
@@ -132,4 +142,66 @@ BOOST_AUTO_TEST_CASE(sort_int_and_float_custom_comparison_func)
     BOOST_CHECK(compute::is_sorted(values.begin(), values.end(), queue) == true);
 }
 
+BOOST_AUTO_TEST_CASE(sort_int_and_float2)
+{
+    using boost::compute::int_;
+    using boost::compute::float2_;
+
+    int n = 1024;
+    std::vector<int_> host_keys(n);
+    std::vector<float2_> host_values(n);
+    for(int i = 0; i < n; i++){
+        host_keys[i] = n - i;
+        host_values[i] = float2_((n - i) / 2.f);
+    }
+
+    BOOST_COMPUTE_FUNCTION(bool, sort_float2, (float2_ a, float2_ b),
+    {
+        return a.x < b.x;
+    });
+
+    compute::vector<int_> keys(host_keys.begin(), host_keys.end(), queue);
+    compute::vector<float2_> values(host_values.begin(), host_values.end(), queue);
+
+    BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue) == false);
+    BOOST_CHECK(compute::is_sorted(values.begin(), values.end(), sort_float2, queue) == false);
+
+    compute::sort_by_key(keys.begin(), keys.end(), values.begin(), queue);
+
+    BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue) == true);
+    BOOST_CHECK(compute::is_sorted(values.begin(), values.end(), sort_float2, queue) == true);
+}
+
+BOOST_AUTO_TEST_CASE(sort_custom_struct_by_int)
+{
+    using boost::compute::int_;
+    using boost::compute::float2_;
+
+    int_ n = 1024;
+    std::vector<int_> host_keys(n);
+    std::vector<custom_struct> host_values(n);
+    for(int_ i = 0; i < n; i++){
+        host_keys[i] = n - i;
+        host_values[i].x = n - i;
+        host_values[i].y = n - i;
+        host_values[i].zw = float2_((n - i) / 0.5f);
+    }
+
+    BOOST_COMPUTE_FUNCTION(bool, sort_custom_struct, (custom_struct a, custom_struct b),
+    {
+        return a.x < b.x;
+    });
+
+    compute::vector<int_> keys(host_keys.begin(), host_keys.end(), queue);
+    compute::vector<custom_struct> values(host_values.begin(), host_values.end(), queue);
+
+    BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue) == false);
+    BOOST_CHECK(compute::is_sorted(values.begin(), values.end(), sort_custom_struct, queue) == false);
+
+    compute::sort_by_key(keys.begin(), keys.end(), values.begin(), queue);
+
+    BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue) == true);
+    BOOST_CHECK(compute::is_sorted(values.begin(), values.end(), sort_custom_struct, queue) == true);
+}
+
 BOOST_AUTO_TEST_SUITE_END()