[libc++] Explicitly reject URNG types with signed result_types.

[• Quuxplusone]

Summary

Fixes https://github.com/llvm/llvm-project/issues/48965

At first I tried making one big .verify.cpp test for all the distributions, but it turned out that that had a problem: Some distributions depend on other distributions. So instantiating lognormal_distribution::operator() will produce an error inside normal_distribution::operator() as well as its "expected" error. This means that one distribution can trigger up to 7(!) static_asserts. And also, once normal_distribution's assert has been triggered transitively by lognormal_distribution, well, now it's been instantiated, so it will not be triggered a second time when we get down to the place in the test where we actually want to test normal_distribution.

So, I've somewhat guiltily gone ahead and added a bad_engine.verify.cpp for every distribution individually. I placed it in test/std/ because my impression is that .verify.cpp tests are run only on Clang+libc++ anyway; this isn't testing a libc++ extension per se, just a libc++-specific diagnostic for standard UB; and I didn't want to re-create the whole deeply nested directory structure in test/libcxx/ just for this.

[• Quuxplusone]

bump CI after adding parent revision

[• Quuxplusone]

Rebase on main.

[ldionne]

libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/bad_engine.verify.cpp

9

You should mark those as REQUIRES: libc++ since they are not under libcxx/test/libcxx.

[ldionne]

Apart from that and the failing CI, this LGTM.

[• Quuxplusone]

Move the new tests to libcxx/test/libcxx/, rather than make them the only ones that require libc++. (Louis tells me that .verify.cpp tests run only with Clang, because they rely on clang -verify; but they don't necessarily run only with libc++.)

libcxx/include/__random/bernoulli_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_BERNOULLI_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_BERNOULLI_DISTRIBUTION_H
 
 #include <__config>
+#include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <iosfwd>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #  pragma clang include_instead(<random>)
 #endif
 
friend _LIBCPP_INLINE_VISIBILITY
         {return !(__x == __y);}
 };
 
 template<class _URNG>
 inline
 bernoulli_distribution::result_type
 bernoulli_distribution::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     uniform_real_distribution<double> __gen;
     return __gen(__g) < __p.p();
 }
 
 template <class _CharT, class _Traits>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, const bernoulli_distribution& __x)
 {

libcxx/include/__random/binomial_distribution.h

 
 // Reference: Kemp, C.D. (1986). `A modal method for generating binomial
 //           variables', Commun. Statist. - Theor. Meth. 15(3), 805-813.
 template<class _IntType>
 template<class _URNG>
 _IntType
 binomial_distribution<_IntType>::operator()(_URNG& __g, const param_type& __pr)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     if (__pr.__t_ == 0 || __pr.__p_ == 0)
         return 0;
     if (__pr.__p_ == 1)
         return __pr.__t_;
     uniform_real_distribution<double> __gen;
     double __u = __gen(__g) - __pr.__pr_;
     if (__u < 0)
         return __pr.__r0_;

libcxx/include/__random/cauchy_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_CAUCHY_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_CAUCHY_DISTRIBUTION_H
 
 #include <__config>
+#include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <cmath>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #  pragma clang include_instead(<random>)

 };
 
 template <class _RealType>
 template<class _URNG>
 inline
 _RealType
 cauchy_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     uniform_real_distribution<result_type> __gen;
     // purposefully let tan arg get as close to pi/2 as it wants, tan will return a finite
     return __p.a() + __p.b() * _VSTD::tan(3.1415926535897932384626433832795 * __gen(__g));
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,

libcxx/include/__random/discrete_distribution.h

discrete_distribution<_IntType>::param_type::probabilities() const
     return __p;
 }
 
 template<class _IntType>
 template<class _URNG>
 _IntType
 discrete_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     uniform_real_distribution<double> __gen;
     return static_cast<_IntType>(
            _VSTD::upper_bound(__p.__p_.begin(), __p.__p_.end(), __gen(__g)) -
                                                               __p.__p_.begin());
 }
 
 template <class _CharT, class _Traits, class _IT>
 basic_ostream<_CharT, _Traits>&

libcxx/include/__random/exponential_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_EXPONENTIAL_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_EXPONENTIAL_DISTRIBUTION_H
 
 #include <__config>
 #include <__random/generate_canonical.h>
+#include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <cmath>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #  pragma clang include_instead(<random>)
friend _LIBCPP_INLINE_VISIBILITY
         {return !(__x == __y);}
 };
 
 template <class _RealType>
 template<class _URNG>
 _RealType
 exponential_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     return -_VSTD::log
                   (
                       result_type(1) -
                       _VSTD::generate_canonical<result_type,
                                        numeric_limits<result_type>::digits>(__g)
                   )
                   / __p.lambda();
 }

libcxx/include/__random/extreme_value_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_EXTREME_VALUE_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_EXTREME_VALUE_DISTRIBUTION_H
 
 #include <__config>
+#include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <cmath>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #  pragma clang include_instead(<random>)
friend _LIBCPP_INLINE_VISIBILITY
         {return !(__x == __y);}
 };
 
 template<class _RealType>
 template<class _URNG>
 _RealType
 extreme_value_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     return __p.a() - __p.b() *
          _VSTD::log(-_VSTD::log(1-uniform_real_distribution<result_type>()(__g)));
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
            const extreme_value_distribution<_RT>& __x)

libcxx/include/__random/fisher_f_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_FISHER_F_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_FISHER_F_DISTRIBUTION_H
 
 #include <__config>
 #include <__random/gamma_distribution.h>
+#include <__random/is_valid.h>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #  pragma clang include_instead(<random>)
 #endif
 
friend _LIBCPP_INLINE_VISIBILITY
         {return !(__x == __y);}
 };
 
 template <class _RealType>
 template<class _URNG>
 _RealType
 fisher_f_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     gamma_distribution<result_type> __gdm(__p.m() * result_type(.5));
     gamma_distribution<result_type> __gdn(__p.n() * result_type(.5));
     return __p.n() * __gdm(__g) / (__p.m() * __gdn(__g));
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,

libcxx/include/__random/gamma_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_GAMMA_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_GAMMA_DISTRIBUTION_H
 
 #include <__config>
 #include <__random/exponential_distribution.h>
+#include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <cmath>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #  pragma clang include_instead(<random>)
friend _LIBCPP_INLINE_VISIBILITY
         {return !(__x == __y);}
 };
 
 template <class _RealType>
 template<class _URNG>
 _RealType
 gamma_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     result_type __a = __p.alpha();
     uniform_real_distribution<result_type> __gen(0, 1);
     exponential_distribution<result_type> __egen;
     result_type __x;
     if (__a == 1)
         __x = __egen(__g);
     else if (__a > 1)
     {

libcxx/include/__random/is_valid.h

 template<> struct __libcpp_random_is_valid_inttype<unsigned long> : true_type {};
 template<> struct __libcpp_random_is_valid_inttype<unsigned long long> : true_type {};
 
 #ifndef _LIBCPP_HAS_NO_INT128
 template<> struct __libcpp_random_is_valid_inttype<__int128_t> : true_type {};
 template<> struct __libcpp_random_is_valid_inttype<__uint128_t> : true_type {};
 #endif // _LIBCPP_HAS_NO_INT128
 
+// [rand.req.urng]/3:
+// A class G meets the uniform random bit generator requirements if G models
+// uniform_random_bit_generator, invoke_result_t<G&> is an unsigned integer type,
+// and G provides a nested typedef-name result_type that denotes the same type
+// as invoke_result_t<G&>.
+// (In particular, reject URNGs with signed result_types; our distributions cannot
+// handle such generator types.)
+
+template<class, class = void> struct __libcpp_random_is_valid_urng : false_type {};
+template<class _Gp> struct __libcpp_random_is_valid_urng<_Gp, __enable_if_t<
+    is_unsigned<typename _Gp::result_type>::value &&
+    _IsSame<decltype(declval<_Gp&>()()), typename _Gp::result_type>::value
+> > : true_type {};
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANDOM_IS_VALID_H

libcxx/include/__random/negative_binomial_distribution.h

friend _LIBCPP_INLINE_VISIBILITY
         {return !(__x == __y);}
 };
 
 template <class _IntType>
 template<class _URNG>
 _IntType
 negative_binomial_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     result_type __k = __pr.k();
     double __p = __pr.p();
     if (__k <= 21 * __p)
     {
         bernoulli_distribution __gen(__p);
         result_type __f = 0;
         result_type __s = 0;
         while (__s < __k)

libcxx/include/__random/normal_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_NORMAL_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_NORMAL_DISTRIBUTION_H
 
 #include <__config>
+#include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <cmath>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #  pragma clang include_instead(<random>)
operator>>(basic_istream<_CharT, _Traits>& __is,
                normal_distribution<_RT>& __x);
 };
 
 template <class _RealType>
 template<class _URNG>
 _RealType
 normal_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     result_type _Up;
     if (_V_hot_)
     {
         _V_hot_ = false;
         _Up = _V_;
     }
     else
     {

libcxx/include/__random/piecewise_constant_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_PIECEWISE_CONSTANT_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_PIECEWISE_CONSTANT_DISTRIBUTION_H
 
 #include <__algorithm/upper_bound.h>
 #include <__config>
+#include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <iosfwd>
 #include <numeric>
 #include <vector>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #  pragma clang include_instead(<random>)
piecewise_constant_distribution<_RealType>::param_type::param_type(
     __init();
 }
 
 template<class _RealType>
 template<class _URNG>
 _RealType
 piecewise_constant_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     typedef uniform_real_distribution<result_type> _Gen;
     result_type __u = _Gen()(__g);
     ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
                                       __u) - __p.__areas_.begin() - 1;
     return (__u - __p.__areas_[__k]) / __p.__densities_[__k] + __p.__b_[__k];
 }
 
 template <class _CharT, class _Traits, class _RT>

libcxx/include/__random/piecewise_linear_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_PIECEWISE_LINEAR_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_PIECEWISE_LINEAR_DISTRIBUTION_H
 
 #include <__algorithm/upper_bound.h>
 #include <__config>
+#include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <iosfwd>
 #include <numeric>
 #include <vector>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #  pragma clang include_instead(<random>)
piecewise_linear_distribution<_RealType>::param_type::param_type(
     __init();
 }
 
 template<class _RealType>
 template<class _URNG>
 _RealType
 piecewise_linear_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     typedef uniform_real_distribution<result_type> _Gen;
     result_type __u = _Gen()(__g);
     ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
                                       __u) - __p.__areas_.begin() - 1;
     __u -= __p.__areas_[__k];
     const result_type __dk = __p.__densities_[__k];
     const result_type __dk1 = __p.__densities_[__k+1];
     const result_type __deltad = __dk1 - __dk;

libcxx/include/__random/poisson_distribution.h

poisson_distribution<_IntType>::param_type::param_type(double __mean)
     }
 }
 
 template <class _IntType>
 template<class _URNG>
 _IntType
 poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     double __tx;
     uniform_real_distribution<double> __urd;
     if (__pr.__mean_ < 10)
     {
          __tx = 0;
         for (double __p = __urd(__urng); __p > __pr.__l_; ++__tx)
             __p *= __urd(__urng);
     }

libcxx/include/__random/student_t_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_STUDENT_T_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_STUDENT_T_DISTRIBUTION_H
 
 #include <__config>
 #include <__random/gamma_distribution.h>
+#include <__random/is_valid.h>
 #include <__random/normal_distribution.h>
 #include <cmath>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #  pragma clang include_instead(<random>)
friend _LIBCPP_INLINE_VISIBILITY
         {return !(__x == __y);}
 };
 
 template <class _RealType>
 template<class _URNG>
 _RealType
 student_t_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     gamma_distribution<result_type> __gd(__p.n() * .5, 2);
     return __nd_(__g) * _VSTD::sqrt(__p.n()/__gd(__g));
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
            const student_t_distribution<_RT>& __x)

libcxx/include/__random/uniform_int_distribution.h

 };
 
 template<class _IntType>
 template<class _URNG>
 typename uniform_int_distribution<_IntType>::result_type
 uniform_int_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p)
 _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     typedef typename conditional<sizeof(result_type) <= sizeof(uint32_t), uint32_t,
                                  typename make_unsigned<result_type>::type>::type _UIntType;
     const _UIntType _Rp = _UIntType(__p.b()) - _UIntType(__p.a()) + _UIntType(1);
     if (_Rp == 1)
         return __p.a();
     const size_t _Dt = numeric_limits<_UIntType>::digits;
     typedef __independent_bits_engine<_URNG, _UIntType> _Eng;
     if (_Rp == 0)

libcxx/include/__random/uniform_real_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_UNIFORM_REAL_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_UNIFORM_REAL_DISTRIBUTION_H
 
 #include <__config>
 #include <__random/generate_canonical.h>
+#include <__random/is_valid.h>
 #include <iosfwd>
 #include <limits>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #  pragma clang include_instead(<random>)
 #endif

 };
 
 template<class _RealType>
 template<class _URNG>
 inline
 typename uniform_real_distribution<_RealType>::result_type
 uniform_real_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
+    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     return (__p.b() - __p.a())
         * _VSTD::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g)
         + __p.a();
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,

libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/bad_engine.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <random>
+
+#include <random>
+
+template<class Int>
+struct G {
+  using result_type = Int;
+  result_type operator()();
+  static constexpr result_type min() { return 0; }
+  static constexpr result_type max() { return 255; }
+};
+
+void test(std::bernoulli_distribution dist)
+{
+  G<int> badg;
+  G<unsigned> okg;
+
+  dist(badg); //expected-error@*:* 2 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(okg);
+}

libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/bad_engine.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <random>
+
+#include <random>
+
+template<class Int>
+struct G {
+  using result_type = Int;
+  result_type operator()();
+  static constexpr result_type min() { return 0; }
+  static constexpr result_type max() { return 255; }
+};
+
+void test(std::binomial_distribution<int> dist)
+{
+  G<int> badg;
+  G<unsigned> okg;
+
+  dist(badg); //expected-error@*:* 2 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(okg);
+}

libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/bad_engine.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <random>
+
+#include <random>
+
+template<class Int>
+struct G {
+  using result_type = Int;
+  result_type operator()();
+  static constexpr result_type min() { return 0; }
+  static constexpr result_type max() { return 255; }
+};
+
+void test(std::geometric_distribution<int> dist)
+{
+  G<int> badg;
+  G<unsigned> okg;
+
+  dist(badg); //expected-error@*:* 7 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(okg);
+}

libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/bad_engine.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <random>
+
+#include <random>
+
+template<class Int>
+struct G {
+  using result_type = Int;
+  result_type operator()();
+  static constexpr result_type min() { return 0; }
+  static constexpr result_type max() { return 255; }
+};
+
+void test(std::negative_binomial_distribution<int> dist)
+{
+  G<int> badg;
+  G<unsigned> okg;
+
+  dist(badg); //expected-error@*:* 7 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(okg);
+}

libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/bad_engine.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <random>
+
+#include <random>
+
+template<class Int>
+struct G {
+  using result_type = Int;
+  result_type operator()();
+  static constexpr result_type min() { return 0; }
+  static constexpr result_type max() { return 255; }
+};
+
+void test(std::cauchy_distribution<double> dist)
+{
+  G<int> badg;
+  G<unsigned> okg;
+
+  dist(badg); //expected-error@*:* 2 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(okg);
+}

libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/bad_engine.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <random>
+
+#include <random>
+
+template<class Int>
+struct G {
+  using result_type = Int;
+  result_type operator()();
+  static constexpr result_type min() { return 0; }
+  static constexpr result_type max() { return 255; }
+};
+
+void test(std::chi_squared_distribution<double> dist)
+{
+  G<int> badg;
+  G<unsigned> okg;
+
+  dist(badg); //expected-error@*:* 3 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(okg);
+}

libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/bad_engine.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <random>
+
+#include <random>
+
+template<class Int>
+struct G {
+  using result_type = Int;
+  result_type operator()();
+  static constexpr result_type min() { return 0; }
+  static constexpr result_type max() { return 255; }
+};
+
+void test(std::fisher_f_distribution<double> dist)
+{
+  G<int> badg;
+  G<unsigned> okg;
+
+  dist(badg); //expected-error@*:* 4 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(okg);
+}

libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/bad_engine.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <random>
+
+#include <random>
+
+template<class Int>
+struct G {
+  using result_type = Int;
+  result_type operator()();
+  static constexpr result_type min() { return 0; }
+  static constexpr result_type max() { return 255; }
+};
+
+void test(std::lognormal_distribution<double> dist)
+{
+  G<int> badg;
+  G<unsigned> okg;
+
+  dist(badg); //expected-error@*:* 2 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(okg);
+}

libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/bad_engine.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <random>
+
+#include <random>
+
+template<class Int>
+struct G {
+  using result_type = Int;
+  result_type operator()();
+  static constexpr result_type min() { return 0; }
+  static constexpr result_type max() { return 255; }
+};
+
+void test(std::normal_distribution<double> dist)
+{
+  G<int> badg;
+  G<unsigned> okg;
+
+  dist(badg); //expected-error@*:* 2 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(okg);
+}

libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/bad_engine.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <random>
+
+#include <random>
+
+template<class Int>
+struct G {
+  using result_type = Int;
+  result_type operator()();
+  static constexpr result_type min() { return 0; }
+  static constexpr result_type max() { return 255; }
+};
+
+void test(std::student_t_distribution<double> dist)
+{
+  G<int> badg;
+  G<unsigned> okg;
+
+  dist(badg); //expected-error@*:* 5 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(okg);
+}

libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/bad_engine.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <random>
+
+#include <random>
+
+template<class Int>
+struct G {
+  using result_type = Int;
+  result_type operator()();
+  static constexpr result_type min() { return 0; }
+  static constexpr result_type max() { return 255; }
+};
+
+void test(std::exponential_distribution<double> dist)
+{
+  G<int> badg;
+  G<unsigned> okg;
+
+  dist(badg); //expected-error@*:* {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(okg);
+}

libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/bad_engine.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <random>
+
+#include <random>
+
+template<class Int>
+struct G {
+  using result_type = Int;
+  result_type operator()();
+  static constexpr result_type min() { return 0; }
+  static constexpr result_type max() { return 255; }
+};
+
+void test(std::extreme_value_distribution<double> dist)
+{
+  G<int> badg;
+  G<unsigned> okg;
+
+  dist(badg); //expected-error@*:* 2 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(okg);
+}

libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/bad_engine.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <random>
+
+#include <random>
+
+template<class Int>
+struct G {
+  using result_type = Int;
+  result_type operator()();
+  static constexpr result_type min() { return 0; }
+  static constexpr result_type max() { return 255; }
+};
+
+void test(std::gamma_distribution<double> dist)
+{
+  G<int> badg;
+  G<unsigned> okg;
+
+  dist(badg); //expected-error@*:* 3 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(okg);
+}

libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/bad_engine.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <random>
+
+#include <random>
+
+template<class Int>
+struct G {
+  using result_type = Int;
+  result_type operator()();
+  static constexpr result_type min() { return 0; }
+  static constexpr result_type max() { return 255; }
+};
+
+void test(std::poisson_distribution<int> dist)
+{
+  G<int> badg;
+  G<unsigned> okg;
+
+  dist(badg); //expected-error@*:* 4 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(okg);
+}

libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/bad_engine.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <random>
+
+#include <random>
+
+template<class Int>
+struct G {
+  using result_type = Int;
+  result_type operator()();
+  static constexpr result_type min() { return 0; }
+  static constexpr result_type max() { return 255; }
+};
+
+void test(std::weibull_distribution<double> dist)
+{
+  G<int> badg;
+  G<unsigned> okg;
+
+  dist(badg); //expected-error@*:* {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(okg);
+}

libcxx/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/bad_engine.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <random>
+
+#include <random>
+
+template<class Int>
+struct G {
+  using result_type = Int;
+  result_type operator()();
+  static constexpr result_type min() { return 0; }
+  static constexpr result_type max() { return 255; }
+};
+
+void test(std::discrete_distribution<int> dist)
+{
+  G<int> badg;
+  G<unsigned> okg;
+
+  dist(badg); //expected-error@*:* 2 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(okg);
+}

libcxx/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/bad_engine.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <random>
+
+#include <random>
+
+template<class Int>
+struct G {
+  using result_type = Int;
+  result_type operator()();
+  static constexpr result_type min() { return 0; }
+  static constexpr result_type max() { return 255; }
+};
+
+void test(std::piecewise_constant_distribution<double> dist)
+{
+  G<int> badg;
+  G<unsigned> okg;
+
+  dist(badg); //expected-error@*:* 2 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(okg);
+}

libcxx/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/bad_engine.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <random>
+
+#include <random>
+
+template<class Int>
+struct G {
+  using result_type = Int;
+  result_type operator()();
+  static constexpr result_type min() { return 0; }
+  static constexpr result_type max() { return 255; }
+};
+
+void test(std::piecewise_linear_distribution<double> dist)
+{
+  G<int> badg;
+  G<unsigned> okg;
+
+  dist(badg); //expected-error@*:* 2 {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(okg);
+}

libcxx/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/bad_engine.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <random>
+
+#include <random>
+
+template<class Int>
+struct G {
+  using result_type = Int;
+  result_type operator()();
+  static constexpr result_type min() { return 0; }
+  static constexpr result_type max() { return 255; }
+};
+
+void test(std::uniform_int_distribution<int> dist)
+{
+  G<int> badg;
+  G<unsigned> okg;
+
+  dist(badg); //expected-error@*:* {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(okg);
+}

libcxx/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/bad_engine.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <random>
+
+#include <random>
+
+template<class Int>
+struct G {
+  using result_type = Int;
+  result_type operator()();
+  static constexpr result_type min() { return 0; }
+  static constexpr result_type max() { return 255; }
+};
+
+void test(std::uniform_real_distribution<double> dist)
+{
+  G<int> badg;
+  G<unsigned> okg;
+
+  dist(badg); //expected-error@*:* {{static_assert failed}} //expected-note {{in instantiation}}
+  dist(okg);
+}