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 
18 static_assert(std::uniform_random_bit_generator<
19               std::linear_congruential_engine<unsigned int, 0U, 1U, 2U> >);
20 
21 #ifndef TEST_HAS_NO_INT128
22 static_assert(std::uniform_random_bit_generator<
23               std::subtract_with_carry_engine<__uint128_t, 1U, 2U, 3U> >);
24 #endif
25 
26 // Not invocable
27 static_assert(!std::uniform_random_bit_generator<void>);
28 static_assert(!std::uniform_random_bit_generator<int>);
29 static_assert(!std::uniform_random_bit_generator<int[10]>);
30 static_assert(!std::uniform_random_bit_generator<int*>);
31 static_assert(!std::uniform_random_bit_generator<const int*>);
32 static_assert(!std::uniform_random_bit_generator<volatile int*>);
33 static_assert(!std::uniform_random_bit_generator<const volatile int*>);
34 static_assert(!std::uniform_random_bit_generator<int&>);
35 static_assert(!std::uniform_random_bit_generator<const int&>);
36 static_assert(!std::uniform_random_bit_generator<volatile int&>);
37 static_assert(!std::uniform_random_bit_generator<const volatile int&>);
38 static_assert(!std::uniform_random_bit_generator<int&&>);
39 static_assert(!std::uniform_random_bit_generator<const int&&>);
40 static_assert(!std::uniform_random_bit_generator<volatile int&&>);
41 static_assert(!std::uniform_random_bit_generator<const volatile int&&>);
42 
43 struct Empty {};
44 static_assert(!std::uniform_random_bit_generator<Empty>);
45 
46 namespace WrongReturnType {
47 using FunctionPointer = void (*)();
48 static_assert(!std::uniform_random_bit_generator<FunctionPointer>);
49 
50 using FunctionReference = int (&)();
51 static_assert(!std::uniform_random_bit_generator<FunctionReference>);
52 
53 struct FunctionObject {
54   unsigned long* operator()();
55 };
56 static_assert(!std::uniform_random_bit_generator<FunctionObject>);
57 static_assert(!std::uniform_random_bit_generator<unsigned int Empty::*>);
58 static_assert(!std::uniform_random_bit_generator<unsigned short (Empty::*)()>);
59 } // namespace WrongReturnType
60 
61 namespace NoMinOrMax {
62 using FunctionPointer = unsigned int (*)();
63 static_assert(!std::uniform_random_bit_generator<FunctionPointer>);
64 
65 using FunctionReference = unsigned long long (&)();
66 static_assert(!std::uniform_random_bit_generator<FunctionReference>);
67 
68 struct FunctionObject {
69   unsigned char operator()();
70 };
71 static_assert(!std::uniform_random_bit_generator<FunctionObject>);
72 } // namespace NoMinOrMax
73 
74 namespace OnlyMinIsRight {
75 struct NoMax {
76   unsigned char operator()();
77 
78   static unsigned char min();
79 };
80 static_assert(!std::uniform_random_bit_generator<NoMax>);
81 
82 struct MaxHasWrongReturnType {
83   unsigned char operator()();
84 
85   static unsigned char min();
86   static unsigned int max();
87 };
88 
89 static_assert(!std::uniform_random_bit_generator<MaxHasWrongReturnType>);
90 } // namespace OnlyMinIsRight
91 
92 namespace OnlyMaxIsRight {
93 struct NoMin {
94   unsigned char operator()();
95 
96   static unsigned char max();
97 };
98 static_assert(!std::uniform_random_bit_generator<NoMin>);
99 
100 struct MinHasWrongReturnType {
101   unsigned char operator()();
102 
103   static unsigned int min();
104   static unsigned char max();
105 };
106 
107 static_assert(!std::uniform_random_bit_generator<MinHasWrongReturnType>);
108 } // namespace OnlyMaxIsRight
109 
110 namespace MinNotLessMax {
111 struct NotConstexpr {
112   unsigned char operator()();
113 
114   static unsigned char min();
115   static unsigned char max();
116 };
117 static_assert(!std::uniform_random_bit_generator<NotConstexpr>);
118 
119 struct MinEqualsMax {
120   unsigned char operator()();
121 
minMinNotLessMax::MinEqualsMax122   static constexpr unsigned char min() { return 0; }
maxMinNotLessMax::MinEqualsMax123   static constexpr unsigned char max() { return 0; }
124 };
125 static_assert(!std::uniform_random_bit_generator<MinEqualsMax>);
126 
127 struct MaxLessThanMin {
128   unsigned char operator()();
129 
minMinNotLessMax::MaxLessThanMin130   static constexpr unsigned char min() { return 1; }
maxMinNotLessMax::MaxLessThanMin131   static constexpr unsigned char max() { return 0; }
132 };
133 static_assert(!std::uniform_random_bit_generator<MaxLessThanMin>);
134 } // namespace MinNotLessMax
135 
136 struct Works {
137   unsigned char operator()();
138 
minWorks139   static constexpr unsigned char min() { return 0; }
maxWorks140   static constexpr unsigned char max() { return 1; }
141 };
142 static_assert(std::uniform_random_bit_generator<Works>);
143