Skip to content

Commit 7a37461

Browse files
jnthntatumcopybara-github
jnthntatum
authored and
copybara-github
committed
Test fixes for macos builds
- ignore conformance test that depends on charconv shortest float rep formatting - fix internal test with ambiguous overloads PiperOrigin-RevId: 899739434
1 parent 9fd4d79 commit 7a37461

2 files changed

Lines changed: 126 additions & 107 deletions

File tree

‎conformance/BUILD‎

Lines changed: 6 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -164,7 +164,7 @@ _ALL_TESTS = [
164164
"@com_google_cel_spec//tests/simple:testdata/type_deduction.textproto",
165165
]
166166

167-
_TESTS_TO_SKIP_MODERN = [
167+
_TESTS_TO_SKIP = [
168168
# Tests which require spec changes.
169169
# TODO(issues/93): Deprecate Duration.getMilliseconds.
170170
"timestamps/duration_converters/get_milliseconds",
@@ -197,45 +197,21 @@ _TESTS_TO_SKIP_MODERN = [
197197
"timestamps/timestamp_selectors_tz/getDayOfMonth_name_pos",
198198
"timestamps/timestamp_selectors_tz/getDayOfYear",
199199
# These depend on using charconv (or equivalent) to format doubles with shortest possible
200-
# precision to preserve value. Not available on older compilers.
200+
# precision to preserve value. Not available on older compilers where we just use absl::Format.
201+
# We should probably update the spec to allow different formats that parse to the same value.
201202
"conversions/string/double_hard",
202203
]
203204

205+
_TESTS_TO_SKIP_MODERN = _TESTS_TO_SKIP
206+
204207
_TESTS_TO_SKIP_MODERN_DASHBOARD = [
205208
# Future features for CEL 1.0
206209
# TODO(issues/119): Strong typing support for enums, specified but not implemented.
207210
"enums/strong_proto2",
208211
"enums/strong_proto3",
209212
]
210213

211-
_TESTS_TO_SKIP_LEGACY = [
212-
# Tests which require spec changes.
213-
# TODO(issues/93): Deprecate Duration.getMilliseconds.
214-
"timestamps/duration_converters/get_milliseconds",
215-
216-
# Broken test cases which should be supported.
217-
# TODO(issues/112): Unbound functions result in empty eval response.
218-
"basic/functions/unbound",
219-
"basic/functions/unbound_is_runtime_error",
220-
221-
# TODO(issues/97): Parse-only qualified variable lookup "x.y" with binding "x.y" or "y" within container "x" fails
222-
"fields/qualified_identifier_resolution/qualified_ident,map_field_select,ident_with_longest_prefix_check,qualified_identifier_resolution_unchecked",
223-
"namespace/qualified/self_eval_qualified_lookup",
224-
"namespace/namespace/self_eval_container_lookup,self_eval_container_lookup_unchecked",
225-
# TODO(issues/117): Integer overflow on enum assignments should error.
226-
"enums/legacy_proto2/select_big,select_neg",
227-
228-
# Skip until fixed.
229-
"wrappers/field_mask/to_json",
230-
"wrappers/empty/to_json",
231-
"fields/qualified_identifier_resolution/map_value_repeat_key_heterogeneous",
232-
"parse/receiver_function_names",
233-
234-
# Future features for CEL 1.0
235-
# TODO(issues/119): Strong typing support for enums, specified but not implemented.
236-
"enums/strong_proto2",
237-
"enums/strong_proto3",
238-
214+
_TESTS_TO_SKIP_LEGACY = _TESTS_TO_SKIP + [
239215
# Legacy value does not support optional_type.
240216
"optionals/optionals",
241217

@@ -245,14 +221,6 @@ _TESTS_TO_SKIP_LEGACY = [
245221
"proto3/set_null/list_value",
246222
"proto3/set_null/single_struct",
247223

248-
# These depend on legacy US/ timezones. It's spotty if these are included with a normally
249-
# configured timezone database.
250-
"timestamps/timestamp_selectors_tz/getDayOfMonth_name_pos",
251-
"timestamps/timestamp_selectors_tz/getDayOfYear",
252-
# These depend on using charconv (or equivalent) to format doubles with shortest possible
253-
# precision to preserve value. Not available on older compilers.
254-
"conversions/string/double_hard",
255-
256224
# cel.@block
257225
"block_ext/basic/optional_list",
258226
"block_ext/basic/optional_map",

‎internal/overflow_test.cc‎

Lines changed: 120 additions & 69 deletions
Original file line numberDiff line numberDiff line change
@@ -57,25 +57,30 @@ INSTANTIATE_TEST_SUITE_P(
5757
CheckedIntMathTest, CheckedIntResultTest,
5858
ValuesIn(std::vector<IntTestCase>{
5959
// Addition tests.
60-
{"OneAddOne", [] { return CheckedAdd(1L, 1L); }, 2L},
61-
{"ZeroAddOne", [] { return CheckedAdd(0, 1L); }, 1L},
62-
{"ZeroAddMinusOne", [] { return CheckedAdd(0, -1L); }, -1L},
63-
{"OneAddZero", [] { return CheckedAdd(1L, 0); }, 1L},
64-
{"MinusOneAddZero", [] { return CheckedAdd(-1L, 0); }, -1L},
60+
{"OneAddOne", [] { return CheckedAdd(int64_t{1L}, 1L); }, 2L},
61+
{"ZeroAddOne", [] { return CheckedAdd(int64_t{0}, 1L); }, 1L},
62+
{"ZeroAddMinusOne", [] { return CheckedAdd(int64_t{0}, -1L); }, -1L},
63+
{"OneAddZero", [] { return CheckedAdd(int64_t{1L}, 0); }, 1L},
64+
{"MinusOneAddZero", [] { return CheckedAdd(int64_t{-1L}, 0); }, -1L},
6565
{"OneAddIntMax",
66-
[] { return CheckedAdd(1L, std::numeric_limits<int64_t>::max()); },
66+
[] {
67+
return CheckedAdd(int64_t{1L}, std::numeric_limits<int64_t>::max());
68+
},
6769
absl::OutOfRangeError("integer overflow")},
6870
{"MinusOneAddIntMin",
69-
[] { return CheckedAdd(-1L, std::numeric_limits<int64_t>::lowest()); },
71+
[] {
72+
return CheckedAdd(int64_t{-1L},
73+
std::numeric_limits<int64_t>::lowest());
74+
},
7075
absl::OutOfRangeError("integer overflow")},
7176

7277
// Subtraction tests.
73-
{"TwoSubThree", [] { return CheckedSub(2L, 3L); }, -1L},
74-
{"TwoSubZero", [] { return CheckedSub(2L, 0); }, 2L},
75-
{"ZeroSubTwo", [] { return CheckedSub(0, 2L); }, -2L},
76-
{"MinusTwoSubThree", [] { return CheckedSub(-2L, 3L); }, -5L},
77-
{"MinusTwoSubZero", [] { return CheckedSub(-2L, 0); }, -2L},
78-
{"ZeroSubMinusTwo", [] { return CheckedSub(0, -2L); }, 2L},
78+
{"TwoSubThree", [] { return CheckedSub(int64_t{2L}, 3L); }, -1L},
79+
{"TwoSubZero", [] { return CheckedSub(int64_t{2L}, 0); }, 2L},
80+
{"ZeroSubTwo", [] { return CheckedSub(int64_t{0}, 2L); }, -2L},
81+
{"MinusTwoSubThree", [] { return CheckedSub(int64_t{-2L}, 3L); }, -5L},
82+
{"MinusTwoSubZero", [] { return CheckedSub(int64_t{-2L}, 0); }, -2L},
83+
{"ZeroSubMinusTwo", [] { return CheckedSub(int64_t{0}, -2L); }, 2L},
7984
{"IntMinSubIntMax",
8085
[] {
8186
return CheckedSub(std::numeric_limits<int64_t>::max(),
@@ -84,66 +89,100 @@ INSTANTIATE_TEST_SUITE_P(
8489
absl::OutOfRangeError("integer overflow")},
8590

8691
// Multiplication tests.
87-
{"TwoMulThree", [] { return CheckedMul(2L, 3L); }, 6L},
88-
{"MinusTwoMulThree", [] { return CheckedMul(-2L, 3L); }, -6L},
89-
{"MinusTwoMulMinusThree", [] { return CheckedMul(-2L, -3L); }, 6L},
90-
{"TwoMulMinusThree", [] { return CheckedMul(2L, -3L); }, -6L},
92+
{"TwoMulThree", [] { return CheckedMul(int64_t{2L}, 3L); }, 6L},
93+
{"MinusTwoMulThree", [] { return CheckedMul(int64_t{-2L}, 3L); }, -6L},
94+
{"MinusTwoMulMinusThree", [] { return CheckedMul(int64_t{-2L}, -3L); },
95+
6L},
96+
{"TwoMulMinusThree", [] { return CheckedMul(int64_t{2L}, -3L); }, -6L},
9197
{"TwoMulIntMax",
92-
[] { return CheckedMul(2L, std::numeric_limits<int64_t>::max()); },
98+
[] {
99+
return CheckedMul(int64_t{2L}, std::numeric_limits<int64_t>::max());
100+
},
93101
absl::OutOfRangeError("integer overflow")},
94102
{"MinusOneMulIntMin",
95-
[] { return CheckedMul(-1L, std::numeric_limits<int64_t>::lowest()); },
103+
[] {
104+
return CheckedMul(int64_t{-1L},
105+
std::numeric_limits<int64_t>::lowest());
106+
},
96107
absl::OutOfRangeError("integer overflow")},
97108
{"IntMinMulMinusOne",
98-
[] { return CheckedMul(std::numeric_limits<int64_t>::lowest(), -1L); },
109+
[] {
110+
return CheckedMul(std::numeric_limits<int64_t>::lowest(),
111+
int64_t{-1L});
112+
},
99113
absl::OutOfRangeError("integer overflow")},
100114
{"IntMinMulZero",
101-
[] { return CheckedMul(std::numeric_limits<int64_t>::lowest(), 0); },
115+
[] {
116+
return CheckedMul(std::numeric_limits<int64_t>::lowest(),
117+
int64_t{0});
118+
},
102119
0},
103120
{"ZeroMulIntMin",
104-
[] { return CheckedMul(0, std::numeric_limits<int64_t>::lowest()); },
121+
[] {
122+
return CheckedMul(int64_t{0},
123+
std::numeric_limits<int64_t>::lowest());
124+
},
105125
0},
106126
{"IntMaxMulZero",
107-
[] { return CheckedMul(std::numeric_limits<int64_t>::max(), 0); }, 0},
127+
[] {
128+
return CheckedMul(std::numeric_limits<int64_t>::max(), int64_t{0});
129+
},
130+
0},
108131
{"ZeroMulIntMax",
109-
[] { return CheckedMul(0, std::numeric_limits<int64_t>::max()); }, 0},
132+
[] {
133+
return CheckedMul(int64_t{0}, std::numeric_limits<int64_t>::max());
134+
},
135+
0},
110136

111137
// Division cases.
112-
{"ZeroDivOne", [] { return CheckedDiv(0, 1L); }, 0},
113-
{"TenDivTwo", [] { return CheckedDiv(10L, 2L); }, 5},
114-
{"TenDivMinusOne", [] { return CheckedDiv(10L, -1L); }, -10},
115-
{"MinusTenDivMinusOne", [] { return CheckedDiv(-10L, -1L); }, 10},
116-
{"MinusTenDivTwo", [] { return CheckedDiv(-10L, 2L); }, -5},
117-
{"OneDivZero", [] { return CheckedDiv(1L, 0L); },
138+
{"ZeroDivOne", [] { return CheckedDiv(int64_t{0}, 1L); }, 0},
139+
{"TenDivTwo", [] { return CheckedDiv(int64_t{10L}, 2L); }, 5},
140+
{"TenDivMinusOne", [] { return CheckedDiv(int64_t{10L}, -1L); }, -10},
141+
{"MinusTenDivMinusOne", [] { return CheckedDiv(int64_t{-10L}, -1L); },
142+
10},
143+
{"MinusTenDivTwo", [] { return CheckedDiv(int64_t{-10L}, 2L); }, -5},
144+
{"OneDivZero", [] { return CheckedDiv(int64_t{1L}, 0L); },
118145
absl::InvalidArgumentError("divide by zero")},
119146
{"IntMinDivMinusOne",
120-
[] { return CheckedDiv(std::numeric_limits<int64_t>::lowest(), -1L); },
147+
[] {
148+
return CheckedDiv(std::numeric_limits<int64_t>::lowest(),
149+
int64_t{-1L});
150+
},
121151
absl::OutOfRangeError("integer overflow")},
122152

123153
// Modulus cases.
124-
{"ZeroModTwo", [] { return CheckedMod(0, 2L); }, 0},
125-
{"TwoModTwo", [] { return CheckedMod(2L, 2L); }, 0},
126-
{"ThreeModTwo", [] { return CheckedMod(3L, 2L); }, 1L},
127-
{"TwoModZero", [] { return CheckedMod(2L, 0); },
154+
{"ZeroModTwo", [] { return CheckedMod(int64_t{0}, 2L); }, 0},
155+
{"TwoModTwo", [] { return CheckedMod(int64_t{2L}, 2L); }, 0},
156+
{"ThreeModTwo", [] { return CheckedMod(int64_t{3L}, 2L); }, 1L},
157+
{"TwoModZero", [] { return CheckedMod(int64_t{2L}, 0); },
128158
absl::InvalidArgumentError("modulus by zero")},
129159
{"IntMinModTwo",
130-
[] { return CheckedMod(std::numeric_limits<int64_t>::lowest(), 2L); },
160+
[] {
161+
return CheckedMod(std::numeric_limits<int64_t>::lowest(),
162+
int64_t{2L});
163+
},
131164
0},
132165
{"IntMaxModMinusOne",
133-
[] { return CheckedMod(std::numeric_limits<int64_t>::max(), -1L); },
166+
[] {
167+
return CheckedMod(std::numeric_limits<int64_t>::max(), int64_t{-1L});
168+
},
134169
0},
135170
{"IntMinModMinusOne",
136-
[] { return CheckedMod(std::numeric_limits<int64_t>::lowest(), -1L); },
171+
[] {
172+
return CheckedMod(std::numeric_limits<int64_t>::lowest(),
173+
int64_t{-1L});
174+
},
137175
absl::OutOfRangeError("integer overflow")},
138176

139177
// Negation cases.
140-
{"NegateOne", [] { return CheckedNegation(1L); }, -1L},
178+
{"NegateOne", [] { return CheckedNegation(int64_t{1L}); }, -1L},
141179
{"NegateMinInt64",
142180
[] { return CheckedNegation(std::numeric_limits<int64_t>::lowest()); },
143181
absl::OutOfRangeError("integer overflow")},
144182

145183
// Numeric conversion cases for uint -> int, double -> int
146-
{"Uint64Conversion", [] { return CheckedUint64ToInt64(1UL); }, 1L},
184+
{"Uint64Conversion", [] { return CheckedUint64ToInt64(uint64_t{1UL}); },
185+
1L},
147186
{"Uint32MaxConversion",
148187
[] {
149188
return CheckedUint64ToInt64(
@@ -156,7 +195,8 @@ INSTANTIATE_TEST_SUITE_P(
156195
static_cast<uint64_t>(std::numeric_limits<uint64_t>::max()));
157196
},
158197
absl::OutOfRangeError("out of int64 range")},
159-
{"DoubleConversion", [] { return CheckedDoubleToInt64(100.1); }, 100L},
198+
{"DoubleConversion", [] { return CheckedDoubleToInt64(double{100.1}); },
199+
100L},
160200
{"DoubleInt64MaxConversionError",
161201
[] {
162202
return CheckedDoubleToInt64(
@@ -201,9 +241,10 @@ INSTANTIATE_TEST_SUITE_P(
201241
},
202242
absl::OutOfRangeError("out of int64 range")},
203243
{"NegRangeConversionError",
204-
[] { return CheckedDoubleToInt64(-1.0e99); },
244+
[] { return CheckedDoubleToInt64(double{-1.0e99}); },
205245
absl::OutOfRangeError("out of int64 range")},
206-
{"PosRangeConversionError", [] { return CheckedDoubleToInt64(1.0e99); },
246+
{"PosRangeConversionError",
247+
[] { return CheckedDoubleToInt64(double{1.0e99}); },
207248
absl::OutOfRangeError("out of int64 range")},
208249
}),
209250
[](const testing::TestParamInfo<CheckedIntResultTest::ParamType>& info) {
@@ -218,51 +259,58 @@ INSTANTIATE_TEST_SUITE_P(
218259
CheckedUintMathTest, CheckedUintResultTest,
219260
ValuesIn(std::vector<UintTestCase>{
220261
// Addition tests.
221-
{"OneAddOne", [] { return CheckedAdd(1UL, 1UL); }, 2UL},
222-
{"ZeroAddOne", [] { return CheckedAdd(0, 1UL); }, 1UL},
223-
{"OneAddZero", [] { return CheckedAdd(1UL, 0); }, 1UL},
262+
{"OneAddOne", [] { return CheckedAdd(uint64_t{1UL}, 1UL); }, 2UL},
263+
{"ZeroAddOne", [] { return CheckedAdd(uint64_t{0}, 1UL); }, 1UL},
264+
{"OneAddZero", [] { return CheckedAdd(uint64_t{1UL}, 0); }, 1UL},
224265
{"OneAddIntMax",
225-
[] { return CheckedAdd(1UL, std::numeric_limits<uint64_t>::max()); },
266+
[] {
267+
return CheckedAdd(uint64_t{1UL},
268+
std::numeric_limits<uint64_t>::max());
269+
},
226270
absl::OutOfRangeError("unsigned integer overflow")},
227271

228272
// Subtraction tests.
229-
{"OneSubOne", [] { return CheckedSub(1UL, 1UL); }, 0},
230-
{"ZeroSubOne", [] { return CheckedSub(0, 1UL); },
273+
{"OneSubOne", [] { return CheckedSub(uint64_t{1UL}, 1UL); }, 0},
274+
{"ZeroSubOne", [] { return CheckedSub(uint64_t{0}, 1UL); },
231275
absl::OutOfRangeError("unsigned integer overflow")},
232-
{"OneSubZero", [] { return CheckedSub(1UL, 0); }, 1UL},
276+
{"OneSubZero", [] { return CheckedSub(uint64_t{1UL}, 0); }, 1UL},
233277

234278
// Multiplication tests.
235-
{"OneMulOne", [] { return CheckedMul(1UL, 1UL); }, 1UL},
236-
{"ZeroMulOne", [] { return CheckedMul(0, 1UL); }, 0},
237-
{"OneMulZero", [] { return CheckedMul(1UL, 0); }, 0},
279+
{"OneMulOne", [] { return CheckedMul(uint64_t{1UL}, 1UL); }, 1UL},
280+
{"ZeroMulOne", [] { return CheckedMul(uint64_t{0}, 1UL); }, 0},
281+
{"OneMulZero", [] { return CheckedMul(uint64_t{1UL}, 0); }, 0},
238282
{"TwoMulUintMax",
239-
[] { return CheckedMul(2UL, std::numeric_limits<uint64_t>::max()); },
283+
[] {
284+
return CheckedMul(uint64_t{2UL},
285+
std::numeric_limits<uint64_t>::max());
286+
},
240287
absl::OutOfRangeError("unsigned integer overflow")},
241288

242289
// Division tests.
243-
{"TwoDivTwo", [] { return CheckedDiv(2UL, 2UL); }, 1UL},
244-
{"TwoDivFour", [] { return CheckedDiv(2UL, 4UL); }, 0},
245-
{"OneDivZero", [] { return CheckedDiv(1UL, 0); },
290+
{"TwoDivTwo", [] { return CheckedDiv(uint64_t{2UL}, 2UL); }, 1UL},
291+
{"TwoDivFour", [] { return CheckedDiv(uint64_t{2UL}, 4UL); }, 0},
292+
{"OneDivZero", [] { return CheckedDiv(uint64_t{1UL}, 0); },
246293
absl::InvalidArgumentError("divide by zero")},
247294

248295
// Modulus tests.
249-
{"TwoModTwo", [] { return CheckedMod(2UL, 2UL); }, 0},
250-
{"TwoModFour", [] { return CheckedMod(2UL, 4UL); }, 2UL},
251-
{"OneModZero", [] { return CheckedMod(1UL, 0); },
296+
{"TwoModTwo", [] { return CheckedMod(uint64_t{2UL}, 2UL); }, 0},
297+
{"TwoModFour", [] { return CheckedMod(uint64_t{2UL}, 4UL); }, 2UL},
298+
{"OneModZero", [] { return CheckedMod(uint64_t{1UL}, 0); },
252299
absl::InvalidArgumentError("modulus by zero")},
253300

254301
// Conversion test cases for int -> uint, double -> uint.
255-
{"Int64Conversion", [] { return CheckedInt64ToUint64(1L); }, 1UL},
302+
{"Int64Conversion", [] { return CheckedInt64ToUint64(int64_t{1L}); },
303+
1UL},
256304
{"Int64MaxConversion",
257305
[] {
258306
return CheckedInt64ToUint64(std::numeric_limits<int64_t>::max());
259307
},
260308
static_cast<uint64_t>(std::numeric_limits<int64_t>::max())},
261309
{"NegativeInt64ConversionError",
262-
[] { return CheckedInt64ToUint64(-1L); },
310+
[] { return CheckedInt64ToUint64(int64_t{-1L}); },
263311
absl::OutOfRangeError("out of uint64 range")},
264-
{"DoubleConversion", [] { return CheckedDoubleToUint64(100.1); },
265-
100UL},
312+
{"DoubleConversion",
313+
[] { return CheckedDoubleToUint64(double{100.1}); }, 100UL},
266314
{"DoubleUint64MaxConversionError",
267315
[] {
268316
return CheckedDoubleToUint64(
@@ -287,13 +335,14 @@ INSTANTIATE_TEST_SUITE_P(
287335
std::numeric_limits<double>::infinity());
288336
},
289337
absl::OutOfRangeError("out of uint64 range")},
290-
{"NegConversionError", [] { return CheckedDoubleToUint64(-1.1); },
338+
{"NegConversionError",
339+
[] { return CheckedDoubleToUint64(double{-1.1}); },
291340
absl::OutOfRangeError("out of uint64 range")},
292341
{"NegRangeConversionError",
293-
[] { return CheckedDoubleToUint64(-1.0e99); },
342+
[] { return CheckedDoubleToUint64(double{-1.0e99}); },
294343
absl::OutOfRangeError("out of uint64 range")},
295344
{"PosRangeConversionError",
296-
[] { return CheckedDoubleToUint64(1.0e99); },
345+
[] { return CheckedDoubleToUint64(double{1.0e99}); },
297346
absl::OutOfRangeError("out of uint64 range")},
298347
}),
299348
[](const testing::TestParamInfo<CheckedUintResultTest::ParamType>& info) {
@@ -571,7 +620,8 @@ TEST_P(CheckedConvertInt64Int32Test, Conversions) { ExpectResult(GetParam()); }
571620
INSTANTIATE_TEST_SUITE_P(
572621
CheckedConvertInt64Int32Test, CheckedConvertInt64Int32Test,
573622
ValuesIn(std::vector<ConvertInt64Int32TestCase>{
574-
{"SimpleConversion", [] { return CheckedInt64ToInt32(1L); }, 1},
623+
{"SimpleConversion", [] { return CheckedInt64ToInt32(int64_t{1L}); },
624+
1},
575625
{"Int32MaxConversion",
576626
[] {
577627
return CheckedInt64ToInt32(
@@ -610,7 +660,8 @@ TEST_P(CheckedConvertUint64Uint32Test, Conversions) {
610660
INSTANTIATE_TEST_SUITE_P(
611661
CheckedConvertUint64Uint32Test, CheckedConvertUint64Uint32Test,
612662
ValuesIn(std::vector<ConvertUint64Uint32TestCase>{
613-
{"SimpleConversion", [] { return CheckedUint64ToUint32(1UL); }, 1U},
663+
{"SimpleConversion",
664+
[] { return CheckedUint64ToUint32(uint64_t{1UL}); }, 1U},
614665
{"Uint32MaxConversion",
615666
[] {
616667
return CheckedUint64ToUint32(

0 commit comments

Comments
 (0)