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