[libc][NFC] Clean up matchers namespace

[gchatelet]

Summary

This is a follow up to https://reviews.llvm.org/D152503

libc/test/UnitTest/ErrnoSetterMatcher.h

 
 public:
   ErrnoSetterMatcher(T ExpectedReturn, int ExpectedErrno)
       : ExpectedReturn(ExpectedReturn), ExpectedErrno(ExpectedErrno) {}
 
   void explainError() override {
     if (ActualReturn != ExpectedReturn) {
       if constexpr (cpp::is_floating_point_v<T>) {
-        __llvm_libc::testing::tlog
-            << "Expected return value to be: "
-            << str(__llvm_libc::fputil::FPBits<T>(ExpectedReturn)) << '\n';
-        __llvm_libc::testing::tlog
-            << "                    But got: "
-            << str(__llvm_libc::fputil::FPBits<T>(ActualReturn)) << '\n';
+        tlog << "Expected return value to be: "
+             << str(fputil::FPBits<T>(ExpectedReturn)) << '\n';
+        tlog << "                    But got: "
+             << str(fputil::FPBits<T>(ActualReturn)) << '\n';
       } else {
-        __llvm_libc::testing::tlog << "Expected return value to be "
-                                   << ExpectedReturn << " but got "
-                                   << ActualReturn << ".\n";
+        tlog << "Expected return value to be " << ExpectedReturn << " but got "
       }
     }
 
     if constexpr (!ignore_errno()) {
       if (ActualErrno != ExpectedErrno) {
-        __llvm_libc::testing::tlog
-            << "Expected errno to be \"" << get_error_string(ExpectedErrno)
+        tlog << "Expected errno to be \"" << get_error_string(ExpectedErrno)
              << "\" but got \"" << get_error_string(ActualErrno) << "\".\n";
       }
     }
   }
 
   bool match(T Got) {
     ActualReturn = Got;
     ActualErrno = libc_errno;
     libc_errno = 0;

libc/test/UnitTest/FPExceptMatcher.h

 //===-- FPExceptMatcher.h ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_UTILS_UNITTEST_FPEXCEPTMATCHER_H
 #define LLVM_LIBC_UTILS_UNITTEST_FPEXCEPTMATCHER_H
 
 #ifndef LIBC_COPT_TEST_USE_FUCHSIA
 
 #include "test/UnitTest/Test.h"
 
 namespace __llvm_libc {
-namespace fputil {
 namespace testing {
 
 // TODO: Make the matcher match specific exceptions instead of just identifying
 // that an exception was raised.
-class FPExceptMatcher : public __llvm_libc::testing::Matcher<bool> {
+class FPExceptMatcher : public Matcher<bool> {
   bool exceptionRaised;
 
 public:
   class FunctionCaller {
   public:
     virtual ~FunctionCaller(){};
     virtual void call() = 0;
   };
public:
   }
 
   // Takes ownership of func.
   explicit FPExceptMatcher(FunctionCaller *func);
 
   bool match(bool unused) { return exceptionRaised; }
 
   void explainError() override {
-    __llvm_libc::testing::tlog
-        << "A floating point exception should have been raised but it "
+    tlog << "A floating point exception should have been raised but it "
          << "wasn't\n";
   }
 };
 
 } // namespace testing
-} // namespace fputil
 } // namespace __llvm_libc
 
 #define ASSERT_RAISES_FP_EXCEPT(func)                                          \
   ASSERT_THAT(                                                                 \
       true,                                                                    \
-      __llvm_libc::fputil::testing::FPExceptMatcher(                           \
-          __llvm_libc::fputil::testing::FPExceptMatcher::getFunctionCaller(    \
-              func)))
+      __llvm_libc::testing::FPExceptMatcher(                                   \
+          __llvm_libc::testing::FPExceptMatcher::getFunctionCaller(func)))
 #else
 #define ASSERT_RAISES_FP_EXCEPT(func) ASSERT_DEATH(func, WITH_SIGNAL(SIGFPE))
 #endif // LIBC_COPT_TEST_USE_FUCHSIA
 
 #endif // LLVM_LIBC_UTILS_UNITTEST_FPEXCEPTMATCHER_H

libc/test/UnitTest/FPExceptMatcher.cpp

 //===-- FPExceptMatchers.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "FPExceptMatcher.h"
 
 #include <fenv.h>
 #include <memory>
 #include <setjmp.h>
 #include <signal.h>
 
 namespace __llvm_libc {
-namespace fputil {
 namespace testing {
 
 #if defined(_WIN32)
 #define sigjmp_buf jmp_buf
 #define sigsetjmp(buf, save) setjmp(buf)
 #define siglongjmp(buf, val) longjmp(buf, val)
 #endif
 
FPExceptMatcher::FPExceptMatcher(FunctionCaller *func) {
   // We restore the previous floating point environment after
   // the call to the function which can potentially raise SIGFPE.
   fesetenv(&oldEnv);
   signal(SIGFPE, oldSIGFPEHandler);
   exceptionRaised = caughtExcept;
 }
 
 } // namespace testing
-} // namespace fputil
 } // namespace __llvm_libc

libc/test/UnitTest/MemoryMatcher.h

 //===-- MemoryMatcher.h -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_UTILS_UNITTEST_MEMORY_MATCHER_H
 #define LLVM_LIBC_UTILS_UNITTEST_MEMORY_MATCHER_H
 
 #include "src/__support/CPP/span.h"
 
 #include "test/UnitTest/Test.h"
 
 namespace __llvm_libc {
-namespace memory {
 namespace testing {
 
 using MemoryView = __llvm_libc::cpp::span<const char>;
 
 } // namespace testing
-} // namespace memory
 } // namespace __llvm_libc
 
 #ifdef LIBC_COPT_TEST_USE_FUCHSIA
 
 #define EXPECT_MEM_EQ(expected, actual)                                        \
   do {                                                                         \
-    __llvm_libc::memory::testing::MemoryView e = (expected);                   \
-    __llvm_libc::memory::testing::MemoryView a = (actual);                     \
+    __llvm_libc::testing::MemoryView e = (expected);                           \
+    __llvm_libc::testing::MemoryView a = (actual);                             \
     ASSERT_EQ(e.size(), a.size());                                             \
     EXPECT_BYTES_EQ(e.data(), a.data(), e.size());                             \
   } while (0)
 
 #define ASSERT_MEM_EQ(expected, actual)                                        \
   do {                                                                         \
-    __llvm_libc::memory::testing::MemoryView e = (expected);                   \
-    __llvm_libc::memory::testing::MemoryView a = (actual);                     \
+    __llvm_libc::testing::MemoryView e = (expected);                           \
+    __llvm_libc::testing::MemoryView a = (actual);                             \
     ASSERT_EQ(e.size(), a.size());                                             \
     ASSERT_BYTES_EQ(e.data(), a.data(), e.size());                             \
   } while (0)
 
 #else
 
-namespace __llvm_libc::memory::testing {
+namespace __llvm_libc::testing {
 
-class MemoryMatcher : public __llvm_libc::testing::Matcher<MemoryView> {
+class MemoryMatcher : public Matcher<MemoryView> {
   MemoryView expected;
   MemoryView actual;
   bool mismatch_size = false;
   size_t mismatch_index = -1;
 
 public:
   MemoryMatcher(MemoryView expectedValue) : expected(expectedValue) {}
 
   bool match(MemoryView actualValue);
 
   void explainError() override;
 };
 
-} // namespace __llvm_libc::memory::testing
+} // namespace __llvm_libc::testing
 
 #define EXPECT_MEM_EQ(expected, actual)                                        \
-  EXPECT_THAT(actual, __llvm_libc::memory::testing::MemoryMatcher(expected))
+  EXPECT_THAT(actual, __llvm_libc::testing::MemoryMatcher(expected))
 #define ASSERT_MEM_EQ(expected, actual)                                        \
-  ASSERT_THAT(actual, __llvm_libc::memory::testing::MemoryMatcher(expected))
+  ASSERT_THAT(actual, __llvm_libc::testing::MemoryMatcher(expected))
 
 #endif
 
 #endif // LLVM_LIBC_UTILS_UNITTEST_MEMORY_MATCHER_H

libc/test/UnitTest/MemoryMatcher.cpp

 //===-- MemoryMatcher.cpp ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "MemoryMatcher.h"
 
 #include "test/UnitTest/Test.h"
 
 using __llvm_libc::testing::tlog;
 
 namespace __llvm_libc {
-namespace memory {
 namespace testing {
 
 template <typename T>
 bool equals(const cpp::span<T> &Span1, const cpp::span<T> &Span2,
             bool &mismatch_size, size_t &mismatch_index) {
   if (Span1.size() != Span2.size()) {
     mismatch_size = true;
     return false;
if (mismatch_size) {
     tlog << '\n';
     tlog << "actual   :";
     display(actual);
     tlog << '\n';
   }
 }
 
 } // namespace testing
-} // namespace memory
 } // namespace __llvm_libc

libc/test/UnitTest/PrintfMatcher.h

 #define LLVM_LIBC_UTILS_UNITTEST_PRINTF_MATCHER_H
 
 #include "src/stdio/printf_core/core_structs.h"
 #include "test/UnitTest/Test.h"
 
 #include <errno.h>
 
 namespace __llvm_libc {
-namespace printf_core {
 namespace testing {
 
-class FormatSectionMatcher
-    : public __llvm_libc::testing::Matcher<FormatSection> {
-  FormatSection expected;
-  FormatSection actual;
+class FormatSectionMatcher : public Matcher<printf_core::FormatSection> {
+  printf_core::FormatSection expected;
+  printf_core::FormatSection actual;
 
 public:
-  FormatSectionMatcher(FormatSection expectedValue) : expected(expectedValue) {}
+  FormatSectionMatcher(printf_core::FormatSection expectedValue)
+      : expected(expectedValue) {}
 
-  bool match(FormatSection actualValue);
+  bool match(printf_core::FormatSection actualValue);
 
   void explainError() override;
 };
 
 } // namespace testing
-} // namespace printf_core
 } // namespace __llvm_libc
 
 #define EXPECT_PFORMAT_EQ(expected, actual)                                    \
-  EXPECT_THAT(actual, __llvm_libc::printf_core::testing::FormatSectionMatcher( \
-                          expected))
+  EXPECT_THAT(actual, __llvm_libc::testing::FormatSectionMatcher(expected))
 
 #define ASSERT_PFORMAT_EQ(expected, actual)                                    \
-  ASSERT_THAT(actual, __llvm_libc::printf_core::testing::FormatSectionMatcher( \
-                          expected))
+  ASSERT_THAT(actual, __llvm_libc::testing::FormatSectionMatcher(expected))
 
 #endif // LLVM_LIBC_UTILS_UNITTEST_PRINTF_MATCHER_H

libc/test/UnitTest/PrintfMatcher.cpp

 #include "src/__support/FPUtil/FPBits.h"
 #include "src/stdio/printf_core/core_structs.h"
 
 #include "test/UnitTest/StringUtils.h"
 #include "test/UnitTest/Test.h"
 
 #include <stdint.h>
 
-using __llvm_libc::testing::tlog;
-
 namespace __llvm_libc {
-namespace printf_core {
 namespace testing {
 
+using printf_core::FormatFlags;
+using printf_core::FormatSection;
+using printf_core::LengthModifier;
+
 bool FormatSectionMatcher::match(FormatSection actualValue) {
   actual = actualValue;
   return expected == actual;
 }
 
 namespace {
 
 #define IF_FLAG_SHOW_FLAG(flag_name)                                           \
void FormatSectionMatcher::explainError() {
   display(expected);
   tlog << '\n';
   tlog << "actual format section  : ";
   display(actual);
   tlog << '\n';
 }
 
 } // namespace testing
-} // namespace printf_core
 } // namespace __llvm_libc

libc/test/UnitTest/ScanfMatcher.h

 #define LLVM_LIBC_UTILS_UNITTEST_SCANF_MATCHER_H
 
 #include "src/stdio/scanf_core/core_structs.h"
 #include "test/UnitTest/Test.h"
 
 #include <errno.h>
 
 namespace __llvm_libc {
-namespace scanf_core {
 namespace testing {
 
-class FormatSectionMatcher
-    : public __llvm_libc::testing::Matcher<FormatSection> {
-  FormatSection expected;
-  FormatSection actual;
+class FormatSectionMatcher : public Matcher<scanf_core::FormatSection> {
+  scanf_core::FormatSection expected;
+  scanf_core::FormatSection actual;
 
 public:
-  FormatSectionMatcher(FormatSection expectedValue) : expected(expectedValue) {}
+  FormatSectionMatcher(scanf_core::FormatSection expectedValue)
+      : expected(expectedValue) {}
 
-  bool match(FormatSection actualValue);
+  bool match(scanf_core::FormatSection actualValue);
 
   void explainError() override;
 };
 
 } // namespace testing
-} // namespace scanf_core
 } // namespace __llvm_libc
 
 #define EXPECT_SFORMAT_EQ(expected, actual)                                    \
-  EXPECT_THAT(actual, __llvm_libc::scanf_core::testing::FormatSectionMatcher(  \
-                          expected))
+  EXPECT_THAT(actual, __llvm_libc::testing::FormatSectionMatcher(expected))
 
 #define ASSERT_SFORMAT_EQ(expected, actual)                                    \
-  ASSERT_THAT(actual, __llvm_libc::scanf_core::testing::FormatSectionMatcher(  \
-                          expected))
+  ASSERT_THAT(actual, __llvm_libc::testing::FormatSectionMatcher(expected))
 
 #endif // LLVM_LIBC_UTILS_UNITTEST_SCANF_MATCHER_H

libc/test/UnitTest/ScanfMatcher.cpp

 #include "src/__support/FPUtil/FPBits.h"
 #include "src/stdio/scanf_core/core_structs.h"
 
 #include "test/UnitTest/StringUtils.h"
 #include "test/UnitTest/Test.h"
 
 #include <stdint.h>
 
-using __llvm_libc::testing::tlog;
-
 namespace __llvm_libc {
-namespace scanf_core {
 namespace testing {
 
+using scanf_core::FormatFlags;
+using scanf_core::FormatSection;
+using scanf_core::LengthModifier;
+
 bool FormatSectionMatcher::match(FormatSection actualValue) {
   actual = actualValue;
   return expected == actual;
 }
 
 namespace {
 
 #define IF_FLAG_SHOW_FLAG(flag_name)                                           \
void FormatSectionMatcher::explainError() {
   display(expected);
   tlog << '\n';
   tlog << "actual format section  : ";
   display(actual);
   tlog << '\n';
 }
 
 } // namespace testing
-} // namespace scanf_core
 } // namespace __llvm_libc

libc/test/src/__support/File/file_test.cpp

 #include "src/__support/error_or.h"
 #include "test/UnitTest/MemoryMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 
 using ModeFlags = __llvm_libc::File::ModeFlags;
-using MemoryView = __llvm_libc::memory::testing::MemoryView;
+using MemoryView = __llvm_libc::testing::MemoryView;
 using __llvm_libc::ErrorOr;
 using __llvm_libc::File;
 using __llvm_libc::FileIOResult;
 
 class StringFile : public File {
   static constexpr size_t SIZE = 512;
   size_t pos;
   char str[SIZE] = {0};

libc/test/src/stdio/fopencookie_test.cpp

 #include "src/stdio/fwrite.h"
 #include "test/UnitTest/MemoryMatcher.h"
 #include "test/UnitTest/Test.h"
 
 #include "src/errno/libc_errno.h"
 #include <stdio.h>
 #include <stdlib.h>
 
-using MemoryView = __llvm_libc::memory::testing::MemoryView;
+using MemoryView = __llvm_libc::testing::MemoryView;
 
 struct StringStream {
   char *buf;
   size_t bufsize; // Size of buf
   size_t endpos;  // 1 more than current fill size
   size_t offset;  // Current read/write location
 };
 

libc/test/src/time/TmMatcher.h

 //===---- TmMatchers.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_TEST_SRC_TIME_TM_MATCHER_H
 #define LLVM_LIBC_TEST_SRC_TIME_TM_MATCHER_H
 
 #include <time.h>
 
 #include "test/UnitTest/Test.h"
 
 namespace __llvm_libc {
-namespace tmmatcher {
 namespace testing {
 
-class StructTmMatcher : public __llvm_libc::testing::Matcher<::tm> {
+class StructTmMatcher : public Matcher<::tm> {
   ::tm expected;
   ::tm actual;
 
 public:
   StructTmMatcher(::tm expectedValue) : expected(expectedValue) {}
 
   bool match(::tm actualValue) {
     actual = actualValue;
     return (actual.tm_sec == expected.tm_sec ||
             actual.tm_min == expected.tm_min ||
             actual.tm_hour == expected.tm_hour ||
             actual.tm_mday == expected.tm_mday ||
             actual.tm_mon == expected.tm_mon ||
             actual.tm_year == expected.tm_year ||
             actual.tm_wday == expected.tm_wday ||
             actual.tm_yday == expected.tm_yday ||
             actual.tm_isdst == expected.tm_isdst);
   }
 
   void describeValue(const char *label, ::tm value) {
-    __llvm_libc::testing::tlog << label;
-    __llvm_libc::testing::tlog << " sec: " << value.tm_sec;
-    __llvm_libc::testing::tlog << " min: " << value.tm_min;
-    __llvm_libc::testing::tlog << " hour: " << value.tm_hour;
-    __llvm_libc::testing::tlog << " mday: " << value.tm_mday;
-    __llvm_libc::testing::tlog << " mon: " << value.tm_mon;
-    __llvm_libc::testing::tlog << " year: " << value.tm_year;
-    __llvm_libc::testing::tlog << " wday: " << value.tm_wday;
-    __llvm_libc::testing::tlog << " yday: " << value.tm_yday;
-    __llvm_libc::testing::tlog << " isdst: " << value.tm_isdst;
-    __llvm_libc::testing::tlog << '\n';
+    tlog << label;
+    tlog << " sec: " << value.tm_sec;
+    tlog << " min: " << value.tm_min;
+    tlog << " hour: " << value.tm_hour;
+    tlog << " mday: " << value.tm_mday;
+    tlog << " mon: " << value.tm_mon;
+    tlog << " year: " << value.tm_year;
+    tlog << " wday: " << value.tm_wday;
+    tlog << " yday: " << value.tm_yday;
+    tlog << " isdst: " << value.tm_isdst;
+    tlog << '\n';
   }
 
   void explainError() override {
     describeValue("Expected tm_struct value: ", expected);
     describeValue("  Actual tm_struct value: ", actual);
   }
 };
 
 } // namespace testing
-} // namespace tmmatcher
 } // namespace __llvm_libc
 
 #define EXPECT_TM_EQ(expected, actual)                                         \
-  EXPECT_THAT((actual),                                                        \
-              __llvm_libc::tmmatcher::testing::StructTmMatcher((expected)))
+  EXPECT_THAT((actual), __llvm_libc::testing::StructTmMatcher((expected)))
 
 #endif // LLVM_LIBC_TEST_SRC_TIME_TM_MATCHER_H