root/lang/objective-cplusplus/i3/trunk/src/mil/src/Test9.cpp @ 34769

#include <mil/PrecompiledHeaders.h>
#include <mil/Mil.h>
#include <mil/Atomic.h>
#include <mil/Thread.h>
#include <mil/GuiModule.h>
#include <mil/Module.h>
#include <quicktest/quicktest.h>

#include "Test.h"

using namespace mil;
using namespace mil::Test;

namespace Test9 {

int global = 0;
atomic<bool> spin;

struct TinyEvent {
};

struct SmallEvent {
    short data;
};

struct MiddleEvent {
    char pad[20];
    int data;
};

struct BigEvent {
    char pad[500];
    int data;
};

struct Foo : GuiModule<Foo> {
    void createGui() {
        this->setWindow(create_window());
        while (spin.load()) {
        }
    }

    void execute(SmallEvent& e) {
        global += e.data;
    }

    void execute(BigEvent& e) {
        global++;
    }
};

struct Bar : GuiModule<Bar> {
    Foo& foo;
    Bar(Foo& foo): foo(foo) {
    }
    void run() {
        this->setWindow(create_window());
        while (spin.load()) {
        }

        for (int i = 0; i < 50000; i++) {
            SmallEvent e;
            e.data = 5;
            foo.post(e, *this);
        }
        this->loop();
    }
};

struct Bar2 : GuiModule<Bar2> {
    Foo& foo;
    Bar2(Foo& foo): foo(foo) {
    }
    void run() {
        this->setWindow(create_window());
        while (spin.load()) {
        }

        for (int i = 0; i < 500; i++) {
            BigEvent e2;
            foo.post(e2, *this);
        }
        this->loop();
    }
};

struct Bar3 : GuiModule<Bar3> {
    Foo& foo;
    Bar3(Foo& foo): foo(foo) {
    }
    void run() {
        this->setWindow(create_window());
        while (spin.load()) {
        }

        for (int i = 0; i < 500; i++) {
            SmallEvent e;
            e.data = 5;
            foo.post(e, *this);

            BigEvent e2;
            foo.post(e2, *this);
        }
        this->loop();
    }
};

struct Hoge : GuiModule<Hoge> {
    void createGui() {
        this->setWindow(create_window());
        while (spin.load()) {}
    }
    void execute(TinyEvent& e) {
        global++;
    }
    void execute(SmallEvent& e) {
        global += e.data;
    }
    void execute(MiddleEvent& e) {
        global += e.data;
    }
    void execute(BigEvent& e) {
        global += e.data;
    }
};

struct Hige : Module<Hige> {
    void run() {
        while (spin.load()) {}
        this->loop();
    }
    void execute(TinyEvent& e) {
        global += 2;
    }
    void execute(SmallEvent& e) {
        global += e.data * 2;
    }
    void execute(MiddleEvent& e) {
        global += e.data * 2;
    }
    void execute(BigEvent& e) {
        global += e.data * 2;
    }
};

template <class Receiver>
struct Hage : GuiModule<Hage<Receiver> > {
    Receiver& r;
    Hage(Receiver& r) : r(r) {}
    void run() {
        this->setWindow(create_window());
        while (spin.load()) {}

        //for (int i = 0; i < 50; i++) {
        //    TinyEvent t;
        //    r.post(t, *this);
        //}

        //sleep(1);

        for (int i = 0; i < 50; i++) {
       
            MiddleEvent m;
            m.data = 2;
            BigEvent b;
            b.data = 4;
            r.post(m, *this);
            r.post(b, *this);
            r.post(m, *this);
            r.post(b, *this);
        }
        sleep(1);
        this->loop();
    }
};

template <class Receiver>
struct Fuga : Module<Fuga<Receiver> > {
    Receiver& r;
    Fuga(Receiver& r) : r(r) {}
    void run() {
        while (spin.load()) {}

        for (int i = 0; i < 50; i++) {
            TinyEvent t;
            r.post(t, *this);
            SmallEvent s;
            s.data = 8;
            r.post(s, *this);
            MiddleEvent m;
            m.data = 16;
            r.post(m, *this);
            BigEvent b;
            b.data = 32;
            r.post(b, *this);
        }

        this->loop();
    }
};


}

using namespace Test9;

QT_TEST(test_asdfadfaadfasdfadf) {
    global = 0;

    {
        spin.store(true);
        Hoge hoge;
        Hage<Hoge> hage(hoge);
        hoge.start();
        hage.start();
        sleep(1);
        spin.store(false);
        sleep(1);
        QT_CHECK_EQUAL(global, 600);
    }

    {
        spin.store(true);
        Hoge hoge;
        Fuga<Hoge> fuga(hoge);
        hoge.start();
        fuga.start();
        sleep(1);
        spin.store(false);
        sleep(1);
        QT_CHECK_EQUAL(global, 3450);
    }

    {
        spin.store(true);
        Hige hige;
        Hage<Hige> hage(hige);
        hige.start();
        hage.start();
        sleep(1);
        spin.store(false);
        sleep(1);
        QT_CHECK_EQUAL(global, 4650);
    }

    {
        spin.store(true);
        Hige hige;
        Fuga<Hige> fuga(hige);
        hige.start();
        fuga.start();
        sleep(1);
        spin.store(false);
        sleep(1);
        QT_CHECK_EQUAL(global, 10350);
    }
}
QT_TEST(test_adifjadfioajdfaoidffgzg8) {
    for (int i = 0; i < 5; i++) {
        global = 0;
        spin.store(true);

        Foo foo;
        Bar bar(foo);

        foo.start();
        bar.start();

        sleep(1);
        spin.store(false);
        sleep(1);
        QT_CHECK_EQUAL(global, 2500);
    }
}


QT_TEST(test_dasfhsdfsadfoiaaaaaoioio) {
    global = 0;
    spin.store(true);

    Foo foo;
    Bar2 bar(foo);

    foo.start();
    bar.start();

    sleep(1);
    spin.store(false);
    sleep(1);
    QT_CHECK_EQUAL(global, 500);
}

QT_TEST(test_dasfhsdfsadfoiaaaaaoioioa89) {
    {
        global = 0;
        spin.store(true);

        Foo foo;
        Bar bar(foo);

        foo.start();
        bar.start();

        sleep(1);
        spin.store(false);
        sleep(1);
        QT_CHECK_EQUAL(global, 2500);
    }

    {
        global = 0;
        spin.store(true);

        Foo foo;
        Bar2 bar(foo);

        foo.start();
        bar.start();

        sleep(1);
        spin.store(false);
        sleep(1);
        QT_CHECK_EQUAL(global, 500);
    }

    {
        global = 0;
        spin.store(true);

        Foo foo;
        Bar3 bar(foo);

        foo.start();
        bar.start();

        sleep(1);
        spin.store(false);
        sleep(1);
        QT_CHECK_EQUAL(global, 3000);
    }
}

QT_TEST(test_das1223sadfoio) {
    global = 0;
    spin.store(false);

    Foo foo;
    Bar bar(foo);

    bar.start();
    sleep(1);
    foo.start();
    sleep(1);
    QT_CHECK_EQUAL(global, 0);
}