[libc++] Remove uses of printf in some test support headers

[ldionne]

Summary

In the test suite, we generally don't use printf or other reporting
utilities. It's not that it wouldn't be useful, it's just that some
platforms don't support IO.

Instead, we try to keep test cases small and self-contained so that
we can reasonably easily reproduce failures locally and debug them.
This patch removes printf in some of the last places in the test suite
that used it. The only remaining places are in a deque test and in the
filesystem tests. The filesystem tests are arguably fine to keep using
IO, since we're testing <filesystem>. The deque test will be handled
separately.

[• Quuxplusone]

Seems fine. Although I wonder if we could go further: These functions that check a bunch of stuff and return true-or-false, could they instead just assert all that stuff and return void?

[ldionne]

In D114282#3143945, @Quuxplusone wrote:

Seems fine. Although I wonder if we could go further: These functions that check a bunch of stuff and return true-or-false, could they instead just assert all that stuff and return void?

That would be more difficult since several tests use the return value of these functions to do more than just assert.

libcxx/test/support/controlled_allocators.h

public:
     bool checkDeallocMatchesAlloc() const {
         return last_dealloc_pointer == last_alloc_pointer &&
                last_dealloc_size == last_alloc_size &&
                last_dealloc_align == last_alloc_align;
     }
 
     template <class ...Args, class Alloc, class Tp>
     bool checkConstruct(Alloc const&, Tp *p) const {
         auto expectAlloc = &makeTypeID<Alloc>();
         auto expectTp = &makeTypeID<Tp>();
         auto expectArgs = &makeArgumentID<Args...>();
-      return last_construct_pointer == p &&
-          COMPARE_TYPEID(last_construct_alloc, expectAlloc) &&
-          COMPARE_TYPEID(last_construct_type, expectTp) &&
-          COMPARE_TYPEID(last_construct_args, expectArgs);
+        if (last_construct_pointer != p)
+            return false;
+        if (last_construct_alloc != expectAlloc)
+            return false;
+        if (last_construct_type != expectTp)
+            return false;
+        if (last_construct_args != expectArgs)
+            return false;
+        return true;
     }
 
     template <class Alloc, class Tp>
     bool checkDestroy(Alloc const&, Tp *p) const {
       return last_destroy_pointer == p &&
           last_destroy_alloc == &makeTypeID<Alloc>() &&
           last_destroy_type == &makeTypeID<Tp>();
     }

libcxx/test/support/type_id.h

 //===----------------------------------------------------------------------===//
 //
 // 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 SUPPORT_TYPE_ID_H
 #define SUPPORT_TYPE_ID_H
 
-#include <functional>
 #include <string>
-#include <cstdio>
 #include <cassert>
 
 #include "test_macros.h"
 
 #if TEST_STD_VER < 11
 #error This header requires C++11 or greater
 #endif
 

 
 // makeArgumentID - Create and return a unique identifier for a given set
 // of arguments.
 template <class ...Args>
 inline  TypeID const& makeArgumentID() {
   return makeTypeIDImp<ArgumentListID<Args...>>();
 }
 
-
-// COMPARE_TYPEID(...) is a utility macro for generating diagnostics when
-// two typeid's are expected to be equal
-#define COMPARE_TYPEID(LHS, RHS) CompareTypeIDVerbose(#LHS, LHS, #RHS, RHS)
-
-inline bool CompareTypeIDVerbose(const char* LHSString, TypeID const* LHS,
-                                 const char* RHSString, TypeID const* RHS) {
-  if (*LHS == *RHS)
-    return true;
-  std::printf("TypeID's not equal:\n");
-  std::printf("%s: %s\n----------\n%s: %s\n",
-              LHSString, LHS->name().c_str(),
-              RHSString, RHS->name().c_str());
-  return false;
-}
-
 #endif // SUPPORT_TYPE_ID_H

libcxx/test/support/uses_alloc_types.h

 //===----------------------------------------------------------------------===//
 //
 // 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 USES_ALLOC_TYPES_H
 #define USES_ALLOC_TYPES_H
 
 #include <cassert>
-#include <cstdio>
 #include <cstdlib>
 #include <memory>
 
 #include "test_macros.h"
 #include "test_workarounds.h"
 #include "type_id.h"
 
 // There are two forms of uses-allocator construction:
case UA_AllocArg:
         return "UA_AllocArg";
     case UA_AllocLast:
         return "UA_AllocLast";
     default:
     std::abort();
     }
 }
 
-#define COMPARE_ALLOC_TYPE(LHS, RHS) CompareVerbose(#LHS, LHS, #RHS, RHS)
-
-inline bool CompareVerbose(const char* LHSString, UsesAllocatorType LHS,
-                           const char* RHSString, UsesAllocatorType RHS) {
-    if (LHS == RHS)
-        return true;
-    std::printf("UsesAllocatorType's don't match:\n%s %s\n----------\n%s %s\n",
-                LHSString, toString(LHS), RHSString, toString(RHS));
-    return false;
-}
-
 template <class Alloc, std::size_t N>
 class UsesAllocatorV1;
     // Implements form (1) of uses-allocator construction from the specified
     // 'Alloc' type and exactly 'N' additional arguments. It also provides
     // non-uses allocator construction from 'N' arguments. This test type
     // blows up when form (2) of uses-allocator is even considered.
 
 template <class Alloc, std::size_t N>

 template <class Self, class Alloc>
 struct UsesAllocatorTestBase {
 public:
     using CtorAlloc = typename TransformErasedTypeAlloc<Alloc>::type;
 
     template <class ...ArgTypes>
     bool checkConstruct(UsesAllocatorType expectType) const {
         auto expectArgs = &makeArgumentID<ArgTypes...>();
-        return COMPARE_ALLOC_TYPE(expectType, constructor_called) &&
-               COMPARE_TYPEID(args_id, expectArgs);
+        if (expectType != constructor_called)
+            return false;
+        if (args_id != expectArgs)
+            return false;
+        return true;
     }
 
     template <class ...ArgTypes>
     bool checkConstruct(UsesAllocatorType expectType,
                         CtorAlloc const& expectAlloc) const {
         auto ExpectID = &makeArgumentID<ArgTypes...>() ;
-        return COMPARE_ALLOC_TYPE(expectType, constructor_called) &&
-               COMPARE_TYPEID(args_id, ExpectID) &&
-               has_alloc() && expectAlloc == *get_alloc();
-
+        if (expectType != constructor_called)
+            return false;
+        if (args_id != ExpectID)
+            return false;
+        if (!has_alloc() || expectAlloc != *get_alloc())
+            return false;
+        return true;
     }
 
     bool checkConstructEquiv(UsesAllocatorTestBase& O) const {
         if (has_alloc() != O.has_alloc())
             return false;
-        return COMPARE_ALLOC_TYPE(constructor_called, O.constructor_called)
-            && COMPARE_TYPEID(args_id, O.args_id)
-            && (!has_alloc() || *get_alloc() == *O.get_alloc());
+        if (constructor_called != O.constructor_called)
+            return false;
+        if (args_id != O.args_id)
+            return false;
+        if (has_alloc() && *get_alloc() != *O.get_alloc())
+            return false;
+        return true;
     }
 
 protected:
     explicit UsesAllocatorTestBase(const TypeID* aid)
         : args_id(aid), constructor_called(UA_None), alloc_store()
     {}
 
     UsesAllocatorTestBase(UsesAllocatorTestBase const&)