[libc] Remove use of 'assert' from the string tests

[jhuber6]

Summary

Currently we use assert as a stand-in for the typical test assertions.
This is because these functions exist outside of the base test class so
we can't use the typical assertion methods. The presence of these
asserts makes it difficult to compile these tests in a standalone
format. This patch removes all occurrences.

[jhuber6]

Remove asserts completely

libc/test/src/string/bzero_test.cpp

 #include "src/string/bzero.h"
 #include "test/UnitTest/Test.h"
 
 namespace __llvm_libc {
 
 // Adapt CheckMemset signature to op implementation signatures.
 template <auto FnImpl>
 void BzeroAdaptor(cpp::span<char> p1, uint8_t value, size_t size) {
-  assert(value == 0);
   FnImpl(p1.begin(), size);
 }
 
 TEST(LlvmLibcBzeroTest, SizeSweep) {
   static constexpr size_t kMaxSize = 1024;
   static constexpr auto Impl = BzeroAdaptor<__llvm_libc::bzero>;
   Buffer DstBuffer(kMaxSize);
   for (size_t size = 0; size < kMaxSize; ++size) {
     auto dst = DstBuffer.span().subspan(0, size);
     ASSERT_TRUE((CheckMemset<Impl>(dst, 0, size)));
   }
 }
 
 } // namespace __llvm_libc

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

 //===-- Utils to test conformance of mem functions ------------------------===//
 //
 // 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 LIBC_TEST_SRC_STRING_MEMORY_UTILS_MEMORY_CHECK_UTILS_H
 #define LIBC_TEST_SRC_STRING_MEMORY_UTILS_MEMORY_CHECK_UTILS_H
 
 #include "src/__support/CPP/span.h"
 #include "src/__support/macros/sanitizer.h"
 #include "src/string/memory_utils/utils.h"
-#include <assert.h> // assert
 #include <stddef.h> // size_t
 #include <stdint.h> // uintxx_t
 #include <stdlib.h> // malloc/free
 
 namespace __llvm_libc {
 
 // Simple structure to allocate a buffer of a particular size.
 // When ASAN is present it also poisons the whole memory.
 // This is a utility class to be used by Buffer below, do not use directly.
 struct PoisonedBuffer {
   PoisonedBuffer(size_t size) : ptr((char *)malloc(size)) {
-    assert(ptr);
     ASAN_POISON_MEMORY_REGION(ptr, size);
   }
   ~PoisonedBuffer() { free(ptr); }
 
 protected:
   char *ptr = nullptr;
 };
 
 // Simple structure to allocate a buffer (aligned or not) of a particular size.
 // It is backed by a wider buffer that is marked poisoned when ASAN is present.
 // The requested region is unpoisoned, this allows catching out of bounds
 // accesses.
 enum class Aligned : bool { NO = false, YES = true };
 struct Buffer : private PoisonedBuffer {
   static constexpr size_t kAlign = 64;
   static constexpr size_t kLeeway = 2 * kAlign;
   Buffer(size_t size, Aligned aligned = Aligned::YES)
       : PoisonedBuffer(size + kLeeway), size(size) {
     offset_ptr = ptr;
     offset_ptr += distance_to_next_aligned<kAlign>(ptr);
-    assert((uintptr_t)(offset_ptr) % kAlign == 0);
     if (aligned == Aligned::NO)
       ++offset_ptr;
-    assert(offset_ptr > ptr);
-    assert((offset_ptr + size) < (ptr + size + kLeeway));
     ASAN_UNPOISON_MEMORY_REGION(offset_ptr, size);
   }
   cpp::span<char> span() { return cpp::span<char>(offset_ptr, size); }
 
 private:
   size_t size = 0;
   char *offset_ptr = nullptr;
 };

 static inline void Randomize(cpp::span<char> buffer) {
   for (auto &current : buffer)
     current = GetRandomChar();
 }
 
 // Copy one span to another.
 static inline void ReferenceCopy(cpp::span<char> dst,
                                  const cpp::span<char> src) {
-  assert(dst.size() == src.size());
   for (size_t i = 0; i < dst.size(); ++i)
     dst[i] = src[i];
 }
 
 // Checks that FnImpl implements the memcpy semantic.
 template <auto FnImpl>
 bool CheckMemcpy(cpp::span<char> dst, cpp::span<char> src, size_t size) {
-  assert(dst.size() == src.size());
-  assert(dst.size() == size);
   Randomize(dst);
   FnImpl(dst, src, size);
   for (size_t i = 0; i < size; ++i)
     if (dst[i] != src[i])
       return false;
   return true;
 }
 
 // Checks that FnImpl implements the memset semantic.
 template <auto FnImpl>
 bool CheckMemset(cpp::span<char> dst, uint8_t value, size_t size) {
   Randomize(dst);
   FnImpl(dst, value, size);
   for (char c : dst)
     if (c != (char)value)
       return false;
   return true;
 }
 
 // Checks that FnImpl implements the bcmp semantic.
 template <auto FnImpl>
 bool CheckBcmp(cpp::span<char> span1, cpp::span<char> span2, size_t size) {
-  assert(span1.size() == span2.size());
   ReferenceCopy(span2, span1);
   // Compare equal
   if (int cmp = FnImpl(span1, span2, size); cmp != 0)
     return false;
   // Compare not equal if any byte differs
   for (size_t i = 0; i < size; ++i) {
     ++span2[i];
     if (int cmp = FnImpl(span1, span2, size); cmp == 0)
       return false;
     if (int cmp = FnImpl(span2, span1, size); cmp == 0)
       return false;
     --span2[i];
   }
   return true;
 }
 
 // Checks that FnImpl implements the memcmp semantic.
 template <auto FnImpl>
 bool CheckMemcmp(cpp::span<char> span1, cpp::span<char> span2, size_t size) {
-  assert(span1.size() == span2.size());
   ReferenceCopy(span2, span1);
   // Compare equal
   if (int cmp = FnImpl(span1, span2, size); cmp != 0)
     return false;
   // Compare not equal if any byte differs
   for (size_t i = 0; i < size; ++i) {
     ++span2[i];
     int ground_truth = __builtin_memcmp(span1.data(), span2.data(), size);

libc/test/src/string/memory_utils/op_tests.cpp

 //===-- Unittests for op_ files -------------------------------------------===//
 //
 // 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 "memory_check_utils.h"
 #include "src/string/memory_utils/op_aarch64.h"
 #include "src/string/memory_utils/op_builtin.h"
 #include "src/string/memory_utils/op_generic.h"
 #include "src/string/memory_utils/op_x86.h"
 #include "test/UnitTest/Test.h"
 
-#include <assert.h>
-
 #if defined(LIBC_TARGET_ARCH_IS_X86_64) || defined(LIBC_TARGET_ARCH_IS_AARCH64)
 #define LLVM_LIBC_HAS_UINT64
 #endif
 
 namespace __llvm_libc {
 
 template <typename T> struct has_head_tail {
   template <typename C> static char sfinae(decltype(&C::head_tail));

 
 // Adapt CheckMemcpy signature to op implementation signatures.
 template <auto FnImpl>
 void CopyAdaptor(cpp::span<char> dst, cpp::span<char> src, size_t size) {
   FnImpl(as_byte(dst), as_byte(src), size);
 }
 template <size_t Size, auto FnImpl>
 void CopyBlockAdaptor(cpp::span<char> dst, cpp::span<char> src, size_t size) {
-  assert(size == Size);
   FnImpl(as_byte(dst), as_byte(src));
 }
 
 TYPED_TEST(LlvmLibcOpTest, Memcpy, MemcpyImplementations) {
   using Impl = ParamType;
   constexpr size_t kSize = Impl::SIZE;
   { // Test block operation
     static constexpr auto BlockImpl = CopyBlockAdaptor<kSize, Impl::block>;

 
 // Adapt CheckMemset signature to op implementation signatures.
 template <auto FnImpl>
 void SetAdaptor(cpp::span<char> dst, uint8_t value, size_t size) {
   FnImpl(as_byte(dst), value, size);
 }
 template <size_t Size, auto FnImpl>
 void SetBlockAdaptor(cpp::span<char> dst, uint8_t value, size_t size) {
-  assert(size == Size);
   FnImpl(as_byte(dst), value);
 }
 
 TYPED_TEST(LlvmLibcOpTest, Memset, MemsetImplementations) {
   using Impl = ParamType;
   constexpr size_t kSize = Impl::SIZE;
   { // Test block operation
     static constexpr auto BlockImpl = SetBlockAdaptor<kSize, Impl::block>;

 
 // Adapt CheckBcmp signature to op implementation signatures.
 template <auto FnImpl>
 int CmpAdaptor(cpp::span<char> p1, cpp::span<char> p2, size_t size) {
   return (int)FnImpl(as_byte(p1), as_byte(p2), size);
 }
 template <size_t Size, auto FnImpl>
 int CmpBlockAdaptor(cpp::span<char> p1, cpp::span<char> p2, size_t size) {
-  assert(size == Size);
   return (int)FnImpl(as_byte(p1), as_byte(p2));
 }
 
 TYPED_TEST(LlvmLibcOpTest, Bcmp, BcmpImplementations) {
   using Impl = ParamType;
   constexpr size_t kSize = Impl::SIZE;
   { // Test block operation
     static constexpr auto BlockImpl = CmpBlockAdaptor<kSize, Impl::block>;