#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

#include <doctest.h>

#include <taskflow/taskflow.hpp>

#include <vector>

#include <utility>

#include <chrono>

#include <limits.h>

TEST_CASE("Builder" * doctest::timeout(300)) {

const size_t num_tasks = 100;

tf::Taskflow taskflow;

tf::Executor executor;

std::atomic<int> counter {0};

std::vector<tf::Task> silent_tasks;

std::vector<tf::Task> tasks;

SUBCASE("EmptyFlow") {

for(unsigned W=1; W<32; ++W) {

tf::Executor executor(W);

tf::Taskflow taskflow;

REQUIRE(taskflow.num_tasks() == 0);

REQUIRE(taskflow.empty() == true);

executor.run(taskflow).wait();

}

}

SUBCASE("Placeholder") {

for(size_t i=0; i<num_tasks; ++i) {

silent_tasks.emplace_back(taskflow.placeholder().name(std::to_string(i)));

}

for(size_t i=0; i<num_tasks; ++i) {

REQUIRE(silent_tasks[i].name() == std::to_string(i));

REQUIRE(silent_tasks[i].num_dependents() == 0);

REQUIRE(silent_tasks[i].num_successors() == 0);

}

for(auto& task : silent_tasks) {

task.work([&counter](){ counter++; });

}

executor.run(taskflow).get();

REQUIRE(counter == num_tasks);

}

SUBCASE("EmbarrassinglyParallel"){

for(size_t i=0;i<num_tasks;i++) {

tasks.emplace_back(taskflow.emplace([&counter]() {counter += 1;}));

}

REQUIRE(taskflow.num_tasks() == num_tasks);

executor.run(taskflow).get();

REQUIRE(counter == num_tasks);

REQUIRE(taskflow.num_tasks() == 100);

counter = 0;

for(size_t i=0;i<num_tasks;i++){

silent_tasks.emplace_back(taskflow.emplace([&counter]() {counter += 1;}));

}

REQUIRE(taskflow.num_tasks() == num_tasks * 2);

executor.run(taskflow).get();

REQUIRE(counter == num_tasks * 2);

REQUIRE(taskflow.num_tasks() == 200);

}

SUBCASE("BinarySequence"){

for(size_t i=0;i<num_tasks;i++){

if(i%2 == 0){

tasks.emplace_back(

taskflow.emplace([&counter]() { REQUIRE(counter == 0); counter += 1;})

);

}

else{

tasks.emplace_back(

taskflow.emplace([&counter]() { REQUIRE(counter == 1); counter -= 1;})

);

}

if(i>0){

//tasks[i-1].first.precede(tasks[i].first);

tasks[i-1].precede(tasks[i]);

}

if(i==0) {

//REQUIRE(tasks[i].first.num_dependents() == 0);

REQUIRE(tasks[i].num_dependents() == 0);

}

else {

//REQUIRE(tasks[i].first.num_dependents() == 1);

REQUIRE(tasks[i].num_dependents() == 1);

}

}

executor.run(taskflow).get();

}

SUBCASE("LinearCounter"){

for(size_t i=0;i<num_tasks;i++){

tasks.emplace_back(

taskflow.emplace([&counter, i]() {

REQUIRE(counter == i); counter += 1;}

)

);

if(i>0){

taskflow.precede(tasks[i-1], tasks[i]);

}

}

executor.run(taskflow).get();

REQUIRE(counter == num_tasks);

REQUIRE(taskflow.num_tasks() == num_tasks);

}

SUBCASE("Broadcast"){

auto src = taskflow.emplace([&counter]() {counter -= 1;});

for(size_t i=1; i<num_tasks; i++){

silent_tasks.emplace_back(

taskflow.emplace([&counter]() {REQUIRE(counter == -1);})

);

}

taskflow.broadcast(src, silent_tasks);

executor.run(taskflow).get();

REQUIRE(counter == - 1);

REQUIRE(taskflow.num_tasks() == num_tasks);

}

SUBCASE("Succeed"){

auto dst = taskflow.emplace([&]() { REQUIRE(counter == num_tasks - 1);});

for(size_t i=1;i<num_tasks;i++){

silent_tasks.emplace_back(

taskflow.emplace([&counter]() {counter += 1;})

);

}

taskflow.gather(silent_tasks, dst);

executor.run(taskflow).get();

REQUIRE(counter == num_tasks - 1);

REQUIRE(taskflow.num_tasks() == num_tasks);

}

SUBCASE("MapReduce"){

auto src = taskflow.emplace([&counter]() {counter = 0;});

for(size_t i=0;i<num_tasks;i++){

silent_tasks.emplace_back(

taskflow.emplace([&counter]() {counter += 1;})

);

}

taskflow.broadcast(src, silent_tasks);

auto dst = taskflow.emplace(

[&counter, num_tasks]() { REQUIRE(counter == num_tasks);}

);

taskflow.gather(silent_tasks, dst);

executor.run(taskflow).get();

REQUIRE(taskflow.num_tasks() == num_tasks + 2);

}

SUBCASE("Linearize"){

for(size_t i=0;i<num_tasks;i++){

silent_tasks.emplace_back(

taskflow.emplace([&counter, i]() {

REQUIRE(counter == i); counter += 1;}

)

);

}

taskflow.linearize(silent_tasks);

executor.run(taskflow).get();

REQUIRE(counter == num_tasks);

REQUIRE(taskflow.num_tasks() == num_tasks);

}

SUBCASE("Kite"){

auto src = taskflow.emplace([&counter]() {counter = 0;});

for(size_t i=0;i<num_tasks;i++){

silent_tasks.emplace_back(

taskflow.emplace([&counter, i]() {

REQUIRE(counter == i); counter += 1; }

)

);

}

taskflow.broadcast(src, silent_tasks);

taskflow.linearize(silent_tasks);

auto dst = taskflow.emplace(

[&counter, num_tasks]() { REQUIRE(counter == num_tasks);}

);

taskflow.gather(silent_tasks, dst);

executor.run(taskflow).get();

REQUIRE(taskflow.num_tasks() == num_tasks + 2);

}

}

TEST_CASE("Creation" * doctest::timeout(300)) {

std::vector<int> dummy(1000, -1);

auto create_taskflow = [&] () {

for(int i=0; i<10; ++i) {

tf::Taskflow tf;

tf.parallel_for(dummy.begin(), dummy.end(), [] (int) {});

}

};

SUBCASE("One") {

create_taskflow();

REQUIRE(dummy.size() == 1000);

for(auto item : dummy) {

REQUIRE(item == -1);

}

}

SUBCASE("Two") {

std::thread t1(create_taskflow);

std::thread t2(create_taskflow);

t1.join();

t2.join();

REQUIRE(dummy.size() == 1000);

for(auto item : dummy) {

REQUIRE(item == -1);

}

}

SUBCASE("Four") {

std::thread t1(create_taskflow);

std::thread t2(create_taskflow);

std::thread t3(create_taskflow);

std::thread t4(create_taskflow);

t1.join();

t2.join();

t3.join();

t4.join();

REQUIRE(dummy.size() == 1000);

for(auto item : dummy) {

REQUIRE(item == -1);

}

}

}

TEST_CASE("Iterators" * doctest::timeout(300)) {

SUBCASE("Order") {

tf::Taskflow taskflow;

auto A = taskflow.emplace([](){}).name("A");

auto B = taskflow.emplace([](){}).name("B");

auto C = taskflow.emplace([](){}).name("C");

auto D = taskflow.emplace([](){}).name("D");

auto E = taskflow.emplace([](){}).name("E");

A.precede(B, C, D, E);

E.succeed(B, C, D);

A.for_each_successor([&, i=0] (tf::Task s) mutable {

switch(i++) {

case 0:

REQUIRE(s == B);

break;

case 1:

REQUIRE(s == C);

break;

case 2:

REQUIRE(s == D);

break;

case 3:

REQUIRE(s == E);

break;

default:

break;

}

});

E.for_each_dependent([&, i=0](tf::Task s) mutable {

switch(i++) {

case 0:

REQUIRE(s == A);

break;

case 1:

REQUIRE(s == B);

break;

case 2:

REQUIRE(s == C);

break;

case 3:

REQUIRE(s == D);

break;

}

});

}

SUBCASE("Generic") {

tf::Taskflow taskflow;

auto A = taskflow.emplace([](){}).name("A");

auto B = taskflow.emplace([](){}).name("B");

auto C = taskflow.emplace([](){}).name("C");

auto D = taskflow.emplace([](){}).name("D");

auto E = taskflow.emplace([](){}).name("E");

std::vector<tf::Task> tasks;

taskflow.for_each_task([&tasks](tf::Task s){

tasks.push_back(s);

});

REQUIRE(std::find(tasks.begin(), tasks.end(), A) != tasks.end());

A.precede(B);

A.for_each_successor([B](tf::Task s){ REQUIRE(s==B); });

B.for_each_dependent([A](tf::Task s){ REQUIRE(s==A); });

A.precede(C);

A.precede(D);

A.precede(E);

C.precede(B);

D.precede(B);

E.precede(B);

int counter{0}, a{0}, b{0}, c{0}, d{0}, e{0};

A.for_each_successor([&](tf::Task s) {

counter++;

if(s == A) ++a;

if(s == B) ++b;

if(s == C) ++c;

if(s == D) ++d;

if(s == E) ++e;

});

REQUIRE(counter == A.num_successors());

REQUIRE(a==0);

REQUIRE(b==1);

REQUIRE(c==1);

REQUIRE(d==1);

REQUIRE(e==1);

counter = a = b = c = d = e = 0;

B.for_each_dependent([&](tf::Task s) {

counter++;

if(s == A) ++a;

if(s == B) ++b;

if(s == C) ++c;

if(s == D) ++d;

if(s == E) ++e;

});

REQUIRE(counter == B.num_dependents());

REQUIRE(a == 1);

REQUIRE(b == 0);

REQUIRE(c == 1);

REQUIRE(d == 1);

REQUIRE(e == 1);

A.for_each_successor([](tf::Task s){

s.name("A");

});

REQUIRE(A.name() == "A");

REQUIRE(B.name() == "A");

REQUIRE(C.name() == "A");

REQUIRE(D.name() == "A");

REQUIRE(E.name() == "A");

B.for_each_dependent([](tf::Task s){

s.name("B");

});

REQUIRE(A.name() == "B");

REQUIRE(B.name() == "A");

REQUIRE(C.name() == "B");

REQUIRE(D.name() == "B");

REQUIRE(E.name() == "B");

}

}

TEST_CASE("SequentialRuns" * doctest::timeout(300)) {

using namespace std::chrono_literals;

size_t num_tasks = 100;

tf::Executor executor(4);

tf::Taskflow taskflow;

std::atomic<int> counter {0};

std::vector<tf::Task> silent_tasks;

for(size_t i=0;i<num_tasks;i++){

silent_tasks.emplace_back(

taskflow.emplace([&counter]() {counter += 1;})

);

}

SUBCASE("RunOnce"){

auto fu = executor.run(taskflow);

REQUIRE(taskflow.num_tasks() == num_tasks);

fu.get();

REQUIRE(counter == num_tasks);

}

SUBCASE("WaitForAll") {

executor.run(taskflow);

executor.wait_for_all();

REQUIRE(counter == num_tasks);

}

SUBCASE("RunWithFuture") {

// Empty subflow test

for(unsigned W=1; W<=4; ++W) {

std::atomic<size_t> count {0};

tf::Taskflow f;

auto A = f.emplace([&](){ count ++; });

auto B = f.emplace([&](auto& subflow){

count ++;

auto B1 = subflow.emplace([&](){ count++; });

auto B2 = subflow.emplace([&](){ count++; });

auto B3 = subflow.emplace([&](){ count++; });

B1.precede(B3); B2.precede(B3);

});

auto C = f.emplace([&](){ count ++; });

auto D = f.emplace([&](){ count ++; });

A.precede(B, C);

B.precede(D);

C.precede(D);

tf::Executor executor(W);

std::list<std::future<void>> fu_list;

for(size_t i=0; i<500; i++) {

if(i == 499) {

executor.run(f).get(); // Synchronize the first 500 runs

executor.run_n(f, 500); // Run 500 times more

}

else if(i % 2) {

fu_list.push_back(executor.run(f));

}

else {

fu_list.push_back(executor.run(f, [&, i=i](){

REQUIRE(count == (i+1)*7); })

);

}

}

executor.wait_for_all();

for(auto& fu: fu_list) {

REQUIRE(fu.valid());

REQUIRE(fu.wait_for(std::chrono::seconds(1)) == std::future_status::ready);

}

REQUIRE(count == 7000);

}

}

SUBCASE("RunWithChange") {

// test correctness when taskflow got changed between runs

for(unsigned W=1; W<=4; ++W) {

std::atomic<size_t> count {0};

tf::Taskflow f;

auto A = f.emplace([&](){ count ++; });

auto B = f.emplace([&](auto& subflow){

count ++;

auto B1 = subflow.emplace([&](){ count++; });

auto B2 = subflow.emplace([&](){ count++; });

auto B3 = subflow.emplace([&](){ count++; });

B1.precede(B3); B2.precede(B3);

});

auto C = f.emplace([&](){ count ++; });

auto D = f.emplace([&](){ count ++; });

A.precede(B, C);

B.precede(D);

C.precede(D);

tf::Executor executor(W);

executor.run_n(f, 10).get();

REQUIRE(count == 70);

auto E = f.emplace([](){});

D.precede(E);

executor.run_n(f, 10).get();

REQUIRE(count == 140);

auto F = f.emplace([](){});

E.precede(F);

executor.run_n(f, 10);

executor.wait_for_all();

REQUIRE(count == 210);

}

}

SUBCASE("RunWithPred") {

// Test run_until

for(unsigned W=1; W<=4; ++W) {

std::atomic<size_t> count {0};

tf::Taskflow f;

auto A = f.emplace([&](){ count ++; });

auto B = f.emplace([&](auto& subflow){

count ++;

auto B1 = subflow.emplace([&](){ count++; });

auto B2 = subflow.emplace([&](){ count++; });

auto B3 = subflow.emplace([&](){ count++; });

B1.precede(B3); B2.precede(B3);

});

auto C = f.emplace([&](){ count ++; });

auto D = f.emplace([&](){ count ++; });

A.precede(B, C);

B.precede(D);

C.precede(D);

tf::Executor executor(W);

executor.run_until(f, [run=10]() mutable { return run-- == 0; },

[&](){

REQUIRE(count == 70);

count = 0;

}

).get();

executor.run_until(f, [run=10]() mutable { return run-- == 0; },

[&](){

REQUIRE(count == 70);

count = 0;

auto E = f.emplace([&](){ count ++; });

auto F = f.emplace([&](){ count ++; });

A.precede(E).precede(F);

});

executor.run_until(f, [run=10]() mutable { return run-- == 0; },

[&](){

REQUIRE(count == 90);

count = 0;

}

).get();

}

}

SUBCASE("MultipleRuns") {

for(unsigned W=1; W<=8; ++W) {

tf::Executor executor(W);

std::atomic<size_t> counter(0);

tf::Taskflow tf1, tf2, tf3, tf4;

for(size_t n=0; n<16; ++n) {

tf1.emplace([&](){counter.fetch_add(1, std::memory_order_relaxed);});

}

for(size_t n=0; n<1024; ++n) {

tf2.emplace([&](){counter.fetch_add(1, std::memory_order_relaxed);});

}

for(size_t n=0; n<32; ++n) {

tf3.emplace([&](){counter.fetch_add(1, std::memory_order_relaxed);});

}

for(size_t n=0; n<128; ++n) {

tf4.emplace([&](){counter.fetch_add(1, std::memory_order_relaxed);});

}

for(int i=0; i<200; ++i) {

executor.run(tf1);

executor.run(tf2);

executor.run(tf3);

executor.run(tf4);

}

executor.wait_for_all();

REQUIRE(counter == 240000);

}

}

}

TEST_CASE("ParallelRuns" * doctest::timeout(300)) {

std::atomic<int> counter;

std::vector<std::thread> threads;

auto make_taskflow = [&] (tf::Taskflow& tf) {

for(int i=0; i<1024; i++) {

auto A = tf.emplace([&] () {

counter.fetch_add(1, std::memory_order_relaxed);

});

auto B = tf.emplace([&] () {

counter.fetch_add(1, std::memory_order_relaxed);

});

A.precede(B);

}

};

SUBCASE("RunAndWait") {

for(unsigned w=1; w<=32; ++w) {

tf::Executor executor(w);

counter = 0;

for(int t=0; t<32; t++) {

threads.emplace_back([&] () {

tf::Taskflow taskflow;

make_taskflow(taskflow);

executor.run(taskflow).wait();

});

}

for(auto& t : threads) {

t.join();

}

threads.clear();

REQUIRE(counter.load() == 32*1024*2);

}

}

SUBCASE("RunAndWaitForAll") {

for(unsigned w=1; w<=32; ++w) {

tf::Executor executor(w);

counter = 0;

std::vector<std::unique_ptr<tf::Taskflow>> taskflows(32);

std::atomic<size_t> barrier(0);

for(int t=0; t<32; t++) {

threads.emplace_back([&, t=t] () {

taskflows[t] = std::make_unique<tf::Taskflow>();

make_taskflow(*taskflows[t]);

executor.run(*taskflows[t]);

++barrier; // make sure all runs are issued

});

}

while(barrier != 32);

executor.wait_for_all();

REQUIRE(counter.load() == 32*1024*2);

for(auto& t : threads) {

t.join();

}

threads.clear();

}

}

}

TEST_CASE("ParallelFor" * doctest::timeout(300)) {

using namespace std::chrono_literals;

const auto mapper = [](unsigned w, size_t num_data, bool group){

tf::Executor executor(w);

tf::Taskflow tf;

std::vector<int> vec(num_data, 0);

tf.parallel_for(

vec.begin(), vec.end(), [] (int& v) { v = 64; }, group ? ::rand() : 0

);

for(const auto v : vec) {

REQUIRE(v == 0);

}

executor.run(tf);

executor.wait_for_all();

for(const auto v : vec) {

REQUIRE(v == 64);

}

};

const auto reducer = [](unsigned w, size_t num_data, bool group){

tf::Executor executor(w);

tf::Taskflow tf;

std::vector<int> vec(num_data, 0);

std::atomic<int> sum(0);

tf.parallel_for(vec.begin(), vec.end(), [&](auto) { ++sum; }, group ? ::rand() : 0);

REQUIRE(sum == 0);

executor.run(tf);

executor.wait_for_all();

REQUIRE(sum == vec.size());

};

// map

SUBCASE("Map") {

for(unsigned W=1; W<=4; ++W){

for(size_t num_data=1; num_data<=59049; num_data *= 3){

mapper(W, num_data, true);

mapper(W, num_data, false);

}

}

}

// reduce

SUBCASE("Reduce") {

for(unsigned W=1; W<=4; ++W){

for(size_t num_data=1; num_data<=59049; num_data *= 3){

reducer(W, num_data, true);

reducer(W, num_data, false);

}

}

}

}

TEST_CASE("ParallelForOnIndex" * doctest::timeout(300)) {

using namespace std::chrono_literals;

auto exception_test = [] () {

tf::Taskflow tf;

// invalid index

REQUIRE_THROWS(tf.parallel_for(0, 10, 0, [] (auto) {}));

REQUIRE_THROWS(tf.parallel_for(0, 10, -1, [] (auto) {}));

REQUIRE_THROWS(tf.parallel_for(10, 0, 0, [] (auto) {}));

REQUIRE_THROWS(tf.parallel_for(10, 0, 1, [] (auto) {}));

REQUIRE_THROWS(tf.parallel_for(0u, 10u, 0u, [] (auto) {}));

REQUIRE_THROWS(tf.parallel_for(10u, 0u, 0u, [] (auto) {}));

REQUIRE_THROWS(tf.parallel_for(10u, 0u, 1u, [] (auto) {}));

REQUIRE_THROWS(tf.parallel_for(0.0f, 10.0f, 0.0f, [] (auto) {}));

REQUIRE_THROWS(tf.parallel_for(0.0f, 10.0f, -1.0f, [] (auto) {}));

REQUIRE_THROWS(tf.parallel_for(10.0f, 0.0f, 0.0f, [] (auto) {}));

REQUIRE_THROWS(tf.parallel_for(10.0f, 0.0f, 1.0f, [] (auto) {}));

REQUIRE_THROWS(tf.parallel_for(0.0, 10.0, 0.0, [] (auto) {}));

REQUIRE_THROWS(tf.parallel_for(0.0, 10.0, -1.0, [] (auto) {}));

REQUIRE_THROWS(tf.parallel_for(10.0, 0.0, 0.0, [] (auto) {}));

REQUIRE_THROWS(tf.parallel_for(10.0, 0.0, 1.0, [] (auto) {}));

REQUIRE_THROWS(tf.parallel_for(0, 0, 0, [] (auto) {}));

REQUIRE_THROWS(tf.parallel_for(0u, 0u, 0u, [] (auto) {}));

REQUIRE_THROWS(tf.parallel_for(0.0, 0.0, 0.0, [] (auto) {}));

// graceful case

REQUIRE_NOTHROW(tf.parallel_for(0, 0, -1, [] (auto) {}));

REQUIRE_NOTHROW(tf.parallel_for(0, 0, 1, [] (auto) {}));

REQUIRE_NOTHROW(tf.parallel_for(0u, 0u, 1u, [] (auto) {}));

REQUIRE_NOTHROW(tf.parallel_for(0.0f, 0.0f, -1.0f, [] (auto) {}));

REQUIRE_NOTHROW(tf.parallel_for(0.0f, 0.0f, 1.0f, [] (auto) {}));

REQUIRE_NOTHROW(tf.parallel_for(0.0, 0.0, -1.0, [] (auto) {}));

REQUIRE_NOTHROW(tf.parallel_for(0.0, 0.0, 1.0, [] (auto) {}));

};

auto positive_integer_step = [] (unsigned w) {

tf::Executor executor(w);

for(int beg=-10; beg<=10; ++beg) {

for(int end=beg; end<=10; ++end) {

for(int s=1; s<=end-beg; ++s) {

int n = 0;

for(int b = beg; b<end; b+=s) {

++n;

}

tf::Taskflow tf;

std::atomic<int> counter {0};

tf.parallel_for(beg, end, s, [&] (auto) {

counter.fetch_add(1, std::memory_order_relaxed);

});

executor.run(tf);

executor.wait_for_all();

REQUIRE(n == counter);

}

}

}

};

auto negative_integer_step = [] (unsigned w) {

tf::Executor executor(w);

for(int beg=10; beg>=-10; --beg) {

for(int end=beg; end>=-10; --end) {

for(int s=1; s<=beg-end; ++s) {

int n = 0;

for(int b = beg; b>end; b-=s) {

++n;

}

tf::Taskflow tf;

std::atomic<int> counter {0};

tf.parallel_for(beg, end, -s, [&] (auto) {

counter.fetch_add(1, std::memory_order_relaxed);

});

executor.run(tf);

executor.wait_for_all();

REQUIRE(n == counter);

}

}

}

};

auto positive_floating_step = [] (unsigned w) {

tf::Executor executor(w);

for(float beg=-10.0f; beg<=10.0f; ++beg) {

for(float end=beg; end<=10.0f; ++end) {

for(float s=1.0f; s<=end-beg; s+=0.1f) {

int n = 0;

if(beg < end) {

for(float b = beg; b < end; b += s) ++n;

}

else if(beg > end) {

for(float b = beg; b > end; b += s) ++n;

}

tf::Taskflow tf;

std::atomic<int> counter {0};

tf.parallel_for(beg, end, s, [&] (auto) {

counter.fetch_add(1, std::memory_order_relaxed);

});

executor.run(tf);

executor.wait_for_all();

REQUIRE(n == counter);

}

}

}

};

auto negative_floating_step = [] (unsigned w) {

tf::Executor executor(w);

for(float beg=10.0f; beg>=-10.0f; --beg) {

for(float end=beg; end>=-10.0f; --end) {

for(float s=1.0f; s<=beg-end; s+=0.1f) {

int n = 0;

if(beg < end) {

for(float b = beg; b < end; b += (-s)) ++n;

}

else if(beg > end) {

for(float b = beg; b > end; b += (-s)) ++n;

}

tf::Taskflow tf;

std::atomic<int> counter {0};

tf.parallel_for(beg, end, -s, [&] (auto) {

counter.fetch_add(1, std::memory_order_relaxed);

});

executor.run(tf);

executor.wait_for_all();

REQUIRE(n == counter);

}

}

}

};

SUBCASE("Exception") {

exception_test();

}

SUBCASE("PositiveIntegerStep") {

for(unsigned w=1; w<=4; w++) {

positive_integer_step(w);

}

}

SUBCASE("NegativeIntegerStep") {

for(unsigned w=1; w<=4; w++) {

negative_integer_step(w);

}

}

SUBCASE("PositiveFloatingStep") {

for(unsigned w=1; w<=4; w++) {

positive_floating_step(w);

}

}

SUBCASE("NegativeFloatingStep") {

for(unsigned w=1; w<=4; w++) {

negative_floating_step(w);

}

}

}

TEST_CASE("Reduce" * doctest::timeout(300)) {

const auto plus_test = [](unsigned num_workers, auto &&data){

tf::Executor executor(num_workers);

tf::Taskflow tf;

int result {0};

std::iota(data.begin(), data.end(), 1);

tf.reduce(data.begin(), data.end(), result, std::plus<int>());

executor.run(tf).get();

REQUIRE(result == std::accumulate(data.begin(), data.end(), 0, std::plus<int>()));

};

const auto multiply_test = [](unsigned num_workers, auto &&data){

tf::Executor executor(num_workers);

tf::Taskflow tf;

std::fill(data.begin(), data.end(), 1.0);

double result {2.0};

tf.reduce(data.begin(), data.end(), result, std::multiplies<double>());

executor.run(tf).get();

REQUIRE(result == std::accumulate(data.begin(), data.end(), 2.0, std::multiplies<double>()));

};

const auto max_test = [](unsigned num_workers, auto &&data){

tf::Executor executor(num_workers);

tf::Taskflow tf;

std::iota(data.begin(), data.end(), 1);

int result {0};

auto lambda = [](const auto& l, const auto& r){return std::max(l, r);};

tf.reduce(data.begin(), data.end(), result, lambda);

executor.run(tf).get();

REQUIRE(result == std::accumulate(data.begin(), data.end(), 0, lambda));

};

const auto min_test = [](unsigned num_workers, auto &&data){

tf::Executor executor(num_workers);

tf::Taskflow tf;

std::iota(data.begin(), data.end(), 1);

int result {std::numeric_limits<int>::max()};

auto lambda = [](const auto& l, const auto& r){return std::min(l, r);};

tf.reduce(data.begin(), data.end(), result, lambda);

executor.run(tf).get();

REQUIRE(result == std::accumulate(

data.begin(), data.end(), std::numeric_limits<int>::max(), lambda)

);

};

for(unsigned w=1; w<=4; ++w){

for(size_t j=0; j<=256; j=j*2+1){

plus_test(w, std::vector<int>(j));

plus_test(w, std::list<int>(j));

multiply_test(w, std::vector<double>(j));

multiply_test(w, std::list<double>(j));

max_test(w, std::vector<int>(j));

max_test(w, std::list<int>(j));

min_test(w, std::vector<int>(j));

min_test(w, std::list<int>(j));

}

}

}

TEST_CASE("ReduceMin" * doctest::timeout(300)) {

for(int w=1; w<=4; w++) {

tf::Executor executor(w);

for(int i=0; i<=65536; i = (i <= 1024) ? i + 1 : i*2 + 1) {

tf::Taskflow tf;

std::vector<int> data(i);

int gold = std::numeric_limits<int>::max();

int test = std::numeric_limits<int>::max();

for(auto& d : data) {

d = ::rand();

gold = std::min(gold, d);

}

tf.reduce_min(data.begin(), data.end(), test);

executor.run(tf).get();

REQUIRE(test == gold);

}

}

}

TEST_CASE("ReduceMax" * doctest::timeout(300)) {

for(int w=1; w<=4; w++) {

tf::Executor executor(w);

for(int i=0; i<=65536; i = (i <= 1024) ? i + 1 : i*2 + 1) {

tf::Taskflow tf;

std::vector<int> data(i);

int gold = std::numeric_limits<int>::min();

int test = std::numeric_limits<int>::min();

for(auto& d : data) {

d = ::rand();

gold = std::max(gold, d);

}

tf.reduce_max(data.begin(), data.end(), test);

executor.run(tf).get();

REQUIRE(test == gold);

}

}

}

TEST_CASE("JoinedSubflow" * doctest::timeout(300)){