hdkv/yuzu
1
Fork 0
Code Issues Pull Requests Releases 1 Activity

early-access version 3088

Browse Source
This commit is contained in:
pineappleEA
2022-11-05 15:35:56 +01:00
parent 4e4fc25ce3
commit b601909c6d
35519 changed files with 5996896 additions and 860 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/Jamfile.v2 vendored Executable file
View File

@@ -0,0 +1,39 @@
#~ Copyright Rene Rivera 2008
#~ Distributed under the Boost Software License, Version 1.0.
#~ (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
import testing ;
import ../../config/checks/config : requires ;
project : requirements <warnings>all <toolset>gcc:<cxxflags>-Wextra ;
obj has_gmpxx : has_gmpxx.cpp ;
explicit has_gmpxx ;
test-suite integer
:
[ run integer_traits_test.cpp ]
[ run integer_test.cpp : : : <toolset>gcc:<cxxflags>-Wno-long-long <toolset>darwin:<cxxflags>-Wno-long-long <toolset>sun:<cxxflags>"-Qoption ccfe -tmpldepth=128" ]
[ run integer_mask_test.cpp ]
[ run integer_log2_test.cpp ]
[ run static_log2_test.cpp ]
[ run static_min_max_test.cpp ]
[ run extended_euclidean_test.cpp ]
[ run mod_inverse_test.cpp ]
[ compile integer_traits_include_test.cpp ]
[ compile integer_include_test.cpp ]
[ compile integer_mask_include_test.cpp ]
[ compile static_log2_include_test.cpp ]
[ compile static_min_max_include_test.cpp ]
[ compile integer_fwd_include_test.cpp ]
[ compile gcd_constexpr14_test.cpp ]
[ compile gcd_noexcept_test.cpp ]
[ compile-fail fail_int_exact.cpp ]
[ compile-fail fail_int_fast.cpp ]
[ compile-fail fail_int_least.cpp ]
[ compile-fail fail_uint_exact.cpp ]
[ compile-fail fail_uint_fast.cpp ]
[ compile-fail fail_uint_least.cpp ]
[ compile-fail fail_uint_65.cpp ]
[ run common_factor_test.cpp : : : [ check-target-builds has_gmpxx "Checking for gmpxx.h" : <define>BOOST_INTEGER_HAS_GMPXX_H=1 <linkflags>-lgmp <linkflags>-lgmpxx ] ]
;

653
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/common_factor_test.cpp vendored Executable file
View File

@@ -0,0 +1,653 @@
// Boost GCD & LCM common_factor.hpp test program --------------------------//
// (C) Copyright Daryle Walker 2001, 2006.
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// See https://www.boost.org for most recent version including documentation.
// Revision History
// 01 Dec 2006 Various fixes for old compilers (Joaquin M Lopez Munoz)
// 10 Nov 2006 Make long long and __int64 mutually exclusive (Daryle Walker)
// 04 Nov 2006 Use more built-in numeric types, binary-GCD (Daryle Walker)
// 03 Nov 2006 Use custom numeric types (Daryle Walker)
// 02 Nov 2006 Change to Boost.Test's unit test system (Daryle Walker)
// 07 Nov 2001 Initial version (Daryle Walker)
#define BOOST_TEST_MAIN "Boost.integer GCD & LCM unit tests"
#include <boost/config.hpp> // for BOOST_MSVC, etc.
#include <boost/detail/workaround.hpp>
#include <boost/integer/common_factor.hpp> // for boost::integer::gcd, etc.
#include <boost/mpl/list.hpp> // for boost::mpl::list
#include <boost/operators.hpp>
#include <boost/core/lightweight_test.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include <boost/rational.hpp>
#include <istream> // for std::basic_istream
#include <limits> // for std::numeric_limits
#include <ostream> // for std::basic_ostream
#ifdef BOOST_INTEGER_HAS_GMPXX_H
#include <gmpxx.h>
#endif
#include "multiprecision_config.hpp"
#ifndef DISABLE_MP_TESTS
#include <boost/multiprecision/cpp_int.hpp>
#endif
namespace {
// TODO: add polynominal/non-real type; especially after any switch to the
// binary-GCD algorithm for built-in types
// Custom integer class (template)
template < typename IntType, int ID = 0 >
class my_wrapped_integer
: private ::boost::shiftable1<my_wrapped_integer<IntType, ID>,
::boost::operators<my_wrapped_integer<IntType, ID> > >
{
// Helper type-aliases
typedef my_wrapped_integer self_type;
typedef IntType self_type::* bool_type;
// Member data
IntType v_;
public:
// Template parameters
typedef IntType int_type;
BOOST_STATIC_CONSTANT(int,id = ID);
// Lifetime management (use automatic destructor and copy constructor)
my_wrapped_integer( int_type const &v = int_type() ) : v_( v ) {}
// Accessors
int_type value() const { return this->v_; }
// Operators (use automatic copy assignment)
operator bool_type() const { return this->v_ ? &self_type::v_ : 0; }
self_type & operator ++() { ++this->v_; return *this; }
self_type & operator --() { --this->v_; return *this; }
self_type operator ~() const { return self_type( ~this->v_ ); }
self_type operator !() const { return self_type( !this->v_ ); }
self_type operator +() const { return self_type( +this->v_ ); }
self_type operator -() const { return self_type( -this->v_ ); }
bool operator <( self_type const &r ) const { return this->v_ < r.v_; }
bool operator ==( self_type const &r ) const { return this->v_ == r.v_; }
self_type &operator *=(self_type const &r) {this->v_ *= r.v_; return *this;}
self_type &operator /=(self_type const &r) {this->v_ /= r.v_; return *this;}
self_type &operator %=(self_type const &r) {this->v_ %= r.v_; return *this;}
self_type &operator +=(self_type const &r) {this->v_ += r.v_; return *this;}
self_type &operator -=(self_type const &r) {this->v_ -= r.v_; return *this;}
self_type &operator<<=(self_type const &r){this->v_ <<= r.v_; return *this;}
self_type &operator>>=(self_type const &r){this->v_ >>= r.v_; return *this;}
self_type &operator &=(self_type const &r) {this->v_ &= r.v_; return *this;}
self_type &operator |=(self_type const &r) {this->v_ |= r.v_; return *this;}
self_type &operator ^=(self_type const &r) {this->v_ ^= r.v_; return *this;}
// Input & output
friend std::istream & operator >>( std::istream &i, self_type &x )
{ return i >> x.v_; }
friend std::ostream & operator <<( std::ostream &o, self_type const &x )
{ return o << x.v_; }
}; // my_wrapped_integer
template < typename IntType, int ID >
my_wrapped_integer<IntType, ID> abs( my_wrapped_integer<IntType, ID> const &x )
{ return ( x < my_wrapped_integer<IntType, ID>(0) ) ? -x : +x; }
typedef my_wrapped_integer<int> MyInt1;
typedef my_wrapped_integer<unsigned> MyUnsigned1;
typedef my_wrapped_integer<int, 1> MyInt2;
typedef my_wrapped_integer<unsigned, 1> MyUnsigned2;
// Without these explicit instantiations, MSVC++ 6.5/7.0 does not find
// some friend operators in certain contexts.
MyInt1 dummy1;
MyUnsigned1 dummy2;
MyInt2 dummy3;
MyUnsigned2 dummy4;
// Various types to test with each GCD/LCM
typedef ::boost::mpl::list<signed char, short, int, long,
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1500)
#elif defined(BOOST_HAS_LONG_LONG)
boost::long_long_type,
#elif defined(BOOST_HAS_MS_INT64)
__int64,
#endif
MyInt1
#ifndef DISABLE_MP_TESTS
, boost::multiprecision::cpp_int
#endif
> signed_test_types;
typedef ::boost::mpl::list<unsigned char, unsigned short, unsigned,
unsigned long,
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1500)
#elif defined(BOOST_HAS_LONG_LONG)
boost::ulong_long_type,
#elif defined(BOOST_HAS_MS_INT64)
unsigned __int64,
#endif
MyUnsigned1, MyUnsigned2 /*, boost::multiprecision::uint256_t*/> unsigned_test_types;
} // namespace
#define BOOST_NO_MACRO_EXPAND /**/
// Specialize numeric_limits for _some_ of our types
namespace std
{
template < >
class numeric_limits< MyInt1 >
{
typedef MyInt1::int_type int_type;
typedef numeric_limits<int_type> limits_type;
public:
BOOST_STATIC_CONSTANT(bool, is_specialized = limits_type::is_specialized);
static MyInt1 min BOOST_NO_MACRO_EXPAND() throw() { return (limits_type::min)(); }
static MyInt1 max BOOST_NO_MACRO_EXPAND() throw() { return (limits_type::max)(); }
BOOST_STATIC_CONSTANT(int, digits = limits_type::digits);
BOOST_STATIC_CONSTANT(int, digits10 = limits_type::digits10);
#ifndef BOOST_NO_CXX11_NUMERIC_LIMITS
BOOST_STATIC_CONSTANT(int, max_digits10 = limits_type::max_digits10);
#endif
BOOST_STATIC_CONSTANT(bool, is_signed = limits_type::is_signed);
BOOST_STATIC_CONSTANT(bool, is_integer = limits_type::is_integer);
BOOST_STATIC_CONSTANT(bool, is_exact = limits_type::is_exact);
BOOST_STATIC_CONSTANT(int, radix = limits_type::radix);
static MyInt1 epsilon() throw() { return limits_type::epsilon(); }
static MyInt1 round_error() throw() { return limits_type::round_error(); }
BOOST_STATIC_CONSTANT(int, min_exponent = limits_type::min_exponent);
BOOST_STATIC_CONSTANT(int, min_exponent10 = limits_type::min_exponent10);
BOOST_STATIC_CONSTANT(int, max_exponent = limits_type::max_exponent);
BOOST_STATIC_CONSTANT(int, max_exponent10 = limits_type::max_exponent10);
BOOST_STATIC_CONSTANT(bool, has_infinity = limits_type::has_infinity);
BOOST_STATIC_CONSTANT(bool, has_quiet_NaN = limits_type::has_quiet_NaN);
BOOST_STATIC_CONSTANT(bool, has_signaling_NaN = limits_type::has_signaling_NaN);
BOOST_STATIC_CONSTANT(float_denorm_style, has_denorm = limits_type::has_denorm);
BOOST_STATIC_CONSTANT(bool, has_denorm_loss = limits_type::has_denorm_loss);
static MyInt1 infinity() throw() { return limits_type::infinity(); }
static MyInt1 quiet_NaN() throw() { return limits_type::quiet_NaN(); }
static MyInt1 signaling_NaN() throw() {return limits_type::signaling_NaN();}
static MyInt1 denorm_min() throw() { return limits_type::denorm_min(); }
BOOST_STATIC_CONSTANT(bool, is_iec559 = limits_type::is_iec559);
BOOST_STATIC_CONSTANT(bool, is_bounded = limits_type::is_bounded);
BOOST_STATIC_CONSTANT(bool, is_modulo = limits_type::is_modulo);
BOOST_STATIC_CONSTANT(bool, traps = limits_type::traps);
BOOST_STATIC_CONSTANT(bool, tinyness_before = limits_type::tinyness_before);
BOOST_STATIC_CONSTANT(float_round_style, round_style = limits_type::round_style);
}; // std::numeric_limits<MyInt1>
template < >
class numeric_limits< MyUnsigned1 >
{
typedef MyUnsigned1::int_type int_type;
typedef numeric_limits<int_type> limits_type;
public:
BOOST_STATIC_CONSTANT(bool, is_specialized = limits_type::is_specialized);
static MyUnsigned1 min BOOST_NO_MACRO_EXPAND() throw() { return (limits_type::min)(); }
static MyUnsigned1 max BOOST_NO_MACRO_EXPAND() throw() { return (limits_type::max)(); }
BOOST_STATIC_CONSTANT(int, digits = limits_type::digits);
BOOST_STATIC_CONSTANT(int, digits10 = limits_type::digits10);
#ifndef BOOST_NO_CXX11_NUMERIC_LIMITS
BOOST_STATIC_CONSTANT(int, max_digits10 = limits_type::max_digits10);
#endif
BOOST_STATIC_CONSTANT(bool, is_signed = limits_type::is_signed);
BOOST_STATIC_CONSTANT(bool, is_integer = limits_type::is_integer);
BOOST_STATIC_CONSTANT(bool, is_exact = limits_type::is_exact);
BOOST_STATIC_CONSTANT(int, radix = limits_type::radix);
static MyUnsigned1 epsilon() throw() { return limits_type::epsilon(); }
static MyUnsigned1 round_error() throw(){return limits_type::round_error();}
BOOST_STATIC_CONSTANT(int, min_exponent = limits_type::min_exponent);
BOOST_STATIC_CONSTANT(int, min_exponent10 = limits_type::min_exponent10);
BOOST_STATIC_CONSTANT(int, max_exponent = limits_type::max_exponent);
BOOST_STATIC_CONSTANT(int, max_exponent10 = limits_type::max_exponent10);
BOOST_STATIC_CONSTANT(bool, has_infinity = limits_type::has_infinity);
BOOST_STATIC_CONSTANT(bool, has_quiet_NaN = limits_type::has_quiet_NaN);
BOOST_STATIC_CONSTANT(bool, has_signaling_NaN = limits_type::has_signaling_NaN);
BOOST_STATIC_CONSTANT(float_denorm_style, has_denorm = limits_type::has_denorm);
BOOST_STATIC_CONSTANT(bool, has_denorm_loss = limits_type::has_denorm_loss);
static MyUnsigned1 infinity() throw() { return limits_type::infinity(); }
static MyUnsigned1 quiet_NaN() throw() { return limits_type::quiet_NaN(); }
static MyUnsigned1 signaling_NaN() throw()
{ return limits_type::signaling_NaN(); }
static MyUnsigned1 denorm_min() throw(){ return limits_type::denorm_min(); }
BOOST_STATIC_CONSTANT(bool, is_iec559 = limits_type::is_iec559);
BOOST_STATIC_CONSTANT(bool, is_bounded = limits_type::is_bounded);
BOOST_STATIC_CONSTANT(bool, is_modulo = limits_type::is_modulo);
BOOST_STATIC_CONSTANT(bool, traps = limits_type::traps);
BOOST_STATIC_CONSTANT(bool, tinyness_before = limits_type::tinyness_before);
BOOST_STATIC_CONSTANT(float_round_style, round_style = limits_type::round_style);
}; // std::numeric_limits<MyUnsigned1>
#if BOOST_WORKAROUND(BOOST_MSVC,<1300)
// MSVC 6.0 lacks operator<< for __int64, see
// https://support.microsoft.com/kb/168440/
inline ostream& operator<<(ostream& os, __int64 i)
{
char buf[20];
sprintf(buf,"%I64d", i);
os << buf;
return os;
}
inline ostream& operator<<(ostream& os, unsigned __int64 i)
{
char buf[20];
sprintf(buf,"%I64u", i);
os << buf;
return os;
}
#endif
} // namespace std
// GCD tests
// GCD on signed integer types
template< class T > void gcd_int_test() // signed_test_types
{
#ifndef BOOST_MSVC
using boost::integer::gcd;
using boost::integer::gcd_evaluator;
#else
using namespace boost::integer;
#endif
// Originally from Boost.Rational tests
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(1), static_cast<T>(-1)), static_cast<T>( 1) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(-1), static_cast<T>(1)), static_cast<T>( 1) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(1), static_cast<T>(1)), static_cast<T>( 1) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(-1), static_cast<T>(-1)), static_cast<T>( 1) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(0), static_cast<T>(0)), static_cast<T>( 0) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(7), static_cast<T>(0)), static_cast<T>( 7) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(0), static_cast<T>(9)), static_cast<T>( 9) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(-7), static_cast<T>(0)), static_cast<T>( 7) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(0), static_cast<T>(-9)), static_cast<T>( 9) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(42), static_cast<T>(30)), static_cast<T>( 6) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(6), static_cast<T>(-9)), static_cast<T>( 3) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(-10), static_cast<T>(-10)), static_cast<T>(10) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(-25), static_cast<T>(-10)), static_cast<T>( 5) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(3), static_cast<T>(7)), static_cast<T>( 1) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(8), static_cast<T>(9)), static_cast<T>( 1) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(7), static_cast<T>(49)), static_cast<T>( 7) );
// Again with function object:
BOOST_TEST_EQ(gcd_evaluator<T>()(1, -1), static_cast<T>(1));
BOOST_TEST_EQ(gcd_evaluator<T>()(-1, 1), static_cast<T>(1));
BOOST_TEST_EQ(gcd_evaluator<T>()(1, 1), static_cast<T>(1));
BOOST_TEST_EQ(gcd_evaluator<T>()(-1, -1), static_cast<T>(1));
BOOST_TEST_EQ(gcd_evaluator<T>()(0, 0), static_cast<T>(0));
BOOST_TEST_EQ(gcd_evaluator<T>()(7, 0), static_cast<T>(7));
BOOST_TEST_EQ(gcd_evaluator<T>()(0, 9), static_cast<T>(9));
BOOST_TEST_EQ(gcd_evaluator<T>()(-7, 0), static_cast<T>(7));
BOOST_TEST_EQ(gcd_evaluator<T>()(0, -9), static_cast<T>(9));
BOOST_TEST_EQ(gcd_evaluator<T>()(42, 30), static_cast<T>(6));
BOOST_TEST_EQ(gcd_evaluator<T>()(6, -9), static_cast<T>(3));
BOOST_TEST_EQ(gcd_evaluator<T>()(-10, -10), static_cast<T>(10));
BOOST_TEST_EQ(gcd_evaluator<T>()(-25, -10), static_cast<T>(5));
BOOST_TEST_EQ(gcd_evaluator<T>()(3, 7), static_cast<T>(1));
BOOST_TEST_EQ(gcd_evaluator<T>()(8, 9), static_cast<T>(1));
BOOST_TEST_EQ(gcd_evaluator<T>()(7, 49), static_cast<T>(7));
}
// GCD on unmarked signed integer type
void gcd_unmarked_int_test()
{
#ifndef BOOST_MSVC
using boost::integer::gcd;
#else
using namespace boost::integer;
#endif
// The regular signed-integer GCD function performs the unsigned version,
// then does an absolute-value on the result. Signed types that are not
// marked as such (due to no std::numeric_limits specialization) may be off
// by a sign.
BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(1), static_cast<MyInt2>(-1) )), MyInt2( 1) );
BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(-1), static_cast<MyInt2>(1) )), MyInt2( 1) );
BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(1), static_cast<MyInt2>(1) )), MyInt2( 1) );
BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(-1), static_cast<MyInt2>(-1) )), MyInt2( 1) );
BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(0), static_cast<MyInt2>(0) )), MyInt2( 0) );
BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(7), static_cast<MyInt2>(0) )), MyInt2( 7) );
BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(0), static_cast<MyInt2>(9) )), MyInt2( 9) );
BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(-7), static_cast<MyInt2>(0) )), MyInt2( 7) );
BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(0), static_cast<MyInt2>(-9) )), MyInt2( 9) );
BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(42), static_cast<MyInt2>(30))), MyInt2( 6) );
BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(6), static_cast<MyInt2>(-9) )), MyInt2( 3) );
BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(-10), static_cast<MyInt2>(-10) )), MyInt2(10) );
BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(-25), static_cast<MyInt2>(-10) )), MyInt2( 5) );
BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(3), static_cast<MyInt2>(7) )), MyInt2( 1) );
BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(8), static_cast<MyInt2>(9) )), MyInt2( 1) );
BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(7), static_cast<MyInt2>(49) )), MyInt2( 7) );
}
// GCD on unsigned integer types
template< class T > void gcd_unsigned_test() // unsigned_test_types
{
#ifndef BOOST_MSVC
using boost::integer::gcd;
#else
using namespace boost::integer;
#endif
// Note that unmarked types (i.e. have no std::numeric_limits
// specialization) are treated like non/unsigned types
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(1u), static_cast<T>(1u)), static_cast<T>( 1u) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(0u), static_cast<T>(0u)), static_cast<T>( 0u) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(7u), static_cast<T>(0u)), static_cast<T>( 7u) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(0u), static_cast<T>(9u)), static_cast<T>( 9u) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(42u), static_cast<T>(30u)), static_cast<T>( 6u) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(3u), static_cast<T>(7u)), static_cast<T>( 1u) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(8u), static_cast<T>(9u)), static_cast<T>( 1u) );
BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(7u), static_cast<T>(49u)), static_cast<T>( 7u) );
}
// GCD at compile-time
void gcd_static_test()
{
#ifndef BOOST_MSVC
using boost::integer::static_gcd;
#else
using namespace boost::integer;
#endif
// Can't use "BOOST_TEST_EQ", otherwise the "value" member will be
// disqualified as compile-time-only constant, needing explicit definition
BOOST_TEST( (static_gcd< 1, 1>::value) == 1 );
BOOST_TEST( (static_gcd< 0, 0>::value) == 0 );
BOOST_TEST( (static_gcd< 7, 0>::value) == 7 );
BOOST_TEST( (static_gcd< 0, 9>::value) == 9 );
BOOST_TEST( (static_gcd<42, 30>::value) == 6 );
BOOST_TEST( (static_gcd< 3, 7>::value) == 1 );
BOOST_TEST( (static_gcd< 8, 9>::value) == 1 );
BOOST_TEST( (static_gcd< 7, 49>::value) == 7 );
}
void gcd_method_test()
{
// Verify that the 3 different methods all yield the same result:
boost::random::mt19937 gen;
boost::random::uniform_int_distribution<int> d(0, ((std::numeric_limits<int>::max)() / 2));
for (unsigned int i = 0; i < 10000; ++i)
{
int v1 = d(gen);
int v2 = d(gen);
int g = boost::integer::gcd_detail::Euclid_gcd(v1, v2);
BOOST_TEST(v1 % g == 0);
BOOST_TEST(v2 % g == 0);
BOOST_TEST_EQ(g, boost::integer::gcd_detail::mixed_binary_gcd(v1, v2));
BOOST_TEST_EQ(g, boost::integer::gcd_detail::Stein_gcd(v1, v2));
}
}
// LCM tests
// LCM on signed integer types
template< class T > void lcm_int_test() // signed_test_types
{
#ifndef BOOST_MSVC
using boost::integer::lcm;
using boost::integer::lcm_evaluator;
#else
using namespace boost::integer;
#endif
// Originally from Boost.Rational tests
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(1), static_cast<T>(-1)), static_cast<T>( 1) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(-1), static_cast<T>(1)), static_cast<T>( 1) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(1), static_cast<T>(1)), static_cast<T>( 1) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(-1), static_cast<T>(-1)), static_cast<T>( 1) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(0), static_cast<T>(0)), static_cast<T>( 0) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(6), static_cast<T>(0)), static_cast<T>( 0) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(0), static_cast<T>(7)), static_cast<T>( 0) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(-5), static_cast<T>(0)), static_cast<T>( 0) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(0), static_cast<T>(-4)), static_cast<T>( 0) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(18), static_cast<T>(30)), static_cast<T>(90) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(-6), static_cast<T>(9)), static_cast<T>(18) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(-10), static_cast<T>(-10)), static_cast<T>(10) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(25), static_cast<T>(-10)), static_cast<T>(50) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(3), static_cast<T>(7)), static_cast<T>(21) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(8), static_cast<T>(9)), static_cast<T>(72) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(7), static_cast<T>(49)), static_cast<T>(49) );
// Again with function object:
BOOST_TEST_EQ(lcm_evaluator<T>()(1, -1), static_cast<T>(1));
BOOST_TEST_EQ(lcm_evaluator<T>()(-1, 1), static_cast<T>(1));
BOOST_TEST_EQ(lcm_evaluator<T>()(1, 1), static_cast<T>(1));
BOOST_TEST_EQ(lcm_evaluator<T>()(-1, -1), static_cast<T>(1));
BOOST_TEST_EQ(lcm_evaluator<T>()(0, 0), static_cast<T>(0));
BOOST_TEST_EQ(lcm_evaluator<T>()(6, 0), static_cast<T>(0));
BOOST_TEST_EQ(lcm_evaluator<T>()(0, 7), static_cast<T>(0));
BOOST_TEST_EQ(lcm_evaluator<T>()(-5, 0), static_cast<T>(0));
BOOST_TEST_EQ(lcm_evaluator<T>()(0, -4), static_cast<T>(0));
BOOST_TEST_EQ(lcm_evaluator<T>()(18, 30), static_cast<T>(90));
BOOST_TEST_EQ(lcm_evaluator<T>()(-6, 9), static_cast<T>(18));
BOOST_TEST_EQ(lcm_evaluator<T>()(-10, -10), static_cast<T>(10));
BOOST_TEST_EQ(lcm_evaluator<T>()(25, -10), static_cast<T>(50));
BOOST_TEST_EQ(lcm_evaluator<T>()(3, 7), static_cast<T>(21));
BOOST_TEST_EQ(lcm_evaluator<T>()(8, 9), static_cast<T>(72));
BOOST_TEST_EQ(lcm_evaluator<T>()(7, 49), static_cast<T>(49));
}
// LCM on unmarked signed integer type
void lcm_unmarked_int_test()
{
#ifndef BOOST_MSVC
using boost::integer::lcm;
#else
using namespace boost::integer;
#endif
// The regular signed-integer LCM function performs the unsigned version,
// then does an absolute-value on the result. Signed types that are not
// marked as such (due to no std::numeric_limits specialization) may be off
// by a sign.
BOOST_TEST_EQ( abs(boost::integer::lcm( static_cast<MyInt2>(1), static_cast<MyInt2>(-1) )), MyInt2( 1) );
BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(-1), static_cast<MyInt2>(1) )), MyInt2( 1) );
BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(1), static_cast<MyInt2>(1) )), MyInt2( 1) );
BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(-1), static_cast<MyInt2>(-1) )), MyInt2( 1) );
BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(0), static_cast<MyInt2>(0) )), MyInt2( 0) );
BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(6), static_cast<MyInt2>(0) )), MyInt2( 0) );
BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(0), static_cast<MyInt2>(7) )), MyInt2( 0) );
BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(-5), static_cast<MyInt2>(0) )), MyInt2( 0) );
BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(0), static_cast<MyInt2>(-4) )), MyInt2( 0) );
BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(18), static_cast<MyInt2>(30) )), MyInt2(90) );
BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(-6), static_cast<MyInt2>(9) )), MyInt2(18) );
BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(-10), static_cast<MyInt2>(-10) )), MyInt2(10) );
BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(25), static_cast<MyInt2>(-10) )), MyInt2(50) );
BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(3), static_cast<MyInt2>(7) )), MyInt2(21) );
BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(8), static_cast<MyInt2>(9) )), MyInt2(72) );
BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(7), static_cast<MyInt2>(49) )), MyInt2(49) );
}
// LCM on unsigned integer types
template< class T > void lcm_unsigned_test() // unsigned_test_types
{
#ifndef BOOST_MSVC
using boost::integer::lcm;
#else
using namespace boost::integer;
#endif
// Note that unmarked types (i.e. have no std::numeric_limits
// specialization) are treated like non/unsigned types
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(1u), static_cast<T>(1u)), static_cast<T>( 1u) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(0u), static_cast<T>(0u)), static_cast<T>( 0u) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(6u), static_cast<T>(0u)), static_cast<T>( 0u) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(0u), static_cast<T>(7u)), static_cast<T>( 0u) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(18u), static_cast<T>(30u)), static_cast<T>(90u) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(3u), static_cast<T>(7u)), static_cast<T>(21u) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(8u), static_cast<T>(9u)), static_cast<T>(72u) );
BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(7u), static_cast<T>(49u)), static_cast<T>(49u) );
}
// LCM at compile-time
void lcm_static_test()
{
#ifndef BOOST_MSVC
using boost::integer::static_lcm;
#else
using namespace boost::integer;
#endif
// Can't use "BOOST_TEST_EQ", otherwise the "value" member will be
// disqualified as compile-time-only constant, needing explicit definition
BOOST_TEST( (static_lcm< 1, 1>::value) == 1 );
BOOST_TEST( (static_lcm< 0, 0>::value) == 0 );
BOOST_TEST( (static_lcm< 6, 0>::value) == 0 );
BOOST_TEST( (static_lcm< 0, 7>::value) == 0 );
BOOST_TEST( (static_lcm<18, 30>::value) == 90 );
BOOST_TEST( (static_lcm< 3, 7>::value) == 21 );
BOOST_TEST( (static_lcm< 8, 9>::value) == 72 );
BOOST_TEST( (static_lcm< 7, 49>::value) == 49 );
}
void variadics()
{
unsigned i[] = { 44, 56, 76, 88 };
BOOST_TEST_EQ(boost::integer::gcd_range(i, i + 4).first, 4);
BOOST_TEST_EQ(boost::integer::gcd_range(i, i + 4).second, i + 4);
BOOST_TEST_EQ(boost::integer::lcm_range(i, i + 4).first, 11704);
BOOST_TEST_EQ(boost::integer::lcm_range(i, i + 4).second, i + 4);
unsigned i_gcd_unity[] = { 44, 56, 1, 88 };
BOOST_TEST_EQ(boost::integer::gcd_range(i_gcd_unity, i_gcd_unity + 4).first, 1);
BOOST_TEST_EQ(boost::integer::gcd_range(i_gcd_unity, i_gcd_unity + 4).second, i_gcd_unity + 3);
unsigned i_lcm_unity[] = { 44, 56, 0, 88 };
BOOST_TEST_EQ(boost::integer::lcm_range(i_lcm_unity, i_lcm_unity + 4).first, 0);
BOOST_TEST_EQ(boost::integer::lcm_range(i_lcm_unity, i_lcm_unity + 4).second, i_lcm_unity + 3);
#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
BOOST_TEST_EQ(boost::integer::gcd(i[0], i[1], i[2], i[3]), 4);
BOOST_TEST_EQ(boost::integer::lcm(i[0], i[1], i[2], i[3]), 11704);
#endif
}
// Test case from Boost.Rational, need to make sure we don't break the rational lib:
template <class T> void gcd_and_lcm_on_rationals()
{
typedef boost::rational<T> rational;
BOOST_TEST_EQ(boost::integer::gcd(rational(1, 4), rational(1, 3)),
rational(1, 12));
BOOST_TEST_EQ(boost::integer::lcm(rational(1, 4), rational(1, 3)),
rational(1));
}
#ifndef DISABLE_MP_TESTS
#define TEST_SIGNED_( test ) \
test<signed char>(); \
test<short>(); \
test<int>(); \
test<long>(); \
test<MyInt1>(); \
test<boost::multiprecision::cpp_int>(); \
test<boost::multiprecision::int512_t>();
#else
#define TEST_SIGNED_( test ) \
test<signed char>(); \
test<short>(); \
test<int>(); \
test<long>(); \
test<MyInt1>();
#endif
#ifdef BOOST_HAS_LONG_LONG
# define TEST_SIGNED__( test ) \
TEST_SIGNED_( test ) \
test<boost::long_long_type>();
#elif defined(BOOST_HAS_MS_INT64)
# define TEST_SIGNED__( test ) \
TEST_SIGNED_( test ) \
test<__int64>();
#endif
#ifndef DISABLE_MP_TESTS
#define TEST_UNSIGNED_( test ) \
test<unsigned char>(); \
test<unsigned short>(); \
test<unsigned>(); \
test<unsigned long>(); \
test<MyUnsigned1>(); \
test<MyUnsigned2>(); \
test<boost::multiprecision::uint512_t>();
#else
#define TEST_UNSIGNED_( test ) \
test<unsigned char>(); \
test<unsigned short>(); \
test<unsigned>(); \
test<unsigned long>(); \
test<MyUnsigned1>(); \
test<MyUnsigned2>();
#endif
#ifdef BOOST_HAS_LONG_LONG
# define TEST_UNSIGNED( test ) \
TEST_UNSIGNED_( test ) \
test<boost::ulong_long_type>();
#elif defined(BOOST_HAS_MS_INT64)
# define TEST_UNSIGNED( test ) \
TEST_UNSIGNED_( test ) \
test<unsigned __int64>();
#endif
#ifdef BOOST_INTEGER_HAS_GMPXX_H
# define TEST_SIGNED(test)\
TEST_SIGNED__(test)\
test<mpz_class>();
# define TEST_SIGNED_NO_GMP(test) TEST_SIGNED__(test)
#else
# define TEST_SIGNED(test) TEST_SIGNED__(test)
# define TEST_SIGNED_NO_GMP(test) TEST_SIGNED__(test)
#endif
int main()
{
TEST_SIGNED(gcd_int_test)
gcd_unmarked_int_test();
TEST_UNSIGNED(gcd_unsigned_test)
gcd_static_test();
gcd_method_test();
TEST_SIGNED(lcm_int_test)
lcm_unmarked_int_test();
TEST_UNSIGNED(lcm_unsigned_test)
lcm_static_test();
variadics();
TEST_SIGNED_NO_GMP(gcd_and_lcm_on_rationals)
return boost::report_errors();
}

58
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/extended_euclidean_test.cpp vendored Executable file
View File

@@ -0,0 +1,58 @@
/*
* (C) Copyright Nick Thompson 2018.
* Use, modification and distribution are subject to the
* Boost Software License, Version 1.0. (See accompanying file
* LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
*/
#include "multiprecision_config.hpp"
#ifndef DISABLE_MP_TESTS
#include <boost/integer/extended_euclidean.hpp>
#include <boost/cstdint.hpp>
#include <boost/core/lightweight_test.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/integer/common_factor.hpp>
using boost::multiprecision::int128_t;
using boost::multiprecision::int256_t;
using boost::integer::extended_euclidean;
using boost::integer::gcd;
template<class Z>
void test_extended_euclidean()
{
// Stress test:
//Z max_arg = std::numeric_limits<Z>::max();
Z max_arg = 500;
for (Z m = max_arg; m > 0; --m)
{
for (Z n = max_arg; n > 0; --n)
{
boost::integer::euclidean_result_t<Z> u = extended_euclidean(m, n);
int256_t gcdmn = gcd(m, n);
int256_t x = u.x;
int256_t y = u.y;
BOOST_TEST_EQ(u.gcd, gcdmn);
BOOST_TEST_EQ(m*x + n*y, gcdmn);
}
}
}
int main()
{
test_extended_euclidean<boost::int16_t>();
test_extended_euclidean<boost::int32_t>();
test_extended_euclidean<boost::int64_t>();
test_extended_euclidean<int128_t>();
return boost::report_errors();;
}
#else
int main()
{
return 0;
}
#endif

8
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/fail_int_exact.cpp vendored Executable file
View File

@@ -0,0 +1,8 @@
// Copyright John Maddock 2012.
// Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
#include <boost/integer.hpp>
typedef boost::int_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::exact fail_int_exact;

8
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/fail_int_fast.cpp vendored Executable file
View File

@@ -0,0 +1,8 @@
// Copyright John Maddock 2012.
// Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
#include <boost/integer.hpp>
typedef boost::int_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::fast fail_int_fast;

8
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/fail_int_least.cpp vendored Executable file
View File

@@ -0,0 +1,8 @@
// Copyright John Maddock 2012.
// Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
#include <boost/integer.hpp>
typedef boost::int_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::least fail_int_least;

13
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/fail_uint_65.cpp vendored Executable file
View File

@@ -0,0 +1,13 @@
// Copyright John Maddock 2012.
// Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
#include <boost/integer.hpp>
#include <iostream>
int main()
{
std::cout << std::numeric_limits<boost::uint_t<65>::least>::digits;
return 0;
}

8
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/fail_uint_exact.cpp vendored Executable file
View File

@@ -0,0 +1,8 @@
// Copyright John Maddock 2012.
// Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
#include <boost/integer.hpp>
typedef boost::uint_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::exact fail_uint_exact;

8
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/fail_uint_fast.cpp vendored Executable file
View File

@@ -0,0 +1,8 @@
// Copyright John Maddock 2012.
// Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
#include <boost/integer.hpp>
typedef boost::uint_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::fast fail_uint_fast;

8
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/fail_uint_least.cpp vendored Executable file
View File

@@ -0,0 +1,8 @@
// Copyright John Maddock 2012.
// Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
#include <boost/integer.hpp>
typedef boost::uint_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::least fail_uint_least;

66
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/gcd_constexpr14_test.cpp vendored Executable file
View File

@@ -0,0 +1,66 @@
// (C) Copyright John Maddock 2017.
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
#include <boost/integer/common_factor.hpp>
#ifndef BOOST_NO_CXX14_CONSTEXPR
void test_constexpr1()
{
constexpr const boost::int64_t i = 347 * 463 * 727;
constexpr const boost::int64_t j = 191 * 347 * 281;
constexpr const boost::int64_t k = boost::integer::gcd(i, j);
constexpr const boost::int64_t l = boost::integer::lcm(i, j);
static_assert(k == 347, "Expected result not integer in constexpr gcd.");
static_assert(l == 6268802158037, "Expected result not integer in constexpr lcm.");
}
void test_constexpr2()
{
constexpr const boost::uint64_t i = 347 * 463 * 727;
constexpr const boost::uint64_t j = 191 * 347 * 281;
constexpr const boost::uint64_t k = boost::integer::gcd(i, j);
constexpr const boost::uint64_t l = boost::integer::lcm(i, j);
static_assert(k == 347, "Expected result not integer in constexpr gcd.");
static_assert(l == 6268802158037, "Expected result not integer in constexpr lcm.");
}
void test_constexpr3()
{
constexpr const boost::uint64_t i = 347 * 463 * 727;
constexpr const boost::uint64_t j = 191 * 347 * 281;
constexpr const boost::uint64_t k = boost::integer::gcd_detail::Euclid_gcd(i, j);
static_assert(k == 347, "Expected result not integer in constexpr gcd.");
}
void test_constexpr4()
{
constexpr const boost::uint64_t i = 347 * 463 * 727;
constexpr const boost::uint64_t j = 191 * 347 * 281;
constexpr const boost::uint64_t k = boost::integer::gcd_detail::mixed_binary_gcd(i, j);
static_assert(k == 347, "Expected result not integer in constexpr gcd.");
}
void test_constexpr5()
{
constexpr const boost::uint64_t i = 347 * 463 * 727;
constexpr const boost::uint64_t j = 191 * 347 * 281;
constexpr const boost::uint64_t k = boost::integer::gcd_detail::Stein_gcd(i, j);
static_assert(k == 347, "Expected result not integer in constexpr gcd.");
}
#endif

35
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/gcd_noexcept_test.cpp vendored Executable file
View File

@@ -0,0 +1,35 @@
// (C) Copyright John Maddock 2017.
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
#include <boost/integer/common_factor.hpp>
#if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
//
// These tests don't pass with GCC-4.x:
//
#if !defined(BOOST_GCC) || (BOOST_GCC >= 50000)
void test_noexcept(unsigned char a, unsigned char b)
{
static_assert(noexcept(boost::integer::gcd(static_cast<unsigned char>(a), static_cast<unsigned char>(b))), "Expected a noexcept function.");
#ifndef _MSC_VER
// This generates an internal compiler error if enabled as well as the following test:
static_assert(noexcept(boost::integer::gcd(static_cast<char>(a), static_cast<char>(b))), "Expected a noexcept function.");
#endif
static_assert(noexcept(boost::integer::gcd(static_cast<signed char>(a), static_cast<signed char>(b))), "Expected a noexcept function.");
static_assert(noexcept(boost::integer::gcd(static_cast<short>(a), static_cast<short>(b))), "Expected a noexcept function.");
static_assert(noexcept(boost::integer::gcd(static_cast<unsigned short>(a), static_cast<unsigned short>(b))), "Expected a noexcept function.");
static_assert(noexcept(boost::integer::gcd(static_cast<int>(a), static_cast<int>(b))), "Expected a noexcept function.");
static_assert(noexcept(boost::integer::gcd(static_cast<unsigned int>(a), static_cast<unsigned int>(b))), "Expected a noexcept function.");
static_assert(noexcept(boost::integer::gcd(static_cast<long>(a), static_cast<long>(b))), "Expected a noexcept function.");
static_assert(noexcept(boost::integer::gcd(static_cast<unsigned long>(a), static_cast<unsigned long>(b))), "Expected a noexcept function.");
static_assert(noexcept(boost::integer::gcd(static_cast<long long>(a), static_cast<long long>(b))), "Expected a noexcept function.");
static_assert(noexcept(boost::integer::gcd(static_cast<unsigned long long>(a), static_cast<unsigned long long>(b))), "Expected a noexcept function.");
}
#endif
#endif

15
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/has_gmpxx.cpp vendored Executable file
View File

@@ -0,0 +1,15 @@
// Copyright John Maddock 2008.
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
#include <gmpxx.h>
// On Linux, libgmpxx is built with gcc and libstdc++. When the user application, such as tests, are built against libc++,
// linking fails because of the C++ standard library symbol names mismatch. So fail the test if we're not using libstdc++.
#if defined(__linux__) || defined(__linux) || defined(linux)
#include <utility>
#if !defined(__GLIBCPP__) && !defined(__GLIBCXX__)
#error "libgmpxx is not supported on this platform with this C++ standard library"
#endif
#endif

22
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/integer_fwd_include_test.cpp vendored Executable file
View File

@@ -0,0 +1,22 @@
// Copyright John Maddock 2009.
// Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
#include <boost/integer_fwd.hpp> // must be the only #include!
// just declare some functions that use the incomplete types in the header:
void f1(const boost::integer_traits<char>*);
void f2(const boost::int_fast_t<char>*);
void f3(const boost::int_t<12>*);
void f4(const boost::uint_t<31>*);
void f5(const boost::int_max_value_t<100>*);
void f6(const boost::int_min_value_t<-100>*);
void f7(const boost::uint_value_t<100>*);
void f8(const boost::high_bit_mask_t<10>*);
void f9(const boost::low_bits_mask_t<10>*);
void f10(boost::static_log2_argument_type, boost::static_log2_result_type, boost::static_log2<10>*);
void f11(boost::static_min_max_signed_type, boost::static_min_max_unsigned_type);
void f12(boost::static_signed_min<1, 2>*, boost::static_signed_max<1,2>*);
void f13(boost::static_unsigned_min<1,2>*, boost::static_unsigned_min<1,2>*);

36
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/integer_include_test.cpp vendored Executable file
View File

@@ -0,0 +1,36 @@
// Copyright John Maddock 2009.
// Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
#include <boost/integer.hpp> // must be the only #include!
int main()
{
boost::int_fast_t<char>::fast f = 0;
(void)f;
boost::int_t<16>::fast f2 = 0;
(void)f2;
boost::int_t<32>::exact e = 0;
(void)e;
boost::int_t<12>::least l = 0;
(void)l;
boost::uint_t<16>::fast uf2 = 0;
(void)uf2;
boost::uint_t<32>::exact ue = 0;
(void)ue;
boost::uint_t<12>::least ul = 0;
(void)ul;
boost::int_max_value_t<200>::fast v1 = 0;
(void)v1;
boost::int_max_value_t<2000>::least v2 = 0;
(void)v2;
boost::int_min_value_t<-200>::fast v3 = 0;
(void)v3;
boost::int_min_value_t<-2000>::least v4 = 0;
(void)v4;
boost::uint_value_t<200>::fast v5 = 0;
(void)v5;
boost::uint_value_t<2000>::least v6 = 0;
(void)v6;
}

187
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/integer_log2_test.cpp vendored Executable file
View File

@@ -0,0 +1,187 @@
// Boost integer_log2.hpp test program --------------------------------------//
// (C) Copyright Andrey Semashev 2021.
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// See https://www.boost.org for most recent version including documentation.
#include <boost/config.hpp>
#include <boost/cstdint.hpp>
#include <boost/integer/integer_log2.hpp>
#include <boost/core/lightweight_test.hpp>
#include <iostream>
#include "multiprecision_config.hpp"
#if !defined(DISABLE_MP_TESTS)
#include <boost/multiprecision/cpp_int.hpp>
#endif
// Macros to compact code
#define PRIVATE_LB_TEST( v, e ) BOOST_TEST( ::boost::integer_log2((v)) == e )
#define PRIVATE_PRINT_LB( v ) ::std::cout << "boost::integer_log2(" << (v) \
<< ") = " << ::boost::integer_log2((v)) << '.' << ::std::endl
// Control to check for a compile-time error
#ifndef CONTROL_LB_0_TEST
#define PRIVATE_LB_0_TEST
#else
#define PRIVATE_LB_0_TEST PRIVATE_PRINT_LB( 0 )
#endif
// Main testing function
int main()
{
std::cout << "Doing tests on integer_log2." << std::endl;
PRIVATE_LB_0_TEST;
PRIVATE_LB_TEST( (unsigned char)1, 0 );
PRIVATE_LB_TEST( (unsigned char)2, 1 );
PRIVATE_LB_TEST( 1, 0 );
PRIVATE_LB_TEST( 2, 1 );
PRIVATE_LB_TEST( 3, 1 );
PRIVATE_LB_TEST( 4, 2 );
PRIVATE_LB_TEST( 5, 2 );
PRIVATE_LB_TEST( 6, 2 );
PRIVATE_LB_TEST( 7, 2 );
PRIVATE_LB_TEST( 8, 3 );
PRIVATE_LB_TEST( 9, 3 );
PRIVATE_LB_TEST( 10, 3 );
PRIVATE_LB_TEST( 11, 3 );
PRIVATE_LB_TEST( 12, 3 );
PRIVATE_LB_TEST( 13, 3 );
PRIVATE_LB_TEST( 14, 3 );
PRIVATE_LB_TEST( 15, 3 );
PRIVATE_LB_TEST( 16, 4 );
PRIVATE_LB_TEST( 17, 4 );
PRIVATE_LB_TEST( 18, 4 );
PRIVATE_LB_TEST( 19, 4 );
PRIVATE_LB_TEST( 20, 4 );
PRIVATE_LB_TEST( 21, 4 );
PRIVATE_LB_TEST( 22, 4 );
PRIVATE_LB_TEST( 23, 4 );
PRIVATE_LB_TEST( 24, 4 );
PRIVATE_LB_TEST( 25, 4 );
PRIVATE_LB_TEST( 26, 4 );
PRIVATE_LB_TEST( 27, 4 );
PRIVATE_LB_TEST( 28, 4 );
PRIVATE_LB_TEST( 29, 4 );
PRIVATE_LB_TEST( 30, 4 );
PRIVATE_LB_TEST( 31, 4 );
PRIVATE_LB_TEST( 32, 5 );
PRIVATE_LB_TEST( 33, 5 );
PRIVATE_LB_TEST( 34, 5 );
PRIVATE_LB_TEST( 35, 5 );
PRIVATE_LB_TEST( 36, 5 );
PRIVATE_LB_TEST( 37, 5 );
PRIVATE_LB_TEST( 38, 5 );
PRIVATE_LB_TEST( 39, 5 );
PRIVATE_LB_TEST( 40, 5 );
PRIVATE_LB_TEST( 63, 5 );
PRIVATE_LB_TEST( 64, 6 );
PRIVATE_LB_TEST( 65, 6 );
PRIVATE_LB_TEST( 127, 6 );
PRIVATE_LB_TEST( 128, 7 );
PRIVATE_LB_TEST( 129, 7 );
PRIVATE_LB_TEST( 255, 7 );
PRIVATE_LB_TEST( 256, 8 );
PRIVATE_LB_TEST( 257, 8 );
PRIVATE_LB_TEST( 511, 8 );
PRIVATE_LB_TEST( 512, 9 );
PRIVATE_LB_TEST( 513, 9 );
PRIVATE_LB_TEST( 1023, 9 );
PRIVATE_LB_TEST( 1024, 10 );
PRIVATE_LB_TEST( 1025, 10 );
PRIVATE_LB_TEST( 2047, 10 );
PRIVATE_LB_TEST( 2048, 11 );
PRIVATE_LB_TEST( 2049, 11 );
PRIVATE_LB_TEST( 4095, 11 );
PRIVATE_LB_TEST( 4096, 12 );
PRIVATE_LB_TEST( 4097, 12 );
PRIVATE_LB_TEST( 8191, 12 );
PRIVATE_LB_TEST( 8192, 13 );
PRIVATE_LB_TEST( 8193, 13 );
PRIVATE_LB_TEST( 16383, 13 );
PRIVATE_LB_TEST( 16384, 14 );
PRIVATE_LB_TEST( 16385, 14 );
PRIVATE_LB_TEST( 32767, 14 );
PRIVATE_LB_TEST( 32768, 15 );
PRIVATE_LB_TEST( 32769, 15 );
PRIVATE_LB_TEST( 65535, 15 );
PRIVATE_LB_TEST( 65536, 16 );
PRIVATE_LB_TEST( 65537, 16 );
#if defined(UINT32_C)
PRIVATE_LB_TEST( UINT32_C(4294967295), 31 );
#endif
#if defined(UINT64_C) && !defined(BOOST_NO_INT64_T)
PRIVATE_LB_TEST( UINT64_C(4294967296), 32 );
PRIVATE_LB_TEST( UINT64_C(4294967297), 32 );
PRIVATE_LB_TEST( UINT64_C(18446744073709551615), 63 );
#endif
#if defined(BOOST_HAS_INT128)
PRIVATE_LB_TEST( boost::uint128_type(1u) << 64u, 64 );
PRIVATE_LB_TEST( (boost::uint128_type(1u) << 64u) + 1u, 64 );
PRIVATE_LB_TEST( ~boost::uint128_type(0u), 127 );
#endif
#if !defined(DISABLE_MP_TESTS)
PRIVATE_LB_TEST( boost::multiprecision::cpp_int(1), 0 );
PRIVATE_LB_TEST( boost::multiprecision::cpp_int(2), 1 );
PRIVATE_LB_TEST( boost::multiprecision::cpp_int(3), 1 );
PRIVATE_LB_TEST( boost::multiprecision::cpp_int(65535), 15 );
PRIVATE_LB_TEST( boost::multiprecision::cpp_int(65536), 16 );
PRIVATE_LB_TEST( boost::multiprecision::int1024_t(1), 0 );
PRIVATE_LB_TEST( boost::multiprecision::int1024_t(2), 1 );
PRIVATE_LB_TEST( boost::multiprecision::int1024_t(3), 1 );
PRIVATE_LB_TEST( boost::multiprecision::int1024_t(65535), 15 );
PRIVATE_LB_TEST( boost::multiprecision::int1024_t(65536), 16 );
PRIVATE_LB_TEST( boost::multiprecision::uint1024_t(1), 0 );
PRIVATE_LB_TEST( boost::multiprecision::uint1024_t(2), 1 );
PRIVATE_LB_TEST( boost::multiprecision::uint1024_t(3), 1 );
PRIVATE_LB_TEST( boost::multiprecision::uint1024_t(65535), 15 );
PRIVATE_LB_TEST( boost::multiprecision::uint1024_t(65536), 16 );
#endif
return boost::report_errors();
}

18
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/integer_mask_include_test.cpp vendored Executable file
View File

@@ -0,0 +1,18 @@
// Copyright John Maddock 2009.
// Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
#include <boost/integer/integer_mask.hpp> // must be the only #include!
int main()
{
boost::high_bit_mask_t<20>::least l = boost::high_bit_mask_t<20>::high_bit;
boost::high_bit_mask_t<12>::fast f = boost::high_bit_mask_t<12>::high_bit_fast;
l += f + boost::high_bit_mask_t<12>::bit_position;
(void)l;
boost::low_bits_mask_t<20>::least l2 = boost::low_bits_mask_t<20>::sig_bits;
boost::low_bits_mask_t<12>::fast f2 = boost::low_bits_mask_t<12>::sig_bits_fast;
l2 += f2 + boost::low_bits_mask_t<12>::bit_count;
(void)l2;
}

203
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/integer_mask_test.cpp vendored Executable file
View File

@@ -0,0 +1,203 @@
// boost integer_mask.hpp test program -------------------------------------//
// (C) Copyright Daryle Walker 2001.
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// See https://www.boost.org for most recent version including documentation.
// Revision History
// 23 Sep 2001 Initial version (Daryle Walker)
#include <boost/core/lightweight_test.hpp>
#include <boost/cstdlib.hpp> // for boost::exit_success
#include <boost/integer/integer_mask.hpp> // for boost::high_bit_mask_t, etc.
#include <iostream> // for std::cout (std::endl indirectly)
#ifdef BOOST_MSVC
#pragma warning(disable:4127) // conditional expression is constant
#endif
#if defined(BOOST_HAS_LONG_LONG)
#define MASK_TYPE ::boost::ulong_long_type
#elif defined(BOOST_HAS_MS_INT64)
#define MASK_TYPE unsigned __int64
#else
#define MASK_TYPE unsigned long
#endif
#define ONE (static_cast<MASK_TYPE>(1))
#define PRIVATE_HIGH_BIT_SLOW_TEST(v) BOOST_TEST( ::boost::high_bit_mask_t< \
(v) >::high_bit == (ONE << (v)) );
#define PRIVATE_HIGH_BIT_FAST_TEST(v) BOOST_TEST( ::boost::high_bit_mask_t< \
(v) >::high_bit_fast == (ONE << (v)) );
#define PRIVATE_HIGH_BIT_TEST(v) do { PRIVATE_HIGH_BIT_SLOW_TEST(v); \
PRIVATE_HIGH_BIT_FAST_TEST(v); } while (false)
#define PRIVATE_LOW_BITS_SLOW_TEST(v) \
do{ \
MASK_TYPE mask = 0;\
if(v > 0)\
{ mask = ((ONE << (v-1)) - 1); mask <<= 1; mask |= 1; }\
BOOST_TEST( ::boost::low_bits_mask_t< (v) >::sig_bits == mask); \
}while(false);
#define PRIVATE_LOW_BITS_FAST_TEST(v) \
do{ \
MASK_TYPE mask = 0;\
if(v > 0)\
{ mask = ((ONE << (v-1)) - 1); mask <<= 1; mask |= 1; }\
BOOST_TEST( ::boost::low_bits_mask_t< (v) >::sig_bits_fast == mask);\
}while(false);
#define PRIVATE_LOW_BITS_TEST(v) do { PRIVATE_LOW_BITS_SLOW_TEST(v); \
PRIVATE_LOW_BITS_FAST_TEST(v); } while (false)
int main( int, char*[] )
{
using std::cout;
using std::endl;
cout << "Doing high_bit_mask_t tests." << endl;
#if defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)
PRIVATE_HIGH_BIT_TEST( 63 );
PRIVATE_HIGH_BIT_TEST( 62 );
PRIVATE_HIGH_BIT_TEST( 61 );
PRIVATE_HIGH_BIT_TEST( 60 );
PRIVATE_HIGH_BIT_TEST( 59 );
PRIVATE_HIGH_BIT_TEST( 58 );
PRIVATE_HIGH_BIT_TEST( 57 );
PRIVATE_HIGH_BIT_TEST( 56 );
PRIVATE_HIGH_BIT_TEST( 55 );
PRIVATE_HIGH_BIT_TEST( 54 );
PRIVATE_HIGH_BIT_TEST( 53 );
PRIVATE_HIGH_BIT_TEST( 52 );
PRIVATE_HIGH_BIT_TEST( 51 );
PRIVATE_HIGH_BIT_TEST( 50 );
PRIVATE_HIGH_BIT_TEST( 49 );
PRIVATE_HIGH_BIT_TEST( 48 );
PRIVATE_HIGH_BIT_TEST( 47 );
PRIVATE_HIGH_BIT_TEST( 46 );
PRIVATE_HIGH_BIT_TEST( 45 );
PRIVATE_HIGH_BIT_TEST( 44 );
PRIVATE_HIGH_BIT_TEST( 43 );
PRIVATE_HIGH_BIT_TEST( 42 );
PRIVATE_HIGH_BIT_TEST( 41 );
PRIVATE_HIGH_BIT_TEST( 40 );
PRIVATE_HIGH_BIT_TEST( 39 );
PRIVATE_HIGH_BIT_TEST( 38 );
PRIVATE_HIGH_BIT_TEST( 37 );
PRIVATE_HIGH_BIT_TEST( 36 );
PRIVATE_HIGH_BIT_TEST( 35 );
PRIVATE_HIGH_BIT_TEST( 34 );
PRIVATE_HIGH_BIT_TEST( 33 );
PRIVATE_HIGH_BIT_TEST( 32 );
#endif
PRIVATE_HIGH_BIT_TEST( 31 );
PRIVATE_HIGH_BIT_TEST( 30 );
PRIVATE_HIGH_BIT_TEST( 29 );
PRIVATE_HIGH_BIT_TEST( 28 );
PRIVATE_HIGH_BIT_TEST( 27 );
PRIVATE_HIGH_BIT_TEST( 26 );
PRIVATE_HIGH_BIT_TEST( 25 );
PRIVATE_HIGH_BIT_TEST( 24 );
PRIVATE_HIGH_BIT_TEST( 23 );
PRIVATE_HIGH_BIT_TEST( 22 );
PRIVATE_HIGH_BIT_TEST( 21 );
PRIVATE_HIGH_BIT_TEST( 20 );
PRIVATE_HIGH_BIT_TEST( 19 );
PRIVATE_HIGH_BIT_TEST( 18 );
PRIVATE_HIGH_BIT_TEST( 17 );
PRIVATE_HIGH_BIT_TEST( 16 );
PRIVATE_HIGH_BIT_TEST( 15 );
PRIVATE_HIGH_BIT_TEST( 14 );
PRIVATE_HIGH_BIT_TEST( 13 );
PRIVATE_HIGH_BIT_TEST( 12 );
PRIVATE_HIGH_BIT_TEST( 11 );
PRIVATE_HIGH_BIT_TEST( 10 );
PRIVATE_HIGH_BIT_TEST( 9 );
PRIVATE_HIGH_BIT_TEST( 8 );
PRIVATE_HIGH_BIT_TEST( 7 );
PRIVATE_HIGH_BIT_TEST( 6 );
PRIVATE_HIGH_BIT_TEST( 5 );
PRIVATE_HIGH_BIT_TEST( 4 );
PRIVATE_HIGH_BIT_TEST( 3 );
PRIVATE_HIGH_BIT_TEST( 2 );
PRIVATE_HIGH_BIT_TEST( 1 );
PRIVATE_HIGH_BIT_TEST( 0 );
cout << "Doing low_bits_mask_t tests." << endl;
#if defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)
PRIVATE_LOW_BITS_TEST( 64 );
PRIVATE_LOW_BITS_TEST( 63 );
PRIVATE_LOW_BITS_TEST( 62 );
PRIVATE_LOW_BITS_TEST( 61 );
PRIVATE_LOW_BITS_TEST( 60 );
PRIVATE_LOW_BITS_TEST( 59 );
PRIVATE_LOW_BITS_TEST( 58 );
PRIVATE_LOW_BITS_TEST( 57 );
PRIVATE_LOW_BITS_TEST( 56 );
PRIVATE_LOW_BITS_TEST( 55 );
PRIVATE_LOW_BITS_TEST( 54 );
PRIVATE_LOW_BITS_TEST( 53 );
PRIVATE_LOW_BITS_TEST( 52 );
PRIVATE_LOW_BITS_TEST( 51 );
PRIVATE_LOW_BITS_TEST( 50 );
PRIVATE_LOW_BITS_TEST( 49 );
PRIVATE_LOW_BITS_TEST( 48 );
PRIVATE_LOW_BITS_TEST( 47 );
PRIVATE_LOW_BITS_TEST( 46 );
PRIVATE_LOW_BITS_TEST( 45 );
PRIVATE_LOW_BITS_TEST( 44 );
PRIVATE_LOW_BITS_TEST( 43 );
PRIVATE_LOW_BITS_TEST( 42 );
PRIVATE_LOW_BITS_TEST( 41 );
PRIVATE_LOW_BITS_TEST( 40 );
PRIVATE_LOW_BITS_TEST( 39 );
PRIVATE_LOW_BITS_TEST( 38 );
PRIVATE_LOW_BITS_TEST( 37 );
PRIVATE_LOW_BITS_TEST( 36 );
PRIVATE_LOW_BITS_TEST( 35 );
PRIVATE_LOW_BITS_TEST( 34 );
PRIVATE_LOW_BITS_TEST( 33 );
#endif
PRIVATE_LOW_BITS_TEST( 32 );
PRIVATE_LOW_BITS_TEST( 31 );
PRIVATE_LOW_BITS_TEST( 30 );
PRIVATE_LOW_BITS_TEST( 29 );
PRIVATE_LOW_BITS_TEST( 28 );
PRIVATE_LOW_BITS_TEST( 27 );
PRIVATE_LOW_BITS_TEST( 26 );
PRIVATE_LOW_BITS_TEST( 25 );
PRIVATE_LOW_BITS_TEST( 24 );
PRIVATE_LOW_BITS_TEST( 23 );
PRIVATE_LOW_BITS_TEST( 22 );
PRIVATE_LOW_BITS_TEST( 21 );
PRIVATE_LOW_BITS_TEST( 20 );
PRIVATE_LOW_BITS_TEST( 19 );
PRIVATE_LOW_BITS_TEST( 18 );
PRIVATE_LOW_BITS_TEST( 17 );
PRIVATE_LOW_BITS_TEST( 16 );
PRIVATE_LOW_BITS_TEST( 15 );
PRIVATE_LOW_BITS_TEST( 14 );
PRIVATE_LOW_BITS_TEST( 13 );
PRIVATE_LOW_BITS_TEST( 12 );
PRIVATE_LOW_BITS_TEST( 11 );
PRIVATE_LOW_BITS_TEST( 10 );
PRIVATE_LOW_BITS_TEST( 9 );
PRIVATE_LOW_BITS_TEST( 8 );
PRIVATE_LOW_BITS_TEST( 7 );
PRIVATE_LOW_BITS_TEST( 6 );
PRIVATE_LOW_BITS_TEST( 5 );
PRIVATE_LOW_BITS_TEST( 4 );
PRIVATE_LOW_BITS_TEST( 3 );
PRIVATE_LOW_BITS_TEST( 2 );
PRIVATE_LOW_BITS_TEST( 1 );
return boost::report_errors();
}

264
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/integer_test.cpp vendored Executable file
View File

@@ -0,0 +1,264 @@
// boost integer.hpp test program ------------------------------------------//
// Copyright Beman Dawes 1999.
// Copyright Daryle Walker 2001.
// Copyright John Maddock 2009.
// Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
// See https://www.boost.org/libs/integer for documentation.
// Revision History
// 04 Oct 01 Added tests for new templates; rewrote code (Daryle Walker)
// 10 Mar 01 Boost Test Library now used for tests (Beman Dawes)
// 31 Aug 99 Initial version
#include <boost/core/lightweight_test.hpp> // for main, BOOST_TEST
#include <boost/integer.hpp> // for boost::int_t, boost::uint_t
#include <boost/type_traits/is_same.hpp>
#include <boost/mpl/bool.hpp> // for mpl::true_ and false_
#include <climits> // for ULONG_MAX, LONG_MAX, LONG_MIN
#include <iostream> // for std::cout (std::endl indirectly)
#include <typeinfo> // for std::type_info
#ifdef BOOST_MSVC
#pragma warning(disable:4127) // conditional expression is constant
#endif
#if defined( BOOST_BORLANDC )
# pragma option -w-8008 -w-8066 // condition is always true
#endif
//
// Keep track of error count, so we can print out detailed
// info only if we need it:
//
int last_error_count = 0;
//
// Helpers to print out the name of a type,
// we use these as typeid(X).name() doesn't always
// return a human readable string:
//
template <class T> const char* get_name_of_type(T){ return typeid(T).name(); }
const char* get_name_of_type(signed char){ return "signed char"; }
const char* get_name_of_type(unsigned char){ return "unsigned char"; }
const char* get_name_of_type(short){ return "short"; }
const char* get_name_of_type(unsigned short){ return "unsigned short"; }
const char* get_name_of_type(int){ return "int"; }
const char* get_name_of_type(unsigned int){ return "unsigned int"; }
const char* get_name_of_type(long){ return "long"; }
const char* get_name_of_type(unsigned long){ return "unsigned long"; }
#ifdef BOOST_HAS_LONG_LONG
const char* get_name_of_type(boost::long_long_type){ return "boost::long_long_type"; }
const char* get_name_of_type(boost::ulong_long_type){ return "boost::ulong_long_type"; }
#endif
template <int Bits>
void do_test_exact(boost::mpl::true_ const&)
{
// Test the ::exact member:
typedef typename boost::int_t<Bits>::exact int_exact;
typedef typename boost::uint_t<Bits>::exact uint_exact;
typedef typename boost::int_t<Bits>::least least_int;
typedef typename boost::uint_t<Bits>::least least_uint;
BOOST_TEST((boost::is_same<int_exact, least_int>::value));
BOOST_TEST((boost::is_same<uint_exact, least_uint>::value));
}
template <int Bits>
void do_test_exact(boost::mpl::false_ const&)
{
// Nothing to do, type does not have an ::extact member.
}
template <int Bits>
void do_test_bits()
{
//
// Recurse to next smallest number of bits:
//
do_test_bits<Bits - 1>();
//
// Test exact types if we have them:
//
do_test_exact<Bits>(
boost::mpl::bool_<
(sizeof(unsigned char) * CHAR_BIT == Bits)
|| (sizeof(unsigned short) * CHAR_BIT == Bits)
|| (sizeof(unsigned int) * CHAR_BIT == Bits)
|| (sizeof(unsigned long) * CHAR_BIT == Bits)
#ifdef BOOST_HAS_LONG_LONG
|| (sizeof(boost::ulong_long_type) * CHAR_BIT == Bits)
#endif
>());
//
// We need to check all aspects of the members of int_t<Bits> and uint_t<Bits>:
//
typedef typename boost::int_t<Bits>::least least_int;
typedef typename boost::int_t<Bits>::least fast_int;
typedef typename boost::uint_t<Bits>::least least_uint;
typedef typename boost::uint_t<Bits>::fast fast_uint;
if(std::numeric_limits<least_int>::is_specialized)
{
BOOST_TEST(std::numeric_limits<least_int>::digits + 1 >= Bits);
}
if(std::numeric_limits<least_uint>::is_specialized)
{
BOOST_TEST(std::numeric_limits<least_uint>::digits >= Bits);
}
BOOST_TEST(sizeof(least_int) * CHAR_BIT >= Bits);
BOOST_TEST(sizeof(least_uint) * CHAR_BIT >= Bits);
BOOST_TEST(sizeof(fast_int) >= sizeof(least_int));
BOOST_TEST(sizeof(fast_uint) >= sizeof(least_uint));
//
// There should be no type smaller than least_* that also has enough bits:
//
if(!boost::is_same<signed char, least_int>::value)
{
BOOST_TEST(std::numeric_limits<signed char>::digits < Bits);
if(!boost::is_same<short, least_int>::value)
{
BOOST_TEST(std::numeric_limits<short>::digits < Bits);
if(!boost::is_same<int, least_int>::value)
{
BOOST_TEST(std::numeric_limits<int>::digits < Bits);
if(!boost::is_same<long, least_int>::value)
{
BOOST_TEST(std::numeric_limits<long>::digits < Bits);
}
}
}
}
// And again, but unsigned:
if(!boost::is_same<unsigned char, least_uint>::value)
{
BOOST_TEST(std::numeric_limits<unsigned char>::digits < Bits);
if(!boost::is_same<unsigned short, least_uint>::value)
{
BOOST_TEST(std::numeric_limits<unsigned short>::digits < Bits);
if(!boost::is_same<unsigned int, least_uint>::value)
{
BOOST_TEST(std::numeric_limits<unsigned int>::digits < Bits);
if(!boost::is_same<unsigned long, least_uint>::value)
{
BOOST_TEST(std::numeric_limits<unsigned long>::digits < Bits);
}
}
}
}
if(boost::detail::test_errors() != last_error_count)
{
last_error_count = boost::detail::test_errors();
std::cout << "Errors occurred while testing with bit count = " << Bits << std::endl;
std::cout << "Type int_t<" << Bits << ">::least was " << get_name_of_type(least_int(0)) << std::endl;
std::cout << "Type int_t<" << Bits << ">::fast was " << get_name_of_type(fast_int(0)) << std::endl;
std::cout << "Type uint_t<" << Bits << ">::least was " << get_name_of_type(least_uint(0)) << std::endl;
std::cout << "Type uint_t<" << Bits << ">::fast was " << get_name_of_type(fast_uint(0)) << std::endl;
}
}
template <>
void do_test_bits<-1>()
{
// Nothing to do here!!
}
template <class Traits, class Expected>
void test_min_max_type(Expected val)
{
typedef typename Traits::least least_type;
typedef typename Traits::fast fast_type;
BOOST_TEST((boost::is_same<least_type, Expected>::value));
BOOST_TEST(sizeof(fast_type) >= sizeof(least_type));
BOOST_TEST((std::numeric_limits<least_type>::min)() <= val);
BOOST_TEST((std::numeric_limits<least_type>::max)() >= val);
if(boost::detail::test_errors() != last_error_count)
{
last_error_count = boost::detail::test_errors();
std::cout << "Traits type is: " << typeid(Traits).name() << std::endl;
std::cout << "Least type is: " << get_name_of_type(least_type(0)) << std::endl;
std::cout << "Fast type is: " << get_name_of_type(fast_type(0)) << std::endl;
std::cout << "Expected type is: " << get_name_of_type(Expected(0)) << std::endl;
std::cout << "Required value is: " << val << std::endl;
}
}
// Test program
int main(int, char*[])
{
// Test int_t and unint_t first:
if(std::numeric_limits<boost::intmax_t>::is_specialized)
do_test_bits<std::numeric_limits<boost::uintmax_t>::digits>();
else
do_test_bits<std::numeric_limits<long>::digits>();
//
// Test min and max value types:
//
test_min_max_type<boost::int_max_value_t<SCHAR_MAX>, signed char>(SCHAR_MAX);
test_min_max_type<boost::int_min_value_t<SCHAR_MIN>, signed char>(SCHAR_MIN);
test_min_max_type<boost::uint_value_t<UCHAR_MAX>, unsigned char>(UCHAR_MAX);
#if(USHRT_MAX != UCHAR_MAX)
test_min_max_type<boost::int_max_value_t<SCHAR_MAX+1>, short>(SCHAR_MAX+1);
test_min_max_type<boost::int_min_value_t<SCHAR_MIN-1>, short>(SCHAR_MIN-1);
test_min_max_type<boost::uint_value_t<UCHAR_MAX+1>, unsigned short>(UCHAR_MAX+1);
test_min_max_type<boost::int_max_value_t<SHRT_MAX>, short>(SHRT_MAX);
test_min_max_type<boost::int_min_value_t<SHRT_MIN>, short>(SHRT_MIN);
test_min_max_type<boost::uint_value_t<USHRT_MAX>, unsigned short>(USHRT_MAX);
#endif
#if(UINT_MAX != USHRT_MAX)
test_min_max_type<boost::int_max_value_t<SHRT_MAX+1>, int>(SHRT_MAX+1);
test_min_max_type<boost::int_min_value_t<SHRT_MIN-1>, int>(SHRT_MIN-1);
test_min_max_type<boost::uint_value_t<USHRT_MAX+1>, unsigned int>(USHRT_MAX+1);
test_min_max_type<boost::int_max_value_t<INT_MAX>, int>(INT_MAX);
test_min_max_type<boost::int_min_value_t<INT_MIN>, int>(INT_MIN);
test_min_max_type<boost::uint_value_t<UINT_MAX>, unsigned int>(UINT_MAX);
#endif
#if(ULONG_MAX != UINT_MAX)
test_min_max_type<boost::int_max_value_t<INT_MAX+1L>, long>(INT_MAX+1L);
test_min_max_type<boost::int_min_value_t<INT_MIN-1L>, long>(INT_MIN-1L);
test_min_max_type<boost::uint_value_t<UINT_MAX+1uL>, unsigned long>(UINT_MAX+1uL);
test_min_max_type<boost::int_max_value_t<LONG_MAX>, long>(LONG_MAX);
test_min_max_type<boost::int_min_value_t<LONG_MIN>, long>(LONG_MIN);
test_min_max_type<boost::uint_value_t<ULONG_MAX>, unsigned long>(ULONG_MAX);
#endif
#ifndef BOOST_NO_INTEGRAL_INT64_T
#if defined(BOOST_HAS_LONG_LONG) && (defined(ULLONG_MAX) && (ULLONG_MAX != ULONG_MAX))
test_min_max_type<boost::int_max_value_t<LONG_MAX+1LL>, boost::long_long_type>(LONG_MAX+1LL);
test_min_max_type<boost::int_min_value_t<LONG_MIN-1LL>, boost::long_long_type>(LONG_MIN-1LL);
test_min_max_type<boost::uint_value_t<ULONG_MAX+1uLL>, boost::ulong_long_type>(ULONG_MAX+1uLL);
test_min_max_type<boost::int_max_value_t<LLONG_MAX>, boost::long_long_type>(LLONG_MAX);
test_min_max_type<boost::int_min_value_t<LLONG_MIN>, boost::long_long_type>(LLONG_MIN);
test_min_max_type<boost::uint_value_t<ULLONG_MAX>, boost::ulong_long_type>(ULLONG_MAX);
#endif
#if defined(BOOST_HAS_LONG_LONG) && (defined(ULONG_LONG_MAX) && (ULONG_LONG_MAX != ULONG_MAX))
test_min_max_type<boost::int_max_value_t<LONG_MAX+1LL>, boost::long_long_type>(LONG_MAX+1LL);
test_min_max_type<boost::int_min_value_t<LONG_MIN-1LL>, boost::long_long_type>(LONG_MIN-1LL);
test_min_max_type<boost::uint_value_t<ULONG_MAX+1uLL>, boost::ulong_long_type>(ULONG_MAX+1uLL);
test_min_max_type<boost::int_max_value_t<LONG_LONG_MAX>, boost::long_long_type>(LONG_LONG_MAX);
test_min_max_type<boost::int_min_value_t<LONG_LONG_MIN>, boost::long_long_type>(LONG_LONG_MIN);
test_min_max_type<boost::uint_value_t<ULONG_LONG_MAX>, boost::ulong_long_type>(ULONG_LONG_MAX);
#endif
#if defined(BOOST_HAS_LONG_LONG) && (defined(ULONGLONG_MAX) && (ULONGLONG_MAX != ULONG_MAX))
test_min_max_type<boost::int_max_value_t<LONG_MAX+1LL>, boost::long_long_type>(LONG_MAX+1LL);
test_min_max_type<boost::int_min_value_t<LONG_MIN-1LL>, boost::long_long_type>(LONG_MIN-1LL);
test_min_max_type<boost::uint_value_t<ULONG_MAX+1uLL>, boost::ulong_long_type>(ULONG_MAX+1uLL);
test_min_max_type<boost::int_max_value_t<LONGLONG_MAX>, boost::long_long_type>(LONGLONG_MAX);
test_min_max_type<boost::int_min_value_t<LONGLONG_MIN>, boost::long_long_type>(LONGLONG_MAX);
test_min_max_type<boost::uint_value_t<ULONGLONG_MAX>, boost::ulong_long_type>(ULONGLONG_MAX);
#endif
#if defined(BOOST_HAS_LONG_LONG) && (defined(_ULLONG_MAX) && defined(_LLONG_MIN) && (_ULLONG_MAX != ULONG_MAX))
test_min_max_type<boost::int_max_value_t<LONG_MAX+1LL>, boost::long_long_type>(LONG_MAX+1LL);
test_min_max_type<boost::int_min_value_t<LONG_MIN-1LL>, boost::long_long_type>(LONG_MIN-1LL);
test_min_max_type<boost::uint_value_t<ULONG_MAX+1uLL>, boost::ulong_long_type>(ULONG_MAX+1uLL);
test_min_max_type<boost::int_max_value_t<_LLONG_MAX>, boost::long_long_type>(_LLONG_MAX);
test_min_max_type<boost::int_min_value_t<_LLONG_MIN>, boost::long_long_type>(_LLONG_MIN);
test_min_max_type<boost::uint_value_t<_ULLONG_MAX>, boost::ulong_long_type>(_ULLONG_MAX);
#endif // BOOST_HAS_LONG_LONG
#endif // BOOST_NO_INTEGRAL_INT64_T
return boost::report_errors();
}

37
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/integer_traits_include_test.cpp vendored Executable file
View File

@@ -0,0 +1,37 @@
// Copyright John Maddock 2009.
// Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
#include <boost/integer_traits.hpp> // must be the only #include!
template <class T>
void check_numeric_limits_derived(const std::numeric_limits<T>&){}
template <class T>
void check()
{
typedef boost::integer_traits<T> traits;
check_numeric_limits_derived(traits());
bool b = traits::is_integral;
(void)b;
T v = traits::const_min + traits::const_max;
(void)v;
}
int main()
{
check<signed char>();
check<unsigned char>();
check<char>();
check<short>();
check<unsigned short>();
check<int>();
check<unsigned int>();
check<signed long>();
check<unsigned long>();
#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
check<boost::long_long_type>();
check<boost::ulong_long_type>();
#endif
}

103
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/integer_traits_test.cpp vendored Executable file
View File

@@ -0,0 +1,103 @@
/* boost integer_traits.hpp tests
*
* Copyright Jens Maurer 2000
* Distributed under the Boost Software License, Version 1.0. (See
* accompanying file LICENSE_1_0.txt or copy at
* https://www.boost.org/LICENSE_1_0.txt)
*
* $Id$
*
* Revision history
* 2000-02-22 Small improvements by Beman Dawes
* 2000-06-27 Rework for better MSVC and BCC co-operation
*/
#include <iostream>
#include <boost/integer_traits.hpp>
// use int64_t instead of long long for better portability
#include <boost/cstdint.hpp>
#include <boost/core/lightweight_test.hpp>
/*
* General portability note:
* MSVC mis-compiles explicit function template instantiations.
* For example, f<A>() and f<B>() are both compiled to call f<A>().
* BCC is unable to implicitly convert a "const char *" to a std::string
* when using explicit function template instantiations.
*
* Therefore, avoid explicit function template instantiations.
*/
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
template<typename T> inline T make_char_numeric_for_streaming(T x) { return x; }
namespace fix{
inline int make_char_numeric_for_streaming(char c) { return c; }
inline int make_char_numeric_for_streaming(signed char c) { return c; }
inline int make_char_numeric_for_streaming(unsigned char c) { return c; }
inline long long int make_char_numeric_for_streaming(wchar_t c) { return c; }
}
using namespace fix;
#else
template<typename T> inline T make_char_numeric_for_streaming(T x) { return x; }
inline int make_char_numeric_for_streaming(char c) { return c; }
inline int make_char_numeric_for_streaming(signed char c) { return c; }
inline int make_char_numeric_for_streaming(unsigned char c) { return c; }
inline long long int make_char_numeric_for_streaming(wchar_t c) { return c; }
#endif
template<class T>
void runtest(const char * type, T)
{
typedef boost::integer_traits<T> traits;
std::cout << "Checking " << type
<< "; min is " << make_char_numeric_for_streaming((traits::min)())
<< ", max is " << make_char_numeric_for_streaming((traits::max)())
<< std::endl;
BOOST_TEST(traits::is_specialized);
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1200)
// MSVC++ 6.0 issues a LNK1179 error (duplicate comdat) when the compiler
// generates different symbol names with a very long common prefix:
// the dummy "&& true" disambiguates between the symbols generated by this
// BOOST_TEST instantiation and the preceding one.
BOOST_TEST(traits::is_integer && true);
#else
BOOST_TEST(traits::is_integer);
#endif
BOOST_TEST(traits::is_integral == true);
BOOST_TEST(traits::const_min == (traits::min)());
BOOST_TEST(traits::const_max == (traits::max)());
}
int main(int, char*[])
{
runtest("bool", bool());
runtest("char", char());
typedef signed char signed_char;
runtest("signed char", signed_char());
typedef unsigned char unsigned_char;
runtest("unsigned char", unsigned_char());
runtest("wchar_t", wchar_t());
runtest("short", short());
typedef unsigned short unsigned_short;
runtest("unsigned short", unsigned_short());
runtest("int", int());
typedef unsigned int unsigned_int;
runtest("unsigned int", unsigned_int());
runtest("long", long());
typedef unsigned long unsigned_long;
runtest("unsigned long", unsigned_long());
#ifndef BOOST_NO_INTEGRAL_INT64_T
//
// MS/Borland compilers can't support 64-bit member constants
// BeOS doesn't have specialisations for long long in SGI's <limits> header.
runtest("int64_t (possibly long long)", boost::int64_t());
runtest("uint64_t (possibly unsigned long long)", boost::uint64_t());
#else
std::cout << "Skipped int64_t and uint64_t" << std::endl;
#endif
// Some compilers don't pay attention to std:3.6.1/5 and issue a
// warning here if "return 0;" is omitted.
return boost::report_errors();
}

71
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/mod_inverse_test.cpp vendored Executable file
View File

@@ -0,0 +1,71 @@
/*
* (C) Copyright Nick Thompson 2018.
* Use, modification and distribution are subject to the
* Boost Software License, Version 1.0. (See accompanying file
* LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
*/
#include "multiprecision_config.hpp"
#ifndef DISABLE_MP_TESTS
#include <boost/integer/mod_inverse.hpp>
#include <boost/cstdint.hpp>
#include <boost/optional/optional.hpp>
#include <boost/core/lightweight_test.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/integer/common_factor.hpp>
using boost::multiprecision::int128_t;
using boost::multiprecision::int256_t;
using boost::integer::mod_inverse;
using boost::integer::gcd;
template<class Z>
void test_mod_inverse()
{
//Z max_arg = std::numeric_limits<Z>::max();
Z max_arg = 500;
for (Z modulus = 2; modulus < max_arg; ++modulus)
{
if (modulus % 1000 == 0)
{
std::cout << "Testing all inverses modulo " << modulus << std::endl;
}
for (Z a = 1; a < modulus; ++a)
{
Z gcdam = gcd(a, modulus);
Z inv_a = mod_inverse(a, modulus);
// Should fail if gcd(a, mod) != 1:
if (gcdam > 1)
{
BOOST_TEST(inv_a == 0);
}
else
{
BOOST_TEST(inv_a > 0);
// Cast to a bigger type so the multiplication won't overflow.
int256_t a_inv = inv_a;
int256_t big_a = a;
int256_t m = modulus;
int256_t outta_be_one = (a_inv*big_a) % m;
BOOST_TEST_EQ(outta_be_one, 1);
}
}
}
}
int main()
{
test_mod_inverse<boost::int16_t>();
test_mod_inverse<boost::int32_t>();
test_mod_inverse<boost::int64_t>();
test_mod_inverse<int128_t>();
return boost::report_errors();
}
#else
int main()
{
return 0;
}
#endif

33
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/multiprecision_config.hpp vendored Executable file
View File

@@ -0,0 +1,33 @@
// Copyright (c) 2018 Andrey Semashev
//
// Use, modification, and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_INTEGER_TEST_MULTIPRECISION_CONFIG_HPP_INCLUDED_
#define BOOST_INTEGER_TEST_MULTIPRECISION_CONFIG_HPP_INCLUDED_
#include <boost/config.hpp>
#include <boost/config/workaround.hpp>
#if (defined(BOOST_MSVC) && (BOOST_MSVC < 1500)) || \
(defined(__clang_major__) && (__clang_major__ == 3) && (__clang_minor__ < 2)) || \
(defined(BOOST_GCC) && defined(BOOST_GCC_CXX11) && BOOST_GCC < 40800)
#define DISABLE_MP_TESTS
#endif
// This list of checks matches those in Boost.Multiprecision, boost/multiprecision/detail/number_base.hpp,
// as it no longer supports C++03 since 2021.
#if !defined(DISABLE_MP_TESTS) && \
(\
defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) || defined(BOOST_NO_CXX11_HDR_ARRAY) || defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)\
|| defined(BOOST_NO_CXX11_ALLOCATOR) || defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) || defined(BOOST_NO_CXX11_CONSTEXPR)\
|| (defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) || BOOST_WORKAROUND(__SUNPRO_CC, < 0x5140)) || defined(BOOST_NO_CXX11_REF_QUALIFIERS) || defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)\
|| defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_NO_CXX11_USER_DEFINED_LITERALS) || defined(BOOST_NO_CXX11_THREAD_LOCAL)\
|| defined(BOOST_NO_CXX11_DECLTYPE) || defined(BOOST_NO_CXX11_STATIC_ASSERT) || defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)\
|| defined(BOOST_NO_CXX11_NOEXCEPT) || defined(BOOST_NO_CXX11_REF_QUALIFIERS)\
)
#define DISABLE_MP_TESTS
#endif
#endif // BOOST_INTEGER_TEST_MULTIPRECISION_CONFIG_HPP_INCLUDED_

14
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/static_log2_include_test.cpp vendored Executable file
View File

@@ -0,0 +1,14 @@
// Copyright John Maddock 2009.
// Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
#include <boost/integer/static_log2.hpp> // must be the only #include!
int main()
{
boost::static_log2_argument_type arg = 0;
(void)arg;
boost::static_log2_result_type result = boost::static_log2<30>::value;
(void)result;
}

149
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/static_log2_test.cpp vendored Executable file
View File

@@ -0,0 +1,149 @@
// Boost static_log2.hpp test program --------------------------------------//
// (C) Copyright Daryle Walker 2001.
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// See https://www.boost.org for most recent version including documentation.
// Revision History
// 01 Oct 2001 Initial version (Daryle Walker)
#include <boost/core/lightweight_test.hpp> // for main
#include <boost/cstdlib.hpp> // for boost::exit_success
#include <boost/integer/static_log2.hpp> // for boost::static_log2
#include <iostream> // for std::cout (std::endl indirectly)
// Macros to compact code
#define PRIVATE_LB_TEST( v, e ) BOOST_TEST( ::boost::static_log2<v>::value == e )
#define PRIVATE_PRINT_LB( v ) ::std::cout << "boost::static_log2<" << (v) \
<< "> = " << ::boost::static_log2< (v) >::value << '.' << ::std::endl
// Control to check for a compile-time error
#ifndef CONTROL_LB_0_TEST
#define PRIVATE_LB_0_TEST
#else
#define PRIVATE_LB_0_TEST PRIVATE_PRINT_LB( 0 )
#endif
// Main testing function
int
main
(
int , // "argc" is unused
char * [] // "argv" is unused
)
{
std::cout << "Doing tests on static_log2." << std::endl;
PRIVATE_LB_0_TEST;
PRIVATE_LB_TEST( 1, 0 );
PRIVATE_LB_TEST( 2, 1 );
PRIVATE_LB_TEST( 3, 1 );
PRIVATE_LB_TEST( 4, 2 );
PRIVATE_LB_TEST( 5, 2 );
PRIVATE_LB_TEST( 6, 2 );
PRIVATE_LB_TEST( 7, 2 );
PRIVATE_LB_TEST( 8, 3 );
PRIVATE_LB_TEST( 9, 3 );
PRIVATE_LB_TEST( 10, 3 );
PRIVATE_LB_TEST( 11, 3 );
PRIVATE_LB_TEST( 12, 3 );
PRIVATE_LB_TEST( 13, 3 );
PRIVATE_LB_TEST( 14, 3 );
PRIVATE_LB_TEST( 15, 3 );
PRIVATE_LB_TEST( 16, 4 );
PRIVATE_LB_TEST( 17, 4 );
PRIVATE_LB_TEST( 18, 4 );
PRIVATE_LB_TEST( 19, 4 );
PRIVATE_LB_TEST( 20, 4 );
PRIVATE_LB_TEST( 21, 4 );
PRIVATE_LB_TEST( 22, 4 );
PRIVATE_LB_TEST( 23, 4 );
PRIVATE_LB_TEST( 24, 4 );
PRIVATE_LB_TEST( 25, 4 );
PRIVATE_LB_TEST( 26, 4 );
PRIVATE_LB_TEST( 27, 4 );
PRIVATE_LB_TEST( 28, 4 );
PRIVATE_LB_TEST( 29, 4 );
PRIVATE_LB_TEST( 30, 4 );
PRIVATE_LB_TEST( 31, 4 );
PRIVATE_LB_TEST( 32, 5 );
PRIVATE_LB_TEST( 33, 5 );
PRIVATE_LB_TEST( 34, 5 );
PRIVATE_LB_TEST( 35, 5 );
PRIVATE_LB_TEST( 36, 5 );
PRIVATE_LB_TEST( 37, 5 );
PRIVATE_LB_TEST( 38, 5 );
PRIVATE_LB_TEST( 39, 5 );
PRIVATE_LB_TEST( 40, 5 );
PRIVATE_LB_TEST( 63, 5 );
PRIVATE_LB_TEST( 64, 6 );
PRIVATE_LB_TEST( 65, 6 );
PRIVATE_LB_TEST( 127, 6 );
PRIVATE_LB_TEST( 128, 7 );
PRIVATE_LB_TEST( 129, 7 );
PRIVATE_LB_TEST( 255, 7 );
PRIVATE_LB_TEST( 256, 8 );
PRIVATE_LB_TEST( 257, 8 );
PRIVATE_LB_TEST( 511, 8 );
PRIVATE_LB_TEST( 512, 9 );
PRIVATE_LB_TEST( 513, 9 );
PRIVATE_LB_TEST( 1023, 9 );
PRIVATE_LB_TEST( 1024, 10 );
PRIVATE_LB_TEST( 1025, 10 );
PRIVATE_LB_TEST( 2047, 10 );
PRIVATE_LB_TEST( 2048, 11 );
PRIVATE_LB_TEST( 2049, 11 );
PRIVATE_LB_TEST( 4095, 11 );
PRIVATE_LB_TEST( 4096, 12 );
PRIVATE_LB_TEST( 4097, 12 );
PRIVATE_LB_TEST( 8191, 12 );
PRIVATE_LB_TEST( 8192, 13 );
PRIVATE_LB_TEST( 8193, 13 );
PRIVATE_LB_TEST( 16383, 13 );
PRIVATE_LB_TEST( 16384, 14 );
PRIVATE_LB_TEST( 16385, 14 );
PRIVATE_LB_TEST( 32767, 14 );
PRIVATE_LB_TEST( 32768, 15 );
PRIVATE_LB_TEST( 32769, 15 );
PRIVATE_LB_TEST( 65535, 15 );
PRIVATE_LB_TEST( 65536, 16 );
PRIVATE_LB_TEST( 65537, 16 );
return boost::report_errors();
}

14
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/static_min_max_include_test.cpp vendored Executable file
View File

@@ -0,0 +1,14 @@
// Copyright John Maddock 2009.
// Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
#include <boost/integer/static_min_max.hpp> // must be the only #include!
int main()
{
boost::static_min_max_signed_type m = boost::static_signed_min<2, 3>::value + boost::static_signed_max<2, 3>::value;
(void)m;
boost::static_min_max_unsigned_type u = boost::static_unsigned_min<2, 3>::value + boost::static_unsigned_max<2, 3>::value;
(void)u;
}

92
externals/vcpkg/buildtrees/boost-integer/src/ost-1.79.0-29fe53acc9.clean/test/static_min_max_test.cpp vendored Executable file
View File

@@ -0,0 +1,92 @@
// Boost static_min_max.hpp test program -----------------------------------//
// (C) Copyright Daryle Walker 2001.
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// See https://www.boost.org for most recent version including documentation.
// Revision History
// 23 Sep 2001 Initial version (Daryle Walker)
#include <boost/core/lightweight_test.hpp> // for main, BOOST_TEST
#include <boost/cstdlib.hpp> // for boost::exit_success
#include <boost/integer/static_min_max.hpp> // for boost::static_signed_min, etc.
#include <iostream> // for std::cout (std::endl indirectly)
// Main testing function
int
main
(
int , // "argc" is unused
char * [] // "argv" is unused
)
{
using std::cout;
using std::endl;
using boost::static_signed_min;
using boost::static_signed_max;
using boost::static_unsigned_min;
using boost::static_unsigned_max;
// Two positives
cout << "Doing tests with two positive values." << endl;
BOOST_TEST( (static_signed_min< 9, 14>::value) == 9 );
BOOST_TEST( (static_signed_max< 9, 14>::value) == 14 );
BOOST_TEST( (static_signed_min<14, 9>::value) == 9 );
BOOST_TEST( (static_signed_max<14, 9>::value) == 14 );
BOOST_TEST( (static_unsigned_min< 9, 14>::value) == 9 );
BOOST_TEST( (static_unsigned_max< 9, 14>::value) == 14 );
BOOST_TEST( (static_unsigned_min<14, 9>::value) == 9 );
BOOST_TEST( (static_unsigned_max<14, 9>::value) == 14 );
// Two negatives
cout << "Doing tests with two negative values." << endl;
BOOST_TEST( (static_signed_min< -8, -101>::value) == -101 );
BOOST_TEST( (static_signed_max< -8, -101>::value) == -8 );
BOOST_TEST( (static_signed_min<-101, -8>::value) == -101 );
BOOST_TEST( (static_signed_max<-101, -8>::value) == -8 );
// With zero
cout << "Doing tests with zero and a positive or negative value." << endl;
BOOST_TEST( (static_signed_min< 0, 14>::value) == 0 );
BOOST_TEST( (static_signed_max< 0, 14>::value) == 14 );
BOOST_TEST( (static_signed_min<14, 0>::value) == 0 );
BOOST_TEST( (static_signed_max<14, 0>::value) == 14 );
BOOST_TEST( (static_unsigned_min< 0, 14>::value) == 0 );
BOOST_TEST( (static_unsigned_max< 0, 14>::value) == 14 );
BOOST_TEST( (static_unsigned_min<14, 0>::value) == 0 );
BOOST_TEST( (static_unsigned_max<14, 0>::value) == 14 );
BOOST_TEST( (static_signed_min< 0, -101>::value) == -101 );
BOOST_TEST( (static_signed_max< 0, -101>::value) == 0 );
BOOST_TEST( (static_signed_min<-101, 0>::value) == -101 );
BOOST_TEST( (static_signed_max<-101, 0>::value) == 0 );
// With identical
cout << "Doing tests with two identical values." << endl;
BOOST_TEST( (static_signed_min<0, 0>::value) == 0 );
BOOST_TEST( (static_signed_max<0, 0>::value) == 0 );
BOOST_TEST( (static_unsigned_min<0, 0>::value) == 0 );
BOOST_TEST( (static_unsigned_max<0, 0>::value) == 0 );
BOOST_TEST( (static_signed_min<14, 14>::value) == 14 );
BOOST_TEST( (static_signed_max<14, 14>::value) == 14 );
BOOST_TEST( (static_unsigned_min<14, 14>::value) == 14 );
BOOST_TEST( (static_unsigned_max<14, 14>::value) == 14 );
BOOST_TEST( (static_signed_min< -101, -101>::value) == -101 );
BOOST_TEST( (static_signed_max< -101, -101>::value) == -101 );
return boost::report_errors();
}