[libc] Make string tests compatible with the Fuchsia build

[mcgrathr]

Summary

Some test code was doing loose conversions caught by compiler
warnings in the Fuchsia build. This included duplicated code
in a few tests that was reconsolidated with the existing header
file copy of the same functions.

The MemoryMatcher abstraction presumes gtest-style matcher support,
which is not available in Fuchsia's zxtest library. It's avoided
in favor of simpler memory-comparing assertions.

libc/test/UnitTest/MemoryMatcher.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);                     \
+    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);                     \
+    ASSERT_EQ(e.size(), a.size());                                             \
+    ASSERT_BYTES_EQ(e.data(), a.data(), e.size());                             \
+  } while (0)
+
+#else
+
+namespace __llvm_libc::memory::testing {
+
 class MemoryMatcher : public __llvm_libc::testing::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(testutils::StreamWrapper &stream) override;
 };
 
-} // namespace testing
-} // namespace memory
-} // namespace __llvm_libc
+} // namespace __llvm_libc::memory::testing
 
 #define EXPECT_MEM_EQ(expected, actual)                                        \
   EXPECT_THAT(actual, __llvm_libc::memory::testing::MemoryMatcher(expected))
 #define ASSERT_MEM_EQ(expected, actual)                                        \
   ASSERT_THAT(actual, __llvm_libc::memory::testing::MemoryMatcher(expected))
 
+#endif
+
 #endif // LLVM_LIBC_UTILS_UNITTEST_MEMORY_MATCHER_H

libc/test/src/string/bcopy_test.cpp

 //===-- Unittests for bcopy -----------------------------------------------===//
 //
 // 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 "src/__support/CPP/span.h"
 #include "src/string/bcopy.h"
+
+#include "memory_utils/memory_check_utils.h"
+#include "src/__support/CPP/span.h"
 #include "test/UnitTest/MemoryMatcher.h"
 #include "test/UnitTest/Test.h"
 
 using __llvm_libc::cpp::array;
 using __llvm_libc::cpp::span;
 
 TEST(LlvmLibcBcopyTest, MoveZeroByte) {
   char Buffer[] = {'a', 'b', 'y', 'z'};
TEST(LlvmLibcBcopyTest, DstFollowSrc) {
   const char Expected[] = {'z', 'a', 'a', 'z'};
   void *const Dst = Buffer + 2;
   __llvm_libc::bcopy(Buffer + 1, Dst, 1);
   ASSERT_MEM_EQ(Buffer, Expected);
 }
 
 static constexpr int kMaxSize = 512;
 
-char GetRandomChar() {
-  static constexpr const uint64_t A = 1103515245;
-  static constexpr const uint64_t C = 12345;
-  static constexpr const uint64_t M = 1ULL << 31;
-  static uint64_t Seed = 123456789;
-  Seed = (A * Seed + C) % M;
-  return Seed;
-}
-
-void Randomize(span<char> Buffer) {
-  for (auto &current : Buffer)
-    current = GetRandomChar();
-}
-
 TEST(LlvmLibcBcopyTest, SizeSweep) {
   using LargeBuffer = array<char, 3 * kMaxSize>;
   LargeBuffer GroundTruth;
-  Randomize(GroundTruth);
+  __llvm_libc::Randomize(GroundTruth);
   for (int Size = 0; Size < kMaxSize; ++Size) {
     for (int Offset = -Size; Offset < Size; ++Offset) {
       LargeBuffer Buffer = GroundTruth;
       LargeBuffer Expected = GroundTruth;
       size_t DstOffset = kMaxSize;
       size_t SrcOffset = kMaxSize + Offset;
       for (int I = 0; I < Size; ++I)
         Expected[DstOffset + I] = GroundTruth[SrcOffset + I];
       void *const Dst = Buffer.data() + DstOffset;
       __llvm_libc::bcopy(Buffer.data() + SrcOffset, Dst, Size);
       ASSERT_MEM_EQ(Buffer, Expected);
     }
   }
 }

libc/test/src/string/memmove_test.cpp

 //===-- Unittests for memmove ---------------------------------------------===//
 //
 // 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 "src/__support/CPP/span.h"
 #include "src/string/memmove.h"
+
+#include "memory_utils/memory_check_utils.h"
+#include "src/__support/CPP/span.h"
 #include "test/UnitTest/MemoryMatcher.h"
 #include "test/UnitTest/Test.h"
 
 using __llvm_libc::cpp::array;
 using __llvm_libc::cpp::span;
 
 TEST(LlvmLibcMemmoveTest, MoveZeroByte) {
   char Buffer[] = {'a', 'b', 'y', 'z'};
TEST(LlvmLibcMemmoveTest, DstFollowSrc) {
   void *const Dst = Buffer + 2;
   void *const Ret = __llvm_libc::memmove(Dst, Buffer + 1, 1);
   EXPECT_EQ(Ret, Dst);
   ASSERT_MEM_EQ(Buffer, Expected);
 }
 
 static constexpr int kMaxSize = 512;
 
-char GetRandomChar() {
-  static constexpr const uint64_t A = 1103515245;
-  static constexpr const uint64_t C = 12345;
-  static constexpr const uint64_t M = 1ULL << 31;
-  static uint64_t Seed = 123456789;
-  Seed = (A * Seed + C) % M;
-  return Seed;
-}
-
-void Randomize(span<char> Buffer) {
-  for (auto &current : Buffer)
-    current = GetRandomChar();
-}
-
 TEST(LlvmLibcMemmoveTest, SizeSweep) {
   using LargeBuffer = array<char, 3 * kMaxSize>;
   LargeBuffer GroundTruth;
-  Randomize(GroundTruth);
+  __llvm_libc::Randomize(GroundTruth);
   for (int Size = 0; Size < kMaxSize; ++Size) {
     for (int Offset = -Size; Offset < Size; ++Offset) {
       LargeBuffer Buffer = GroundTruth;
       LargeBuffer Expected = GroundTruth;
       size_t DstOffset = kMaxSize;
       size_t SrcOffset = kMaxSize + Offset;
       for (int I = 0; I < Size; ++I)
         Expected[DstOffset + I] = GroundTruth[SrcOffset + I];
       void *const Dst = Buffer.data() + DstOffset;
       void *const Ret =
           __llvm_libc::memmove(Dst, Buffer.data() + SrcOffset, Size);
       EXPECT_EQ(Ret, Dst);
       ASSERT_MEM_EQ(Buffer, Expected);
     }
   }
 }

libc/test/src/string/memory_utils/memory_check_utils.h

 };
 
 static inline char GetRandomChar() {
   static constexpr const uint64_t a = 1103515245;
   static constexpr const uint64_t c = 12345;
   static constexpr const uint64_t m = 1ULL << 31;
   static uint64_t seed = 123456789;
   seed = (a * seed + c) % m;
-  return seed;
+  return static_cast<char>(seed);
 }
 
 // Randomize the content of the buffer.
 static inline void Randomize(cpp::span<char> buffer) {
   for (auto &current : buffer)
     current = GetRandomChar();
 }
 

libc/test/src/string/strsignal_test.cpp

const char *rt_message_array[] = {
       "Real-time signal 18", "Real-time signal 19", "Real-time signal 20",
       "Real-time signal 21", "Real-time signal 22", "Real-time signal 23",
       "Real-time signal 24", "Real-time signal 25", "Real-time signal 26",
       "Real-time signal 27", "Real-time signal 28", "Real-time signal 29",
       "Real-time signal 30", "Real-time signal 31", "Real-time signal 32",
   };
 
   for (size_t i = 0; i < (sizeof(message_array) / sizeof(char *)); ++i) {
-    EXPECT_STREQ(__llvm_libc::strsignal(i), message_array[i]);
+    ASSERT_EQ(static_cast<size_t>(static_cast<int>(i)), i);
+    EXPECT_STREQ(__llvm_libc::strsignal(static_cast<int>(i)), message_array[i]);
   }
 
-  for (size_t i = 0; i < SIGRTMAX - SIGRTMIN; ++i) {
+  for (int i = 0; i < SIGRTMAX - SIGRTMIN; ++i) {
     EXPECT_STREQ(__llvm_libc::strsignal(i + SIGRTMIN), rt_message_array[i]);
   }
 }
 
 TEST(LlvmLibcStrsignalTest, UnknownSignals) {
   ASSERT_STREQ(__llvm_libc::strsignal(-1), "Unknown signal -1");
   ASSERT_STREQ(__llvm_libc::strsignal(65), "Unknown signal 65");
   ASSERT_STREQ(__llvm_libc::strsignal(2147483647), "Unknown signal 2147483647");
   ASSERT_STREQ(__llvm_libc::strsignal(-2147483648),
                "Unknown signal -2147483648");
 }