//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//

// REQUIRES: std-at-least-c++20

// MSVC warning C5215: a function parameter with a volatile qualified type is deprecated in C++20
// MSVC warning C5216: a volatile qualified return type is deprecated in C++20
// ADDITIONAL_COMPILE_FLAGS(cl-style-warnings): /wd5215 /wd5216

// <numeric>

// template <class _Tp>
// _Tp* midpoint(_Tp* __a, _Tp* __b) noexcept
// Constraints:
//  - T is a complete object type.

#include <cassert>
#include <numeric>

#include "test_macros.h"

template <typename T>
constexpr void constexpr_test() {
  constexpr T array[1000] = {};
  ASSERT_SAME_TYPE(decltype(std::midpoint(array, array)), const T*);
  ASSERT_NOEXCEPT(std::midpoint(array, array));

  static_assert(std::midpoint(array, array) == array, "");
  static_assert(std::midpoint(array, array + 1000) == array + 500, "");

  static_assert(std::midpoint(array, array + 9) == array + 4, "");
  static_assert(std::midpoint(array, array + 10) == array + 5, "");
  static_assert(std::midpoint(array, array + 11) == array + 5, "");
  static_assert(std::midpoint(array + 9, array) == array + 5, "");
  static_assert(std::midpoint(array + 10, array) == array + 5, "");
  static_assert(std::midpoint(array + 11, array) == array + 6, "");
}

template <typename T>
void runtime_test() {
  T array[1000] = {}; // we need an array to make valid pointers
  ASSERT_SAME_TYPE(decltype(std::midpoint(array, array)), T*);
  ASSERT_NOEXCEPT(std::midpoint(array, array));

  assert(std::midpoint(array, array) == array);
  assert(std::midpoint(array, array + 1000) == array + 500);

  assert(std::midpoint(array, array + 9) == array + 4);
  assert(std::midpoint(array, array + 10) == array + 5);
  assert(std::midpoint(array, array + 11) == array + 5);
  assert(std::midpoint(array + 9, array) == array + 5);
  assert(std::midpoint(array + 10, array) == array + 5);
  assert(std::midpoint(array + 11, array) == array + 6);

  // explicit instantiation
  ASSERT_SAME_TYPE(decltype(std::midpoint<T>(array, array)), T*);
  ASSERT_NOEXCEPT(std::midpoint<T>(array, array));
  assert(std::midpoint<T>(array, array) == array);
  assert(std::midpoint<T>(array, array + 1000) == array + 500);
}

template <typename T>
void pointer_test() {
  runtime_test< T>();
  runtime_test<const T>();
  runtime_test< volatile T>();
  runtime_test<const volatile T>();

  //  The constexpr tests are always const, but we can test them anyway.
  constexpr_test< T>();
  constexpr_test<const T>();

//  GCC 9.0.1 (unreleased as of 2019-03) barfs on this, but we have a bot for it.
//  Uncomment when gcc 9.1 is released
#ifndef TEST_COMPILER_GCC
  constexpr_test< volatile T>();
  constexpr_test<const volatile T>();
#endif
}

int main(int, char**) {
  pointer_test<char>();
  pointer_test<int>();
  pointer_test<double>();

  return 0;
}