coffee/continuable
1
0
Fork 0
mirror of https://github.com/Naios/continuable.git synced 2026-02-08 02:36:40 +08:00
Code Issues Packages Projects Releases Wiki Activity

Basic implementation of the shared unit tests between all and seq

Browse Source
This commit is contained in:
Denis Blank 2018-03-09 05:12:09 +01:00
parent 7f76c55350
commit f43a730cbd
4 changed files with 44 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
test/unit-test/CMakeLists.txt
View File

@ -57,7 +57,8 @@ foreach(STEP RANGE 4)
target_include_directories(${PROJECT_NAME} target_include_directories(${PROJECT_NAME}
PUBLIC PUBLIC
${CMAKE_CURRENT_LIST_DIR}) ${CMAKE_CURRENT_LIST_DIR}
${CMAKE_CURRENT_LIST_DIR}/multi)
target_compile_definitions(${PROJECT_NAME} target_compile_definitions(${PROJECT_NAME}
PUBLIC PUBLIC

64
test/unit-test/multi/test-continuable-connection-all-seq.hpp
View File

@ -21,6 +21,9 @@
SOFTWARE. SOFTWARE.
**/ **/
#ifndef TEST_CONTINUABLE_CONNECTION_HPP__
#define TEST_CONTINUABLE_CONNECTION_HPP__
#include <test-continuable.hpp> #include <test-continuable.hpp>
template <typename Supplier, typename OperatorConnector> template <typename Supplier, typename OperatorConnector>
@ -49,64 +52,9 @@ void test_all_seq_op(Supplier&& supply, OperatorConnector&& op) {
template <typename Supplier, typename AggregateConnector> template <typename Supplier, typename AggregateConnector>
void test_all_seq_aggregate(Supplier&& supply, AggregateConnector&& ag) { void test_all_seq_aggregate(Supplier&& supply, AggregateConnector&& ag) {
{ {
auto chain = ag(supply(1, 2), supply(3, 4)); auto chain = ag(supply(1, 2), supply(3, 4), supply(5, 6));
EXPECT_ASYNC_RESULT(std::move(chain), 1, 2, 3, 4); EXPECT_ASYNC_RESULT(std::move(chain), 1, 2, 3, 4, 5, 6);
} }
} }
/*
TYPED_TEST(single_dimension_tests, is_logical_seq_connectable) { #endif // TEST_CONTINUABLE_CONNECTION_HPP__
auto chain = this->supply() >> this->supply();
EXPECT_ASYNC_RESULT(std::move(chain));
}
TYPED_TEST(single_dimension_tests, is_logical_seq_connectable_value) {
auto chain = this->supply(1) >> this->supply(2);
EXPECT_ASYNC_RESULT(std::move(chain), 1, 2);
}
TYPED_TEST(single_dimension_tests, is_logical_seq_connectable_when_seq) {
auto chain = cti::when_seq(this->supply(1), this->supply(2), this->supply(3));
EXPECT_ASYNC_RESULT(std::move(chain), 1, 2, 3);
}
TYPED_TEST(single_dimension_tests, is_logical_seq_connectable_duplicated_val) {
auto chain = this->supply(1, 2) >> this->supply(3, 4);
EXPECT_ASYNC_RESULT(std::move(chain), 1, 2, 3, 4);
}
TYPED_TEST(single_dimension_tests, is_logical_seq_connectable_tag) {
auto chain = this->supply(tag1{}, tag2{}) >> this->supply(tag1{}, tag2{});
ASSERT_ASYNC_TYPES(std::move(chain), tag1, tag2, tag1, tag2);
}
TYPED_TEST(single_dimension_tests, is_logical_seq_connectable_three_tags) {
auto chain = this->supply(tag1{}, tag2{}, tag3{}) >>
this->supply(tag1{}, tag2{}, tag3{});
ASSERT_ASYNC_TYPES(std::move(chain), tag1, tag2, tag3, tag1, tag2, tag3);
}
TYPED_TEST(single_dimension_tests, is_logical_seq_connectable_composed) {
// 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_chars) {
auto chain = this->supply('a') >> this->supply('b') >> this->supply('c');
EXPECT_ASYNC_RESULT(std::move(chain), 'a', 'b', 'c');
}
*/
TYPED_TEST(single_dimension_tests, is_logical_all_connectable) {
{
// 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));
}
}

91
test/unit-test/multi/test-continuable-connection-all.cpp
View File

@ -21,84 +21,29 @@
SOFTWARE. SOFTWARE.
**/ **/
#include <test-continuable-connection-all-seq.hpp>
#include <test-continuable.hpp> #include <test-continuable.hpp>
template <typename Supplier, typename OperatorConnector> TYPED_TEST(single_dimension_tests, is_op_all_connectable) {
void test_all_seq_op(Supplier&& supply, OperatorConnector&& op) { test_all_seq_op(
{ [this](auto&&... args) {
auto chain = op(supply(), supply()); return this->supply(std::forward<decltype(args)>(args)...);
EXPECT_ASYNC_RESULT(std::move(chain)); },
} [](auto&& left, auto&& right) {
return std::forward<decltype(left)>(left) &&
{ std::forward<decltype(right)>(right);
auto chain = op(supply(1), supply(2)); });
EXPECT_ASYNC_RESULT(std::move(chain), 1, 2);
}
{
auto chain = op(supply(1, 2), supply(3, 4, 5));
EXPECT_ASYNC_RESULT(std::move(chain), 1, 2, 3, 4, 5);
}
{
auto chain = op(supply(tag1{}), supply(tag2{}, tag3{}));
ASSERT_ASYNC_TYPES(std::move(chain), tag1, tag2, tag3);
}
} }
template <typename Supplier, typename AggregateConnector> TYPED_TEST(single_dimension_tests, is_aggregate_all_connectable) {
void test_all_seq_aggregate(Supplier&& supply, AggregateConnector&& ag) { test_all_seq_aggregate(
{ [this](auto&&... args) {
auto chain = ag(supply(1, 2), supply(3, 4)); return this->supply(std::forward<decltype(args)>(args)...);
EXPECT_ASYNC_RESULT(std::move(chain), 1, 2, 3, 4); },
} [](auto&&... args) {
return cti::when_all(std::forward<decltype(args)>(args)...);
});
} }
/*
TYPED_TEST(single_dimension_tests, is_logical_seq_connectable) {
auto chain = this->supply() >> this->supply();
EXPECT_ASYNC_RESULT(std::move(chain));
}
TYPED_TEST(single_dimension_tests, is_logical_seq_connectable_value) {
auto chain = this->supply(1) >> this->supply(2);
EXPECT_ASYNC_RESULT(std::move(chain), 1, 2);
}
TYPED_TEST(single_dimension_tests, is_logical_seq_connectable_when_seq) {
auto chain = cti::when_seq(this->supply(1), this->supply(2), this->supply(3));
EXPECT_ASYNC_RESULT(std::move(chain), 1, 2, 3);
}
TYPED_TEST(single_dimension_tests, is_logical_seq_connectable_duplicated_val) {
auto chain = this->supply(1, 2) >> this->supply(3, 4);
EXPECT_ASYNC_RESULT(std::move(chain), 1, 2, 3, 4);
}
TYPED_TEST(single_dimension_tests, is_logical_seq_connectable_tag) {
auto chain = this->supply(tag1{}, tag2{}) >> this->supply(tag1{}, tag2{});
ASSERT_ASYNC_TYPES(std::move(chain), tag1, tag2, tag1, tag2);
}
TYPED_TEST(single_dimension_tests, is_logical_seq_connectable_three_tags) {
auto chain = this->supply(tag1{}, tag2{}, tag3{}) >>
this->supply(tag1{}, tag2{}, tag3{});
ASSERT_ASYNC_TYPES(std::move(chain), tag1, tag2, tag3, tag1, tag2, tag3);
}
TYPED_TEST(single_dimension_tests, is_logical_seq_connectable_composed) {
// 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_chars) {
auto chain = this->supply('a') >> this->supply('b') >> this->supply('c');
EXPECT_ASYNC_RESULT(std::move(chain), 'a', 'b', 'c');
}
*/
TYPED_TEST(single_dimension_tests, is_logical_all_connectable) { TYPED_TEST(single_dimension_tests, is_logical_all_connectable) {

45
test/unit-test/multi/test-continuable-connection-seq.cpp
View File

@ -21,37 +21,28 @@
SOFTWARE. SOFTWARE.
**/ **/
#include <test-continuable-connection-all-seq.hpp>
#include <test-continuable.hpp> #include <test-continuable.hpp>
TYPED_TEST(single_dimension_tests, is_logical_seq_connectable) { TYPED_TEST(single_dimension_tests, is_op_seq_connectable) {
auto chain = this->supply() >> this->supply(); test_all_seq_op(
EXPECT_ASYNC_RESULT(std::move(chain)); [this](auto&&... args) {
return this->supply(std::forward<decltype(args)>(args)...);
},
[](auto&& left, auto&& right) {
return std::forward<decltype(left)>(left) >>
std::forward<decltype(right)>(right);
});
} }
TYPED_TEST(single_dimension_tests, is_logical_seq_connectable_value) { TYPED_TEST(single_dimension_tests, is_aggregate_seq_connectable) {
auto chain = this->supply(1) >> this->supply(2); test_all_seq_aggregate(
EXPECT_ASYNC_RESULT(std::move(chain), 1, 2); [this](auto&&... args) {
} return this->supply(std::forward<decltype(args)>(args)...);
},
TYPED_TEST(single_dimension_tests, is_logical_seq_connectable_when_seq) { [](auto&&... args) {
auto chain = cti::when_seq(this->supply(1), this->supply(2), this->supply(3)); return cti::when_seq(std::forward<decltype(args)>(args)...);
EXPECT_ASYNC_RESULT(std::move(chain), 1, 2, 3); });
}
TYPED_TEST(single_dimension_tests, is_logical_seq_connectable_duplicated_val) {
auto chain = this->supply(1, 2) >> this->supply(3, 4);
EXPECT_ASYNC_RESULT(std::move(chain), 1, 2, 3, 4);
}
TYPED_TEST(single_dimension_tests, is_logical_seq_connectable_tag) {
auto chain = this->supply(tag1{}, tag2{}) >> this->supply(tag1{}, tag2{});
ASSERT_ASYNC_TYPES(std::move(chain), tag1, tag2, tag1, tag2);
}
TYPED_TEST(single_dimension_tests, is_logical_seq_connectable_three_tags) {
auto chain = this->supply(tag1{}, tag2{}, tag3{}) >>
this->supply(tag1{}, tag2{}, tag3{});
ASSERT_ASYNC_TYPES(std::move(chain), tag1, tag2, tag3, tag1, tag2, tag3);
} }
TYPED_TEST(single_dimension_tests, is_logical_seq_connectable_composed) { TYPED_TEST(single_dimension_tests, is_logical_seq_connectable_composed) {