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// REQUIRES: std-at-least-c++26
10
11// The test uses "Placeholder variables with no name"
12// UNSUPPORTED: apple-clang-15, apple-clang-16
13
14// <numeric>
15
16// template<class T>
17// constexpr T div_sat(T x, T y) noexcept; // freestanding
18
19#include <cassert>
20#include <concepts>
21#include <limits>
22#include <numeric>
23
24#include "test_macros.h"
25
26template <typename IntegerT>
27constexpr bool test_signed() {
28 constexpr auto minVal = std::numeric_limits<IntegerT>::min();
29 constexpr auto maxVal = std::numeric_limits<IntegerT>::max();
30
31 std::same_as<IntegerT> decltype(auto) _ = std::div_sat(minVal, maxVal);
32
33 static_assert(noexcept(std::div_sat(minVal, maxVal)));
34
35 // clang-format off
36
37 // Limit values (-1, 0, 1, min, max)
38
39 assert(std::div_sat(IntegerT{-1}, IntegerT{-1}) == IntegerT{ 1});
40 assert(std::div_sat(IntegerT{-1}, IntegerT{ 1}) == IntegerT{-1});
41 assert(std::div_sat(IntegerT{-1}, minVal) == IntegerT{ 0});
42 assert(std::div_sat(IntegerT{-1}, maxVal) == IntegerT{ 0});
43 assert(std::div_sat(IntegerT{ 0}, IntegerT{-1}) == IntegerT{ 0});
44 assert(std::div_sat(IntegerT{ 0}, IntegerT{ 1}) == IntegerT{ 0});
45 assert(std::div_sat(IntegerT{ 0}, minVal) == IntegerT{ 0});
46 assert(std::div_sat(IntegerT{ 0}, maxVal) == IntegerT{ 0});
47 assert(std::div_sat(IntegerT{ 1}, IntegerT{-1}) == IntegerT{-1});
48 assert(std::div_sat(IntegerT{ 1}, IntegerT{ 1}) == IntegerT{ 1});
49 assert(std::div_sat(IntegerT{ 1}, minVal) == IntegerT{ 0});
50 assert(std::div_sat(IntegerT{ 1}, maxVal) == IntegerT{ 0});
51 assert(std::div_sat( minVal, IntegerT{ 1}) == minVal);
52 assert(std::div_sat( minVal, IntegerT{-1}) == maxVal); // saturated
53 assert(std::div_sat( minVal, minVal) == IntegerT{ 1});
54 assert(std::div_sat( minVal, maxVal) == (minVal / maxVal));
55 assert(std::div_sat( maxVal, IntegerT{-1}) == -maxVal);
56 assert(std::div_sat( maxVal, IntegerT{ 1}) == maxVal);
57 assert(std::div_sat( maxVal, minVal) == IntegerT{ 0});
58 assert(std::div_sat( maxVal, maxVal) == IntegerT{ 1});
59
60 // No saturation (no limit values)
61
62 assert(std::div_sat(IntegerT{27}, IntegerT{28}) == IntegerT{0});
63 assert(std::div_sat(IntegerT{28}, IntegerT{27}) == IntegerT{1});
64 {
65 constexpr IntegerT lesserVal = minVal / IntegerT{2} + IntegerT{-28};
66 constexpr IntegerT biggerVal = minVal / IntegerT{2} + IntegerT{-27};
67 assert(std::div_sat(lesserVal, biggerVal) == IntegerT{1});
68 assert(std::div_sat(biggerVal, lesserVal) == IntegerT{0});
69 }
70 {
71 constexpr IntegerT lesserVal = minVal / IntegerT{2} + IntegerT{-27};
72 constexpr IntegerT biggerVal = maxVal / IntegerT{2} + IntegerT{28};
73 assert(std::div_sat(lesserVal, biggerVal) == IntegerT{-1});
74 assert(std::div_sat(biggerVal, lesserVal) == IntegerT{-1});
75 }
76 {
77 constexpr IntegerT lesserVal = maxVal / IntegerT{2} + IntegerT{27};
78 constexpr IntegerT biggerVal = maxVal / IntegerT{2} + IntegerT{28};
79 assert(std::div_sat(lesserVal, biggerVal) == IntegerT{0});
80 assert(std::div_sat(biggerVal, lesserVal) == IntegerT{1});
81 }
82
83 // clang-format on
84
85 return true;
86}
87
88template <typename IntegerT>
89constexpr bool test_unsigned() {
90 constexpr auto minVal = std::numeric_limits<IntegerT>::min();
91 constexpr auto maxVal = std::numeric_limits<IntegerT>::max();
92
93 std::same_as<IntegerT> decltype(auto) _ = std::div_sat(minVal, maxVal);
94 static_assert(noexcept(std::div_sat(minVal, maxVal)));
95
96 // clang-format off
97
98 // No limit values (0, 1, min, max)
99
100 assert(std::div_sat(IntegerT{0}, IntegerT{1}) == IntegerT{0});
101 assert(std::div_sat(IntegerT{0}, maxVal) == IntegerT{0});
102
103 assert(std::div_sat(IntegerT{1}, IntegerT{1}) == IntegerT{1});
104 assert(std::div_sat(IntegerT{1}, maxVal) == IntegerT{0});
105
106 assert(std::div_sat( minVal, IntegerT{1}) == minVal);
107 assert(std::div_sat( minVal, maxVal) == IntegerT{0});
108
109 assert(std::div_sat( maxVal, IntegerT{1}) == maxVal);
110 assert(std::div_sat( maxVal, maxVal) == IntegerT{1});
111
112 // No saturation (no limit values)
113
114 assert(std::div_sat(IntegerT{27}, IntegerT{28}) == IntegerT{0});
115 assert(std::div_sat(IntegerT{28}, IntegerT{27}) == IntegerT{1});
116 {
117 constexpr IntegerT lesserVal = maxVal / IntegerT{2} + IntegerT{27};
118 constexpr IntegerT biggerVal = maxVal / IntegerT{2} + IntegerT{28};
119 assert(std::div_sat(lesserVal, biggerVal) == IntegerT{0});
120 assert(std::div_sat(biggerVal, lesserVal) == IntegerT{1});
121 }
122
123 // Unsigned integer division never overflows
124
125 // clang-format on
126
127 return true;
128}
129
130constexpr bool test() {
131 // Signed
132 test_signed<signed char>();
133 test_signed<short int>();
134 test_signed<int>();
135 test_signed<long int>();
136 test_signed<long long int>();
137#ifndef TEST_HAS_NO_INT128
138 test_signed<__int128_t>();
139#endif
140 // Unsigned
141 test_unsigned<unsigned char>();
142 test_unsigned<unsigned short int>();
143 test_unsigned<unsigned int>();
144 test_unsigned<unsigned long int>();
145 test_unsigned<unsigned long long int>();
146#ifndef TEST_HAS_NO_INT128
147 test_unsigned<__uint128_t>();
148#endif
149
150 return true;
151}
152
153int main(int, char**) {
154 test();
155 static_assert(test());
156
157 return 0;
158}
159

source code of libcxx/test/std/numerics/numeric.ops/numeric.ops.sat/div_sat.pass.cpp