#include <climits>
#include <cstdint>
#include <limits>
#include <type_traits>
#include <zp/mth>
#include <zp/mem>
#include <zp/str>

int main() {
	static_assert([] {
		static_assert(::zp::isptr<int>::val                                  == false);
		static_assert(::zp::isptr<int                *>::val                 == true);
		static_assert(::zp::isptr<int const          *>::val                 == true);
		static_assert(::zp::isptr<int volatile       *>::val                 == true);
		static_assert(::zp::isptr<int const volatile *>::val                 == true);
		static_assert(::zp::isptr<int                * const>::val           == true);
		static_assert(::zp::isptr<int const          * const>::val           == true);
		static_assert(::zp::isptr<int volatile       * const>::val           == true);
		static_assert(::zp::isptr<int const volatile * const>::val           == true);
		static_assert(::zp::isptr<int                * volatile>::val        == true);
		static_assert(::zp::isptr<int const          * volatile>::val        == true);
		static_assert(::zp::isptr<int volatile       * volatile>::val        == true);
		static_assert(::zp::isptr<int const volatile * volatile>::val        == true);
		static_assert(::zp::isptr<int                * const volatile>::val  == true);
		static_assert(::zp::isptr<int const          * const volatile>::val  == true);
		static_assert(::zp::isptr<int volatile       * const volatile>::val  == true);
		static_assert(::zp::isptr<int const volatile * const volatile>::val  == true);

		static_assert(::zp::typequ<int,int>::val  == true);
		static_assert(::zp::typequ<int,long>::val == false);

		static_assert(::zp::typequ<::zp::sgn<int>::typ,         int>::val == true);
		static_assert(::zp::typequ<::zp::sgn<int unsigned>::typ,int>::val == true);

		static_assert(::zp::typequ<::zp::usgn<int unsigned>::typ,int unsigned>::val == true);
		static_assert(::zp::typequ<::zp::usgn<int>::typ,         int unsigned>::val == true);

		static_assert(::zp::typequ<::zp::remqual<int volatile>::typ,      int>::val == true);
		static_assert(::zp::typequ<::zp::remqual<int const volatile>::typ,int>::val == true);

		static_assert(::zp::typequ<::zp::remqual<int>::typ,               int>::val == true);
		static_assert(::zp::typequ<::zp::remqual<int const>::typ,         int>::val == true);
		static_assert(::zp::typequ<::zp::remqual<int volatile>::typ,      int>::val == true);
		static_assert(::zp::typequ<::zp::remqual<int const volatile>::typ,int>::val == true);
		
		static_assert(::zp::typequ<::zp::nulptrtyp,::std::nullptr_t>::val == true);

		static_assert(::zp::typequ<::zp::i8m,  ::std::uint_least8_t>::val  == true);
		static_assert(::zp::typequ<::zp::i8ms, ::std::int_least8_t>::val   == true);
		static_assert(::zp::typequ<::zp::i01m, ::std::uint_least16_t>::val == true);
		static_assert(::zp::typequ<::zp::i01ms,::std::int_least16_t>::val  == true);
		static_assert(::zp::typequ<::zp::i02m, ::std::uint_least32_t>::val == true);
		static_assert(::zp::typequ<::zp::i02ms,::std::int_least32_t>::val  == true);
		static_assert(::zp::typequ<::zp::i04m, ::std::uint_least64_t>::val == true);
		static_assert(::zp::typequ<::zp::i04ms,::std::int_least64_t>::val  == true);

		static_assert(::zp::typequ<::zp::intptr,::std::uintptr_t>::val == true);
		static_assert(::zp::typequ<::zp::sz,    ::std::size_t>::val    == true);

		static_assert(::zp::isusgn<char>::val               == ::std::is_unsigned_v<char>);
		static_assert(::zp::isusgn<char16_t>::val           == ::std::is_unsigned_v<char16_t>);
		static_assert(::zp::isusgn<char32_t>::val           == ::std::is_unsigned_v<char32_t>);
		static_assert(::zp::isusgn<char8_t>::val            == ::std::is_unsigned_v<char8_t>);
		static_assert(::zp::isusgn<double>::val             == ::std::is_unsigned_v<double>);
		static_assert(::zp::isusgn<float>::val              == ::std::is_unsigned_v<float>);
		static_assert(::zp::isusgn<int>::val                == ::std::is_unsigned_v<int>);
		static_assert(::zp::isusgn<long>::val               == ::std::is_unsigned_v<long>);
		static_assert(::zp::isusgn<long double>::val        == ::std::is_unsigned_v<long double>);
		static_assert(::zp::isusgn<long long>::val          == ::std::is_unsigned_v<long long>);
		static_assert(::zp::isusgn<short>::val              == ::std::is_unsigned_v<short>);
		static_assert(::zp::isusgn<char signed>::val        == ::std::is_unsigned_v<char signed>);
		static_assert(::zp::isusgn<char unsigned>::val      == ::std::is_unsigned_v<char unsigned>);
		static_assert(::zp::isusgn<int unsigned>::val       == ::std::is_unsigned_v<int unsigned>);
		static_assert(::zp::isusgn<long unsigned>::val      == ::std::is_unsigned_v<long unsigned>);
		static_assert(::zp::isusgn<long long unsigned>::val == ::std::is_unsigned_v<long long unsigned>);
		static_assert(::zp::isusgn<short unsigned>::val     == ::std::is_unsigned_v<short unsigned>);
		static_assert(::zp::isusgn<wchar_t>::val            == ::std::is_unsigned_v<wchar_t>);		

		static_assert(::zp::issgn<char>::val               == ::std::is_signed_v<char>);
		static_assert(::zp::issgn<double>::val             == ::std::is_signed_v<double>);
		static_assert(::zp::issgn<float>::val              == ::std::is_signed_v<float>);
		static_assert(::zp::issgn<int>::val                == ::std::is_signed_v<int>);
		static_assert(::zp::issgn<long>::val               == ::std::is_signed_v<long>);
		static_assert(::zp::issgn<long double>::val        == ::std::is_signed_v<long double>);
		static_assert(::zp::issgn<long long>::val          == ::std::is_signed_v<long long>);
		static_assert(::zp::issgn<short>::val              == ::std::is_signed_v<short>);
		static_assert(::zp::issgn<char signed>::val        == ::std::is_signed_v<char signed>);
		static_assert(::zp::issgn<char unsigned>::val      == ::std::is_signed_v<char unsigned>);
		static_assert(::zp::issgn<int unsigned>::val       == ::std::is_signed_v<int unsigned>);
		static_assert(::zp::issgn<long unsigned>::val      == ::std::is_signed_v<long unsigned>);
		static_assert(::zp::issgn<long long unsigned>::val == ::std::is_signed_v<long long unsigned>);
		static_assert(::zp::issgn<short unsigned>::val     == ::std::is_signed_v<short unsigned>);
		static_assert(::zp::issgn<wchar_t>::val            == ::std::is_signed_v<wchar_t>);

		static_assert(::zp::bytelen == CHAR_BIT);

		static_assert(::zp::minval<bool>::val               == ::std::numeric_limits<bool>::lowest());
		static_assert(::zp::minval<char>::val               == ::std::numeric_limits<char>::lowest());
		static_assert(::zp::minval<char16_t>::val           == ::std::numeric_limits<char16_t>::lowest());
		static_assert(::zp::minval<char32_t>::val           == ::std::numeric_limits<char32_t>::lowest());
		static_assert(::zp::minval<char8_t>::val            == ::std::numeric_limits<char8_t>::lowest());
		static_assert(::zp::minval<double>::val             == ::std::numeric_limits<double>::lowest());
		static_assert(::zp::minval<float>::val              == ::std::numeric_limits<float>::lowest());
		static_assert(::zp::minval<int>::val                == ::std::numeric_limits<int>::lowest());
		static_assert(::zp::minval<long>::val               == ::std::numeric_limits<long>::lowest());
		static_assert(::zp::minval<long double>::val        == ::std::numeric_limits<long double>::lowest());
		static_assert(::zp::minval<long long>::val          == ::std::numeric_limits<long long>::lowest());
		static_assert(::zp::minval<short>::val              == ::std::numeric_limits<short>::lowest());
		static_assert(::zp::minval<char signed>::val        == ::std::numeric_limits<char signed>::lowest());
		static_assert(::zp::minval<char unsigned>::val      == ::std::numeric_limits<char unsigned>::lowest());
		static_assert(::zp::minval<short unsigned>::val     == ::std::numeric_limits<short unsigned>::lowest());
		static_assert(::zp::minval<int unsigned>::val       == ::std::numeric_limits<int unsigned>::lowest());
		static_assert(::zp::minval<long unsigned>::val      == ::std::numeric_limits<long unsigned>::lowest());
		static_assert(::zp::minval<long long unsigned>::val == ::std::numeric_limits<long long unsigned>::lowest());
		static_assert(::zp::minval<wchar_t>::val            == ::std::numeric_limits<wchar_t>::lowest());

		static_assert(::zp::maxval<bool>::val               == ::std::numeric_limits<bool>::max());
		static_assert(::zp::maxval<char>::val               == ::std::numeric_limits<char>::max());
		static_assert(::zp::maxval<char16_t>::val           == ::std::numeric_limits<char16_t>::max());
		static_assert(::zp::maxval<char32_t>::val           == ::std::numeric_limits<char32_t>::max());
		static_assert(::zp::maxval<char8_t>::val            == ::std::numeric_limits<char8_t>::max());
		static_assert(::zp::maxval<double>::val             == ::std::numeric_limits<double>::max());
		static_assert(::zp::maxval<float>::val              == ::std::numeric_limits<float>::max());
		static_assert(::zp::maxval<int>::val                == ::std::numeric_limits<int>::max());
		static_assert(::zp::maxval<long>::val               == ::std::numeric_limits<long>::max());
		static_assert(::zp::maxval<long double>::val        == ::std::numeric_limits<long double>::max());
		static_assert(::zp::maxval<long long>::val          == ::std::numeric_limits<long long>::max());
		static_assert(::zp::maxval<short>::val              == ::std::numeric_limits<short>::max());
		static_assert(::zp::maxval<char signed>::val        == ::std::numeric_limits<char signed>::max());
		static_assert(::zp::maxval<char unsigned>::val      == ::std::numeric_limits<char unsigned>::max());
		static_assert(::zp::maxval<short unsigned>::val     == ::std::numeric_limits<short unsigned>::max());
		static_assert(::zp::maxval<int unsigned>::val       == ::std::numeric_limits<int unsigned>::max());
		static_assert(::zp::maxval<long unsigned>::val      == ::std::numeric_limits<long unsigned>::max());
		static_assert(::zp::maxval<long long unsigned>::val == ::std::numeric_limits<long long unsigned>::max());
		static_assert(::zp::maxval<wchar_t>::val            == ::std::numeric_limits<wchar_t>::max());

		return true;
	}());
}