1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9// UNSUPPORTED: c++03, c++11, c++14, c++17
10
11// template<class T>
12// concept uniform_random_bit_generator = // see below
13
14#include <random>
15
16#include "test_macros.h"
17
18static_assert(std::uniform_random_bit_generator<
19 std::linear_congruential_engine<unsigned int, 0U, 1U, 2U> >);
20
21#ifndef TEST_HAS_NO_INT128
22static_assert(std::uniform_random_bit_generator<
23 std::subtract_with_carry_engine<__uint128_t, 1U, 2U, 3U> >);
24#endif
25
26// Not invocable
27static_assert(!std::uniform_random_bit_generator<void>);
28static_assert(!std::uniform_random_bit_generator<int>);
29static_assert(!std::uniform_random_bit_generator<int[10]>);
30static_assert(!std::uniform_random_bit_generator<int*>);
31static_assert(!std::uniform_random_bit_generator<const int*>);
32static_assert(!std::uniform_random_bit_generator<volatile int*>);
33static_assert(!std::uniform_random_bit_generator<const volatile int*>);
34static_assert(!std::uniform_random_bit_generator<int&>);
35static_assert(!std::uniform_random_bit_generator<const int&>);
36static_assert(!std::uniform_random_bit_generator<volatile int&>);
37static_assert(!std::uniform_random_bit_generator<const volatile int&>);
38static_assert(!std::uniform_random_bit_generator<int&&>);
39static_assert(!std::uniform_random_bit_generator<const int&&>);
40static_assert(!std::uniform_random_bit_generator<volatile int&&>);
41static_assert(!std::uniform_random_bit_generator<const volatile int&&>);
42
43struct Empty {};
44static_assert(!std::uniform_random_bit_generator<Empty>);
45
46namespace WrongReturnType {
47using FunctionPointer = void (*)();
48static_assert(!std::uniform_random_bit_generator<FunctionPointer>);
49
50using FunctionReference = int (&)();
51static_assert(!std::uniform_random_bit_generator<FunctionReference>);
52
53struct FunctionObject {
54 unsigned long* operator()();
55};
56static_assert(!std::uniform_random_bit_generator<FunctionObject>);
57static_assert(!std::uniform_random_bit_generator<unsigned int Empty::*>);
58static_assert(!std::uniform_random_bit_generator<unsigned short (Empty::*)()>);
59} // namespace WrongReturnType
60
61namespace NoMinOrMax {
62using FunctionPointer = unsigned int (*)();
63static_assert(!std::uniform_random_bit_generator<FunctionPointer>);
64
65using FunctionReference = unsigned long long (&)();
66static_assert(!std::uniform_random_bit_generator<FunctionReference>);
67
68struct FunctionObject {
69 unsigned char operator()();
70};
71static_assert(!std::uniform_random_bit_generator<FunctionObject>);
72} // namespace NoMinOrMax
73
74namespace OnlyMinIsRight {
75struct NoMax {
76 unsigned char operator()();
77
78 static unsigned char min();
79};
80static_assert(!std::uniform_random_bit_generator<NoMax>);
81
82struct MaxHasWrongReturnType {
83 unsigned char operator()();
84
85 static unsigned char min();
86 static unsigned int max();
87};
88
89static_assert(!std::uniform_random_bit_generator<MaxHasWrongReturnType>);
90} // namespace OnlyMinIsRight
91
92namespace OnlyMaxIsRight {
93struct NoMin {
94 unsigned char operator()();
95
96 static unsigned char max();
97};
98static_assert(!std::uniform_random_bit_generator<NoMin>);
99
100struct MinHasWrongReturnType {
101 unsigned char operator()();
102
103 static unsigned int min();
104 static unsigned char max();
105};
106
107static_assert(!std::uniform_random_bit_generator<MinHasWrongReturnType>);
108} // namespace OnlyMaxIsRight
109
110namespace MinNotLessMax {
111struct NotConstexpr {
112 unsigned char operator()();
113
114 static unsigned char min();
115 static unsigned char max();
116};
117static_assert(!std::uniform_random_bit_generator<NotConstexpr>);
118
119struct MinEqualsMax {
120 unsigned char operator()();
121
122 static constexpr unsigned char min() { return 0; }
123 static constexpr unsigned char max() { return 0; }
124};
125static_assert(!std::uniform_random_bit_generator<MinEqualsMax>);
126
127struct MaxLessThanMin {
128 unsigned char operator()();
129
130 static constexpr unsigned char min() { return 1; }
131 static constexpr unsigned char max() { return 0; }
132};
133static_assert(!std::uniform_random_bit_generator<MaxLessThanMin>);
134} // namespace MinNotLessMax
135
136struct Works {
137 unsigned char operator()();
138
139 static constexpr unsigned char min() { return 0; }
140 static constexpr unsigned char max() { return 1; }
141};
142static_assert(std::uniform_random_bit_generator<Works>);
143

source code of libcxx/test/std/numerics/rand/rand.req/rand.req.urng/uniform_random_bit_generator.compile.pass.cpp