1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9// UNSUPPORTED: c++03, c++11, c++14, c++17
10
11// <chrono>
12
13// time_point
14
15// template<class Clock, class Duration1,
16// three_way_comparable_with<Duration1> Duration2>
17// constexpr auto operator<=>(const time_point<Clock, Duration1>& lhs,
18// const time_point<Clock, Duration2>& rhs);
19
20#include <cassert>
21#include <chrono>
22#include <ratio>
23
24#include "test_comparisons.h"
25
26constexpr void test_with_integral_ticks_value() {
27 using Clock = std::chrono::system_clock;
28
29 using Duration1 = std::chrono::milliseconds;
30 using Duration2 = std::chrono::microseconds;
31 using T1 = std::chrono::time_point<Clock, Duration1>;
32 using T2 = std::chrono::time_point<Clock, Duration2>;
33
34 {
35 T1 t1(Duration1(3));
36 T1 t2(Duration1(3));
37 assert((t1 <=> t2) == std::strong_ordering::equal);
38 assert(testOrder(t1, t2, std::strong_ordering::equal));
39 }
40 {
41 T1 t1(Duration1(3));
42 T1 t2(Duration1(4));
43 assert((t1 <=> t2) == std::strong_ordering::less);
44 assert(testOrder(t1, t2, std::strong_ordering::less));
45 }
46 {
47 T1 t1(Duration1(3));
48 T2 t2(Duration2(3000));
49 assert((t1 <=> t2) == std::strong_ordering::equal);
50 assert(testOrder(t1, t2, std::strong_ordering::equal));
51 }
52 {
53 T1 t1(Duration1(3));
54 T2 t2(Duration2(3001));
55 assert((t1 <=> t2) == std::strong_ordering::less);
56 assert(testOrder(t1, t2, std::strong_ordering::less));
57 assert((t2 <=> t1) == std::strong_ordering::greater);
58 assert(testOrder(t2, t1, std::strong_ordering::greater));
59 }
60}
61
62constexpr void test_with_integral_ticks_value_and_custom_period_value() {
63 using Clock = std::chrono::system_clock;
64
65 using DInt30Hz = std::chrono::duration<int, std::ratio<1, 30>>;
66 using DInt60Hz = std::chrono::duration<int, std::ratio<1, 60>>;
67
68 using TIntR1 = std::chrono::time_point<Clock, DInt30Hz>;
69 using TIntR2 = std::chrono::time_point<Clock, DInt60Hz>;
70
71 {
72 TIntR1 t1(DInt30Hz(10));
73 TIntR2 t2(DInt60Hz(20));
74 assert((t1 <=> t2) == std::strong_ordering::equal);
75 assert(testOrder(t1, t2, std::strong_ordering::equal));
76 }
77 {
78 TIntR1 t1(DInt30Hz(10));
79 TIntR2 t2(DInt60Hz(21));
80 assert((t1 <=> t2) == std::strong_ordering::less);
81 assert(testOrder(t1, t2, std::strong_ordering::less));
82 }
83 {
84 TIntR1 t1(DInt30Hz(11));
85 TIntR2 t2(DInt60Hz(20));
86 assert((t1 <=> t2) == std::strong_ordering::greater);
87 assert(testOrder(t1, t2, std::strong_ordering::greater));
88 }
89}
90
91constexpr void test_with_floating_point_ticks_value() {
92 using Clock = std::chrono::system_clock;
93
94 using DF30Hz = std::chrono::duration<double, std::ratio<1, 30>>;
95 using DF60Hz = std::chrono::duration<double, std::ratio<1, 60>>;
96 using F1 = std::chrono::time_point<Clock, DF30Hz>;
97 using F2 = std::chrono::time_point<Clock, DF60Hz>;
98
99 // No equality comparison test for floating point values.
100
101 {
102 F1 t1(DF30Hz(3.5));
103 F2 t2(DF60Hz(7.1));
104 assert((t1 <=> t2) == std::weak_ordering::less);
105 assert(testOrder(t1, t2, std::weak_ordering::less));
106 }
107 {
108 F1 t1(DF30Hz(3.6));
109 F2 t2(DF60Hz(7.0));
110 assert((t1 <=> t2) == std::weak_ordering::greater);
111 assert(testOrder(t1, t2, std::weak_ordering::greater));
112 }
113}
114
115constexpr bool test() {
116 test_with_integral_ticks_value();
117 test_with_integral_ticks_value_and_custom_period_value();
118 test_with_floating_point_ticks_value();
119
120 return true;
121}
122
123int main(int, char**) {
124 assert(test());
125 static_assert(test());
126 return 0;
127}
128

source code of libcxx/test/std/time/time.point/time.point.comparisons/compare.three_way.pass.cpp