[libc++][chrono] Fixes month inc and dec operations.

[Mordante]

Summary

The operator++, operator++(int), operator--, and operator--(int) need to
change the month to a valid value. The wording is specified in terms of

operator+(const month& x, const months& y) noexcept;

which has the correct behavior. The aforementioned operators instead
used ++/-- on the internal value direction, resulting in incorrect
behaviour.

As a drive-by improve the unit tests:

• use the typical constexpr test method
• test whether the month is valid after the operations
• format the tests

Fixes: https://llvm.org/PR63912

libcxx/include/__chrono/month.h

 {
 
 class month {
 private:
     unsigned char __m_;
 public:
     month() = default;
     _LIBCPP_HIDE_FROM_ABI explicit inline constexpr month(unsigned __val) noexcept : __m_(static_cast<unsigned char>(__val)) {}
-    _LIBCPP_HIDE_FROM_ABI inline constexpr month& operator++()    noexcept { ++__m_; return *this; }
+    _LIBCPP_HIDE_FROM_ABI inline constexpr month& operator++()    noexcept { *this += months{1}; return *this; }
     _LIBCPP_HIDE_FROM_ABI inline constexpr month  operator++(int) noexcept { month __tmp = *this; ++(*this); return __tmp; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr month& operator--()    noexcept { --__m_; return *this; }
+    _LIBCPP_HIDE_FROM_ABI inline constexpr month& operator--()    noexcept { *this -= months{1}; return *this; }
     _LIBCPP_HIDE_FROM_ABI inline constexpr month  operator--(int) noexcept { month __tmp = *this; --(*this); return __tmp; }
     _LIBCPP_HIDE_FROM_ABI        constexpr month& operator+=(const months& __m1) noexcept;
     _LIBCPP_HIDE_FROM_ABI        constexpr month& operator-=(const months& __m1) noexcept;
     _LIBCPP_HIDE_FROM_ABI explicit inline constexpr operator unsigned() const noexcept { return __m_; }
     _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept { return __m_ >= 1 && __m_ <= 12; }
 };
 
 

libcxx/test/std/time/time.cal/time.cal.month/time.cal.month.members/decrement.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
 
 // <chrono>
 // class month;
 
 //  constexpr month& operator--() noexcept;
 //  constexpr month operator--(int) noexcept;
 
-
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
-template <typename M>
-constexpr bool testConstexpr()
-{
-    M m1{10};
-    if (static_cast<unsigned>(--m1) != 9) return false;
-    if (static_cast<unsigned>(m1--) != 9) return false;
-    if (static_cast<unsigned>(m1)   != 8) return false;
-    return true;
+constexpr bool test() {
+  using month = std::chrono::month;
+  for (unsigned i = 0; i <= 15; ++i) {
+    month m1(i);
+    month m2 = m1--;
+    assert(m1.ok());
+    assert(m1 != m2);
+
+    unsigned exp = i == 0 ? 11 : i == 1 ? 12 : i - 1;
+    while (exp > 12)
+      exp -= 12;
+    assert(static_cast<unsigned>(m1) == exp);
+  }
+  for (unsigned i = 0; i <= 15; ++i) {
+    month m1(i);
+    month m2 = --m1;
+    assert(m1.ok());
+    assert(m2.ok());
+    assert(m1 == m2);
+
+    unsigned exp = i == 0 ? 11 : i == 1 ? 12 : i - 1;
+    while (exp > 12)
+      exp -= 12;
+    assert(static_cast<unsigned>(m1) == exp);
+  }
+
 }
 
-int main(int, char**)
-{
-    using month = std::chrono::month;
+int main(int, char**) {
 
-    ASSERT_NOEXCEPT(--(std::declval<month&>())  );
-    ASSERT_NOEXCEPT(  (std::declval<month&>())--);
+  ASSERT_NOEXCEPT(--(std::declval<month&>()));
+  ASSERT_NOEXCEPT((std::declval<month&>())--);
 
-    ASSERT_SAME_TYPE(month , decltype(  std::declval<month&>()--));
-    ASSERT_SAME_TYPE(month&, decltype(--std::declval<month&>()  ));
+  ASSERT_SAME_TYPE(month, decltype(std::declval<month&>()--));
+  ASSERT_SAME_TYPE(month&, decltype(--std::declval<month&>()));
 
-    static_assert(testConstexpr<month>(), "");
-
-    for (unsigned i = 10; i <= 20; ++i)
-    {
-        month m(i);
-        assert(static_cast<unsigned>(--m) == i - 1);
-        assert(static_cast<unsigned>(m--) == i - 1);
-        assert(static_cast<unsigned>(m)   == i - 2);
-    }
+  test();
+  static_assert(test());
 
   return 0;
 }

libcxx/test/std/time/time.cal/time.cal.month/time.cal.month.members/increment.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
 
 // <chrono>
 // class month;
 
 //  constexpr month& operator++() noexcept;
 //  constexpr month operator++(int) noexcept;
 
-
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
-template <typename M>
-constexpr bool testConstexpr()
-{
-    M m1{1};
-    if (static_cast<unsigned>(++m1) != 2) return false;
-    if (static_cast<unsigned>(m1++) != 2) return false;
-    if (static_cast<unsigned>(m1)   != 3) return false;
-    return true;
+constexpr bool test() {
+  using month = std::chrono::month;
+  for (unsigned i = 0; i <= 15; ++i) {
+    month m1(i);
+    month m2 = m1++;
+    assert(m1.ok());
+    assert(m1 != m2);
+
+    unsigned exp = i + 1;
+    while (exp > 12)
+      exp -= 12;
+    assert(static_cast<unsigned>(m1) == exp);
+  }
+  for (unsigned i = 0; i <= 15; ++i) {
+    month m1(i);
+    month m2 = ++m1;
+    assert(m1.ok());
+    assert(m2.ok());
+    assert(m1 == m2);
+
+    unsigned exp = i + 1;
+    while (exp > 12)
+      exp -= 12;
+    assert(static_cast<unsigned>(m1) == exp);
+  }
+
 }
 
-int main(int, char**)
-{
-    using month = std::chrono::month;
-    ASSERT_NOEXCEPT(++(std::declval<month&>())  );
-    ASSERT_NOEXCEPT(  (std::declval<month&>())++);
+int main(int, char**) {
+
+  ASSERT_NOEXCEPT(++(std::declval<month&>()));
+  ASSERT_NOEXCEPT((std::declval<month&>())++);
 
-    ASSERT_SAME_TYPE(month , decltype(  std::declval<month&>()++));
-    ASSERT_SAME_TYPE(month&, decltype(++std::declval<month&>()  ));
+  ASSERT_SAME_TYPE(month, decltype(std::declval<month&>()++));
+  ASSERT_SAME_TYPE(month&, decltype(++std::declval<month&>()));
 
-    static_assert(testConstexpr<month>(), "");
-
-    for (unsigned i = 0; i <= 10; ++i)
-    {
-        month m(i);
-        assert(static_cast<unsigned>(++m) == i + 1);
-        assert(static_cast<unsigned>(m++) == i + 1);
-        assert(static_cast<unsigned>(m)   == i + 2);
-    }
+  test();
+  static_assert(test());
 
   return 0;
 }

libcxx/test/std/time/time.cal/time.cal.month/time.cal.month.members/plus_minus_equal.pass.cpp

 // constexpr month& operator-=(const month& d) noexcept;
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
-template <typename M, typename Ms>
-constexpr bool testConstexpr()
-{
-    M m1{1};
-    if (static_cast<unsigned>(m1 += Ms{ 1}) !=  2) return false;
-    if (static_cast<unsigned>(m1 += Ms{ 2}) !=  4) return false;
-    if (static_cast<unsigned>(m1 += Ms{ 8}) != 12) return false;
-    if (static_cast<unsigned>(m1 -= Ms{ 1}) != 11) return false;
-    if (static_cast<unsigned>(m1 -= Ms{ 2}) !=  9) return false;
-    if (static_cast<unsigned>(m1 -= Ms{ 8}) !=  1) return false;
-    return true;
-}
-
-int main(int, char**)
-{
-    using month  = std::chrono::month;
-    using months = std::chrono::months;
+constexpr bool test() {
 
-    ASSERT_NOEXCEPT(std::declval<month&>() += std::declval<months&>());
-    ASSERT_NOEXCEPT(std::declval<month&>() -= std::declval<months&>());
-    ASSERT_SAME_TYPE(month&, decltype(std::declval<month&>() += std::declval<months&>()));
-    ASSERT_SAME_TYPE(month&, decltype(std::declval<month&>() -= std::declval<months&>()));
-
-    static_assert(testConstexpr<month, months>(), "");
-
-    for (unsigned i = 1; i <= 10; ++i)
-    {
-        month m(i);
-        int exp = i + 10;
-        while (exp > 12)
-            exp -= 12;
-        assert(static_cast<unsigned>(m += months{10}) == static_cast<unsigned>(exp));
-        assert(static_cast<unsigned>(m)               == static_cast<unsigned>(exp));
-    }
+  for (unsigned i = 1; i <= 10; ++i) {
+    assert(static_cast<unsigned>(m) == static_cast<unsigned>(exp));
+    assert(m.ok());
 
-    for (unsigned i = 1; i <= 10; ++i)
-    {
-        month m(i);
-        int exp = i - 9;
-        while (exp < 1)
-            exp += 12;
-        assert(static_cast<unsigned>(m -= months{ 9}) == static_cast<unsigned>(exp));
-        assert(static_cast<unsigned>(m)               == static_cast<unsigned>(exp));
-    }
+  for (unsigned i = 1; i <= 10; ++i) {
+    assert(static_cast<unsigned>(m -= months{9}) == static_cast<unsigned>(exp));
+    assert(static_cast<unsigned>(m) == static_cast<unsigned>(exp));
+    assert(m.ok());
+  }
+  return true;
 
+int main(int, char**) {
+  using month  = std::chrono::month;
+  using months = std::chrono::months;
+
+  ASSERT_NOEXCEPT(std::declval<month&>() += std::declval<months&>());
+  ASSERT_NOEXCEPT(std::declval<month&>() -= std::declval<months&>());
+  ASSERT_SAME_TYPE(month&, decltype(std::declval<month&>() += std::declval<months&>()));
+  ASSERT_SAME_TYPE(month&, decltype(std::declval<month&>() -= std::declval<months&>()));
+
+  test();
+  static_assert(test());
+
   return 0;
 }

libcxx/test/std/time/time.cal/time.cal.month/time.cal.month.nonmembers/minus.pass.cpp

int main(int, char**)
     ASSERT_SAME_TYPE(months, decltype(std::declval<month>() - std::declval<month> ()));
 
     static_assert(testConstexpr<month, months>(), "");
 
     month m{6};
     for (unsigned i = 1; i <= 12; ++i)
     {
         month m1   = m - months{i};
-        // months off = m - month {i};
+        assert(m1.ok());
         int exp = 6 - i;
         if (exp < 1)
             exp += 12;
         assert(static_cast<unsigned>(m1) == static_cast<unsigned>(exp));
-        // assert(off.count()            == static_cast<unsigned>(exp));
     }
 
   return 0;
 }

libcxx/test/std/time/time.cal/time.cal.month/time.cal.month.nonmembers/plus.pass.cpp

 //     month{modulo(static_cast<long long>(int{x}) + (y.count() - 1), 12) + 1}
 //   where modulo(n, 12) computes the remainder of n divided by 12 using Euclidean division.
 //   [Note: Given a divisor of 12, Euclidean division truncates towards negative infinity
 //   and always produces a remainder in the range of [0, 11].
 //   Assuming no overflow in the signed summation, this operation results in a month
 //   holding a value in the range [1, 12] even if !x.ok(). -end note]
 //   [Example: February + months{11} == January. -end example]
 
-
-
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
-template <typename M, typename Ms>
-constexpr bool testConstexpr()
-{
-    M m{1};
-    Ms offset{4};
-    assert(m + offset == M{5});
-    assert(offset + m == M{5});
-    //  Check the example
-    assert(M{2} + Ms{11} == M{1});
-    return true;
-}
-
-int main(int, char**)
-{
-    using month  = std::chrono::month;
-    using months = std::chrono::months;
+constexpr bool test() {
 
-    ASSERT_NOEXCEPT(std::declval<month>() + std::declval<months>());
-    ASSERT_NOEXCEPT(std::declval<months>() + std::declval<month>());
-
-    ASSERT_SAME_TYPE(month, decltype(std::declval<month>()  + std::declval<months>()));
-    ASSERT_SAME_TYPE(month, decltype(std::declval<months>() + std::declval<month>() ));
-
-    static_assert(testConstexpr<month, months>(), "");
-
-    month my{2};
-    for (unsigned i = 0; i <= 15; ++i)
-    {
-        month m1 = my + months{i};
-        month m2 = months{i} + my;
-        assert(m1 == m2);
-        unsigned exp = i + 2;
-        while (exp > 12)
-            exp -= 12;
-        assert(static_cast<unsigned>(m1) == exp);
-        assert(static_cast<unsigned>(m2) == exp);
-    }
+  for (unsigned i = 0; i <= 15; ++i) {
+    assert(m1.ok());
+    assert(m2.ok());
 
-    return 0;
+  return true;
+}
+
+int main(int, char**) {
+  using month  = std::chrono::month;
+  using months = std::chrono::months;
+
+  ASSERT_NOEXCEPT(std::declval<month>() + std::declval<months>());
+  ASSERT_NOEXCEPT(std::declval<months>() + std::declval<month>());
+
+  ASSERT_SAME_TYPE(month, decltype(std::declval<month>() + std::declval<months>()));
+  ASSERT_SAME_TYPE(month, decltype(std::declval<months>() + std::declval<month>()));
+
+  test();
+  static_assert(test());
+
 }