MockUDPSocket.h

/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 *
 * MockUDPsocket.h
 * Header file for the Mock UDP Socket class
 * Copyright (C) 2010 Simon Newton
 */

#ifndef INCLUDE_OLA_TESTING_MOCKUDPSOCKET_H_
#define INCLUDE_OLA_TESTING_MOCKUDPSOCKET_H_

#include <cppunit/extensions/HelperMacros.h>

#include <ola/base/Macro.h>
#include <ola/network/IPV4Address.h>
#include <ola/network/Socket.h>
#include <ola/network/SocketAddress.h>

#include <string>
#include <queue>

namespace ola {
namespace testing {

/*
 * The MockUDPSocket allows one to stub out a UDP Socket for testing. The
 * code-under-test can use this object as it would a UDP socket, and the code
 * performing the test can verify that the data written matches what it
 * expects. It does this by calling AddExpectedData(), e.g.
 *
 *  // add the data we expect, you can call this more than once
 *  udp_socket.AddExpectedData(....);
 *  udp_socket.AddExpectedData(....);
 *  // this calls one of the SendTo methods
 *  MethodToTest(udp_socket);
 *  // verify all the expected data has been consumed
 *  udp_socket.Verify()
 *
 * You can also inject packets into the socket by calling InjectData(), this
 * will trigger the on_read callback that was attached to the socket.
 */
class MockUDPSocket: public ola::network::UDPSocketInterface {
 public:
    MockUDPSocket();
    ~MockUDPSocket() { Close(); }

    // These are the socket methods
    bool Init();
    bool Bind(const ola::network::IPV4SocketAddress &endpoint);
    bool GetSocketAddress(ola::network::IPV4SocketAddress *address) const;
    bool Close();
    ola::io::DescriptorHandle ReadDescriptor() const { return m_dummy_handle; }
    ola::io::DescriptorHandle WriteDescriptor() const { return m_dummy_handle; }
    ssize_t SendTo(const uint8_t *buffer,
                   unsigned int size,
                   const ola::network::IPV4Address &ip,
                   unsigned short port) const;
    ssize_t SendTo(const uint8_t *buffer,
                   unsigned int size,
                   const ola::network::IPV4SocketAddress &dest) const {
      return SendTo(buffer, size, dest.Host(), dest.Port());
    }
    ssize_t SendTo(ola::io::IOVecInterface *data,
                   const ola::network::IPV4Address &ip,
                   unsigned short port) const;
    ssize_t SendTo(ola::io::IOVecInterface *data,
                   const ola::network::IPV4SocketAddress &dest) const {
      return SendTo(data, dest.Host(), dest.Port());
    }

    bool RecvFrom(uint8_t *buffer, ssize_t *data_read) const;
    bool RecvFrom(uint8_t *buffer,
                  ssize_t *data_read,
                  ola::network::IPV4Address &source) const;  // NOLINT
    bool RecvFrom(uint8_t *buffer,
                  ssize_t *data_read,
                  ola::network::IPV4Address &source,  // NOLINT
                  uint16_t &port) const;  // NOLINT
    bool RecvFrom(uint8_t *buffer,
                  ssize_t *data_read,
                  ola::network::IPV4SocketAddress *source);
    bool EnableBroadcast();
    bool SetMulticastInterface(const ola::network::IPV4Address &iface);
    bool JoinMulticast(const ola::network::IPV4Address &iface,
                       const ola::network::IPV4Address &group,
                       bool multicast_loop = false);
    bool LeaveMulticast(const ola::network::IPV4Address &iface,
                        const ola::network::IPV4Address &group);

    bool SetTos(uint8_t tos);

    void SetDiscardMode(bool discard_mode) { m_discard_mode = discard_mode; }

    // these are methods used for verification
    void AddExpectedData(const uint8_t *data,
                         unsigned int size,
                         const ola::network::IPV4Address &ip,
                         uint16_t port);
    void AddExpectedData(ola::io::IOQueue *queue,
                         const ola::network::IPV4SocketAddress &dest);

    // this can be fetched by calling PerformRead() on the socket
    void InjectData(const uint8_t *data,
                    unsigned int size,
                    const ola::network::IPV4Address &ip,
                    uint16_t port);
    void InjectData(const uint8_t *data,
                    unsigned int size,
                    const ola::network::IPV4SocketAddress &source);
    void InjectData(ola::io::IOQueue *ioqueue,
                    const ola::network::IPV4SocketAddress &source);

    void Verify();

    bool CheckNetworkParamsMatch(bool init_called,
                                 bool bound_to_port,
                                 uint16_t port,
                                 bool broadcast_set);

    void SetInterface(const ola::network::IPV4Address &iface);

 private:
    typedef struct {
      const uint8_t *data;
      unsigned int size;
      ola::network::IPV4Address address;
      uint16_t port;
      bool free_data;
    } expected_call;

    typedef expected_call received_data;

    bool m_init_called;
    // We need a sd so that calls to select continue to work. This isn't used
    // for anything else.
    ola::io::DescriptorHandle m_dummy_handle;
    bool m_bound_to_port;
    bool m_broadcast_set;
    uint16_t m_port;
    uint8_t m_tos;
    mutable std::queue<expected_call> m_expected_calls;
    mutable std::queue<received_data> m_received_data;
    ola::network::IPV4Address m_interface;
    bool m_discard_mode;

    uint8_t* IOQueueToBuffer(ola::io::IOQueue *ioqueue,
                             unsigned int *size) const;

    DISALLOW_COPY_AND_ASSIGN(MockUDPSocket);
};


class SocketVerifier {
 public:
    explicit SocketVerifier(MockUDPSocket *socket)
        : m_socket(socket) {
    }
    ~SocketVerifier() {
      m_socket->Verify();
    }

 private:
    MockUDPSocket *m_socket;

    DISALLOW_COPY_AND_ASSIGN(SocketVerifier);
};
}  // namespace testing
}  // namespace ola
#endif  // INCLUDE_OLA_TESTING_MOCKUDPSOCKET_H_