diff options
Diffstat (limited to 'src/boost/libs/safe_numerics/test')
147 files changed, 12049 insertions, 0 deletions
diff --git a/src/boost/libs/safe_numerics/test/CMakeLists.txt b/src/boost/libs/safe_numerics/test/CMakeLists.txt new file mode 100644 index 00000000..c2ad6046 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/CMakeLists.txt @@ -0,0 +1,147 @@ +# CMake build control file for safe numerics Library tests + +########################### +# test targets + +message( STATUS "Runtimes are stored in ${CMAKE_CURRENT_BINARY_DIR}" ) + +# compile and run tests +set( run_test_list + test_add_automatic + test_add_native + test_and_automatic + test_and_native + test_assignment + test_auto + test_cast + test_checked_add + test_checked_and + test_checked_cast + test_checked_divide + test_checked_equal_to + test_checked_left_shift + test_checked_less_than + test_checked_modulus + test_checked_multiply + test_checked_or + test_checked_right_shift + test_checked_subtract + test_checked_xor + test_construction + test_cpp + test_divide_automatic + test_divide_native + test_equal_automatic + test_equal_native + test_float + test_interval + test_left_shift_automatic + test_left_shift_native + test_less_than_automatic + test_less_than_native + test_modulus_automatic + test_modulus_native + test_multiply_automatic + test_multiply_native + test_or_automatic + test_or_native + # test_performance + test_range + test_rational + test_right_shift_automatic + test_right_shift_native + test_safe_compare + test_subtract_automatic + test_subtract_native + test_xor_automatic + test_xor_native + test_z +) + +foreach(test_name ${run_test_list}) + test_run_pass(${test_name}) + set_target_properties(${test_name} PROPERTIES FOLDER "safe numeric runtime tests") +endforeach(test_name) + +# compile fail tests +set(compile_fail_test_list + test_trap + test_constexpr +) + +foreach(test_name ${compile_fail_test_list}) + test_compile_fail(${test_name}) + set_target_properties(${test_name} PROPERTIES FOLDER "safe numeric compile fail tests") +endforeach(test_name) + +## safe integer constexpr tests +set(safe_constexpr_test_list + test_add_automatic_constexpr + test_add_native_constexpr + test_divide_automatic_constexpr + test_divide_native_constexpr + test_equal_automatic_constexpr + test_equal_native_constexpr + test_left_shift_automatic_constexpr + test_left_shift_native_constexpr + test_less_than_automatic_constexpr + test_less_than_native_constexpr + test_modulus_automatic_constexpr + test_modulus_native_constexpr + test_multiply_automatic_constexpr + test_multiply_native_constexpr + test_or_automatic_constexpr + test_or_native_constexpr + test_right_shift_automatic_constexpr + test_right_shift_native_constexpr + test_xor_automatic_constexpr + test_xor_native_constexpr + test_subtract_native_constexpr + test_subtract_automatic_constexpr +) + +foreach(test_name ${safe_constexpr_test_list}) + test_compile_pass(${test_name}) + set_target_properties(${test_name} PROPERTIES FOLDER "safe constexpr tests - compile only") +endforeach(test_name) + +# checked results constexpr + +set(checked_result_test_list + test_checked_add_constexpr + test_checked_and_constexpr + test_checked_cast_constexpr + test_checked_divide_constexpr + test_checked_equal_to_constexpr + test_checked_left_shift_constexpr + test_checked_less_than_constexpr + test_checked_modulus_constexpr + test_checked_multiply_constexpr + test_checked_or_constexpr + test_checked_right_shift_constexpr + test_checked_subtract_constexpr + test_checked_xor_constexpr +) + +foreach(test_name ${checked_result_test_list}) + test_compile_pass(${test_name}) + set_target_properties(${test_name} PROPERTIES FOLDER "checked result tests - compile only") +endforeach(test_name) + +# end test targets +#################### + +########################### +# add headers to IDE + +if(0) +file(GLOB include_files + RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" + "${CMAKE_CURRENT_SOURCE_DIR}/*.hpp" +) +add_custom_target(include SOURCES ${include_files}) +set_target_properties(include PROPERTIES FOLDER "tests") +endif(0) + +# end headers in IDE +#################### diff --git a/src/boost/libs/safe_numerics/test/Jamfile.v2 b/src/boost/libs/safe_numerics/test/Jamfile.v2 new file mode 100644 index 00000000..80468ed1 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/Jamfile.v2 @@ -0,0 +1,121 @@ +# Boost.SafeNumerics Library test Jamfile +# +# Copyright (c) 2017 Robert Ramey +# +# Distributed under the Boost Software License, Version 1.0. +# See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt + +import testing ; +import ../../config/checks/config : requires ; +project + : requirements + [ requires cxx14_constexpr ] + # toolset optimizations + <c++-template-depth>1024 + ; + +# compile and run tests + +run test_add_automatic.cpp ; +run test_add_native.cpp ; +run test_and_automatic.cpp ; +run test_and_native.cpp ; +run test_assignment.cpp ; +run test_auto.cpp ; +run test_cast.cpp ; + +run test_checked_add.cpp ; +run test_checked_and.cpp ; +run test_checked_cast.cpp ; +run test_checked_divide.cpp ; +run test_checked_equal_to.cpp ; +run test_checked_left_shift.cpp ; +run test_checked_less_than.cpp ; +run test_checked_modulus.cpp ; +run test_checked_multiply.cpp ; +run test_checked_or.cpp ; +run test_checked_right_shift.cpp ; +run test_checked_subtract.cpp ; +run test_checked_xor.cpp ; + +run test_construction.cpp ; +run test_cpp.cpp ; +run test_divide_automatic.cpp ; +run test_divide_native.cpp ; +run test_equal_automatic.cpp ; +run test_equal_native.cpp ; +run test_float.cpp ; +run test_interval.cpp ; +run test_left_shift_automatic.cpp ; +run test_left_shift_native.cpp ; +run test_less_than_automatic.cpp ; +run test_less_than_native.cpp ; +run test_modulus_automatic.cpp ; +run test_modulus_native.cpp ; +run test_multiply_automatic.cpp ; +run test_multiply_native.cpp ; +run test_or_automatic.cpp ; +run test_or_native.cpp ; +run test_performance.cpp # sources + : # args + : # input + : <variant>debug:<build>no # requirements + ; +run test_range.cpp ; +run test_rational.cpp ; +run test_right_shift_automatic.cpp ; +run test_right_shift_native.cpp ; +run test_safe_compare.cpp ; +run test_subtract_automatic.cpp ; +run test_subtract_native.cpp ; +run test_xor_automatic.cpp ; +run test_xor_native.cpp ; +run test_z.cpp ; + +# compile fail tests + +compile-fail test_constexpr.cpp ; +compile-fail test_trap.cpp ; + +# safe integer constexpr tests + +compile test_add_automatic_constexpr.cpp ; +compile test_add_native_constexpr.cpp ; +compile test_divide_automatic_constexpr.cpp ; +compile test_divide_native_constexpr.cpp ; +compile test_equal_automatic_constexpr.cpp ; +compile test_equal_native_constexpr.cpp ; +compile test_left_shift_automatic_constexpr.cpp ; +compile test_left_shift_native_constexpr.cpp ; +compile test_less_than_automatic_constexpr.cpp ; +compile test_less_than_native_constexpr.cpp ; +compile test_modulus_automatic_constexpr.cpp ; +compile test_modulus_native_constexpr.cpp ; +compile test_multiply_automatic_constexpr.cpp ; +compile test_multiply_native_constexpr.cpp ; +compile test_or_automatic_constexpr.cpp ; +compile test_or_native_constexpr.cpp ; +compile test_right_shift_automatic_constexpr.cpp ; +compile test_right_shift_native_constexpr.cpp ; +compile test_xor_automatic_constexpr.cpp ; +compile test_xor_native_constexpr.cpp ; +compile test_subtract_native_constexpr.cpp ; +compile test_subtract_automatic_constexpr.cpp ; + +# checked results constexpr + +compile test_checked_add_constexpr.cpp ; +compile test_checked_and_constexpr.cpp ; +compile test_checked_cast_constexpr.cpp ; +compile test_checked_divide_constexpr.cpp ; +compile test_checked_equal_to_constexpr.cpp ; +compile test_checked_left_shift_constexpr.cpp ; +compile test_checked_less_than_constexpr.cpp ; +compile test_checked_modulus_constexpr.cpp ; +compile test_checked_multiply_constexpr.cpp ; +compile test_checked_or_constexpr.cpp ; +compile test_checked_right_shift_constexpr.cpp ; +compile test_checked_subtract_constexpr.cpp ; +compile test_checked_xor_constexpr.cpp ; + diff --git a/src/boost/libs/safe_numerics/test/check_symmetry.hpp b/src/boost/libs/safe_numerics/test/check_symmetry.hpp new file mode 100644 index 00000000..07e25f51 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/check_symmetry.hpp @@ -0,0 +1,10 @@ +// given an array of values of a particular type +template<typename T, unsigned int N> +constexpr void check_symmetry(const T (&value)[N]) { + using namespace boost::safe_numerics; + // for each pair of values p1, p2 (100) + for(unsigned int i = 0; i < N; i++) + for(unsigned int j = 0; j < N; j++) + assert(value[i][j] == value[j][i]); +} + diff --git a/src/boost/libs/safe_numerics/test/test0.cpp b/src/boost/libs/safe_numerics/test/test0.cpp new file mode 100644 index 00000000..e4ef159e --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test0.cpp @@ -0,0 +1,146 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer_range.hpp> +#include <boost/safe_numerics/safe_integer.hpp> + +bool test1(){ + std::cout << "test1" << std::endl; + boost::safe_numerics::safe_signed_range<-64, 63> x, y, z; + x = 1; + y = 2; + z = 3; + z = x + y; + z = x - y; + + try{ + short int yi, zi; + yi = y; + zi = x + yi; + } + catch(const std::exception & e){ + // none of the above should trap. Mark failure if they do + std::cout << e.what() << std::endl; + return false; + } + return true; +} + +bool test2(){ + std::cout << "test2" << std::endl; + boost::safe_numerics::safe_unsigned_range<0, 64> x, y, z; + x = 1; + y = 2; + z = 3; + + bool success = false; + try{ + z = x - y; // should trap here + } + catch(const std::exception & e){ + success = true; + } + if(success == false) + return false; + + try{ + int yi = y; + z = x + yi; // should trap here + } + catch(const std::exception & e){ + // none of the above should trap. Mark failure if they do + std::cout << e.what() << std::endl; + return false; + } + return true; +} + +bool test3(){ + using namespace boost::safe_numerics; + std::cout << "test3" << std::endl; + safe<int> x, y, z; + x = 1; + y = 2; + z = 3; + try{ + z = x + y; + z = x - y; + int yi, zi; + zi = x + yi; + z = x + yi; + } + catch(const std::exception & e){ + // none of the above should trap. Mark failure if they do + std::cout << e.what() << std::endl; + return false; + } + return true; +} + +bool test4(){ + std::cout << "test4" << std::endl; + boost::safe_numerics::safe<unsigned int> x, y, z; + x = 1; + y = 2; + z = 3; + z = x + y; + bool success = false; + try{ + z = x - y; // should trap here + } + catch(const std::exception & e){ + success = true; + } + if(success == false) + return false; + unsigned int yi, zi; + zi = x; + zi = x + yi; + z = x + yi; + zi = x + y; + return true; +} + +#include <cstdint> + +bool test5(){ + std::cout << "test5" << std::endl; + boost::safe_numerics::safe<boost::uint64_t> x, y, z; + x = 1; + y = 2; + z = 3; + z = x + y; + bool success = false; + try{ + z = x - y; // should trap here + } + catch(const std::exception & e){ + success = true; + } + if(success == false) + return false; + boost::uint64_t yi, zi; + zi = x; + zi = x + yi; + z = x + yi; + zi = x + y; + return true; +} + +int main(int, char *[]){ + bool rval = ( + test1() && + test2() && + test3() && + test4() && + test5() + ); + std::cout << (rval ? "success!" : "failure") << std::endl; + return rval ? EXIT_SUCCESS : EXIT_FAILURE; +} + diff --git a/src/boost/libs/safe_numerics/test/test_add.hpp b/src/boost/libs/safe_numerics/test/test_add.hpp new file mode 100644 index 00000000..768373bc --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_add.hpp @@ -0,0 +1,147 @@ +#ifndef BOOST_TEST_ADD_HPP +#define BOOST_TEST_ADD_HPP + +// Copyright (c) 2015 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/range_value.hpp> + +template<class T1, class T2> +bool test_add( + T1 v1, + T2 v2, + const char *av1, + const char *av2, + char expected_result +){ + std::cout << "testing"<< std::endl; + { + safe_t<T1> t1 = v1; + std::cout << "safe<" << av1 << "> + " << av2 << " -> "; + static_assert( + boost::safe_numerics::is_safe<safe_t<T1> >::value, + "safe_t not safe!" + ); + try{ + // use auto to avoid checking assignment. + auto result = t1 + v2; + static_assert( + boost::safe_numerics::is_safe<decltype(result)>::value, + "Expression failed to return safe type" + ); + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " + " << av2 + << " failed to detect error in addition " + << std::endl; + t1 + v2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " + " << av2 + << " erroneously detected error in addition " + << std::endl; + try{ + t1 + v2; + } + catch(const std::exception &){} + return false; + } + std::cout << std::endl; + } + } + { + safe_t<T2> t2 = v2; + using result_type = decltype(v1 + t2); + std::cout << av1 << " + " << "safe<" << av2 << "> -> "; + static_assert( + boost::safe_numerics::is_safe<safe_t<T2> >::value, + "safe_t not safe!" + ); + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + try{ + // use auto to avoid checking assignment. + auto result = v1 + t2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " + " << av2 + << " failed to detect error in addition " + << std::endl; + v1 + t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " + " << av2 + << " erroneously detected error in addition " + << std::endl; + try{ + v1 + t2; + } + catch(const std::exception &){} + return false; + } + std::cout << std::endl; + } + } + { + safe_t<T1> t1 = v1; + safe_t<T2> t2 = v2; + using result_type = decltype(t1 + t2); + std::cout << "safe<" << av1 << "> + " << "safe<" << av2 << "> -> "; + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = t1 + t2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " + " << av2 + << " failed to detect error in addition " + << std::endl; + t1 + t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " + " << av2 + << " erroneously detected error in addition " + << std::endl; + try{ + t1 + t2; + } + catch(const std::exception &){} + return false; + } + std::cout << std::endl; + } + } + return true; // correct result +} + +#endif // BOOST_TEST_DIVIDE diff --git a/src/boost/libs/safe_numerics/test/test_add_automatic.cpp b/src/boost/libs/safe_numerics/test/test_add_automatic.cpp new file mode 100644 index 00000000..c48c5bb0 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_add_automatic.cpp @@ -0,0 +1,69 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> +#include "test_add_automatic_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; + +#include "test_add.hpp" + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_add( + mp_at_c<L, i1>()(), // value of first argument + mp_at_c<L, i2>()(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + test_addition_automatic_result[i1][i2] + ); + } +}; + +#include "check_symmetry.hpp" + +int main(){ + // sanity check on test matrix - should be symetrical + check_symmetry(test_addition_automatic_result); + + //TEST_EACH_VALUE_PAIR + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_add_automatic_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_add_automatic_constexpr.cpp new file mode 100644 index 00000000..13b89ac8 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_add_automatic_constexpr.cpp @@ -0,0 +1,56 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> +#include "test_add_automatic_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; + +#include "test_add_constexpr.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_add_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + test_addition_automatic_result[i][j] + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include "check_symmetry.hpp" + +int main(){ + using namespace boost::mp11; + + // sanity check on test matrix - should be symetrical + check_symmetry(test_addition_automatic_result); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly added" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_add_automatic_results.hpp b/src/boost/libs/safe_numerics/test/test_add_automatic_results.hpp new file mode 100644 index 00000000..73af1d3f --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_add_automatic_results.hpp @@ -0,0 +1,59 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_ADD_AUTOMATIC_RESULTS_HPP +#define BOOST_SAFE_NUMERICS_TEST_ADD_AUTOMATIC_RESULTS_HPP + +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_values.hpp" + +constexpr const char *test_addition_automatic_result[ + boost::mp11::mp_size<test_values>::value +] = { +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/* 0*/ ".............x...............xxx.", +/* 1*/ ".............x...............xxx.", +/* 2*/ "..............x...............xx.", +/* 3*/ "..............x...............xx.", +/* 4*/ ".............x...............xxx.", +/* 5*/ ".............x...............xxx.", +/* 6*/ "..............x...............xx.", +/* 7*/ "..............x...............xx.", + +/* 8*/ ".............x...............xxx.", +/* 9*/ ".............x...............xxx.", +/*10*/ "..............x...............xx.", +/*11*/ "..............x...............xx.", +/*12*/ ".............x...............xxx.", +/*13*/ "xx..xx..xx..xx..xxxxxxxxxxxxxxxx.", +/*14*/ "..xx..xx..xx..xx..............xx.", +/*15*/ "..............x...............xx.", + +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/*16*/ ".............x.................x.", +/*17*/ ".............x.................x.", +/*18*/ ".............x.................x.", +/*19*/ ".............x.................x.", +/*20*/ ".............x.................x.", +/*21*/ ".............x.................x.", +/*22*/ ".............x.................x.", +/*23*/ ".............x.................x.", + +/*24*/ ".............x.................x.", +/*25*/ ".............x.................x.", +/*26*/ ".............x.................x.", +/*27*/ ".............x.................x.", +/*28*/ ".............x.................x.", +/*29*/ "xx..xx..xx..xx.................x.", +/*30*/ "xxxxxxxxxxxxxxxx..............xxx", +/*31*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", +/*32*/ "..............................xx." +}; + +#endif diff --git a/src/boost/libs/safe_numerics/test/test_add_constexpr.hpp b/src/boost/libs/safe_numerics/test/test_add_constexpr.hpp new file mode 100644 index 00000000..3c67e2b0 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_add_constexpr.hpp @@ -0,0 +1,30 @@ +#ifndef BOOST_TEST_ADD_CONSTEXPR_HPP +#define BOOST_TEST_ADD_CONSTEXPR_HPP + +// Copyright (c) 2015 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> + +template<class T1, class T2> +constexpr bool test_add_constexpr( + T1 v1, + T2 v2, + char expected_result +){ + using namespace boost::safe_numerics; + // if we don't expect the operation to pass, we can't + // check the constexpr version of the calculation so + // just return success. + if(expected_result == 'x') + return true; + safe_t<T1>(v1) + v2; + v1 + safe_t<T2>(v2); + safe_t<T1>(v1) + safe_t<T2>(v2); + return true; // correct result +} + +#endif // BOOST_TEST_ADD_CONSTEXPR_HPP diff --git a/src/boost/libs/safe_numerics/test/test_add_native.cpp b/src/boost/libs/safe_numerics/test/test_add_native.cpp new file mode 100644 index 00000000..b7a1ef92 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_add_native.cpp @@ -0,0 +1,67 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/native.hpp> +#include "test_add_native_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; +#include "test_add.hpp" + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_add( + mp_at_c<L, i1>()(), // value of first argument + mp_at_c<L, i2>()(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + test_addition_native_result[i1][i2] + ); + } +}; + +#include "check_symmetry.hpp" + +int main(){ + // sanity check on test matrix - should be symetrical + check_symmetry(test_addition_native_result); + + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_add_native_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_add_native_constexpr.cpp new file mode 100644 index 00000000..e54ecc71 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_add_native_constexpr.cpp @@ -0,0 +1,57 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/native.hpp> + +#include "test_add_native_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; + +#include "test_add_constexpr.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_add_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + test_addition_native_result[i][j] + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include "check_symmetry.hpp" + +int main(){ + using namespace boost::mp11; + + // sanity check on test matrix - should be symetrical + check_symmetry(test_addition_native_result); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly added" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_add_native_results.hpp b/src/boost/libs/safe_numerics/test/test_add_native_results.hpp new file mode 100644 index 00000000..16364cfe --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_add_native_results.hpp @@ -0,0 +1,60 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_ADD_NATIVE_RESULTS_HPP +#define BOOST_SAFE_NUMERICS_TEST_ADD_NATIVE_RESULTS_HPP + +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_values.hpp" + +constexpr const char *test_addition_native_result[ + boost::mp11::mp_size<test_values>::value +] = { +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/* 0*/ ".........x...x.............x...x.", +/* 1*/ ".........x...x.............x...x.", +/* 2*/ "..........x...x.........xxxxxxxx.", +/* 3*/ "..........x...x.........xxxxxxxx.", +/* 4*/ ".........x...x.............x...x.", +/* 5*/ ".........x...x.............x...x.", +/* 6*/ "..........x...x.........xxxxxxxx.", +/* 7*/ "..........x...x.........xxxxxxxx.", + +/* 8*/ ".........x...x.............x...x.", +/* 9*/ "xx..xx..xx...x..xxxxxxxx...x...x.", +/*10*/ "..xx..xx..xx..x.........xxxxxxxx.", +/*11*/ "..........x...x.........xxxxxxxx.", +/*12*/ ".............x.................x.", +/*13*/ "xx..xx..xx..xx..xxxxxxxxxxxx...x.", +/*14*/ "..xx..xx..xx..xx............xxxx.", +/*15*/ "..............x.............xxxx.", + +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/*16*/ ".........x...x.............x...x.", +/*17*/ ".........x...x.............x...x.", +/*18*/ ".........x...x.............x...x.", +/*19*/ ".........x...x.............x...x.", +/*20*/ ".........x...x.............x...x.", +/*21*/ ".........x...x.............x...x.", +/*22*/ ".........x...x.............x...x.", +/*23*/ ".........x...x.............x...x.", + +/*24*/ "..xx..xx..xx.x.............x...x.", +/*25*/ "..xx..xx..xx.x.............x...x.", +/*26*/ "..xx..xx..xx.x............xx...x.", +/*27*/ "xxxxxxxxxxxx.x..xxxxxxxxxxxx...x.", +/*28*/ "..xx..xx..xx..xx...............x.", +/*29*/ "..xx..xx..xx..xx...............x.", +/*30*/ "..xx..xx..xx..xx..............xx.", +/*31*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/*32*/ "................................." +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_ADD_NATIVE_RESULTS_HPP + diff --git a/src/boost/libs/safe_numerics/test/test_and.hpp b/src/boost/libs/safe_numerics/test/test_and.hpp new file mode 100644 index 00000000..5a53b0ac --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_and.hpp @@ -0,0 +1,146 @@ +#ifndef BOOST_TEST_AND_HPP +#define BOOST_TEST_AND_HPP + +// Copyright (c) 2015 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/range_value.hpp> + +template<class T1, class T2> +bool test_and( + T1 v1, + T2 v2, + const char *av1, + const char *av2, + char expected_result +){ + std::cout << "testing"<< std::endl; + { + safe_t<T1> t1 = v1; + using result_type = decltype(t1 & v2); + std::cout << "safe<" << av1 << "> & " << av2 << " -> "; + static_assert( + boost::safe_numerics::is_safe<safe_t<T1> >::value, + "safe_t not safe!" + ); + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + try{ + // use auto to avoid checking assignment. + auto result = t1 & v2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " & " << av2 + << " failed to detect error in and operation " + << std::endl; + t1 & v2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " & " << av2 + << " erroneously detected error in and operation " + << std::endl; + try{ + t1 & v2; + } + catch(const std::exception &){} + return false; + } + } + } + { + safe_t<T2> t2 = v2; + using result_type = decltype(v1 & t2); + std::cout << av1 << " & " << "safe<" << av2 << "> -> "; + static_assert( + boost::safe_numerics::is_safe<safe_t<T2> >::value, + "safe_t not safe!" + ); + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = v1 & t2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " & " << av2 + << " failed to detect error in and operation " + << std::endl; + v1 & t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " & " << av2 + << " erroneously detected error in and operation " + << std::endl; + try{ + v1 & t2; + } + catch(const std::exception &){} + return false; + } + } + } + { + safe_t<T1> t1 = v1; + safe_t<T2> t2 = v2; + using result_type = decltype(t1 & t2); + std::cout << "safe<" << av1 << "> & " << "safe<" << av2 << "> -> "; + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = t1 & t2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " != "<< av1 << " & " << av2 + << " failed to detect error in and operation" + << std::endl; + t1 & t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " & " << av2 + << " erroneously detected error in and operation" + << std::endl; + try{ + t1 & t2; + } + catch(const std::exception &){} + return false; + } + } + } + return true; // correct result +} + +#endif // BOOST_TEST_AND_HPP diff --git a/src/boost/libs/safe_numerics/test/test_and_automatic.cpp b/src/boost/libs/safe_numerics/test/test_and_automatic.cpp new file mode 100644 index 00000000..d181655b --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_and_automatic.cpp @@ -0,0 +1,62 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; +#include "test_and.hpp" + +#include "test_values.hpp" +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_and( + mp_at_c<L, i1>()(), // value of first argument + mp_at_c<L, i2>()(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + '.' + ); + } +}; + +int main(){ + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_and_automatic_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_and_automatic_constexpr.cpp new file mode 100644 index 00000000..825df9d7 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_and_automatic_constexpr.cpp @@ -0,0 +1,58 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> +#include "test_add_automatic_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; + +#include "test_add_constexpr.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_add_constexpr( + typename boost::mp11::mp_at_c<test_values, i>()(), + typename boost::mp11::mp_at_c<test_values, j>()(), + test_addition_automatic_result[i][j] + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include "check_symmetry.hpp" + +int main(){ + using namespace boost::mp11; + + // sanity check on test matrix - should be symetrical + check_symmetry(test_addition_automatic_result); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly added" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_and_native.cpp b/src/boost/libs/safe_numerics/test/test_and_native.cpp new file mode 100644 index 00000000..afa2b1d3 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_and_native.cpp @@ -0,0 +1,62 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/native.hpp> + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; +#include "test_and.hpp" + +#include "test_values.hpp" +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_and( + mp_at_c<L, i1>()(), // value of first argument + mp_at_c<L, i2>()(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + '.' + ); + } +}; + +int main(){ + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_and_native_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_and_native_constexpr.cpp new file mode 100644 index 00000000..bb0054f6 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_and_native_constexpr.cpp @@ -0,0 +1,59 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/native.hpp> + +#include "test_add_native_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; + +#include "test_add_constexpr.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_add_constexpr( + typename boost::mp11::mp_at_c<test_values, i>()(), + typename boost::mp11::mp_at_c<test_values, j>()(), + test_addition_native_result[i][j] + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include "check_symmetry.hpp" + +int main(){ + using namespace boost::mp11; + + // sanity check on test matrix - should be symetrical + check_symmetry(test_addition_native_result); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly added" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_assignment.cpp b/src/boost/libs/safe_numerics/test/test_assignment.cpp new file mode 100644 index 00000000..cddf59c9 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_assignment.cpp @@ -0,0 +1,123 @@ +// Copyright (c) 2017 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// test construction assignments + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include "test_values.hpp" + +// note: same test matrix as used in test_checked. Here we test all combinations +// safe and unsafe integers. in test_checked we test all combinations of +// integer primitives + +const char *test_assignment_result[boost::mp11::mp_size<test_values>::value] = { +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/* 0*/ ".....xx..xx..xx...xx.xxx.xxx.xxx.", +/* 1*/ ".....xx..xx..xx...xx.xxx.xxx.xxx.", +/* 2*/ ".....xx..xx..xx...xx.xxx.xxx.xxx.", +/* 3*/ ".....xx..xx..xx...xx.xxx.xxx.xxx.", +/* 4*/ ".........xx..xx.......xx.xxx.xxx.", +/* 5*/ ".........xx..xx.......xx.xxx.xxx.", +/* 6*/ ".........xx..xx.......xx.xxx.xxx.", +/* 7*/ ".........xx..xx.......xx.xxx.xxx.", + +/* 8*/ ".............xx...........xx.xxx.", +/* 9*/ ".............xx...........xx.xxx.", +/*10*/ ".............xx...........xx.xxx.", +/*11*/ ".............xx...........xx.xxx.", +/*12*/ "..............................xx.", +/*13*/ "..............................xx.", +/*14*/ "..............................xx.", +/*15*/ "..............................xx.", + +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/*16*/ "..xx.xxx.xxx.xxx.....xxx.xxx.xxx.", +/*17*/ "..xx.xxx.xxx.xxx.....xxx.xxx.xxx.", +/*18*/ "..xx.xxx.xxx.xxx.....xxx.xxx.xxx.", +/*19*/ "..xx.xxx.xxx.xxx.....xxx.xxx.xxx.", +/*20*/ "..xx..xx.xxx.xxx.........xxx.xxx.", +/*21*/ "..xx..xx.xxx.xxx.........xxx.xxx.", +/*22*/ "..xx..xx.xxx.xxx.........xxx.xxx.", +/*23*/ "..xx..xx.xxx.xxx.........xxx.xxx.", + +/*24*/ "..xx..xx..xx.xxx.............xxx.", +/*25*/ "..xx..xx..xx.xxx.............xxx.", +/*26*/ "..xx..xx..xx.xxx.............xxx.", +/*27*/ "..xx..xx..xx.xxx.............xxx.", +/*28*/ "..xx..xx..xx..xx.................", +/*29*/ "..xx..xx..xx..xx.................", +/*30*/ "..xx..xx..xx..xx.................", +/*31*/ "..xx..xx..xx..xx.................", +// 012345678901234567890123456789012 +/*32*/ ".....xx..xx..xx...xx.xxx.xxx.xxx." +}; + +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; +#include "test_assignment.hpp" + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename boost::mp11::mp_at_c<L, i1>::value_type; + using T2 = typename boost::mp11::mp_at_c<L, i2>::value_type; + m_error &= test_assignment<T1, T2>( + boost::mp11::mp_at_c<L, i1>(), // value of first argument + boost::mp11::mp_at_c<L, i2>(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + test_assignment_result[i1][i2] + ); + } +}; + +int main(int, char *[]){ + + // TEST_EACH_VALUE_PAIR + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_assignment.hpp b/src/boost/libs/safe_numerics/test/test_assignment.hpp new file mode 100644 index 00000000..678e2cb8 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_assignment.hpp @@ -0,0 +1,102 @@ +#ifndef BOOST_TEST_ASSIGNMENT_HPP +#define BOOST_TEST_ASSIGNMENT_HPP + +// Copyright (c) 2015 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/core/demangle.hpp> +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/range_value.hpp> + +template<class T1, class T2> +bool test_assignment( + T1 t1, + T2 t2, + const char *at1, + const char *at2, + char expected_result +){ + std::cout << "testing " << std::endl; + { + std::cout << "safe<" << at1 << "> = " << at2 << std::endl; + // std::cout << boost::core::demangle(typeid(t1).name()) << " = " << at2 << std::endl; + safe_t<T2> s2(t2); + + static_assert( + boost::safe_numerics::is_safe<safe_t<T1> >::value, + "safe_t not safe!" + ); + try{ + t1 = s2; + if(expected_result == 'x'){ + std::cout + << "failed to detect error in assignment " + << boost::core::demangle(typeid(t1).name()) + << " = " + << at2 + << std::endl; + t1 = s2; + return false; + } + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << "erroneously detected error in assignment " + << boost::core::demangle(typeid(t1).name()) + << " = " + << at2 + << std::endl; + try{ + t1 = s2; + } + catch(const std::exception &){} + return false; + } + } + } + { + safe_t<T1> s1(t1); + safe_t<T2> s2(t2); + std::cout + << "safe<" << boost::core::demangle(typeid(t1).name()) << ">" + << " = " + << "safe<" << at2 << '>' << std::endl; + try{ + s1 = s2; + if(expected_result == 'x'){ + std::cout + << "failed to detect error in assignment " + << "safe<" << boost::core::demangle(typeid(t1).name()) << ">" + << " = " + << at2 + << std::endl; + s1 = s2; + return false; + } + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << "erroneously detected error in assignment " + << "safe<" << boost::core::demangle(typeid(t1).name()) << ">" + << " = " + << at2 + << std::endl; + try{ + s1 = t2; + } + catch(const std::exception &){} + return false; + } + } + } + return true; // correct result +} + +#endif // BOOST_TEST_ASSIGNMENT_HPP diff --git a/src/boost/libs/safe_numerics/test/test_auto.cpp b/src/boost/libs/safe_numerics/test/test_auto.cpp new file mode 100644 index 00000000..b73a8e17 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_auto.cpp @@ -0,0 +1,89 @@ +#include <iostream> +#include <cassert> +#include <boost/core/demangle.hpp> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/safe_integer_range.hpp> +#include <boost/safe_numerics/automatic.hpp> +#include <boost/safe_numerics/utility.hpp> + +int test_log(){ + using namespace boost::safe_numerics::utility; + assert(ilog2(127u) == 6); + assert(ilog2(128u) == 7); + assert(ilog2(129u) == 7); + assert(ilog2(255u) == 7); + assert(ilog2(256u) == 8); + + assert(ilog2(127) == 6); + assert(ilog2(128) == 7); + assert(ilog2(129) == 7); + assert(ilog2(255) == 7); + assert(ilog2(256) == 8); + return 0; +} + +template<class T> +void print_argument_type(const T & t){ + const std::type_info & ti = typeid(T); + std::cout + << boost::core::demangle(ti.name()) << ' ' << t << std::endl; +} + +template<typename T, typename U> +int test_auto(const T & t, const U & u){ + using namespace boost::safe_numerics; + + try{ + safe<T, automatic>(t) + u; + } + catch(const std::exception &){ + safe<T, automatic>(t) + u; + } + + try{ + t + safe<U, automatic>(u); + } + catch(const std::exception &){ + t + safe<U, automatic>(u); + } + return 0; +} + +int test_auto_result(){ + using namespace boost::safe_numerics; + automatic::addition_result< + safe<std::int8_t, automatic>, + safe<std::uint16_t, automatic> + >::type r1; + print_argument_type(r1); + + automatic::addition_result< + safe_signed_range<-3, 8, automatic>, + safe_signed_range<-4, 9, automatic> + >::type r2; + print_argument_type(r2); + return 0; +} + +int test_compare_result(){ + using namespace boost::safe_numerics; + + automatic::comparison_result< + safe<std::int16_t, automatic>, + safe<std::int16_t, automatic> + >::type r1; + print_argument_type(r1); + + return 0; +} + +int main(){ + using namespace boost::safe_numerics; + + test_log(); + test_auto<std::int8_t, std::int8_t>(1, -128); + test_auto_result(); + test_compare_result(); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_cast.cpp b/src/boost/libs/safe_numerics/test/test_cast.cpp new file mode 100644 index 00000000..57b8c33a --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_cast.cpp @@ -0,0 +1,135 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> +#include <cstdlib> // EXIT_SUCCESS + +#include <boost/safe_numerics/safe_compare.hpp> +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/range_value.hpp> + +using namespace boost::safe_numerics; + +// works for both GCC and clang +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-value" + +// test conversion to T2 from different literal types +template<class T2, class T1> +bool test_cast(T1 v1, const char *t2_name, const char *t1_name){ + std::cout + << "testing static_cast<safe<" << t2_name << ">>(" << t1_name << ")" + << std::endl; + { + /* test conversion constructor to safe<T2> from v1 */ + try{ + // use auto to avoid checking assignment. + auto result = static_cast<safe<T2>>(v1); + std::cout << make_result_display(result) << " <- " << v1 + << std::endl; + if(! safe_compare::equal(base_value(result), v1)){ + std::cout + << ' ' << t2_name << "<-" << t1_name + << " failed to detect error in construction" + << std::endl; + static_cast<safe<T2> >(v1); + return false; + } + } + catch(const std::exception &){ + if( safe_compare::equal(static_cast<T2>(v1), v1)){ + std::cout + << ' ' << t1_name << "<-" << t2_name + << " erroneously emitted error " + << std::endl; + try{ + static_cast<safe<T2> >(v1); + } + catch(const std::exception &){} + return false; + } + } + } + { + /* test conversion to T1 from safe<T2>(v2) */ + safe<T1> s1(v1); + try{ + auto result = static_cast<T2>(s1); + std::cout << make_result_display(result) << " <- " << v1 + << std::endl; + if(! safe_compare::equal(result, v1)){ + std::cout + << ' ' << t2_name << "<-" << t1_name + << " failed to detect error in construction" + << std::endl; + static_cast<T2>(s1); + return false; + } + } + catch(const std::exception &){ + if(safe_compare::equal(static_cast<T2>(v1), v1)){ + std::cout + << ' ' << t1_name << "<-" << t2_name + << " erroneously emitted error" + << std::endl; + try{ + static_cast<T2>(s1); + } + catch(const std::exception &){} + return false; + } + } + } + return true; // passed test +} +#pragma GCC diagnostic pop + +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> +#include "test_values.hpp" + +using namespace boost::mp11; + +template<typename T> +using extract_value_type = typename T::value_type; +using test_types = mp_unique< + mp_transform< + extract_value_type, + test_values + > +>; + +struct test { + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two types"); + using T1 = mp_first<T>; // first element is a type + // second element is an integral constant + using T2 = typename mp_second<T>::value_type; // get it's type + constexpr T2 v2 = mp_second<T>(); // get it's value + m_error &= test_cast<T1>( + v2, + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str() + ); + } +}; + +int main(){ + test rval(true); + + mp_for_each< + mp_product<mp_list, test_types, test_values> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_add.cpp b/src/boost/libs/safe_numerics/test/test_checked_add.cpp new file mode 100644 index 00000000..b74c956d --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_add.cpp @@ -0,0 +1,126 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/core/demangle.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +// note: T should be of type checked_result<R> for some integer type R +template<class T> +bool test_checked_add( + T v1, + T v2, + char expected_result +){ + using namespace boost::safe_numerics; + const T result = v1 + v2; + std::cout + << "testing " << boost::core::demangle(typeid(T).name()) << ' ' + << v1 << " + " << v2 << " -> " << result + << std::endl; + + switch(expected_result){ + case '.': + if(result.exception()){ + std::cout + << "erroneously detected error in addition " + << std::endl; + v1 + v2; + return false; + } + return true; + case '-': + if(safe_numerics_error::negative_overflow_error == result.m_e) + return true; + break; + case '+': + if(safe_numerics_error::positive_overflow_error == result.m_e) + return true; + break; + case '!': + if(safe_numerics_error::range_error == result.m_e) + return true; + break; + } + std::cout + << "failed to detect error in addition " + << std::hex << result << "(" << std::dec << result << ")" + << " != "<< v1 << " + " << v2 + << std::endl; + v1 + v2; + return false; +} + +#include "test_checked_add.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_add( + signed_values<T>[i], + signed_values<T>[j], + signed_addition_results[i][j] + ); + }; +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_add( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_addition_results[i][j] + ); + }; +}; + +#include "check_symmetry.hpp" + +#include <boost/mp11/algorithm.hpp> + +int main(){ + // sanity check on test matrix - should be symetrical + check_symmetry(signed_addition_results); + check_symmetry(unsigned_addition_results); + + using namespace boost::mp11; + bool rval = true; + + mp_for_each< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, + signed_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + mp_for_each< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return rval ? 0 : 1; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_add.hpp b/src/boost/libs/safe_numerics/test/test_checked_add.hpp new file mode 100644 index 00000000..24411cb0 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_add.hpp @@ -0,0 +1,44 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_CHECKED_ADD_HPP +#define BOOST_SAFE_NUMERICS_TEST_CHECKED_ADD_HPP + +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_checked_values.hpp" + +// test result matrices + +// key +// . success +// - negative_overflow_error +// + positive_overflow_error +// ! range_error + +constexpr const char * signed_addition_results[] = { +// 012345678 +/* 0*/ "!!!!!!!!!", +/* 1*/ "!!!!!!!!!", +/* 2*/ "!!++++++!", +/* 3*/ "!!+++...-", +/* 4*/ "!!++....-", +/* 5*/ "!!+.....-", +/* 6*/ "!!+....--", +/* 7*/ "!!+...---", +/* 8*/ "!!!------", +}; + +constexpr const char * unsigned_addition_results[] = { +// 0123456 +/* 0*/ "!!!!!!!", +/* 1*/ "!!!!!!!", +/* 2*/ "!!++++!", +/* 3*/ "!!+++.-", +/* 4*/ "!!++..-", +/* 5*/ "!!+...-", +/* 6*/ "!!!----", +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_CHECKED_ADD_HPP diff --git a/src/boost/libs/safe_numerics/test/test_checked_add_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_checked_add_constexpr.cpp new file mode 100644 index 00000000..9eaa880e --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_add_constexpr.cpp @@ -0,0 +1,91 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/checked_result.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +// note: T should be of tyme checked_result<R> for some integer type R +template<class T> +constexpr bool test_checked_add( + const T & v1, + const T & v2, + char expected_result +){ + using namespace boost::safe_numerics; + const T result = v1 + v2; + switch(expected_result){ + case '.': + return ! result.exception(); + case '-': + return safe_numerics_error::negative_overflow_error == result.m_e; + case '+': + return safe_numerics_error::positive_overflow_error == result.m_e; + case '!': + return safe_numerics_error::range_error == result.m_e; + } + return false; +} + +#include "test_checked_add.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_add( + signed_values<T>[i], + signed_values<T>[j], + signed_addition_results[i][j] + ); +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_add( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_addition_results[i][j] + ); +}; + +#include "check_symmetry.hpp" +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + check_symmetry(signed_addition_results); + check_symmetry(unsigned_addition_results); + + static_assert( + mp_all_of< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, signed_value_indices + >, + mp_to_bool + >(), + "all values for all signed types correctly added" + ); + + static_assert( + mp_all_of< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + >, + mp_to_bool + >(), + "all values for all unsigned types correctly added" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_and.cpp b/src/boost/libs/safe_numerics/test/test_checked_and.cpp new file mode 100644 index 00000000..81646f28 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_and.cpp @@ -0,0 +1,126 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/core/demangle.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +// note: T should be of tyme checked_result<R> for some integer type R +template<class T> +bool test_checked_and( + T v1, + T v2, + char expected_result +){ + using namespace boost::safe_numerics; + const T result = v1 & v2; + std::cout + << v1 << " & " << v2 << " -> " << result + << std::endl; + + switch(expected_result){ + case '.': + if(result.exception()){ + std::cout + << "erroneously detected error in and operation " + << std::endl; + v1 & v2; + return false; + } + return true; + case '-': + if(safe_numerics_error::negative_overflow_error == result.m_e) + return true; + case '+': + if(safe_numerics_error::positive_overflow_error == result.m_e) + return true; + case '!': + if(safe_numerics_error::range_error == result.m_e) + return true; + } + std::cout + << "failed to detect error in and operation " + << std::hex << result << "(" << std::dec << result << ")" + << " != "<< v1 << " & " << v2 + << std::endl; + v1 & v2; + return false; +} + +#include "test_checked_and.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_and( + signed_values<T>[i], + signed_values<T>[j], + signed_and_results[i][j] + ); + }; +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_and( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_and_results[i][j] + ); + }; +}; + +#include "check_symmetry.hpp" + +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + // sanity check on test matrix - should be symetrical + check_symmetry(signed_and_results); + check_symmetry(unsigned_and_results); + + bool rval = true; + + std::cout << "*** testing signed values\n"; + + mp_for_each< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, + signed_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + std::cout << "*** testing unsigned values\n"; + + mp_for_each< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return rval ? 0 : 1; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_and.hpp b/src/boost/libs/safe_numerics/test/test_checked_and.hpp new file mode 100644 index 00000000..d7ed82f3 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_and.hpp @@ -0,0 +1,44 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_CHECKED_AND_HPP +#define BOOST_SAFE_NUMERICS_TEST_CHECKED_AND_HPP + +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_checked_values.hpp" + +// test result matrices + +// key +// . success +// - negative_overflow_error +// + positive_overflow_error +// ? range_error + +constexpr const char * signed_and_results[] = { +// 012345678 +/* 0*/ "!!!!!!!!!", +/* 1*/ "!!!!!!!!!", +/* 2*/ "!!!!!!!!!", +/* 3*/ "!!!.....!", +/* 4*/ "!!!.....!", +/* 5*/ "!!!.....!", +/* 6*/ "!!!.....!", +/* 7*/ "!!!.....!", +/* 8*/ "!!!!!!!!!", +}; + +constexpr const char * unsigned_and_results[] = { +// 0123456 +/* 0*/ "!!!!!!!", +/* 1*/ "!!!!!!!", +/* 2*/ "!!!!!!!", +/* 3*/ "!!!...!", +/* 4*/ "!!!...!", +/* 5*/ "!!!...!", +/* 6*/ "!!!!!!!", +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_CHECKED_AND_HPP diff --git a/src/boost/libs/safe_numerics/test/test_checked_and_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_checked_and_constexpr.cpp new file mode 100644 index 00000000..1080def6 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_and_constexpr.cpp @@ -0,0 +1,91 @@ +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/checked_result.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +// note: T should be of tyme checked_result<R> for some integer type R +template<class T> +constexpr bool test_checked_and( + const T & v1, + const T & v2, + char expected_result +){ + using namespace boost::safe_numerics; + const T result = v1 & v2; + switch(expected_result){ + case '.': + return ! result.exception(); + case '-': + return safe_numerics_error::negative_overflow_error == result.m_e; + case '+': + return safe_numerics_error::positive_overflow_error == result.m_e; + case '!': + return safe_numerics_error::range_error == result.m_e; + } + return false; +} + +#include "test_checked_and.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_and( + signed_values<T>[i], + signed_values<T>[j], + signed_and_results[i][j] + ); +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_and( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_and_results[i][j] + ); +}; + +#include "check_symmetry.hpp" +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + check_symmetry(signed_and_results); + check_symmetry(unsigned_and_results); + + static_assert( + mp_all_of< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, signed_value_indices + >, + mp_to_bool + >(), + "all values for all signed types correctly anded" + ); + + static_assert( + mp_all_of< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + >, + mp_to_bool + >(), + "all values for all unsigned types correctly anded" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_cast.cpp b/src/boost/libs/safe_numerics/test/test_checked_cast.cpp new file mode 100644 index 00000000..f1d111d1 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_cast.cpp @@ -0,0 +1,95 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include "test_checked_cast.hpp" +#include <boost/safe_numerics/checked_integer.hpp> + +// test conversion to TResult from different literal types +template<class TResult, class TArg> +bool test_cast( + const TArg & v, + const char *tresult_name, + const char *targ_name, + char expected_result +){ + std::cout + << "testing static_cast<" << tresult_name << ">(" << targ_name << ")" + << std::endl; + + boost::safe_numerics::checked_result<TResult> r2 = + boost::safe_numerics::checked::cast<TResult>(v); + + if(expected_result == 'x' && ! r2.exception()){ + std::cout + << "failed to detect error in construction " + << tresult_name << "<-" << targ_name + << std::endl; + boost::safe_numerics::checked::cast<TResult>(v); + return false; + } + if(expected_result == '.' && r2.exception()){ + std::cout + << "erroneously emitted error " + << tresult_name << "<-" << targ_name + << std::endl; + boost::safe_numerics::checked::cast<TResult>(v); + return false; + } + return true; // passed test +} + +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +using namespace boost::mp11; + +// given a list of integral constants I, return a list of values +template<typename I> +struct get_values { + static_assert(mp_is_list<I>(), "must be a list of two types"); + static_assert(2 == mp_size<I>::value, "must be a list of two types"); + static constexpr const size_t first = mp_first<I>(); // index of first argument + static constexpr const size_t second = mp_second<I>();// index of second argument +}; + +struct test_pair { + bool m_error; + test_pair(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename I> + void operator()(const I &){ + using pair = get_values<I>; + using TResult = mp_at<test_types, mp_first<I>>; + using TArg = typename mp_at<test_values, mp_second<I>>::value_type; + static constexpr TArg v = mp_at<test_values, mp_second<I>>()(); + m_error &= test_cast<TResult>( + v, + boost::core::demangle(typeid(TResult).name()).c_str(), + boost::core::demangle(typeid(TArg).name()).c_str(), + test_result_cast[pair::first][pair::second] + ); + } +}; + +int main(){ + // list of indices for values (integral constants) + using value_indices = mp_iota_c<mp_size<test_values>::value>; + // list of indices for types (integral constants) + using type_indices = mp_iota_c<mp_size<test_types>::value>; + + // test runtime behavior + test_pair rval(true); + mp_for_each< + mp_product<mp_list, type_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_cast.hpp b/src/boost/libs/safe_numerics/test/test_checked_cast.hpp new file mode 100644 index 00000000..e8efe576 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_cast.hpp @@ -0,0 +1,31 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_CHECKED_CAST_HPP +#define BOOST_SAFE_NUMERICS_TEST_CHECKED_CAST_HPP + +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/mp11/integral.hpp> +#include "test_values.hpp" + +// note: the types indexed on the left side of the table are gathered +// by filtering the test_values list. So the types are in the same +// sequence + +constexpr const char *test_result_cast[boost::mp11::mp_size<test_values>::value] = { +// 0 0 0 0 +// 01234567012345670123456701234567 +// 01234567890123456789012345678901 +/* 0*/ ".....xx..xx..xx...xx.xxx.xxx.xxx", +/* 1*/ ".........xx..xx.......xx.xxx.xxx", +/* 2*/ ".............xx...........xx.xxx", +/* 3*/ "..............................xx", +/* 4*/ "..xx.xxx.xxx.xxx.....xxx.xxx.xxx", +/* 5*/ "..xx..xx.xxx.xxx.........xxx.xxx", +/* 6*/ "..xx..xx..xx.xxx.............xxx", +/* 7*/ "..xx..xx..xx..xx................" +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_CHECKED_CAST_HPP diff --git a/src/boost/libs/safe_numerics/test/test_checked_cast_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_checked_cast_constexpr.cpp new file mode 100644 index 00000000..ac60dcdd --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_cast_constexpr.cpp @@ -0,0 +1,65 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/checked_integer.hpp> + +// test conversion to T2 from different literal types +template<class T2, class T1> +constexpr bool test_cast_constexpr( + const T1 & v1, + char result +){ + const boost::safe_numerics::checked_result<T2> r2 = + boost::safe_numerics::checked::cast<T2>(v1); + return ('x' == result) ? + r2.exception() : + ! r2.exception(); +} + +#include "test_checked_cast.hpp" + +#include <boost/mp11/algorithm.hpp> // mp_iota +#include <boost/mp11/list.hpp> // mp_first, mp_second, mp_size, mp_is_list + +using namespace boost::mp11; + +// given a list of integral constants I, return a list of values +template<typename I> +struct get_values { + static_assert(mp_is_list<I>(), "must be a list of two types"); + static_assert(2 == mp_size<I>::value, "must be a list of two types"); + static constexpr const size_t first = mp_first<I>(); // index of first argument + static constexpr const size_t second = mp_second<I>();// index of second argument +}; + +template<typename I> +struct test_pair_constexpr { + using pair = get_values<I>; + using TResult = mp_at<test_types, mp_first<I>>; + using TArg = typename mp_at<test_values, mp_second<I>>::value_type; + static constexpr TArg v = mp_at<test_values, mp_second<I>>()(); + static constexpr bool value = test_cast_constexpr<TResult>( + v, + test_result_cast[pair::first][pair::second] + ); +}; + +int main(){ + // list of indices for values (integral constants) + using value_indices = mp_iota_c<mp_size<test_values>::value>; + // list of indices for types (integral constants) + using type_indices = mp_iota_c<mp_size<test_types>::value>; + // all combinations of type index, value index + using index_pairs = mp_product<mp_list, type_indices, value_indices>; + // test all type/value pairs to verify that cast can be done. + static_assert( + mp_all_of<index_pairs, test_pair_constexpr>::value, + "all type/value pairs correctly cast" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_comparison.hpp b/src/boost/libs/safe_numerics/test/test_checked_comparison.hpp new file mode 100644 index 00000000..74af9c7f --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_comparison.hpp @@ -0,0 +1,44 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_CHECKED_COMPARISON_HPP +#define BOOST_SAFE_NUMERICS_TEST_CHECKED_COMPARISON_HPP + +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_checked_values.hpp" + +// test result matrices + +// key +// < less than +// > greater than +// = equal to +// ! indeterminant + +constexpr const char * signed_comparison_results[] = { +// 012345678 +/* 0*/ "!!!!!!!!!", +/* 1*/ "!!!!!!!!!", +/* 2*/ "!!!>>>>>>", +/* 3*/ "!!<=>>>>>", +/* 4*/ "!!<<=>>>>", +/* 5*/ "!!<<<=>>>", +/* 6*/ "!!<<<<=>>", +/* 7*/ "!!<<<<<=>", +/* 8*/ "!!<<<<<<!", +}; + +constexpr const char * unsigned_comparison_results[] = { +// 0123456 +/* 0*/ "!!!!!!!", +/* 1*/ "!!!!!!!", +/* 2*/ "!!!>>>>", +/* 3*/ "!!<=>>>", +/* 4*/ "!!<<=>>", +/* 5*/ "!!<<<=>", +/* 6*/ "!!<<<<!", +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_CHECKED_COMPARISON_HPP diff --git a/src/boost/libs/safe_numerics/test/test_checked_divide.cpp b/src/boost/libs/safe_numerics/test/test_checked_divide.cpp new file mode 100644 index 00000000..ca471f1d --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_divide.cpp @@ -0,0 +1,129 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/core/demangle.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +// note: T should be of type checked_result<R> for some integer type R +template<class T> +bool test_checked_divide( + T v1, + T v2, + char expected_result +){ + using namespace boost::safe_numerics; + const T result = v1 / v2; + std::cout + << v1 << " / " << v2 << " -> " << result + << std::endl; + + switch(expected_result){ + case '.': + case '0': + if(result.exception()){ + std::cout + << "*** erroneously detected error in division" + << std::endl; + v1 / v2; + return false; + } + if(expected_result == '0' + && result != T(0) + ){ + std::cout + << "*** failed to get expected zero result " + << std::endl; + v1 / v2; + return false; + } + return true; + case '-': + if(safe_numerics_error::negative_overflow_error == result.m_e) + return true; + case '+': + if(safe_numerics_error::positive_overflow_error == result.m_e) + return true; + case '!': + if(safe_numerics_error::range_error == result.m_e) + return true; + } + std::cout + << "*** failed to detect error in division " + << std::hex << result << "(" << std::dec << result << ")" + << " != "<< v1 << " / " << v2 + << std::endl; + v1 / v2; + return false; +} + +#include "test_checked_divide.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_divide( + signed_values<T>[i], + signed_values<T>[j], + signed_division_results[i][j] + ); + }; +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_divide( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_division_results[i][j] + ); + }; +}; + +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + bool rval = true; + + std::cout << "*** testing signed values\n"; + mp_for_each< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, + signed_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + std::cout << "*** testing unsigned values\n"; + mp_for_each< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return rval ? 0 : 1; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_divide.hpp b/src/boost/libs/safe_numerics/test/test_checked_divide.hpp new file mode 100644 index 00000000..9e2affe1 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_divide.hpp @@ -0,0 +1,44 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_CHECKED_DIVIDE_HPP +#define BOOST_SAFE_NUMERICS_TEST_CHECKED_DIVIDE_HPP + +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_checked_values.hpp" + +// test result matrices + +// key +// . success +// - negative_overflow_error +// + positive_overflow_error +// ! range_error + +constexpr const char * signed_division_results[] = { +// 012345678 +/* 0*/ "!!!!!!!!!", +/* 1*/ "!!!!!!!!!", +/* 2*/ "!!!+++---", +/* 3*/ "!!0..+..0", +/* 4*/ "!!0..+.00", +/* 5*/ "!!000!000", +/* 6*/ "!!0..-.00", +/* 7*/ "!!0..-+.0", +/* 8*/ "!!----++!", +}; + +constexpr const char * unsigned_division_results[] = { +// 0123456 +/* 0*/ "!!!!!!!", +/* 1*/ "!!!!!!!", +/* 2*/ "!!!+++-", +/* 3*/ "!!0..+.", +/* 4*/ "!!0..+.", +/* 5*/ "!!000!0", +/* 6*/ "!!----!", +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_CHECKED_DIVIDE_HPP diff --git a/src/boost/libs/safe_numerics/test/test_checked_divide_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_checked_divide_constexpr.cpp new file mode 100644 index 00000000..6056f06a --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_divide_constexpr.cpp @@ -0,0 +1,92 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <cstdint> // std::int8, ... + +#include <boost/safe_numerics/checked_result.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +// note: T should be of tyme checked_result<R> for some integer type R +template<class T> +constexpr bool test_checked_divide( + const T & v1, + const T & v2, + char expected_result +){ + using namespace boost::safe_numerics; + const T result = v1 / v2; + switch(expected_result){ + case '0': + case '.': + return ! result.exception(); + case '-': + return safe_numerics_error::negative_overflow_error == result.m_e; + case '+': + return safe_numerics_error::positive_overflow_error == result.m_e; + case '!': + return safe_numerics_error::range_error == result.m_e; + } + return false; +} + +#include "test_checked_divide.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_divide( + signed_values<T>[i], + signed_values<T>[j], + signed_division_results[i][j] + ); +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_divide( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_division_results[i][j] + ); +}; + +#include <boost/mp11/algorithm.hpp> +#include <boost/mp11/function.hpp> + +int main(){ + using namespace boost::mp11; + + static_assert( + mp_all_of< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, signed_value_indices + >, + mp_to_bool + >(), + "all values for all signed types correctly divided" + ); + + static_assert( + mp_all_of< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + >, + mp_to_bool + >(), + "all values for all unsigned types correctly divided" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_equal_to.cpp b/src/boost/libs/safe_numerics/test/test_checked_equal_to.cpp new file mode 100644 index 00000000..8517095b --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_equal_to.cpp @@ -0,0 +1,118 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> +#include <boost/logic/tribool_io.hpp> + +#include <boost/core/demangle.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +// works for both GCC and clang +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-value" + +// note: T should be of type checked_result<R> for some integer type R +template<class T> +bool test_checked_equal_to( + T v1, + T v2, + char expected_result +){ + using namespace boost::safe_numerics; + const boost::logic::tribool result = (v1 == v2); + std::cout + << std::boolalpha << v1 << " == " << v2 << " -> " << result + << std::endl; + + switch(expected_result){ + case '<': + case '>': + if(! result) + return true; + break; + case '=': + if(result) + return true; + break; + case '!': + if(indeterminate(result)) + return true; + break; + } + std::cout + << "failed to detect error in addition " + << std::hex << result << "(" << std::dec << result << ")" + << " != "<< v1 << " == " << v2 + << std::endl; + v1 == v2; + return false; +} + +#pragma GCC diagnostic pop + +#include "test_checked_comparison.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_equal_to( + signed_values<T>[i], + signed_values<T>[j], + signed_comparison_results[i][j] + ); + }; +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_equal_to( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_comparison_results[i][j] + ); + }; +}; + +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + bool rval = true; + + mp_for_each< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, + signed_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + mp_for_each< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return rval ? 0 : 1; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_equal_to_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_checked_equal_to_constexpr.cpp new file mode 100644 index 00000000..072f2371 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_equal_to_constexpr.cpp @@ -0,0 +1,93 @@ +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/checked_result.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +// note: T should be of tyme checked_result<R> for some integer type R +template<class T> +constexpr bool test_checked_equal_to( + T v1, + T v2, + char expected_result +){ + using namespace boost::safe_numerics; + const boost::logic::tribool result = (v1 == v2); + switch(expected_result){ + case '<': + case '>': + if(! result) + return true; + break; + case '=': + if(result) + return true; + break; + case '!': + if(indeterminate(result)) + return true; + break; + } + return false; +} + +#include "test_checked_comparison.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_equal_to( + signed_values<T>[i], + signed_values<T>[j], + signed_comparison_results[i][j] + ); +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_equal_to( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_comparison_results[i][j] + ); +}; + +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + static_assert( + mp_all_of< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, signed_value_indices + >, + mp_to_bool + >(), + "all values for all signed types correctly compared" + ); + + static_assert( + mp_all_of< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + >, + mp_to_bool + >(), + "all values for all unsigned types correctly compared" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_left_shift.cpp b/src/boost/libs/safe_numerics/test/test_checked_left_shift.cpp new file mode 100644 index 00000000..ca9789dd --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_left_shift.cpp @@ -0,0 +1,136 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/core/demangle.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +template<class T> +bool test_checked_left_shift( + T v1, + T v2, + char expected_result +){ + using namespace boost::safe_numerics; + + const T result = v1 << v2; + std::cout + << v1 << " << " << v2 << " -> " << result + << std::endl; + + switch(expected_result){ + case '.': + if(result.exception()){ + std::cout + << "erroneously detected error in left shift " + << std::endl; + v1 << v2; + return false; + } + return true; + case '-': + if(safe_numerics_error::negative_overflow_error == result.m_e) + return true; + break; + case '+': + if(safe_numerics_error::positive_overflow_error == result.m_e) + return true; + break; + case '!': + if(result.exception()) + return true; + break; + case 'n': // n negative_shift + if(safe_numerics_error::negative_shift == result.m_e) + return true; + break; + case 's': // s negative_value_shift + if(safe_numerics_error::negative_value_shift == result.m_e) + return true; + break; + case 'l': // l shift_too_large + if(safe_numerics_error::shift_too_large == result.m_e) + return true; + break; + default: + assert(false); + } + std::cout + << "failed to detect error in left shift " + << std::hex << result << "(" << std::dec << result << ")" + << " != "<< v1 << " << " << v2 + << std::endl; + v1 << v2; + return false; +} + +#include "test_checked_left_shift.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_left_shift( + signed_values<T>[i], + signed_values<T>[j], + signed_left_shift_results[i][j] + ); + }; +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_left_shift( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_left_shift_results[i][j] + ); + }; +}; + +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + bool rval = true; + + std::cout << "*** testing signed values\n"; + mp_for_each< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, + signed_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + std::cout << "*** testing unsigned values\n"; + mp_for_each< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return rval ? 0 : 1; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_left_shift.hpp b/src/boost/libs/safe_numerics/test/test_checked_left_shift.hpp new file mode 100644 index 00000000..61d949a7 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_left_shift.hpp @@ -0,0 +1,48 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_CHECKED_LEFT_SHIFT_HPP +#define BOOST_SAFE_NUMERICS_TEST_CHECKED_LEFT_SHIFT_HPP + +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_checked_values.hpp" + +// test result matrices + +// key +// . success +// - negative_overflow_error +// + positive_overflow_error +// ! range_error +// n negative_shift, // negative value in shift operator +// s negative_value_shift, // shift a negative value +// l shift_too_large, // l/r shift exceeds variable size + +constexpr char const * const signed_left_shift_results[] = { +// 012345678 +/* 0*/ "!!!!!!!!!", +/* 1*/ "!!!!!!!!!", +/* 2*/ "!!++++++!", +/* 3*/ "!!+++....", +/* 4*/ "!!++.....", +/* 5*/ ".........", +/* 6*/ "!!--.....", +/* 7*/ "!!---....", +/* 8*/ "!!------!", +}; + +constexpr char const * const unsigned_left_shift_results[] = { +// 0123456 +/* 0*/ "!!!!!!!", +/* 1*/ "!!!!!!!", +/* 2*/ "!!++++!", +/* 3*/ "!!+++..", +/* 4*/ "!!++...", +/* 5*/ ".......", +/* 6*/ "!!----!", +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_CHECKED_LEFT_SHIFT_HPP + diff --git a/src/boost/libs/safe_numerics/test/test_checked_left_shift_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_checked_left_shift_constexpr.cpp new file mode 100644 index 00000000..25da8eb6 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_left_shift_constexpr.cpp @@ -0,0 +1,96 @@ +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/checked_result.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +template<class T> +constexpr bool test_checked_left_shift( + const T & v1, + const T & v2, + char expected_result +){ + using namespace boost::safe_numerics; + const T result = v1 << v2; + switch(expected_result){ + case '.': + return ! result.exception(); + case '-': + return safe_numerics_error::negative_overflow_error == result.m_e; + case '+': + return safe_numerics_error::positive_overflow_error == result.m_e; + case '!': + return safe_numerics_error::range_error == result.m_e; + case 'n': // n negative_shift + return safe_numerics_error::negative_shift == result.m_e; + case 's': // s negative_value_shift + return safe_numerics_error::negative_value_shift == result.m_e; + case 'l': // l shift_too_large + return safe_numerics_error::shift_too_large == result.m_e; + default: + assert(false); + } + return false; +} + +#include "test_checked_left_shift.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_left_shift( + signed_values<T>[i], + signed_values<T>[j], + signed_left_shift_results[i][j] + ); +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_left_shift( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_left_shift_results[i][j] + ); +}; + +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + static_assert( + mp_all_of< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, signed_value_indices + >, + mp_to_bool + >(), + "all values for all signed types correctly shifted" + ); + + static_assert( + mp_all_of< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + >, + mp_to_bool + >(), + "all values for all unsigned types correctly shifted" + ); + + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_less_than.cpp b/src/boost/libs/safe_numerics/test/test_checked_less_than.cpp new file mode 100644 index 00000000..b0702ca2 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_less_than.cpp @@ -0,0 +1,118 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> +#include <boost/logic/tribool_io.hpp> + +#include <boost/core/demangle.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +// works for both GCC and clang +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-value" + +// note: T should be of type checked_result<R> for some integer type R +template<class T> +bool test_checked_less_than( + T v1, + T v2, + char expected_result +){ + using namespace boost::safe_numerics; + const boost::logic::tribool result = v1 < v2; + std::cout + << std::boolalpha << v1 << " < " << v2 << " -> " << result + << std::endl; + + switch(expected_result){ + case '<': + if(result) + return true; + break; + case '>': + case '=': + if(!result) + return true; + break; + case '!': + if(indeterminate(result)) + return true; + break; + } + std::cout + << "failed to detect error in addition " + << std::hex << result << "(" << std::dec << result << ")" + << " != "<< v1 << " < " << v2 + << std::endl; + v1 < v2; + return false; +} + +#pragma GCC diagnostic pop + +#include "test_checked_comparison.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_less_than( + signed_values<T>[i], + signed_values<T>[j], + signed_comparison_results[i][j] + ); + }; +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_less_than( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_comparison_results[i][j] + ); + }; +}; + +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + bool rval = true; + + mp_for_each< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, + signed_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + mp_for_each< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return rval ? 0 : 1; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_less_than_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_checked_less_than_constexpr.cpp new file mode 100644 index 00000000..3c9b89f3 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_less_than_constexpr.cpp @@ -0,0 +1,93 @@ +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/checked_result.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +// note: T should be of tyme checked_result<R> for some integer type R +template<class T> +constexpr bool test_checked_less_than( + T v1, + T v2, + char expected_result +){ + using namespace boost::safe_numerics; + const boost::logic::tribool result = v1 < v2; + switch(expected_result){ + case '<': + if(result) + return true; + break; + case '>': + case '=': + if(!result) + return true; + break; + case '!': + if(indeterminate(result)) + return true; + break; + } + return false; +} + +#include "test_checked_comparison.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_less_than( + signed_values<T>[i], + signed_values<T>[j], + signed_comparison_results[i][j] + ); +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_less_than( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_comparison_results[i][j] + ); +}; + +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + static_assert( + mp_all_of< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, signed_value_indices + >, + mp_to_bool + >(), + "all values for all signed types correctly compared" + ); + + static_assert( + mp_all_of< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + >, + mp_to_bool + >(), + "all values for all unsigned types correctly compared" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_modulus.cpp b/src/boost/libs/safe_numerics/test/test_checked_modulus.cpp new file mode 100644 index 00000000..57b257b1 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_modulus.cpp @@ -0,0 +1,129 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/core/demangle.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +template<class T> +bool test_checked_modulus( + T v1, + T v2, + char expected_result +){ + using namespace boost::safe_numerics; + + const T result = v1 % v2; + std::cout + << v1 << " % " << v2 << " -> " << result + << std::endl; + + switch(expected_result){ + case '.': + case '0': + if(result.exception()){ + std::cout + << "erroneously detected error in division" + << std::endl; + v1 % v2; + return false; + } + if(expected_result == '0' + && result != T(0) + ){ + std::cout + << "failed to get expected zero result " + << std::endl; + v1 % v2; + return false; + } + return true; + case '-': + if(safe_numerics_error::negative_overflow_error == result.m_e) + return true; + case '+': + if(safe_numerics_error::positive_overflow_error == result.m_e) + return true; + case '!': + if(safe_numerics_error::range_error == result.m_e) + return true; + } + std::cout + << "failed to detect error in modulus " + << std::hex << result << "(" << std::dec << result << ")" + << " != "<< v1 << " % " << v2 + << std::endl; + v1 % v2; + return false; +} + +#include "test_checked_modulus.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_modulus( + signed_values<T>[i], + signed_values<T>[j], + signed_modulus_results[i][j] + ); + }; +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_modulus( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_modulus_results[i][j] + ); + }; +}; + +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + bool rval = true; + + std::cout << "*** testing signed values\n"; + mp_for_each< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, + signed_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + std::cout << "*** testing unsigned values\n"; + mp_for_each< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return rval ? 0 : 1; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_modulus.hpp b/src/boost/libs/safe_numerics/test/test_checked_modulus.hpp new file mode 100644 index 00000000..f2a818b7 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_modulus.hpp @@ -0,0 +1,44 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_CHECKED_MODULUS_HPP +#define BOOST_SAFE_NUMERICS_TEST_CHECKED_MODULUS_HPP + +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_checked_values.hpp" + +// test result matrices + +// key +// . success +// - negative_overflow_error +// + positive_overflow_error +// ! range_error + +constexpr const char * signed_modulus_results[] = { +// 012345678 +/* 0*/ "!!!!!!!!!", +/* 1*/ "!!!!!!!!!", +/* 2*/ "!!!.0!.-!", +/* 3*/ "!!...!...", +/* 4*/ "!!...!...", +/* 5*/ "!!000!000", +/* 6*/ "!!...!...", +/* 7*/ "!!...!...", +/* 8*/ "!!!..!.+!", +}; + +constexpr const char * unsigned_modulus_results[] = { +// 0123456 +/* 0*/ "!!!!!!!", +/* 1*/ "!!!!!!!", +/* 2*/ "!!!.0!!", +/* 3*/ "!!...!.", +/* 4*/ "!!...!.", +/* 5*/ "!!000!0", +/* 6*/ "!!!-.!!", +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_CHECKED_MODULUS_HPP diff --git a/src/boost/libs/safe_numerics/test/test_checked_modulus_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_checked_modulus_constexpr.cpp new file mode 100644 index 00000000..0d480dce --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_modulus_constexpr.cpp @@ -0,0 +1,90 @@ +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/checked_result.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +template<class T> +constexpr bool test_checked_modulus( + const T & v1, + const T & v2, + char expected_result +){ + using namespace boost::safe_numerics; + const T result = v1 % v2; + switch(expected_result){ + case '0': + case '.': + return ! result.exception(); + case '-': + return safe_numerics_error::negative_overflow_error == result.m_e; + case '+': + return safe_numerics_error::positive_overflow_error == result.m_e; + case '!': + return safe_numerics_error::range_error == result.m_e; + } + return false; +} + +#include "test_checked_modulus.hpp" + +#include <boost/mp11/algorithm.hpp> + +template<typename T, typename First, typename Second> +struct test_signed_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_modulus( + signed_values<T>[i], + signed_values<T>[j], + signed_modulus_results[i][j] + ); +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_modulus( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_modulus_results[i][j] + ); +}; + +#include <boost/mp11/algorithm.hpp> +#include <boost/mp11/function.hpp> + +int main(){ + using namespace boost::mp11; + static_assert( + mp_all_of< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, signed_value_indices + >, + mp_to_bool + >(), + "modulus for all signed values correct" + ); + + static_assert( + mp_all_of< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + >, + mp_to_bool + >(), + "modulus for all unsigned values correct" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_multiply.cpp b/src/boost/libs/safe_numerics/test/test_checked_multiply.cpp new file mode 100644 index 00000000..de2ee679 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_multiply.cpp @@ -0,0 +1,138 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/core/demangle.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +// note: T should be of type checked_result<R> for some integer type R +template<class T> +bool test_checked_multiply( + T v1, + T v2, + char expected_result +){ + using namespace boost::safe_numerics; + const T result = v1 * v2; + std::cout + << "testing " + << v1 << " * " << v2 << " -> " << result + << std::endl; + + switch(expected_result){ + case '0': + case '.': + if(result.exception()){ + std::cout + << "erroneously detected error in multiplication " + << std::endl; + v1 * v2; + return false; + } + if(expected_result == '0' + && result != T(0) + ){ + std::cout + << "failed to get expected zero result " + << std::endl; + v1 * v2; + return false; + } + return true; + case '-': + if(safe_numerics_error::negative_overflow_error == result.m_e) + return true; + break; + case '+': + if(safe_numerics_error::positive_overflow_error == result.m_e) + return true; + break; + case '!': + if(safe_numerics_error::range_error == result.m_e) + return true; + break; + } + std::cout + << "failed to detect error in multiplication " + << std::hex << result << "(" << std::dec << result << ")" + << " != "<< v1 << " * " << v2 + << std::endl; + v1 * v2; + return false; +} + +#include "test_checked_multiply.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_multiply( + signed_values<T>[i], + signed_values<T>[j], + signed_multiplication_results[i][j] + ); + }; +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_multiply( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_multiplication_results[i][j] + ); + }; +}; + +#include "check_symmetry.hpp" + +#include <boost/mp11/algorithm.hpp> + +int main(int , char *[]){ + // sanity check on test matrix - should be symetrical + check_symmetry(signed_multiplication_results); + check_symmetry(unsigned_multiplication_results); + + using namespace boost::mp11; + bool rval = true; + + mp_for_each< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, + signed_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + std::cout << "*** testing unsigned values\n"; + + mp_for_each< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return rval ? 0 : 1; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_multiply.hpp b/src/boost/libs/safe_numerics/test/test_checked_multiply.hpp new file mode 100644 index 00000000..5589f925 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_multiply.hpp @@ -0,0 +1,44 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_CHECKED_MULTIPLY_HPP +#define BOOST_SAFE_NUMERICS_TEST_CHECKED_MULTIPLY_HPP + +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_checked_values.hpp" + +// test result matrices + +// key +// . success +// - negative_overflow_error +// + positive_overflow_error +// ! range_error + +constexpr const char * signed_multiplication_results[] = { +// 012345678 +/* 0*/ "!!!!!!!!!", +/* 1*/ "!!!!!!!!!", +/* 2*/ "!!+++.---", +/* 3*/ "!!++...--", +/* 4*/ "!!+.....-", +/* 5*/ "!!...0000", +/* 6*/ "!!-..0.++", +/* 7*/ "!!--.0+++", +/* 8*/ "!!---0+++", +}; + +constexpr const char * unsigned_multiplication_results[] = { +// 0123456 +/* 0*/ "!!!!!!!", +/* 1*/ "!!!!!!!", +/* 2*/ "!!+++.-", +/* 3*/ "!!++..-", +/* 4*/ "!!+...-", +/* 5*/ "!!...00", +/* 6*/ "!!---0+", +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_CHECKED_MULTIPLY_HPP diff --git a/src/boost/libs/safe_numerics/test/test_checked_multiply_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_checked_multiply_constexpr.cpp new file mode 100644 index 00000000..c154a369 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_multiply_constexpr.cpp @@ -0,0 +1,99 @@ +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/checked_result.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +template<class T> +constexpr bool test_checked_multiply( + T v1, + T v2, + char expected_result +){ + using namespace boost::safe_numerics; + const T result = v1 * v2; + switch(expected_result){ + case '0': + case '.': + if(result.exception()){ + return false; + } + if(expected_result == '0' + && result != T(0) + ){ + return false; + } + return true; + case '-': + return safe_numerics_error::negative_overflow_error == result.m_e; + case '+': + return safe_numerics_error::positive_overflow_error == result.m_e; + case '!': + return safe_numerics_error::range_error == result.m_e; + } + return false; +} + +#include "test_checked_multiply.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_multiply( + signed_values<T>[i], + signed_values<T>[j], + signed_multiplication_results[i][j] + ); +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_multiply( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_multiplication_results[i][j] + ); +}; + +#include "check_symmetry.hpp" +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + check_symmetry(signed_multiplication_results); + check_symmetry(unsigned_multiplication_results); + + static_assert( + mp_all_of< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, signed_value_indices + >, + mp_to_bool + >(), + "all values for all signed types correctly multiplied" + ); + + static_assert( + mp_all_of< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + >, + mp_to_bool + >(), + "all values for all unsigned types correctly multiplied" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_or.cpp b/src/boost/libs/safe_numerics/test/test_checked_or.cpp new file mode 100644 index 00000000..4638bf63 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_or.cpp @@ -0,0 +1,125 @@ +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/core/demangle.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +// note: T should be of tyme checked_result<R> for some integer type R +template<class T> +bool test_checked_or( + T v1, + T v2, + char expected_result +){ + using namespace boost::safe_numerics; + const T result = v1 | v2; + std::cout + << v1 << " | " << v2 << " -> " << result + << std::endl; + + switch(expected_result){ + case '.': + if(result.exception()){ + std::cout + << "erroneously detected error in bitwise or " + << std::endl; + v1 | v2; + return false; + } + return true; + case '-': + if(safe_numerics_error::negative_overflow_error == result.m_e) + return true; + case '+': + if(safe_numerics_error::positive_overflow_error == result.m_e) + return true; + case '!': + if(safe_numerics_error::range_error == result.m_e) + return true; + } + std::cout + << "failed to detect error in bitwise or " + << std::hex << result << "(" << std::dec << result << ")" + << " != "<< v1 << " | " << v2 + << std::endl; + v1 | v2; + return false; +} + +#include "test_checked_or.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_or( + signed_values<T>[i], + signed_values<T>[j], + signed_or_results[i][j] + ); + }; +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_or( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_or_results[i][j] + ); + }; +}; + +#include "check_symmetry.hpp" + +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + // sanity check on test matrix - should be symetrical + check_symmetry(signed_or_results); + check_symmetry(unsigned_or_results); + + bool rval = true; + + std::cout << "*** testing signed values\n"; + mp_for_each< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, + signed_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + std::cout << "*** testing unsigned values\n"; + + mp_for_each< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return rval ? 0 : 1; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_or.hpp b/src/boost/libs/safe_numerics/test/test_checked_or.hpp new file mode 100644 index 00000000..b6fb0de4 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_or.hpp @@ -0,0 +1,44 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_CHECKED_OR_HPP +#define BOOST_SAFE_NUMERICS_TEST_CHECKED_OR_HPP + +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_checked_values.hpp" + +// test result matrices + +// key +// . success +// - negative_overflow_error +// + positive_overflow_error +// ? range_error + +constexpr const char * const signed_or_results[] = { +// 012345678 +/* 0*/ "!!!!!!!!!", +/* 1*/ "!!!!!!!!!", +/* 2*/ "!!++++++!", +/* 3*/ "!!+.....-", +/* 4*/ "!!+.....-", +/* 5*/ "!!+.....-", +/* 6*/ "!!+.....-", +/* 7*/ "!!+.....-", +/* 8*/ "!!!------", +}; + +constexpr const char * const unsigned_or_results[] = { +// 0123456 +/* 0*/ "!!!!!!!", +/* 1*/ "!!!!!!!", +/* 2*/ "!!+++++", +/* 3*/ "!!+...-", +/* 4*/ "!!+...-", +/* 5*/ "!!+...-", +/* 6*/ "!!+----", +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_CHECKED_OR_HPP diff --git a/src/boost/libs/safe_numerics/test/test_checked_or_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_checked_or_constexpr.cpp new file mode 100644 index 00000000..35491a0c --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_or_constexpr.cpp @@ -0,0 +1,98 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/checked_result.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +// note: T should be of tyme checked_result<R> for some integer type R +template<class T> +constexpr bool test_checked_or( + T v1, + T v2, + char expected_result +){ + using namespace boost::safe_numerics; + const T result = v1 | v2; + switch(expected_result){ + case '.': + if(result.exception()){ + return false; + } + return true; + case '-': + if(safe_numerics_error::negative_overflow_error == result.m_e) + return true; + case '+': + if(safe_numerics_error::positive_overflow_error == result.m_e) + return true; + case '!': + if(safe_numerics_error::range_error == result.m_e) + return true; + } + return false; +} + +#include "test_checked_or.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_or( + signed_values<T>[i], + signed_values<T>[j], + signed_or_results[i][j] + ); +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_or( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_or_results[i][j] + ); +}; + +#include "check_symmetry.hpp" +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + // sanity check on test matrix - should be symetrical + check_symmetry(signed_or_results); + check_symmetry(unsigned_or_results); + + static_assert( + mp_all_of< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, signed_value_indices + >, + mp_to_bool + >(), + "all values for all signed types correctly or'ed" + ); + + static_assert( + mp_all_of< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + >, + mp_to_bool + >(), + "all values for all unsigned types correctly or'ed" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_right_shift.cpp b/src/boost/libs/safe_numerics/test/test_checked_right_shift.cpp new file mode 100644 index 00000000..6d37aea9 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_right_shift.cpp @@ -0,0 +1,139 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> +#include <boost/core/demangle.hpp> + +#include <boost/safe_numerics/checked_result.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +// note: T should be of tyme checked_result<R> for some integer type R +template<class T> +bool test_checked_right_shift( + T v1, + T v2, + char expected_result +){ + using namespace boost::safe_numerics; + const T result = v1 >> v2; + std::cout + << v1 << " >> " << v2 << " -> " << result + << std::endl; + + switch(expected_result){ + case '.': + if(result.exception()){ + std::cout + << "erroneously detected error in right shift " + << std::endl; + v1 >> v2; + return false; + } + return true; + case '-': + if(safe_numerics_error::negative_overflow_error == result.m_e) + return true; + break; + case '+': + if(safe_numerics_error::positive_overflow_error == result.m_e) + return true; + break; + case '!': + if(safe_numerics_error::range_error == result.m_e) + return true; + break; + case 'n': // n negative_shift + if(safe_numerics_error::negative_shift == result.m_e) + return true; + break; + case 's': // s negative_value_shift + if(safe_numerics_error::negative_value_shift == result.m_e) + return true; + break; + case 'l': // l shift_too_large + if(safe_numerics_error::shift_too_large == result.m_e) + return true; + break; + default: + assert(false); + } + std::cout + << "failed to detect error in right shift " + << std::hex << result << "(" << std::dec << result << ")" + << " != "<< v1 << " >> " << v2 + << std::endl; + v1 >> v2; + return false; +} + +#include "test_checked_right_shift.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_right_shift( + signed_values<T>[i], + signed_values<T>[j], + signed_right_shift_results[i][j] + ); + }; +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_right_shift( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_right_shift_results[i][j] + ); + }; +}; + +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + bool rval = true; + + std::cout << "*** testing signed values\n"; + + mp_for_each< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, + signed_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + std::cout << "*** testing unsigned values\n"; + + mp_for_each< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return rval ? 0 : 1; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_right_shift.hpp b/src/boost/libs/safe_numerics/test/test_checked_right_shift.hpp new file mode 100644 index 00000000..d5f1f9df --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_right_shift.hpp @@ -0,0 +1,47 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_CHECKED_RIGHT_SHIFT_HPP +#define BOOST_SAFE_NUMERICS_TEST_CHECKED_RIGHT_SHIFT_HPP + +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_checked_values.hpp" + +// test result matrices + +// key +// . success +// - negative_overflow_error +// + positive_overflow_error +// ? range_error +// n negative_shift, // negative value in shift operator +// s negative_value_shift, // shift a negative value +// l shift_too_large, // l/r shift exceeds variable size + +constexpr char const * const signed_right_shift_results[] = { +// 012345678 +/* 0*/ "!!!!!!!!!", +/* 1*/ "!!!!!!!!!", +/* 2*/ "!!!++++++", +/* 3*/ "!!....+++", +/* 4*/ "!!.....++", +/* 5*/ ".........", +/* 6*/ "!!.....--", +/* 7*/ "!!....---", +/* 8*/ "!!!------", +}; + +constexpr char const * const unsigned_right_shift_results[] = { +// 0123456 +/* 0*/ "!!!!!!!", +/* 1*/ "!!!!!!!", +/* 2*/ "!!!++++", +/* 3*/ "!!....+", +/* 4*/ "!!....+", +/* 5*/ ".......", +/* 6*/ "!!!----", +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_CHECKED_RIGHT_SHIFT_HPP diff --git a/src/boost/libs/safe_numerics/test/test_checked_right_shift_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_checked_right_shift_constexpr.cpp new file mode 100644 index 00000000..6e40a83b --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_right_shift_constexpr.cpp @@ -0,0 +1,115 @@ +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> +#include <boost/core/demangle.hpp> + +#include <boost/safe_numerics/checked_result.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +// note: T should be of tyme checked_result<R> for some integer type R +template<class T> +constexpr bool test_checked_right_shift( + const T & v1, + const T & v2, + char expected_result +){ + using namespace boost::safe_numerics; + const T result = v1 >> v2; + + switch(expected_result){ + case '.': + if(result.exception()){ + return false; + } + return true; + case '-': + if(safe_numerics_error::negative_overflow_error == result.m_e) + return true; + break; + case '+': + if(safe_numerics_error::positive_overflow_error == result.m_e) + return true; + break; + case '!': + if(safe_numerics_error::range_error == result.m_e) + return true; + break; + case 'n': // n negative_shift + if(safe_numerics_error::negative_shift == result.m_e) + return true; + break; + case 's': // s negative_value_shift + if(safe_numerics_error::negative_value_shift == result.m_e) + return true; + break; + case 'l': // l shift_too_large + if(safe_numerics_error::shift_too_large == result.m_e) + return true; + break; + default: + assert(false); + } + return false; +} + +#include "test_checked_right_shift.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_right_shift( + signed_values<T>[i], + signed_values<T>[j], + signed_right_shift_results[i][j] + ); +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_right_shift( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_right_shift_results[i][j] + ); +}; + +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + static_assert( + mp_all_of< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, signed_value_indices + >, + mp_to_bool + >(), + "all values for all signed types correctly right_shifted" + ); + + static_assert( + mp_all_of< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + >, + mp_to_bool + >(), + "all values for all unsigned types correctly right_shifted" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_subtract.cpp b/src/boost/libs/safe_numerics/test/test_checked_subtract.cpp new file mode 100644 index 00000000..b6fc9204 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_subtract.cpp @@ -0,0 +1,121 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/core/demangle.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +// note: T should be of tyme checked_result<R> for some integer type R +template<class T> +bool test_checked_subtract( + T v1, + T v2, + char expected_result +){ + using namespace boost::safe_numerics; + const T result = v1 - v2; + std::cout + << v1 << " - " << v2 << " -> " << result + << std::endl; + + switch(expected_result){ + case '.': + if(result.exception()){ + std::cout + << "erroneously detected error in subtraction " + << std::endl; + v1 - v2; + return false; + } + return true; + case '-': + if(safe_numerics_error::negative_overflow_error == result.m_e) + return true; + case '+': + if(safe_numerics_error::positive_overflow_error == result.m_e) + return true; + case '!': + if(safe_numerics_error::range_error == result.m_e) + return true; + } + std::cout + << "failed to detect error in ition " + << std::hex << result << "(" << std::dec << result << ")" + << " != "<< v1 << " - " << v2 + << std::endl; + v1 - v2; + return false; +} + +#include "test_checked_subtract.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_subtract( + signed_values<T>[i], + signed_values<T>[j], + signed_subtraction_results[i][j] + ); + }; +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_subtract( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_subtraction_results[i][j] + ); + }; +}; + +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + bool rval = true; + + std::cout << "*** testing signed values\n"; + + mp_for_each< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, + signed_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + std::cout << "*** testing unsigned values\n"; + + mp_for_each< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return rval ? 0 : 1; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_subtract.hpp b/src/boost/libs/safe_numerics/test/test_checked_subtract.hpp new file mode 100644 index 00000000..5a00147c --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_subtract.hpp @@ -0,0 +1,44 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_CHECKED_AND_HPP +#define BOOST_SAFE_NUMERICS_TEST_CHECKED_AND_HPP + +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_checked_values.hpp" + +// test result matrices + +// key +// . success +// - negative_overflow_error +// + positive_overflow_error +// ? range_error + +constexpr const char * signed_subtraction_results[] = { +// 012345678 +/* 0*/ "!!!!!!!!!", +/* 1*/ "!!!!!!!!!", +/* 2*/ "!!+++++++", +/* 3*/ "!!-...++-", +/* 4*/ "---....++", +/* 5*/ "---....++", +/* 6*/ "---.....+", +/* 7*/ "!!---...-", +/* 8*/ "!!-------", +}; + +constexpr const char * unsigned_subtraction_results[] = { +// 0123456 +/* 0*/ "!!!!!!!", +/* 1*/ "!!!!!!!", +/* 2*/ "!!+++++", +/* 3*/ "!!-...+", +/* 4*/ "----..+", +/* 5*/ "-----.+", +/* 6*/ "------+", +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_CHECKED_AND_HPP diff --git a/src/boost/libs/safe_numerics/test/test_checked_subtract_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_checked_subtract_constexpr.cpp new file mode 100644 index 00000000..4d8ba6a8 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_subtract_constexpr.cpp @@ -0,0 +1,94 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/checked_result.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +// note: T should be of tyme checked_result<R> for some integer type R +template<class T> +constexpr bool test_checked_subtract( + const T & v1, + const T & v2, + char expected_result +){ + using namespace boost::safe_numerics; + const T result = v1 - v2; + switch(expected_result){ + case '.': + if(result.exception()){ + return false; + } + return true; + case '-': + if(safe_numerics_error::negative_overflow_error == result.m_e) + return true; + case '+': + if(safe_numerics_error::positive_overflow_error == result.m_e) + return true; + case '!': + if(safe_numerics_error::range_error == result.m_e) + return true; + } + return false; +} + +#include "test_checked_subtract.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_subtract( + signed_values<T>[i], + signed_values<T>[j], + signed_subtraction_results[i][j] + ); +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_subtract( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_subtraction_results[i][j] + ); +}; + +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + static_assert( + mp_all_of< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, signed_value_indices + >, + mp_to_bool + >(), + "all values for all signed types correctly subtracted" + ); + + static_assert( + mp_all_of< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + >, + mp_to_bool + >(), + "all values for all unsigned types correctly subtracted" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_values.hpp b/src/boost/libs/safe_numerics/test/test_checked_values.hpp new file mode 100644 index 00000000..957db559 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_values.hpp @@ -0,0 +1,57 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_CHECKED_VALUES_HPP +#define BOOST_SAFE_NUMERICS_TEST_CHECKED_VALUES_HPP + +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/checked_result.hpp> +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> + +// values +// note: In theory explicity specifying the number of elements in the +// array should not be necessary. However, this seems to crash the CLang +// compilers with standards setting of C++17. So don't remove the array +// bounds below +template<typename T> +constexpr const boost::safe_numerics::checked_result<T> signed_values[9] = { + boost::safe_numerics::safe_numerics_error::range_error, + boost::safe_numerics::safe_numerics_error::domain_error, + boost::safe_numerics::safe_numerics_error::positive_overflow_error, + std::numeric_limits<T>::max(), + 1, + 0, + -1, + std::numeric_limits<T>::lowest(), + boost::safe_numerics::safe_numerics_error::negative_overflow_error, +}; + +using signed_test_types = boost::mp11::mp_list< + std::int8_t, std::int16_t, std::int32_t, std::int64_t +>; +using signed_value_indices = boost::mp11::mp_iota_c< + sizeof(signed_values<int>) / sizeof(signed_values<int>[0]) +>; + +template<typename T> +constexpr const boost::safe_numerics::checked_result<T> unsigned_values[7] = { + boost::safe_numerics::safe_numerics_error::range_error, + boost::safe_numerics::safe_numerics_error::domain_error, + boost::safe_numerics::safe_numerics_error::positive_overflow_error, + std::numeric_limits<T>::max(), + 1, + 0, + boost::safe_numerics::safe_numerics_error::negative_overflow_error, +}; + +using unsigned_test_types = boost::mp11::mp_list< + std::uint8_t, std::uint16_t, std::uint32_t, std::uint64_t +>; +using unsigned_value_indices = boost::mp11::mp_iota_c< + sizeof(unsigned_values<int>) / sizeof(unsigned_values<int>[0]) +>; + +#endif // BOOST_SAFE_NUMERICS_TEST_CHECKED_VALUES_HPP diff --git a/src/boost/libs/safe_numerics/test/test_checked_xor.cpp b/src/boost/libs/safe_numerics/test/test_checked_xor.cpp new file mode 100644 index 00000000..6709fc0f --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_xor.cpp @@ -0,0 +1,126 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/core/demangle.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +// note: T should be of tyme checked_result<R> for some integer type R +template<class T> +bool test_checked_xor( + T v1, + T v2, + char expected_result +){ + using namespace boost::safe_numerics; + const T result = v1 ^ v2; + std::cout + << v1 << " ^ " << v2 << " -> " << result + << std::endl; + + switch(expected_result){ + case '.': + if(result.exception()){ + std::cout + << "erroneously detected error in exclusive or " + << std::endl; + v1 ^ v2; + return false; + } + return true; + case '-': + if(safe_numerics_error::negative_overflow_error == result.m_e) + return true; + case '+': + if(safe_numerics_error::positive_overflow_error == result.m_e) + return true; + case '!': + if(safe_numerics_error::range_error == result.m_e) + return true; + } + std::cout + << "failed to detect error in exclusive or " + << std::hex << result << "(" << std::dec << result << ")" + << " != "<< v1 << " ^ " << v2 + << std::endl; + v1 ^ v2; + return false; +} + +#include "test_checked_xor.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_xor( + signed_values<T>[i], + signed_values<T>[j], + signed_xor_results[i][j] + ); + }; +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + bool operator()() const { + std::size_t i = First(); + std::size_t j = Second(); + std::cout << std::dec << i << ',' << j << ',' + << "testing " << boost::core::demangle(typeid(T).name()) << ' '; + return test_checked_xor( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_xor_results[i][j] + ); + }; +}; + +#include "check_symmetry.hpp" + +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + // sanity check on test matrix - should be symetrical + check_symmetry(signed_xor_results); + check_symmetry(unsigned_xor_results); + + bool rval = true; + + std::cout << "*** testing signed values\n"; + + mp_for_each< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, + signed_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + std::cout << "*** testing unsigned values\n"; + + mp_for_each< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + > + >([&](auto I){ + rval &= I(); + }); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return rval ? 0 : 1; +} diff --git a/src/boost/libs/safe_numerics/test/test_checked_xor.hpp b/src/boost/libs/safe_numerics/test/test_checked_xor.hpp new file mode 100644 index 00000000..f30725b1 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_xor.hpp @@ -0,0 +1,44 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_CHECKED_XOR_HPP +#define BOOST_SAFE_NUMERICS_TEST_CHECKED_XOR_HPP + +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_checked_values.hpp" + +// test result matrices + +// key +// . success +// - negative_overflow_error +// + positive_overflow_error +// ? range_error + +constexpr const char * const signed_xor_results[] = { +// 012345678 +/* 0*/ "!!!!!!!!!", +/* 1*/ "!!!!!!!!!", +/* 2*/ "!!++++++!", +/* 3*/ "!!+.....-", +/* 4*/ "!!+.....-", +/* 5*/ "!!+.....-", +/* 6*/ "!!+.....-", +/* 7*/ "!!+.....-", +/* 8*/ "!!!-----!", +}; + +constexpr const char * const unsigned_xor_results[] = { +// 0123456 +/* 0*/ "!!!!!!!", +/* 1*/ "!!!!!!!", +/* 2*/ "!!+++++", +/* 3*/ "!!+...-", +/* 4*/ "!!+...-", +/* 5*/ "!!+...-", +/* 6*/ "!!+----", +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_CHECKED_XOR_HPP diff --git a/src/boost/libs/safe_numerics/test/test_checked_xor_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_checked_xor_constexpr.cpp new file mode 100644 index 00000000..68667ad1 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_checked_xor_constexpr.cpp @@ -0,0 +1,100 @@ +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/core/demangle.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/checked_integer.hpp> + +// note: T should be of tyme checked_result<R> for some integer type R +template<class T> +constexpr bool test_checked_xor( + const T & v1, + const T & v2, + char expected_result +){ + using namespace boost::safe_numerics; + const T result = v1 ^ v2; + + switch(expected_result){ + case '.': + if(result.exception()){ + return false; + } + return true; + case '-': + if(safe_numerics_error::negative_overflow_error == result.m_e) + return true; + case '+': + if(safe_numerics_error::positive_overflow_error == result.m_e) + return true; + case '!': + if(safe_numerics_error::range_error == result.m_e) + return true; + } + return false; +} + +#include "test_checked_xor.hpp" + +template<typename T, typename First, typename Second> +struct test_signed_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + static const bool value = test_checked_xor( + signed_values<T>[i], + signed_values<T>[j], + signed_xor_results[i][j] + ); +}; + +template<typename T, typename First, typename Second> +struct test_unsigned_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + // note: is constexpr really required here? compilers disagree! + constexpr static const bool value = test_checked_xor( + unsigned_values<T>[i], + unsigned_values<T>[j], + unsigned_xor_results[i][j] + ); +}; + +#include "check_symmetry.hpp" +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + check_symmetry(signed_xor_results); + check_symmetry(unsigned_xor_results); + + static_assert( + mp_all_of< + mp_product< + test_signed_pair, + signed_test_types, + signed_value_indices, signed_value_indices + >, + mp_to_bool + >(), + "all values for all signed types correctly xor'ed" + ); + + static_assert( + mp_all_of< + mp_product< + test_unsigned_pair, + unsigned_test_types, + unsigned_value_indices, unsigned_value_indices + >, + mp_to_bool + >(), + "all values for all unsigned types correctly xor'ed" + ); + + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_compare_automatic.hpp b/src/boost/libs/safe_numerics/test/test_compare_automatic.hpp new file mode 100644 index 00000000..52d677ce --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_compare_automatic.hpp @@ -0,0 +1,56 @@ +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#pragma once + +#include "test_values.hpp" + +constexpr const char *test_compare_automatic_result[ + boost::mp11::mp_size<test_values>::value +] = { +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/* 0*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<xx>", +/* 1*/ ">=>>><>>><>>><>>>=<<><<<><<<><xx>", +/* 2*/ "<<=<<<><<<><<<><<<<<<<<<<<<<<<xx<", +/* 3*/ "<<>=<<>=<<>=<<>=<<<<<<<<<<<<<<xx<", +/* 4*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<xx>", +/* 5*/ ">>>>>=>>><>>><>>>>>>>=<<><<<><xx>", +/* 6*/ "<<<<<<=<<<><<<><<<<<<<<<<<<<<<xx<", +/* 7*/ "<<>=<<>=<<>=<<>=<<<<<<<<<<<<<<xx<", + +/* 8*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<xx>", +/* 9*/ ">>>>>>>>>=>>><>>>>>>>>>>>=<<><xx>", +/*10*/ "<<<<<<<<<<=<<<><<<<<<<<<<<<<<<xx<", +/*11*/ "<<>=<<>=<<>=<<>=<<<<<<<<<<<<<<xx<", +/*12*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<xx>", +/*13*/ ">>>>>>>>>>>>>=>>>>>>>>>>>>>>>=xx>", +/*14*/ "<<<<<<<<<<<<<<=<<<<<<<<<<<<<<<xx<", +/*15*/ "<<>=<<>=<<>=<<>=<<<<<<<<<<<<<<xx<", + +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/*16*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<<<>", +/*17*/ ">=>>><>>><>>><>>>=<<><<<><<<><<<>", +/*18*/ ">>>>><>>><>>><>>>>=<><<<><<<><<<>", +/*19*/ ">>>>><>>><>>><>>>>>=><<<><<<><<<>", +/*20*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<<<>", +/*21*/ ">>>>>=>>><>>><>>>>>>>=<<><<<><<<>", +/*22*/ ">>>>>>>>><>>><>>>>>>>>=<><<<><<<>", +/*23*/ ">>>>>>>>><>>><>>>>>>>>>=><<<><<<>", + +/*24*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<<<>", +/*25*/ ">>>>>>>>>=>>><>>>>>>>>>>>=<<><<<>", +/*26*/ ">>>>>>>>>>>>><>>>>>>>>>>>>=<><<<>", +/*27*/ ">>>>>>>>>>>>><>>>>>>>>>>>>>=><<<>", +/*28*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<<<>", +/*29*/ ">>>>>>>>>>>>>=>>>>>>>>>>>>>>>=<<>", +/*30*/ "xxxxxxxxxxxxxxxx>>>>>>>>>>>>>>=<x", +/*31*/ "xxxxxxxxxxxxxxxx>>>>>>>>>>>>>>>=x", +/*32*/ "<<>><<>><<>><<>><<<<<<<<<<<<<<xx=" +}; diff --git a/src/boost/libs/safe_numerics/test/test_compare_native.hpp b/src/boost/libs/safe_numerics/test/test_compare_native.hpp new file mode 100644 index 00000000..2b55dab9 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_compare_native.hpp @@ -0,0 +1,48 @@ +#include "test_values.hpp" + +constexpr const char *test_compare_native_result[ + boost::mp11::mp_size<test_values>::value +] = { +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/* 0*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<<<>", +/* 1*/ ">=>>><>>><>>><>>>=<<><<<><<<><<<>", +/* 2*/ "<<=<<<><<<><<<><<<<<<<<<xxxxxxxx<", +/* 3*/ "<<>=<<>=<<>=<<>=<<<<<<<<xxxxxxxx<", +/* 4*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<<<>", +/* 5*/ ">>>>>=>>><>>><>>>>>>>=<<><<<><<<>", +/* 6*/ "<<<<<<=<<<><<<><<<<<<<<<xxxxxxxx<", +/* 7*/ "<<>=<<>=<<>=<<>=<<<<<<<<xxxxxxxx<", + +/* 8*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<<<>", +/* 9*/ ">>>>>>>>>=>>><>>>>>>>>>>>=<<><<<>", +/*10*/ "<<<<<<<<<<=<<<><<<<<<<<<xxxxxxxx<", +/*11*/ "<<>=<<>=<<>=<<>=<<<<<<<<xxxxxxxx<", +/*12*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<<<>", +/*13*/ ">>>>>>>>>>>>>=>>>>>>>>>>>>>>>=<<>", +/*14*/ "<<<<<<<<<<<<<<=<<<<<<<<<<<<<xxxx<", +/*15*/ "<<>=<<>=<<>=<<>=<<<<<<<<<<<<xxxx<", + +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/*16*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<<<>", +/*17*/ ">=>>><>>><>>><>>>=<<><<<><<<><<<>", +/*18*/ ">>>>><>>><>>><>>>>=<><<<><<<><<<>", +/*19*/ ">>>>><>>><>>><>>>>>=><<<><<<><<<>", +/*20*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<<<>", +/*21*/ ">>>>>=>>><>>><>>>>>>>=<<><<<><<<>", +/*22*/ ">>>>>>>>><>>><>>>>>>>>=<><<<><<<>", +/*23*/ ">>>>>>>>><>>><>>>>>>>>>=><<<><<<>", + +/*24*/ "=<xx=<xx=<xx=<>>=<<<=<<<=<<<=<<<>", +/*25*/ ">>xx>>xx>=xx><>>>>>>>>>>>=<<><<<>", +/*26*/ ">>xx>>xx>>xx><>>>>>>>>>>>>=<><<<>", +/*27*/ ">>xx>>xx>>xx><>>>>>>>>>>>>>=><<<>", +/*28*/ "=<xx=<xx=<xx=<xx=<<<=<<<=<<<=<<<>", +/*29*/ ">>xx>>xx>>xx>=xx>>>>>>>>>>>>>=<<>", +/*30*/ ">>xx>>xx>>xx>>xx>>>>>>>>>>>>>>=<>", +/*31*/ ">>xx>>xx>>xx>>xx>>>>>>>>>>>>>>>=>", +/*32*/ "<<>><<>><<>><<>><<<<<<<<<<<<<<<<=" +}; diff --git a/src/boost/libs/safe_numerics/test/test_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_constexpr.cpp new file mode 100644 index 00000000..30bf18f6 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_constexpr.cpp @@ -0,0 +1,64 @@ +// Copyright (c) 2014 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// Test constexpr operations on literals + +#include <iostream> + +#include <boost/safe_numerics/safe_integer_literal.hpp> +#include <boost/safe_numerics/native.hpp> +#include <boost/safe_numerics/exception.hpp> + +using namespace boost::safe_numerics; + +template<std::uintmax_t N> +using compile_time_value = safe_unsigned_literal<N, native, loose_trap_policy>; + +int main(){ + constexpr const compile_time_value<1000> x; + constexpr const compile_time_value<1> y; + + // should compile and execute without problem + std::cout << x << '\n'; + + // all the following statements should compile + constexpr auto x_plus_y = x + y; + static_assert(1001 == x_plus_y, "1001 == x + y"); + + constexpr auto x_minus_y = x - y; + static_assert(999 == x_minus_y, "999 == x - y"); + + constexpr auto x_times_y = x * y; + static_assert(1000 == x_times_y, "1000 == x * y"); + + constexpr auto x_and_y = x & y; + static_assert(0 == x_and_y, "0 == x & y"); + + constexpr auto x_or_y = x | y; + static_assert(1001 == x_or_y, "1001 == x | y"); + + constexpr auto x_xor_y = x ^ y; + static_assert(1001 == x_xor_y, "1001 == x ^ y"); + + constexpr auto x_divided_by_y = x / y; + static_assert(1000 == x_divided_by_y, "1000 == x / y"); + + constexpr auto x_mod_y = x % y; + static_assert(0 == x_mod_y, "0 == x % y"); + + // this should fail compilation since a positive unsigned number + // can't be converted to a negative value of the same type + constexpr auto minus_x = -x; + + // should compile OK since the negative inverse of a zero is still zero + constexpr const compile_time_value<0> x0; + constexpr auto minus_x0 = -x0; // should compile OK + static_assert(0 == minus_x0, "0 == -x where x == 0"); + + constexpr auto not_x = ~x; + + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_construction.cpp b/src/boost/libs/safe_numerics/test/test_construction.cpp new file mode 100644 index 00000000..68ad43ef --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_construction.cpp @@ -0,0 +1,172 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// test constructors + +#include <iostream> + +#include <boost/safe_numerics/safe_compare.hpp> +#include <boost/safe_numerics/safe_integer.hpp> + +template<class T2, class T1> +bool test_construction(T1 t1, const char *t2_name, const char *t1_name){ + using namespace boost::safe_numerics; + std::cout + << "testing constructions to " << t2_name << " from " << t1_name + << std::endl; + { + /* (1) test construction of safe<T1> from T1 type */ + try{ + safe<T1> s1(t1); + // should always arrive here! + } + catch(const std::exception &){ + // should never, ever arrive here + std::cout + << "erroneously detected error in construction " + << "safe<" << t1_name << "> (" << t1_name << ")" + << std::endl; + try{ + safe<T1> s1(t1); // try again for debugging + } + catch(const std::exception &){} + return false; + } + } + { + /* (2) test construction of safe<T2> from T1 type */ + T2 t2; + try{ + t2 = safe<T2>(t1); + if(! safe_compare::equal(t2 , t1)){ + std::cout + << "failed to detect error in construction " + << "safe<" << t2_name << "> (" << t1_name << ")" + << std::endl; + safe<T2> s2x(t1); + return false; + } + } + catch(const std::exception &){ + if(safe_compare::equal(t2, t1)){ + std::cout + << "erroneously detected error in construction " + << "safe<" << t2_name << "> (" << t1_name << ")" + << std::endl; + try{ + safe<T2> sx2(t1); // try again for debugging + } + catch(const std::exception &){} + return false; + } + } + } + { + /* (3) test construction of safe<T1> from safe<T1> type */ + safe<T1> s1x(t1); + try{ + safe<T1> s1(s1x); + if(! (s1 == s1x)){ + std::cout + << "copy constructor altered value " + << "safe<" << t1_name << "> (safe<" << t1_name << ">(" << t1 << "))" + << std::endl; + //safe<T1> s1(s1x); + return false; + } + } + catch(const std::exception &){ + // should never arrive here + std::cout + << "erroneously detected error in construction " + << "safe<" << t1_name << "> (safe<" << t1_name << ">(" << t1 << "))" + << std::endl; + try{ + safe<T1> s1(t1); + } + catch(const std::exception &){} + return false; + } + } + { + /* (4) test construction of safe<T2> from safe<T1> type */ + T2 t2; + try{ + safe<T1> s1(t1); + safe<T2> s2(s1); + t2 = static_cast<T2>(s2); + if(! (safe_compare::equal(t1, t2))){ + std::cout + << "failed to detect error in construction " + << "safe<" << t1_name << "> (safe<" << t2_name << ">(" << t1 << "))" + << std::endl; + safe<T2> s1x(t1); + return false; + } + } + catch(const std::exception &){ + if(safe_compare::equal(t1, t2)){ + std::cout + << "erroneously detected error in construction " + << "safe<" << t2_name << "> (safe<" << t1_name << ">(" << t1 << "))" + << std::endl; + try{ + safe<T2> s1(t1); + } + catch(const std::exception &){} + return false; + } + } + } + return true; +} + +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> +#include "test_values.hpp" + +using namespace boost::mp11; + +struct test { + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two types"); + using T1 = mp_first<T>; // first element is a type + // second element is an integral constant + using T2 = typename mp_second<T>::value_type; // get it's type + constexpr T2 v2 = mp_second<T>(); // get it's value + m_error &= test_construction<T1>( + v2, + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str() + ); + } +}; + +template<typename T> +using extract_value_type = typename T::value_type; +using test_types = mp_unique< + mp_transform< + extract_value_type, + test_values + > +>; + +int main(){ + test rval(true); + + mp_for_each< + mp_product<mp_list, test_types, test_values> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_cpp.cpp b/src/boost/libs/safe_numerics/test/test_cpp.cpp new file mode 100644 index 00000000..c9869c15 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_cpp.cpp @@ -0,0 +1,36 @@ +// Copyright (c) 2018 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/integer.hpp> +#include <boost/safe_numerics/utility.hpp> + +// include headers to support safe integers +#include <boost/safe_numerics/cpp.hpp> + +using promotion_policy = boost::safe_numerics::cpp< + 8, // char 8 bits + 16, // short 16 bits + 16, // int 16 bits + 16, // long 32 bits + 32 // long long 32 bits +>; + +template<typename R, typename T, typename U> +struct test { + using ResultType = promotion_policy::result_type<T,U>; + //boost::safe_numerics::utility::print_type<ResultType> pt; + static_assert( + std::is_same<R, ResultType>::value, + "is_same<R, ResultType>" + ); +}; + +test<std::uint16_t, std::uint8_t, std::uint8_t> t1; + +int main(){ + return 0; +} + diff --git a/src/boost/libs/safe_numerics/test/test_divide.hpp b/src/boost/libs/safe_numerics/test/test_divide.hpp new file mode 100644 index 00000000..93c53cc3 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_divide.hpp @@ -0,0 +1,137 @@ +#ifndef BOOST_TEST_DIVIDE_HPP +#define BOOST_TEST_DIVIDE_HPP + +// Copyright (c) 2015 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> +#include <boost/core/demangle.hpp> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/range_value.hpp> + +template<class T1, class T2> +bool test_divide( + T1 v1, + T2 v2, + const char *av1, + const char *av2, + char expected_result +){ + { + safe_t<T1> t1 = v1; + using result_type = decltype(t1 / v2); + std::cout + << "safe<" << av1 << "> / " << av2 << " -> " + << boost::core::demangle(typeid(result_type).name()) << '\n'; + static_assert( + boost::safe_numerics::is_safe<safe_t<T1> >::value, + "safe_t not safe!" + ); + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = t1 / v2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout << " *** failed to detect error in division" << std::endl; + t1 / v2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout << " *** erroneously detected error in division" << std::endl; + try{ + t1 / v2; + } + catch(const std::exception &){} + return false; + } + } + } + { + safe_t<T2> t2 = v2; + using result_type = decltype(v1 / t2); + std::cout + << "safe<" << av1 << "> / " << av2 << " -> " + << boost::core::demangle(typeid(result_type).name()) << '\n'; + + static_assert( + boost::safe_numerics::is_safe<safe_t<T2> >::value, + "safe_t not safe!" + ); + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + try{ + // use auto to avoid checking assignment. + auto result = v1 / t2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout << " *** failed to detect error in division " << std::endl; + v1 / t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout << "*** erroneously detected error in division " << std::endl; + try{ + v1 / t2; + } + catch(const std::exception &){} + // assert(result == unsafe_result); + return false; + } + } + } + { + safe_t<T1> t1 = v1; + safe_t<T2> t2 = v2; + using result_type = decltype(t1 / t2); + std::cout + << "testing safe<" << av1 << "> / safe<" << av2 << "> -> " + << boost::core::demangle(typeid(result_type).name()) << '\n'; + + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = t1 / t2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout << " *** failed to detect error in division" << std::endl; + t1 / t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout << " *** erroneously detected error in division \\" << std::endl; + try{ + t1 / t2; + } + catch(const std::exception &){} + return false; + } + } + } + return true; +} + +#endif // BOOST_TEST_DIVIDE diff --git a/src/boost/libs/safe_numerics/test/test_divide_automatic.cpp b/src/boost/libs/safe_numerics/test/test_divide_automatic.cpp new file mode 100644 index 00000000..d3caf049 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_divide_automatic.cpp @@ -0,0 +1,62 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> +#include "test_divide_automatic_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; +#include "test_divide.hpp" + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_divide( + boost::mp11::mp_at_c<L, i1>()(), // value of first argument + boost::mp11::mp_at_c<L, i2>()(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + test_division_automatic_result[i1][i2] + ); + } +}; + +int main(){ + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_divide_automatic_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_divide_automatic_constexpr.cpp new file mode 100644 index 00000000..5ad430a9 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_divide_automatic_constexpr.cpp @@ -0,0 +1,52 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> +#include "test_divide_automatic_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; + +#include "test_divide_constexpr.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_divide_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + test_division_automatic_result[i][j] + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly divided" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_divide_automatic_results.hpp b/src/boost/libs/safe_numerics/test/test_divide_automatic_results.hpp new file mode 100644 index 00000000..bb286058 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_divide_automatic_results.hpp @@ -0,0 +1,59 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_DIVIDE_AUTOMATIC_RESULTS_HPP +#define BOOST_SAFE_NUMERICS_TEST_DIVIDE_AUTOMATIC_RESULTS_HPP + +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_values.hpp" + +constexpr const char *test_division_automatic_result[ + boost::mp11::mp_size<test_values>::value +] = { +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/* 0*/ "..............................xxx", +/* 1*/ "..............................xxx", +/* 2*/ "..............................xxx", +/* 3*/ "..............................xxx", +/* 4*/ "..............................xxx", +/* 5*/ "..............................xxx", +/* 6*/ "..............................xxx", +/* 7*/ "..............................xxx", + +/* 8*/ "..............................xxx", +/* 9*/ "..............................xxx", +/*10*/ "..............................xxx", +/*11*/ "..............................xxx", +/*12*/ "..............................xxx", +/*13*/ "..............................xxx", +/*14*/ "...x...x...x...x..............xxx", +/*15*/ "..............................xxx", + +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/*16*/ "................................x", +/*17*/ "................................x", +/*18*/ "................................x", +/*19*/ "................................x", +/*20*/ "................................x", +/*21*/ "................................x", +/*22*/ "................................x", +/*23*/ "................................x", + +/*24*/ "................................x", +/*25*/ "................................x", +/*26*/ "................................x", +/*27*/ "................................x", +/*28*/ "................................x", +/*29*/ "................................x", +/*30*/ "xxxxxxxxxxxxxxxx................x", +/*31*/ "xxxxxxxxxxxxxxxx................x", +/*32*/ "..............................xxx" +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_DIVIDE_AUTOMATIC_RESULTS_HPP diff --git a/src/boost/libs/safe_numerics/test/test_divide_constexpr.hpp b/src/boost/libs/safe_numerics/test/test_divide_constexpr.hpp new file mode 100644 index 00000000..4ec0ef8f --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_divide_constexpr.hpp @@ -0,0 +1,30 @@ +#ifndef BOOST_TEST_DIVIDE_CONSTEXPR_HPP +#define BOOST_TEST_DIVIDE_CONSTEXPR_HPP + +// Copyright (c) 2015 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> + +template<class T1, class T2> +constexpr bool test_divide_constexpr( + T1 v1, + T2 v2, + char expected_result +){ + using namespace boost::safe_numerics; + // if we don't expect the operation to pass, we can't + // check the constexpr version of the calculation so + // just return success. + if(expected_result == 'x') + return true; + safe_t<T1>(v1) / v2; + v1 / safe_t<T2>(v2); + safe_t<T1>(v1) / safe_t<T2>(v2); + return true; // correct result +} + +#endif // BOOST_TEST_DIVIDE_CONSTEXPR_HPP diff --git a/src/boost/libs/safe_numerics/test/test_divide_native.cpp b/src/boost/libs/safe_numerics/test/test_divide_native.cpp new file mode 100644 index 00000000..0299223d --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_divide_native.cpp @@ -0,0 +1,63 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/native.hpp> +#include "test_divide_native_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; +#include "test_divide.hpp" + +using namespace boost::mp11; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_divide( + mp_at_c<L, i1>()(), // value of first argument + mp_at_c<L, i2>()(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + test_division_native_result[i1][i2] + ); + } +}; + +int main(){ + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_divide_native_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_divide_native_constexpr.cpp new file mode 100644 index 00000000..1a800a60 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_divide_native_constexpr.cpp @@ -0,0 +1,53 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/native.hpp> + +#include "test_divide_native_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; + +#include "test_divide_constexpr.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_divide_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + test_division_native_result[i][j] + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly divided" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_divide_native_results.hpp b/src/boost/libs/safe_numerics/test/test_divide_native_results.hpp new file mode 100644 index 00000000..b24a3541 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_divide_native_results.hpp @@ -0,0 +1,63 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_DIVIDE_NATIVE_RESULTS_HPP +#define BOOST_SAFE_NUMERICS_TEST_DIVIDE_NATIVE_RESULTS_HPP + +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_values.hpp" + +// note: These tables presume that the the size of an int is 32 bits. +// This should be changed for a different architecture or better yet +// be dynamically adjusted depending on the indicated architecture + +constexpr const char *test_division_native_result[ + boost::mp11::mp_size<test_values>::value +] = { +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/* 0*/ "................................x", +/* 1*/ "................................x", +/* 2*/ "........................xxxxxxxxx", +/* 3*/ "........................xxxxxxxxx", +/* 4*/ "................................x", +/* 5*/ "................................x", +/* 6*/ "........................xxxxxxxxx", +/* 7*/ "........................xxxxxxxxx", + +/* 8*/ "................................x", +/* 9*/ "................................x", +/*10*/ "...x...x...x............xxxxxxxxx", +/*11*/ "........................xxxxxxxxx", +/*12*/ "................................x", +/*13*/ "................................x", +/*14*/ "...x...x...x...x............xxxxx", +/*15*/ "............................xxxxx", + +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/*16*/ "................................x", +/*17*/ "................................x", +/*18*/ "................................x", +/*19*/ "................................x", +/*20*/ "................................x", +/*21*/ "................................x", +/*22*/ "................................x", +/*23*/ "................................x", + +/*24*/ "..xx..xx..xx....................x", +/*25*/ "..xx..xx..xx....................x", +/*26*/ "..xx..xx..xx....................x", +/*27*/ "..xx..xx..xx....................x", +/*28*/ "..xx..xx..xx..xx................x", +/*29*/ "..xx..xx..xx..xx................x", +/*30*/ "..xx..xx..xx..xx................x", +/*31*/ "..xx..xx..xx..xx................x", +/*32*/ "................................x" +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_DIVIDE_NATIVE_RESULTS_HPP diff --git a/src/boost/libs/safe_numerics/test/test_equal.hpp b/src/boost/libs/safe_numerics/test/test_equal.hpp new file mode 100644 index 00000000..70e9006d --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_equal.hpp @@ -0,0 +1,162 @@ + #ifndef BOOST_TEST_LESS_THAN_HPP +#define BOOST_TEST_LESS_THAN_HPP + +// Copyright (c) 2015 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/range_value.hpp> + +// works for both GCC and clang +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-value" + +template<class T1, class T2> +bool test_equal( + T1 v1, + T2 v2, + const char *av1, + const char *av2, + char expected_result +){ + using namespace boost::safe_numerics; + std::cout << "testing"<< std::boolalpha << std::endl; + { + safe_t<T1> t1 = v1; + std::cout << "safe<" << av1 << "> == " << av2 << " -> "; + static_assert( + boost::safe_numerics::is_safe<safe_t<T1> >::value, + "safe_t not safe!" + ); + try{ + // use auto to avoid checking assignment. + auto result = (t1 == v2); + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " == " << av2 + << " failed to detect error in equals" + << std::endl; + t1 == v2; + return false; + } + if(result != (expected_result == '=')){ + std::cout + << " ! = "<< av1 << " == " << av2 + << " produced the wrong answer" + << std::endl; + t1 == v2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result != 'x'){ + std::cout + << " == "<< av1 << " == " << av2 + << " erroneously detected error in equals" + << std::endl; + try{ + t1 == v2; + } + catch(const std::exception &){} + return false; + } + std::cout << std::endl; + } + } + { + safe_t<T2> t2 = v2; + std::cout << av1 << " == " << "safe<" << av2 << "> -> "; + static_assert( + boost::safe_numerics::is_safe<safe_t<T2> >::value, + "safe_t not safe!" + ); + try{ + // use auto to avoid checking assignment. + auto result = (v1 == t2); + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " == " << av2 + << " failed to detect error in equals " + << std::endl; + v1 == t2; + return false; + } + if(result != (expected_result == '=')){ + std::cout + << " ! = "<< av1 << " == " << av2 + << " produced the wrong answer " + << std::endl; + v1 == t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result != 'x'){ + std::cout + << " == "<< av1 << " == " << av2 + << " erroneously detected error in equals" + << std::endl; + try{ + v1 == t2; + } + catch(const std::exception &){} + return false; + } + std::cout << std::endl; + } + } + { + safe_t<T1> t1 = v1; + safe_t<T2> t2 = v2; + std::cout << "safe<" << av1 << "> < " << "safe<" << av2 << "> -> "; + + try{ + auto result = (t1 == t2); + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " == " << av2 + << " failed to detect error in equals" + << std::endl; + t1 == t2; + return false; + } + if(result != (expected_result == '=')){ + std::cout + << " ! = "<< av1 << " == " << av2 + << " produced the wrong answer" + << std::endl; + t1 == t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " == " << av2 + << " erroneously detected error in equals" + << std::endl; + try{ + t1 == t2; + } + catch(const std::exception &){} + return false; + } + std::cout << std::endl; + } + } + return true; // correct result +} +#pragma GCC diagnostic pop + +#endif // BOOST_TEST_SUBTRACT diff --git a/src/boost/libs/safe_numerics/test/test_equal_automatic.cpp b/src/boost/libs/safe_numerics/test/test_equal_automatic.cpp new file mode 100644 index 00000000..9c02c3d2 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_equal_automatic.cpp @@ -0,0 +1,61 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; +#include "test_equal.hpp" + +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> +#include "test_compare_automatic.hpp" + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_equal( + mp_at_c<L, i1>()(), // value of first argument + mp_at_c<L, i2>()(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + test_compare_automatic_result[i1][i2] + ); + } +}; + +int main(){ + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_equal_automatic_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_equal_automatic_constexpr.cpp new file mode 100644 index 00000000..5168d590 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_equal_automatic_constexpr.cpp @@ -0,0 +1,52 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> +#include "test_compare_automatic.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; + +#include "test_equal_constexpr.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_equal_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + test_compare_automatic_result[i][j] + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly compared for equality" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_equal_constexpr.hpp b/src/boost/libs/safe_numerics/test/test_equal_constexpr.hpp new file mode 100644 index 00000000..61887662 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_equal_constexpr.hpp @@ -0,0 +1,40 @@ +#ifndef BOOST_TEST_EQUAL_CONSTEXPR_HPP +#define BOOST_TEST_EQUAL_CONSTEXPR_HPP + +// Copyright (c) 2015 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/config.hpp> // BOOST_CLANG +#include <boost/safe_numerics/safe_integer.hpp> + +#if BOOST_CLANG == 1 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-comparison" +#endif + +template<class T1, class T2> +constexpr bool test_equal_constexpr( + T1 v1, + T2 v2, + char expected_result +){ + using namespace boost::safe_numerics; + // if we don't expect the operation to pass, we can't + // check the constexpr version of the calculation so + // just return success. + if(expected_result == 'x') + return true; + safe_t<T1>(v1) == v2; + v1 == safe_t<T2>(v2); + safe_t<T1>(v1) == safe_t<T2>(v2); + return true; // correct result +} + +#if BOOST_CLANG == 1 +#pragma GCC diagnostic pop +#endif + +#endif // BOOST_TEST_EQUAL_CONSTEXPR_HPP diff --git a/src/boost/libs/safe_numerics/test/test_equal_native.cpp b/src/boost/libs/safe_numerics/test/test_equal_native.cpp new file mode 100644 index 00000000..2252fd12 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_equal_native.cpp @@ -0,0 +1,60 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; +#include "test_equal.hpp" + +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> +#include "test_compare_native.hpp" + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_equal( + mp_at_c<L, i1>()(), // value of first argument + mp_at_c<L, i2>()(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + test_compare_native_result[i1][i2] + ); + } +}; + +int main(){ + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_equal_native_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_equal_native_constexpr.cpp new file mode 100644 index 00000000..866a0df2 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_equal_native_constexpr.cpp @@ -0,0 +1,52 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/native.hpp> +#include "test_compare_native.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; + +#include "test_equal_constexpr.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_equal_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + test_compare_native_result[i][j] + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly compared for equality" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_float.cpp b/src/boost/libs/safe_numerics/test/test_float.cpp new file mode 100644 index 00000000..c0e192db --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_float.cpp @@ -0,0 +1,36 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// testing floating point + +// this is a compile only test - but since many build systems +// can't handle a compile-only test - make sure it passes trivially. +#include <cassert> +#include <boost/safe_numerics/safe_integer.hpp> + +template<typename T, typename U> +void test(){ + T t; + U u; + float x = t; + t = x; + t + u; + t - u; + t * u; + t / u; +/**/ + // the operators below are restricted to integral types +} +int main(){ + using namespace boost::safe_numerics; + /* + test<safe<std::int8_t>, float>(); + test<safe<std::int16_t>,float>(); + test<safe<std::int32_t>, float>(); + test<safe<std::int64_t>, float>(); + */ + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_interval.cpp b/src/boost/libs/safe_numerics/test/test_interval.cpp new file mode 100644 index 00000000..115f4abd --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_interval.cpp @@ -0,0 +1,184 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> +#include <limits> +#include <functional> +#include <array> + +#include <boost/core/demangle.hpp> +#include <boost/safe_numerics/checked_result.hpp> +#include <boost/safe_numerics/checked_result_operations.hpp> +#include <boost/safe_numerics/interval.hpp> + +template<typename T> +using fptr = T (*)(const T &, const T &); +template<typename T> +using fptr_interval = fptr<boost::safe_numerics::interval<T>>; + +template<typename T> +struct op { + const fptr<T> m_f; + const fptr_interval<T> m_finterval; + const char * m_symbol; + const bool skip_zeros; +}; + +template< + typename T, + unsigned int N +> +bool test_type_operator( + const T (&value)[N], + const op<T> & opi +){ + using namespace boost::safe_numerics; + + // for each pair of values p1, p2 (100) + for(const T & l1 : value) + for(const T & u1 : value){ + if(l1 > u1) continue; // skip reverse range + const interval<T> p1(l1, u1); + for(const T & l2 : value) + for(const T & u2 : value){ + if(l2 > u2) continue; // skip reverse range + const interval<T> p2(l2, u2); + + // maybe skip intervals which include zero + if(opi.skip_zeros){ + if(l2 == safe_numerics_error::range_error + || l2 == safe_numerics_error::domain_error + || u2 == safe_numerics_error::range_error + || u2 == safe_numerics_error::domain_error + || p2.includes(T(0)) + ) + continue; + } + + // create a new interval from the operation + const interval<T> result_interval = opi.m_finterval(p1, p2); + std::cout + << p1 << opi.m_symbol << p2 << " -> " << result_interval << std::endl; + + // if resulting interval is null + if(result_interval.u < result_interval.l) + continue; + + // for each pair test values + for(const T r1 : value) + for(const T r2 : value){ + // calculate result of operation + const T result = opi.m_f(r1, r2); + if(result != safe_numerics_error::range_error + && result != safe_numerics_error::domain_error ){ + // note usage of tribool logic here !!! + // includes returns indeterminate the conditional + // returns false in both cases and this is what we want. + // This is very subtle, don't skim over this. + // if both r1 and r2 are within they're respective bounds + if(p1.includes(r1) && p2.includes(r2) + && ! result_interval.includes(result)){ + #if 0 + const boost::logic::tribool b1 = p1.includes(r1); + const boost::logic::tribool b2 = p2.includes(r2); + const boost::logic::tribool b3 = result_interval.includes(result); + const interval<T> result_intervalx = opi.m_finterval(p1, p2); + const T resultx = opi.m_f(r1, r2); + #endif + return false; + } + } + } + } + } + return true; +} + +// values +// note: need to explicitly specify number of elements to avoid msvc failure +template<typename T> +const boost::safe_numerics::checked_result<T> value[8] = { + boost::safe_numerics::safe_numerics_error::negative_overflow_error, + std::numeric_limits<T>::lowest(), + T(-1), + T(0), + T(1), + std::numeric_limits<T>::max(), + boost::safe_numerics::safe_numerics_error::positive_overflow_error, + boost::safe_numerics::safe_numerics_error::domain_error +}; + +// note: need to explicitly specify number of elements to avoid msvc failure +template<typename T> +const boost::safe_numerics::checked_result<T> unsigned_value[6] = { + boost::safe_numerics::safe_numerics_error::negative_overflow_error, + T(0), + T(1), + std::numeric_limits<T>::max(), + boost::safe_numerics::safe_numerics_error::positive_overflow_error, + boost::safe_numerics::safe_numerics_error::domain_error +}; + +// invoke for each type +struct test_type { + unsigned int m_error_count; + test_type() : + m_error_count(0) + {} + template<typename T> + bool operator()(const T &){ + using namespace boost::safe_numerics; + std::cout + << "** testing " + << boost::core::demangle(typeid(T).name()) + << std::endl; + + using R = checked_result<T>; + // pointers to operands for types T + static const std::array<op<R>, 5> op_table{{ + {operator+, operator+, "+", false}, + {operator-, operator-, "-", false}, + {operator*, operator*, "*", false}, + {operator<<, operator<<, "<<", false}, + {operator>>, operator>>, ">>", false}, + }}; + + //for(unsigned int i = 0; i < sizeof(op_table)/sizeof(op) / sizeof(fptr<R>); ++i){ + for(const op<R> & o : op_table){ + if(std::is_signed<T>::value){ + if(! test_type_operator(value<T>, o)){ + ++m_error_count; + return false; + } + } + else{ + if(! test_type_operator(unsigned_value<T>, o)){ + ++m_error_count; + return false; + } + } + } + return true; + } +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> + +int main(int, char *[]){ + using namespace boost::mp11; + // list of signed types + using signed_types = mp_list<std::int8_t, std::int16_t, std::int32_t, std::int64_t>; + // list of unsigned types + using unsigned_types = mp_list<std::uint8_t, std::uint16_t, std::uint32_t, std::uint64_t>; + + test_type t; + mp_for_each<unsigned_types>(t); + mp_for_each<signed_types>(t); + + std::cout << (t.m_error_count == 0 ? "success!" : "failure") << std::endl; + return t.m_error_count ; +} diff --git a/src/boost/libs/safe_numerics/test/test_left_shift.hpp b/src/boost/libs/safe_numerics/test/test_left_shift.hpp new file mode 100644 index 00000000..f9f87e4e --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_left_shift.hpp @@ -0,0 +1,148 @@ +#ifndef BOOST_TEST_LEFT_SHIFT_HPP +#define BOOST_TEST_LEFT_SHIFT_HPP + +// Copyright (c) 2015 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/range_value.hpp> + +template<class T1, class T2> +bool test_left_shift( + T1 v1, + T2 v2, + const char *av1, + const char *av2, + char expected_result +){ + std::cout + << "testing " + << av1 << " << " << av2 + << std::endl; + { + safe_t<T1> t1 = v1; + using result_type = decltype(t1 << v2); + std::cout << "safe<" << av1 << "> << " << av2 << " -> "; + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + try{ + // use auto to avoid checking assignment. + auto result = t1 << v2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " << " << av2 + << " failed to detect arithmetic error in left shift" + << std::endl; + t1 << v2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception & e){ + if(expected_result == '.'){ + std::cout + << "erroneously detected arithmetic error in left shift" + << " == "<< av1 << " << " << av2 + << ' ' << e.what() + << std::endl; + try{ + t1 << v2; + } + catch(const std::exception &){} + return false; + } + std::cout << std::endl; + } + } + { + safe_t<T2> t2 = v2; + using result_type = decltype(v1 << t2); + std::cout << av1 << " << " << "safe<" << av2 << "> -> "; + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = v1 << t2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " << " << av2 + << " failed to detect error in left shift" + << std::hex << result << "(" << std::dec << result << ")" + << std::endl; + v1 << t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception & e){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " << " << av2 + << "erroneously detected error in left shift " + << ' ' << e.what() + << std::endl; + try{ + v1 << t2; + } + catch(const std::exception &){} + return false; + } + std::cout << std::endl; + } + } + { + safe_t<T1> t1 = v1; + safe_t<T2> t2 = v2; + using result_type = decltype(t1 << t2); + std::cout << "safe<" << av1 << "> << " << "safe<" << av2 << "> -> "; + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = t1 << t2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " << " << av2 + << " failed to detect error in left shift" + << std::endl; + t1 << t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception & e){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " << " << av2 + << " erroneously detected error in left shift" + << ' ' << e.what() + << std::endl; + try{ + t1 << t2; + } + catch(const std::exception &){} + return false; + } + std::cout << std::endl; + } + } + return true; // correct result +} + +#endif // BOOST_TEST_DIVIDE diff --git a/src/boost/libs/safe_numerics/test/test_left_shift_automatic.cpp b/src/boost/libs/safe_numerics/test/test_left_shift_automatic.cpp new file mode 100644 index 00000000..6aa22e29 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_left_shift_automatic.cpp @@ -0,0 +1,62 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> +#include "test_left_shift_automatic_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; +#include "test_left_shift.hpp" + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_left_shift( + mp_at_c<L, i1>()(), // value of first argument + mp_at_c<L, i2>()(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + test_left_shift_automatic_result[i1][i2] + ); + } +}; + +int main(){ + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_left_shift_automatic_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_left_shift_automatic_constexpr.cpp new file mode 100644 index 00000000..9ca5b96e --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_left_shift_automatic_constexpr.cpp @@ -0,0 +1,52 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> +#include "test_left_shift_automatic_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; + +#include "test_left_shift_constexpr.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_left_shift_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + test_left_shift_automatic_result[i][j] + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly shifted to the left" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_left_shift_automatic_results.hpp b/src/boost/libs/safe_numerics/test/test_left_shift_automatic_results.hpp new file mode 100644 index 00000000..5923855e --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_left_shift_automatic_results.hpp @@ -0,0 +1,65 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_LEFT_SHIFT_AUTOMATIC_RESULTS_HPP +#define BOOST_SAFE_NUMERICS_TEST_LEFT_SHIFT_AUTOMATIC_RESULTS_HPP + +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_values.hpp" + +// note: same test matrix as used in test_checked. Here we test all combinations +// safe and unsafe integers. in test_checked we test all combinations of +// integer primitives + +constexpr const char *test_left_shift_automatic_result[ + boost::mp11::mp_size<test_values>::value +] = { +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/* 0*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/* 1*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/* 2*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/* 3*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/* 4*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/* 5*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/* 6*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/* 7*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", + +/* 8*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/* 9*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*10*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/*11*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/*12*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*13*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/*14*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/*15*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", + +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/*16*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*17*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*18*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*19*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*20*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*21*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*22*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*23*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", + +/*24*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*25*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*26*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*27*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*28*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*29*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*30*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/*31*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/*32*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx." +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_LEFT_SHIFT_AUTOMATIC_RESULTS_HPP + + diff --git a/src/boost/libs/safe_numerics/test/test_left_shift_constexpr.hpp b/src/boost/libs/safe_numerics/test/test_left_shift_constexpr.hpp new file mode 100644 index 00000000..defdb9a1 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_left_shift_constexpr.hpp @@ -0,0 +1,30 @@ +#ifndef BOOST_TEST_LEFT_SHIFT_CONSTEXPR_HPP +#define BOOST_TEST_LEFT_SHIFT_CONSTEXPR_HPP + +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> + +template<class T1, class T2> +constexpr bool test_left_shift_constexpr( + T1 v1, + T2 v2, + char expected_result +){ + using namespace boost::safe_numerics; + // if we don't expect the operation to pass, we can't + // check the constexpr version of the calculation so + // just return success. + if(expected_result == 'x') + return true; + safe_t<T1>(v1) << v2; + v1 << safe_t<T2>(v2); + safe_t<T1>(v1) << safe_t<T2>(v2); + return true; // correct result +} + +#endif // BOOST_TEST_LEFT_SHIFT_CONSTEXPR_HPP diff --git a/src/boost/libs/safe_numerics/test/test_left_shift_native.cpp b/src/boost/libs/safe_numerics/test/test_left_shift_native.cpp new file mode 100644 index 00000000..00c92d20 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_left_shift_native.cpp @@ -0,0 +1,62 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/native.hpp> +#include "test_left_shift_native_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; +#include "test_left_shift.hpp" + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_left_shift<T1, T2>( + mp_at_c<L, i1>()(), // value of first argument + mp_at_c<L, i2>()(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + test_left_shift_native_result[i1][i2] + ); + } +}; + +int main(){ + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_left_shift_native_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_left_shift_native_constexpr.cpp new file mode 100644 index 00000000..011ee37c --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_left_shift_native_constexpr.cpp @@ -0,0 +1,53 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/native.hpp> + +#include "test_left_shift_native_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; + +#include "test_left_shift_constexpr.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_left_shift_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + test_left_shift_native_result[i][j] + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly shifted to the left" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_left_shift_native_results.hpp b/src/boost/libs/safe_numerics/test/test_left_shift_native_results.hpp new file mode 100644 index 00000000..f1685bb0 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_left_shift_native_results.hpp @@ -0,0 +1,60 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_LEFT_SHIFT_NATIVE_RESULTS_HPP +#define BOOST_SAFE_NUMERICS_TEST_LEFT_SHIFT_NATIVE_RESULTS_HPP + +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_values.hpp" + +constexpr const char *test_left_shift_native_result[ + boost::mp11::mp_size<test_values>::value +] = { +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/* 0*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/* 1*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/* 2*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/* 3*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/* 4*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/* 5*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/* 6*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/* 7*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", + +/* 8*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/* 9*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/*10*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/*11*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/*12*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*13*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/*14*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/*15*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", + +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/*16*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*17*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*18*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*19*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*20*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*21*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*22*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*23*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", + +/*24*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*25*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*26*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/*27*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/*28*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*29*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*30*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/*31*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.", +/*32*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx." +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_LEFT_SHIFT_NATIVE_RESULTS_HPP + diff --git a/src/boost/libs/safe_numerics/test/test_less_than.hpp b/src/boost/libs/safe_numerics/test/test_less_than.hpp new file mode 100644 index 00000000..6460ad6a --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_less_than.hpp @@ -0,0 +1,163 @@ +// Copyright (c) 2015 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_TEST_LESS_THAN_HPP +#define BOOST_TEST_LESS_THAN_HPP + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/range_value.hpp> + +// works for both GCC and clang +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-value" + +template<class T1, class T2> +bool test_less_than( + T1 v1, + T2 v2, + const char *av1, + const char *av2, + char expected_result +){ + using namespace boost::safe_numerics; + std::cout << "testing"<< std::boolalpha << std::endl; + { + safe_t<T1> t1 = v1; + std::cout << "safe<" << av1 << "> < " << av2 << " -> "; + static_assert( + boost::safe_numerics::is_safe<safe_t<T1> >::value, + "safe_t not safe!" + ); + try{ + // use auto to avoid checking assignment. + auto result = t1 < v2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " < " << av2 + << " failed to detect error in less than" + << std::endl; + t1 < v2; + return false; + } + if(result != (expected_result == '<')){ + std::cout + << " ! = "<< av1 << " < " << av2 + << " produced the wrong answer" + << std::endl; + t1 < v2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result != 'x'){ + std::cout + << " == "<< av1 << " < " << av2 + << " erroneously detected error in less than" + << std::endl; + try{ + t1 < v2; + } + catch(const std::exception &){} + return false; + } + std::cout << std::endl; + } + } + { + safe_t<T2> t2 = v2; + std::cout << av1 << " < " << "safe<" << av2 << "> -> "; + static_assert( + boost::safe_numerics::is_safe<safe_t<T2> >::value, + "safe_t not safe!" + ); + try{ + // use auto to avoid checking assignment. + auto result = v1 < t2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " < " << av2 + << " failed to detect error in less than" + << std::endl; + v1 < t2; + return false; + } + if(result != (expected_result == '<')){ + std::cout + << " ! = "<< av1 << " < " << av2 + << " produced the wrong answer" + << std::endl; + v1 < t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result != 'x'){ + std::cout + << " == "<< av1 << " < " << av2 + << " erroneously detected error in less than" + << std::endl; + try{ + v1 < t2; + } + catch(const std::exception &){} + return false; + } + std::cout << std::endl; + } + } + { + safe_t<T1> t1 = v1; + safe_t<T2> t2 = v2; + std::cout << "safe<" << av1 << "> < " << "safe<" << av2 << "> -> "; + + try{ + // use auto to avoid checking assignment. + auto result = t1 < t2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " < " << av2 + << " failed to detect error in less than" + << std::endl; + t1 < t2; + return false; + } + if(result != (expected_result == '<')){ + std::cout + << " ! = "<< av1 << " < " << av2 + << " produced the wrong answer" + << std::endl; + t1 < t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " < " << av2 + << " erroneously detected error in less than" + << std::endl; + try{ + t1 < t2; + } + catch(const std::exception &){} + return false; + } + std::cout << std::endl; + } + } + return true; // correct result +} +#pragma GCC diagnostic pop + +#endif // BOOST_TEST_SUBTRACT diff --git a/src/boost/libs/safe_numerics/test/test_less_than_automatic.cpp b/src/boost/libs/safe_numerics/test/test_less_than_automatic.cpp new file mode 100644 index 00000000..a04f5fb7 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_less_than_automatic.cpp @@ -0,0 +1,61 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; +#include "test_less_than.hpp" + +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> +#include "test_compare_automatic.hpp" + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_less_than( + mp_at_c<L, i1>()(), // value of first argument + mp_at_c<L, i2>()(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + test_compare_automatic_result[i1][i2] + ); + } +}; + +int main(){ + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_less_than_automatic_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_less_than_automatic_constexpr.cpp new file mode 100644 index 00000000..3c5be46d --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_less_than_automatic_constexpr.cpp @@ -0,0 +1,52 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> +#include "test_compare_automatic.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; + +#include "test_less_than_constexpr.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_less_than_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + test_compare_automatic_result[i][j] + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly compared" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_less_than_constexpr.hpp b/src/boost/libs/safe_numerics/test/test_less_than_constexpr.hpp new file mode 100644 index 00000000..f3ecf588 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_less_than_constexpr.hpp @@ -0,0 +1,40 @@ +#ifndef BOOST_TEST_LESS_THAN_CONSTEXPR_HPP +#define BOOST_TEST_LESS_THAN_CONSTEXPR_HPP + +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/config.hpp> // BOOST_CLANG +#include <boost/safe_numerics/safe_integer.hpp> + +#if BOOST_CLANG==1 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-comparison" +#endif + +template<class T1, class T2> +constexpr bool test_less_than_constexpr( + T1 v1, + T2 v2, + char expected_result +){ + using namespace boost::safe_numerics; + // if we don't expect the operation to pass, we can't + // check the constexpr version of the calculation so + // just return success. + if(expected_result == 'x') + return true; + safe_t<T1>(v1) < v2; + v1 < safe_t<T2>(v2); + safe_t<T1>(v1) < safe_t<T2>(v2); + return true; // correct result +} + +#if BOOST_CLANG==1 +#pragma GCC diagnostic pop +#endif + +#endif // BOOST_TEST_LESS_THAN_CONSTEXPR_HPP diff --git a/src/boost/libs/safe_numerics/test/test_less_than_native.cpp b/src/boost/libs/safe_numerics/test/test_less_than_native.cpp new file mode 100644 index 00000000..8dccebfc --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_less_than_native.cpp @@ -0,0 +1,60 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; +#include "test_less_than.hpp" + +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> +#include "test_compare_native.hpp" + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_less_than<T1, T2>( + mp_at_c<L, i1>(), // value of first argument + mp_at_c<L, i2>(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + test_compare_native_result[i1][i2] + ); + } +}; + +int main(){ + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_less_than_native_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_less_than_native_constexpr.cpp new file mode 100644 index 00000000..dfdd1a04 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_less_than_native_constexpr.cpp @@ -0,0 +1,52 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/native.hpp> +#include "test_compare_native.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; + +#include "test_less_than_constexpr.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_less_than_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + test_compare_native_result[i][j] + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly compared" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_modulus.hpp b/src/boost/libs/safe_numerics/test/test_modulus.hpp new file mode 100644 index 00000000..cec70ae8 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_modulus.hpp @@ -0,0 +1,153 @@ +#ifndef BOOST_TEST_MODULUS_HPP +#define BOOST_TEST_MODULUS_HPP + +// Copyright (c) 2015 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/range_value.hpp> + +template<class T1, class T2> +bool test_modulus( + T1 v1, + T2 v2, + const char *av1, + const char *av2, + char expected_result +){ + std::cout << "testing"<< std::endl; + { + safe_t<T1> t1 = v1; + using result_type = decltype(t1 % v2); + std::cout << "safe<" << av1 << "> % " << av2 << " -> "; + static_assert( + boost::safe_numerics::is_safe<safe_t<T1> >::value, + "safe_t not safe!" + ); + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = t1 % v2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " % " << av2 + << " failed to detect error in modulus" + << std::endl; + t1 % v2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " % " << av2 + << " erroneously detected error in modulus" + << std::endl; + try{ + t1 % v2; + } + catch(const std::exception &){} + return false; + } + } + } + { + safe_t<T2> t2 = v2; + using result_type = decltype(v1 % t2); + std::cout << av1 << " % " << "safe<" << av2 << "> -> "; + static_assert( + boost::safe_numerics::is_safe<safe_t<T2> >::value, + "safe_t not safe!" + ); + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = v1 % t2; + std::cout << make_result_display(result); + if(expected_result =='x'){ + std::cout + << " ! = "<< av1 << " % " << av2 + << " failed to detect error in modulus" + << std::endl; + try{ + v1 % t2; + } + catch(const std::exception &){} + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result != 'x'){ + std::cout + << " == "<< av1 << " % " << av2 + << " erroneously detected error in modulus" + << std::endl; + try{ + v1 % t2; + } + catch(const std::exception &){} + return false; + } + } + } + { + safe_t<T1> t1 = v1; + safe_t<T2> t2 = v2; + using result_type = decltype(t1 + t2); + std::cout << "safe<" << av1 << "> % " << "safe<" << av2 << "> -> "; + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = t1 % t2; + std::cout << make_result_display(result); + if(expected_result != '.'){ + std::cout + << " ! = "<< av1 << " % " << av2 + << " failed to detect error in modulus" + << std::endl; + try{ + t1 % t2; + } + catch(const std::exception &){} + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result != 'x'){ + std::cout + << " == "<< av1 << " % " << av2 + << " erroneously detected error in modulus" + << std::endl; + try{ + t1 % t2; + } + catch(const std::exception &){} + return false; + } + } + } + return true; +} + +#endif // BOOST_TEST_MODULUS diff --git a/src/boost/libs/safe_numerics/test/test_modulus_automatic.cpp b/src/boost/libs/safe_numerics/test/test_modulus_automatic.cpp new file mode 100644 index 00000000..2fd5c378 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_modulus_automatic.cpp @@ -0,0 +1,62 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> +#include "test_modulus_automatic_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; +#include "test_modulus.hpp" + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_modulus<T1, T2>( + mp_at_c<L, i1>()(), // value of first argument + mp_at_c<L, i2>()(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + test_modulus_automatic_result[i1][i2] + ); + } +}; + +int main(){ + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_modulus_automatic_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_modulus_automatic_constexpr.cpp new file mode 100644 index 00000000..3bb90867 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_modulus_automatic_constexpr.cpp @@ -0,0 +1,52 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> +#include "test_modulus_automatic_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; + +#include "test_modulus_constexpr.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_modulus_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + test_modulus_automatic_result[i][j] + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly invoked modulus" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_modulus_automatic_results.hpp b/src/boost/libs/safe_numerics/test/test_modulus_automatic_results.hpp new file mode 100644 index 00000000..2530c78d --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_modulus_automatic_results.hpp @@ -0,0 +1,60 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_MODULUS_AUTOMATIC_RESULTS_HPP +#define BOOST_SAFE_NUMERICS_TEST_MODULUS_AUTOMATIC_RESULTS_HPP + +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_values.hpp" + +constexpr const char *test_modulus_automatic_result[ + boost::mp11::mp_size<test_values>::value +] = { +// 0 0 0 0 +// 012345670123456701234567012345672 +// 012345678901234567890123456789010 +/* 0*/ "..............................xxx", +/* 1*/ "..............................xxx", +/* 2*/ "..............................xxx", +/* 3*/ "..............................xxx", +/* 4*/ "..............................xxx", +/* 5*/ "..............................xxx", +/* 6*/ "..............................xxx", +/* 7*/ "..............................xxx", + +/* 8*/ "..............................xxx", +/* 9*/ "..............................xxx", +/*10*/ "..............................xxx", +/*11*/ "..............................xxx", +/*12*/ "..............................xxx", +/*13*/ "..............................xxx", +/*14*/ "..............................xxx", +/*15*/ "..............................xxx", + +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/*16*/ "................................x", +/*17*/ "................................x", +/*18*/ "................................x", +/*19*/ "................................x", +/*20*/ "................................x", +/*21*/ "................................x", +/*22*/ "................................x", +/*23*/ "................................x", + +/*24*/ "................................x", +/*25*/ "................................x", +/*26*/ "................................x", +/*27*/ "................................x", +/*28*/ "................................x", +/*29*/ "................................x", +/*30*/ "xxxxxxxxxxxxxxxx................x", +/*31*/ "xxxxxxxxxxxxxxxx................x", +/*32*/ "..............................xxx" +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_MODULUS_AUTOMATIC_RESULTS_HPP + diff --git a/src/boost/libs/safe_numerics/test/test_modulus_constexpr.hpp b/src/boost/libs/safe_numerics/test/test_modulus_constexpr.hpp new file mode 100644 index 00000000..8bf06589 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_modulus_constexpr.hpp @@ -0,0 +1,30 @@ +#ifndef BOOST_TEST_ADD_CONSTEXPR_HPP +#define BOOST_TEST_ADD_CONSTEXPR_HPP + +// Copyright (c) 2015 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> + +template<class T1, class T2> +constexpr bool test_modulus_constexpr( + T1 v1, + T2 v2, + char expected_result +){ + using namespace boost::safe_numerics; + // if we don't expect the operation to pass, we can't + // check the constexpr version of the calculation so + // just return success. + if(expected_result == 'x') + return true; + safe_t<T1>(v1) % v2; + v1 % safe_t<T2>(v2); + safe_t<T1>(v1) % safe_t<T2>(v2); + return true; // correct result +} + +#endif // BOOST_TEST_ADD_CONSTEXPR_HPP diff --git a/src/boost/libs/safe_numerics/test/test_modulus_native.cpp b/src/boost/libs/safe_numerics/test/test_modulus_native.cpp new file mode 100644 index 00000000..6484be1b --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_modulus_native.cpp @@ -0,0 +1,61 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include "test_modulus_native_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; +#include "test_modulus.hpp" + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_modulus<T1, T2>( + mp_at_c<L, i1>()(), // value of first argument + mp_at_c<L, i2>()(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + test_modulus_native_result[i1][i2] + ); + } +}; + +int main(){ + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_modulus_native_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_modulus_native_constexpr.cpp new file mode 100644 index 00000000..0f21db94 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_modulus_native_constexpr.cpp @@ -0,0 +1,52 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/native.hpp> +#include "test_modulus_native_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; + +#include "test_modulus_constexpr.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_modulus_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + test_modulus_native_result[i][j] + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly invoked modulus" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_modulus_native_results.hpp b/src/boost/libs/safe_numerics/test/test_modulus_native_results.hpp new file mode 100644 index 00000000..0cae9315 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_modulus_native_results.hpp @@ -0,0 +1,60 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_MODULUS_NATIVE_RESULTS_HPP +#define BOOST_SAFE_NUMERICS_TEST_MODULUS_NATIVE_RESULTS_HPP + +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_values.hpp" + +constexpr const char *test_modulus_native_result[ + boost::mp11::mp_size<test_values>::value +] = { +// 0 0 0 0 +// 012345670123456701234567012345672 +// 012345678901234567890123456789010 +/* 0*/ "................................x", +/* 1*/ "................................x", +/* 2*/ "........................xxxxxxxxx", +/* 3*/ "........................xxxxxxxxx", +/* 4*/ "................................x", +/* 5*/ "................................x", +/* 6*/ "........................xxxxxxxxx", +/* 7*/ "........................xxxxxxxxx", + +/* 8*/ "................................x", +/* 9*/ "................................x", +/*10*/ "........................xxxxxxxxx", +/*11*/ "........................xxxxxxxxx", +/*12*/ "................................x", +/*13*/ "................................x", +/*14*/ "............................xxxxx", +/*15*/ "............................xxxxx", + +// 0 0 0 0 +// 012345670123456701234567012345672 +// 012345678901234567890123456789010 +/*16*/ "................................x", +/*17*/ "................................x", +/*18*/ "................................x", +/*19*/ "................................x", +/*20*/ "................................x", +/*21*/ "................................x", +/*22*/ "................................x", +/*23*/ "................................x", + +/*24*/ "..xx..xx..xx....................x", +/*25*/ "..xx..xx..xx....................x", +/*26*/ "..xx..xx..xx....................x", +/*27*/ "..xx..xx..xx....................x", +/*28*/ "..xx..xx..xx..xx................x", +/*29*/ "..xx..xx..xx..xx................x", +/*30*/ "..xx..xx..xx..xx................x", +/*31*/ "..xx..xx..xx..xx................x", +/*32*/ "................................x" +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_MODULUS_NATIVE_RESULTS_HPP + diff --git a/src/boost/libs/safe_numerics/test/test_multiply.hpp b/src/boost/libs/safe_numerics/test/test_multiply.hpp new file mode 100644 index 00000000..fe44ab1f --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_multiply.hpp @@ -0,0 +1,151 @@ +#ifndef BOOST_TEST_MULTIPLY_HPP +#define BOOST_TEST_MULTIPLY_HPP + +// Copyright (c) 2015 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> +#include <boost/core/demangle.hpp> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/range_value.hpp> + +template<class T1, class T2> +bool test_multiply( + T1 v1, + T2 v2, + const char *av1, + const char *av2, + char expected_result +){ + std::cout << "testing"<< std::endl; + { + safe_t<T1> t1 = v1; + + using result_type = decltype(t1 * v2); + std::cout << "safe<" << av1 << "> * " << av2 << " -> "; + static_assert( + boost::safe_numerics::is_safe<safe_t<T1> >::value, + "safe_t not safe!" + ); + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = t1 * v2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + const std::type_info & ti = typeid(result); + std::cout + << " *** failed to detect error in multiplication" + << boost::core::demangle(ti.name()) + << std::endl; + t1 * v2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << " *** erroneously detected error in multiplication" + << std::endl; + try{ + t1 * v2; + } + catch(const std::exception &){} + return false; + } + } + } + { + safe_t<T2> t2 = v2; + using result_type = decltype(v1 * t2); + std::cout << av1 << " * " << "safe<" << av2 << "> -> "; + static_assert( + boost::safe_numerics::is_safe<safe_t<T2> >::value, + "safe_t not safe!" + ); + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = v1 * t2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + const std::type_info & ti = typeid(result); + std::cout + << " *** failed to detect error in multiplication" + << boost::core::demangle(ti.name()) + << std::endl; + v1 * t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << " *** erroneously detected error in multiplication" + << std::endl; + try{ + v1 * t2; + } + catch(const std::exception &){} + return false; + } + } + } + { + safe_t<T1> t1 = v1; + safe_t<T2> t2 = v2; + + using result_type = decltype(t1 * t2); + std::cout << "safe<" << av1 << "> * " << "safe<" << av2 << "> -> "; + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = t1 * t2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + const std::type_info & ti = typeid(result); + std::cout + << " *** failed to detect error in multiplication" + << boost::core::demangle(ti.name()) + << std::endl; + t1 * t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << " *** erroneously detected error in multiplication" + << std::endl; + try{ + t1 * t2; + } + catch(const std::exception &){} + return false; + } + } + } + return true; +} + + +#endif // BOOST_TEST_MULTIPLY diff --git a/src/boost/libs/safe_numerics/test/test_multiply_automatic.cpp b/src/boost/libs/safe_numerics/test/test_multiply_automatic.cpp new file mode 100644 index 00000000..4d47d9f7 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_multiply_automatic.cpp @@ -0,0 +1,68 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> +#include "test_multiply_automatic_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; +#include "test_multiply.hpp" + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_multiply( + mp_at_c<L, i1>()(), // value of first argument + mp_at_c<L, i2>()(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + test_multiplication_automatic_result[i1][i2] + ); + } +}; + +#include "check_symmetry.hpp" + +int main(){ + // sanity check on test matrix - should be symetrical + check_symmetry(test_multiplication_automatic_result); + + //TEST_EACH_VALUE_PAIR + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_multiply_automatic_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_multiply_automatic_constexpr.cpp new file mode 100644 index 00000000..0b9ce06d --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_multiply_automatic_constexpr.cpp @@ -0,0 +1,56 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> +#include "test_multiply_automatic_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; + +#include "test_multiply_constexpr.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_multiply_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + test_multiplication_automatic_result[i][j] + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include "check_symmetry.hpp" + +int main(){ + using namespace boost::mp11; + + // sanity check on test matrix - should be symetrical + check_symmetry(test_multiplication_automatic_result); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly multiplied" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_multiply_automatic_results.hpp b/src/boost/libs/safe_numerics/test/test_multiply_automatic_results.hpp new file mode 100644 index 00000000..97279840 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_multiply_automatic_results.hpp @@ -0,0 +1,59 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_MULTIPLY_AUTOMATIC_RESULTS_HPP +#define BOOST_SAFE_NUMERICS_TEST_MULTIPLY_AUTOMATIC_RESULTS_HPP + +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_values.hpp" + +constexpr const char *test_multiplication_automatic_result[ + boost::mp11::mp_size<test_values>::value +] = { +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/* 0*/ "..............................xx.", +/* 1*/ ".............xx..............xxx.", +/* 2*/ ".............xx..............xxx.", +/* 3*/ "..............x...............xx.", +/* 4*/ "..............................xx.", +/* 5*/ ".............xx..............xxx.", +/* 6*/ ".............xx..............xxx.", +/* 7*/ "..............x...............xx.", + +/* 8*/ "..............................xx.", +/* 9*/ ".............xx..............xxx.", +/*10*/ ".............xx..............xxx.", +/*11*/ "..............x...............xx.", +/*12*/ "..............................xx.", +/*13*/ ".xx..xx..xx..xx..xxx.xxx.xxx.xxx.", +/*14*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*15*/ "..............x...............xx.", + +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/*16*/ ".................................", +/*17*/ ".............xx..............xxx.", +/*18*/ ".............xx..............xxx.", +/*19*/ ".............xx..............xxx.", +/*20*/ ".................................", +/*21*/ ".............xx..............xxx.", +/*22*/ ".............xx..............xxx.", +/*23*/ ".............xx..............xxx.", + +/*24*/ ".................................", +/*25*/ ".............xx..............xxx.", +/*26*/ ".............xx..............xxx.", +/*27*/ ".............xx..............xxx.", +/*28*/ ".................................", +/*29*/ ".xx..xx..xx..xx..xxx.xxx.xxx.xxx.", +/*30*/ "xxxxxxxxxxxxxxxx.xxx.xxx.xxx.xxxx", +/*31*/ "xxxxxxxxxxxxxxxx.xxx.xxx.xxx.xxxx", +/*32*/ "..............................xx." +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_MULTIPLY_AUTOMATIC_RESULTS_HPP diff --git a/src/boost/libs/safe_numerics/test/test_multiply_constexpr.hpp b/src/boost/libs/safe_numerics/test/test_multiply_constexpr.hpp new file mode 100644 index 00000000..2fe107df --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_multiply_constexpr.hpp @@ -0,0 +1,30 @@ +#ifndef BOOST_TEST_MULTIPLY_CONSTEXPR_HPP +#define BOOST_TEST_MULTIPLY_CONSTEXPR_HPP + +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> + +template<class T1, class T2> +constexpr bool test_multiply_constexpr( + T1 v1, + T2 v2, + char expected_result +){ + using namespace boost::safe_numerics; + // if we don't expect the operation to pass, we can't + // check the constexpr version of the calculation so + // just return success. + if(expected_result == 'x') + return true; + safe_t<T1>(v1) * v2; + v1 * safe_t<T2>(v2); + safe_t<T1>(v1) * safe_t<T2>(v2); + return true; // correct result +} + +#endif // BOOST_TEST_MULTIPLY_CONSTEXPR_HPP diff --git a/src/boost/libs/safe_numerics/test/test_multiply_native.cpp b/src/boost/libs/safe_numerics/test/test_multiply_native.cpp new file mode 100644 index 00000000..8e4cc585 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_multiply_native.cpp @@ -0,0 +1,66 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include "test_multiply_native_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; +#include "test_multiply.hpp" + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_multiply<T1, T2>( + mp_at_c<L, i1>()(), // value of first argument + mp_at_c<L, i2>()(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + test_multiplication_native_result[i1][i2] + ); + } +}; + +#include "check_symmetry.hpp" + +int main(){ + // sanity check on test matrix - should be symetrical + check_symmetry(test_multiplication_native_result); + //TEST_EACH_VALUE_PAIR + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_multiply_native_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_multiply_native_constexpr.cpp new file mode 100644 index 00000000..2773bc7a --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_multiply_native_constexpr.cpp @@ -0,0 +1,56 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/native.hpp> +#include "test_multiply_native_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; + +#include "test_multiply_constexpr.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_multiply_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + test_multiplication_native_result[i][j] + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include "check_symmetry.hpp" + +int main(){ + using namespace boost::mp11; + + // sanity check on test matrix - should be symetrical + check_symmetry(test_multiplication_native_result); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly multiplied" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_multiply_native_results.hpp b/src/boost/libs/safe_numerics/test/test_multiply_native_results.hpp new file mode 100644 index 00000000..888a00c5 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_multiply_native_results.hpp @@ -0,0 +1,48 @@ +#include "test_values.hpp" + +constexpr const char *test_multiplication_native_result[ + boost::mp11::mp_size<test_values>::value +] = { +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/* 0*/ ".................................", +/* 1*/ ".........xx..xx..........xxx.xxx.", +/* 2*/ ".........xx..xx.........xxxxxxxx.", +/* 3*/ "..........x...x.........xxxxxxxx.", +/* 4*/ ".................................", +/* 5*/ ".........xx..xx..........xxx.xxx.", +/* 6*/ ".........xx..xx.........xxxxxxxx.", +/* 7*/ "..........x...x.........xxxxxxxx.", + +/* 8*/ ".................................", +/* 9*/ ".xx..xx..xx..xx..xxx.xxx.xxx.xxx.", +/*10*/ ".xxx.xxx.xxx.xx..xxx.xxxxxxxxxxx.", +/*11*/ "..........x...x.........xxxxxxxx.", +/*12*/ ".................................", +/*13*/ ".xx..xx..xx..xx..xxx.xxx.xxx.xxx.", +/*14*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxxxxxx.", +/*15*/ "..............x.............xxxx.", + +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/*16*/ ".................................", +/*17*/ ".........xx..xx..........xxx.xxx.", +/*18*/ ".........xx..xx..........xxx.xxx.", +/*19*/ ".........xx..xx..........xxx.xxx.", +/*20*/ ".................................", +/*21*/ ".........xx..xx..........xxx.xxx.", +/*22*/ ".........xx..xx..........xxx.xxx.", +/*23*/ ".........xx..xx........x.xxx.xxx.", + +/*24*/ "..xx..xx..xx.....................", +/*25*/ ".xxx.xxx.xxx.xx..xxx.xxx.xxx.xxx.", +/*26*/ ".xxx.xxx.xxx.xx..xxx.xxx.xxx.xxx.", +/*27*/ ".xxx.xxx.xxx.xx..xxx.xxx.xxx.xxx.", +/*28*/ "..xx..xx..xx..xx.................", +/*29*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*30*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*31*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*31*/ "................................." +}; diff --git a/src/boost/libs/safe_numerics/test/test_notepad.hpp b/src/boost/libs/safe_numerics/test/test_notepad.hpp new file mode 100644 index 00000000..d2204a63 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_notepad.hpp @@ -0,0 +1,12 @@ +// this is a hack to workaround the limititation of template +// expansion depth in the MSVC compiler. +template<class L, class F> +BOOST_MP11_CONSTEXPR mp_if_c<mp_size<L>::value <= 1024, F> mp_for_each_1( F && f ){ + return detail::mp_for_each_impl( mp_rename<L, mp_list>(), std::forward<F>(f) ); +} +template<class L, class F> +BOOST_MP11_CONSTEXPR mp_if_c<mp_size<L>::value >= 1025, F> mp_for_each_1( F && f ){ + mp_for_each<mp_take_c<L, 1024>>( std::forward<F>(f) ); + return mp_for_each_1<mp_drop_c<L, 1024>>( std::forward<F>(f) ); +} + diff --git a/src/boost/libs/safe_numerics/test/test_or.hpp b/src/boost/libs/safe_numerics/test/test_or.hpp new file mode 100644 index 00000000..f3eb16c3 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_or.hpp @@ -0,0 +1,147 @@ +#ifndef BOOST_TEST_OR_HPP +#define BOOST_TEST_OR_HPP + +// Copyright (c) 2015 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/range_value.hpp> + +template<class T1, class T2> +bool test_or( + T1 v1, + T2 v2, + const char *av1, + const char *av2, + char expected_result +){ + std::cout << "testing"<< std::endl; + { + safe_t<T1> t1 = v1; + using result_type = decltype(t1 | v2); + std::cout << "safe<" << av1 << "> | " << av2 << " -> "; + static_assert( + boost::safe_numerics::is_safe<safe_t<T1> >::value, + "safe_t not safe!" + ); + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = t1 | v2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " | " << av2 + << " failed to detect error in bitwise or" + << std::endl; + t1 | v2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << " != "<< av1 << " | " << av2 + << " erroneously detected error in bitwise or" + << std::endl; + try{ + t1 | v2; + } + catch(const std::exception &){} + return false; + } + } + } + { + safe_t<T2> t2 = v2; + using result_type = decltype(v1 | t2); + std::cout << av1 << " | " << "safe<" << av2 << "> -> "; + static_assert( + boost::safe_numerics::is_safe<safe_t<T2> >::value, + "safe_t not safe!" + ); + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = v1 | t2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " | " << av2 + << " failed to detect error in bitwise or" + << std::endl; + v1 | t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " | " << av2 + << " erroneously detected error in bitwise or" + << std::endl; + try{ + v1 | t2; + } + catch(const std::exception &){} + return false; + } + } + } + { + safe_t<T1> t1 = v1; + safe_t<T2> t2 = v2; + using result_type = decltype(t1 | t2); + std::cout << "safe<" << av1 << "> | " << "safe<" << av2 << "> -> "; + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = t1 | t2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " | " << av2 + << " failed to detect error in bitwise or" + << std::endl; + t1 | t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " | " << av2 + << " erroneously detected error in bitwise or" + << std::endl; + try{ + t1 | t2; + } + catch(const std::exception &){} + return false; + } + } + } + return true; // correct result +} + +#endif // BOOST_TEST_DIVIDE diff --git a/src/boost/libs/safe_numerics/test/test_or_automatic.cpp b/src/boost/libs/safe_numerics/test/test_or_automatic.cpp new file mode 100644 index 00000000..f8139ee1 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_or_automatic.cpp @@ -0,0 +1,62 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; +#include "test_or.hpp" + +#include "test_values.hpp" +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_or( + mp_at_c<L, i1>()(), // value of first argument + mp_at_c<L, i2>()(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + '.' + ); + } +}; + +int main(){ + //TEST_EACH_VALUE_PAIR + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_or_automatic_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_or_automatic_constexpr.cpp new file mode 100644 index 00000000..20c7a48c --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_or_automatic_constexpr.cpp @@ -0,0 +1,53 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; + +#include "test_or_constexpr.hpp" + +#include "test_values.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_or_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + '.' + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly or'ed" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_or_constexpr.hpp b/src/boost/libs/safe_numerics/test/test_or_constexpr.hpp new file mode 100644 index 00000000..20844ce4 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_or_constexpr.hpp @@ -0,0 +1,30 @@ +#ifndef BOOST_TEST_ADD_CONSTEXPR_HPP +#define BOOST_TEST_ADD_CONSTEXPR_HPP + +// Copyright (c) 2015 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> + +template<class T1, class T2> +constexpr bool test_or_constexpr( + T1 v1, + T2 v2, + char expected_result +){ + using namespace boost::safe_numerics; + // if we don't expect the operation to pass, we can't + // check the constexpr version of the calculation so + // just return success. + if(expected_result == 'x') + return true; + safe_t<T1>(v1) | v2; + v1 | safe_t<T2>(v2); + safe_t<T1>(v1) | safe_t<T2>(v2); + return true; // correct result +} + +#endif // BOOST_TEST_ADD_CONSTEXPR_HPP diff --git a/src/boost/libs/safe_numerics/test/test_or_native.cpp b/src/boost/libs/safe_numerics/test/test_or_native.cpp new file mode 100644 index 00000000..92ec26e7 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_or_native.cpp @@ -0,0 +1,62 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; +#include "test_or.hpp" +#include "test_values.hpp" + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_or<T1, T2>( + mp_at_c<L, i1>(), // value of first argument + mp_at_c<L, i2>(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + '.' + ); + } +}; + +int main(){ + //TEST_EACH_VALUE_PAIR + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_or_native_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_or_native_constexpr.cpp new file mode 100644 index 00000000..d83034a7 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_or_native_constexpr.cpp @@ -0,0 +1,53 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/native.hpp> + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; + +#include "test_or_constexpr.hpp" + +#include "test_values.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_or_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + '.' + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly or'ed" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_performance.cpp b/src/boost/libs/safe_numerics/test/test_performance.cpp new file mode 100644 index 00000000..364a7671 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_performance.cpp @@ -0,0 +1,112 @@ +// test performance.cpp : Defines the entry point for the console application. +// + +#include <cstdio> +#include <cstdint> +#include <iostream> +#include <chrono> +#include <boost/multiprecision/cpp_int.hpp> +#include <boost/multiprecision/integer.hpp> + +#include <boost/safe_numerics/safe_integer.hpp> + +typedef boost::safe_numerics::safe<unsigned> safe_type; + +namespace boost { +namespace multiprecision { + + template <class Integer, class I2> + typename enable_if_c<boost::safe_numerics::is_safe<Integer>::value, Integer&>::type + multiply(Integer& result, const I2& a, const I2& b){ + return result = static_cast<Integer>(a) * static_cast<Integer>(b); + } + + template <class Integer> + typename enable_if_c<boost::safe_numerics::is_safe<Integer>::value, bool>::type + bit_test(const Integer& val, unsigned index){ + Integer mask = 1; + if (index >= sizeof(Integer) * CHAR_BIT) + return 0; + if (index) + mask <<= index; + return val & mask ? true : false; + } + + template <class I1, class I2> + typename enable_if_c<boost::safe_numerics::is_safe<I1>::value, I2>::type + integer_modulus(const I1& x, I2 val){ + return x % val; + } + + namespace detail { + template <class T> struct double_integer; + + template <> + struct double_integer<safe_type>{ + using type = boost::safe_numerics::safe<std::uint64_t>; + }; + } + + template <class I1, class I2, class I3> + typename enable_if_c<boost::safe_numerics::is_safe<I1>::value, I1>::type + powm(const I1& a, I2 b, I3 c){ + typedef typename detail::double_integer<I1>::type double_type; + + I1 x(1), y(a); + double_type result; + + while (b > 0){ + if (b & 1){ + multiply(result, x, y); + x = integer_modulus(result, c); + } + multiply(result, y, y); + y = integer_modulus(result, c); + b >>= 1; + } + return x % c; + } + + template <class T, class PP, class EP> + inline unsigned + lsb(const boost::safe_numerics::safe<T, PP, EP>& x){ + return lsb(static_cast<T>(x)); + } + +} } + +#include <boost/multiprecision/miller_rabin.hpp> + +template <class Clock> +class stopwatch +{ + const typename Clock::time_point m_start; +public: + stopwatch() : + m_start(Clock::now()) + {} + typename Clock::duration elapsed() const { + return Clock::now() - m_start; + } +}; + +template<typename T> +void test(const char * msg){ + const stopwatch<std::chrono::high_resolution_clock> c; + + unsigned count = 0; + for (T i = 3; i < 30000000; ++i) + if (boost::multiprecision::miller_rabin_test(i, 25)) ++count; + + std::chrono::duration<double> time = c.elapsed(); + std::cout<< msg << ":\ntime = " << time.count(); + std::cout << "\ncount = " << count << std::endl; +} + +int main() +{ + test<unsigned>("Testing type unsigned"); + test<boost::safe_numerics::safe<unsigned>>("Testing type safe<unsigned>"); + return 0; +} + diff --git a/src/boost/libs/safe_numerics/test/test_range.cpp b/src/boost/libs/safe_numerics/test/test_range.cpp new file mode 100644 index 00000000..930b38ed --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_range.cpp @@ -0,0 +1,96 @@ +#include <iostream> +#include <cassert> +#include <limits> + +#include <boost/safe_numerics/utility.hpp> +#include <boost/safe_numerics/safe_integer_range.hpp> + +template<typename T> +void display_log(T Max){ + std::cout + << "ilog2(" << Max << ") = " + << boost::safe_numerics::utility::ilog2(Max) << std::endl; +} + +bool test_significant_bits(){ + using namespace boost::safe_numerics; + assert(utility::significant_bits(127u) == 7); // 7 bits + assert(utility::significant_bits(127u) == 7); // 7 bits + assert(utility::significant_bits(128u) == 8); // 8 bits + assert(utility::significant_bits(129u) == 8); // 8 bits + assert(utility::significant_bits(255u) == 8); // 8 bits + assert(utility::significant_bits(256u) == 9); // 9 bits + return true; +} + +bool test1(){ + using namespace boost::safe_numerics; + using t2 = safe_unsigned_range<0u, 1000u>; + static_assert( + std::numeric_limits<t2>::is_signed == false, + "this range should be unsigned" + ); + return true; +} + +#include <boost/safe_numerics/automatic.hpp> + +template < + std::intmax_t Min, + std::intmax_t Max +> +using safe_t = boost::safe_numerics::safe_signed_range< + Min, + Max, + boost::safe_numerics::automatic, + boost::safe_numerics::default_exception_policy +>; + +bool test2(){ + std::cout << "test1" << std::endl; + try{ + const safe_t<-64, 63> x(1); + safe_t<-64, 63> y; + y = 2; + std::cout << "x = " << x << std::endl; + std::cout << "y = " << y << std::endl; + auto z = x + y; + std::cout << "x + y = [" + << std::numeric_limits<decltype(z)>::min() << "," + << std::numeric_limits<decltype(z)>::max() << "] = " + << z << std::endl; + + auto z2 = x - y; + std::cout << "x - y = [" + << std::numeric_limits<decltype(z2)>::min() << "," + << std::numeric_limits<decltype(z2)>::max() << "] = " + << z2 << std::endl; + + short int yi, zi; + yi = y; + zi = x + yi; + } + catch(const std::exception & e){ + // none of the above should trap. Mark failure if they do + std::cout << e.what() << std::endl; + return false; + } + return true; +} + +int main(){ + //using namespace boost::safe_numerics; + //safe_signed_literal2<100> one_hundred; + //one_hundred = 200; + + bool rval = + test_significant_bits() && + test1() && + test2() /* && + test3() && + test4() + */ + ; + std::cout << (rval ? "success!" : "failure") << std::endl; + return rval ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/src/boost/libs/safe_numerics/test/test_rational.cpp b/src/boost/libs/safe_numerics/test/test_rational.cpp new file mode 100644 index 00000000..8e60bf57 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_rational.cpp @@ -0,0 +1,109 @@ +////////////////////////////////////////////////////////////////// +// example94.cpp +// +// Copyright (c) 2015 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// illustrate usage of safe<int> as drop-in replacement for int in +// a more complex library. Use an example from the boost.rational +// library with modifications to use safe<int> rather than int + +// rational number example program ----------------------------------------// + +// (C) Copyright Paul Moore 1999. Permission to copy, use, modify, sell +// and distribute this software is granted provided this copyright notice +// appears in all copies. This software is provided "as is" without express or +// implied warranty, and with no claim as to its suitability for any purpose. + +// boostinspect:nolicense (don't complain about the lack of a Boost license) +// (Paul Moore hasn't been in contact for years, so there's no way to change the +// license.) + +// Revision History +// 14 Dec 99 Initial version + +#include <iostream> +#include <cassert> +#include <cstdlib> +#include <boost/config.hpp> +#include <limits> +#include <exception> +#include <boost/rational.hpp> + +#include <boost/safe_numerics/safe_integer.hpp> + +using std::cout; +using std::endl; +using boost::rational; +using namespace boost::safe_numerics; + +using int_type = safe<int>; + +int main () +{ + rational<int_type> half(1,2); + rational<int_type> one(1); + rational<int_type> two(2); + + // Some basic checks + assert(half.numerator() == 1); + assert(half.denominator() == 2); +// assert(boost::rational_cast<double>(half) == 0.5); + + static_assert( + ! boost::safe_numerics::is_safe<rational<int_type>>::value, + "rational<int_type> is safe" + ); + + // Arithmetic + assert(half + half == one); + assert(one - half == half); + assert(two * half == one); + assert(one / half == two); + + // With conversions to integer + assert(half+half == 1); + assert(2 * half == one); + assert(2 * half == 1); + assert(one / half == 2); + assert(1 / half == 2); + + // Sign handling + rational<int_type> minus_half(-1,2); + assert(-half == minus_half); + assert(abs(minus_half) == half); + + // Do we avoid overflow? + int maxint = (std::numeric_limits<int>::max)(); + rational<int_type> big(maxint, 2); + assert(2 * big == maxint); + + // Print some of the above results + cout << half << "+" << half << "=" << one << endl; + cout << one << "-" << half << "=" << half << endl; + cout << two << "*" << half << "=" << one << endl; + cout << one << "/" << half << "=" << two << endl; + cout << "abs(" << minus_half << ")=" << half << endl; + cout << "2 * " << big << "=" << maxint + << " (rational: " << rational<int>(maxint) << ")" << endl; + + // Some extras +// rational<int_type> pi(22,7); +// cout << "pi = " << boost::rational_cast<double>(pi) << " (nearly)" << endl; + + // Exception handling + try { + rational<int_type> r; // Forgot to initialise - set to 0 + r = 1/r; // Boom! + } + catch (const boost::bad_rational &e) { + cout << "Bad rational, as expected: " << e.what() << endl; + } + catch (...) { + cout << "Wrong exception raised!" << endl; + } + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_right_shift.hpp b/src/boost/libs/safe_numerics/test/test_right_shift.hpp new file mode 100644 index 00000000..8b46df4a --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_right_shift.hpp @@ -0,0 +1,149 @@ +#ifndef BOOST_TEST_RIGHT_SHIFT_HPP +#define BOOST_TEST_RIGHT_SHIFT_HPP + +// Copyright (c) 2015 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/range_value.hpp> + +template<class T1, class T2> +bool test_right_shift( + T1 v1, + T2 v2, + const char *av1, + const char *av2, + char expected_result +){ + std::cout + << "testing " + << av1 << " >> " << av2 + << std::endl; + { + safe_t<T1> t1 = v1; + using result_type = decltype(t1 >> v2); + std::cout << "safe<" << av1 << "> << " << av2 << " -> "; + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = t1 >> v2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " >> " << av2 + << " failed to detect error in right shift" + << std::endl; + t1 >> v2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception & e){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " >> " << av2 + << " erroneously detected error in right shift" + << ' ' << e.what() + << std::endl; + try{ + t1 >> v2; + } + catch(const std::exception &){} + return false; + } + std::cout << std::endl; + } + } + { + safe_t<T2> t2 = v2; + using result_type = decltype(v1 >> t2); + std::cout << av1 << " >> " << "safe<" << av2 << "> -> "; + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = v1 >> t2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " >> " << av2 + << " failed to detect error in right shift" + << std::hex << result << "(" << std::dec << result << ")" + << std::endl; + v1 >> t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception & e){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " >> " << av2 + << " erroneously detected error in right shift" + << ' ' << e.what() + << std::endl; + try{ + v1 >> t2; + } + catch(const std::exception &){} + return false; + } + std::cout << std::endl; + } + } + { + safe_t<T1> t1 = v1; + safe_t<T2> t2 = v2; + using result_type = decltype(t1 >> t2); + std::cout << "safe<" << av1 << "> >> " << "safe<" << av2 << "> -> "; + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = t1 >> t2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " << " << av2 + << " failed to detect error in right shift" + << std::endl; + t1 >> t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception & e){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " << " << av2 + << " erroneously detected error in right shift" + << ' ' << e.what() + << std::endl; + try{ + t1 >> t2; + } + catch(const std::exception &){} + return false; + } + std::cout << std::endl; + } + } + return true; // correct result +} + +#endif // BOOST_TEST_RIGHT_SHIFT_HPP diff --git a/src/boost/libs/safe_numerics/test/test_right_shift_automatic.cpp b/src/boost/libs/safe_numerics/test/test_right_shift_automatic.cpp new file mode 100644 index 00000000..1087f364 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_right_shift_automatic.cpp @@ -0,0 +1,63 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> +#include "test_right_shift_automatic_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; +#include "test_right_shift.hpp" + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_right_shift<T1, T2>( + mp_at_c<L, i1>()(), // value of first argument + mp_at_c<L, i2>()(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + test_right_shift_automatic_result[i1][i2] + ); + } +}; + +int main(){ + //TEST_EACH_VALUE_PAIR + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_right_shift_automatic_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_right_shift_automatic_constexpr.cpp new file mode 100644 index 00000000..05a66434 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_right_shift_automatic_constexpr.cpp @@ -0,0 +1,52 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> +#include "test_right_shift_automatic_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; + +#include "test_right_shift_constexpr.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_right_shift_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + test_right_shift_automatic_result[i][j] + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly right shifted" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_right_shift_automatic_results.hpp b/src/boost/libs/safe_numerics/test/test_right_shift_automatic_results.hpp new file mode 100644 index 00000000..26dc8ab7 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_right_shift_automatic_results.hpp @@ -0,0 +1,60 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_RIGHT_SHIFT_AUTOMATIC_RESULTS_HPP +#define BOOST_SAFE_NUMERICS_TEST_RIGHT_SHIFT_AUTOMATIC_RESULTS_HPP + +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_values.hpp" + +constexpr const char *test_right_shift_automatic_result[ + boost::mp11::mp_size<test_values>::value +] = { +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/* 0*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/* 1*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/* 2*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", +/* 3*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", +/* 4*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/* 5*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/* 6*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", +/* 7*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", + +/* 8*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/* 9*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*10*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", +/*11*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", +/*12*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*13*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*14*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", +/*15*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", + +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/*16*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*17*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*18*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*19*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*20*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*21*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*22*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*23*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", + +/*24*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*25*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*26*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*27*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*28*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*29*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*30*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*31*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*32*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx." +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_RIGHT_SHIFT_AUTOMATIC_RESULTS_HPP + diff --git a/src/boost/libs/safe_numerics/test/test_right_shift_constexpr.hpp b/src/boost/libs/safe_numerics/test/test_right_shift_constexpr.hpp new file mode 100644 index 00000000..c4e2bab2 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_right_shift_constexpr.hpp @@ -0,0 +1,30 @@ +#ifndef BOOST_TEST_RIGHT_SHIFT_CONSTEXPR_HPP +#define BOOST_TEST_RIGHT_SHIFT_CONSTEXPR_HPP + +// Copyright (c) 2015 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> + +template<class T1, class T2> +constexpr bool test_right_shift_constexpr( + T1 v1, + T2 v2, + char expected_result +){ + using namespace boost::safe_numerics; + // if we don't expect the operation to pass, we can't + // check the constexpr version of the calculation so + // just return success. + if(expected_result == 'x') + return true; + safe_t<T1>(v1) >> v2; + v1 >> safe_t<T2>(v2); + safe_t<T1>(v1) >> safe_t<T2>(v2); + return true; // correct result +} + +#endif // BOOST_TEST_RIGHT_SHIFT_CONSTEXPR_HPP diff --git a/src/boost/libs/safe_numerics/test/test_right_shift_native.cpp b/src/boost/libs/safe_numerics/test/test_right_shift_native.cpp new file mode 100644 index 00000000..f7c8b311 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_right_shift_native.cpp @@ -0,0 +1,62 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include "test_right_shift_native_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; +#include "test_right_shift.hpp" + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_right_shift<T1, T2>( + mp_at_c<L, i1>(), // value of first argument + mp_at_c<L, i2>(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + test_right_shift_native_result[i1][i2] + ); + } +}; + +int main(){ + //TEST_EACH_VALUE_PAIR + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_right_shift_native_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_right_shift_native_constexpr.cpp new file mode 100644 index 00000000..59496354 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_right_shift_native_constexpr.cpp @@ -0,0 +1,52 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/native.hpp> +#include "test_right_shift_native_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; + +#include "test_right_shift_constexpr.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_right_shift_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + test_right_shift_native_result[i][j] + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly right shifted" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_right_shift_native_results.hpp b/src/boost/libs/safe_numerics/test/test_right_shift_native_results.hpp new file mode 100644 index 00000000..c299aa04 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_right_shift_native_results.hpp @@ -0,0 +1,59 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_RIGHT_SHIFT_NATIVE_RESULTS_HPP +#define BOOST_SAFE_NUMERICS_TEST_RIGHT_SHIFT_NATIVE_RESULTS_HPP + +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_values.hpp" + +constexpr const char *test_right_shift_native_result[ + boost::mp11::mp_size<test_values>::value +] = { +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/* 0*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/* 1*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/* 2*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", +/* 3*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", +/* 4*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/* 5*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/* 6*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", +/* 7*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", + +/* 8*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/* 9*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*10*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", +/*11*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", +/*12*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*13*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*14*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", +/*15*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", + +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/*16*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*17*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*18*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*19*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*20*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*21*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*22*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*23*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", + +/*24*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*25*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*26*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*27*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*28*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*29*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*30*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*31*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*32*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx." +}; + +#endif // BOOST_SAFE_NUMERICS_TEST_RIGHT_SHIFT_NATIVE_RESULTS_HPP diff --git a/src/boost/libs/safe_numerics/test/test_safe_compare.cpp b/src/boost/libs/safe_numerics/test/test_safe_compare.cpp new file mode 100644 index 00000000..41190566 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_safe_compare.cpp @@ -0,0 +1,165 @@ +// Copyright (c) 2014 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/core/demangle.hpp> +#include <boost/safe_numerics/safe_compare.hpp> + +template<class T1, class T2> +void print_argument_types( + T1 v1, + T2 v2 +){ + const std::type_info & ti1 = typeid(v1); + const std::type_info & ti2 = typeid(v2); + + std::cout + << boost::core::demangle(ti1.name()) << ',' + << boost::core::demangle(ti2.name()); +} + +#include <boost/mp11/algorithm.hpp> + +using namespace boost::safe_numerics; + +template<class T1, class T2> +bool test_safe_compare_impl( + T1 v1, + T2 v2, + char expected_result +){ + switch(expected_result){ + case '=': { + if(! safe_compare::equal(v1, v2)) + return false; + if(safe_compare::less_than(v1, v2)) + return false; + if(safe_compare::greater_than(v1, v2)) + return false; + break; + } + case '<': { + if(! safe_compare::less_than(v1, v2)) + return false; + if(safe_compare::greater_than(v1, v2)) + return false; + if(safe_compare::equal(v1, v2)) + return false; + break; + } + case '>':{ + if(! safe_compare::greater_than(v1, v2)) + return false; + if(safe_compare::less_than(v1, v2)) + return false; + if(safe_compare::equal(v1, v2)) + return false; + break; + } + } + return true; +} + +template<class T1, class T2> +bool test_safe_compare( + T1 v1, + T2 v2, + char expected_result +){ + print_argument_types(v1, v2); + const bool result = test_safe_compare_impl(v1, v2, expected_result); + if(! result) + std::cout << " failed"; + std::cout << '\n'; + return result; +} + +#include "test_values.hpp" + +const char *test_compare_result[boost::mp11::mp_size<test_values>::value] = { +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/* 0*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<<<>", +/* 1*/ ">=>>><>>><>>><>>>=<<><<<><<<><<<>", +/* 2*/ "<<=<<<><<<><<<><<<<<<<<<<<<<<<<<<", +/* 3*/ "<<>=<<>=<<>=<<>=<<<<<<<<<<<<<<<<<", +/* 4*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<<<>", +/* 5*/ ">>>>>=>>><>>><>>>>>>>=<<><<<><<<>", +/* 6*/ "<<<<<<=<<<><<<><<<<<<<<<<<<<<<<<<", +/* 7*/ "<<>=<<>=<<>=<<>=<<<<<<<<<<<<<<<<<", + +/* 8*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<<<>", +/* 9*/ ">>>>>>>>>=>>><>>>>>>>>>>>=<<><<<>", +/*10*/ "<<<<<<<<<<=<<<><<<<<<<<<<<<<<<<<<", +/*11*/ "<<>=<<>=<<>=<<>=<<<<<<<<<<<<<<<<<", +/*12*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<<<>", +/*13*/ ">>>>>>>>>>>>>=>>>>>>>>>>>>>>>=<<>", +/*14*/ "<<<<<<<<<<<<<<=<<<<<<<<<<<<<<<<<<", +/*15*/ "<<>=<<>=<<>=<<>=<<<<<<<<<<<<<<<<", + +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/*16*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<<<>", +/*17*/ ">=>>><>>><>>><>>>=<<><<<><<<><<<>", +/*18*/ ">>>>><>>><>>><>>>>=<><<<><<<><<<>", +/*19*/ ">>>>><>>><>>><>>>>>=><<<><<<><<<>", +/*20*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<<<>", +/*21*/ ">>>>>=>>><>>><>>>>>>>=<<><<<><<<>", +/*22*/ ">>>>>>>>><>>><>>>>>>>>=<><<<><<<>", +/*23*/ ">>>>>>>>><>>><>>>>>>>>>=><<<><<<>", + +/*24*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<<<>", +/*25*/ ">>>>>>>>>=>>><>>>>>>>>>>>=<<><<<>", +/*26*/ ">>>>>>>>>>>>><>>>>>>>>>>>>=<><<<>", +/*27*/ ">>>>>>>>>>>>><>>>>>>>>>>>>>=><<<>", +/*28*/ "=<>>=<>>=<>>=<>>=<<<=<<<=<<<=<<<>", +/*29*/ ">>>>>>>>>>>>>=>>>>>>>>>>>>>>>=<<>", +/*30*/ ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>=<>", +/*31*/ ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>=>", +/*32*/ "<<>><<>><<>><<>><<<<<<<<<<<<<<<<=" +}; + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename boost::mp11::mp_at_c<L, i1>::value_type; + using T2 = typename boost::mp11::mp_at_c<L, i2>::value_type; + m_error &= test_safe_compare<T1, T2>( + boost::mp11::mp_at_c<L, i1>(), // value of first argument + boost::mp11::mp_at_c<L, i2>(), // value of second argument + test_compare_result[i1][i2] + ); + } +}; + +int main(){ + //TEST_EACH_VALUE_PAIR + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_subtract.hpp b/src/boost/libs/safe_numerics/test/test_subtract.hpp new file mode 100644 index 00000000..832d49e2 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_subtract.hpp @@ -0,0 +1,146 @@ +#ifndef BOOST_TEST_SUBTRACT_HPP +#define BOOST_TEST_SUBTRACT_HPP + +// Copyright (c) 2015 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/range_value.hpp> + +template<class T1, class T2> +bool test_subtract( + T1 v1, + T2 v2, + const char *av1, + const char *av2, + char expected_result +){ + std::cout << "testing"<< std::endl; + { + safe_t<T1> t1 = v1; + using result_type = decltype(t1 - v2); + std::cout << "safe<" << av1 << "> - " << av2 << " -> "; + static_assert( + boost::safe_numerics::is_safe<safe_t<T1> >::value, + "safe_t not safe!" + ); + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = t1 - v2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " - " << av2 + << " failed to detect error in subtraction " + << std::endl; + t1 - v2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " - " << av2 + << " erroneously detected error in subtraction " + << std::endl; + try{ + t1 - v2; + } + catch(const std::exception &){} + return false; + } + } + } + { + safe_t<T2> t2 = v2; + using result_type = decltype(v1 - t2); + std::cout << av1 << " - " << "safe<" << av2 << "> -> "; + static_assert( + boost::safe_numerics::is_safe<safe_t<T2> >::value, + "safe_t not safe!" + ); + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = v1 - t2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " - " << av2 + << " failed to detect error in subtraction " + << std::endl; + v1 - t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " - " << av2 + << " erroneously detected error in subtraction " + << std::endl; + try{ + v1 - t2; + } + catch(const std::exception &){} + return false; + } + } + } + { + safe_t<T1> t1 = v1; + safe_t<T2> t2 = v2; + using result_type = decltype(t1 - t2); + std::cout << "safe<" << av1 << "> - " << "safe<" << av2 << "> -> "; + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + try{ + // use auto to avoid checking assignment. + auto result = t1 - t2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " - " << av2 + << " failed to detect error in subtraction " + << std::endl; + t1 - t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " - " << av2 + << "erroneously detected error in subtraction " + << std::endl; + try{ + t1 - t2; + } + catch(const std::exception &){} + return false; + } + } + } + return true; // correct result +} + +#endif // BOOST_TEST_SUBTRACT diff --git a/src/boost/libs/safe_numerics/test/test_subtract_automatic.cpp b/src/boost/libs/safe_numerics/test/test_subtract_automatic.cpp new file mode 100644 index 00000000..dadd15d0 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_subtract_automatic.cpp @@ -0,0 +1,64 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> +#include "test_subtract_automatic_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; + +#include "test_subtract.hpp" + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_subtract<T1, T2>( + mp_at_c<L, i1>(), // value of first argument + mp_at_c<L, i2>(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + test_subtraction_automatic_result[i1][i2] + ); + } +}; + +int main(){ + //TEST_EACH_VALUE_PAIR + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_subtract_automatic_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_subtract_automatic_constexpr.cpp new file mode 100644 index 00000000..bef25dae --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_subtract_automatic_constexpr.cpp @@ -0,0 +1,52 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> +#include "test_subtract_automatic_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; + +#include "test_subtract_constexpr.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_subtract_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + test_subtraction_automatic_result[i][j] + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly subtracted" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_subtract_automatic_results.hpp b/src/boost/libs/safe_numerics/test/test_subtract_automatic_results.hpp new file mode 100644 index 00000000..afa59e40 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_subtract_automatic_results.hpp @@ -0,0 +1,65 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_ADD_AUTOMATIC_RESULTS_HPP +#define BOOST_SAFE_NUMERICS_TEST_ADD_AUTOMATIC_RESULTS_HPP + +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "test_values.hpp" + +// note: same test matrix as used in test_checked. Here we test all combinations +// safe and unsafe integers. in test_checked we test all combinations of +// integer primitives + +constexpr const char *test_subtraction_automatic_result[ + boost::mp11::mp_size<test_values>::value +] = { +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/* 0*/ "..............x...............xx.", +/* 1*/ "..............x...............xx.", +/* 2*/ ".............x...............xxx.", +/* 3*/ "..............................xx.", +/* 4*/ "..............x...............xx.", +/* 5*/ "..............x...............xx.", +/* 6*/ ".............x...............xxx.", +/* 7*/ "..............................xx.", + +/* 8*/ "..............x...............xx.", +/* 9*/ "..............x...............xx.", +/*10*/ ".............x...............xxx.", +/*11*/ "..............................xx.", +/*12*/ "..............x...............xx.", +/*13*/ "..xx..xx..xx..xx..............xx.", +/*14*/ "xx..xx..xx..xx..xxxxxxxxxxxxxxxx.", +/*15*/ "..............................xx.", + +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/*16*/ "..............x...............xx.", +/*17*/ "..............x...............xx.", +/*18*/ "..............x...............xx.", +/*19*/ "..............x...............xx.", +/*20*/ "..............x...............xx.", +/*21*/ "..............x...............xx.", +/*22*/ "..............x...............xx.", +/*23*/ "..............x...............xx.", + +/*24*/ "..............x...............xx.", +/*25*/ "..............x...............xx.", +/*26*/ "..............x...............xx.", +/*27*/ "..............x...............xx.", +/*28*/ "..............x...............xx.", +/*29*/ "..xx..xx..xx..xx..............xx.", +/*30*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", +/*31*/ "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", +/*32*/ "..............x...............xx." +}; + + +#endif + diff --git a/src/boost/libs/safe_numerics/test/test_subtract_constexpr.hpp b/src/boost/libs/safe_numerics/test/test_subtract_constexpr.hpp new file mode 100644 index 00000000..a82c171e --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_subtract_constexpr.hpp @@ -0,0 +1,30 @@ +#ifndef BOOST_TEST_SUBTRACT_CONSTEXPR_HPP +#define BOOST_TEST_SUBTRACT_CONSTEXPR_HPP + +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> + +template<class T1, class T2> +constexpr bool test_subtract_constexpr( + T1 v1, + T2 v2, + char expected_result +){ + using namespace boost::safe_numerics; + // if we don't expect the operation to pass, we can't + // check the constexpr version of the calculation so + // just return success. + if(expected_result == 'x') + return true; + safe_t<T1>(v1) - v2; + v1 - safe_t<T2>(v2); + safe_t<T1>(v1) - safe_t<T2>(v2); + return true; // correct result +} + +#endif // BOOST_TEST_SUBTRACT_CONSTEXPR_HPP diff --git a/src/boost/libs/safe_numerics/test/test_subtract_native.cpp b/src/boost/libs/safe_numerics/test/test_subtract_native.cpp new file mode 100644 index 00000000..2f622a81 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_subtract_native.cpp @@ -0,0 +1,65 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> +#include "test_subtract_native_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; +#include "test_subtract.hpp" + +using namespace boost::mp11; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_subtract( + boost::mp11::mp_at_c<L, i1>()(), // value of first argument + boost::mp11::mp_at_c<L, i2>()(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + test_subtraction_native_result[i1][i2] + ); + } +}; + +int main(){ + //TEST_EACH_VALUE_PAIR + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_subtract_native_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_subtract_native_constexpr.cpp new file mode 100644 index 00000000..3d8eae63 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_subtract_native_constexpr.cpp @@ -0,0 +1,53 @@ +// Copyright (c) 2019Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/native.hpp> + +#include "test_subtract_native_results.hpp" + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; + +#include "test_subtract_constexpr.hpp" + +using namespace boost::mp11; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_subtract_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + test_subtraction_native_result[i][j] + ); +}; + +int main(){ + using namespace boost::mp11; + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly subtracted" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_subtract_native_results.hpp b/src/boost/libs/safe_numerics/test/test_subtract_native_results.hpp new file mode 100644 index 00000000..030b6278 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_subtract_native_results.hpp @@ -0,0 +1,48 @@ +#include "test_values.hpp" + +constexpr const char *test_subtraction_native_result[ + boost::mp11::mp_size<test_values>::value +] = { +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/* 0*/ "..........x...x..........xxx.xxx.", +/* 1*/ "..........x...x..........xxx.xxx.", +/* 2*/ ".........x...x..........xxxxxxxx.", +/* 3*/ "........................xxxxxxxx.", +/* 4*/ "..........x...x..........xxx.xxx.", +/* 5*/ "..........x...x..........xxx.xxx.", +/* 6*/ ".........x...x..........xxxxxxxx.", +/* 7*/ "........................xxxxxxxx.", + +/* 8*/ "..........x...x..........xxx.xxx.", +/* 9*/ "..xx..xx..xx..x...........xx.xxx.", +/*10*/ "xx..xx..xx...x..xxxxxxxxxxxxxxxx.", +/*11*/ "........................xxxxxxxx.", +/*12*/ "..............x..............xxx.", +/*13*/ "..xx..xx..xx..xx..............xx.", +/*14*/ "xx..xx..xx..xx..xxxxxxxxxxxxxxxx.", +/*15*/ "............................xxxx.", + +// 0 0 0 0 +// 012345670123456701234567012345670 +// 012345678901234567890123456789012 +/*16*/ "..........x...x..........xxx.xxx.", +/*17*/ "..........x...x..........xxx.xxx.", +/*18*/ "..........x...x..........xxx.xxx.", +/*19*/ "..........x...x..........xxx.xxx.", +/*20*/ "..........x...x..........xxx.xxx.", +/*21*/ "..........x...x..........xxx.xxx.", +/*22*/ "..........x...x..........xxx.xxx.", +/*23*/ "..........x...x..........xxx.xxx.", + +/*24*/ ".xxx.xxx.xxx..x..xxx.xxx.xxx.xxx.", +/*25*/ "..xx..xx..xx..x...........xx.xxx.", +/*26*/ "..xx..xx..xx..x............x.xxx.", +/*27*/ "..xx..xx..xx..x..............xxx.", +/*28*/ ".xxx.xxx.xxx.xxx.xxx.xxx.xxx.xxx.", +/*29*/ "..xx..xx..xx..xx..............xx.", +/*30*/ "..xx..xx..xx..xx...............x.", +/*31*/ "..xx..xx..xx..xx.................", +/*32*/ "..........x...x.........xxxxxxxx." +}; diff --git a/src/boost/libs/safe_numerics/test/test_trap.cpp b/src/boost/libs/safe_numerics/test/test_trap.cpp new file mode 100644 index 00000000..fa067f46 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_trap.cpp @@ -0,0 +1,44 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// testing trap + +// this is a compile only test - but since many build systems +// can't handle a compile-only test - make sure it passes trivially. + +#include <boost/safe_numerics/exception_policies.hpp> +#include <boost/safe_numerics/safe_integer.hpp> + +using namespace boost::safe_numerics; +template <typename T> // T is char, int, etc data type +using safe_t = safe< + T, + native, + loose_trap_policy // use for compiling and running tests +>; + +template<typename T, typename U> +void test(){ + safe_t<T> t; + safe_t<U> u; + t + u; + t - u; + t * u; + t / u; // could fail regardless of data type + t % u; // could fail regardless of data type + t << u; + t >> u; + t | u; + t & u; + t ^ u; +} +int main(int, char *[]){ + test<std::int8_t, std::int8_t>(); // should compile + test<std::int16_t, std::int16_t>(); // should compile + test<std::int32_t, std::int32_t>(); // should fail to compile + test<std::int64_t, std::int64_t>(); // should fail to compile + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_values.hpp b/src/boost/libs/safe_numerics/test/test_values.hpp new file mode 100644 index 00000000..de533611 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_values.hpp @@ -0,0 +1,71 @@ +#ifndef BOOST_SAFE_NUMERICS_TEST_VALUES_HPP +#define BOOST_SAFE_NUMERICS_TEST_VALUES_HPP + +// test_values.hpp +// +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <cstdint> +#include <type_traits> // integral_constant +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> + +#define TEST_VALUE(type, value) std::integral_constant<type,(type)value> + +using test_values = boost::mp11::mp_list< + TEST_VALUE(std::int8_t,0x01), + TEST_VALUE(std::int8_t,0x7f), + TEST_VALUE(std::int8_t,0x80), + TEST_VALUE(std::int8_t,0xff), + TEST_VALUE(std::int16_t,0x0001), + TEST_VALUE(std::int16_t,0x7fff), + TEST_VALUE(std::int16_t,0x8000), + TEST_VALUE(std::int16_t,0xffff), + TEST_VALUE(std::int32_t,0x00000001), + TEST_VALUE(std::int32_t,0x7fffffff), + TEST_VALUE(std::int32_t,0x80000000), + TEST_VALUE(std::int32_t,0xffffffff), + TEST_VALUE(std::int64_t,0x0000000000000001), + TEST_VALUE(std::int64_t,0x7fffffffffffffff), + TEST_VALUE(std::int64_t,0x8000000000000000), + TEST_VALUE(std::int64_t,0xffffffffffffffff), + TEST_VALUE(std::uint8_t,0x01), + TEST_VALUE(std::uint8_t,0x7f), + TEST_VALUE(std::uint8_t,0x80), + TEST_VALUE(std::uint8_t,0xff), + TEST_VALUE(std::uint16_t,0x0001), + TEST_VALUE(std::uint16_t,0x7fff), + TEST_VALUE(std::uint16_t,0x8000), + TEST_VALUE(std::uint16_t,0xffff), + TEST_VALUE(std::uint32_t,0x00000001), + TEST_VALUE(std::uint32_t,0x7fffffff), + TEST_VALUE(std::uint32_t,0x80000000), + TEST_VALUE(std::uint32_t,0xffffffff), + TEST_VALUE(std::uint64_t,0x0000000000000001), + TEST_VALUE(std::uint64_t,0x7fffffffffffffff), + TEST_VALUE(std::uint64_t,0x8000000000000000), + TEST_VALUE(std::uint64_t,0xffffffffffffffff), + TEST_VALUE(std::int8_t,0x0) // uh oh - breaks test_types +>; + +/* +template<typename T> +using extract_value_type = typename T::value_type; +using test_types = boost::mp11:: mp_unique< + boost::mp11::mp_transform< + extract_value_type, + test_values + > +>; +*/ + +using test_types = boost::mp11::mp_list< + std::int8_t, std::int16_t, std::int32_t, std::int64_t, + std::uint8_t, std::uint16_t, std::uint32_t, std::uint64_t +>; + +#endif diff --git a/src/boost/libs/safe_numerics/test/test_xor.hpp b/src/boost/libs/safe_numerics/test/test_xor.hpp new file mode 100644 index 00000000..4788d475 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_xor.hpp @@ -0,0 +1,176 @@ +#ifndef BOOST_TEST_XOR_HPP +#define BOOST_TEST_XOR_HPP + +// Copyright (c) 2015 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> +#include <iosfwd> + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/range_value.hpp> + +template<class T1, class T2> +bool test_xor( + T1 v1, + T2 v2, + const char *av1, + const char *av2, + char expected_result +){ + std::cout << "testing"<< std::endl; + { + safe_t<T1> t1 = v1; + using result_type = decltype(t1 ^ v2); + std::cout << "safe<" << av1 << "> ^ " << av2 << " -> "; + static_assert( + boost::safe_numerics::is_safe<safe_t<T1> >::value, + "safe_t not safe!" + ); + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = t1 ^ v2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " ^ " << av2 + << " failed to detect error in xor operation" + << std::endl; + t1 ^ v2; + return false; + } + else + if(result != (v1 ^ v2)){ + std::cout + << " ! = "<< av1 << " ^ " << av2 + << " incorrect result in xor operation" + << std::endl; + t1 ^ v2; + boost::safe_numerics::safe_compare::equal(base_value(result), (v1 ^ v2)); + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " ^ " << av2 + << " erroneously detected error in xor operation" + << std::endl; + try{ + t1 ^ v2; + } + catch(const std::exception &){} + return false; + } + } + } + { + safe_t<T2> t2 = v2; + using result_type = decltype(v1 ^ t2); + std::cout << av1 << " ^ " << "safe<" << av2 << "> -> "; + static_assert( + boost::safe_numerics::is_safe<safe_t<T2> >::value, + "safe_t not safe!" + ); + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = v1 ^ t2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " ^ " << av2 + << " failed to detect error in and operation" + << std::endl; + v1 ^ t2; + return false; + } + else + if(result != (v1 ^ v2)){ + std::cout + << " ! = "<< av1 << " ^ " << av2 + << " incorrect result in xor operation" + << std::endl; + v1 ^ t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " ^ " << av2 + << " erroneously detected error in and operation" + << std::endl; + try{ + v1 ^ t2; + } + catch(const std::exception &){} + return false; + } + } + } + { + safe_t<T1> t1 = v1; + safe_t<T2> t2 = v2; + using result_type = decltype(t1 ^ t2); + std::cout << "safe<" << av1 << "> ^ " << "safe<" << av2 << "> -> "; + static_assert( + boost::safe_numerics::is_safe<result_type>::value, + "Expression failed to return safe type" + ); + + try{ + // use auto to avoid checking assignment. + auto result = t1 ^ t2; + std::cout << make_result_display(result); + if(expected_result == 'x'){ + std::cout + << " ! = "<< av1 << " ^ " << av2 + << " failed to detect error in and operation" + << std::endl; + t1 ^ t2; + return false; + } + else + if(result != (v1 ^ v2)){ + std::cout + << " ! = "<< av1 << " ^ " << av2 + << " incorrect result in xor operation" + << std::endl; + t1 ^ t2; + return false; + } + std::cout << std::endl; + } + catch(const std::exception &){ + if(expected_result == '.'){ + std::cout + << " == "<< av1 << " ^ " << av2 + << " erroneously detected error in and operation" + << std::endl; + try{ + t1 ^ t2; + } + catch(const std::exception &){} + return false; + } + } + } + return true; // correct result +} + +#endif // BOOST_TEST_XOR_HPP diff --git a/src/boost/libs/safe_numerics/test/test_xor_automatic.cpp b/src/boost/libs/safe_numerics/test/test_xor_automatic.cpp new file mode 100644 index 00000000..4777f358 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_xor_automatic.cpp @@ -0,0 +1,60 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; +#include "test_xor.hpp" +#include "test_values.hpp" + +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_xor<T1, T2>( + mp_at_c<L, i1>()(), // value of first argument + mp_at_c<L, i2>()(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + '.' + ); + } +}; + +int main(){ + //TEST_EACH_VALUE_PAIR + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_xor_automatic_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_xor_automatic_constexpr.cpp new file mode 100644 index 00000000..4a8038f3 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_xor_automatic_constexpr.cpp @@ -0,0 +1,52 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::automatic +>; + +#include "test_xor_constexpr.hpp" +#include "test_values.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_xor_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + '.' + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> + +int main(){ + using namespace boost::mp11; + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly xor'ed" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_xor_constexpr.hpp b/src/boost/libs/safe_numerics/test/test_xor_constexpr.hpp new file mode 100644 index 00000000..c6cfb65c --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_xor_constexpr.hpp @@ -0,0 +1,30 @@ +#ifndef BOOST_TEST_XOR_CONSTEXPR_HPP +#define BOOST_TEST_XOR_CONSTEXPR_HPP + +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> + +template<class T1, class T2> +constexpr bool test_xor_constexpr( + T1 v1, + T2 v2, + char expected_result +){ + using namespace boost::safe_numerics; + // if we don't expect the operation to pass, we can't + // check the constexpr version of the calculation so + // just return success. + if(expected_result == 'x') + return true; + safe_t<T1>(v1) ^ v2; + v1 ^ safe_t<T2>(v2); + safe_t<T1>(v1) ^ safe_t<T2>(v2); + return true; // correct result +} + +#endif // BOOST_TEST_XOR_CONSTEXPR_HPP diff --git a/src/boost/libs/safe_numerics/test/test_xor_native.cpp b/src/boost/libs/safe_numerics/test/test_xor_native.cpp new file mode 100644 index 00000000..10288f14 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_xor_native.cpp @@ -0,0 +1,61 @@ +// Copyright (c) 2012 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> + +#include <boost/safe_numerics/safe_integer.hpp> + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; +#include "test_xor.hpp" +#include "test_values.hpp" + +#include <boost/mp11/algorithm.hpp> +#include <boost/core/demangle.hpp> + +using namespace boost::mp11; + +template<typename L> +struct test { + static_assert(mp_is_list<L>(), "must be a list of integral constants"); + bool m_error; + test(bool b = true) : m_error(b) {} + operator bool(){ + return m_error; + } + template<typename T> + void operator()(const T &){ + static_assert(mp_is_list<T>(), "must be a list of two integral constants"); + constexpr size_t i1 = mp_first<T>(); // index of first argument + constexpr size_t i2 = mp_second<T>();// index of second argument + std::cout << i1 << ',' << i2 << ','; + using T1 = typename mp_at_c<L, i1>::value_type; + using T2 = typename mp_at_c<L, i2>::value_type; + m_error &= test_xor<T1, T2>( + mp_at_c<L, i1>(), // value of first argument + mp_at_c<L, i2>(), // value of second argument + boost::core::demangle(typeid(T1).name()).c_str(), + boost::core::demangle(typeid(T2).name()).c_str(), + '.' + ); + } +}; + +int main(){ + //TEST_EACH_VALUE_PAIR + test<test_values> rval(true); + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + mp_for_each< + mp_product<mp_list, value_indices, value_indices> + >(rval); + + std::cout << (rval ? "success!" : "failure") << std::endl; + return ! rval ; +} diff --git a/src/boost/libs/safe_numerics/test/test_xor_native_constexpr.cpp b/src/boost/libs/safe_numerics/test/test_xor_native_constexpr.cpp new file mode 100644 index 00000000..7ad71d81 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_xor_native_constexpr.cpp @@ -0,0 +1,53 @@ +// Copyright (c) 2019 Robert Ramey +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/native.hpp> + +template <class T> +using safe_t = boost::safe_numerics::safe< + T, + boost::safe_numerics::native +>; + +#include "test_xor_constexpr.hpp" +#include "test_values.hpp" + +using namespace boost::mp11; + +template<typename First, typename Second> +struct test_pair { + static const std::size_t i = First(); + static const std::size_t j = Second(); + constexpr static const bool value = test_xor_constexpr( + mp_at_c<test_values, i>()(), + mp_at_c<test_values, j>()(), + '.' + ); +}; + +#include <boost/mp11/list.hpp> +#include <boost/mp11/algorithm.hpp> +#include "check_symmetry.hpp" + +int main(){ + using namespace boost::mp11; + + using value_indices = mp_iota_c<mp_size<test_values>::value>; + + static_assert( + mp_all_of< + mp_product< + test_pair, + value_indices, + value_indices + >, + mp_to_bool + >(), + "all values for all integer types correctly xor'ed" + ); + return 0; +} diff --git a/src/boost/libs/safe_numerics/test/test_z.cpp b/src/boost/libs/safe_numerics/test/test_z.cpp new file mode 100644 index 00000000..795ed4f8 --- /dev/null +++ b/src/boost/libs/safe_numerics/test/test_z.cpp @@ -0,0 +1,758 @@ + +#if 0 +auto val() +{ + return -0xFFFFFFFF; +} + +#include <stdexcept> +#include <iostream> +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/safe_integer_literal.hpp> + +void val0(){ + const boost::safe_numerics::safe<unsigned int> x{0}; + std::cout << x << std::endl; + std::cout << -x << std::endl; + auto y = -x; + std::cout << y << std::endl; +} + +constexpr boost::safe_numerics::safe<unsigned int> val1() +{ + constexpr boost::safe_numerics::safe<unsigned int> x = 0xFFFFFFFF; + return -x; +} +constexpr boost::safe_numerics::safe<unsigned int> val2() +{ + boost::safe_numerics::safe<unsigned int> x = - boost::safe_numerics::safe_unsigned_literal<0xFFFFFFFF>(); + return x; +} + +constexpr boost::safe_numerics::safe<unsigned int> val3() +{ + return - boost::safe_numerics::safe_unsigned_literal<0xFFFFFFFF>(); +} + +int main(){ + val0(); + std::cout << val1() << std::endl; + std::cout << val2() << std::endl; + std::cout << val3() << std::endl; + return 0; +} + +// test utility +#include <boost/safe_numerics/utility.hpp> + +int main(){ + using namespace boost::safe_numerics; + using x = unsigned_stored_type<0, 42>; + print_type<x> p1; + + return 0; +} + +// test automatic type promotion +#include <boost/safe_numerics/automatic.hpp> +#include <boost/safe_numerics/safe_integer.hpp> +#include <type_traits> +#include <cstdint> +#include <iostream> + +int main(){ + using namespace boost::safe_numerics; + using ar = automatic::addition_result<std::uint8_t, std::uint8_t>; + static_assert( + std::is_same<ar::type, std::uint16_t>::value, + "sum of two 8 bit unsigned integers should fit in on 16 bit unsigned integer" + ); + return 0; +} + + +// test automatic type promotion +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/safe_integer_range.hpp> +#include <boost/safe_numerics/safe_integer_literal.hpp> +#include <boost/safe_numerics/automatic.hpp> +#include <type_traits> +#include <cstdint> +#include <iostream> + +int main(){ + using namespace boost::safe_numerics; + unsigned char t1 = 1; + constexpr const safe_unsigned_literal<42, automatic, default_exception_policy> v2; + using result_type = decltype(t1 + v2); + + static_assert( + std::is_same< + result_type, + safe_unsigned_range<42, 297, automatic, default_exception_policy> + >::value, + "result type should have a range 42-297" + ); + return 0; +} +void f1(){ + using namespace boost::safe_numerics; + constexpr safe<int> j = 0; + constexpr safe<int> k = 3; + constexpr safe<int> l = j + k; // compile error +} + +void f2(){ + using namespace boost::safe_numerics; + constexpr safe<int> j = boost::safe_numerics::safe_signed_literal<0>(); + constexpr safe<int> k = boost::safe_numerics::safe_signed_literal<3>(); + constexpr safe<int> l = j + k; // compile error +} + +void f3(){ + using namespace boost::safe_numerics; + constexpr auto j = safe_signed_literal<0, native, loose_trap_policy>(); + constexpr auto k = safe_signed_literal<3>(); + constexpr const safe<int> l = j + k; +} + +void f4(){ + using namespace boost::safe_numerics; + safe_signed_literal<0, native, loose_trap_policy> j; + safe_signed_literal<3> k; + constexpr auto l = safe_signed_literal<3>(); + constexpr const safe<int> l2 = j + k; +} + +#include <boost/safe_numerics/interval.hpp> + +int main(){ + return 0; +} + +#include <boost/safe_numerics/utility.hpp> +#include <boost/safe_numerics/cpp.hpp> +#include <boost/safe_numerics/safe_common.hpp> + +using pic16_promotion = boost::safe_numerics::cpp< + 8, // char + 8, // short + 8, // int + 16, // long + 32 // long long +>; + +#include <type_traits> +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/range_value.hpp> +#include <iostream> + +int main(){ + using namespace boost::safe_numerics; + static_assert( + std::is_literal_type<safe<int>>::value, + "safe type is a literal type" + ); + static_assert( + std::is_literal_type<interval<int>>::value, + "interval type is a literal type" + ); + static_assert( + std::is_literal_type<interval< + safe<int> + >>::value, + "interval of safe types is a literal type" + ); + static_assert( + std::is_literal_type<range_value< + safe<int> + >>::value, + "range_value of safe types is a literal type" + ); + safe<int> x = 42; + std::cout << make_range_value(x); + return 0; +} + +auto val() +{ + return -0xFFFFFFFF; +} + +#include <stdexcept> +#include <iostream> +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/safe_integer_literal.hpp> + +void val0(){ + const boost::safe_numerics::safe<unsigned int> x{0}; + std::cout << x << std::endl; + std::cout << -x << std::endl; + auto y = -x; + std::cout << y << std::endl; +} + +constexpr boost::safe_numerics::safe<unsigned int> val1(){ + constexpr boost::safe_numerics::safe<unsigned int> x = 0xFFFFFFFF; + return -x; +} +constexpr boost::safe_numerics::safe<unsigned int> val2(){ + const boost::safe_numerics::safe<unsigned int> x + = -boost::safe_numerics::safe_unsigned_literal<0xFFFFFFFF>(); + return x; +} +constexpr boost::safe_numerics::safe<unsigned int> val3(){ + return - boost::safe_numerics::safe_unsigned_literal<0xFFFFFFFF>(); +} + +int main(){ + val0(); + std::cout << val1() << std::endl; + std::cout << val2() << std::endl; + std::cout << val3() << std::endl; + return 0; +} + +#include <boost/logic/tribool.hpp> +#include <boost/safe_integer/checked_integer.hpp> +#include <boost/safe_integer/checked_result.hpp> +#include <boost/safe_integer/checked_result_operations.hpp> +#include <boost/safe_integer/interval.hpp> + +namespace boost { +namespace safe_numerics { + +template<class EP, typename R> +constexpr void +dispatch(const checked_result<R> & cr){ +} + +template<class T> +constexpr T base_value(const T & t){ + return t; +} + +template<typename R, R Min, R Max, typename T, typename E> +struct validate_detail { + + constexpr static const interval<checked_result<R>> t_interval{ + checked::cast<R>(base_value(std::numeric_limits<T>::min())), + checked::cast<R>(base_value(std::numeric_limits<T>::max())) + }; + constexpr static const interval<checked_result<R>> r_interval{Min, Max}; + +/* + static_assert( + ! static_cast<bool>(r_interval.excludes(t_interval)), + "ranges don't overlap: can't cast" + ); +*/ + + struct exception_possible { + constexpr static R return_value( + const T & t + ){ + static_assert( + ! static_cast<bool>(r_interval.includes(t_interval)), + "exeption not possible" + ); + // INT08-C + const checked_result<R> r = checked::cast<R>(t); + dispatch<E>(r); + return base_value(r); + } + }; + struct exception_not_possible { + constexpr static R return_value( + const T & t + ){ + static_assert( + static_cast<bool>(r_interval.includes(t_interval)), + "exeption not possible" + ); + return static_cast<R>(t); + } + }; + + static R return_value(const T & t){ + return std::conditional< + static_cast<bool>(r_interval.includes(t_interval)), + exception_not_possible, + exception_possible + >::type::return_value(t); + } +}; + +template<typename R, R Min, R Max, typename T> +bool test1(const T & t){ + const interval<checked_result<R>> t_interval{ + checked::cast<R>(base_value(std::numeric_limits<T>::min())), + checked::cast<R>(base_value(std::numeric_limits<T>::max())) + }; + const interval<checked_result<R>> r_interval{Min, Max}; + +/* + static_assert( + ! static_cast<bool>(r_interval.excludes(t_interval)), + "ranges don't overlap: can't cast" + ); +*/ + const boost::logic::tribool tb1 = r_interval.includes(t_interval); + const bool x1 = tb1; + + const boost::logic::tribool tb2 = r_interval.excludes(t_interval); + const bool x2 = tb2; + return x2; +} + + +} // safe_numerics +} // boost + +int main(){ + unsigned int x1 = boost::safe_numerics::test1< + unsigned int, 0, 100, signed char + >(-1); + bool x2 = boost::safe_numerics::validate_detail< + unsigned int, 0, 100, signed char, void + >::return_value(-1); + return 0; +} + +using uint8_t = unsigned char; + +enum class safe_numerics_error : uint8_t { + success = 0, + failure, // result is above representational maximum + error_count +}; + +template<typename R> +struct checked_result { + const safe_numerics_error m_e; + const union { + const R m_r; + char const * const m_msg; + }; + constexpr /*explicit*/ checked_result(const R & r) : + m_e(safe_numerics_error::success), + m_r(r) + {} + constexpr /*explicit*/ checked_result(const safe_numerics_error & e) : + m_e(e), + m_msg("") + {} +}; + +// integers addition +template<class T> +constexpr inline checked_result<T> operator+( + const checked_result<T> & t, + const checked_result<T> & u +){ +#if 1 // compile fails + constexpr const safe_numerics_error x[2][2]{ + // t == success + { + // u == ... + safe_numerics_error::success, + safe_numerics_error::failure + }, + // t == positive_overflow_error, + { + // u == ... + safe_numerics_error::success, + safe_numerics_error::failure + } + }; + + // "Constexpr variable 'e' must be initialized by a constant expression" + constexpr const safe_numerics_error e = x + [static_cast<uint8_t>(t.m_e)] + [static_cast<uint8_t>(u.m_e)] + ; + + return + safe_numerics_error::success == e + ? t.m_r + u.m_r + : checked_result<T>(e) + ; +#else // works as expected + constexpr const safe_numerics_error x[2][2]{ + // t == success + { + // u == ... + safe_numerics_error::success, + safe_numerics_error::failure + }, + // t == failure, + { + // u == ... + safe_numerics_error::failure, + safe_numerics_error::failure + } + }; + + return + safe_numerics_error::success == x + [static_cast<uint8_t>(t.m_e)] + [static_cast<uint8_t>(u.m_e)] + ? t.m_r + u.m_r + : checked_result<T>(x + [static_cast<uint8_t>(t.m_e)] + [static_cast<uint8_t>(u.m_e)] + ) + ; +#endif +} + +int main(){ + constexpr const checked_result<unsigned> i = 0; + constexpr const checked_result<unsigned> j = 0; + + constexpr const checked_result<unsigned> k = i + j; + + // return k.m_r; + + constexpr const checked_result<unsigned> i2 = safe_numerics_error::failure; + constexpr const checked_result<unsigned> j2 = 0; + + constexpr const checked_result<unsigned> k2 = i2 + j2; + return k2.m_r; +} +#endif + +#if 0 +using uint8_t = unsigned char; + + +#if 1 +enum class safe_numerics_error : uint8_t { + success = 0, + failure, // result is above representational maximum + error_count +}; +#else +// avoiding enum class fails to solve problem +struct safe_numerics_error { + const uint8_t m_t; + constexpr const static uint8_t success = 0; + constexpr const static uint8_t failure = 1; + constexpr safe_numerics_error(uint8_t t) : + m_t(t) + {} + constexpr operator uint8_t () const { + return m_t; + } +}; +#endif + +template<typename R> +struct checked_result { + const safe_numerics_error m_e; + const union { + const R m_r; + char const * const m_msg; + }; + constexpr /*explicit*/ checked_result(const R & r) : + m_e(safe_numerics_error::success), + m_r(r) + {} + constexpr /*explicit*/ checked_result(const safe_numerics_error & e) : + m_e(e), + m_msg("") + {} +}; + +// integers addition +template<class T> +constexpr inline checked_result<T> operator+( + const checked_result<T> & t, + const checked_result<T> & u +){ + // "Constexpr variable 'e' must be initialized by a constant expression" + constexpr const safe_numerics_error x[2][2]{ + // t == success + { + // u == ... + safe_numerics_error::success, + safe_numerics_error::failure + }, + // t == positive_overflow_error, + { + // u == ... + safe_numerics_error::failure, + safe_numerics_error::failure + } + }; + +#if 1 // compile fails + const safe_numerics_error e = x + [static_cast<uint8_t>(t.m_e)] + [static_cast<uint8_t>(u.m_e)] + ; + + return + (safe_numerics_error::success == e) + ? t.m_r + u.m_r + : checked_result<T>(e) + ; +#else // works as expected + return + safe_numerics_error::success == x + [static_cast<uint8_t>(t.m_e)] + [static_cast<uint8_t>(u.m_e)] + ? t.m_r + u.m_r + : checked_result<T>(x + [static_cast<uint8_t>(t.m_e)] + [static_cast<uint8_t>(u.m_e)] + ) + ; +#endif +} + +int main(){ + constexpr const checked_result<unsigned> i = 0; + constexpr const checked_result<unsigned> j = 0; + + //constexpr const checked_result<unsigned> k = i + j; + // return k.m_r; + + constexpr const checked_result<unsigned> i2 = safe_numerics_error::failure; + constexpr const checked_result<unsigned> j2 = 0; + + constexpr const checked_result<unsigned> k2 = i2 + j2; + return 0; +} + +#endif + +#if 0 +//#include "safe_common.hpp> +//#include "checked_result.hpp> +//#include "checked_default.hpp> +#include <cassert> +#include <boost/logic/tribool.hpp> + +#include <iostream> + +// note: Don't reorder these. Code in the file checked_result_operations.hpp +// depends upon this order !!! +enum class safe_numerics_error : std::uint8_t { + success = 0, + positive_overflow_error, // result is above representational maximum + negative_overflow_error, // result is below representational minimum + domain_error, // one operand is out of valid range + range_error, // result cannot be produced for this operation + precision_overflow_error, // result lost precision + underflow_error, // result is too small to be represented + negative_value_shift, // negative value in shift operator + negative_shift, // shift a negative value + shift_too_large, // l/r shift exceeds variable size + uninitialized_value // l/r shift exceeds variable size +}; + +// checked result is an "extended version" of the type R. That is it's domain is +// the domain of R U possible other values which might result from arithmetic +// operations. An example of such a value would be safe_error::positive_overflow_error. +template<typename R> +struct checked_result { + const safe_numerics_error m_e; + const union { + R m_r; + char const * m_msg; + }; + + constexpr /*explicit*/ checked_result(const R & r) : + m_e(safe_numerics_error::success), + m_r(r) + {} + constexpr /*explicit*/ checked_result( + safe_numerics_error e, + const char * msg = "" + ) : + m_e(e), + m_msg(msg) + { + assert(m_e != safe_numerics_error::success); + } + constexpr bool exception() const { + return m_e != safe_numerics_error::success; + } + + // don't permit construction without initial value; + checked_result() = delete; + + // disallow assignment + checked_result & operator=(const checked_result &) = delete; +}; + +// all arithmetic operations of type T are supported on checked_result<T>. +// but the results might surprising. For example + + +constexpr signed int test_constexpr( + const checked_result<signed int> & t, + const checked_result<signed int> & u +){ + const boost::logic::tribool tb2 = t < u; + const signed int x = (tb2) ? 2 : 3; + return x; +} + +using namespace boost::safe_numerics; + +int main() +{ + constexpr const checked_result<signed int> po = safe_numerics_error::positive_overflow_error; + constexpr const checked_result<signed int> no = safe_numerics_error::negative_overflow_error; + constexpr const boost::logic::tribool tb = no < po; + const boost::logic::tribool tb1 = no > po; + constexpr const checked_result<signed int> re = safe_numerics_error::range_error; + const boost::logic::tribool tb2 = no < re; + const checked_result<signed int> x = no < re ? no : re; + + static_assert(test_constexpr(no, re) == 3, "test_constexpr(no, re)"); + + + static_assert(tb, "no < po"); + + signed int result; + if(tb) + result = 0; + else + result = 1; + std::cout << result; + return result; +} + +#endif + +#if 0 + +#include <boost/logic/tribool.hpp> +#include <cassert> +int main(){ + constexpr const boost::tribool tb_t{true}; + static_assert(tb_t, "tb_t"); + assert(static_cast<bool>(tb_t)); + constexpr boost::tribool tb_f{false}; + static_assert(! tb_f, "tb_f"); + assert(! static_cast<bool>(tb_f)); + return 0; +} +#endif + +#if 0 +#include <boost/integer.hpp> +#include <boost/safe_numerics/utility.hpp> + +// include headers to support safe integers +#include <boost/safe_numerics/cpp.hpp> +//#include <boost/safe_numerics/exception.hpp> + +using promotion_policy = boost::safe_numerics::cpp< + 8, // char 8 bits + 16, // short 16 bits + 16, // int 16 bits + 16, // long 32 bits + 32 // long long 32 bits +>; + +template<typename R, typename T, typename U> +struct test { + using ResultType = promotion_policy::result_type<T,U>; + //boost::safe_numerics::utility::print_type<ResultType> pt; + static_assert( + std::is_same<R, ResultType>::value, + "is_same<R, ResultType>" + ); +}; + +test<std::uint16_t, std::uint8_t, std::uint8_t> t1; + +int main(){ + return 0; +} + +#endif + +#if 0 +#include <string> +#include <unordered_map> +#include <boost/safe_numerics/safe_integer.hpp> + +#include <functional> // hash + +template<typename T> +struct safe_hash { + size_t operator()(boost::safe_numerics::safe<T> const& t) const { + return std::hash<T>()(t); + } +}; + +int main(){ + auto foo = std::unordered_map< + boost::safe_numerics::safe<int>, + std::string, + safe_hash<int> + >{}; + foo[boost::safe_numerics::safe<int>(42)] = "hello, world!"; + foo[42] = "hello, world!"; +} + +#endif + +#if 0 + +#include <string> +#include <unordered_map> +#include <boost/safe_numerics/safe_integer.hpp> + +#include <functional> // hash + +template<typename T> +struct safe_hash { + size_t operator()(boost::safe_numerics::safe<T> const& t) const { + return std::hash<T>()(t); + } +}; + +int main(){ + auto foo = std::unordered_map<int, std::string>{}; + foo[boost::safe_numerics::safe<int>(42)] = "hello, world!"; +} + +#endif + +#if 0 + +#include <iostream> +#include <boost/safe_numerics/safe_integer.hpp> +#include <boost/safe_numerics/automatic.hpp> + +using namespace boost::safe_numerics; + +int main(){ + using safe_int = safe< + int, + automatic, + loose_trap_policy + >; + safe_int i; + std::cin >> i; // might throw exception + auto j = i * i; + // won't ever trap + // result type can hold the maximum value of i * i + static_assert(is_safe<decltype(j)>::value, "result is a safe type"); + static_assert( + std::numeric_limits<decltype(i * i)>::max() >= + std::numeric_limits<safe_int>::max() * std::numeric_limits<safe_int>::max(), + "result can never overflow" + ); // always true + + return 0; +} +#endif + +int main(){} |