1 //===- llvm/unittest/Support/FileCheckTest.cpp - FileCheck tests --===//
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 #include "llvm/Support/FileCheck.h"
10 #include "../lib/Support/FileCheckImpl.h"
11 #include "llvm/Support/Regex.h"
12 #include "llvm/Testing/Support/Error.h"
13 #include "gtest/gtest.h"
14 #include <tuple>
15 #include <unordered_set>
16
17 using namespace llvm;
18
19 namespace {
20
21 class FileCheckTest : public ::testing::Test {};
22
bufferize(SourceMgr & SM,StringRef Str)23 static StringRef bufferize(SourceMgr &SM, StringRef Str) {
24 std::unique_ptr<MemoryBuffer> Buffer =
25 MemoryBuffer::getMemBufferCopy(Str, "TestBuffer");
26 StringRef StrBufferRef = Buffer->getBuffer();
27 SM.AddNewSourceBuffer(std::move(Buffer), SMLoc());
28 return StrBufferRef;
29 }
30
toString(const std::unordered_set<std::string> & Set)31 static std::string toString(const std::unordered_set<std::string> &Set) {
32 bool First = true;
33 std::string Str;
34 for (StringRef S : Set) {
35 Str += Twine(First ? "{" + S : ", " + S).str();
36 First = false;
37 }
38 Str += '}';
39 return Str;
40 }
41
42 template <typename ErrorT>
expectSameErrors(std::unordered_set<std::string> ExpectedMsgs,Error Err)43 static void expectSameErrors(std::unordered_set<std::string> ExpectedMsgs,
44 Error Err) {
45 auto AnyErrorMsgMatch = [&ExpectedMsgs](std::string &&ErrorMsg) -> bool {
46 for (auto ExpectedMsgItr = ExpectedMsgs.begin(),
47 ExpectedMsgEnd = ExpectedMsgs.end();
48 ExpectedMsgItr != ExpectedMsgEnd; ++ExpectedMsgItr) {
49 if (ErrorMsg.find(*ExpectedMsgItr) != std::string::npos) {
50 ExpectedMsgs.erase(ExpectedMsgItr);
51 return true;
52 }
53 }
54 return false;
55 };
56
57 Error RemainingErrors = std::move(Err);
58 do {
59 RemainingErrors =
60 handleErrors(std::move(RemainingErrors), [&](const ErrorT &E) {
61 EXPECT_TRUE(AnyErrorMsgMatch(E.message()))
62 << "Unexpected error message:" << std::endl
63 << E.message();
64 });
65 } while (RemainingErrors && !ExpectedMsgs.empty());
66 EXPECT_THAT_ERROR(std::move(RemainingErrors), Succeeded());
67 EXPECT_TRUE(ExpectedMsgs.empty())
68 << "Error message(s) not found:" << std::endl
69 << toString(ExpectedMsgs);
70 }
71
72 template <typename ErrorT>
expectError(StringRef ExpectedMsg,Error Err)73 static void expectError(StringRef ExpectedMsg, Error Err) {
74 expectSameErrors<ErrorT>({ExpectedMsg.str()}, std::move(Err));
75 }
76
expectDiagnosticError(StringRef ExpectedMsg,Error Err)77 static void expectDiagnosticError(StringRef ExpectedMsg, Error Err) {
78 expectError<ErrorDiagnostic>(ExpectedMsg, std::move(Err));
79 }
80
81 constexpr uint64_t MaxUint64 = std::numeric_limits<uint64_t>::max();
82 constexpr int64_t MaxInt64 = std::numeric_limits<int64_t>::max();
83 constexpr int64_t MinInt64 = std::numeric_limits<int64_t>::min();
84 constexpr uint64_t AbsoluteMinInt64 =
85 static_cast<uint64_t>(-(MinInt64 + 1)) + 1;
86 constexpr uint64_t AbsoluteMaxInt64 = static_cast<uint64_t>(MaxInt64);
87
88 struct ExpressionFormatParameterisedFixture
89 : public ::testing::TestWithParam<ExpressionFormat::Kind> {
90 bool Signed;
91 bool AllowHex;
92 bool AllowUpperHex;
93 ExpressionFormat Format;
94 Regex WildcardRegex;
95
96 StringRef TenStr;
97 StringRef FifteenStr;
98 std::string MaxUint64Str;
99 std::string MaxInt64Str;
100 std::string MinInt64Str;
101 StringRef FirstInvalidCharDigits;
102 StringRef AcceptedHexOnlyDigits;
103 StringRef RefusedHexOnlyDigits;
104
105 SourceMgr SM;
106
SetUp__anon52e0d15e0111::ExpressionFormatParameterisedFixture107 void SetUp() {
108 ExpressionFormat::Kind Kind = GetParam();
109 AllowHex = Kind == ExpressionFormat::Kind::HexLower ||
110 Kind == ExpressionFormat::Kind::HexUpper;
111 AllowUpperHex = Kind == ExpressionFormat::Kind::HexUpper;
112 Signed = Kind == ExpressionFormat::Kind::Signed;
113 Format = ExpressionFormat(Kind);
114
115 if (!AllowHex) {
116 MaxUint64Str = std::to_string(MaxUint64);
117 MaxInt64Str = std::to_string(MaxInt64);
118 MinInt64Str = std::to_string(MinInt64);
119 TenStr = "10";
120 FifteenStr = "15";
121 FirstInvalidCharDigits = "aA";
122 AcceptedHexOnlyDigits = RefusedHexOnlyDigits = "N/A";
123 return;
124 }
125
126 MaxUint64Str = AllowUpperHex ? "FFFFFFFFFFFFFFFF" : "ffffffffffffffff";
127 MaxInt64Str = AllowUpperHex ? "7FFFFFFFFFFFFFFF" : "7fffffffffffffff";
128 TenStr = AllowUpperHex ? "A" : "a";
129 FifteenStr = AllowUpperHex ? "F" : "f";
130 AcceptedHexOnlyDigits = AllowUpperHex ? "ABCDEF" : "abcdef";
131 RefusedHexOnlyDigits = AllowUpperHex ? "abcdef" : "ABCDEF";
132 MinInt64Str = "N/A";
133 FirstInvalidCharDigits = "gG";
134 }
135
checkWildcardRegexMatch__anon52e0d15e0111::ExpressionFormatParameterisedFixture136 void checkWildcardRegexMatch(StringRef Input) {
137 SmallVector<StringRef, 4> Matches;
138 ASSERT_TRUE(WildcardRegex.match(Input, &Matches))
139 << "Wildcard regex does not match " << Input;
140 EXPECT_EQ(Matches[0], Input);
141 }
142
checkWildcardRegexMatchFailure__anon52e0d15e0111::ExpressionFormatParameterisedFixture143 void checkWildcardRegexMatchFailure(StringRef Input) {
144 EXPECT_FALSE(WildcardRegex.match(Input));
145 }
146
checkMatchingString__anon52e0d15e0111::ExpressionFormatParameterisedFixture147 template <class T> void checkMatchingString(T Val, StringRef ExpectedStr) {
148 Expected<std::string> MatchingString =
149 Format.getMatchingString(ExpressionValue(Val));
150 ASSERT_THAT_EXPECTED(MatchingString, Succeeded())
151 << "No matching string for " << Val;
152 EXPECT_EQ(*MatchingString, ExpectedStr);
153 }
154
checkMatchingStringFailure__anon52e0d15e0111::ExpressionFormatParameterisedFixture155 template <class T> void checkMatchingStringFailure(T Val) {
156 Expected<std::string> MatchingString =
157 Format.getMatchingString(ExpressionValue(Val));
158 // Error message tested in ExpressionValue unit tests.
159 EXPECT_THAT_EXPECTED(MatchingString, Failed());
160 }
161
getValueFromStringReprFailure__anon52e0d15e0111::ExpressionFormatParameterisedFixture162 Expected<ExpressionValue> getValueFromStringReprFailure(StringRef Str) {
163 StringRef BufferizedStr = bufferize(SM, Str);
164 return Format.valueFromStringRepr(BufferizedStr, SM);
165 }
166
167 template <class T>
checkValueFromStringRepr__anon52e0d15e0111::ExpressionFormatParameterisedFixture168 void checkValueFromStringRepr(StringRef Str, T ExpectedVal) {
169 Expected<ExpressionValue> ResultValue = getValueFromStringReprFailure(Str);
170 ASSERT_THAT_EXPECTED(ResultValue, Succeeded())
171 << "Failed to get value from " << Str;
172 ASSERT_EQ(ResultValue->isNegative(), ExpectedVal < 0)
173 << "Value for " << Str << " is not " << ExpectedVal;
174 if (ResultValue->isNegative())
175 EXPECT_EQ(cantFail(ResultValue->getSignedValue()),
176 static_cast<int64_t>(ExpectedVal));
177 else
178 EXPECT_EQ(cantFail(ResultValue->getUnsignedValue()),
179 static_cast<uint64_t>(ExpectedVal));
180 }
181
checkValueFromStringReprFailure__anon52e0d15e0111::ExpressionFormatParameterisedFixture182 void checkValueFromStringReprFailure(StringRef Str) {
183 StringRef OverflowErrorStr = "unable to represent numeric value";
184 Expected<ExpressionValue> ResultValue = getValueFromStringReprFailure(Str);
185 expectDiagnosticError(OverflowErrorStr, ResultValue.takeError());
186 }
187 };
188
TEST_P(ExpressionFormatParameterisedFixture,FormatGetWildcardRegex)189 TEST_P(ExpressionFormatParameterisedFixture, FormatGetWildcardRegex) {
190 // Wildcard regex is valid.
191 Expected<StringRef> WildcardPattern = Format.getWildcardRegex();
192 ASSERT_THAT_EXPECTED(WildcardPattern, Succeeded());
193 WildcardRegex = Regex((Twine("^") + *WildcardPattern).str());
194 ASSERT_TRUE(WildcardRegex.isValid());
195
196 // Does not match empty string.
197 checkWildcardRegexMatchFailure("");
198
199 // Matches all decimal digits and matches several of them.
200 checkWildcardRegexMatch("0123456789");
201
202 // Matches negative digits.
203 if (Signed)
204 checkWildcardRegexMatch("-42");
205 else
206 checkWildcardRegexMatchFailure("-42");
207
208 // Check non digits or digits with wrong casing are not matched.
209 if (AllowHex) {
210 checkWildcardRegexMatch(AcceptedHexOnlyDigits);
211 checkWildcardRegexMatchFailure(RefusedHexOnlyDigits);
212 }
213 checkWildcardRegexMatchFailure(FirstInvalidCharDigits);
214 }
215
TEST_P(ExpressionFormatParameterisedFixture,FormatGetMatchingString)216 TEST_P(ExpressionFormatParameterisedFixture, FormatGetMatchingString) {
217 checkMatchingString(0, "0");
218 checkMatchingString(9, "9");
219
220 if (Signed) {
221 checkMatchingString(-5, "-5");
222 checkMatchingStringFailure(MaxUint64);
223 checkMatchingString(MaxInt64, MaxInt64Str);
224 checkMatchingString(MinInt64, MinInt64Str);
225 } else {
226 checkMatchingStringFailure(-5);
227 checkMatchingString(MaxUint64, MaxUint64Str);
228 checkMatchingString(MaxInt64, MaxInt64Str);
229 checkMatchingStringFailure(MinInt64);
230 }
231
232 checkMatchingString(10, TenStr);
233 checkMatchingString(15, FifteenStr);
234 }
235
TEST_P(ExpressionFormatParameterisedFixture,FormatValueFromStringRepr)236 TEST_P(ExpressionFormatParameterisedFixture, FormatValueFromStringRepr) {
237 checkValueFromStringRepr("0", 0);
238 checkValueFromStringRepr("9", 9);
239
240 if (Signed) {
241 checkValueFromStringRepr("-5", -5);
242 checkValueFromStringReprFailure(MaxUint64Str);
243 } else {
244 checkValueFromStringReprFailure("-5");
245 checkValueFromStringRepr(MaxUint64Str, MaxUint64);
246 }
247
248 checkValueFromStringRepr(TenStr, 10);
249 checkValueFromStringRepr(FifteenStr, 15);
250
251 // Wrong casing is not tested because valueFromStringRepr() relies on
252 // StringRef's getAsInteger() which does not allow to restrict casing.
253 checkValueFromStringReprFailure("G");
254 }
255
TEST_P(ExpressionFormatParameterisedFixture,FormatBoolOperator)256 TEST_P(ExpressionFormatParameterisedFixture, FormatBoolOperator) {
257 EXPECT_TRUE(bool(Format));
258 }
259
260 INSTANTIATE_TEST_CASE_P(AllowedExplicitExpressionFormat,
261 ExpressionFormatParameterisedFixture,
262 ::testing::Values(ExpressionFormat::Kind::Unsigned,
263 ExpressionFormat::Kind::Signed,
264 ExpressionFormat::Kind::HexLower,
265 ExpressionFormat::Kind::HexUpper), );
266
TEST_F(FileCheckTest,NoFormatProperties)267 TEST_F(FileCheckTest, NoFormatProperties) {
268 ExpressionFormat NoFormat(ExpressionFormat::Kind::NoFormat);
269 expectError<StringError>("trying to match value with invalid format",
270 NoFormat.getWildcardRegex().takeError());
271 expectError<StringError>(
272 "trying to match value with invalid format",
273 NoFormat.getMatchingString(ExpressionValue(18u)).takeError());
274 EXPECT_FALSE(bool(NoFormat));
275 }
276
TEST_F(FileCheckTest,FormatEqualityOperators)277 TEST_F(FileCheckTest, FormatEqualityOperators) {
278 ExpressionFormat UnsignedFormat(ExpressionFormat::Kind::Unsigned);
279 ExpressionFormat UnsignedFormat2(ExpressionFormat::Kind::Unsigned);
280 EXPECT_TRUE(UnsignedFormat == UnsignedFormat2);
281 EXPECT_FALSE(UnsignedFormat != UnsignedFormat2);
282
283 ExpressionFormat HexLowerFormat(ExpressionFormat::Kind::HexLower);
284 EXPECT_FALSE(UnsignedFormat == HexLowerFormat);
285 EXPECT_TRUE(UnsignedFormat != HexLowerFormat);
286
287 ExpressionFormat NoFormat(ExpressionFormat::Kind::NoFormat);
288 ExpressionFormat NoFormat2(ExpressionFormat::Kind::NoFormat);
289 EXPECT_FALSE(NoFormat == NoFormat2);
290 EXPECT_TRUE(NoFormat != NoFormat2);
291 }
292
TEST_F(FileCheckTest,FormatKindEqualityOperators)293 TEST_F(FileCheckTest, FormatKindEqualityOperators) {
294 ExpressionFormat UnsignedFormat(ExpressionFormat::Kind::Unsigned);
295 EXPECT_TRUE(UnsignedFormat == ExpressionFormat::Kind::Unsigned);
296 EXPECT_FALSE(UnsignedFormat != ExpressionFormat::Kind::Unsigned);
297 EXPECT_FALSE(UnsignedFormat == ExpressionFormat::Kind::HexLower);
298 EXPECT_TRUE(UnsignedFormat != ExpressionFormat::Kind::HexLower);
299 ExpressionFormat NoFormat(ExpressionFormat::Kind::NoFormat);
300 EXPECT_TRUE(NoFormat == ExpressionFormat::Kind::NoFormat);
301 EXPECT_FALSE(NoFormat != ExpressionFormat::Kind::NoFormat);
302 }
303
304 template <class T1, class T2>
doValueOperation(binop_eval_t Operation,T1 LeftValue,T2 RightValue)305 static Expected<ExpressionValue> doValueOperation(binop_eval_t Operation,
306 T1 LeftValue, T2 RightValue) {
307 ExpressionValue LeftOperand(LeftValue);
308 ExpressionValue RightOperand(RightValue);
309 return Operation(LeftOperand, RightOperand);
310 }
311
312 template <class T>
expectValueEqual(ExpressionValue ActualValue,T ExpectedValue)313 static void expectValueEqual(ExpressionValue ActualValue, T ExpectedValue) {
314 EXPECT_EQ(ExpectedValue < 0, ActualValue.isNegative());
315 if (ExpectedValue < 0) {
316 Expected<int64_t> SignedActualValue = ActualValue.getSignedValue();
317 ASSERT_THAT_EXPECTED(SignedActualValue, Succeeded());
318 EXPECT_EQ(*SignedActualValue, static_cast<int64_t>(ExpectedValue));
319 } else {
320 Expected<uint64_t> UnsignedActualValue = ActualValue.getUnsignedValue();
321 ASSERT_THAT_EXPECTED(UnsignedActualValue, Succeeded());
322 EXPECT_EQ(*UnsignedActualValue, static_cast<uint64_t>(ExpectedValue));
323 }
324 }
325
326 template <class T1, class T2, class TR>
expectOperationValueResult(binop_eval_t Operation,T1 LeftValue,T2 RightValue,TR ResultValue)327 static void expectOperationValueResult(binop_eval_t Operation, T1 LeftValue,
328 T2 RightValue, TR ResultValue) {
329 Expected<ExpressionValue> OperationResult =
330 doValueOperation(Operation, LeftValue, RightValue);
331 ASSERT_THAT_EXPECTED(OperationResult, Succeeded());
332 expectValueEqual(*OperationResult, ResultValue);
333 }
334
335 template <class T1, class T2>
expectOperationValueResult(binop_eval_t Operation,T1 LeftValue,T2 RightValue)336 static void expectOperationValueResult(binop_eval_t Operation, T1 LeftValue,
337 T2 RightValue) {
338 expectError<OverflowError>(
339 "overflow error",
340 doValueOperation(Operation, LeftValue, RightValue).takeError());
341 }
342
TEST_F(FileCheckTest,ExpressionValueGetUnsigned)343 TEST_F(FileCheckTest, ExpressionValueGetUnsigned) {
344 // Test positive value.
345 Expected<uint64_t> UnsignedValue = ExpressionValue(10).getUnsignedValue();
346 ASSERT_THAT_EXPECTED(UnsignedValue, Succeeded());
347 EXPECT_EQ(*UnsignedValue, 10U);
348
349 // Test 0.
350 UnsignedValue = ExpressionValue(0).getUnsignedValue();
351 ASSERT_THAT_EXPECTED(UnsignedValue, Succeeded());
352 EXPECT_EQ(*UnsignedValue, 0U);
353
354 // Test max positive value.
355 UnsignedValue = ExpressionValue(MaxUint64).getUnsignedValue();
356 ASSERT_THAT_EXPECTED(UnsignedValue, Succeeded());
357 EXPECT_EQ(*UnsignedValue, MaxUint64);
358
359 // Test failure with negative value.
360 expectError<OverflowError>(
361 "overflow error", ExpressionValue(-1).getUnsignedValue().takeError());
362
363 // Test failure with min negative value.
364 expectError<OverflowError>(
365 "overflow error",
366 ExpressionValue(MinInt64).getUnsignedValue().takeError());
367 }
368
TEST_F(FileCheckTest,ExpressionValueGetSigned)369 TEST_F(FileCheckTest, ExpressionValueGetSigned) {
370 // Test positive value.
371 Expected<int64_t> SignedValue = ExpressionValue(10).getSignedValue();
372 ASSERT_THAT_EXPECTED(SignedValue, Succeeded());
373 EXPECT_EQ(*SignedValue, 10);
374
375 // Test 0.
376 SignedValue = ExpressionValue(0).getSignedValue();
377 ASSERT_THAT_EXPECTED(SignedValue, Succeeded());
378 EXPECT_EQ(*SignedValue, 0);
379
380 // Test max int64_t.
381 SignedValue = ExpressionValue(MaxInt64).getSignedValue();
382 ASSERT_THAT_EXPECTED(SignedValue, Succeeded());
383 EXPECT_EQ(*SignedValue, MaxInt64);
384
385 // Test failure with too big positive value.
386 expectError<OverflowError>(
387 "overflow error", ExpressionValue(static_cast<uint64_t>(MaxInt64) + 1)
388 .getSignedValue()
389 .takeError());
390
391 // Test failure with max uint64_t.
392 expectError<OverflowError>(
393 "overflow error",
394 ExpressionValue(MaxUint64).getSignedValue().takeError());
395
396 // Test negative value.
397 SignedValue = ExpressionValue(-10).getSignedValue();
398 ASSERT_THAT_EXPECTED(SignedValue, Succeeded());
399 EXPECT_EQ(*SignedValue, -10);
400
401 // Test min int64_t.
402 SignedValue = ExpressionValue(MinInt64).getSignedValue();
403 ASSERT_THAT_EXPECTED(SignedValue, Succeeded());
404 EXPECT_EQ(*SignedValue, MinInt64);
405 }
406
TEST_F(FileCheckTest,ExpressionValueAbsolute)407 TEST_F(FileCheckTest, ExpressionValueAbsolute) {
408 // Test positive value.
409 expectValueEqual(ExpressionValue(10).getAbsolute(), 10);
410
411 // Test 0.
412 expectValueEqual(ExpressionValue(0).getAbsolute(), 0);
413
414 // Test max uint64_t.
415 expectValueEqual(ExpressionValue(MaxUint64).getAbsolute(), MaxUint64);
416
417 // Test negative value.
418 expectValueEqual(ExpressionValue(-10).getAbsolute(), 10);
419
420 // Test absence of overflow on min int64_t.
421 expectValueEqual(ExpressionValue(MinInt64).getAbsolute(),
422 static_cast<uint64_t>(-(MinInt64 + 10)) + 10);
423 }
424
TEST_F(FileCheckTest,ExpressionValueAddition)425 TEST_F(FileCheckTest, ExpressionValueAddition) {
426 // Test both negative values.
427 expectOperationValueResult(operator+, -10, -10, -20);
428
429 // Test both negative values with underflow.
430 expectOperationValueResult(operator+, MinInt64, -1);
431 expectOperationValueResult(operator+, MinInt64, MinInt64);
432
433 // Test negative and positive value.
434 expectOperationValueResult(operator+, -10, 10, 0);
435 expectOperationValueResult(operator+, -10, 11, 1);
436 expectOperationValueResult(operator+, -11, 10, -1);
437
438 // Test positive and negative value.
439 expectOperationValueResult(operator+, 10, -10, 0);
440 expectOperationValueResult(operator+, 10, -11, -1);
441 expectOperationValueResult(operator+, 11, -10, 1);
442
443 // Test both positive values.
444 expectOperationValueResult(operator+, 10, 10, 20);
445
446 // Test both positive values with overflow.
447 expectOperationValueResult(operator+, MaxUint64, 1);
448 expectOperationValueResult(operator+, MaxUint64, MaxUint64);
449 }
450
TEST_F(FileCheckTest,ExpressionValueSubtraction)451 TEST_F(FileCheckTest, ExpressionValueSubtraction) {
452 // Test negative value and value bigger than int64_t max.
453 expectOperationValueResult(operator-, -10, MaxUint64);
454
455 // Test negative and positive value with underflow.
456 expectOperationValueResult(operator-, MinInt64, 1);
457
458 // Test negative and positive value.
459 expectOperationValueResult(operator-, -10, 10, -20);
460
461 // Test both negative values.
462 expectOperationValueResult(operator-, -10, -10, 0);
463 expectOperationValueResult(operator-, -11, -10, -1);
464 expectOperationValueResult(operator-, -10, -11, 1);
465
466 // Test positive and negative values.
467 expectOperationValueResult(operator-, 10, -10, 20);
468
469 // Test both positive values with result positive.
470 expectOperationValueResult(operator-, 10, 5, 5);
471
472 // Test both positive values with underflow.
473 expectOperationValueResult(operator-, 0, MaxUint64);
474 expectOperationValueResult(operator-, 0,
475 static_cast<uint64_t>(-(MinInt64 + 10)) + 11);
476
477 // Test both positive values with result < -(max int64_t)
478 expectOperationValueResult(operator-, 10,
479 static_cast<uint64_t>(MaxInt64) + 11,
480 -MaxInt64 - 1);
481
482 // Test both positive values with 0 > result > -(max int64_t)
483 expectOperationValueResult(operator-, 10, 11, -1);
484 }
485
TEST_F(FileCheckTest,ExpressionValueMultiplication)486 TEST_F(FileCheckTest, ExpressionValueMultiplication) {
487 // Test mixed signed values.
488 expectOperationValueResult(operator*, -3, 10, -30);
489 expectOperationValueResult(operator*, 2, -17, -34);
490 expectOperationValueResult(operator*, 0, MinInt64, 0);
491 expectOperationValueResult(operator*, MinInt64, 1, MinInt64);
492 expectOperationValueResult(operator*, 1, MinInt64, MinInt64);
493 expectOperationValueResult(operator*, MaxInt64, -1, -MaxInt64);
494 expectOperationValueResult(operator*, -1, MaxInt64, -MaxInt64);
495
496 // Test both negative values.
497 expectOperationValueResult(operator*, -3, -10, 30);
498 expectOperationValueResult(operator*, -2, -17, 34);
499 expectOperationValueResult(operator*, MinInt64, -1, AbsoluteMinInt64);
500
501 // Test both positive values.
502 expectOperationValueResult(operator*, 3, 10, 30);
503 expectOperationValueResult(operator*, 2, 17, 34);
504 expectOperationValueResult(operator*, 0, MaxUint64, 0);
505
506 // Test negative results that underflow.
507 expectOperationValueResult(operator*, -10, MaxInt64);
508 expectOperationValueResult(operator*, MaxInt64, -10);
509 expectOperationValueResult(operator*, 10, MinInt64);
510 expectOperationValueResult(operator*, MinInt64, 10);
511 expectOperationValueResult(operator*, -1, MaxUint64);
512 expectOperationValueResult(operator*, MaxUint64, -1);
513 expectOperationValueResult(operator*, -1, AbsoluteMaxInt64 + 2);
514 expectOperationValueResult(operator*, AbsoluteMaxInt64 + 2, -1);
515
516 // Test positive results that overflow.
517 expectOperationValueResult(operator*, 10, MaxUint64);
518 expectOperationValueResult(operator*, MaxUint64, 10);
519 expectOperationValueResult(operator*, MinInt64, -10);
520 expectOperationValueResult(operator*, -10, MinInt64);
521 }
522
TEST_F(FileCheckTest,ExpressionValueDivision)523 TEST_F(FileCheckTest, ExpressionValueDivision) {
524 // Test mixed signed values.
525 expectOperationValueResult(operator/, -30, 10, -3);
526 expectOperationValueResult(operator/, 34, -17, -2);
527 expectOperationValueResult(operator/, 0, -10, 0);
528 expectOperationValueResult(operator/, MinInt64, 1, MinInt64);
529 expectOperationValueResult(operator/, MaxInt64, -1, -MaxInt64);
530 expectOperationValueResult(operator/, -MaxInt64, 1, -MaxInt64);
531
532 // Test both negative values.
533 expectOperationValueResult(operator/, -30, -10, 3);
534 expectOperationValueResult(operator/, -34, -17, 2);
535
536 // Test both positive values.
537 expectOperationValueResult(operator/, 30, 10, 3);
538 expectOperationValueResult(operator/, 34, 17, 2);
539 expectOperationValueResult(operator/, 0, 10, 0);
540
541 // Test divide by zero.
542 expectOperationValueResult(operator/, -10, 0);
543 expectOperationValueResult(operator/, 10, 0);
544 expectOperationValueResult(operator/, 0, 0);
545
546 // Test negative result that underflows.
547 expectOperationValueResult(operator/, MaxUint64, -1);
548 expectOperationValueResult(operator/, AbsoluteMaxInt64 + 2, -1);
549 }
550
TEST_F(FileCheckTest,ExpressionValueEquality)551 TEST_F(FileCheckTest, ExpressionValueEquality) {
552 // Test negative and positive value.
553 EXPECT_FALSE(ExpressionValue(5) == ExpressionValue(-3));
554 EXPECT_TRUE(ExpressionValue(5) != ExpressionValue(-3));
555 EXPECT_FALSE(ExpressionValue(-2) == ExpressionValue(6));
556 EXPECT_TRUE(ExpressionValue(-2) != ExpressionValue(6));
557 EXPECT_FALSE(ExpressionValue(-7) == ExpressionValue(7));
558 EXPECT_TRUE(ExpressionValue(-7) != ExpressionValue(7));
559 EXPECT_FALSE(ExpressionValue(4) == ExpressionValue(-4));
560 EXPECT_TRUE(ExpressionValue(4) != ExpressionValue(-4));
561 EXPECT_FALSE(ExpressionValue(MaxUint64) == ExpressionValue(-1));
562 EXPECT_TRUE(ExpressionValue(MaxUint64) != ExpressionValue(-1));
563
564 // Test both negative values.
565 EXPECT_FALSE(ExpressionValue(-2) == ExpressionValue(-7));
566 EXPECT_TRUE(ExpressionValue(-2) != ExpressionValue(-7));
567 EXPECT_TRUE(ExpressionValue(-3) == ExpressionValue(-3));
568 EXPECT_FALSE(ExpressionValue(-3) != ExpressionValue(-3));
569 EXPECT_FALSE(ExpressionValue(MinInt64) == ExpressionValue(-1));
570 EXPECT_TRUE(ExpressionValue(MinInt64) != ExpressionValue(-1));
571 EXPECT_FALSE(ExpressionValue(MinInt64) == ExpressionValue(-0));
572 EXPECT_TRUE(ExpressionValue(MinInt64) != ExpressionValue(-0));
573
574 // Test both positive values.
575 EXPECT_FALSE(ExpressionValue(8) == ExpressionValue(9));
576 EXPECT_TRUE(ExpressionValue(8) != ExpressionValue(9));
577 EXPECT_TRUE(ExpressionValue(1) == ExpressionValue(1));
578 EXPECT_FALSE(ExpressionValue(1) != ExpressionValue(1));
579
580 // Check the signedness of zero doesn't affect equality.
581 EXPECT_TRUE(ExpressionValue(0) == ExpressionValue(0));
582 EXPECT_FALSE(ExpressionValue(0) != ExpressionValue(0));
583 EXPECT_TRUE(ExpressionValue(0) == ExpressionValue(-0));
584 EXPECT_FALSE(ExpressionValue(0) != ExpressionValue(-0));
585 EXPECT_TRUE(ExpressionValue(-0) == ExpressionValue(0));
586 EXPECT_FALSE(ExpressionValue(-0) != ExpressionValue(0));
587 EXPECT_TRUE(ExpressionValue(-0) == ExpressionValue(-0));
588 EXPECT_FALSE(ExpressionValue(-0) != ExpressionValue(-0));
589 }
590
TEST_F(FileCheckTest,Literal)591 TEST_F(FileCheckTest, Literal) {
592 SourceMgr SM;
593
594 // Eval returns the literal's value.
595 ExpressionLiteral Ten(bufferize(SM, "10"), 10u);
596 Expected<ExpressionValue> Value = Ten.eval();
597 ASSERT_THAT_EXPECTED(Value, Succeeded());
598 EXPECT_EQ(10, cantFail(Value->getSignedValue()));
599 Expected<ExpressionFormat> ImplicitFormat = Ten.getImplicitFormat(SM);
600 ASSERT_THAT_EXPECTED(ImplicitFormat, Succeeded());
601 EXPECT_EQ(*ImplicitFormat, ExpressionFormat::Kind::NoFormat);
602
603 // Min value can be correctly represented.
604 ExpressionLiteral Min(bufferize(SM, std::to_string(MinInt64)), MinInt64);
605 Value = Min.eval();
606 ASSERT_TRUE(bool(Value));
607 EXPECT_EQ(MinInt64, cantFail(Value->getSignedValue()));
608
609 // Max value can be correctly represented.
610 ExpressionLiteral Max(bufferize(SM, std::to_string(MaxUint64)), MaxUint64);
611 Value = Max.eval();
612 ASSERT_THAT_EXPECTED(Value, Succeeded());
613 EXPECT_EQ(MaxUint64, cantFail(Value->getUnsignedValue()));
614 }
615
TEST_F(FileCheckTest,Expression)616 TEST_F(FileCheckTest, Expression) {
617 SourceMgr SM;
618
619 std::unique_ptr<ExpressionLiteral> Ten =
620 std::make_unique<ExpressionLiteral>(bufferize(SM, "10"), 10u);
621 ExpressionLiteral *TenPtr = Ten.get();
622 Expression Expr(std::move(Ten),
623 ExpressionFormat(ExpressionFormat::Kind::HexLower));
624 EXPECT_EQ(Expr.getAST(), TenPtr);
625 EXPECT_EQ(Expr.getFormat(), ExpressionFormat::Kind::HexLower);
626 }
627
628 static void
expectUndefErrors(std::unordered_set<std::string> ExpectedUndefVarNames,Error Err)629 expectUndefErrors(std::unordered_set<std::string> ExpectedUndefVarNames,
630 Error Err) {
631 EXPECT_THAT_ERROR(handleErrors(std::move(Err),
632 [&](const UndefVarError &E) {
633 EXPECT_EQ(ExpectedUndefVarNames.erase(
634 std::string(E.getVarName())),
635 1U);
636 }),
637 Succeeded());
638 EXPECT_TRUE(ExpectedUndefVarNames.empty()) << toString(ExpectedUndefVarNames);
639 }
640
TEST_F(FileCheckTest,NumericVariable)641 TEST_F(FileCheckTest, NumericVariable) {
642 SourceMgr SM;
643
644 // Undefined variable: getValue and eval fail, error returned by eval holds
645 // the name of the undefined variable.
646 NumericVariable FooVar("FOO",
647 ExpressionFormat(ExpressionFormat::Kind::Unsigned), 1);
648 EXPECT_EQ("FOO", FooVar.getName());
649 EXPECT_EQ(FooVar.getImplicitFormat(), ExpressionFormat::Kind::Unsigned);
650 NumericVariableUse FooVarUse("FOO", &FooVar);
651 Expected<ExpressionFormat> ImplicitFormat = FooVarUse.getImplicitFormat(SM);
652 ASSERT_THAT_EXPECTED(ImplicitFormat, Succeeded());
653 EXPECT_EQ(*ImplicitFormat, ExpressionFormat::Kind::Unsigned);
654 EXPECT_FALSE(FooVar.getValue());
655 Expected<ExpressionValue> EvalResult = FooVarUse.eval();
656 expectUndefErrors({"FOO"}, EvalResult.takeError());
657
658 FooVar.setValue(ExpressionValue(42u));
659
660 // Defined variable: getValue and eval return value set.
661 Optional<ExpressionValue> Value = FooVar.getValue();
662 ASSERT_TRUE(Value);
663 EXPECT_EQ(42, cantFail(Value->getSignedValue()));
664 EvalResult = FooVarUse.eval();
665 ASSERT_THAT_EXPECTED(EvalResult, Succeeded());
666 EXPECT_EQ(42, cantFail(EvalResult->getSignedValue()));
667
668 // Clearing variable: getValue and eval fail. Error returned by eval holds
669 // the name of the cleared variable.
670 FooVar.clearValue();
671 EXPECT_FALSE(FooVar.getValue());
672 EvalResult = FooVarUse.eval();
673 expectUndefErrors({"FOO"}, EvalResult.takeError());
674 }
675
TEST_F(FileCheckTest,Binop)676 TEST_F(FileCheckTest, Binop) {
677 SourceMgr SM;
678
679 StringRef ExprStr = bufferize(SM, "FOO+BAR");
680 StringRef FooStr = ExprStr.take_front(3);
681 NumericVariable FooVar(FooStr,
682 ExpressionFormat(ExpressionFormat::Kind::Unsigned), 1);
683 FooVar.setValue(ExpressionValue(42u));
684 std::unique_ptr<NumericVariableUse> FooVarUse =
685 std::make_unique<NumericVariableUse>(FooStr, &FooVar);
686 StringRef BarStr = ExprStr.take_back(3);
687 NumericVariable BarVar(BarStr,
688 ExpressionFormat(ExpressionFormat::Kind::Unsigned), 2);
689 BarVar.setValue(ExpressionValue(18u));
690 std::unique_ptr<NumericVariableUse> BarVarUse =
691 std::make_unique<NumericVariableUse>(BarStr, &BarVar);
692 binop_eval_t doAdd = operator+;
693 BinaryOperation Binop(ExprStr, doAdd, std::move(FooVarUse),
694 std::move(BarVarUse));
695
696 // Defined variables: eval returns right value; implicit format is as
697 // expected.
698 Expected<ExpressionValue> Value = Binop.eval();
699 ASSERT_THAT_EXPECTED(Value, Succeeded());
700 EXPECT_EQ(60, cantFail(Value->getSignedValue()));
701 Expected<ExpressionFormat> ImplicitFormat = Binop.getImplicitFormat(SM);
702 ASSERT_THAT_EXPECTED(ImplicitFormat, Succeeded());
703 EXPECT_EQ(*ImplicitFormat, ExpressionFormat::Kind::Unsigned);
704
705 // 1 undefined variable: eval fails, error contains name of undefined
706 // variable.
707 FooVar.clearValue();
708 Value = Binop.eval();
709 expectUndefErrors({"FOO"}, Value.takeError());
710
711 // 2 undefined variables: eval fails, error contains names of all undefined
712 // variables.
713 BarVar.clearValue();
714 Value = Binop.eval();
715 expectUndefErrors({"FOO", "BAR"}, Value.takeError());
716
717 {
718 // Literal + Variable has format of variable.
719 ExprStr = bufferize(SM, "FOO+18");
720 FooStr = ExprStr.take_front(3);
721 StringRef EighteenStr = ExprStr.take_back(2);
722 FooVarUse = std::make_unique<NumericVariableUse>(FooStr, &FooVar);
723 std::unique_ptr<ExpressionLiteral> Eighteen =
724 std::make_unique<ExpressionLiteral>(EighteenStr, 18u);
725 Binop = BinaryOperation(ExprStr, doAdd, std::move(FooVarUse),
726 std::move(Eighteen));
727 ImplicitFormat = Binop.getImplicitFormat(SM);
728 ASSERT_THAT_EXPECTED(ImplicitFormat, Succeeded());
729 EXPECT_EQ(*ImplicitFormat, ExpressionFormat::Kind::Unsigned);
730 ExprStr = bufferize(SM, "18+FOO");
731 FooStr = ExprStr.take_back(3);
732 EighteenStr = ExprStr.take_front(2);
733 FooVarUse = std::make_unique<NumericVariableUse>(FooStr, &FooVar);
734 Eighteen = std::make_unique<ExpressionLiteral>(EighteenStr, 18u);
735 Binop = BinaryOperation(ExprStr, doAdd, std::move(Eighteen),
736 std::move(FooVarUse));
737 ImplicitFormat = Binop.getImplicitFormat(SM);
738 ASSERT_THAT_EXPECTED(ImplicitFormat, Succeeded());
739 EXPECT_EQ(*ImplicitFormat, ExpressionFormat::Kind::Unsigned);
740 }
741
742 // Variables with different implicit format conflict.
743 ExprStr = bufferize(SM, "FOO+BAZ");
744 FooStr = ExprStr.take_front(3);
745 StringRef BazStr = ExprStr.take_back(3);
746 NumericVariable BazVar(BazStr,
747 ExpressionFormat(ExpressionFormat::Kind::HexLower), 3);
748 FooVarUse = std::make_unique<NumericVariableUse>(FooStr, &FooVar);
749 std::unique_ptr<NumericVariableUse> BazVarUse =
750 std::make_unique<NumericVariableUse>(BazStr, &BazVar);
751 Binop = BinaryOperation(ExprStr, doAdd, std::move(FooVarUse),
752 std::move(BazVarUse));
753 ImplicitFormat = Binop.getImplicitFormat(SM);
754 expectDiagnosticError(
755 "implicit format conflict between 'FOO' (%u) and 'BAZ' (%x), "
756 "need an explicit format specifier",
757 ImplicitFormat.takeError());
758
759 // All variable conflicts are reported.
760 ExprStr = bufferize(SM, "(FOO+BAZ)+(FOO+QUUX)");
761 StringRef Paren1ExprStr = ExprStr.substr(1, 7);
762 FooStr = Paren1ExprStr.take_front(3);
763 BazStr = Paren1ExprStr.take_back(3);
764 StringRef Paren2ExprStr = ExprStr.substr(ExprStr.rfind('(') + 1, 8);
765 StringRef FooStr2 = Paren2ExprStr.take_front(3);
766 StringRef QuuxStr = Paren2ExprStr.take_back(4);
767 FooVarUse = std::make_unique<NumericVariableUse>(FooStr, &FooVar);
768 BazVarUse = std::make_unique<NumericVariableUse>(BazStr, &BazVar);
769 std::unique_ptr<NumericVariableUse> FooVarUse2 =
770 std::make_unique<NumericVariableUse>(FooStr2, &FooVar);
771 NumericVariable QuuxVar(
772 QuuxStr, ExpressionFormat(ExpressionFormat::Kind::HexLower), 4);
773 std::unique_ptr<NumericVariableUse> QuuxVarUse =
774 std::make_unique<NumericVariableUse>(QuuxStr, &QuuxVar);
775 std::unique_ptr<BinaryOperation> Binop1 = std::make_unique<BinaryOperation>(
776 ExprStr.take_front(9), doAdd, std::move(FooVarUse), std::move(BazVarUse));
777 std::unique_ptr<BinaryOperation> Binop2 = std::make_unique<BinaryOperation>(
778 ExprStr.take_back(10), doAdd, std::move(FooVarUse2),
779 std::move(QuuxVarUse));
780 std::unique_ptr<BinaryOperation> OuterBinop =
781 std::make_unique<BinaryOperation>(ExprStr, doAdd, std::move(Binop1),
782 std::move(Binop2));
783 ImplicitFormat = OuterBinop->getImplicitFormat(SM);
784 expectSameErrors<ErrorDiagnostic>(
785 {"implicit format conflict between 'FOO' (%u) and 'BAZ' (%x), "
786 "need an explicit format specifier",
787 "implicit format conflict between 'FOO' (%u) and 'QUUX' (%x), "
788 "need an explicit format specifier"},
789 ImplicitFormat.takeError());
790 }
791
TEST_F(FileCheckTest,ValidVarNameStart)792 TEST_F(FileCheckTest, ValidVarNameStart) {
793 EXPECT_TRUE(Pattern::isValidVarNameStart('a'));
794 EXPECT_TRUE(Pattern::isValidVarNameStart('G'));
795 EXPECT_TRUE(Pattern::isValidVarNameStart('_'));
796 EXPECT_FALSE(Pattern::isValidVarNameStart('2'));
797 EXPECT_FALSE(Pattern::isValidVarNameStart('$'));
798 EXPECT_FALSE(Pattern::isValidVarNameStart('@'));
799 EXPECT_FALSE(Pattern::isValidVarNameStart('+'));
800 EXPECT_FALSE(Pattern::isValidVarNameStart('-'));
801 EXPECT_FALSE(Pattern::isValidVarNameStart(':'));
802 }
803
TEST_F(FileCheckTest,ParseVar)804 TEST_F(FileCheckTest, ParseVar) {
805 SourceMgr SM;
806 StringRef OrigVarName = bufferize(SM, "GoodVar42");
807 StringRef VarName = OrigVarName;
808 Expected<Pattern::VariableProperties> ParsedVarResult =
809 Pattern::parseVariable(VarName, SM);
810 ASSERT_THAT_EXPECTED(ParsedVarResult, Succeeded());
811 EXPECT_EQ(ParsedVarResult->Name, OrigVarName);
812 EXPECT_TRUE(VarName.empty());
813 EXPECT_FALSE(ParsedVarResult->IsPseudo);
814
815 VarName = OrigVarName = bufferize(SM, "$GoodGlobalVar");
816 ParsedVarResult = Pattern::parseVariable(VarName, SM);
817 ASSERT_THAT_EXPECTED(ParsedVarResult, Succeeded());
818 EXPECT_EQ(ParsedVarResult->Name, OrigVarName);
819 EXPECT_TRUE(VarName.empty());
820 EXPECT_FALSE(ParsedVarResult->IsPseudo);
821
822 VarName = OrigVarName = bufferize(SM, "@GoodPseudoVar");
823 ParsedVarResult = Pattern::parseVariable(VarName, SM);
824 ASSERT_THAT_EXPECTED(ParsedVarResult, Succeeded());
825 EXPECT_EQ(ParsedVarResult->Name, OrigVarName);
826 EXPECT_TRUE(VarName.empty());
827 EXPECT_TRUE(ParsedVarResult->IsPseudo);
828
829 VarName = bufferize(SM, "42BadVar");
830 ParsedVarResult = Pattern::parseVariable(VarName, SM);
831 expectDiagnosticError("invalid variable name", ParsedVarResult.takeError());
832
833 VarName = bufferize(SM, "$@");
834 ParsedVarResult = Pattern::parseVariable(VarName, SM);
835 expectDiagnosticError("invalid variable name", ParsedVarResult.takeError());
836
837 VarName = OrigVarName = bufferize(SM, "B@dVar");
838 ParsedVarResult = Pattern::parseVariable(VarName, SM);
839 ASSERT_THAT_EXPECTED(ParsedVarResult, Succeeded());
840 EXPECT_EQ(VarName, OrigVarName.substr(1));
841 EXPECT_EQ(ParsedVarResult->Name, "B");
842 EXPECT_FALSE(ParsedVarResult->IsPseudo);
843
844 VarName = OrigVarName = bufferize(SM, "B$dVar");
845 ParsedVarResult = Pattern::parseVariable(VarName, SM);
846 ASSERT_THAT_EXPECTED(ParsedVarResult, Succeeded());
847 EXPECT_EQ(VarName, OrigVarName.substr(1));
848 EXPECT_EQ(ParsedVarResult->Name, "B");
849 EXPECT_FALSE(ParsedVarResult->IsPseudo);
850
851 VarName = bufferize(SM, "BadVar+");
852 ParsedVarResult = Pattern::parseVariable(VarName, SM);
853 ASSERT_THAT_EXPECTED(ParsedVarResult, Succeeded());
854 EXPECT_EQ(VarName, "+");
855 EXPECT_EQ(ParsedVarResult->Name, "BadVar");
856 EXPECT_FALSE(ParsedVarResult->IsPseudo);
857
858 VarName = bufferize(SM, "BadVar-");
859 ParsedVarResult = Pattern::parseVariable(VarName, SM);
860 ASSERT_THAT_EXPECTED(ParsedVarResult, Succeeded());
861 EXPECT_EQ(VarName, "-");
862 EXPECT_EQ(ParsedVarResult->Name, "BadVar");
863 EXPECT_FALSE(ParsedVarResult->IsPseudo);
864
865 VarName = bufferize(SM, "BadVar:");
866 ParsedVarResult = Pattern::parseVariable(VarName, SM);
867 ASSERT_THAT_EXPECTED(ParsedVarResult, Succeeded());
868 EXPECT_EQ(VarName, ":");
869 EXPECT_EQ(ParsedVarResult->Name, "BadVar");
870 EXPECT_FALSE(ParsedVarResult->IsPseudo);
871 }
872
expectNotFoundError(Error Err)873 static void expectNotFoundError(Error Err) {
874 expectError<NotFoundError>("String not found in input", std::move(Err));
875 }
876
877 class PatternTester {
878 private:
879 size_t LineNumber = 1;
880 SourceMgr SM;
881 FileCheckRequest Req;
882 FileCheckPatternContext Context;
883 Pattern P{Check::CheckPlain, &Context, LineNumber};
884
885 public:
PatternTester()886 PatternTester() {
887 std::vector<StringRef> GlobalDefines = {"#FOO=42", "BAR=BAZ", "#add=7"};
888 // An ASSERT_FALSE would make more sense but cannot be used in a
889 // constructor.
890 EXPECT_THAT_ERROR(Context.defineCmdlineVariables(GlobalDefines, SM),
891 Succeeded());
892 Context.createLineVariable();
893 // Call parsePattern to have @LINE defined.
894 P.parsePattern("N/A", "CHECK", SM, Req);
895 // parsePattern does not expect to be called twice for the same line and
896 // will set FixedStr and RegExStr incorrectly if it is. Therefore prepare
897 // a pattern for a different line.
898 initNextPattern();
899 }
900
initNextPattern()901 void initNextPattern() {
902 P = Pattern(Check::CheckPlain, &Context, ++LineNumber);
903 }
904
getLineNumber() const905 size_t getLineNumber() const { return LineNumber; }
906
907 Expected<std::unique_ptr<Expression>>
parseSubst(StringRef Expr,bool IsLegacyLineExpr=false)908 parseSubst(StringRef Expr, bool IsLegacyLineExpr = false) {
909 StringRef ExprBufferRef = bufferize(SM, Expr);
910 Optional<NumericVariable *> DefinedNumericVariable;
911 return P.parseNumericSubstitutionBlock(
912 ExprBufferRef, DefinedNumericVariable, IsLegacyLineExpr, LineNumber,
913 &Context, SM);
914 }
915
parsePattern(StringRef Pattern)916 bool parsePattern(StringRef Pattern) {
917 StringRef PatBufferRef = bufferize(SM, Pattern);
918 return P.parsePattern(PatBufferRef, "CHECK", SM, Req);
919 }
920
match(StringRef Buffer)921 Expected<size_t> match(StringRef Buffer) {
922 StringRef BufferRef = bufferize(SM, Buffer);
923 size_t MatchLen;
924 return P.match(BufferRef, MatchLen, SM);
925 }
926 };
927
TEST_F(FileCheckTest,ParseNumericSubstitutionBlock)928 TEST_F(FileCheckTest, ParseNumericSubstitutionBlock) {
929 PatternTester Tester;
930
931 // Variable definition.
932
933 expectDiagnosticError("invalid variable name",
934 Tester.parseSubst("%VAR:").takeError());
935
936 expectDiagnosticError("definition of pseudo numeric variable unsupported",
937 Tester.parseSubst("@LINE:").takeError());
938
939 expectDiagnosticError("string variable with name 'BAR' already exists",
940 Tester.parseSubst("BAR:").takeError());
941
942 expectDiagnosticError("unexpected characters after numeric variable name",
943 Tester.parseSubst("VAR GARBAGE:").takeError());
944
945 // Change of format.
946 expectDiagnosticError("format different from previous variable definition",
947 Tester.parseSubst("%X,FOO:").takeError());
948
949 // Invalid format.
950 expectDiagnosticError("invalid matching format specification in expression",
951 Tester.parseSubst("X,VAR1:").takeError());
952 expectDiagnosticError("invalid format specifier in expression",
953 Tester.parseSubst("%F,VAR1:").takeError());
954 expectDiagnosticError("invalid matching format specification in expression",
955 Tester.parseSubst("%X a,VAR1:").takeError());
956
957 // Acceptable variable definition.
958 EXPECT_THAT_EXPECTED(Tester.parseSubst("VAR1:"), Succeeded());
959 EXPECT_THAT_EXPECTED(Tester.parseSubst(" VAR2:"), Succeeded());
960 EXPECT_THAT_EXPECTED(Tester.parseSubst("VAR3 :"), Succeeded());
961 EXPECT_THAT_EXPECTED(Tester.parseSubst("VAR3: "), Succeeded());
962
963 // Acceptable variable definition with format specifier. Use parsePattern for
964 // variables whose definition needs to be visible for later checks.
965 EXPECT_FALSE(Tester.parsePattern("[[#%u, VAR_UNSIGNED:]]"));
966 EXPECT_FALSE(Tester.parsePattern("[[#%x, VAR_LOWER_HEX:]]"));
967 EXPECT_THAT_EXPECTED(Tester.parseSubst("%X, VAR_UPPER_HEX:"), Succeeded());
968
969 // Acceptable variable definition from a numeric expression.
970 EXPECT_THAT_EXPECTED(Tester.parseSubst("FOOBAR: FOO+1"), Succeeded());
971
972 // Numeric expression. Switch to next line to make above valid definition
973 // available in expressions.
974 Tester.initNextPattern();
975
976 // Invalid variable name.
977 expectDiagnosticError("invalid matching constraint or operand format",
978 Tester.parseSubst("%VAR").takeError());
979
980 expectDiagnosticError("invalid pseudo numeric variable '@FOO'",
981 Tester.parseSubst("@FOO").takeError());
982
983 // parsePattern() is used here instead of parseSubst() for the variable to be
984 // recorded in GlobalNumericVariableTable and thus appear defined to
985 // parseNumericVariableUse(). Note that the same pattern object is used for
986 // the parsePattern() and parseSubst() since no initNextPattern() is called,
987 // thus appearing as being on the same line from the pattern's point of view.
988 ASSERT_FALSE(Tester.parsePattern("[[#SAME_LINE_VAR:]]"));
989 expectDiagnosticError("numeric variable 'SAME_LINE_VAR' defined earlier in "
990 "the same CHECK directive",
991 Tester.parseSubst("SAME_LINE_VAR").takeError());
992
993 // Invalid use of variable defined on the same line from an expression not
994 // using any variable defined on the same line.
995 ASSERT_FALSE(Tester.parsePattern("[[#SAME_LINE_EXPR_VAR:@LINE+1]]"));
996 expectDiagnosticError("numeric variable 'SAME_LINE_EXPR_VAR' defined earlier "
997 "in the same CHECK directive",
998 Tester.parseSubst("SAME_LINE_EXPR_VAR").takeError());
999
1000 // Valid use of undefined variable which creates the variable and record it
1001 // in GlobalNumericVariableTable.
1002 ASSERT_THAT_EXPECTED(Tester.parseSubst("UNDEF"), Succeeded());
1003 EXPECT_TRUE(Tester.parsePattern("[[UNDEF:.*]]"));
1004
1005 // Invalid literal.
1006 expectDiagnosticError("unsupported operation 'U'",
1007 Tester.parseSubst("42U").takeError());
1008
1009 // Valid empty expression.
1010 EXPECT_THAT_EXPECTED(Tester.parseSubst(""), Succeeded());
1011
1012 // Invalid equality matching constraint with empty expression.
1013 expectDiagnosticError("empty numeric expression should not have a constraint",
1014 Tester.parseSubst("==").takeError());
1015
1016 // Valid single operand expression.
1017 EXPECT_THAT_EXPECTED(Tester.parseSubst("FOO"), Succeeded());
1018 EXPECT_THAT_EXPECTED(Tester.parseSubst("18"), Succeeded());
1019 EXPECT_THAT_EXPECTED(Tester.parseSubst(std::to_string(MaxUint64)),
1020 Succeeded());
1021 EXPECT_THAT_EXPECTED(Tester.parseSubst("0x12"), Succeeded());
1022 EXPECT_THAT_EXPECTED(Tester.parseSubst("-30"), Succeeded());
1023 EXPECT_THAT_EXPECTED(Tester.parseSubst(std::to_string(MinInt64)),
1024 Succeeded());
1025
1026 // Valid optional matching constraint.
1027 EXPECT_THAT_EXPECTED(Tester.parseSubst("==FOO"), Succeeded());
1028
1029 // Invalid matching constraint.
1030 expectDiagnosticError("invalid matching constraint or operand format",
1031 Tester.parseSubst("+=FOO").takeError());
1032
1033 // Invalid format.
1034 expectDiagnosticError("invalid matching format specification in expression",
1035 Tester.parseSubst("X,FOO:").takeError());
1036 expectDiagnosticError("invalid format specifier in expression",
1037 Tester.parseSubst("%F,FOO").takeError());
1038 expectDiagnosticError("invalid matching format specification in expression",
1039 Tester.parseSubst("%X a,FOO").takeError());
1040
1041 // Valid expression with 2 or more operands.
1042 EXPECT_THAT_EXPECTED(Tester.parseSubst("FOO+3"), Succeeded());
1043 EXPECT_THAT_EXPECTED(Tester.parseSubst("FOO+0xC"), Succeeded());
1044 EXPECT_THAT_EXPECTED(Tester.parseSubst("FOO-3+FOO"), Succeeded());
1045
1046 expectDiagnosticError("unsupported operation '/'",
1047 Tester.parseSubst("@LINE/2").takeError());
1048
1049 expectDiagnosticError("missing operand in expression",
1050 Tester.parseSubst("@LINE+").takeError());
1051
1052 // Errors in RHS operand are bubbled up by parseBinop() to
1053 // parseNumericSubstitutionBlock().
1054 expectDiagnosticError("invalid operand format",
1055 Tester.parseSubst("@LINE+%VAR").takeError());
1056
1057 // Invalid legacy @LINE expression with non literal rhs.
1058 expectDiagnosticError(
1059 "invalid operand format",
1060 Tester.parseSubst("@LINE+@LINE", /*IsLegacyNumExpr=*/true).takeError());
1061
1062 // Invalid legacy @LINE expression made of a single literal.
1063 expectDiagnosticError(
1064 "invalid variable name",
1065 Tester.parseSubst("2", /*IsLegacyNumExpr=*/true).takeError());
1066
1067 // Invalid hex literal in legacy @LINE expression.
1068 expectDiagnosticError(
1069 "unexpected characters at end of expression 'xC'",
1070 Tester.parseSubst("@LINE+0xC", /*LegacyLineExpr=*/true).takeError());
1071
1072 // Valid expression with format specifier.
1073 EXPECT_THAT_EXPECTED(Tester.parseSubst("%u, FOO"), Succeeded());
1074 EXPECT_THAT_EXPECTED(Tester.parseSubst("%d, FOO"), Succeeded());
1075 EXPECT_THAT_EXPECTED(Tester.parseSubst("%x, FOO"), Succeeded());
1076 EXPECT_THAT_EXPECTED(Tester.parseSubst("%X, FOO"), Succeeded());
1077
1078 // Valid legacy @LINE expression.
1079 EXPECT_THAT_EXPECTED(Tester.parseSubst("@LINE+2", /*IsLegacyNumExpr=*/true),
1080 Succeeded());
1081
1082 // Invalid legacy @LINE expression with more than 2 operands.
1083 expectDiagnosticError(
1084 "unexpected characters at end of expression '+@LINE'",
1085 Tester.parseSubst("@LINE+2+@LINE", /*IsLegacyNumExpr=*/true).takeError());
1086 expectDiagnosticError(
1087 "unexpected characters at end of expression '+2'",
1088 Tester.parseSubst("@LINE+2+2", /*IsLegacyNumExpr=*/true).takeError());
1089
1090 // Valid expression with several variables when their implicit formats do not
1091 // conflict.
1092 EXPECT_THAT_EXPECTED(Tester.parseSubst("FOO+VAR_UNSIGNED"), Succeeded());
1093
1094 // Valid implicit format conflict in presence of explicit formats.
1095 EXPECT_THAT_EXPECTED(Tester.parseSubst("%X,FOO+VAR_LOWER_HEX"), Succeeded());
1096
1097 // Implicit format conflict.
1098 expectDiagnosticError(
1099 "implicit format conflict between 'FOO' (%u) and "
1100 "'VAR_LOWER_HEX' (%x), need an explicit format specifier",
1101 Tester.parseSubst("FOO+VAR_LOWER_HEX").takeError());
1102
1103 // Simple parenthesized expressions:
1104 EXPECT_THAT_EXPECTED(Tester.parseSubst("(1)"), Succeeded());
1105 EXPECT_THAT_EXPECTED(Tester.parseSubst("(1+1)"), Succeeded());
1106 EXPECT_THAT_EXPECTED(Tester.parseSubst("(1)+1"), Succeeded());
1107 EXPECT_THAT_EXPECTED(Tester.parseSubst("((1)+1)"), Succeeded());
1108 EXPECT_THAT_EXPECTED(Tester.parseSubst("((1)+X)"), Succeeded());
1109 EXPECT_THAT_EXPECTED(Tester.parseSubst("((X)+Y)"), Succeeded());
1110
1111 expectDiagnosticError("missing operand in expression",
1112 Tester.parseSubst("(").takeError());
1113 expectDiagnosticError("missing ')' at end of nested expression",
1114 Tester.parseSubst("(1").takeError());
1115 expectDiagnosticError("missing operand in expression",
1116 Tester.parseSubst("(1+").takeError());
1117 expectDiagnosticError("missing ')' at end of nested expression",
1118 Tester.parseSubst("(1+1").takeError());
1119 expectDiagnosticError("missing ')' at end of nested expression",
1120 Tester.parseSubst("((1+2+3").takeError());
1121 expectDiagnosticError("missing ')' at end of nested expression",
1122 Tester.parseSubst("((1+2)+3").takeError());
1123
1124 // Test missing operation between operands:
1125 expectDiagnosticError("unsupported operation '('",
1126 Tester.parseSubst("(1)(2)").takeError());
1127 expectDiagnosticError("unsupported operation '('",
1128 Tester.parseSubst("2(X)").takeError());
1129
1130 // Test more closing than opening parentheses. The diagnostic messages are
1131 // not ideal, but for now simply check that we reject invalid input.
1132 expectDiagnosticError("invalid matching constraint or operand format",
1133 Tester.parseSubst(")").takeError());
1134 expectDiagnosticError("unsupported operation ')'",
1135 Tester.parseSubst("1)").takeError());
1136 expectDiagnosticError("unsupported operation ')'",
1137 Tester.parseSubst("(1+2))").takeError());
1138 expectDiagnosticError("unsupported operation ')'",
1139 Tester.parseSubst("(2))").takeError());
1140 expectDiagnosticError("unsupported operation ')'",
1141 Tester.parseSubst("(1))(").takeError());
1142
1143 // Valid expression with function call.
1144 EXPECT_THAT_EXPECTED(Tester.parseSubst("add(FOO,3)"), Succeeded());
1145 EXPECT_THAT_EXPECTED(Tester.parseSubst("add (FOO,3)"), Succeeded());
1146 // Valid expression with nested function call.
1147 EXPECT_THAT_EXPECTED(Tester.parseSubst("add(FOO, min(BAR,10))"), Succeeded());
1148 // Valid expression with function call taking expression as argument.
1149 EXPECT_THAT_EXPECTED(Tester.parseSubst("add(FOO, (BAR+10) + 3)"),
1150 Succeeded());
1151 EXPECT_THAT_EXPECTED(Tester.parseSubst("add(FOO, min (BAR,10) + 3)"),
1152 Succeeded());
1153 // Valid expression with variable named the same as a function.
1154 EXPECT_THAT_EXPECTED(Tester.parseSubst("add"), Succeeded());
1155 EXPECT_THAT_EXPECTED(Tester.parseSubst("add+FOO"), Succeeded());
1156 EXPECT_THAT_EXPECTED(Tester.parseSubst("FOO+add"), Succeeded());
1157 EXPECT_THAT_EXPECTED(Tester.parseSubst("add(add,add)+add"), Succeeded());
1158
1159 // Malformed call syntax.
1160 expectDiagnosticError("missing ')' at end of call expression",
1161 Tester.parseSubst("add(FOO,(BAR+7)").takeError());
1162 expectDiagnosticError("missing ')' at end of call expression",
1163 Tester.parseSubst("add(FOO,min(BAR,7)").takeError());
1164 expectDiagnosticError("missing argument",
1165 Tester.parseSubst("add(FOO,)").takeError());
1166 expectDiagnosticError("missing argument",
1167 Tester.parseSubst("add(,FOO)").takeError());
1168 expectDiagnosticError("missing argument",
1169 Tester.parseSubst("add(FOO,,3)").takeError());
1170
1171 // Valid call, but to an unknown function.
1172 expectDiagnosticError("call to undefined function 'bogus_function'",
1173 Tester.parseSubst("bogus_function(FOO,3)").takeError());
1174 expectDiagnosticError("call to undefined function '@add'",
1175 Tester.parseSubst("@add(2,3)").takeError());
1176 expectDiagnosticError("call to undefined function '$add'",
1177 Tester.parseSubst("$add(2,3)").takeError());
1178 expectDiagnosticError("call to undefined function 'FOO'",
1179 Tester.parseSubst("FOO(2,3)").takeError());
1180 expectDiagnosticError("call to undefined function 'FOO'",
1181 Tester.parseSubst("FOO (2,3)").takeError());
1182
1183 // Valid call, but with incorrect argument count.
1184 expectDiagnosticError("function 'add' takes 2 arguments but 1 given",
1185 Tester.parseSubst("add(FOO)").takeError());
1186 expectDiagnosticError("function 'add' takes 2 arguments but 3 given",
1187 Tester.parseSubst("add(FOO,3,4)").takeError());
1188
1189 // Valid call, but not part of a valid expression.
1190 expectDiagnosticError("unsupported operation 'a'",
1191 Tester.parseSubst("2add(FOO,2)").takeError());
1192 expectDiagnosticError("unsupported operation 'a'",
1193 Tester.parseSubst("FOO add(FOO,2)").takeError());
1194 expectDiagnosticError("unsupported operation 'a'",
1195 Tester.parseSubst("add(FOO,2)add(FOO,2)").takeError());
1196 }
1197
TEST_F(FileCheckTest,ParsePattern)1198 TEST_F(FileCheckTest, ParsePattern) {
1199 PatternTester Tester;
1200
1201 // Invalid space in string substitution.
1202 EXPECT_TRUE(Tester.parsePattern("[[ BAR]]"));
1203
1204 // Invalid variable name in string substitution.
1205 EXPECT_TRUE(Tester.parsePattern("[[42INVALID]]"));
1206
1207 // Invalid string variable definition.
1208 EXPECT_TRUE(Tester.parsePattern("[[@PAT:]]"));
1209 EXPECT_TRUE(Tester.parsePattern("[[PAT+2:]]"));
1210
1211 // Collision with numeric variable.
1212 EXPECT_TRUE(Tester.parsePattern("[[FOO:]]"));
1213
1214 // Valid use of string variable.
1215 EXPECT_FALSE(Tester.parsePattern("[[BAR]]"));
1216
1217 // Valid string variable definition.
1218 EXPECT_FALSE(Tester.parsePattern("[[PAT:[0-9]+]]"));
1219
1220 // Invalid numeric substitution.
1221 EXPECT_TRUE(Tester.parsePattern("[[#42INVALID]]"));
1222
1223 // Valid numeric substitution.
1224 EXPECT_FALSE(Tester.parsePattern("[[#FOO]]"));
1225
1226 // Valid legacy @LINE expression.
1227 EXPECT_FALSE(Tester.parsePattern("[[@LINE+2]]"));
1228
1229 // Invalid legacy @LINE expression with non decimal literal.
1230 EXPECT_TRUE(Tester.parsePattern("[[@LINE+0x3]]"));
1231 }
1232
TEST_F(FileCheckTest,Match)1233 TEST_F(FileCheckTest, Match) {
1234 PatternTester Tester;
1235
1236 // Check a substitution error is diagnosed.
1237 ASSERT_FALSE(Tester.parsePattern("[[#%u, -1]]"));
1238 expectDiagnosticError(
1239 "unable to substitute variable or numeric expression: overflow error",
1240 Tester.match("").takeError());
1241
1242 // Check matching an empty expression only matches a number.
1243 Tester.initNextPattern();
1244 ASSERT_FALSE(Tester.parsePattern("[[#]]"));
1245 expectNotFoundError(Tester.match("FAIL").takeError());
1246 EXPECT_THAT_EXPECTED(Tester.match("18"), Succeeded());
1247
1248 // Check matching a definition only matches a number with the right format.
1249 Tester.initNextPattern();
1250 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR:]]"));
1251 expectNotFoundError(Tester.match("FAIL").takeError());
1252 expectNotFoundError(Tester.match("").takeError());
1253 EXPECT_THAT_EXPECTED(Tester.match("18"), Succeeded());
1254 Tester.initNextPattern();
1255 Tester.parsePattern("[[#%u,NUMVAR_UNSIGNED:]]");
1256 expectNotFoundError(Tester.match("C").takeError());
1257 EXPECT_THAT_EXPECTED(Tester.match("20"), Succeeded());
1258 Tester.initNextPattern();
1259 Tester.parsePattern("[[#%x,NUMVAR_LOWER_HEX:]]");
1260 expectNotFoundError(Tester.match("g").takeError());
1261 expectNotFoundError(Tester.match("C").takeError());
1262 EXPECT_THAT_EXPECTED(Tester.match("c"), Succeeded());
1263 Tester.initNextPattern();
1264 Tester.parsePattern("[[#%X,NUMVAR_UPPER_HEX:]]");
1265 expectNotFoundError(Tester.match("H").takeError());
1266 expectNotFoundError(Tester.match("b").takeError());
1267 EXPECT_THAT_EXPECTED(Tester.match("B"), Succeeded());
1268
1269 // Check matching expressions with no explicit format matches the values in
1270 // the right format.
1271 Tester.initNextPattern();
1272 Tester.parsePattern("[[#NUMVAR_UNSIGNED-5]]");
1273 expectNotFoundError(Tester.match("f").takeError());
1274 expectNotFoundError(Tester.match("F").takeError());
1275 EXPECT_THAT_EXPECTED(Tester.match("15"), Succeeded());
1276 Tester.initNextPattern();
1277 Tester.parsePattern("[[#NUMVAR_LOWER_HEX+1]]");
1278 expectNotFoundError(Tester.match("13").takeError());
1279 expectNotFoundError(Tester.match("D").takeError());
1280 EXPECT_THAT_EXPECTED(Tester.match("d"), Succeeded());
1281 Tester.initNextPattern();
1282 Tester.parsePattern("[[#NUMVAR_UPPER_HEX+1]]");
1283 expectNotFoundError(Tester.match("12").takeError());
1284 expectNotFoundError(Tester.match("c").takeError());
1285 EXPECT_THAT_EXPECTED(Tester.match("C"), Succeeded());
1286
1287 // Check matching an undefined variable returns a NotFound error.
1288 Tester.initNextPattern();
1289 ASSERT_FALSE(Tester.parsePattern("100"));
1290 expectNotFoundError(Tester.match("101").takeError());
1291
1292 // Check matching the defined variable matches the correct number only.
1293 Tester.initNextPattern();
1294 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR]]"));
1295 EXPECT_THAT_EXPECTED(Tester.match("18"), Succeeded());
1296
1297 // Check matching several substitutions does not match them independently.
1298 Tester.initNextPattern();
1299 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR]] [[#NUMVAR+2]]"));
1300 expectNotFoundError(Tester.match("19 21").takeError());
1301 expectNotFoundError(Tester.match("18 21").takeError());
1302 EXPECT_THAT_EXPECTED(Tester.match("18 20"), Succeeded());
1303
1304 // Check matching a numeric expression using @LINE after a match failure uses
1305 // the correct value for @LINE.
1306 Tester.initNextPattern();
1307 ASSERT_FALSE(Tester.parsePattern("[[#@LINE]]"));
1308 // Ok, @LINE matches the current line number.
1309 EXPECT_THAT_EXPECTED(Tester.match(std::to_string(Tester.getLineNumber())),
1310 Succeeded());
1311 Tester.initNextPattern();
1312 // Match with substitution failure.
1313 ASSERT_FALSE(Tester.parsePattern("[[#UNKNOWN]]"));
1314 expectUndefErrors({"UNKNOWN"}, Tester.match("FOO").takeError());
1315 Tester.initNextPattern();
1316 // Check that @LINE matches the later (given the calls to initNextPattern())
1317 // line number.
1318 EXPECT_FALSE(Tester.parsePattern("[[#@LINE]]"));
1319 EXPECT_THAT_EXPECTED(Tester.match(std::to_string(Tester.getLineNumber())),
1320 Succeeded());
1321 }
1322
TEST_F(FileCheckTest,MatchParen)1323 TEST_F(FileCheckTest, MatchParen) {
1324 PatternTester Tester;
1325 // Check simple parenthesized expressions
1326 Tester.initNextPattern();
1327 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR:]]"));
1328 expectNotFoundError(Tester.match("FAIL").takeError());
1329 expectNotFoundError(Tester.match("").takeError());
1330 EXPECT_THAT_EXPECTED(Tester.match("18"), Succeeded());
1331
1332 Tester.initNextPattern();
1333 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR + (2 + 2)]]"));
1334 expectNotFoundError(Tester.match("21").takeError());
1335 EXPECT_THAT_EXPECTED(Tester.match("22"), Succeeded());
1336 Tester.initNextPattern();
1337 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR + (2)]]"));
1338 EXPECT_THAT_EXPECTED(Tester.match("20"), Succeeded());
1339 Tester.initNextPattern();
1340 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR+(2)]]"));
1341 EXPECT_THAT_EXPECTED(Tester.match("20"), Succeeded());
1342 Tester.initNextPattern();
1343 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR+(NUMVAR)]]"));
1344 EXPECT_THAT_EXPECTED(Tester.match("36"), Succeeded());
1345
1346 // Check nested parenthesized expressions:
1347 Tester.initNextPattern();
1348 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR+(2+(2))]]"));
1349 EXPECT_THAT_EXPECTED(Tester.match("22"), Succeeded());
1350 Tester.initNextPattern();
1351 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR+(2+(NUMVAR))]]"));
1352 EXPECT_THAT_EXPECTED(Tester.match("38"), Succeeded());
1353 Tester.initNextPattern();
1354 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR+((((NUMVAR))))]]"));
1355 EXPECT_THAT_EXPECTED(Tester.match("36"), Succeeded());
1356 Tester.initNextPattern();
1357 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR+((((NUMVAR)))-1)-1]]"));
1358 EXPECT_THAT_EXPECTED(Tester.match("34"), Succeeded());
1359
1360 // Parentheses can also be the first character after the '#':
1361 Tester.initNextPattern();
1362 ASSERT_FALSE(Tester.parsePattern("[[#(NUMVAR)]]"));
1363 EXPECT_THAT_EXPECTED(Tester.match("18"), Succeeded());
1364 Tester.initNextPattern();
1365 ASSERT_FALSE(Tester.parsePattern("[[#(NUMVAR+2)]]"));
1366 EXPECT_THAT_EXPECTED(Tester.match("20"), Succeeded());
1367 }
1368
TEST_F(FileCheckTest,MatchBuiltinFunctions)1369 TEST_F(FileCheckTest, MatchBuiltinFunctions) {
1370 PatternTester Tester;
1371 // Esnure #NUMVAR has the expected value.
1372 Tester.initNextPattern();
1373 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR:]]"));
1374 expectNotFoundError(Tester.match("FAIL").takeError());
1375 expectNotFoundError(Tester.match("").takeError());
1376 EXPECT_THAT_EXPECTED(Tester.match("18"), Succeeded());
1377
1378 // Check each builtin function generates the expected result.
1379 Tester.initNextPattern();
1380 ASSERT_FALSE(Tester.parsePattern("[[#add(NUMVAR,13)]]"));
1381 EXPECT_THAT_EXPECTED(Tester.match("31"), Succeeded());
1382 Tester.initNextPattern();
1383 ASSERT_FALSE(Tester.parsePattern("[[#div(NUMVAR,3)]]"));
1384 EXPECT_THAT_EXPECTED(Tester.match("6"), Succeeded());
1385 Tester.initNextPattern();
1386 ASSERT_FALSE(Tester.parsePattern("[[#max(NUMVAR,5)]]"));
1387 EXPECT_THAT_EXPECTED(Tester.match("18"), Succeeded());
1388 Tester.initNextPattern();
1389 ASSERT_FALSE(Tester.parsePattern("[[#max(NUMVAR,99)]]"));
1390 EXPECT_THAT_EXPECTED(Tester.match("99"), Succeeded());
1391 Tester.initNextPattern();
1392 ASSERT_FALSE(Tester.parsePattern("[[#min(NUMVAR,5)]]"));
1393 EXPECT_THAT_EXPECTED(Tester.match("5"), Succeeded());
1394 Tester.initNextPattern();
1395 ASSERT_FALSE(Tester.parsePattern("[[#min(NUMVAR,99)]]"));
1396 EXPECT_THAT_EXPECTED(Tester.match("18"), Succeeded());
1397 Tester.initNextPattern();
1398 ASSERT_FALSE(Tester.parsePattern("[[#mul(NUMVAR,3)]]"));
1399 EXPECT_THAT_EXPECTED(Tester.match("54"), Succeeded());
1400 Tester.initNextPattern();
1401 ASSERT_FALSE(Tester.parsePattern("[[#sub(NUMVAR,7)]]"));
1402 EXPECT_THAT_EXPECTED(Tester.match("11"), Succeeded());
1403
1404 // Check nested function calls.
1405 Tester.initNextPattern();
1406 ASSERT_FALSE(Tester.parsePattern("[[#add(min(7,2),max(4,10))]]"));
1407 EXPECT_THAT_EXPECTED(Tester.match("12"), Succeeded());
1408
1409 // Check function call that uses a variable of the same name.
1410 Tester.initNextPattern();
1411 ASSERT_FALSE(Tester.parsePattern("[[#add(add,add)+min (add,3)+add]]"));
1412 EXPECT_THAT_EXPECTED(Tester.match("24"), Succeeded());
1413 }
1414
TEST_F(FileCheckTest,Substitution)1415 TEST_F(FileCheckTest, Substitution) {
1416 SourceMgr SM;
1417 FileCheckPatternContext Context;
1418 EXPECT_THAT_ERROR(Context.defineCmdlineVariables({"FOO=BAR"}, SM),
1419 Succeeded());
1420
1421 // Substitution of an undefined string variable fails and error holds that
1422 // variable's name.
1423 StringSubstitution StringSubstitution(&Context, "VAR404", 42);
1424 Expected<std::string> SubstValue = StringSubstitution.getResult();
1425 expectUndefErrors({"VAR404"}, SubstValue.takeError());
1426
1427 // Numeric substitution blocks constituted of defined numeric variables are
1428 // substituted for the variable's value.
1429 NumericVariable NVar("N", ExpressionFormat(ExpressionFormat::Kind::Unsigned),
1430 1);
1431 NVar.setValue(ExpressionValue(10u));
1432 auto NVarUse = std::make_unique<NumericVariableUse>("N", &NVar);
1433 auto ExpressionN = std::make_unique<Expression>(
1434 std::move(NVarUse), ExpressionFormat(ExpressionFormat::Kind::HexUpper));
1435 NumericSubstitution SubstitutionN(&Context, "N", std::move(ExpressionN),
1436 /*InsertIdx=*/30);
1437 SubstValue = SubstitutionN.getResult();
1438 ASSERT_THAT_EXPECTED(SubstValue, Succeeded());
1439 EXPECT_EQ("A", *SubstValue);
1440
1441 // Substitution of an undefined numeric variable fails, error holds name of
1442 // undefined variable.
1443 NVar.clearValue();
1444 SubstValue = SubstitutionN.getResult();
1445 expectUndefErrors({"N"}, SubstValue.takeError());
1446
1447 // Substitution of a defined string variable returns the right value.
1448 Pattern P(Check::CheckPlain, &Context, 1);
1449 StringSubstitution = llvm::StringSubstitution(&Context, "FOO", 42);
1450 SubstValue = StringSubstitution.getResult();
1451 ASSERT_THAT_EXPECTED(SubstValue, Succeeded());
1452 EXPECT_EQ("BAR", *SubstValue);
1453 }
1454
TEST_F(FileCheckTest,FileCheckContext)1455 TEST_F(FileCheckTest, FileCheckContext) {
1456 FileCheckPatternContext Cxt;
1457 SourceMgr SM;
1458
1459 // No definition.
1460 EXPECT_THAT_ERROR(Cxt.defineCmdlineVariables({}, SM), Succeeded());
1461
1462 // Missing equal sign.
1463 expectDiagnosticError("missing equal sign in global definition",
1464 Cxt.defineCmdlineVariables({"LocalVar"}, SM));
1465 expectDiagnosticError("missing equal sign in global definition",
1466 Cxt.defineCmdlineVariables({"#LocalNumVar"}, SM));
1467
1468 // Empty variable name.
1469 expectDiagnosticError("empty variable name",
1470 Cxt.defineCmdlineVariables({"=18"}, SM));
1471 expectDiagnosticError("empty variable name",
1472 Cxt.defineCmdlineVariables({"#=18"}, SM));
1473
1474 // Invalid variable name.
1475 expectDiagnosticError("invalid variable name",
1476 Cxt.defineCmdlineVariables({"18LocalVar=18"}, SM));
1477 expectDiagnosticError("invalid variable name",
1478 Cxt.defineCmdlineVariables({"#18LocalNumVar=18"}, SM));
1479
1480 // Name conflict between pattern and numeric variable.
1481 expectDiagnosticError(
1482 "string variable with name 'LocalVar' already exists",
1483 Cxt.defineCmdlineVariables({"LocalVar=18", "#LocalVar=36"}, SM));
1484 Cxt = FileCheckPatternContext();
1485 expectDiagnosticError(
1486 "numeric variable with name 'LocalNumVar' already exists",
1487 Cxt.defineCmdlineVariables({"#LocalNumVar=18", "LocalNumVar=36"}, SM));
1488 Cxt = FileCheckPatternContext();
1489
1490 // Invalid numeric value for numeric variable.
1491 expectUndefErrors({"x"}, Cxt.defineCmdlineVariables({"#LocalNumVar=x"}, SM));
1492
1493 // Define local variables from command-line.
1494 std::vector<StringRef> GlobalDefines;
1495 // Clear local variables to remove dummy numeric variable x that
1496 // parseNumericSubstitutionBlock would have created and stored in
1497 // GlobalNumericVariableTable.
1498 Cxt.clearLocalVars();
1499 GlobalDefines.emplace_back("LocalVar=FOO");
1500 GlobalDefines.emplace_back("EmptyVar=");
1501 GlobalDefines.emplace_back("#LocalNumVar1=18");
1502 GlobalDefines.emplace_back("#%x,LocalNumVar2=LocalNumVar1+2");
1503 GlobalDefines.emplace_back("#LocalNumVar3=0xc");
1504 ASSERT_THAT_ERROR(Cxt.defineCmdlineVariables(GlobalDefines, SM), Succeeded());
1505
1506 // Create @LINE pseudo numeric variable and check it is present by matching
1507 // it.
1508 size_t LineNumber = 1;
1509 Pattern P(Check::CheckPlain, &Cxt, LineNumber);
1510 FileCheckRequest Req;
1511 Cxt.createLineVariable();
1512 ASSERT_FALSE(P.parsePattern("[[@LINE]]", "CHECK", SM, Req));
1513 size_t MatchLen;
1514 ASSERT_THAT_EXPECTED(P.match("1", MatchLen, SM), Succeeded());
1515
1516 #ifndef NDEBUG
1517 // Recreating @LINE pseudo numeric variable fails.
1518 EXPECT_DEATH(Cxt.createLineVariable(),
1519 "@LINE pseudo numeric variable already created");
1520 #endif
1521
1522 // Check defined variables are present and undefined ones are absent.
1523 StringRef LocalVarStr = "LocalVar";
1524 StringRef LocalNumVar1Ref = bufferize(SM, "LocalNumVar1");
1525 StringRef LocalNumVar2Ref = bufferize(SM, "LocalNumVar2");
1526 StringRef LocalNumVar3Ref = bufferize(SM, "LocalNumVar3");
1527 StringRef EmptyVarStr = "EmptyVar";
1528 StringRef UnknownVarStr = "UnknownVar";
1529 Expected<StringRef> LocalVar = Cxt.getPatternVarValue(LocalVarStr);
1530 P = Pattern(Check::CheckPlain, &Cxt, ++LineNumber);
1531 Optional<NumericVariable *> DefinedNumericVariable;
1532 Expected<std::unique_ptr<Expression>> ExpressionPointer =
1533 P.parseNumericSubstitutionBlock(LocalNumVar1Ref, DefinedNumericVariable,
1534 /*IsLegacyLineExpr=*/false, LineNumber,
1535 &Cxt, SM);
1536 ASSERT_THAT_EXPECTED(LocalVar, Succeeded());
1537 EXPECT_EQ(*LocalVar, "FOO");
1538 Expected<StringRef> EmptyVar = Cxt.getPatternVarValue(EmptyVarStr);
1539 Expected<StringRef> UnknownVar = Cxt.getPatternVarValue(UnknownVarStr);
1540 ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
1541 Expected<ExpressionValue> ExpressionVal =
1542 (*ExpressionPointer)->getAST()->eval();
1543 ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
1544 EXPECT_EQ(cantFail(ExpressionVal->getSignedValue()), 18);
1545 ExpressionPointer = P.parseNumericSubstitutionBlock(
1546 LocalNumVar2Ref, DefinedNumericVariable,
1547 /*IsLegacyLineExpr=*/false, LineNumber, &Cxt, SM);
1548 ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
1549 ExpressionVal = (*ExpressionPointer)->getAST()->eval();
1550 ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
1551 EXPECT_EQ(cantFail(ExpressionVal->getSignedValue()), 20);
1552 ExpressionPointer = P.parseNumericSubstitutionBlock(
1553 LocalNumVar3Ref, DefinedNumericVariable,
1554 /*IsLegacyLineExpr=*/false, LineNumber, &Cxt, SM);
1555 ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
1556 ExpressionVal = (*ExpressionPointer)->getAST()->eval();
1557 ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
1558 EXPECT_EQ(cantFail(ExpressionVal->getSignedValue()), 12);
1559 ASSERT_THAT_EXPECTED(EmptyVar, Succeeded());
1560 EXPECT_EQ(*EmptyVar, "");
1561 expectUndefErrors({std::string(UnknownVarStr)}, UnknownVar.takeError());
1562
1563 // Clear local variables and check they become absent.
1564 Cxt.clearLocalVars();
1565 LocalVar = Cxt.getPatternVarValue(LocalVarStr);
1566 expectUndefErrors({std::string(LocalVarStr)}, LocalVar.takeError());
1567 // Check a numeric expression's evaluation fails if called after clearing of
1568 // local variables, if it was created before. This is important because local
1569 // variable clearing due to --enable-var-scope happens after numeric
1570 // expressions are linked to the numeric variables they use.
1571 expectUndefErrors({"LocalNumVar3"},
1572 (*ExpressionPointer)->getAST()->eval().takeError());
1573 P = Pattern(Check::CheckPlain, &Cxt, ++LineNumber);
1574 ExpressionPointer = P.parseNumericSubstitutionBlock(
1575 LocalNumVar1Ref, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
1576 LineNumber, &Cxt, SM);
1577 ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
1578 ExpressionVal = (*ExpressionPointer)->getAST()->eval();
1579 expectUndefErrors({"LocalNumVar1"}, ExpressionVal.takeError());
1580 ExpressionPointer = P.parseNumericSubstitutionBlock(
1581 LocalNumVar2Ref, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
1582 LineNumber, &Cxt, SM);
1583 ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
1584 ExpressionVal = (*ExpressionPointer)->getAST()->eval();
1585 expectUndefErrors({"LocalNumVar2"}, ExpressionVal.takeError());
1586 EmptyVar = Cxt.getPatternVarValue(EmptyVarStr);
1587 expectUndefErrors({"EmptyVar"}, EmptyVar.takeError());
1588 // Clear again because parseNumericSubstitutionBlock would have created a
1589 // dummy variable and stored it in GlobalNumericVariableTable.
1590 Cxt.clearLocalVars();
1591
1592 // Redefine global variables and check variables are defined again.
1593 GlobalDefines.emplace_back("$GlobalVar=BAR");
1594 GlobalDefines.emplace_back("#$GlobalNumVar=36");
1595 ASSERT_THAT_ERROR(Cxt.defineCmdlineVariables(GlobalDefines, SM), Succeeded());
1596 StringRef GlobalVarStr = "$GlobalVar";
1597 StringRef GlobalNumVarRef = bufferize(SM, "$GlobalNumVar");
1598 Expected<StringRef> GlobalVar = Cxt.getPatternVarValue(GlobalVarStr);
1599 ASSERT_THAT_EXPECTED(GlobalVar, Succeeded());
1600 EXPECT_EQ(*GlobalVar, "BAR");
1601 P = Pattern(Check::CheckPlain, &Cxt, ++LineNumber);
1602 ExpressionPointer = P.parseNumericSubstitutionBlock(
1603 GlobalNumVarRef, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
1604 LineNumber, &Cxt, SM);
1605 ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
1606 ExpressionVal = (*ExpressionPointer)->getAST()->eval();
1607 ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
1608 EXPECT_EQ(cantFail(ExpressionVal->getSignedValue()), 36);
1609
1610 // Clear local variables and check global variables remain defined.
1611 Cxt.clearLocalVars();
1612 EXPECT_THAT_EXPECTED(Cxt.getPatternVarValue(GlobalVarStr), Succeeded());
1613 P = Pattern(Check::CheckPlain, &Cxt, ++LineNumber);
1614 ExpressionPointer = P.parseNumericSubstitutionBlock(
1615 GlobalNumVarRef, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
1616 LineNumber, &Cxt, SM);
1617 ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
1618 ExpressionVal = (*ExpressionPointer)->getAST()->eval();
1619 ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
1620 EXPECT_EQ(cantFail(ExpressionVal->getSignedValue()), 36);
1621 }
1622 } // namespace
1623