test_generators.hpp

Go to the documentation of this file.

#ifndef TEST_GENERATORS_HPP
#define TEST_GENERATORS_HPP
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion" // turn off warning for rapidcheck
#endif
#include <rapidcheck/gtest.h>
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
 
#include <algorithm>
#include <utility>
#include <string>
#include <tuple>
#include <array>
#include <string_view>
#include <bitset>
#include <sstream>
#include <vector>
 
#include "openvpn/addr/ip.hpp"
#include "openvpn/tun/builder/capture.hpp"
 
namespace rc {
 
template <size_t N>
auto atLeastOneFalse() -> Gen<std::array<bool, N>>
{
    static_assert(N > 0, "N must be greater than 0");
 
    return gen::suchThat(
        gen::container<std::array<bool, N>>(gen::arbitrary<bool>()),
        [](const auto &booleans)
        {
            return std::any_of(booleans.begin(), booleans.end(), [](const bool b)
                               { return !b; });
        });
}
 
template <size_t N>
auto generateValidityFlags(const bool all_valid = true) -> Gen<std::array<bool, N>>
{
    if (all_valid)
    {
        return gen::container<std::array<bool, N>>(gen::just(true));
    }
    return atLeastOneFalse<N>();
}
 
inline auto IPv4Octet(const bool valid = true) -> Gen<int>
{
    static constexpr int min_ipv4_octet = 0;
    static constexpr int max_ipv4_octet = 255;
 
    if (valid)
    {
        return gen::inRange(min_ipv4_octet, max_ipv4_octet + 1);
    }
    return gen::suchThat(gen::arbitrary<int>(), [](const auto &i)
                         { return i < min_ipv4_octet || i > max_ipv4_octet; });
}
 
inline auto IPv4Address(const bool valid = true) -> Gen<std::string>
{
    static constexpr int octets_number = 4;
    static constexpr std::array<bool, octets_number> all_true = {true, true, true, true};
    const auto octet_validity = valid ? all_true : *atLeastOneFalse<octets_number>().as("first,second,third,fourth octet valid");
 
    return gen::map(
        gen::tuple(IPv4Octet(octet_validity[0]),
                   IPv4Octet(octet_validity[1]),
                   IPv4Octet(octet_validity[2]),
                   IPv4Octet(octet_validity[3])),
        [](const auto &octets)
        {
            return std::to_string(std::get<0>(octets)) + "." + std::to_string(std::get<1>(octets)) + "."
                   + std::to_string(std::get<2>(octets)) + "." + std::to_string(std::get<3>(octets));
        });
}
 
inline auto asciiPrintableCode() -> Gen<int>
{
    static constexpr int ASCII_range_start_code = 32;  // ASCII code for space character
    static constexpr int ASCII_range_end_code = 127;   // ASCII code for DEL (not included)
    static constexpr int ASCII_percent_sign_code = 37; // ASCII code for percent sign
 
    // Due to IPv6 Scoped Address Architecture (RFC 4007) anything after '%' is not part of IPv6 address but zone_id
    // Therefore generating '% breaks assumption on validity of generated IPv6 addresses
    return gen::distinctFrom(gen::inRange(ASCII_range_start_code, ASCII_range_end_code), ASCII_percent_sign_code);
}
 
inline auto hexChar(const bool valid = true) -> Gen<std::string>
{
    if (valid)
    {
        const auto alphapositives = gen::elementOf(std::string("abcdefABCDEF123456789"));
 
        static constexpr int probability_weight_of_0 = 23;
        static constexpr int probability_weight_of_alphapositives = 1;
 
        // "0" should be generated <probability_weight_of_0> times more often
        return gen::map(gen::weightedOneOf<char>({{probability_weight_of_0, gen::just<char>('0')},
                                                  {probability_weight_of_alphapositives, alphapositives}}),
                        [](const auto &c)
                        {
                            return std::string{static_cast<char>(c)};
                        });
    }
 
    // Generate invalid hexadecimal characters
    return gen::map(gen::suchThat(asciiPrintableCode(), [](const auto &c)
                                  { return isxdigit(c) == 0; }),
                    [](const auto &c)
                    {
                        return std::string{static_cast<char>(c)};
                    });
}
 
inline auto IPv6HextetValue(const bool valid = true) -> Gen<std::string>
{
    static constexpr int hexchars_number = 4;
    static constexpr std::array<bool, hexchars_number> all_true = {true, true, true, true};
    const auto hexchar_validity = valid ? all_true : *atLeastOneFalse<hexchars_number>().as("first,second,third,fourth hexchar in hextet valid");
 
    return gen::map(
        gen::tuple(hexChar(hexchar_validity[0]),
                   hexChar(hexchar_validity[1]),
                   hexChar(hexchar_validity[2]),
                   hexChar(hexchar_validity[3])),
        [](const auto &hexchars)
        {
            const auto &[first_hexchar, second_hexchar, third_hexchar, fourth_hexchar] = hexchars;
            return first_hexchar + second_hexchar + third_hexchar + fourth_hexchar;
        });
}
 
inline std::string removeLeadingZerosFromHextet(const std::string &hextet)
{
    const auto first_nonzero = hextet.find_first_not_of('0');
    return first_nonzero == std::string::npos ? "0" : hextet.substr(first_nonzero);
}
 
inline void removeLeadingZerosFromHextets(std::vector<std::string> &hextets)
{
    std::transform(hextets.begin(), hextets.end(), hextets.begin(), removeLeadingZerosFromHextet);
}
 
inline void replaceSequenceOfZerosWithDoubleColon(std::vector<std::string> &hextets)
{
    for (auto longest_zero_sequence = hextets.size(); longest_zero_sequence > 1; --longest_zero_sequence)
    {
        auto position = std::search_n(hextets.begin(), hextets.end(), longest_zero_sequence, std::string{"0"});
        if (position != hextets.end())
        {
            const auto it = hextets.insert(position, "::");
            hextets.erase(it + 1, std::next(it + 1, longest_zero_sequence));
            return;
        }
    }
}
 
inline std::string stringifyHextetsToAddressWithColons(const std::vector<std::string> &hextets)
{
    std::string result;
    for (size_t i = 0; i < hextets.size(); ++i)
    {
        if (i > 0 && hextets[i] != "::" && hextets[i - 1] != "::")
        {
            result += ":";
        }
        result += hextets[i];
    }
    return result;
}
 
inline std::string compressIPv6Address(std::vector<std::string> hextets)
{
    removeLeadingZerosFromHextets(hextets);
    replaceSequenceOfZerosWithDoubleColon(hextets);
    return stringifyHextetsToAddressWithColons(hextets);
}
 
inline auto IPv6Address(const bool valid = true) -> Gen<std::string>
{
    static constexpr int number_of_hextets = 8;
    static constexpr std::array<bool, number_of_hextets> all_true = {true, true, true, true, true, true, true, true};
    const auto hextet_validity = valid ? all_true : *atLeastOneFalse<number_of_hextets>().as("first,second,third,fourth,fifth,sixth,seventh,eighth hextet valid");
 
    auto convert_hextets_to_compressed_address = [](std::string first_hextet,
                                                    std::string second_hextet,
                                                    std::string third_hextet,
                                                    std::string fourth_hextet,
                                                    std::string fifth_hextet,
                                                    std::string sixth_hextet,
                                                    std::string seventh_hextet,
                                                    std::string eighth_hextet)
    {
        return compressIPv6Address({std::move(first_hextet),
                                    std::move(second_hextet),
                                    std::move(third_hextet),
                                    std::move(fourth_hextet),
                                    std::move(fifth_hextet),
                                    std::move(sixth_hextet),
                                    std::move(seventh_hextet),
                                    std::move(eighth_hextet)});
    };
 
    if (valid)
    {
        return gen::apply(convert_hextets_to_compressed_address,
                          IPv6HextetValue(hextet_validity[0]),
                          IPv6HextetValue(hextet_validity[1]),
                          IPv6HextetValue(hextet_validity[2]),
                          IPv6HextetValue(hextet_validity[3]),
                          IPv6HextetValue(hextet_validity[4]),
                          IPv6HextetValue(hextet_validity[5]),
                          IPv6HextetValue(hextet_validity[6]),
                          IPv6HextetValue(hextet_validity[7]));
    }
    return gen::map(gen::tuple(
                        IPv6HextetValue(hextet_validity[0]),
                        IPv6HextetValue(hextet_validity[1]),
                        IPv6HextetValue(hextet_validity[2]),
                        IPv6HextetValue(hextet_validity[3]),
                        IPv6HextetValue(hextet_validity[4]),
                        IPv6HextetValue(hextet_validity[5]),
                        IPv6HextetValue(hextet_validity[6]),
                        IPv6HextetValue(hextet_validity[7])),
                    [](const auto &hextets)
                    {
                        const auto [first_hextet, second_hextet, third_hextet, fourth_hextet, fifth_hextet, sixth_hextet, seventh_hextet, eighth_hextet] = hextets;
                        return first_hextet + ":" + second_hextet + ":" + third_hextet + ":" + fourth_hextet + ":" + fifth_hextet + ":" + sixth_hextet + ":" + seventh_hextet + ":" + eighth_hextet;
                    });
}
 
using RedirectGatewayFlagsValues = openvpn::RedirectGatewayFlags::Flags;
 
template <>
struct Arbitrary<RedirectGatewayFlagsValues>
{
    static Gen<RedirectGatewayFlagsValues> arbitrary()
    {
        static constexpr int number_of_flags = 9;
        return gen::map(
            gen::container<std::vector<int>>(gen::inRange(0, number_of_flags + 1)),
            [](const auto &bit_positions)
            {
                auto flags = static_cast<RedirectGatewayFlagsValues>(0);
                for (const auto &pos : bit_positions)
                {
                    flags = static_cast<RedirectGatewayFlagsValues>(flags | (1 << pos));
                }
                return flags;
            });
    }
};
 
template <>
struct Arbitrary<openvpn::TunBuilderCapture::RouteBase>
{
    static auto arbitrary() -> Gen<openvpn::TunBuilderCapture::RouteBase>
    {
        return gen::just(openvpn::TunBuilderCapture::RouteBase{});
    }
};
 
template <>
struct Arbitrary<openvpn::TunBuilderCapture::Route>
{
    static auto arbitrary() -> Gen<openvpn::TunBuilderCapture::Route>
    {
        return gen::just(openvpn::TunBuilderCapture::Route{});
    }
};
 
template <>
struct Arbitrary<openvpn::TunBuilderCapture::RouteAddress>
{
    static auto arbitrary() -> Gen<openvpn::TunBuilderCapture::RouteAddress>
    {
        return gen::just(openvpn::TunBuilderCapture::RouteAddress{});
    }
};
 
using RouteBased = std::variant<openvpn::TunBuilderCapture::Route,
                                openvpn::TunBuilderCapture::RouteAddress,
                                openvpn::TunBuilderCapture::RouteBase>;
 
template <typename T, typename... Ts>
struct Arbitrary<std::variant<T, Ts...>>
{
    static auto arbitrary() -> Gen<std::variant<T, Ts...>>
    {
        return gen::oneOf(
            gen::cast<std::variant<T, Ts...>>(gen::arbitrary<T>()),
            gen::cast<std::variant<T, Ts...>>(gen::arbitrary<Ts>())...);
    }
};
 
static const std::string ALPHA_CHARACTERS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
static const std::string DIGITS = "1234567890";
 
inline auto alpha(const bool valid = true) -> Gen<char>
{
    if (valid)
    {
        return gen::elementOf(std::string_view{ALPHA_CHARACTERS});
    }
    return gen::suchThat(gen::character<char>(),
                         [](const char character)
                         { return !std::isalpha(character); });
}
 
inline auto from_allowed_chars(const std::string_view &allowed_chars, const bool valid = true) -> Gen<char>
{
    if (valid)
    {
        return gen::elementOf(allowed_chars);
    }
    return gen::suchThat(gen::character<char>(),
                         [allowed_chars](const char character)
                         { return allowed_chars.find(character) == std::string::npos; });
}
 
inline auto string_from_allowed_chars(const std::string_view &allowed_chars, const bool valid = true) -> Gen<std::string>
{
    if (valid)
    {
        return gen::container<std::string>(from_allowed_chars(allowed_chars));
    }
    return gen::suchThat(gen::string<std::string>(), [allowed_chars](const auto &string)
                         { return std::any_of(string.begin(), string.end(), [allowed_chars](const auto &character)
                                              { return allowed_chars.find(character) == std::string::npos; }); });
}
 
inline auto port(const bool valid = true) -> Gen<int>
{
    static constexpr int port_upper_bound = 65535;
    static constexpr int port_lower_bound = 0;
    if (valid)
        return gen::inRange(port_lower_bound, port_upper_bound + 1);
    return gen::suchThat<int>(
        [](const auto port_number)
        { return port_number < port_lower_bound || port_number > port_upper_bound; });
}
 
inline auto calculateIPPrefixRange(const std::string &ipAddress) -> std::tuple<int, int>
{
    std::array<unsigned int, 4> addressParts{};
    std::istringstream addressStream(ipAddress);
    std::string part;
    size_t partIndex = 0;
 
    while (std::getline(addressStream, part, '.'))
    {
        addressParts[partIndex++] = std::stoi(part);
    }
 
    const uint32_t addressInteger = (addressParts[0] << 24) | (addressParts[1] << 16) | (addressParts[2] << 8) | addressParts[3];
 
    auto minimumPrefix = 32;
    for (auto bitPosition = 0; bitPosition < 32; ++bitPosition)
    {
        if (addressInteger & (1U << bitPosition))
        {
            minimumPrefix = 32 - bitPosition;
            break;
        }
    }
 
    return {minimumPrefix, openvpn::IPv4::Addr::SIZE};
}
} // namespace rc
#endif // TEST_GENERATORS_HPP