//===----------------------------------------------------------------------===//
//
// 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++98, c++03, c++11, c++14, c++17

// <chrono>
// class year_month_day;

// constexpr year_month_day
//   operator/(const year_month& ym, const day& d) noexcept;
// Returns: {ym.year(), ym.month(), d}.
//
// constexpr year_month_day
//   operator/(const year_month& ym, int d) noexcept;
// Returns: ym / day(d).
//
// constexpr year_month_day
//   operator/(const year& y, const month_day& md) noexcept;
// Returns: y / md.month() / md.day().
//
// constexpr year_month_day
//   operator/(int y, const month_day& md) noexcept;
// Returns: year(y) / md.
//
// constexpr year_month_day
//   operator/(const month_day& md, const year& y) noexcept;
// Returns: y / md.
//
// constexpr year_month_day
//   operator/(const month_day& md, int y) noexcept;
// Returns: year(y) / md.


#include <chrono>
#include <type_traits>
#include <cassert>

#include "test_macros.h"
#include "test_comparisons.h"

int main(int, char**)
{
    using year           = std::chrono::year;
    using month          = std::chrono::month;
    using day            = std::chrono::day;
    using year_month     = std::chrono::year_month;
    using month_day      = std::chrono::month_day;
    using year_month_day = std::chrono::year_month_day;

    constexpr month February = std::chrono::February;
    constexpr year_month Feb2018{year{2018}, February};

    { // operator/(const year_month& ym, const day& d)
        ASSERT_NOEXCEPT (                         Feb2018/day{2});
        ASSERT_SAME_TYPE(year_month_day, decltype(Feb2018/day{2}));

        static_assert((Feb2018/day{2}).month() == February, "");
        static_assert((Feb2018/day{2}).day()   == day{2},   "");

        for (int i = 1000; i < 1010; ++i)
            for (int j = 1; j <= 12; ++j)
                for (unsigned k = 0; k <= 28; ++k)
                {
                    year y(i);
                    month m(j);
                    day d(k);
                    year_month ym(y, m);
                    year_month_day ymd = ym/d;
                    assert(ymd.year()  == y);
                    assert(ymd.month() == m);
                    assert(ymd.day()   == d);
                }
    }


    { // operator/(const year_month& ym, int d)
        ASSERT_NOEXCEPT (                         Feb2018/2);
        ASSERT_SAME_TYPE(year_month_day, decltype(Feb2018/2));

        static_assert((Feb2018/2).month() == February, "");
        static_assert((Feb2018/2).day()   == day{2},   "");

        for (int i = 1000; i < 1010; ++i)
            for (int j = 1; j <= 12; ++j)
                for (unsigned k = 0; k <= 28; ++k)
                {
                    year y(i);
                    month m(j);
                    day d(k);
                    year_month ym(y, m);
                    year_month_day ymd = ym/k;
                    assert(ymd.year()  == y);
                    assert(ymd.month() == m);
                    assert(ymd.day()   == d);
                }
    }


    { // operator/(const year_month& ym, int d)
        ASSERT_NOEXCEPT (                         Feb2018/2);
        ASSERT_SAME_TYPE(year_month_day, decltype(Feb2018/2));

        static_assert((Feb2018/2).month() == February, "");
        static_assert((Feb2018/2).day()   == day{2},   "");

        for (int i = 1000; i < 1010; ++i)
            for (int j = 1; j <= 12; ++j)
                for (unsigned k = 0; k <= 28; ++k)
                {
                    year y(i);
                    month m(j);
                    day d(k);
                    year_month ym(y, m);
                    year_month_day ymd = ym/k;
                    assert(ymd.year()  == y);
                    assert(ymd.month() == m);
                    assert(ymd.day()   == d);
                }
    }


    { // operator/(const year& y, const month_day& md) (and switched)
        ASSERT_NOEXCEPT (                         year{2018}/month_day{February, day{2}});
        ASSERT_SAME_TYPE(year_month_day, decltype(year{2018}/month_day{February, day{2}}));
        ASSERT_NOEXCEPT (                         month_day{February, day{2}}/year{2018});
        ASSERT_SAME_TYPE(year_month_day, decltype(month_day{February, day{2}}/year{2018}));

        static_assert((year{2018}/month_day{February, day{2}}).month() == February, "" );
        static_assert((year{2018}/month_day{February, day{2}}).day()   == day{2},   "" );
        static_assert((month_day{February, day{2}}/year{2018}).month() == February, "" );
        static_assert((month_day{February, day{2}}/year{2018}).day()   == day{2},   "" );

        for (int i = 1000; i < 1010; ++i)
            for (int j = 1; j <= 12; ++j)
                for (unsigned k = 0; k <= 28; ++k)
                {
                    year y(i);
                    month m(j);
                    day d(k);
                    month_day md(m, d);
                    year_month_day ymd1 = y/md;
                    year_month_day ymd2 = md/y;
                    assert(ymd1.year()  == y);
                    assert(ymd2.year()  == y);
                    assert(ymd1.month() == m);
                    assert(ymd2.month() == m);
                    assert(ymd1.day()   == d);
                    assert(ymd2.day()   == d);
                    assert(ymd1 == ymd2);
                }
    }

    { // operator/(const month_day& md, int y) (and switched)
        ASSERT_NOEXCEPT (                         2018/month_day{February, day{2}});
        ASSERT_SAME_TYPE(year_month_day, decltype(2018/month_day{February, day{2}}));
        ASSERT_NOEXCEPT (                         month_day{February, day{2}}/2018);
        ASSERT_SAME_TYPE(year_month_day, decltype(month_day{February, day{2}}/2018));

        static_assert((2018/month_day{February, day{2}}).month() == February, "" );
        static_assert((2018/month_day{February, day{2}}).day()   == day{2},   "" );
        static_assert((month_day{February, day{2}}/2018).month() == February, "" );
        static_assert((month_day{February, day{2}}/2018).day()   == day{2},   "" );

        for (int i = 1000; i < 1010; ++i)
            for (int j = 1; j <= 12; ++j)
                for (unsigned k = 0; k <= 28; ++k)
                {
                    year y(i);
                    month m(j);
                    day d(k);
                    month_day md(m, d);
                    year_month_day ymd1 = i/md;
                    year_month_day ymd2 = md/i;
                    assert(ymd1.year()  == y);
                    assert(ymd2.year()  == y);
                    assert(ymd1.month() == m);
                    assert(ymd2.month() == m);
                    assert(ymd1.day()   == d);
                    assert(ymd2.day()   == d);
                    assert(ymd1 == ymd2);
                }
    }


  return 0;
}