Diff coverage report for

//

//

// Copyright (c) 2025 Vinnie Falco (vinnie dot falco at gmail dot com)

// Copyright (c) 2025 Vinnie Falco (vinnie dot falco at gmail dot com)

//

//

// Distributed under the Boost Software License, Version 1.0. (See accompanying

// Distributed under the Boost Software License, Version 1.0. (See accompanying

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//

//

// Official repository: https://github.com/cppalliance/corosio

// Official repository: https://github.com/cppalliance/corosio

//

//

#ifndef BOOST_COROSIO_TEST_MOCKET_HPP

#ifndef BOOST_COROSIO_TEST_MOCKET_HPP

#define BOOST_COROSIO_TEST_MOCKET_HPP

#define BOOST_COROSIO_TEST_MOCKET_HPP

#include <boost/corosio/detail/config.hpp>

#include <boost/corosio/detail/config.hpp>

#include <boost/corosio/tcp_socket.hpp>

#include <boost/corosio/tcp_socket.hpp>

#include <boost/capy/buffers/buffer_copy.hpp>

#include <boost/capy/buffers/buffer_copy.hpp>

#include <boost/capy/buffers/make_buffer.hpp>

#include <boost/capy/buffers/make_buffer.hpp>

#include <boost/capy/error.hpp>

#include <boost/capy/error.hpp>

#include <boost/capy/io_result.hpp>

#include <boost/capy/io_result.hpp>

#include <boost/capy/test/fuse.hpp>

#include <boost/capy/test/fuse.hpp>

#include <system_error>

#include <system_error>

#include <cstddef>

#include <cstddef>

#include <new>

#include <new>

#include <string>

#include <string>

#include <utility>

#include <utility>

namespace boost::capy {

namespace boost::capy {

class execution_context;

class execution_context;

} // namespace boost::capy

} // namespace boost::capy

namespace boost::corosio::test {

namespace boost::corosio::test {

/** A mock socket for testing I/O operations.

/** A mock socket for testing I/O operations.

    This class provides a testable socket-like interface where data

    This class provides a testable socket-like interface where data

    can be staged for reading and expected data can be validated on

    can be staged for reading and expected data can be validated on

    writes. A mocket is paired with a regular tcp_socket using

    writes. A mocket is paired with a regular tcp_socket using

    @ref make_mocket_pair, allowing bidirectional communication testing.

    @ref make_mocket_pair, allowing bidirectional communication testing.

    When reading, data comes from the `provide()` buffer first.

    When reading, data comes from the `provide()` buffer first.

    When writing, data is validated against the `expect()` buffer.

    When writing, data is validated against the `expect()` buffer.

    Once buffers are exhausted, I/O passes through to the underlying

    Once buffers are exhausted, I/O passes through to the underlying

    socket connection.

    socket connection.

    Satisfies the `capy::Stream` concept.

    Satisfies the `capy::Stream` concept.

    @par Thread Safety

    @par Thread Safety

    Not thread-safe. All operations must occur on a single thread.

    Not thread-safe. All operations must occur on a single thread.

    All coroutines using the mocket must be suspended when calling

    All coroutines using the mocket must be suspended when calling

    `expect()` or `provide()`.

    `expect()` or `provide()`.

    @see make_mocket_pair

    @see make_mocket_pair

*/

*/

class BOOST_COROSIO_DECL mocket

class BOOST_COROSIO_DECL mocket

{

{

    tcp_socket sock_;

    tcp_socket sock_;

    std::string provide_;

    std::string provide_;

    std::string expect_;

    std::string expect_;

    capy::test::fuse* fuse_;

    capy::test::fuse* fuse_;

    std::size_t max_read_size_;

    std::size_t max_read_size_;

    std::size_t max_write_size_;

    std::size_t max_write_size_;

    template<class MutableBufferSequence>

    template<class MutableBufferSequence>

    std::size_t

    std::size_t

    consume_provide(MutableBufferSequence const& buffers) noexcept;

    consume_provide(MutableBufferSequence const& buffers) noexcept;

    template<class ConstBufferSequence>

    template<class ConstBufferSequence>

    bool

    bool

    validate_expect(

    validate_expect(

        ConstBufferSequence const& buffers,

        ConstBufferSequence const& buffers,

        std::size_t& bytes_written);

        std::size_t& bytes_written);

public:

public:

    template<class MutableBufferSequence>

    template<class MutableBufferSequence>

    class read_some_awaitable;

    class read_some_awaitable;

    template<class ConstBufferSequence>

    template<class ConstBufferSequence>

    class write_some_awaitable;

    class write_some_awaitable;

    /** Destructor.

    /** Destructor.

    */

    */

    ~mocket();

    ~mocket();

    /** Construct a mocket.

    /** Construct a mocket.

        @param ctx The execution context for the socket.

        @param ctx The execution context for the socket.

        @param f The fuse for error injection testing.

        @param f The fuse for error injection testing.

        @param max_read_size Maximum bytes per read operation.

        @param max_read_size Maximum bytes per read operation.

        @param max_write_size Maximum bytes per write operation.

        @param max_write_size Maximum bytes per write operation.

    */

    */

    mocket(

    mocket(

        capy::execution_context& ctx,

        capy::execution_context& ctx,

        capy::test::fuse& f,

        capy::test::fuse& f,

        std::size_t max_read_size = std::size_t(-1),

        std::size_t max_read_size = std::size_t(-1),

        std::size_t max_write_size = std::size_t(-1));

        std::size_t max_write_size = std::size_t(-1));

    /** Move constructor.

    /** Move constructor.

    */

    */

    mocket(mocket&& other) noexcept;

    mocket(mocket&& other) noexcept;

    /** Move assignment.

    /** Move assignment.

    */

    */

    mocket& operator=(mocket&& other) noexcept;

    mocket& operator=(mocket&& other) noexcept;

    mocket(mocket const&) = delete;

    mocket(mocket const&) = delete;

    mocket& operator=(mocket const&) = delete;

    mocket& operator=(mocket const&) = delete;

    /** Return the execution context.

    /** Return the execution context.

        @return Reference to the execution context that owns this mocket.

        @return Reference to the execution context that owns this mocket.

    */

    */

    capy::execution_context&

    capy::execution_context&

    context() const noexcept

    context() const noexcept

    {

    {

        return sock_.context();

        return sock_.context();

    }

    }

    /** Return the underlying socket.

    /** Return the underlying socket.

        @return Reference to the underlying tcp_socket.

        @return Reference to the underlying tcp_socket.

    */

    */

    tcp_socket&

    tcp_socket&

    {

    {

    }

    }

    /** Stage data for reads.

    /** Stage data for reads.

        Appends the given string to this mocket's provide buffer.

        Appends the given string to this mocket's provide buffer.

        When `read_some` is called, it will receive this data first

        When `read_some` is called, it will receive this data first

        before reading from the underlying socket.

        before reading from the underlying socket.

        @param s The data to provide.

        @param s The data to provide.

        @pre All coroutines using this mocket must be suspended.

        @pre All coroutines using this mocket must be suspended.

    */

    */

    void provide(std::string s);

    void provide(std::string s);

    /** Set expected data for writes.

    /** Set expected data for writes.

        Appends the given string to this mocket's expect buffer.

        Appends the given string to this mocket's expect buffer.

        When the caller writes to this mocket, the written data

        When the caller writes to this mocket, the written data

        must match the expected data. On mismatch, `fuse::fail()`

        must match the expected data. On mismatch, `fuse::fail()`

        is called.

        is called.

        @param s The expected data.

        @param s The expected data.

        @pre All coroutines using this mocket must be suspended.

        @pre All coroutines using this mocket must be suspended.

    */

    */

    void expect(std::string s);

    void expect(std::string s);

    /** Close the mocket and verify test expectations.

    /** Close the mocket and verify test expectations.

        Closes the underlying socket and verifies that both the

        Closes the underlying socket and verifies that both the

        `expect()` and `provide()` buffers are empty. If either

        `expect()` and `provide()` buffers are empty. If either

        buffer contains unconsumed data, returns `test_failure`

        buffer contains unconsumed data, returns `test_failure`

        and calls `fuse::fail()`.

        and calls `fuse::fail()`.

        @return An error code indicating success or failure.

        @return An error code indicating success or failure.

            Returns `error::test_failure` if buffers are not empty.

            Returns `error::test_failure` if buffers are not empty.

    */

    */

    std::error_code close();

    std::error_code close();

    /** Cancel pending I/O operations.

    /** Cancel pending I/O operations.

        Cancels any pending asynchronous operations on the underlying

        Cancels any pending asynchronous operations on the underlying

        socket. Outstanding operations complete with `cond::canceled`.

        socket. Outstanding operations complete with `cond::canceled`.

    */

    */

    void cancel();

    void cancel();

    /** Check if the mocket is open.

    /** Check if the mocket is open.

        @return `true` if the mocket is open.

        @return `true` if the mocket is open.

    */

    */

    bool is_open() const noexcept;

    bool is_open() const noexcept;

    /** Initiate an asynchronous read operation.

    /** Initiate an asynchronous read operation.

        Reads available data into the provided buffer sequence. If the

        Reads available data into the provided buffer sequence. If the

        provide buffer has data, it is consumed first. Otherwise, the

        provide buffer has data, it is consumed first. Otherwise, the

        operation delegates to the underlying socket.

        operation delegates to the underlying socket.

        @param buffers The buffer sequence to read data into.

        @param buffers The buffer sequence to read data into.

        @return An awaitable yielding `(error_code, std::size_t)`.

        @return An awaitable yielding `(error_code, std::size_t)`.

    */

    */

    template<class MutableBufferSequence>

    template<class MutableBufferSequence>

    {

    {

    }

    }

    /** Initiate an asynchronous write operation.

    /** Initiate an asynchronous write operation.

        Writes data from the provided buffer sequence. If the expect

        Writes data from the provided buffer sequence. If the expect

        buffer has data, it is validated. Otherwise, the operation

        buffer has data, it is validated. Otherwise, the operation

        delegates to the underlying socket.

        delegates to the underlying socket.

        @param buffers The buffer sequence containing data to write.

        @param buffers The buffer sequence containing data to write.

        @return An awaitable yielding `(error_code, std::size_t)`.

        @return An awaitable yielding `(error_code, std::size_t)`.

    */

    */

    template<class ConstBufferSequence>

    template<class ConstBufferSequence>

    {

    {

    }

    }

};

};

//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

template<class MutableBufferSequence>

template<class MutableBufferSequence>

std::size_t

std::size_t

consume_provide(MutableBufferSequence const& buffers) noexcept

consume_provide(MutableBufferSequence const& buffers) noexcept

{

{

}

}

template<class ConstBufferSequence>

template<class ConstBufferSequence>

bool

bool

validate_expect(

validate_expect(

    ConstBufferSequence const& buffers,

    ConstBufferSequence const& buffers,

    std::size_t& bytes_written)

    std::size_t& bytes_written)

{

{

    // Build the write data up to max_write_size_

    // Build the write data up to max_write_size_

    // Check if written data matches expect prefix

    // Check if written data matches expect prefix

    {

    {

    }

    }

    // Consume matched portion

    // Consume matched portion

//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

template<class MutableBufferSequence>

template<class MutableBufferSequence>

class mocket::read_some_awaitable

class mocket::read_some_awaitable

{

{

    using sock_awaitable =

    using sock_awaitable =

        decltype(std::declval<tcp_socket&>().read_some(

        decltype(std::declval<tcp_socket&>().read_some(

            std::declval<MutableBufferSequence>()));

            std::declval<MutableBufferSequence>()));

    mocket* m_;

    mocket* m_;

    MutableBufferSequence buffers_;

    MutableBufferSequence buffers_;

    std::size_t n_ = 0;

    std::size_t n_ = 0;

    union {

    union {

        char dummy_;

        char dummy_;

        sock_awaitable underlying_;

        sock_awaitable underlying_;

    };

    };

    bool sync_ = true;

    bool sync_ = true;

public:

public:

        mocket& m,

        mocket& m,

        MutableBufferSequence buffers) noexcept

        MutableBufferSequence buffers) noexcept

    {

    {

    {

    {

    {

    {

        {

        {

        }

        }

    read_some_awaitable(read_some_awaitable const&) = delete;

    read_some_awaitable(read_some_awaitable const&) = delete;

    read_some_awaitable& operator=(read_some_awaitable const&) = delete;

    read_some_awaitable& operator=(read_some_awaitable const&) = delete;

    read_some_awaitable& operator=(read_some_awaitable&&) = delete;

    read_some_awaitable& operator=(read_some_awaitable&&) = delete;

    {

    {

        {

        {

        }

        }

    }

    }

    template<class... Args>

    template<class... Args>

    {

    {

    }

    }

    {

    {

    }

    }

};

};

//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

template<class ConstBufferSequence>

template<class ConstBufferSequence>

class mocket::write_some_awaitable

class mocket::write_some_awaitable

{

{

    using sock_awaitable =

    using sock_awaitable =

        decltype(std::declval<tcp_socket&>().write_some(

        decltype(std::declval<tcp_socket&>().write_some(

            std::declval<ConstBufferSequence>()));

            std::declval<ConstBufferSequence>()));

    mocket* m_;

    mocket* m_;

    ConstBufferSequence buffers_;

    ConstBufferSequence buffers_;

    std::size_t n_ = 0;

    std::size_t n_ = 0;

    std::error_code ec_;

    std::error_code ec_;

    union {

    union {

        char dummy_;

        char dummy_;

        sock_awaitable underlying_;

        sock_awaitable underlying_;

    };

    };

    bool sync_ = true;

    bool sync_ = true;

public:

public:

        mocket& m,

        mocket& m,

        ConstBufferSequence buffers) noexcept

        ConstBufferSequence buffers) noexcept

    {

    {

    {

    {

    {

    {

        {

        {

        }

        }

    write_some_awaitable(write_some_awaitable const&) = delete;

    write_some_awaitable(write_some_awaitable const&) = delete;

    write_some_awaitable& operator=(write_some_awaitable const&) = delete;

    write_some_awaitable& operator=(write_some_awaitable const&) = delete;

    write_some_awaitable& operator=(write_some_awaitable&&) = delete;

    write_some_awaitable& operator=(write_some_awaitable&&) = delete;

    {

    {

        {

        {

            {

            {

            }

            }

        }

        }

    }

    }

    template<class... Args>

    template<class... Args>

    {

    {

    }

    }

    {

    {

    }

    }

};

};

//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

/** Create a mocket paired with a socket.

/** Create a mocket paired with a socket.

    Creates a mocket and a tcp_socket connected via loopback.

    Creates a mocket and a tcp_socket connected via loopback.

    Data written to one can be read from the other.

    Data written to one can be read from the other.

    The mocket has fuse checks enabled via `maybe_fail()` and

    The mocket has fuse checks enabled via `maybe_fail()` and

    supports provide/expect buffers for test instrumentation.

    supports provide/expect buffers for test instrumentation.

    The tcp_socket is the "peer" end with no test instrumentation.

    The tcp_socket is the "peer" end with no test instrumentation.

    Optional max_read_size and max_write_size parameters limit the

    Optional max_read_size and max_write_size parameters limit the

    number of bytes transferred per I/O operation on the mocket,

    number of bytes transferred per I/O operation on the mocket,

    simulating chunked network delivery for testing purposes.

    simulating chunked network delivery for testing purposes.

    @param ctx The execution context for the sockets.

    @param ctx The execution context for the sockets.

    @param f The fuse for error injection testing.

    @param f The fuse for error injection testing.

    @param max_read_size Maximum bytes per read operation (default unlimited).

    @param max_read_size Maximum bytes per read operation (default unlimited).

    @param max_write_size Maximum bytes per write operation (default unlimited).

    @param max_write_size Maximum bytes per write operation (default unlimited).

    @return A pair of (mocket, tcp_socket).

    @return A pair of (mocket, tcp_socket).

    @note Mockets are not thread-safe and must be used in a

    @note Mockets are not thread-safe and must be used in a

        single-threaded, deterministic context.

        single-threaded, deterministic context.

*/

*/

BOOST_COROSIO_DECL

BOOST_COROSIO_DECL

std::pair<mocket, tcp_socket>

std::pair<mocket, tcp_socket>

make_mocket_pair(

make_mocket_pair(

    capy::execution_context& ctx,

    capy::execution_context& ctx,

    capy::test::fuse& f,

    capy::test::fuse& f,

    std::size_t max_read_size = std::size_t(-1),

    std::size_t max_read_size = std::size_t(-1),

    std::size_t max_write_size = std::size_t(-1));

    std::size_t max_write_size = std::size_t(-1));

} // namespace boost::corosio::test

} // namespace boost::corosio::test

#endif

#endif