task_unit.hpp

 
#pragma once
 
#include "../asrtlpp/task.hpp"
#include "./reactor.hpp"
 
#include <ecor/ecor.hpp>
 
namespace asrt
{
 
 
struct task_test
{
        task_test( task_ctx& ctx )
          : _ctx( ctx )
        {
        }
 
        template < typename T >
        auto& query( T&& q )
        {
                return _ctx.query( (T&&) q );
        }
 
private:
        task_ctx& _ctx;
};
 
using ecor::suspend;
using ecor::with_error;
 
template < typename T >
struct task_unit : asrt_test
{
 
        struct recv
        {
                using receiver_concept = ecor::receiver_t;
 
                record* rec;
 
                void set_value() { rec->state = ASRT_TEST_PASS; }
                void set_error( ecor::task_error ) { rec->state = ASRT_TEST_FAIL; }
                void set_error( test_fail_t ) { rec->state = ASRT_TEST_FAIL; }
                void set_error( asrt::status ) { rec->state = ASRT_TEST_ERROR; }
                void set_stopped() { rec->state = ASRT_TEST_FAIL; }
        };
 
        task_unit( T def )
          : _def( std::move( def ) )
        {
                asrt_test_init( this, _def.name, static_cast< task_unit* >( this ), task_unit::cb );
        }
 
        static asrt_status cb( record* rec )
        {
                auto& self = *static_cast< task_unit* >( rec->inpt->test_ptr );
 
                if ( rec->state == ASRT_TEST_INIT ) {
                        rec->state = ASRT_TEST_RUNNING;
                        self._op   = self._def.exec().connect( recv{ rec } );
                        self._op.start();
                }
 
                return ASRT_SUCCESS;
        }
 
private:
        T _def;
        // XXX: note that this being here is waste of memory - it is needed only per active test
        ecor::connect_type< task< void >, recv > _op;
};
 
}  // namespace asrt