1 /* 2 Copyright (c) 2005-2021 Intel Corporation 3 4 Licensed under the Apache License, Version 2.0 (the "License"); 5 you may not use this file except in compliance with the License. 6 You may obtain a copy of the License at 7 8 http://www.apache.org/licenses/LICENSE-2.0 9 10 Unless required by applicable law or agreed to in writing, software 11 distributed under the License is distributed on an "AS IS" BASIS, 12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 See the License for the specific language governing permissions and 14 limitations under the License. 15 */ 16 17 // Message based key matching is a preview feature 18 #define TBB_PREVIEW_FLOW_GRAPH_FEATURES 1 19 #define MAX_TUPLE_TEST_SIZE 10 20 21 #include "common/config.h" 22 23 #include "test_join_node.h" 24 25 //! \file test_join_node_msg_key_matching.cpp 26 //! \brief Test for [preview] functionality 27 28 #if __TBB_PREVIEW_FLOW_GRAPH_NODE_SET 29 #include <array> 30 #include <vector> 31 void test_follows_and_precedes_api() { 32 using msg_t = MyMessageKeyWithoutKey<int, int>; 33 using JoinOutputType = std::tuple<msg_t, msg_t, msg_t>; 34 35 std::array<msg_t, 3> messages_for_follows = { {msg_t(), msg_t(), msg_t()} }; 36 std::vector<msg_t> messages_for_precedes = { msg_t(), msg_t(), msg_t() }; 37 38 follows_and_precedes_testing::test_follows 39 <msg_t, tbb::flow::join_node<JoinOutputType, tbb::flow::key_matching<std::size_t>>, tbb::flow::buffer_node<msg_t>> 40 (messages_for_follows); 41 follows_and_precedes_testing::test_precedes 42 <msg_t, tbb::flow::join_node<JoinOutputType, tbb::flow::key_matching<std::size_t>>> 43 (messages_for_precedes); 44 } 45 #endif 46 47 #if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT 48 struct message_key { 49 int my_key; 50 double my_value; 51 52 int key() const { return my_key; } 53 54 operator size_t() const { return my_key; } 55 56 bool operator==(const message_key& rhs) { return my_value == rhs.my_value; } 57 }; 58 59 void test_deduction_guides() { 60 using namespace tbb::flow; 61 using tuple_type = std::tuple<message_key, message_key>; 62 63 graph g; 64 broadcast_node<message_key> bm1(g), bm2(g); 65 broadcast_node<tuple_type> bm3(g); 66 join_node<tuple_type, key_matching<int> > j0(g); 67 join_node j3(j0); 68 static_assert(std::is_same_v<decltype(j3), join_node<tuple_type, key_matching<int>>>); 69 } 70 #endif 71 72 //! Serial test with matching policies 73 //! \brief \ref error_guessing 74 TEST_CASE("Serial test") { 75 generate_test<serial_test, std::tuple<MyMessageKeyWithBrokenKey<int, double>, MyMessageKeyWithoutKey<int, float> >, message_based_key_matching<int> >::do_test(); 76 generate_test<serial_test, std::tuple<MyMessageKeyWithoutKeyMethod<std::string, double>, MyMessageKeyWithBrokenKey<std::string, float> >, message_based_key_matching<std::string> >::do_test(); 77 } 78 79 template <typename T1, typename T2> 80 using make_tuple = decltype(std::tuple_cat(T1(), std::tuple<T2>())); 81 using T1 = std::tuple<MyMessageKeyWithoutKeyMethod<std::string, double>>; 82 using T2 = make_tuple<T1, MyMessageKeyWithBrokenKey<std::string, int>>; 83 using T3 = make_tuple < T2, MyMessageKeyWithoutKey<std::string, int>>; 84 using T4 = make_tuple < T3, MyMessageKeyWithoutKeyMethod<std::string, size_t>>; 85 using T5 = make_tuple < T4, MyMessageKeyWithBrokenKey<std::string, int>>; 86 using T6 = make_tuple < T5, MyMessageKeyWithoutKeyMethod<std::string, short>>; 87 using T7 = make_tuple < T6, MyMessageKeyWithoutKeyMethod<std::string, threebyte>>; 88 using T8 = make_tuple < T7, MyMessageKeyWithBrokenKey<std::string, int>>; 89 using T9 = make_tuple < T8, MyMessageKeyWithoutKeyMethod<std::string, threebyte>>; 90 using T10 = make_tuple < T9, MyMessageKeyWithBrokenKey<std::string, size_t>>; 91 92 //! Serial test with different tuple sizes 93 //! \brief \ref error_guessing 94 TEST_CASE_TEMPLATE("Serial N tests", T, T2, T3, T4, T5, T6, T7, T8, T9, T10) { 95 generate_test<serial_test, T, message_based_key_matching<std::string&> >::do_test(); 96 } 97 98 //! Parallel test with different tuple sizes 99 //! \brief \ref error_guessing 100 TEST_CASE_TEMPLATE("Parallel N tests", T, T2, T3, T4, T5, T6, T7, T8, T9, T10) { 101 generate_test<parallel_test, T, message_based_key_matching<std::string&> >::do_test(); 102 } 103 104 //! Parallel test with special key types 105 //! \brief \ref error_guessing 106 TEST_CASE("Parallel test"){ 107 generate_test<parallel_test, std::tuple<MyMessageKeyWithBrokenKey<int, double>, MyMessageKeyWithoutKey<int, float> >, message_based_key_matching<int> >::do_test(); 108 generate_test<parallel_test, std::tuple<MyMessageKeyWithoutKeyMethod<int, double>, MyMessageKeyWithBrokenKey<int, float> >, message_based_key_matching<int&> >::do_test(); 109 generate_test<parallel_test, std::tuple<MyMessageKeyWithoutKey<std::string, double>, MyMessageKeyWithoutKeyMethod<std::string, float> >, message_based_key_matching<std::string&> >::do_test(); 110 } 111 112 #if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT 113 //! Test deduction guides 114 //! \brief \ref requirement 115 TEST_CASE("Deduction guides test"){ 116 test_deduction_guides(); 117 } 118 #endif 119 120 //! Serial test with special key types 121 //! \brief \ref error_guessing 122 TEST_CASE("Serial test"){ 123 generate_test<serial_test, std::tuple<MyMessageKeyWithBrokenKey<int, double>, MyMessageKeyWithoutKey<int, float> >, message_based_key_matching<int> >::do_test(); 124 generate_test<serial_test, std::tuple<MyMessageKeyWithoutKeyMethod<std::string, double>, MyMessageKeyWithBrokenKey<std::string, float> >, message_based_key_matching<std::string> >::do_test(); 125 } 126