Constrained number template

template <typename T>
constexpr CheckedNumber<T>& CheckedNumber<T>::operator=(ValueType newvalue)
{
    T::Check(newvalue);
    value = std::move(newvalue);
    // oops!
}

{
    ValueType result = value + val;
    T::Check(result);
    value = std::move(result);
    return *this;
}

{
    return *this = value + val;
}

#include <type_traits>
#include <utility>
#include <istream>

namespace ftz
{
namespace General
{

template <typename T>
concept bool Predicate()
{
    return requires()
    {
        typename T::ValueType;
    } &&
    requires (typename T::ValueType value)
    {
        {T::Check(value)} -> void;
    };
}

/// \brief A checked number.
/// \details Checked number is a number which can't have some values which are
/// otherwise possible for the underlying type. For example, a floating point
/// number which can't be negative. This class takes a predicate class which
/// defines the underlying type of the value and a static function to check the
/// value. Predicate must throw std::domain_error if the value is illegal.
/// \tparam T Type of the predicate.
template<Predicate T>
class CheckedNumber
{
public:
    using ValueType = typename T::ValueType; ///< Underlying type of the value.

    /// \brief Constructor.
    /// \param[in] val Value to set.
    /// \throw std::domain_error If value is illegal.
    constexpr CheckedNumber(ValueType val = ValueType{});

    /// \brief Returns the underlying value.
    /// \return Underlying value.
    constexpr operator ValueType() const noexcept { return value; }

    /// \brief Preincrements the underlying value.
    /// \return Reference to this number.
    /// \throw std::domain_error if result is illegal.
    constexpr CheckedNumber& operator++();

    /// \brief Postincrements the underlying value.
    /// \return Copy of this number before increment.
    /// \throw std::domain_error if the incremented value is illegal.
    constexpr CheckedNumber operator++(int);

    /// \brief Predecrements the underlying value.
    /// \return Reference to this number.
    /// \throw std::domain_error if result is illegal.
    constexpr CheckedNumber& operator--();

    /// \brief Postdecrements the underlying value.
    /// \return Copy of this number before decrement.
    /// \throw std::domain_error if the decremented value is illegal.
    constexpr CheckedNumber operator--(int);

    /// \brief Adds a value to the underlying value.
    /// \tparam U Type of the value.
    /// \param[in] val Value to add.
    /// \return Reference to this number.
    /// \throw std::domain_error If the sum is illegal.
    template <typename U>
    constexpr CheckedNumber& operator+=(const U& val);

    /// \brief Subtracts a value from the underlying value.
    /// \tparam U Type of the value.
    /// \param[in] val Value to subtract.
    /// \return Reference to this number.
    /// \throw std::domain_error If the difference is illegal.
    template <typename U>
    constexpr CheckedNumber& operator-=(const U& val);

    /// \brief Mulptiplies the underlying value by another value.
    /// \tparam U Type of the value.
    /// \param[in] val Value to multiply by.
    /// \return Reference to this number.
    /// \throw std::domain_error If the product is illegal.
    template <typename U>
    constexpr CheckedNumber& operator*=

#include <gtest/gtest.h>

#include <cmath>
#include <sstream>
#include <stdexcept>

struct assert_even
{
    using ValueType = int;
    static constexpr void Check(ValueType n) {
        if (n % 2)
            throw std::domain_error("Violated EvenNumber constraint");
    }
};

struct assert_small
{
    using ValueType = char;
    static constexpr void Check(ValueType n) {
        if (n < -9 or 9 < n)
            throw std::domain_error("Violated SmallNumber constraint");
    }
};

struct assert_small_double
{
    using ValueType = double;
    static constexpr void Check(ValueType n) {
        if (n < -9 or 9 < n)
            throw std::domain_error("Violated SmallNumber constraint");
    }
};


using ftz::General::CheckedNumber;

using EvenNumber = CheckedNumber<assert_even>;
using SmallNumber = CheckedNumber<assert_small>;
using SmallDouble = CheckedNumber<assert_small_double>;


TEST(EvenNumber, construct)
{
    EXPECT_NO_THROW({EvenNumber a{0};});
    EXPECT_THROW({EvenNumber a{1};}, std::domain_error);
}

TEST(EvenNumber, istream)
{
    EvenNumber a{6};
    std::istringstream in{"3 2"};
    EXPECT_THROW(in >> a, std::domain_error);
    EXPECT_EQ(a, 6);            // unchanged
    EXPECT_TRUE(in >> a);
    EXPECT_EQ(a, 2);
    EXPECT_FALSE(in >> a);      // end of stream
    EXPECT_EQ(a, 2);            // unchanged
}

TEST(EvenNumber, increment)
{
    EvenNumber a;
    EXPECT_THROW({++a;}, std::domain_error);
    EXPECT_THROW({a++;}, std::domain_error);
    EXPECT_EQ(a, 0);            // strong exception guarantee
}
TEST(EvenNumber, add)
{
    EvenNumber a;
    EXPECT_THROW({a+=1;}, std::domain_error);
    EXPECT_EQ(a+=2, 2);
}
TEST(EvenNumber, false)
{
    EvenNumber a;
    EXPECT_FALSE(a);
}
TEST(EvenNumber, true)
{
    EvenNumber a = 6;
    EXPECT_TRUE(a);
}
TEST(EvenNumber, unary_negate)
{
    EvenNumber a = 6;
    EXPECT_EQ(-a, -6);
}

TEST(SmallNumber, construct)
{
    EXPECT_THROW({SmallNumber a{-10};}, std::domain_error);
    EXPECT_NO_THROW({SmallNumber a{-9};});
    EXPECT_NO_THROW({SmallNumber a{};});
    EXPECT_NO_THROW({SmallNumber a{9};});
    EXPECT_THROW({SmallNumber a{10};}, std::domain_error);
}

TEST(SmallNumber, increment)
{
    SmallNumber a{8};
    EXPECT_EQ(++a, 9);
    EXPECT_THROW({a++;}, std::domain_error);
    EXPECT_EQ(a, 9);            // strong exception guarantee
}

TEST(SmallNumber, multiply)
{
    SmallNumber a{4};
    EXPECT_EQ(a*4, 16);
    EXPECT_THROW({a*=4;}, std::domain_error);
    EXPECT_EQ(a, 4);            // strong exception guarantee
}


TEST(SmallDouble, trigonometric)
{
    SmallDouble a{0};
    EXPECT_DOUBLE_EQ(std::sin(a), 0);
    EXPECT_DOUBLE_EQ(std::cos(a), 1);
}