root/lang/objective-cplusplus/i3/trunk/src/Tester.cpp @ 36128

#include <PrecompiledHeaders.h>
#include "Mediator.h"
#include "Tester.h"
#include <mil/Synchronize.h>

namespace i3 {

boost::shared_ptr<Tester> tester_ptr;

#define CHECK_VALID { if (!valid) { throw std::logic_error("Tester"); }}

Tester::Tester() : valid(false), mediator(*(std::auto_ptr<Mediator>(new Mediator()))), passed(true), index(0) {
}

Tester::Tester(Mediator& mediator) : valid(true), mediator(mediator), passed(true), index(0) {
}

std::string Tester::getName() {
        CHECK_VALID;
        synchronized (mutex) {
                if (passed) {
                        return "test passed";
                }
                return name;
        }

        return "";
}

void Tester::pass() {
        CHECK_VALID;

    std::cout << "Test [" << getName() << "] passed" << std::endl;
        synchronized (mutex) {
                passed = true;
        }
}

void Tester::next(const char* name_) {
        CHECK_VALID;
        synchronized (mutex) {
                name = name_;
                passed = false;
        }
}

void Tester::run() {
        CHECK_VALID;

        sleep(3);

    for (;;) {
                for (int i = 0; i < 100 && this->execute_front(); i++) {
                        mil::yield();
                }

                synchronized (mutex) {
                        if (!passed) {
                continue;
            }
            if (!startNext()) {
                return;
            }
                }
    }
}

struct SimplePing {
};

template <>
void InputWindow::beforeExecute(SimplePing& e) {
        if (tester.getName() == "simple ping") {
                QT_CHECK(true);
                tester.pass();
        }
}

template <>
void InputWindow::execute(SimplePing& e) {
}

bool Tester::startNext() {
        CHECK_VALID;

        index++;
        if (index == 1) {
                next("simple ping");
                SimplePing s;
                mediator.getInputWindow().post(s, *this);
        return true;
        }
        return false;
}

}

using namespace i3;

QT_TEST(mediadafd) {
    char argv1[] = "foo";
    char argv2[] = "bar";
    char* argv[] = {argv1, argv2};
    int argc = _countof(argv);

    exit_status exit_status;

    exit_status = init_os_global_data(argc, argv);
    QT_CHECK(!exit_status);

    exit_status = init_gui_global_data(argc, argv);
    QT_CHECK(!exit_status);

    {
        i3::Mediator mediator;
        exit_status = mediator.start();
        if (exit_status) {
            QT_CHECK(!exit_status);
        }
    }
}