test_main.hxx

Go to the documentation of this file.

 
#ifdef _UTILS_TEST_MAIN_HXX_
#error Only ever include test_main into the main unittest file.
#else
#define _UTILS_TEST_MAIN_HXX_
 
#include "nmranet_config.h"
 
#include <stdio.h>
#include <stdarg.h>
#include <memory>
#include <string>
#include <functional>
#include "gtest/gtest.h"
#include "gmock/gmock.h"
 
#include "can_frame.h"
#include "executor/CallableFlow.hxx"
#include "executor/Executor.hxx"
#include "executor/Service.hxx"
#include "os/TempFile.hxx"
#include "os/os.h"
#include "utils/StringPrintf.hxx"
 
#ifdef WITHGPERFTOOLS
#include <gperftools/profiler.h>
 
std::function<void()> profiler_enable{&ProfilerEnable};
std::function<void()> profiler_disable{&ProfilerDisable};
#endif
 
int appl_main(int argc, char *argv[])
{
    testing::InitGoogleMock(&argc, argv);
    return RUN_ALL_TESTS();
}
 
bool mute_log_output = false;
extern "C" {
 
void log_output(char* buf, int size) {
    if (size <= 0 || mute_log_output) return;
    fwrite(buf, size, 1, stderr);
    fwrite("\n", 1, 1, stderr);
}
 
}
 
 
extern Executor<1> g_executor;
 
#ifdef __EMSCRIPTEN__
Executor<1> g_executor{NO_THREAD()};
 
void os_emscripten_yield() {
    g_executor.loop_once();
}
#else
Executor<1> g_executor("ex_thread", 0, 1024);
#endif
 
#ifndef NO_GC_OPTIMIZE
OVERRIDE_CONST(gridconnect_buffer_size, 1);
#endif
 
Service g_service(&g_executor);
 
void wait_for_main_executor()
{
    std::unique_ptr<ExecutorGuard> guard(new ExecutorGuard(&g_executor));
    guard->wait_for_notification();
}
 
void wait_for_main_timers()
{
    wait_for_main_executor();
    while (!g_executor.active_timers()->empty())
    {
        usleep(20000);
        wait_for_main_executor();
    }
    wait_for_main_executor();
}
 
class ExecutorStartupFix {
public:
  ~ExecutorStartupFix() {
    wait_for_main_executor();
  }
} unused_executor_startup_guard_instance; 
 
class ExecuteOnMainExecutor : public Executable {
public:
    typedef void* thread_fn_t(void*);
    ExecuteOnMainExecutor(thread_fn_t *fn, void* arg)
        : fn_(fn), arg_(arg) {
        g_executor.add(this);
    }
 
    void run() OVERRIDE {
        (*fn_)(arg_);
        delete this;
    }
private:
    thread_fn_t *fn_; 
    void* arg_; 
};
 
class FnExecutable : public Executable
{
public:
    FnExecutable(std::function<void()> &&fn)
        : fn_(std::move(fn))
    {
    }
 
    void run() OVERRIDE
    {
        fn_();
        n.notify();
    }
 
    SyncNotifiable n;
 
private:
    std::function<void()> fn_;
};
 
void run_x(std::function<void()> fn)
{
    g_executor.sync_run(std::move(fn));
}
 
class RunInConstruct
{
public:
    RunInConstruct(std::function<void()> f)
    {
        f();
    }
};
 
class RunInConstructOnMain
{
public:
    RunInConstructOnMain(std::function<void()> f)
    {
        run_x(f);
    }
};
 
#define RX(statement) run_x([&](){ statement; })
 
template <class T> struct PendingInvocation
{
    BufferPtr<T> b;
    SyncNotifiable notifiable;
    BarrierNotifiable barrier {&notifiable};
    bool isWaited {false};
 
    ~PendingInvocation()
    {
        wait();
    }
 
    void wait()
    {
        if (isWaited)
        {
            return;
        }
        notifiable.wait_for_notification();
        isWaited = true;
    }
};
 
template <class T, typename... Args>
std::unique_ptr<PendingInvocation<T>> invoke_flow_nowait(
    FlowInterface<Buffer<T>> *flow, Args &&...args)
{
    auto ret = std::make_unique<PendingInvocation<T>>();
    ret->b.reset(flow->alloc());
    ret->b->data()->reset(std::forward<Args>(args)...);
    ret->b->data()->done.reset(&ret->barrier);
    flow->send(ret->b->ref());
    return ret;
}
 
class BlockExecutor : public Executable
{
public:
    BlockExecutor()
    {
    }
 
    BlockExecutor(ExecutorBase *e)
    {
        if (e)
        {
            e->add(this);
        }
        else
        {
            g_executor.add(this);
        }
        wait_for_blocked();
    }
 
    virtual void run()
    {
        n_.notify();
#ifndef __EMSCRIPTEN__
        m_.wait_for_notification();
#endif
    }
 
    void wait_for_blocked()
    {
        n_.wait_for_notification();
    }
 
    void release_block()
    {
#ifndef __EMSCRIPTEN__
        m_.notify();
#endif
    }
 
private:
    SyncNotifiable n_;
    SyncNotifiable m_;
};
 
class ScopedOverride
{
public:
    template <class T, typename U>
    ScopedOverride(T *variable, U new_value)
        : holder_(new Holder<T>(variable, new_value))
    {
    }
 
    void restore()
    {
        holder_.reset();
    }
 
private:
    class HolderBase
    {
    public:
        virtual ~HolderBase()
        {
        }
    };
 
    template <class T> class Holder : public HolderBase
    {
    public:
        Holder(T *variable, T new_value)
            : variable_(variable)
            , oldValue_(*variable)
        {
            *variable = new_value;
        }
 
        ~Holder()
        {
            *variable_ = oldValue_;
        }
 
    private:
        T *variable_;
        T oldValue_;
    };
 
    std::unique_ptr<HolderBase> holder_;
};
 
int nibble_to_int(char n)
{
    if ('0' <= n && n <= '9')
    {
        return n - '0';
    }
    if ('a' <= n && n <= 'f')
    {
        return n - 'a' + 10;
    }
    if ('A' <= n && n <= 'F')
    {
        return n - 'A' + 10;
    }
    DIE("Unknown nibble arrived.");
}
 
std::string hex2str(const char *hex)
{
    std::string ret;
    while (*hex && *(hex + 1))
    {
        if (*hex == ' ')
        {
            ++hex;
            continue;
        }
        ret.push_back((nibble_to_int(*hex) << 4) | (nibble_to_int(*(hex + 1))));
        hex += 2;
    }
    return ret;
}
 
const char HEXCHR[17] = "0123456789abcdef";
 
std::string str2hex(const string &s)
{
    std::string ret;
    for (char c : s)
    {
        ret.push_back(HEXCHR[c >> 4]);
        ret.push_back(HEXCHR[c & 0xf]);
    }
    return ret;
}
 
#endif // _UTILS_TEST_MAIN_HXX_