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