test/std/numerics/rand/rand.req/rand.req.urng/uniform_random_bit_generator.compile.pass.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, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-concepts

// template<class T>
// concept uniform_random_bit_generator = // see below

#include <random>

static_assert(std::uniform_random_bit_generator<
              std::linear_congruential_engine<unsigned int, 0U, 1U, 2U> >);

#ifndef _LIBCPP_HAS_NO_INT128
static_assert(std::uniform_random_bit_generator<
              std::subtract_with_carry_engine<__uint128_t, 1U, 2U, 3U> >);
#endif

// Not invocable
static_assert(!std::uniform_random_bit_generator<void>);
static_assert(!std::uniform_random_bit_generator<int>);
static_assert(!std::uniform_random_bit_generator<int[10]>);
static_assert(!std::uniform_random_bit_generator<int*>);
static_assert(!std::uniform_random_bit_generator<const int*>);
static_assert(!std::uniform_random_bit_generator<volatile int*>);
static_assert(!std::uniform_random_bit_generator<const volatile int*>);
static_assert(!std::uniform_random_bit_generator<int&>);
static_assert(!std::uniform_random_bit_generator<const int&>);
static_assert(!std::uniform_random_bit_generator<volatile int&>);
static_assert(!std::uniform_random_bit_generator<const volatile int&>);
static_assert(!std::uniform_random_bit_generator<int&&>);
static_assert(!std::uniform_random_bit_generator<const int&&>);
static_assert(!std::uniform_random_bit_generator<volatile int&&>);
static_assert(!std::uniform_random_bit_generator<const volatile int&&>);

struct Empty {};
static_assert(!std::uniform_random_bit_generator<Empty>);

namespace WrongReturnType {
using FunctionPointer = void (*)();
static_assert(!std::uniform_random_bit_generator<FunctionPointer>);

using FunctionReference = int (&)();
static_assert(!std::uniform_random_bit_generator<FunctionReference>);

struct FunctionObject {
  unsigned long* operator()();
};
static_assert(!std::uniform_random_bit_generator<FunctionObject>);
static_assert(!std::uniform_random_bit_generator<unsigned int Empty::*>);
static_assert(!std::uniform_random_bit_generator<unsigned short (Empty::*)()>);
} // namespace WrongReturnType

namespace NoMinOrMax {
using FunctionPointer = unsigned int (*)();
static_assert(!std::uniform_random_bit_generator<FunctionPointer>);

using FunctionReference = unsigned long long (&)();
static_assert(!std::uniform_random_bit_generator<FunctionReference>);

struct FunctionObject {
  unsigned char operator()();
};
static_assert(!std::uniform_random_bit_generator<FunctionObject>);
} // namespace NoMinOrMax

namespace OnlyMinIsRight {
struct NoMax {
  unsigned char operator()();

  static unsigned char min();
};
static_assert(!std::uniform_random_bit_generator<NoMax>);

struct MaxHasWrongReturnType {
  unsigned char operator()();

  static unsigned char min();
  static unsigned int max();
};

static_assert(!std::uniform_random_bit_generator<MaxHasWrongReturnType>);
} // namespace OnlyMinIsRight

namespace OnlyMaxIsRight {
struct NoMin {
  unsigned char operator()();

  static unsigned char max();
};
static_assert(!std::uniform_random_bit_generator<NoMin>);

struct MinHasWrongReturnType {
  unsigned char operator()();

  static unsigned int min();
  static unsigned char max();
};

static_assert(!std::uniform_random_bit_generator<MinHasWrongReturnType>);
} // namespace OnlyMaxIsRight

namespace MinNotLessMax {
struct NotConstexpr {
  unsigned char operator()();

  static unsigned char min();
  static unsigned char max();
};
static_assert(!std::uniform_random_bit_generator<NotConstexpr>);

struct MinEqualsMax {
  unsigned char operator()();

  static constexpr unsigned char min() { return 0; }
  static constexpr unsigned char max() { return 0; }
};
static_assert(!std::uniform_random_bit_generator<MinEqualsMax>);

struct MaxLessThanMin {
  unsigned char operator()();

  static constexpr unsigned char min() { return 1; }
  static constexpr unsigned char max() { return 0; }
};
static_assert(!std::uniform_random_bit_generator<MaxLessThanMin>);
} // namespace MinNotLessMax

struct Works {
  unsigned char operator()();

  static constexpr unsigned char min() { return 0; }
  static constexpr unsigned char max() { return 1; }
};
static_assert(std::uniform_random_bit_generator<Works>);

int main(int, char**) { return 0; }