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

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

namespace i3 {

Tester* tester_ptr = NULL;
extern void (**tester_tests)(Tester&);
extern unsigned int tester_tests_length;

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

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

Tester::Tester(Mediator& mediator) : mediator(mediator), valid(true), 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;

    synchronized (mutex) {
        passed = true;
    }
}

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

void Tester::run() {
    CHECK_VALID;

    sleep(5);

#if MIL_GUI_COCOA
    return; //XXX
#endif

    while (!break_loop_request) {
        this->execute_front();
        mil::yield();
        synchronized (mutex) {
            if (!passed) {
                continue;
            }
            if (!startNext()) {
                return;
            }
        }
    }
}


#ifdef MIL_OS_WINDOWS
void send_key(char c_) {
    unsigned char c = c_;
    if (c == '\r' || c == '\n') {
        keybd_event(VK_RETURN, 0, 0, 0 );
        keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
        return;
    }

    if (isalnum(c)) {
        unsigned char u = toupper(c);
        keybd_event(u, 0, 0, 0 );
        keybd_event(u, 0, KEYEVENTF_KEYUP, 0);
    }
}
#else
void send_key(char c_) {
}
#endif

void Tester::sendKeys(std::string keys) {
    for (unsigned i = 0; i < keys.size(); i++) {
        send_key(keys[i]);
    }
}

bool Tester::startNext() {
    CHECK_VALID;

    if (index < tester_tests_length) {
        (tester_tests[index])(*this);
        index++;
        return true;
    }
    return false;
}

bool Tester::completed() const {
    CHECK_VALID;

    return (index == tester_tests_length);
}

}

using namespace i3;

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

    int exit_status = 0;

    exit_status = init_common_global_data(argc, argv);
    QT_CHECK(!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);

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