Replace 0x42 with 0x420 in ThreadDelegateForNewHandlerTest

base/allocator/allocator_shim_unittest.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/allocator/allocator_shim.h"
 
 #include <malloc.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
@@ skipping 58 matching lines @@
       if (alignment < kMaxSizeTracked)
         ++(instance_->aligned_allocs_intercepted_by_alignment[alignment]);
     }
     return self->next->alloc_aligned_function(self->next, alignment, size);
   }
 
   static void* MockRealloc(const AllocatorDispatch* self,
                            void* address,
                            size_t size) {
     if (instance_) {
-      // Address 0x42 is a special sentinel for the NewHandlerConcurrency test.
+      // Address 0x420 is a special sentinel for the NewHandlerConcurrency test.
       // The first time (but only the first one) it is hit it fails, causing the
       // invocation of the std::new_handler.
-      if (address == reinterpret_cast<void*>(0x42)) {
-        if (!instance_->did_fail_realloc_0x42_once->Get()) {
-          instance_->did_fail_realloc_0x42_once->Set(true);
+      if (address == reinterpret_cast<void*>(0x420)) {
+        if (!instance_->did_fail_realloc_0x420_once->Get()) {
+          instance_->did_fail_realloc_0x420_once->Set(true);
           return nullptr;
         } else {
-          return reinterpret_cast<void*>(0x42ul);
+          return reinterpret_cast<void*>(0x420ul);
         }
       }
 
       if (size < kMaxSizeTracked)
         ++(instance_->reallocs_intercepted_by_size[size]);
       ++instance_->reallocs_intercepted_by_addr[Hash(address)];
     }
     return self->next->realloc_function(self->next, address, size);
   }
 
@@ skipping 15 matching lines @@
   }
 
   void SetUp() override {
     const size_t array_size = kMaxSizeTracked * sizeof(size_t);
     memset(&allocs_intercepted_by_size, 0, array_size);
     memset(&zero_allocs_intercepted_by_size, 0, array_size);
     memset(&aligned_allocs_intercepted_by_size, 0, array_size);
     memset(&aligned_allocs_intercepted_by_alignment, 0, array_size);
     memset(&reallocs_intercepted_by_size, 0, array_size);
     memset(&frees_intercepted_by_addr, 0, array_size);
-    did_fail_realloc_0x42_once.reset(new ThreadLocalBoolean());
+    did_fail_realloc_0x420_once.reset(new ThreadLocalBoolean());
     subtle::Release_Store(&num_new_handler_calls, 0);
     instance_ = this;
   }
 
   void TearDown() override { instance_ = nullptr; }
 
  protected:
   size_t allocs_intercepted_by_size[kMaxSizeTracked];
   size_t zero_allocs_intercepted_by_size[kMaxSizeTracked];
   size_t aligned_allocs_intercepted_by_size[kMaxSizeTracked];
   size_t aligned_allocs_intercepted_by_alignment[kMaxSizeTracked];
   size_t reallocs_intercepted_by_size[kMaxSizeTracked];
   size_t reallocs_intercepted_by_addr[kMaxSizeTracked];
   size_t frees_intercepted_by_addr[kMaxSizeTracked];
-  std::unique_ptr<ThreadLocalBoolean> did_fail_realloc_0x42_once;
+  std::unique_ptr<ThreadLocalBoolean> did_fail_realloc_0x420_once;
   subtle::Atomic32 num_new_handler_calls;
 
  private:
   static AllocatorShimTest* instance_;
 };
 
 struct TestStruct1 {
   uint32_t ignored;
   uint8_t ignored_2;
 };
 
 struct TestStruct2 {
   uint64_t ignored;
   uint8_t ignored_3;
 };
 
 class ThreadDelegateForNewHandlerTest : public PlatformThread::Delegate {
  public:
   ThreadDelegateForNewHandlerTest(WaitableEvent* event) : event_(event) {}
 
   void ThreadMain() override {
     event_->Wait();
-    void* res = realloc(reinterpret_cast<void*>(0x42ul), 1);
-    EXPECT_EQ(0x42u, reinterpret_cast<uintptr_t>(res));
+    void* res = realloc(reinterpret_cast<void*>(0x420ul), 1);
+    EXPECT_EQ(reinterpret_cast<void*>(0x420ul), res);
   }
 
  private:
   WaitableEvent* event_;
 };
 
 AllocatorShimTest* AllocatorShimTest::instance_ = nullptr;
 
 AllocatorDispatch g_mock_dispatch = {
     &AllocatorShimTest::MockAlloc,         /* alloc_function */
@@ skipping 112 matching lines @@
 
   delete[] new_array_nt_ptr;
   ASSERT_GE(frees_intercepted_by_addr[Hash(new_array_nt_ptr)], 1u);
 
   RemoveAllocatorDispatchForTesting(&g_mock_dispatch);
 }
 
 // This test exercises the case of concurrent OOM failure, which would end up
 // invoking std::new_handler concurrently. This is to cover the CallNewHandler()
 // paths of allocator_shim.cc and smoke-test its thread safey.
-// The test creates kNumThreads threads. Each of them does just a realloc(0x42).
+// The test creates kNumThreads threads. Each of them does just a
+// realloc(0x420).
 // The shim intercepts such realloc and makes it fail only once on each thread.
 // We expect to see excactly kNumThreads invocations of the new_handler.
 TEST_F(AllocatorShimTest, NewHandlerConcurrency) {
   const int kNumThreads = 32;
   PlatformThreadHandle threads[kNumThreads];
 
   // The WaitableEvent here is used to attempt to trigger all the threads at
   // the same time, after they have been initialized.
   WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
                       WaitableEvent::InitialState::NOT_SIGNALED);
 
   ThreadDelegateForNewHandlerTest mock_thread_main(&event);
 
   for (int i = 0; i < kNumThreads; ++i)
     PlatformThread::Create(0, &mock_thread_main, &threads[i]);
 
   std::set_new_handler(&AllocatorShimTest::NewHandler);
   SetCallNewHandlerOnMallocFailure(true);  // It's going to fail on realloc().
   InsertAllocatorDispatch(&g_mock_dispatch);
   event.Signal();
   for (int i = 0; i < kNumThreads; ++i)
     PlatformThread::Join(threads[i]);
   RemoveAllocatorDispatchForTesting(&g_mock_dispatch);
   ASSERT_EQ(kNumThreads, GetNumberOfNewHandlerCalls());
 }
 
 }  // namespace
 }  // namespace allocator
 }  // namespace base