RCF - Interprocess Communication for C++

#include <RCF/test/TestMinimal.hpp>

#include <RCF/Idl.hpp>
#include <RCF/RcfClient.hpp>
#include <RCF/RcfServer.hpp>
#include <RCF/ClientProgress.hpp>
#include <RCF/TcpClientTransport.hpp>

#ifdef RCF_USE_BOOST_ASIO
#include <RCF/TcpAsioServerTransport.hpp>
#else
#include <RCF/TcpIocpServerTransport.hpp>
#endif

#include <RCF/test/PrintTestHeader.hpp>
#include <RCF/test/TransportFactories.hpp>

#include <RCF/util/PortNumbers.hpp>

#ifndef BOOST_WINDOWS
#define QS_PAINT 0
#endif

namespace Test_ClientProgress {

    RCF_BEGIN(I_X, "I_X")
        RCF_METHOD_R2(std::string, echo, std::string, unsigned int)
    RCF_END(I_X)

    class X
    {
    public:
        std::string echo(const std::string &s, unsigned int waitMs)
        {
            Platform::OS::SleepMs(waitMs);
            return s;
        }
    };

    unsigned int gEventCallbacks = 0;
    unsigned int gTimerCallbacks = 0;
    unsigned int gMessageFilterCallbacks = 0;
    RCF::ClientProgress::Action gAction = RCF::ClientProgress::Continue;

    void myCallback(
        std::size_t bytesTransferred,
        std::size_t bytesTotal,
        RCF::ClientProgress::Trigger trigger,
        RCF::ClientProgress::Activity activity,
        RCF::ClientProgress::Action &action)
    {

        switch (trigger)
        {
            case RCF::ClientProgress::Event:
                ++gEventCallbacks;
                break;

            case RCF::ClientProgress::Timer:
                ++gTimerCallbacks;
                break;

            case RCF::ClientProgress::UiMessage:

#ifdef BOOST_WINDOWS

                {
                    MSG msg = {0};
                    while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
                    {
                        if (msg.message == WM_QUIT)
                        {

                        }
                        else if (msg.message == WM_PAINT)
                        {
                            TranslateMessage(&msg);
                            DispatchMessage(&msg);
                        }
                    }
                }

#endif

                ++gMessageFilterCallbacks;
                break;

            default:
                RCF_ASSERT(0);
        }
        action = gAction;
    }

} // namespace Test_ClientProgress

int RCF_TEST_MAIN(int argc, char **argv)
{
    printTestHeader(__FILE__);

    using namespace Test_ClientProgress;

    std::string ip = util::PortNumbers::getSingleton().getIp();
    int port = util::PortNumbers::getSingleton().getNext();

#ifdef RCF_USE_BOOST_ASIO
    RCF::ServerTransportPtr serverTransportPtr( new RCF::TcpAsioServerTransport(port));
#else
    RCF::ServerTransportPtr serverTransportPtr( new RCF::TcpIocpServerTransport(port));
#endif

    RCF::ClientTransportAutoPtr clientTransportAutoPtr( new RCF::TcpClientTransport(ip, port));

    X x;
    RCF::RcfServer server(serverTransportPtr);
    server.bind( (I_X*) 0, x);
    server.start();

    std::string s0 = "asdf";
    std::string s;
    RcfClient<I_X> client(clientTransportAutoPtr->clone());

    s = client.echo(s0, 10);
    BOOST_CHECK(s == s0);

    RCF::ClientProgressPtr clientProgressPtr( new RCF::ClientProgress() );
    client.getClientStub().setClientProgressPtr(clientProgressPtr);

    {
        clientProgressPtr->mTriggerMask = RCF::ClientProgress::Event | RCF::ClientProgress::Timer | RCF::ClientProgress::UiMessage;
        clientProgressPtr->mTimerIntervalMs = 500;
        clientProgressPtr->mUiMessageFilter = QS_PAINT;
        // vc6 hack
        //clientProgressPtr->mProgressCallback = myCallback;
        clientProgressPtr->mProgressCallback = RCF::ClientProgress::ProgressCallback(&myCallback);

        gEventCallbacks = 0;
        gTimerCallbacks = 0;
        gMessageFilterCallbacks = 0;
        gAction = RCF::ClientProgress::Continue;

        s = client.echo(s0, 1000*5);
        BOOST_CHECK(gEventCallbacks > 0);
        BOOST_CHECK(gTimerCallbacks > 0);
        BOOST_CHECK(gMessageFilterCallbacks == 0); // no UI thread running anyway...
    }

    {
        clientProgressPtr->mTriggerMask = RCF::ClientProgress::Event;
        clientProgressPtr->mTimerIntervalMs = 500;
        clientProgressPtr->mUiMessageFilter = QS_PAINT;
        //clientProgressPtr->mProgressCallback = myCallback;
        clientProgressPtr->mProgressCallback = RCF::ClientProgress::ProgressCallback(&myCallback);

        gEventCallbacks = 0;
        gTimerCallbacks = 0;
        gMessageFilterCallbacks = 0;
        gAction = RCF::ClientProgress::Continue;

        s = client.echo(s0, 1000*5);
        BOOST_CHECK(gEventCallbacks > 0);
        BOOST_CHECK(gTimerCallbacks == 0);
        BOOST_CHECK(gMessageFilterCallbacks == 0); // no UI thread running anyway...
    }

    {
        clientProgressPtr->mTriggerMask = RCF::ClientProgress::Timer;
        clientProgressPtr->mTimerIntervalMs = 500;
        clientProgressPtr->mUiMessageFilter = QS_PAINT;
        //clientProgressPtr->mProgressCallback = myCallback;
        clientProgressPtr->mProgressCallback = RCF::ClientProgress::ProgressCallback(&myCallback);

        gEventCallbacks = 0;
        gTimerCallbacks = 0;
        gMessageFilterCallbacks = 0;
        gAction = RCF::ClientProgress::Continue;

        s = client.echo(s0, 1000*5);
        BOOST_CHECK(gEventCallbacks == 0);
        BOOST_CHECK(gTimerCallbacks > 0);
        BOOST_CHECK(gMessageFilterCallbacks == 0); // no UI thread running anyway...
    }

    {
        clientProgressPtr->mTriggerMask = RCF::ClientProgress::UiMessage;
        clientProgressPtr->mTimerIntervalMs = 500;
        clientProgressPtr->mUiMessageFilter = QS_PAINT;
        //clientProgressPtr->mProgressCallback = myCallback;
        clientProgressPtr->mProgressCallback = RCF::ClientProgress::ProgressCallback(&myCallback);

        gEventCallbacks = 0;
        gTimerCallbacks = 0;
        gMessageFilterCallbacks = 0;
        gAction = RCF::ClientProgress::Continue;

        s = client.echo(s0, 1000*5);
        BOOST_CHECK(gEventCallbacks == 0);
        BOOST_CHECK(gTimerCallbacks == 0);
        BOOST_CHECK(gMessageFilterCallbacks == 0); // no UI thread running anyway...
    }

    {
        clientProgressPtr->mTriggerMask = RCF::ClientProgress::Event;
        clientProgressPtr->mTimerIntervalMs = 500;
        clientProgressPtr->mUiMessageFilter = QS_PAINT;
        //clientProgressPtr->mProgressCallback = myCallback;
        clientProgressPtr->mProgressCallback = RCF::ClientProgress::ProgressCallback(&myCallback);

        gEventCallbacks = 0;
        gTimerCallbacks = 0;
        gMessageFilterCallbacks = 0;
        gAction = RCF::ClientProgress::Cancel;

        try
        {
            s = client.echo(s0, 1000*5);
            BOOST_CHECK(1==0);
        }
        catch (const RCF::Exception &e)
        {
            BOOST_CHECK(1==1);
            BOOST_CHECK(e.getError() == RCF::RcfError_ClientCancel);
            BOOST_CHECK(gEventCallbacks > 0);
            BOOST_CHECK(gTimerCallbacks == 0);
            BOOST_CHECK(gMessageFilterCallbacks == 0); // no UI thread running anyway...
        }
    }

    {
        clientProgressPtr->mTriggerMask = RCF::ClientProgress::Timer;
        clientProgressPtr->mTimerIntervalMs = 500;
        clientProgressPtr->mUiMessageFilter = QS_PAINT;
        //clientProgressPtr->mProgressCallback = myCallback;
        clientProgressPtr->mProgressCallback = RCF::ClientProgress::ProgressCallback(&myCallback);

        gEventCallbacks = 0;
        gTimerCallbacks = 0;
        gMessageFilterCallbacks = 0;
        gAction = RCF::ClientProgress::Cancel;

        try
        {
            s = client.echo(s0, 1000*5);
            BOOST_CHECK(1==0);
        }
        catch (const RCF::Exception &e)
        {
            BOOST_CHECK(1==1);
            BOOST_CHECK(e.getError() == RCF::RcfError_ClientCancel);
            BOOST_CHECK(gEventCallbacks == 0);
            BOOST_CHECK(gTimerCallbacks > 0);
            BOOST_CHECK(gMessageFilterCallbacks == 0); // no UI thread running anyway...
        }
    }

    return boost::exit_success;
}