MocksTest.cpp

Go to the documentation of this file.

/*

Copyright (C) 2006-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

Calitko is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#include "Qt.h"
#include "../Mocks.h"
#include "Imports.cpp"

/*
    This whole file requires revising! The examples should use the mock and
    driver code generator, so that modifying the implementations should not
    require reqriting of these examples.
*/
#if 0

using std::string;

namespace Utils {
namespace CalitkoMocks {
namespace Testing {


class IntCalculator
{
public:
    int     add (int a, int b)      { return a + b; }
    int     mul (int a, int b)      { return a * b; }
    int     div (int a, int b)      { return a / b; }
    int     mod (int a, int b)      { return a % b; }
};


class IntCalculatorDriver
{
    TEST_DRIVER_FOR (IntCalculator);

public:
    BOUND_FUNCTION_FACTORY2 (add, int, int, int);
    BOUND_FUNCTION_FACTORY2 (mul, int, int, int);
    BOUND_FUNCTION_FACTORY2 (div, int, int, int);
    BOUND_FUNCTION_FACTORY2 (mod, int, int, int);
};


class Server : public QObject
{
    Q_OBJECT

public slots:
    virtual void    connectTo (int number) = 0;
    virtual void    login (const string &username, const string &password) = 0;
    virtual void    disconnect() = 0;
    virtual void    sendMessage (const string &) = 0;

signals:
    void    connected();
    void    disconnected();
    void    loginSucceeded();
    void    loginFailed();
    void    messageReceived  (string);
};

class ServerMock : public MockBase
{
public:
    MOCK_FOR (Server);

    EXPECTED_FUNCTION_FACTORY1 (0, connectTo, void, int);
    EXPECTED_FUNCTION_FACTORY2 (0, login, void, const string &, const string &);
    EXPECTED_FUNCTION_FACTORY0 (0, disconnect, void);
    EXPECTED_FUNCTION_FACTORY1 (0, sendMessage, void, const string &);

private:
    class ServerImp : public Server
    {
    public:
        ServerImp (ServerMock &m) : mock (m) {}

        EXPECTED_FUNCTION_CHECKER1 (0, connectTo, void, int);
        EXPECTED_FUNCTION_CHECKER2 (0, login, void, const string &, const string &);
        EXPECTED_FUNCTION_CHECKER0 (0, disconnect, void);
        EXPECTED_FUNCTION_CHECKER1 (0, sendMessage, void, const string &);

        ServerMock  &mock;
    };
    ServerImp       imp_;
    friend class    ServerImp;
};

class Client : public QObject
{
    Q_OBJECT
    CALITKO_TESTABLE;

public:
    enum State
    {
        Disconnected,
        Connecting,
        Authenticating,
        Authenticated,
        Disconnecting,
    };

            Client (Server *server);
    void    joinChat (int serverNumber, const string &user, const string &pass);
    void    sendMessage (const string &message);
    void    leaveChat();

private slots:
    void    connected();
    void    disconnected();
    void    loginSucceeded();
    void    loginFailed();
    void    messageReceived  (string);

signals:
    void    connectedToServer();
    void    disconnectedFromServer();

private:
    Server  *server_;
    int     serverNumber_;
    string  userName_;
    string  password_;
    State   state_;
};

class ClientDriver : public QObject
{
    Q_OBJECT
    TEST_DRIVER_FOR (Client);

public:
    ClientDriver (Server *server) : object (server)
    {
        MONITOR_SIGNAL (connectedToServer());
        MONITOR_SIGNAL (disconnectedFromServer());
    }

    BOUND_FUNCTION_FACTORY3 (joinChat, void, int, const string &, const string &);
    BOUND_FUNCTION_FACTORY1 (sendMessage, void, const string &);
    BOUND_FUNCTION_FACTORY0 (leaveChat, void);
    BOUND_FUNCTION_FACTORY0 (connected, void);
    BOUND_FUNCTION_FACTORY0 (disconnected, void);
    BOUND_FUNCTION_FACTORY0 (loginSucceeded, void);
    BOUND_FUNCTION_FACTORY1 (messageReceived, void, string);

    EXPECTED_FUNCTION_FACTORY0 (0, connectedToServer, void);
    EXPECTED_FUNCTION_FACTORY0 (0, disconnectedFromServer, void);

private slots:
    void _checker_connectedToServer()
    {
        EXPECTED_SIGNAL_CHECKER0 (0, connectedToServer);
    }

    void _checker_disconnectedFromServer()
    {
        EXPECTED_SIGNAL_CHECKER0 (0, disconnectedFromServer);
    }
};

Client::Client (Server *server)
{
    server_ = server;
    serverNumber_ = 0;
    /* A typical implementation would connect the server's signals with the
    private slots of this, but we don't need to do that for our sample test to
    work */
}

void Client::joinChat (int serverNumber, const string &user, const string &pass)
{
    state_ = Connecting;
    userName_ = user;
    password_ = pass;
    server_->connectTo (serverNumber);
}

void Client::leaveChat()
{
    state_ = Disconnecting;
    server_->disconnect();
}

void Client::connected()
{
    state_ = Authenticating;
    server_->login (userName_, password_);
}

void Client::disconnected()
{
    state_ = Disconnected;
}

void Client::loginSucceeded()
{
    state_ = Authenticated;
    emit connectedToServer();
}

void Client::loginFailed()
{
    leaveChat();
}

void Client::sendMessage (const string &message)
{
    server_->sendMessage (message);
}

void Client::messageReceived (string)
{
}

class ServerRequests
{
public:
    virtual void    connectTo (int number) = 0;
    virtual void    login (const string &username, const string &password) = 0;
    virtual void    disconnect() = 0;
    virtual void    sendMessage (const string &) = 0;
};

class ServerResponses
{
public:
    virtual void    connected() = 0;
    virtual void    disconnected() = 0;
    virtual void    loginSucceeded() = 0;
    virtual void    loginFailed() = 0;
    virtual void    messageReceived  (string) = 0;
};


class MocksTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (MocksTest);
    CPPUNIT_TEST (testIntCalculatorCppUnit);
    CPPUNIT_TEST (testIntCalculatorCalitko);
    CPPUNIT_TEST (testServerLoginOk);
    CPPUNIT_TEST_SUITE_END();

public:

    void testIntCalculatorCppUnit()
    {
        IntCalculator calc;
        CPPUNIT_ASSERT (calc.add (1, 2) == 3);
        CPPUNIT_ASSERT (calc.mul (1, 2) == 2);
        CPPUNIT_ASSERT (calc.div (1, 2) == 0);
        CPPUNIT_ASSERT (calc.mod (1, 2) == 1);
    }

    void testIntCalculatorCalitko()
    {
        IntCalculatorDriver calc;
        call (calc.add (1, 2)).willReturn (3);
        call (calc.mul (1, 2)).willReturn (2);
        call (calc.div (1, 2)).willReturn (0);
        call (calc.mod (1, 2)).willReturn (1);
    }

    void testServerLoginOk()
    {
        ServerMock server;
        ClientDriver client (server.imp());

        call (client.joinChat (4, "peter", "mypassword"))
            .willCall (server.connectTo (4))
            .returns()
        .returns();

        server.calls (client.connected())
            .willCall (server.login ("peter", "mypassword"))
            .returns()
        .returns();

        server.calls (client.loginSucceeded())
            .willEmit (client.connectedToServer())
        .returns();
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION (MocksTest);

} // namespace Testing
} // namespace CalitkoMocks
} // namespace Utils

#include "MocksTest.moc"

#endif // 0

Copyright © 2006 Peter Dimov.
Powered by Doxygen.