forstio/test/async.cpp

#include "suite/suite.h"

#include "source/forstio/async.h"

namespace {
SAW_TEST("Async Immediate"){
	using namespace saw;

	event_loop event_loop;
	wait_scope wait_scope{event_loop};

	conveyor<size_t> number{5};

	conveyor<bool> is_number = number.then([](size_t val){
		return val == 5;
	});

	wait_scope.poll();

	error_or<bool> error_or_number = is_number.take();

	SAW_EXPECT(!error_or_number.is_error(), error_or_number.error().message());
	SAW_EXPECT(error_or_number.is_value(), "Return is not a value");
	SAW_EXPECT(error_or_number.value(), "Value is not 5");
}

SAW_TEST("Async Adapt"){
	using namespace saw;

	event_loop event_loop;
	wait_scope wait_scope{event_loop};

	auto feeder_conveyor = new_conveyor_and_feeder<size_t>();

	feeder_conveyor.feeder->feed(5);

	error_or<size_t> foo = feeder_conveyor.conveyor.take();

	SAW_EXPECT(!foo.is_error(), foo.error().message());
	SAW_EXPECT(foo.is_value(), "Return is not a value");
	SAW_EXPECT(foo.value() == 5, "Values not 5, but " + std::to_string(foo.value()));
}


SAW_TEST("Async Adapt Multiple"){
	using namespace saw;

	event_loop event_loop;
	wait_scope wait_scope{event_loop};

	auto feeder_conveyor = new_conveyor_and_feeder<size_t>();

	feeder_conveyor.feeder->feed(5);

	error_or<size_t> foo = feeder_conveyor.conveyor.take();

	SAW_EXPECT(!foo.is_error(), foo.error().message());
	SAW_EXPECT(foo.is_value(), "Return is not a value");
	SAW_EXPECT(foo.value() == 5, "Values not 5, but " + std::to_string(foo.value()));

	feeder_conveyor.feeder->feed(10);

	error_or<size_t> bar = feeder_conveyor.conveyor.take();

	SAW_EXPECT(!foo.is_error(), bar.error().message());
	SAW_EXPECT(bar.is_value(), "Return is not a value");
	SAW_EXPECT(bar.value() == 10, "Values not 10, but " + std::to_string(bar.value()));

	feeder_conveyor.feeder->feed(2);
	feeder_conveyor.feeder->feed(4234);

	error_or<size_t> a = feeder_conveyor.conveyor.take();
	error_or<size_t> b = feeder_conveyor.conveyor.take();

	SAW_EXPECT(!foo.is_error(), a.error().message());
	SAW_EXPECT(a.is_value(), "Return is not a value");
	SAW_EXPECT(a.value() == 2, "Values not 2, but " + std::to_string(a.value()));

	SAW_EXPECT(!foo.is_error(), b.error().message());
	SAW_EXPECT(b.is_value(), "Return is not a value");
	SAW_EXPECT(b.value() == 4234, "Values not 4234, but " + std::to_string(b.value()));
}

SAW_TEST("Async Conversion"){
	using namespace saw;

	event_loop event_loop;
	wait_scope wait_scope{event_loop};

	auto feeder_conveyor = new_conveyor_and_feeder<size_t>();

	conveyor<std::string> string_conveyor = feeder_conveyor.conveyor.then([](size_t foo){
		return std::to_string(foo);
	});

	feeder_conveyor.feeder->feed(10);

	error_or<std::string> foo = string_conveyor.take();

	SAW_EXPECT(!foo.is_error(), foo.error().message());
	SAW_EXPECT(foo.is_value(), "Return is not a value");
	SAW_EXPECT(foo.value() == std::to_string(10), "Values is not 10, but " + foo.value());
}

SAW_TEST("Async Conversion Multistep"){
	using namespace saw;

	event_loop event_loop;
	wait_scope wait_scope{event_loop};

	auto feeder_conveyor = new_conveyor_and_feeder<size_t>();

	conveyor<bool> conveyor = feeder_conveyor.conveyor.then([](size_t foo){
		return std::to_string(foo);
	}).then([](const std::string& value){
		return value != "10";
	}).then([](bool value){
		return !value;
	});

	feeder_conveyor.feeder->feed(10);

	error_or<bool> foo = conveyor.take();

	SAW_EXPECT(!foo.is_error(), foo.error().message());
	SAW_EXPECT(foo.is_value(), "Return is not a value");
	SAW_EXPECT(foo.value(), "Values is not true");
}

SAW_TEST("Async Scheduling"){
	using namespace saw;

	event_loop event_loop;
	wait_scope wait_scope{event_loop};

	auto feeder_conveyor = new_conveyor_and_feeder<size_t>();

	/*
	* Attach node test data
	*/
	own<size_t> counter = heap<size_t>();
	size_t* ctr_ptr = counter.get();
	*ctr_ptr = 0;

	conveyor<std::string> string_conveyor = feeder_conveyor.conveyor
	.then([ctr_ptr](size_t foo){
		return std::to_string(foo + ++(*ctr_ptr));
	})
	.attach(std::move(counter))
	.buffer(10)
	.then([](const std::string& value){
		return value + std::string{"post"};
	})
	.buffer(10)
	.then([](const std::string& value){
		return std::string{"pre"} + value;
	})
	.buffer(10);

	feeder_conveyor.feeder->feed(10);
	feeder_conveyor.feeder->feed(20);
	feeder_conveyor.feeder->feed(30);

	wait_scope.poll();

	error_or<std::string> foo_10 = string_conveyor.take();

	SAW_EXPECT(!foo_10.is_error(), foo_10.error().message());
	SAW_EXPECT(foo_10.is_value(), "Return is not a value");
	SAW_EXPECT(foo_10.value() == (std::string{"pre"} + std::to_string(11) + std::string{"post"}), "Values is not pre11post, but " + foo_10.value());

	error_or<std::string> foo_20 = string_conveyor.take();

	SAW_EXPECT(!foo_20.is_error(), foo_20.error().message());
	SAW_EXPECT(foo_20.is_value(), "Return is not a value");
	SAW_EXPECT(foo_20.value() == (std::string{"pre"} + std::to_string(22) + std::string{"post"}), "Values is not pre22post, but " + foo_20.value());

	error_or<std::string> foo_30 = string_conveyor.take();

	SAW_EXPECT(!foo_30.is_error(), foo_30.error().message());
	SAW_EXPECT(foo_30.is_value(), "Return is not a value");
	SAW_EXPECT(foo_30.value() == (std::string{"pre"} + std::to_string(33) + std::string{"post"}), "Values is not pre33post, but " + foo_30.value());
}

SAW_TEST("Async Detach"){
	using namespace saw;

	event_loop event_loop;
	wait_scope wait_scope{event_loop};

	int num = 0;

	conveyor<int>{10}.then([&num](int bar){
		num = bar;
	}).detach();

	wait_scope.poll();

	SAW_EXPECT(num == 10, std::string{"Bad value: Expected 10, but got "} + std::to_string(num));
}

SAW_TEST("Async Merge"){
	using namespace saw;

	event_loop event_loop;
	wait_scope wait_scope{event_loop};

	auto cam = conveyor<int>{10}.merge();

	cam.second.attach(conveyor<int>{11});

	cam.second.attach(conveyor<int>{14});

	size_t elements_passed = 0;
	bool wrong_value = false;

	auto sink = cam.first.then([&elements_passed, &wrong_value](int foo){
		if(foo == 10 || foo == 11 || 14){
			++elements_passed;
		}else{
			wrong_value = true;
		}
	}).sink();

	wait_scope.poll();

	SAW_EXPECT(!wrong_value, std::string{"Expected values 10 or 11"});
	SAW_EXPECT(elements_passed == 3, std::string{"Expected 2 passed elements, got only "} + std::to_string(elements_passed));
}

SAW_TEST("Async Connect"){
	using namespace saw;

	event_loop event_loop;
	wait_scope wait_scope{event_loop};

	auto caf1 = new_conveyor_and_feeder<int>();

	auto caf2 = new_conveyor_and_feeder<float>();

	bool val_passed = false;
	auto conveyor1 = caf1.conveyor.then([&val_passed](int val) -> float{
		val_passed = (val == 10);

		return static_cast<float>(val);
	}).buffer(1);

	bool val_passed_2 = false;
	auto sink = caf2.conveyor.then([&val_passed_2](float val) {
		val_passed_2 = (val == 10.f);
	}).sink();

	caf1.feeder->feed(10);

	caf2.feeder->swap(std::move(conveyor1));

	wait_scope.poll();

	SAW_EXPECT(val_passed, std::string{"Expected value 10"});
	SAW_EXPECT(val_passed_2, std::string{"Expected value 10.f"});
}
}