root/threadman/trunk/tests/test_cases.cpp

#include "threadman.h"
#include <iostream>
#include <sstream>

using namespace std;

static int serial = 0;
struct Data {
    Data* source;
    int id;
    Data(int i) : source(0), id(i) {
        source = this;
    }
    Data(void* d) : source(static_cast<Data*>(d)), id(source ? source->id : 0) {}
    int dump(const char* func = "?") {
        ostringstream oss;
        oss << func << " (in #" << ThreadMan::thread_id() << "): " << id << "\n";
        if (source)
            delete source;
        // do it all at once to minimise chance of mixing thread output
        cout << oss.str();
        return 0;
    }
    static Data* x(int i = ++serial) {
        return new Data(i);
    }
    int intmemfun() {
        return dump(__func__);
    }
    bool boolmemfun() {
        return dump(__func__);
    }
    //functors..
    bool operator==(const Data& rhs) const {
        /* for functors, things with the same serial will be synchronised */
        return id == rhs.id;
    }
    int operator()() {
        source = 0; /* this comes via temporary */
        return dump(__func__);
    }
    int operator()(Data* d) {
        source = 0; /* this comes via temporary */
        d->dump("operator()+arg");
        return dump("operator()+arg");
    }
};

int oldschool(void* d) {
    Data(d).dump(__func__);
}

long neater(Data* d) {
    d->dump(__func__);
}

long noarg() {
    Data::x()->dump(__func__);
}

void dotests(bool sync) {
    ThreadMan &tm = ThreadMan::tman();

    cout << "\n== Doing " << (sync ? "synchronised" : "concurrent") << " tests ==" << endl;

    tm.run(oldschool, Data::x(), sync);

    tm.run(ThreadMan::runner(oldschool), Data::x(), sync);
    tm.run(ThreadMan::runner(neater), Data::x(), sync);
    tm.run(ThreadMan::runner(noarg), 0, sync);

    //member functions
    tm.run(ThreadMan::runner(&Data::intmemfun), Data::x(), sync);
    tm.run(ThreadMan::runner(&Data::boolmemfun), Data::x(), sync);

    //functors
    tm.run(ThreadMan::runner(Data(++serial)), 0, sync);
    tm.run(ThreadMan::runner1<Data>(Data(++serial)), Data::x(), sync);

}

int main() {
    ThreadMan &tm = ThreadMan::tman();
    dotests(true);
    tm.joinSync();
    dotests(false);
    tm.stopAsync();

    return 0;
}