//===----------------------------------------------------------------------===//
//
// 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
// 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
//
#include <numeric>
#include <cassert>
#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;
}