Don't use `sizeof(a) / sizeof(a)` to compute the number of elements in array a.

base/shared_memory_unittest.cc

 // Copyright (c) 2011 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/basictypes.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/shared_memory.h"
 #include "base/test/multiprocess_test.h"
 #include "base/threading/platform_thread.h"
@@ skipping 24 matching lines @@
   // PlatformThread::Delegate interface.
   void ThreadMain() {
     mac::ScopedNSAutoreleasePool pool;  // noop if not OSX
     const uint32 kDataSize = 1024;
     SharedMemory memory;
     bool rv = memory.CreateNamed(s_test_name_, true, kDataSize);
     EXPECT_TRUE(rv);
     rv = memory.Map(kDataSize);
     EXPECT_TRUE(rv);
     int *ptr = static_cast<int*>(memory.memory()) + id_;
-    EXPECT_EQ(*ptr, 0);
+    EXPECT_EQ(0, *ptr);
 
     for (int idx = 0; idx < 100; idx++) {
       *ptr = idx;
       PlatformThread::Sleep(1);  // Short wait.
       EXPECT_EQ(*ptr, idx);
     }
+    // Reset back to 0 for the next test that uses the same name.
+    *ptr = 0;
 
     memory.Close();
   }
 
  private:
   int16 id_;
 
   static const char* const s_test_name_;
 
   DISALLOW_COPY_AND_ASSIGN(MultipleThreadMain);
@@ skipping 159 matching lines @@
 TEST(SharedMemoryTest, MultipleThreads) {
   MultipleThreadMain::CleanUp();
   // On POSIX we have a problem when 2 threads try to create the shmem
   // (a file) at exactly the same time, since create both creates the
   // file and zerofills it.  We solve the problem for this unit test
   // (make it not flaky) by starting with 1 thread, then
   // intentionally don't clean up its shmem before running with
   // kNumThreads.
 
   int threadcounts[] = { 1, kNumThreads };
-  for (size_t i = 0; i < sizeof(threadcounts) / sizeof(threadcounts); i++) {
+  for (size_t i = 0; i < arraysize(threadcounts); i++) {
     int numthreads = threadcounts[i];
     scoped_array<PlatformThreadHandle> thread_handles;
     scoped_array<MultipleThreadMain*> thread_delegates;
 
     thread_handles.reset(new PlatformThreadHandle[numthreads]);
     thread_delegates.reset(new MultipleThreadMain*[numthreads]);
 
     // Spawn the threads.
     for (int16 index = 0; index < numthreads; index++) {
       PlatformThreadHandle pth;
@@ skipping 151 matching lines @@
   }
 
   SharedMemoryProcessTest::CleanUp();
 }
 
 MULTIPROCESS_TEST_MAIN(SharedMemoryTestMain) {
   return SharedMemoryProcessTest::TaskTestMain();
 }
 
 }  // namespace base