Split connection tests

test/unit-test/CMakeLists.txt

@@ -4,7 +4,9 @@ add_executable(test-continuable
   ${CMAKE_SOURCE_DIR}/include/continuable/continuable-testing.hpp
   ${CMAKE_CURRENT_LIST_DIR}/test-continuable.hpp
   ${CMAKE_CURRENT_LIST_DIR}/test-continuable-base.cpp
-  ${CMAKE_CURRENT_LIST_DIR}/test-continuable-connection.cpp
+  ${CMAKE_CURRENT_LIST_DIR}/test-continuable-connection-all.cpp
+  ${CMAKE_CURRENT_LIST_DIR}/test-continuable-connection-any.cpp
+  ${CMAKE_CURRENT_LIST_DIR}/test-continuable-connection-seq.cpp
   ${CMAKE_CURRENT_LIST_DIR}/test-continuable-erasure.cpp
   ${CMAKE_CURRENT_LIST_DIR}/test-continuable-recursion.cpp)
 

test/unit-test/test-continuable-connection-all.cpp

@@ -0,0 +1,60 @@
+
+/**
+  Copyright(c) 2015 - 2017 Denis Blank <denis.blank at outlook dot com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files(the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions :
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+**/
+
+#include "test-continuable.hpp"
+
+TYPED_TEST(single_dimension_tests, is_logical_all_connectable) {
+
+  {
+    auto chain = this->supply() && this->supply();
+    EXPECT_ASYNC_RESULT(std::move(chain));
+  }
+
+  {
+    auto chain = this->supply(1) && this->supply(2);
+    EXPECT_ASYNC_RESULT(std::move(chain), 1, 2);
+  }
+
+  {
+    auto chain = this->supply(1, 2) && this->supply(3, 4, 5);
+    EXPECT_ASYNC_RESULT(std::move(chain), 1, 2, 3, 4, 5);
+  }
+
+  {
+    auto chain = cti::all_of(this->supply(1, 2), this->supply(3, 4));
+    EXPECT_ASYNC_RESULT(std::move(chain), 1, 2, 3, 4);
+  }
+
+  {
+    auto chain = this->supply(tag1{}) && this->supply(tag2{}, tag3{});
+    ASSERT_ASYNC_TYPES(std::move(chain), tag1, tag2, tag3);
+  }
+
+  {
+    // Check the evaluation order
+    unsigned i = 0;
+    auto composed =
+        make_step(this, i, 0) && make_step(this, i, 1) && make_step(this, i, 2);
+    EXPECT_ASYNC_RESULT(std::move(composed));
+  }
+}

test/unit-test/test-continuable-connection-any.cpp

@@ -0,0 +1,72 @@
+
+/**
+  Copyright(c) 2015 - 2017 Denis Blank <denis.blank at outlook dot com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files(the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions :
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+**/
+
+#include "test-continuable.hpp"
+
+TYPED_TEST(single_dimension_tests, is_logical_any_connectable) {
+
+  {
+    auto chain = this->supply() || this->supply();
+    EXPECT_ASYNC_RESULT(std::move(chain));
+  }
+
+  {
+    auto chain = this->supply(1) || this->supply(2);
+    EXPECT_ASYNC_RESULT(std::move(chain), 1);
+  }
+
+  {
+    auto chain = this->supply(1, 2) || this->supply(3, 4);
+    EXPECT_ASYNC_RESULT(std::move(chain), 1, 2);
+  }
+
+  {
+    auto chain = cti::any_of(this->supply(1), this->supply(2), this->supply(3));
+    EXPECT_ASYNC_RESULT(std::move(chain), 1);
+  }
+
+  {
+    auto chain = this->supply(tag1{}, tag2{}) || this->supply(tag1{}, tag2{});
+    ASSERT_ASYNC_TYPES(std::move(chain), tag1, tag2);
+  }
+
+  {
+    auto chain = this->supply(tag1{}, tag2{}, tag3{}) ||
+                 this->supply(tag1{}, tag2{}, tag3{});
+    ASSERT_ASYNC_TYPES(std::move(chain), tag1, tag2, tag3);
+  }
+
+  {
+    using common = std::common_type_t<char, int>;
+    auto chain = this->supply(char(0), int(0)) || this->supply(int(0), char(0));
+    ASSERT_ASYNC_TYPES(std::move(chain), common, common);
+  }
+
+  {
+    // Check the evaluation order
+    unsigned i = 0;
+    auto composed =
+        make_step(this, i, 0) || make_step(this, i, 1) || make_step(this, i, 2);
+    EXPECT_ASYNC_RESULT(std::move(composed));
+  }
+}

test/unit-test/test-continuable-connection-seq.cpp

@@ -23,97 +23,6 @@
 
 #include "test-continuable.hpp"
 
-template <typename T> auto make_step(T* me, unsigned& current, unsigned step) {
-  return me->invoke([=]() mutable {
-    ASSERT_EQ(step, current);
-    ++current;
-  });
-}
-
-TYPED_TEST(single_dimension_tests, is_logical_and_connectable) {
-
-  {
-    auto chain = this->supply() && this->supply();
-    EXPECT_ASYNC_RESULT(std::move(chain));
-  }
-
-  {
-    auto chain = this->supply(1) && this->supply(2);
-    EXPECT_ASYNC_RESULT(std::move(chain), 1, 2);
-  }
-
-  {
-    auto chain = this->supply(1, 2) && this->supply(3, 4, 5);
-    EXPECT_ASYNC_RESULT(std::move(chain), 1, 2, 3, 4, 5);
-  }
-
-  {
-    auto chain = cti::all_of(this->supply(1, 2), this->supply(3, 4));
-    EXPECT_ASYNC_RESULT(std::move(chain), 1, 2, 3, 4);
-  }
-
-  {
-    auto chain = this->supply(tag1{}) && this->supply(tag2{}, tag3{});
-    ASSERT_ASYNC_TYPES(std::move(chain), tag1, tag2, tag3);
-  }
-
-  {
-    // Check the evaluation order
-    unsigned i = 0;
-    auto composed =
-        make_step(this, i, 0) && make_step(this, i, 1) && make_step(this, i, 2);
-    EXPECT_ASYNC_RESULT(std::move(composed));
-  }
-}
-
-TYPED_TEST(single_dimension_tests, is_logical_or_connectable) {
-
-  {
-    auto chain = this->supply() || this->supply();
-    EXPECT_ASYNC_RESULT(std::move(chain));
-  }
-
-  {
-    auto chain = this->supply(1) || this->supply(2);
-    EXPECT_ASYNC_RESULT(std::move(chain), 1);
-  }
-
-  {
-    auto chain = this->supply(1, 2) || this->supply(3, 4);
-    EXPECT_ASYNC_RESULT(std::move(chain), 1, 2);
-  }
-
-  {
-    auto chain = cti::any_of(this->supply(1), this->supply(2), this->supply(3));
-    EXPECT_ASYNC_RESULT(std::move(chain), 1);
-  }
-
-  {
-    auto chain = this->supply(tag1{}, tag2{}) || this->supply(tag1{}, tag2{});
-    ASSERT_ASYNC_TYPES(std::move(chain), tag1, tag2);
-  }
-
-  {
-    auto chain = this->supply(tag1{}, tag2{}, tag3{}) ||
-                 this->supply(tag1{}, tag2{}, tag3{});
-    ASSERT_ASYNC_TYPES(std::move(chain), tag1, tag2, tag3);
-  }
-
-  {
-    using common = std::common_type_t<char, int>;
-    auto chain = this->supply(char(0), int(0)) || this->supply(int(0), char(0));
-    ASSERT_ASYNC_TYPES(std::move(chain), common, common);
-  }
-
-  {
-    // Check the evaluation order
-    unsigned i = 0;
-    auto composed =
-        make_step(this, i, 0) || make_step(this, i, 1) || make_step(this, i, 2);
-    EXPECT_ASYNC_RESULT(std::move(composed));
-  }
-}
-
 TYPED_TEST(single_dimension_tests, is_logical_seq_connectable) {
 
   {

test/unit-test/test-continuable.hpp

@@ -174,4 +174,11 @@ struct single_dimension_tests : continuation_provider<Provider> {};
 
 TYPED_TEST_CASE(single_dimension_tests, single_types);
 
+template <typename T> auto make_step(T* me, unsigned& current, unsigned step) {
+  return me->invoke([=]() mutable {
+    ASSERT_EQ(step, current);
+    ++current;
+  });
+}
+
 #endif // TEST_CONTINUABLE_HPP__