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 <cstdint>
#include <limits>
#include <optional>
#include <utility>
#include <string>
#include <tuple>
#include <array>
#include <string_view>
#include <bitset>
#include <sstream>
#include <vector>
 
#include "openvpn/addr/ip.hpp"
#include "openvpn/addr/addrpair.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 helpers {
 
inline auto genHost(const bool valid = true) -> Gen<std::string>
{
    static constexpr size_t HOST_MAX_LENGTH = 256;
    static constexpr size_t HOST_MIN_LENGTH = 1;
    static constexpr size_t INVALID_MAX_LENGTH_LIMIT = 8192;
 
    static const std::string allowed_chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-:";
 
    auto [valid_chars, valid_length] = valid ? *generateValidityFlags<2>() : *generateValidityFlags<2>(false);
    const auto length = valid_length ? *gen::inRange(HOST_MIN_LENGTH, HOST_MAX_LENGTH + 1) : *gen::inRange(HOST_MAX_LENGTH + 1, INVALID_MAX_LENGTH_LIMIT);
 
    return gen::container<std::string>(length, from_allowed_chars(allowed_chars, valid_chars));
}
 
inline auto genDnsServerSecurity() -> Gen<openvpn::DnsServer::Security>
{
    return gen::element(
        openvpn::DnsServer::Security::Unset,
        openvpn::DnsServer::Security::No,
        openvpn::DnsServer::Security::Yes,
        openvpn::DnsServer::Security::Optional);
}
 
inline auto genDnsServerTransport() -> Gen<openvpn::DnsServer::Transport>
{
    return gen::element(
        openvpn::DnsServer::Transport::Unset,
        openvpn::DnsServer::Transport::Plain,
        openvpn::DnsServer::Transport::HTTPS,
        openvpn::DnsServer::Transport::TLS);
}
 
constexpr auto otherVersion(const openvpn::IP::Addr::Version version) -> openvpn::IP::Addr::Version
{
    return version == openvpn::IP::Addr::V4 ? openvpn::IP::Addr::V6 : openvpn::IP::Addr::V4;
}
 
inline auto singleBit(const openvpn::IP::Addr::Version version, const unsigned int bit) -> openvpn::IP::Addr
{
    using openvpn::IP::Addr;
    const auto size = Addr::version_size(version);
    return Addr::netmask_from_prefix_len(version, size - bit) & ~Addr::netmask_from_prefix_len(version, size - bit - 1);
}
 
inline auto nonContiguousNetmask(const openvpn::IP::Addr::Version version, const unsigned int cleared_bit) -> openvpn::IP::Addr
{
    return ~singleBit(version, cleared_bit);
}
 
template <typename Parse>
std::optional<std::string> rejectionMessageOf(Parse &&parse)
{
    try
    {
        parse();
    }
    catch (const openvpn::IP::AddrMaskPair::addr_pair_mask_parse_error &e)
    {
        return e.what();
    }
    return std::nullopt;
}
 
inline std::optional<std::string> rejectionMessage(const std::string &input, const char *title = nullptr)
{
    return rejectionMessageOf([&]
                              { openvpn::IP::AddrMaskPair::from_string(input, title); });
}
 
inline std::optional<std::string> rejectionMessageForTerms(const std::string &address, const std::string &mask)
{
    return rejectionMessageOf([&]
                              { openvpn::IP::AddrMaskPair::from_string(address, mask); });
}
 
inline std::optional<std::string> rejectionMessage(const openvpn::IP::AddrMaskPair::StringPair &pair)
{
    return rejectionMessageOf([&]
                              { openvpn::IP::AddrMaskPair::from_string(pair); });
}
 
} // namespace helpers
 
inline auto genDnsDomain(const bool valid = true) -> Gen<openvpn::DnsDomain>
{
    return gen::build(
        gen::construct<openvpn::DnsDomain>(),
        gen::set(&openvpn::DnsDomain::domain, helpers::genHost(valid)));
}
 
inline auto genDnsAddress(const bool valid = true) -> Gen<openvpn::DnsAddress>
{
    return gen::map(
        gen::tuple(
            gen::oneOf(IPv4Address(valid), IPv6Address(valid)),
            gen::maybe(port(*rc::gen::arbitrary<bool>()))), // port is not checked during DnsAddress validation
        [](const auto &params) -> openvpn::DnsAddress
        {
            const auto &[address, maybe_port] = params;
            openvpn::DnsAddress result;
            result.address = address;
            if (maybe_port)
            {
                result.port = *maybe_port;
            }
            return result;
        });
}
 
inline auto genDnsAddressAsStr(const bool valid = true) -> Gen<std::string>
{
    return gen::map(
        gen::tuple(
            gen::oneOf(IPv4Address(valid), IPv6Address(valid)),
            gen::maybe(port(valid))),
        [](const auto &params) -> std::string
        {
            const auto &[address, maybe_port] = params;
            openvpn::DnsAddress result;
            result.address = address;
            if (maybe_port)
            {
                result.port = *maybe_port;
            }
            return result.to_string();
        });
}
 
inline auto genDnsServer() -> Gen<openvpn::DnsServer>
{
    static constexpr auto MAX_VECTOR_SIZE = 100;
    return gen::build(
        gen::construct<openvpn::DnsServer>(),
        gen::set(&openvpn::DnsServer::addresses,
                 gen::container<std::vector<openvpn::DnsAddress>>(
                     *gen::inRange<size_t>(0, MAX_VECTOR_SIZE),
                     genDnsAddress())),
        gen::set(&openvpn::DnsServer::domains,
                 gen::container<std::vector<openvpn::DnsDomain>>(
                     *gen::inRange<size_t>(0, MAX_VECTOR_SIZE),
                     genDnsDomain())),
        gen::set(&openvpn::DnsServer::dnssec, helpers::genDnsServerSecurity()),
        gen::set(&openvpn::DnsServer::transport, helpers::genDnsServerTransport()),
        gen::set(&openvpn::DnsServer::sni, gen::string<std::string>()));
}
 
inline auto genDNSOptions() -> Gen<openvpn::DnsOptions>
{
    static constexpr auto MAX_CONTAINER_SIZE = 100;
    auto generateDnsServerMap = []() -> Gen<std::map<int, openvpn::DnsServer>>
    {
        return gen::map(
            gen::tuple(
                gen::container<std::vector<openvpn::DnsServer>>(
                    *gen::inRange<size_t>(0, MAX_CONTAINER_SIZE),
                    genDnsServer()),
                gen::unique<std::vector<int>>(*gen::inRange<size_t>(0, MAX_CONTAINER_SIZE), gen::nonNegative<int>())),
            [](const auto &params) -> std::map<int, openvpn::DnsServer>
            {
                const auto &[servers, priorities] = params;
                std::map<int, openvpn::DnsServer> result;
 
                for (size_t i = 0; i < std::min(servers.size(), priorities.size()); ++i)
                {
                    result[priorities[i]] = servers[i];
                }
 
                return result;
            });
    };
 
    return gen::build(
        gen::construct<openvpn::DnsOptions>(),
        gen::set(&openvpn::DnsOptions::from_dhcp_options, gen::arbitrary<bool>()),
        gen::set(&openvpn::DnsOptions::search_domains,
                 gen::container<std::vector<openvpn::DnsDomain>>(
                     *gen::inRange<size_t>(0, MAX_CONTAINER_SIZE),
                     genDnsDomain())),
        gen::set(&openvpn::DnsOptions::servers, generateDnsServerMap()));
}
 
template <>
struct Arbitrary<openvpn::IP::Addr::Version>
{
    static auto arbitrary() -> Gen<openvpn::IP::Addr::Version>
    {
        return gen::element(openvpn::IP::Addr::V4, openvpn::IP::Addr::V6);
    }
};
 
inline auto genIPAddressString(const openvpn::IP::Addr::Version version, const bool valid = true) -> Gen<std::string>
{
    if (version == openvpn::IP::Addr::V4)
    {
        return IPv4Address(valid);
    }
    return IPv6Address(valid);
}
 
inline auto genIPAddr(const openvpn::IP::Addr::Version version) -> Gen<openvpn::IP::Addr>
{
    return gen::map(genIPAddressString(version),
                    [](const std::string &address)
                    { return openvpn::IP::Addr::from_string(address); });
}
 
inline auto genIPAddr() -> Gen<openvpn::IP::Addr>
{
    return gen::mapcat(gen::arbitrary<openvpn::IP::Addr::Version>(),
                       [](const auto version)
                       { return genIPAddr(version); });
}
 
inline auto genPrefixLength(const openvpn::IP::Addr::Version version, const bool valid = true) -> Gen<unsigned int>
{
    const auto address_size = openvpn::IP::Addr::version_size(version);
 
    if (valid)
    {
        static constexpr int bound_weight = 1;
        static constexpr int interior_weight = 6;
        return gen::weightedOneOf<unsigned int>({{bound_weight, gen::just(0U)},
                                                 {bound_weight, gen::just(address_size)},
                                                 {interior_weight, gen::inRange(0U, address_size + 1U)}});
    }
    static constexpr unsigned int illegal_prefix_upper_bound = std::numeric_limits<unsigned int>::max();
    return gen::inRange(address_size + 1U, illegal_prefix_upper_bound);
}
 
inline auto genAddrMaskPair(const openvpn::IP::Addr::Version version) -> Gen<openvpn::IP::AddrMaskPair>
{
    return gen::apply(
        [version](openvpn::IP::Addr addr, const unsigned int prefix_len)
        {
            return openvpn::IP::AddrMaskPair{.addr = std::move(addr),
                                             .netmask = openvpn::IP::Addr::netmask_from_prefix_len(version, prefix_len)};
        },
        genIPAddr(version),
        genPrefixLength(version));
}
 
template <>
struct Arbitrary<openvpn::IP::AddrMaskPair>
{
    static auto arbitrary() -> Gen<openvpn::IP::AddrMaskPair>
    {
        return gen::mapcat(gen::arbitrary<openvpn::IP::Addr::Version>(),
                           [](const auto version)
                           { return genAddrMaskPair(version); });
    }
};
 
inline auto genNonCanonicalAddrMaskPair(const openvpn::IP::Addr::Version version) -> Gen<openvpn::IP::AddrMaskPair>
{
    using openvpn::IP::Addr;
    const auto size = Addr::version_size(version);
    return gen::mapcat(gen::inRange(0U, size),
                       [version, size](const unsigned int prefix_len)
                       {
                           return gen::apply(
                               [version, prefix_len](const Addr &addr, const unsigned int host_bit)
                               {
                                   return openvpn::IP::AddrMaskPair{.addr = addr | helpers::singleBit(version, host_bit),
                                                                    .netmask = Addr::netmask_from_prefix_len(version, prefix_len)};
                               },
                               genIPAddr(version),
                               gen::inRange(0U, size - prefix_len));
                       });
}
 
inline auto genNetmaskString(const openvpn::IP::Addr::Version version, const bool valid = true) -> Gen<std::string>
{
    if (valid)
    {
        return gen::map(genPrefixLength(version),
                        [version](const unsigned int prefix_len)
                        { return openvpn::IP::Addr::netmask_from_prefix_len(version, prefix_len).to_string(); });
    }
    return gen::map(gen::inRange(1U, openvpn::IP::Addr::version_size(version)),
                    [version](const unsigned int cleared_bit)
                    { return helpers::nonContiguousNetmask(version, cleared_bit).to_string(); });
}
 
inline auto genMaskToken(const openvpn::IP::Addr::Version version, const bool valid = true) -> Gen<std::string>
{
    const auto asToken = [](Gen<unsigned int> prefix_length)
    {
        return gen::map(std::move(prefix_length),
                        [](const unsigned int prefix_len)
                        { return std::to_string(prefix_len); });
    };
 
    if (valid)
    {
        return gen::oneOf(asToken(genPrefixLength(version)),
                          genNetmaskString(version),
                          gen::just(std::string{}));
    }
    return gen::oneOf(asToken(genPrefixLength(version, false)),
                      genNetmaskString(version, false),
                      genNetmaskString(helpers::otherVersion(version)));
}
 
inline auto genAddrMaskPairString(const openvpn::IP::Addr::Version version, const bool valid = true) -> Gen<std::string>
{
    static constexpr int bare_address_weight = 1;
    static constexpr int mask_term_weight = 3;
    static constexpr int shape_weight = 1;
 
    const auto joined = [](const std::string &address, const std::string &mask)
    { return address + "/" + mask; };
 
    if (valid)
    {
        return gen::weightedOneOf<std::string>({{bare_address_weight, genIPAddressString(version)},
                                                {mask_term_weight, gen::apply(joined, genIPAddressString(version), genMaskToken(version))}});
    }
 
    const auto three_terms = [](const std::string &address, const unsigned int first, const unsigned int second)
    { return address + "/" + std::to_string(first) + "/" + std::to_string(second); };
 
    // Addr::from_string accepts both families, so a string malformed as one is filtered against the other too
    const auto malformed_address = gen::suchThat(genIPAddressString(version, false),
                                                 [](const std::string &address)
                                                 { return !openvpn::IP::Addr::is_valid(address); });
 
    return gen::weightedOneOf<std::string>({{shape_weight, malformed_address},
                                            {mask_term_weight, gen::apply(joined, genIPAddressString(version), genMaskToken(version, false))},
                                            {shape_weight, gen::apply(three_terms, genIPAddressString(version), genPrefixLength(version), genPrefixLength(version))},
                                            {shape_weight, gen::just(std::string{})},
                                            {shape_weight, gen::nonEmpty(string_from_allowed_chars(ALPHA_CHARACTERS))}});
}
} // namespace rc
#endif // TEST_GENERATORS_HPP