/***************************************************************************
 * Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and         *
 * Martin Renou                                                             *
 * Copyright (c) QuantStack                                                 *
 * Copyright (c) Serge Guelton                                              *
 *                                                                          *
 * Distributed under the terms of the BSD 3-Clause License.                 *
 *                                                                          *
 * The full license is in the file LICENSE, distributed with this software. *
 ****************************************************************************/

#include "xsimd/xsimd.hpp"
#ifndef XSIMD_NO_SUPPORTED_ARCHITECTURE

#include <array>
#include <functional>
#include <type_traits>
#include <vector>

#include "test_utils.hpp"

namespace xsimd
{

    namespace test_detail
    {
        template <class T, std::size_t N>
        struct ct_mask_arch
        {
            static constexpr bool supported() noexcept { return true; }
            static constexpr bool available() noexcept { return true; }
            static constexpr std::size_t alignment() noexcept { return 0; }
            static constexpr bool requires_alignment() noexcept { return false; }
            static constexpr char const* name() noexcept { return "ct_mask_arch"; }
        };

        template <class T, std::size_t N>
        struct ct_mask_register
        {
            std::array<T, N> data {};
        };

        struct mask_all_false
        {
            static constexpr bool get(std::size_t, std::size_t) { return false; }
        };

        struct mask_all_true
        {
            static constexpr bool get(std::size_t, std::size_t) { return true; }
        };

        struct mask_prefix1
        {
            static constexpr bool get(std::size_t i, std::size_t) { return i < 1; }
        };

        struct mask_suffix1
        {
            static constexpr bool get(std::size_t i, std::size_t n) { return i >= (n - 1); }
        };

        struct mask_ends
        {
            static constexpr bool get(std::size_t i, std::size_t n)
            {
                return (i < 1) || (i >= (n - 1));
            }
        };

        struct mask_interleaved
        {
            static constexpr bool get(std::size_t i, std::size_t) { return (i % 2) == 0; }
        };

        template <class T>
        struct alternating_numeric
        {
            static constexpr T get(std::size_t i, std::size_t)
            {
                return (i % 2) ? T(2) : T(1);
            }
        };
    }

    namespace types
    {
        template <class T, std::size_t N>
        struct simd_register<T, test_detail::ct_mask_arch<T, N>>
        {
            using register_type = test_detail::ct_mask_register<T, N>;
            register_type data;
            constexpr operator register_type() const noexcept { return data; }
        };

        template <class T, std::size_t N>
        struct has_simd_register<T, test_detail::ct_mask_arch<T, N>> : std::true_type
        {
        };
    }

    int popcount(int v)
    {
        // from https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan
        int c; // c accumulates the total bits set in v
        for (c = 0; v; c++)
        {
            v &= v - 1; // clear the least significant bit set
        }
        return c;
    }

    template <class T, std::size_t N>
    struct get_bool_base
    {
        using vector_type = std::array<bool, N>;

        std::vector<vector_type> almost_all_false()
        {
            std::vector<vector_type> vectors;
            vectors.reserve(N);
            for (size_t i = 0; i < N; ++i)
            {
                vector_type v;
                v.fill(false);
                v[i] = true;
                vectors.push_back(std::move(v));
            }
            return vectors;
        }

        std::vector<vector_type> almost_all_true()
        {
            auto vectors = almost_all_false();
            flip(vectors);
            return vectors;
        }

        void flip(vector_type& vec)
        {
            std::transform(vec.begin(), vec.end(), vec.begin(), std::logical_not<bool> {});
        }

        void flip(std::vector<vector_type>& vectors)
        {
            for (auto& vec : vectors)
            {
                flip(vec);
            }
        }
    };

    template <class T, size_t N = T::size>
    struct get_bool;

    template <class T>
    struct get_bool<batch_bool<T>, 1> : public get_bool_base<T, 1>
    {
        using type = batch_bool<T>;
        type all_true = type(true);
        type all_false = type(false);
        type half = { 0 };
        type ihalf = { 1 };
        type interspersed = { 0 };
    };

    template <class T>
    struct get_bool<batch_bool<T>, 2> : public get_bool_base<T, 2>
    {
        using type = batch_bool<T>;
        type all_true = type(true);
        type all_false = type(false);
        type half = { 0, 1 };
        type ihalf = { 1, 0 };
        type interspersed = { 0, 1 };
    };

    template <class T>
    struct get_bool<batch_bool<T>, 4> : public get_bool_base<T, 4>
    {
        using type = batch_bool<T>;

        type all_true = true;
        type all_false = false;
        type half = { 0, 0, 1, 1 };
        type ihalf = { 1, 1, 0, 0 };
        type interspersed = { 0, 1, 0, 1 };
    };

    template <class T>
    struct get_bool<batch_bool<T>, 8> : public get_bool_base<T, 8>
    {
        using type = batch_bool<T>;
        type all_true = true;
        type all_false = false;
        type half = { 0, 0, 0, 0, 1, 1, 1, 1 };
        type ihalf = { 1, 1, 1, 1, 0, 0, 0, 0 };
        type interspersed = { 0, 1, 0, 1, 0, 1, 0, 1 };
    };

    template <class T>
    struct get_bool<batch_bool<T>, 16> : public get_bool_base<T, 16>
    {
        using type = batch_bool<T>;
        type all_true = true;
        type all_false = false;
        type half = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1 };
        type ihalf = { 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 };
        type interspersed = { 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1 };
    };

    template <class T>
    struct get_bool<batch_bool<T>, 32> : public get_bool_base<T, 32>
    {
        using type = batch_bool<T>;
        type all_true = true;
        type all_false = false;
        type half = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
        type ihalf = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
        type interspersed = { 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1 };
    };

    template <class T>
    struct get_bool<batch_bool<T>, 64> : public get_bool_base<T, 64>
    {
        using type = batch_bool<T>;
        type all_true = true;
        type all_false = false;
        type half = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
        type ihalf = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
        type interspersed = { 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1 };
    };

}

template <class T>
struct batch_bool_test
{
    using batch_type = T;
    using value_type = typename T::value_type;
    static constexpr size_t size = T::size;
    using batch_bool_type = typename T::batch_bool_type;
    using array_type = std::array<value_type, size>;
    using bool_array_type = std::array<bool, size>;

    // Compile-time check helpers for batch_bool_constant masks
    template <class B, class Enable = void>
    struct xsimd_ct_mask_checker;

    // Small masks: safe to compare numeric masks at compile time
    template <class B>
    struct xsimd_ct_mask_checker<B, typename std::enable_if<(B::size <= 31)>::type>
    {
        static constexpr std::size_t sum_indices(uint64_t bits, std::size_t index, std::size_t remaining)
        {
            return remaining == 0
                ? 0u
                : ((bits & 1u ? index : 0u) + sum_indices(bits >> 1, index + 1, remaining - 1));
        }

        static constexpr uint32_t low_mask_bits(std::size_t width)
        {
            return width == 0 ? 0u : (static_cast<uint32_t>(1u << width) - 1u);
        }

        template <class Mask, class ValueType, bool Enable>
        struct splice_checker
        {
            static void run()
            {
            }
        };

        template <class Mask, class ValueType>
        struct splice_checker<Mask, ValueType, true>
        {
            static void run()
            {
                constexpr std::size_t begin = 1;
                constexpr std::size_t end = (Mask::size > 3 ? 3 : Mask::size);
                constexpr std::size_t length = (end > begin) ? (end - begin) : 0;
                using slice_arch = xsimd::test_detail::ct_mask_arch<ValueType, length>;
                constexpr auto slice = xsimd::detail::splice<slice_arch, begin, end>(Mask {});
                constexpr uint32_t src_mask = static_cast<uint32_t>(Mask::mask());
                constexpr uint32_t expected = (src_mask >> begin) & low_mask_bits(length);
                static_assert(static_cast<uint32_t>(slice.mask()) == expected, "splice mask expected");
                constexpr uint32_t slice_bits = static_cast<uint32_t>(slice.mask());
                constexpr uint32_t shifted_source = src_mask >> begin;
                static_assert((length == 0) || ((slice_bits & 1u) == (shifted_source & 1u)), "slice first bit matches");
                static_assert((length <= 1) || (((slice_bits >> (length - 1)) & 1u) == ((shifted_source >> (length - 1)) & 1u)),
                              "slice last bit matches");
            }
        };

        template <class Mask, class ValueType, bool Enable>
        struct half_checker
        {
            static void run()
            {
            }
        };

        template <class Mask, class ValueType>
        struct half_checker<Mask, ValueType, true>
        {
            static void run()
            {
                constexpr std::size_t total = Mask::size;
                constexpr std::size_t mid = total / 2;
                using lower_arch = xsimd::test_detail::ct_mask_arch<ValueType, mid>;
                using upper_arch = xsimd::test_detail::ct_mask_arch<ValueType, total - mid>;
                constexpr auto lower = xsimd::detail::lower_half<lower_arch>(Mask {});
                constexpr auto upper = xsimd::detail::upper_half<upper_arch>(Mask {});
                constexpr uint32_t source_mask = static_cast<uint32_t>(Mask::mask());
                static_assert(static_cast<uint32_t>(lower.mask()) == (source_mask & low_mask_bits(mid)),
                              "lower_half mask matches");
                static_assert(static_cast<uint32_t>(upper.mask()) == ((source_mask >> mid) & low_mask_bits(total - mid)),
                              "upper_half mask matches");
                constexpr auto lower_splice = xsimd::detail::splice<lower_arch, 0, mid>(Mask {});
                constexpr auto upper_splice = xsimd::detail::splice<upper_arch, mid, total>(Mask {});
                static_assert(lower.mask() == lower_splice.mask(), "lower_half equals splice");
                static_assert(upper.mask() == upper_splice.mask(), "upper_half equals splice");
                constexpr uint32_t lower_bits = static_cast<uint32_t>(lower.mask());
                constexpr uint32_t upper_bits = static_cast<uint32_t>(upper.mask());
                constexpr std::size_t upper_size = decltype(upper)::size;
                static_assert((mid == 0) || ((lower_bits & 1u) == (source_mask & 1u)), "lower first element");
                static_assert((mid <= 1) || (((lower_bits >> (mid - 1)) & 1u) == ((source_mask >> (mid - 1)) & 1u)),
                              "lower last element");
                static_assert((upper_size == 0) || ((upper_bits & 1u) == ((source_mask >> mid) & 1u)),
                              "upper first element");
                static_assert((upper_size <= 1) || (((upper_bits >> (upper_size - 1)) & 1u) == ((source_mask >> (total - 1)) & 1u)),
                              "upper last element");
            }
        };

        static void run()
        {
            using value_type = typename B::value_type;
            using arch_type = typename B::arch_type;
            constexpr auto m_zero = xsimd::make_batch_bool_constant<value_type, xsimd::test_detail::mask_all_false, arch_type>();
            constexpr auto m_one = xsimd::make_batch_bool_constant<value_type, xsimd::test_detail::mask_all_true, arch_type>();
            constexpr auto m_prefix = xsimd::make_batch_bool_constant<value_type, xsimd::test_detail::mask_prefix1, arch_type>();
            constexpr auto m_suffix = xsimd::make_batch_bool_constant<value_type, xsimd::test_detail::mask_suffix1, arch_type>();
            constexpr auto m_ends = xsimd::make_batch_bool_constant<value_type, xsimd::test_detail::mask_ends, arch_type>();
            constexpr auto m_interleaved = xsimd::make_batch_bool_constant<value_type, xsimd::test_detail::mask_interleaved, arch_type>();

            static_assert((m_zero | m_one).mask() == m_one.mask(), "0|1 == 1");
            static_assert((m_zero & m_one).mask() == m_zero.mask(), "0&1 == 0");
            static_assert((m_zero ^ m_zero).mask() == m_zero.mask(), "0^0 == 0");
            static_assert((m_one ^ m_one).mask() == m_zero.mask(), "1^1 == 0");

            static_assert((!m_zero).mask() == m_one.mask(), "!0 == 1");
            static_assert((~m_zero).mask() == m_one.mask(), "~0 == 1");
            static_assert((!m_one).mask() == m_zero.mask(), "!1 == 0");
            static_assert((~m_one).mask() == m_zero.mask(), "~1 == 0");

            static_assert(((m_prefix && m_suffix).mask()) == (m_prefix & m_suffix).mask(), "&& consistent");
            static_assert(((m_prefix || m_suffix).mask()) == (m_prefix | m_suffix).mask(), "|| consistent");

            static_assert((m_prefix | m_suffix).mask() == m_ends.mask(), "prefix|suffix == ends");
            static_assert(B::size == 1 || (m_prefix & m_suffix).mask() == m_zero.mask(), "prefix&suffix == 0 when size>1");

            static_assert(m_zero.none(), "zero mask none");
            static_assert(!m_zero.any(), "zero mask any");
            static_assert(!m_zero.all(), "zero mask all");
            static_assert(m_zero.countr_zero() == B::size, "zero mask trailing zeros");
            static_assert(m_zero.countl_zero() == B::size, "zero mask leading zeros");

            static_assert(m_one.all(), "all mask all");
            static_assert(m_one.any(), "all mask any");
            static_assert(!m_one.none(), "all mask none");
            static_assert(m_one.countr_zero() == 0, "all mask trailing zeros");
            static_assert(m_one.countl_zero() == 0, "all mask leading zeros");

            constexpr auto prefix_bits = static_cast<uint32_t>(m_prefix.mask());
            constexpr auto suffix_bits = static_cast<uint32_t>(m_suffix.mask());
            constexpr auto ends_bits_mask = static_cast<uint32_t>(m_ends.mask());

            static_assert((B::size == 0) || ((prefix_bits & 1u) != 0u), "prefix first element set");
            static_assert((B::size <= 1) || ((prefix_bits & (1u << 1)) == 0u), "prefix second element cleared");

            static_assert((B::size == 0) || (((suffix_bits >> (B::size - 1)) & 1u) != 0u), "suffix last element set");
            static_assert((B::size <= 1) || ((suffix_bits & 1u) == 0u), "suffix first element cleared");

            static_assert((B::size == 0) || ((ends_bits_mask & 1u) != 0u), "ends first element set");
            static_assert((B::size == 0) || (((ends_bits_mask >> (B::size - 1)) & 1u) != 0u), "ends last element set");
            static_assert((B::size <= 2) || (((ends_bits_mask >> 1) & 1u) == 0u), "ends interior element cleared");

            static_assert(std::is_same<decltype(m_prefix.as_batch_bool()), typename B::batch_bool_type>::value,
                          "as_batch_bool type");
            static_assert(std::is_same<decltype(static_cast<typename B::batch_bool_type>(m_prefix)), typename B::batch_bool_type>::value,
                          "conversion operator type");

            // splice API is validated indirectly via arch-specific masked implementations.

            constexpr std::size_t prefix_zero = m_prefix.countr_zero();
            constexpr std::size_t prefix_one = m_prefix.countr_one();
            static_assert(prefix_zero == 0, "prefix mask zero leading zeros from LSB");
            static_assert((B::size == 0 ? prefix_one == 0 : prefix_one == 1), "prefix mask trailing ones count");

            constexpr std::size_t suffix_zero = m_suffix.countl_zero();
            constexpr std::size_t suffix_one = m_suffix.countl_one();
            static_assert(suffix_zero == 0, "suffix mask leading zeros count");
            static_assert((B::size == 0 ? suffix_one == 0 : suffix_one == 1), "suffix mask trailing ones count");

            splice_checker<decltype(m_interleaved), value_type, (B::size > 1)>::run();
            half_checker<decltype(m_ends), value_type, (B::size > 0 && (B::size % 2 == 0))>::run();
        }
    };

    // Large masks: avoid calling mask() in constant expressions
    template <class B>
    struct xsimd_ct_mask_checker<B, typename std::enable_if<(B::size > 31)>::type>
    {
        static void run() { }
    };

    array_type lhs;
    array_type rhs;
    bool_array_type all_true;
    bool_array_type ba;

    batch_bool_test()
    {
        for (size_t i = 0; i < size; ++i)
        {
            lhs[i] = value_type(i);
            rhs[i] = i == 0 % 2 ? lhs[i] : lhs[i] * value_type(2);
            all_true[i] = true;
            ba[i] = i == 0 % 2 ? true : false;
        }
    }

    template <size_t... Is>
    struct pack
    {
    };

    template <typename F, size_t... Values>
    static batch_bool_type make_batch_impl(F&& f, std::integral_constant<size_t, 0>, pack<Values...>)
    {
        return batch_bool_type(bool(f(Values))...);
    }

    template <typename F, size_t I, size_t... Values>
    static batch_bool_type make_batch_impl(F&& f, std::integral_constant<size_t, I>, pack<Values...>)
    {
        return make_batch_impl(std::forward<F>(f), std::integral_constant<size_t, I - 1>(), pack<I - 1, Values...>());
    }

    template <typename F>
    static batch_bool_type make_batch(F&& f)
    {
        return make_batch_impl(std::forward<F>(f), std::integral_constant<size_t, size>(), pack<> {});
    }

    void test_constructors() const
    {
        batch_bool_type a;
        // value uninitialized, cannot test it.
        (void)a;

        {
            bool_array_type res;
            batch_bool_type b(true);
            b.store_unaligned(res.data());
            INFO("batch_bool{value}");
            CHECK_EQ(res, all_true);

            batch_bool_type c { true };
            c.store_unaligned(res.data());
            INFO("batch_bool{value}");
            CHECK_EQ(res, all_true);
        }

        {
            auto f_bool = [](size_t i)
            { return bool(i % 3); };

            bool_array_type res;
            for (size_t i = 0; i < res.size(); i++)
            {
                res[i] = f_bool(i);
            }

            bool_array_type tmp;
            batch_bool_type b0 = make_batch(f_bool);
            b0.store_unaligned(tmp.data());
            INFO("batch_bool(values...)");
            CHECK_EQ(tmp, res);

            batch_bool_type b1 = make_batch(f_bool);
            b1.store_unaligned(tmp.data());
            INFO("batch_bool{values...}");
            CHECK_EQ(tmp, res);
        }
    }

    void test_load_store() const
    {
        bool_array_type res;
        batch_bool_type b(batch_bool_type::load_unaligned(ba.data()));
        b.store_unaligned(res.data());
        CHECK_EQ(res, ba);

        alignas(xsimd::default_arch::alignment()) bool_array_type arhs(this->ba);
        alignas(xsimd::default_arch::alignment()) bool_array_type ares;
        b = batch_bool_type::load_aligned(arhs.data());
        b.store_aligned(ares.data());
        CHECK_EQ(ares, arhs);

        auto bool_g = xsimd::get_bool<batch_bool_type> {};
        // load/store, almost all false
        {
            size_t i = 0;
            for (const auto& vec : bool_g.almost_all_false())
            {
                batch_bool_type b = batch_bool_type::load_unaligned(vec.data());
                batch_bool_type expected = make_batch([i](size_t x)
                                                      { return x == i; });
                i++;
                CHECK_UNARY(xsimd::all(b == expected));
                b.store_unaligned(res.data());
                // Check that the representation is bitwise exact.
                CHECK_UNARY(memcmp(res.data(), vec.data(), sizeof(res)) == 0);
            }
        }

        // load/store, almost all true
        {
            size_t i = 0;
            for (const auto& vec : bool_g.almost_all_true())
            {
                batch_bool_type b = batch_bool_type::load_unaligned(vec.data());
                batch_bool_type expected = make_batch([i](size_t x)
                                                      { return x != i; });
                i++;
                CHECK_UNARY(xsimd::all(b == expected));
                b.store_unaligned(res.data());
                CHECK_UNARY(memcmp(res.data(), vec.data(), sizeof(res)) == 0);
            }
        }
    }

    void test_any_all() const
    {
        auto bool_g = xsimd::get_bool<batch_bool_type> {};
        // any
        {
            auto any_check_false = (batch_lhs() != batch_lhs());
            bool any_res_false = xsimd::any(any_check_false);
            CHECK_FALSE(any_res_false);
            auto any_check_true = (batch_lhs() == batch_rhs());
            bool any_res_true = xsimd::any(any_check_true);
            CHECK_UNARY(any_res_true);

            for (const auto& vec : bool_g.almost_all_false())
            {
                batch_bool_type b = batch_bool_type::load_unaligned(vec.data());
                bool any_res = xsimd::any(b);
                CHECK_UNARY(any_res);
            }

            for (const auto& vec : bool_g.almost_all_true())
            {
                batch_bool_type b = batch_bool_type::load_unaligned(vec.data());
                bool any_res = xsimd::any(b);
                CHECK_UNARY(any_res);
            }
        }
        // all
        {
            auto all_check_false = (batch_lhs() == batch_rhs());
            bool all_res_false = xsimd::all(all_check_false);
            CHECK_FALSE(all_res_false);
            auto all_check_true = (batch_lhs() == batch_lhs());
            bool all_res_true = xsimd::all(all_check_true);
            CHECK_UNARY(all_res_true);

            for (const auto& vec : bool_g.almost_all_false())
            {
                // TODO: implement batch_bool(bool*)
                // It currently compiles (need to understand why) but does not
                // give expected result
                batch_bool_type b = batch_bool_type::load_unaligned(vec.data());
                bool all_res = xsimd::all(b);
                CHECK_FALSE(all_res);
            }

            for (const auto& vec : bool_g.almost_all_true())
            {
                batch_bool_type b = batch_bool_type::load_unaligned(vec.data());
                bool all_res = xsimd::all(b);
                CHECK_FALSE(all_res);
            }
        }
        // none
        {
            auto none_check_false = (batch_lhs() == batch_rhs());
            bool none_res_false = xsimd::none(none_check_false);
            CHECK_FALSE(none_res_false);
            auto none_check_true = (batch_lhs() != batch_lhs());
            bool none_res_true = xsimd::none(none_check_true);
            CHECK_UNARY(none_res_true);

            for (const auto& vec : bool_g.almost_all_false())
            {
                batch_bool_type b = batch_bool_type::load_unaligned(vec.data());
                bool none_res = xsimd::none(b);
                CHECK_FALSE(none_res);
            }

            for (const auto& vec : bool_g.almost_all_true())
            {
                batch_bool_type b = batch_bool_type::load_unaligned(vec.data());
                bool none_res = xsimd::none(b);
                CHECK_FALSE(none_res);
            }
        }
    }

    void test_logical_operations() const
    {
        auto bool_g = xsimd::get_bool<batch_bool_type> {};
        size_t s = size;
        // operator!=
        {
            bool res = xsimd::all(bool_g.half != bool_g.ihalf);
            CHECK_UNARY(res);
        }
        // operator==
        {
            CHECK_BATCH_EQ(bool_g.half, !bool_g.ihalf);
        }
        // operator &&
        {
            batch_bool_type res = bool_g.half && bool_g.ihalf;
            bool_array_type ares;
            res.store_unaligned(ares.data());
            size_t nb_false = std::count(ares.cbegin(), ares.cend(), false);
            CHECK_EQ(nb_false, s);
        }
        // operator ||
        {
            batch_bool_type res = bool_g.half || bool_g.ihalf;
            bool_array_type ares;
            res.store_unaligned(ares.data());
            size_t nb_true = std::count(ares.cbegin(), ares.cend(), true);
            CHECK_EQ(nb_true, s);
        }
        // operator ^
        {
            batch_bool_type res = bool_g.half ^ bool_g.ihalf;
            bool_array_type ares;
            res.store_unaligned(ares.data());
            size_t nb_true = std::count(ares.cbegin(), ares.cend(), true);
            CHECK_EQ(nb_true, s);
        }
        // bitwise_andnot
        {
            batch_bool_type res = xsimd::bitwise_andnot(bool_g.half, bool_g.half);
            bool_array_type ares;
            res.store_unaligned(ares.data());
            size_t nb_false = std::count(ares.cbegin(), ares.cend(), false);
            CHECK_EQ(nb_false, s);
        }
    }

    void test_bitwise_operations() const
    {
        auto bool_g = xsimd::get_bool<batch_bool_type> {};
        // operator version
        {
            INFO("operator~");
            CHECK_BATCH_EQ(bool_g.half, ~bool_g.ihalf);
        }
        {
            INFO("operator|");
            CHECK_BATCH_EQ(bool_g.half | bool_g.ihalf, bool_g.all_true);
        }
        {
            INFO("operator&");
            CHECK_BATCH_EQ(bool_g.half & bool_g.ihalf, bool_g.all_false);
        }
        {
            INFO("operator^");
            CHECK_BATCH_EQ(bool_g.half ^ bool_g.all_true, bool_g.ihalf);
        }
        // free function version
        {
            INFO("bitwise_not");
            CHECK_BATCH_EQ(bool_g.half, xsimd::bitwise_not(bool_g.ihalf));
        }
        {
            INFO("bitwise_or");
            CHECK_BATCH_EQ(xsimd::bitwise_or(bool_g.half, bool_g.ihalf), bool_g.all_true);
        }
        {
            INFO("bitwise_and");
            CHECK_BATCH_EQ(xsimd::bitwise_and(bool_g.half, bool_g.ihalf), bool_g.all_false);
        }
        {
            INFO("bitwise_xor");
            CHECK_BATCH_EQ(xsimd::bitwise_xor(bool_g.half, bool_g.all_true), bool_g.ihalf);
        }
    }

    void test_update_operations() const
    {
        auto bool_g = xsimd::get_bool<batch_bool_type> {};
        {
            auto tmp = bool_g.half;
            tmp |= bool_g.ihalf;
            bool res = xsimd::all(tmp);
            INFO("operator|=");
            CHECK_UNARY(res);
        }
        {
            auto tmp = bool_g.half;
            tmp &= bool_g.half;
            INFO("operator&=");
            CHECK_BATCH_EQ(tmp, bool_g.half);
        }
        {
            auto tmp = bool_g.half;
            tmp ^= bool_g.ihalf;
            bool res = xsimd::all(tmp);
            INFO("operator^=");
            CHECK_UNARY(res);
        }
    }

    void test_mask() const
    {
        auto bool_g = xsimd::get_bool<batch_bool_type> {};
        const uint64_t full_mask = ((uint64_t)-1) >> (64 - batch_bool_type::size);
        CHECK_EQ(bool_g.all_false.mask(), 0);
        CHECK_EQ(batch_bool_type::from_mask(bool_g.all_false.mask()).mask(), bool_g.all_false.mask());

        CHECK_EQ(bool_g.all_true.mask(), full_mask);
        CHECK_EQ(batch_bool_type::from_mask(bool_g.all_true.mask()).mask(), bool_g.all_true.mask());

        CHECK_EQ(bool_g.half.mask(), full_mask & ((uint64_t)-1) << (batch_bool_type::size / 2));
        CHECK_EQ(batch_bool_type::from_mask(bool_g.half.mask()).mask(), bool_g.half.mask());

        CHECK_EQ(bool_g.ihalf.mask(), full_mask & ~(((uint64_t)-1) << (batch_bool_type::size / 2)));
        CHECK_EQ(batch_bool_type::from_mask(bool_g.ihalf.mask()).mask(), bool_g.ihalf.mask());

        CHECK_EQ(bool_g.interspersed.mask(), full_mask & 0xAAAAAAAAAAAAAAAAul);
        CHECK_EQ(batch_bool_type::from_mask(bool_g.interspersed.mask()).mask(), bool_g.interspersed.mask());
    }

    void test_count() const
    {
        auto bool_g = xsimd::get_bool<batch_bool_type> {};
        CHECK_EQ(count(bool_g.all_false), 0);
        CHECK_EQ(count(bool_g.all_true), batch_bool_type::size);
        CHECK_EQ(count(bool_g.half), batch_bool_type::size / 2);
    }

    void test_comparison() const
    {
        auto bool_g = xsimd::get_bool<batch_bool_type> {};
        // eq
        {
            CHECK_BATCH_EQ(bool_g.half, !bool_g.ihalf);
            CHECK_BATCH_EQ(xsimd::eq(bool_g.half, !bool_g.ihalf), bool_g.all_true);
        }
        // neq
        {
            CHECK_BATCH_EQ(xsimd::neq(bool_g.half, bool_g.ihalf), bool_g.all_true);
            CHECK_BATCH_EQ(xsimd::neq(bool_g.all_true, bool_g.all_true), bool_g.all_false);
        }
    }

    void test_mask_compile_time() const
    {
        xsimd_ct_mask_checker<T>::run();
    }

private:
    batch_type batch_lhs() const
    {
        return batch_type::load_unaligned(lhs.data());
    }

    batch_type batch_rhs() const
    {
        return batch_type::load_unaligned(rhs.data());
    }
};

TEST_CASE_TEMPLATE("[xsimd batch bool]", B, BATCH_TYPES)
{
    batch_bool_test<B> Test;

    SUBCASE("constructors") { Test.test_constructors(); }

    SUBCASE("load store") { Test.test_load_store(); }

    SUBCASE("any all") { Test.test_any_all(); }

    SUBCASE("logical operations") { Test.test_logical_operations(); }

    SUBCASE("bitwise operations") { Test.test_bitwise_operations(); }

    SUBCASE("update operations") { Test.test_update_operations(); }

    SUBCASE("mask") { Test.test_mask(); }

    SUBCASE("count") { Test.test_count(); }

    SUBCASE("eq neq") { Test.test_comparison(); }

    SUBCASE("mask utils (compile-time)") { Test.test_mask_compile_time(); }
}
#endif