1 //===-- Implementation of the base class for libc unittests----------------===//
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 "LibcTest.h"
10 
11 #include "utils/testutils/ExecuteFunction.h"
12 #include <cassert>
13 #include <iostream>
14 #include <string>
15 
16 namespace __llvm_libc {
17 namespace testing {
18 
19 // This need not be a class as all it has is a single read-write state variable.
20 // But, we make it class as then its implementation can be hidden from the
21 // header file.
22 class RunContext {
23 public:
24   enum RunResult { Result_Pass = 1, Result_Fail = 2 };
25 
26   RunResult status() const { return Status; }
27 
28   void markFail() { Status = Result_Fail; }
29 
30 private:
31   RunResult Status = Result_Pass;
32 };
33 
34 namespace internal {
35 
36 // When the value is of integral type, just display it as normal.
37 template <typename ValType>
38 cpp::EnableIfType<cpp::IsIntegral<ValType>::Value, std::string>
39 describeValue(ValType Value) {
40   return std::to_string(Value);
41 }
42 
43 std::string describeValue(std::string Value) { return std::string(Value); }
44 
45 // When the value is __uint128_t, also show its hexadecimal digits.
46 // Using template to force exact match, prevent ambiguous promotion.
47 template <> std::string describeValue<__uint128_t>(__uint128_t Value) {
48   std::string S(sizeof(__uint128_t) * 2, '0');
49 
50   for (auto I = S.rbegin(), End = S.rend(); I != End; ++I, Value >>= 4) {
51     unsigned char Mod = static_cast<unsigned char>(Value) & 15;
52     *I = Mod < 10 ? '0' + Mod : 'a' + Mod - 10;
53   }
54 
55   return "0x" + S;
56 }
57 
58 template <typename ValType>
59 void explainDifference(ValType LHS, ValType RHS, const char *LHSStr,
60                        const char *RHSStr, const char *File, unsigned long Line,
61                        std::string OpString) {
62   size_t OffsetLength = OpString.size() > 2 ? OpString.size() - 2 : 0;
63   std::string Offset(OffsetLength, ' ');
64 
65   std::cout << File << ":" << Line << ": FAILURE\n"
66             << Offset << "Expected: " << LHSStr << '\n'
67             << Offset << "Which is: " << describeValue(LHS) << '\n'
68             << "To be " << OpString << ": " << RHSStr << '\n'
69             << Offset << "Which is: " << describeValue(RHS) << '\n';
70 }
71 
72 template <typename ValType>
73 bool test(RunContext *Ctx, TestCondition Cond, ValType LHS, ValType RHS,
74           const char *LHSStr, const char *RHSStr, const char *File,
75           unsigned long Line) {
76   auto ExplainDifference = [=](std::string OpString) {
77     explainDifference(LHS, RHS, LHSStr, RHSStr, File, Line, OpString);
78   };
79 
80   switch (Cond) {
81   case Cond_EQ:
82     if (LHS == RHS)
83       return true;
84 
85     Ctx->markFail();
86     ExplainDifference("equal to");
87     return false;
88   case Cond_NE:
89     if (LHS != RHS)
90       return true;
91 
92     Ctx->markFail();
93     ExplainDifference("not equal to");
94     return false;
95   case Cond_LT:
96     if (LHS < RHS)
97       return true;
98 
99     Ctx->markFail();
100     ExplainDifference("less than");
101     return false;
102   case Cond_LE:
103     if (LHS <= RHS)
104       return true;
105 
106     Ctx->markFail();
107     ExplainDifference("less than or equal to");
108     return false;
109   case Cond_GT:
110     if (LHS > RHS)
111       return true;
112 
113     Ctx->markFail();
114     ExplainDifference("greater than");
115     return false;
116   case Cond_GE:
117     if (LHS >= RHS)
118       return true;
119 
120     Ctx->markFail();
121     ExplainDifference("greater than or equal to");
122     return false;
123   default:
124     Ctx->markFail();
125     std::cout << "Unexpected test condition.\n";
126     return false;
127   }
128 }
129 
130 } // namespace internal
131 
132 Test *Test::Start = nullptr;
133 Test *Test::End = nullptr;
134 
135 void Test::addTest(Test *T) {
136   if (End == nullptr) {
137     Start = T;
138     End = T;
139     return;
140   }
141 
142   End->Next = T;
143   End = T;
144 }
145 
146 int Test::runTests(const char *TestFilter) {
147   int TestCount = 0;
148   int FailCount = 0;
149   for (Test *T = Start; T != nullptr; T = T->Next) {
150     const char *TestName = T->getName();
151     std::string StrTestName(TestName);
152     constexpr auto GREEN = "\033[32m";
153     constexpr auto RED = "\033[31m";
154     constexpr auto RESET = "\033[0m";
155     if ((TestFilter != nullptr) && (StrTestName != TestFilter)) {
156       continue;
157     }
158     std::cout << GREEN << "[ RUN      ] " << RESET << TestName << '\n';
159     RunContext Ctx;
160     T->SetUp();
161     T->setContext(&Ctx);
162     T->Run();
163     T->TearDown();
164     auto Result = Ctx.status();
165     switch (Result) {
166     case RunContext::Result_Fail:
167       std::cout << RED << "[  FAILED  ] " << RESET << TestName << '\n';
168       ++FailCount;
169       break;
170     case RunContext::Result_Pass:
171       std::cout << GREEN << "[       OK ] " << RESET << TestName << '\n';
172       break;
173     }
174     ++TestCount;
175   }
176 
177   if (TestCount > 0) {
178     std::cout << "Ran " << TestCount << " tests. "
179               << " PASS: " << TestCount - FailCount << ' '
180               << " FAIL: " << FailCount << '\n';
181   } else {
182     std::cout << "No tests run.\n";
183     if (TestFilter) {
184       std::cout << "No matching test for " << TestFilter << '\n';
185     }
186   }
187 
188   return FailCount > 0 || TestCount == 0 ? 1 : 0;
189 }
190 
191 template bool Test::test<char, 0>(TestCondition Cond, char LHS, char RHS,
192                                   const char *LHSStr, const char *RHSStr,
193                                   const char *File, unsigned long Line);
194 
195 template bool Test::test<short, 0>(TestCondition Cond, short LHS, short RHS,
196                                    const char *LHSStr, const char *RHSStr,
197                                    const char *File, unsigned long Line);
198 
199 template bool Test::test<int, 0>(TestCondition Cond, int LHS, int RHS,
200                                  const char *LHSStr, const char *RHSStr,
201                                  const char *File, unsigned long Line);
202 
203 template bool Test::test<long, 0>(TestCondition Cond, long LHS, long RHS,
204                                   const char *LHSStr, const char *RHSStr,
205                                   const char *File, unsigned long Line);
206 
207 template bool Test::test<long long, 0>(TestCondition Cond, long long LHS,
208                                        long long RHS, const char *LHSStr,
209                                        const char *RHSStr, const char *File,
210                                        unsigned long Line);
211 
212 template bool Test::test<unsigned char, 0>(TestCondition Cond,
213                                            unsigned char LHS, unsigned char RHS,
214                                            const char *LHSStr,
215                                            const char *RHSStr, const char *File,
216                                            unsigned long Line);
217 
218 template bool
219 Test::test<unsigned short, 0>(TestCondition Cond, unsigned short LHS,
220                               unsigned short RHS, const char *LHSStr,
221                               const char *RHSStr, const char *File,
222                               unsigned long Line);
223 
224 template bool Test::test<unsigned int, 0>(TestCondition Cond, unsigned int LHS,
225                                           unsigned int RHS, const char *LHSStr,
226                                           const char *RHSStr, const char *File,
227                                           unsigned long Line);
228 
229 template bool Test::test<unsigned long, 0>(TestCondition Cond,
230                                            unsigned long LHS, unsigned long RHS,
231                                            const char *LHSStr,
232                                            const char *RHSStr, const char *File,
233                                            unsigned long Line);
234 
235 template bool Test::test<bool, 0>(TestCondition Cond, bool LHS, bool RHS,
236                                   const char *LHSStr, const char *RHSStr,
237                                   const char *File, unsigned long Line);
238 
239 template bool
240 Test::test<unsigned long long, 0>(TestCondition Cond, unsigned long long LHS,
241                                   unsigned long long RHS, const char *LHSStr,
242                                   const char *RHSStr, const char *File,
243                                   unsigned long Line);
244 
245 template bool Test::test<__uint128_t, 0>(TestCondition Cond, __uint128_t LHS,
246                                          __uint128_t RHS, const char *LHSStr,
247                                          const char *RHSStr, const char *File,
248                                          unsigned long Line);
249 
250 bool Test::testStrEq(const char *LHS, const char *RHS, const char *LHSStr,
251                      const char *RHSStr, const char *File, unsigned long Line) {
252   return internal::test(Ctx, Cond_EQ, LHS ? std::string(LHS) : std::string(),
253                         RHS ? std::string(RHS) : std::string(), LHSStr, RHSStr,
254                         File, Line);
255 }
256 
257 bool Test::testStrNe(const char *LHS, const char *RHS, const char *LHSStr,
258                      const char *RHSStr, const char *File, unsigned long Line) {
259   return internal::test(Ctx, Cond_NE, LHS ? std::string(LHS) : std::string(),
260                         RHS ? std::string(RHS) : std::string(), LHSStr, RHSStr,
261                         File, Line);
262 }
263 
264 bool Test::testMatch(bool MatchResult, MatcherBase &Matcher, const char *LHSStr,
265                      const char *RHSStr, const char *File, unsigned long Line) {
266   if (MatchResult)
267     return true;
268 
269   Ctx->markFail();
270   std::cout << File << ":" << Line << ": FAILURE\n"
271             << "Failed to match " << LHSStr << " against " << RHSStr << ".\n";
272   testutils::StreamWrapper OutsWrapper = testutils::outs();
273   Matcher.explainError(OutsWrapper);
274   return false;
275 }
276 
277 #ifdef ENABLE_SUBPROCESS_TESTS
278 
279 bool Test::testProcessKilled(testutils::FunctionCaller *Func, int Signal,
280                              const char *LHSStr, const char *RHSStr,
281                              const char *File, unsigned long Line) {
282   testutils::ProcessStatus Result = testutils::invokeInSubprocess(Func, 500);
283 
284   if (const char *error = Result.getError()) {
285     Ctx->markFail();
286     std::cout << File << ":" << Line << ": FAILURE\n" << error << '\n';
287     return false;
288   }
289 
290   if (Result.timedOut()) {
291     Ctx->markFail();
292     std::cout << File << ":" << Line << ": FAILURE\n"
293               << "Process timed out after " << 500 << " milliseconds.\n";
294     return false;
295   }
296 
297   if (Result.exitedNormally()) {
298     Ctx->markFail();
299     std::cout << File << ":" << Line << ": FAILURE\n"
300               << "Expected " << LHSStr
301               << " to be killed by a signal\nBut it exited normally!\n";
302     return false;
303   }
304 
305   int KilledBy = Result.getFatalSignal();
306   assert(KilledBy != 0 && "Not killed by any signal");
307   if (Signal == -1 || KilledBy == Signal)
308     return true;
309 
310   using testutils::signalAsString;
311   Ctx->markFail();
312   std::cout << File << ":" << Line << ": FAILURE\n"
313             << "              Expected: " << LHSStr << '\n'
314             << "To be killed by signal: " << Signal << '\n'
315             << "              Which is: " << signalAsString(Signal) << '\n'
316             << "  But it was killed by: " << KilledBy << '\n'
317             << "              Which is: " << signalAsString(KilledBy) << '\n';
318   return false;
319 }
320 
321 bool Test::testProcessExits(testutils::FunctionCaller *Func, int ExitCode,
322                             const char *LHSStr, const char *RHSStr,
323                             const char *File, unsigned long Line) {
324   testutils::ProcessStatus Result = testutils::invokeInSubprocess(Func, 500);
325 
326   if (const char *error = Result.getError()) {
327     Ctx->markFail();
328     std::cout << File << ":" << Line << ": FAILURE\n" << error << '\n';
329     return false;
330   }
331 
332   if (Result.timedOut()) {
333     Ctx->markFail();
334     std::cout << File << ":" << Line << ": FAILURE\n"
335               << "Process timed out after " << 500 << " milliseconds.\n";
336     return false;
337   }
338 
339   if (!Result.exitedNormally()) {
340     Ctx->markFail();
341     std::cout << File << ":" << Line << ": FAILURE\n"
342               << "Expected " << LHSStr << '\n'
343               << "to exit with exit code " << ExitCode << '\n'
344               << "But it exited abnormally!\n";
345     return false;
346   }
347 
348   int ActualExit = Result.getExitCode();
349   if (ActualExit == ExitCode)
350     return true;
351 
352   Ctx->markFail();
353   std::cout << File << ":" << Line << ": FAILURE\n"
354             << "Expected exit code of: " << LHSStr << '\n'
355             << "             Which is: " << ActualExit << '\n'
356             << "       To be equal to: " << RHSStr << '\n'
357             << "             Which is: " << ExitCode << '\n';
358   return false;
359 }
360 
361 #endif // ENABLE_SUBPROCESS_TESTS
362 } // namespace testing
363 } // namespace __llvm_libc
364