Revert 41938 - Merged third_party/tcmalloc/vendor/src(googleperftools r87) in...

third_party/tcmalloc/chromium/src/tests/atomicops_unittest.cc

 /* Copyright (c) 2006, Google Inc.
  * All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  * 
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 42 matching lines @@
   } s;
 
   AtomicType prev_word_value, next_word_value;
   memset(&prev_word_value, 0xFF, sizeof(AtomicType));
   memset(&next_word_value, 0xEE, sizeof(AtomicType));
 
   s.prev_word = prev_word_value;
   s.count = 0;
   s.next_word = next_word_value;
 
-  ASSERT_EQ(1, base::subtle::NoBarrier_AtomicIncrement(&s.count, 1));
-  ASSERT_EQ(1, s.count);
-  ASSERT_EQ(prev_word_value, s.prev_word);
-  ASSERT_EQ(next_word_value, s.next_word);
+  CHECK_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, 1), 1);
+  CHECK_EQ(s.count, 1);
+  CHECK_EQ(s.prev_word, prev_word_value);
+  CHECK_EQ(s.next_word, next_word_value);
 
-  ASSERT_EQ(3, base::subtle::NoBarrier_AtomicIncrement(&s.count, 2));
-  ASSERT_EQ(3, s.count);
-  ASSERT_EQ(prev_word_value, s.prev_word);
-  ASSERT_EQ(next_word_value, s.next_word);
+  CHECK_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, 2), 3);
+  CHECK_EQ(s.count, 3);
+  CHECK_EQ(s.prev_word, prev_word_value);
+  CHECK_EQ(s.next_word, next_word_value);
 
-  ASSERT_EQ(6, base::subtle::NoBarrier_AtomicIncrement(&s.count, 3));
-  ASSERT_EQ(6, s.count);
-  ASSERT_EQ(prev_word_value, s.prev_word);
-  ASSERT_EQ(next_word_value, s.next_word);
+  CHECK_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, 3), 6);
+  CHECK_EQ(s.count, 6);
+  CHECK_EQ(s.prev_word, prev_word_value);
+  CHECK_EQ(s.next_word, next_word_value);
 
-  ASSERT_EQ(3, base::subtle::NoBarrier_AtomicIncrement(&s.count, -3));
-  ASSERT_EQ(3, s.count);
-  ASSERT_EQ(prev_word_value, s.prev_word);
-  ASSERT_EQ(next_word_value, s.next_word);
+  CHECK_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, -3), 3);
+  CHECK_EQ(s.count, 3);
+  CHECK_EQ(s.prev_word, prev_word_value);
+  CHECK_EQ(s.next_word, next_word_value);
 
-  ASSERT_EQ(1, base::subtle::NoBarrier_AtomicIncrement(&s.count, -2));
-  ASSERT_EQ(1, s.count);
-  ASSERT_EQ(prev_word_value, s.prev_word);
-  ASSERT_EQ(next_word_value, s.next_word);
+  CHECK_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, -2), 1);
+  CHECK_EQ(s.count, 1);
+  CHECK_EQ(s.prev_word, prev_word_value);
+  CHECK_EQ(s.next_word, next_word_value);
 
-  ASSERT_EQ(0, base::subtle::NoBarrier_AtomicIncrement(&s.count, -1));
-  ASSERT_EQ(0, s.count);
-  ASSERT_EQ(prev_word_value, s.prev_word);
-  ASSERT_EQ(next_word_value, s.next_word);
+  CHECK_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, -1), 0);
+  CHECK_EQ(s.count, 0);
+  CHECK_EQ(s.prev_word, prev_word_value);
+  CHECK_EQ(s.next_word, next_word_value);
 
-  ASSERT_EQ(-1, base::subtle::NoBarrier_AtomicIncrement(&s.count, -1));
-  ASSERT_EQ(-1, s.count);
-  ASSERT_EQ(prev_word_value, s.prev_word);
-  ASSERT_EQ(next_word_value, s.next_word);
+  CHECK_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, -1), -1);
+  CHECK_EQ(s.count, -1);
+  CHECK_EQ(s.prev_word, prev_word_value);
+  CHECK_EQ(s.next_word, next_word_value);
 
-  ASSERT_EQ(-5, base::subtle::NoBarrier_AtomicIncrement(&s.count, -4));
-  ASSERT_EQ(-5, s.count);
-  ASSERT_EQ(prev_word_value, s.prev_word);
-  ASSERT_EQ(next_word_value, s.next_word);
+  CHECK_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, -4), -5);
+  CHECK_EQ(s.count, -5);
+  CHECK_EQ(s.prev_word, prev_word_value);
+  CHECK_EQ(s.next_word, next_word_value);
 
-  ASSERT_EQ(0, base::subtle::NoBarrier_AtomicIncrement(&s.count, 5));
-  ASSERT_EQ(0, s.count);
-  ASSERT_EQ(prev_word_value, s.prev_word);
-  ASSERT_EQ(next_word_value, s.next_word);
+  CHECK_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, 5), 0);
+  CHECK_EQ(s.count, 0);
+  CHECK_EQ(s.prev_word, prev_word_value);
+  CHECK_EQ(s.next_word, next_word_value);
 }
 
 
 #define NUM_BITS(T) (sizeof(T) * 8)
 
 
 template <class AtomicType>
 static void TestCompareAndSwap() {
   AtomicType value = 0;
   AtomicType prev = base::subtle::NoBarrier_CompareAndSwap(&value, 0, 1);
-  ASSERT_EQ(1, value);
-  ASSERT_EQ(0, prev);
+  CHECK_EQ(1, value);
+  CHECK_EQ(0, prev);
 
   // Use test value that has non-zero bits in both halves, more for testing
   // 64-bit implementation on 32-bit platforms.
   const AtomicType k_test_val = (GG_ULONGLONG(1) <<
                                  (NUM_BITS(AtomicType) - 2)) + 11;
   value = k_test_val;
   prev = base::subtle::NoBarrier_CompareAndSwap(&value, 0, 5);
-  ASSERT_EQ(k_test_val, value);
-  ASSERT_EQ(k_test_val, prev);
+  CHECK_EQ(k_test_val, value);
+  CHECK_EQ(k_test_val, prev);
 
   value = k_test_val;
   prev = base::subtle::NoBarrier_CompareAndSwap(&value, k_test_val, 5);
-  ASSERT_EQ(5, value);
-  ASSERT_EQ(k_test_val, prev);
+  CHECK_EQ(5, value);
+  CHECK_EQ(k_test_val, prev);
 }
 
 
 template <class AtomicType>
 static void TestAtomicExchange() {
   AtomicType value = 0;
   AtomicType new_value = base::subtle::NoBarrier_AtomicExchange(&value, 1);
-  ASSERT_EQ(1, value);
-  ASSERT_EQ(0, new_value);
+  CHECK_EQ(1, value);
+  CHECK_EQ(0, new_value);
 
   // Use test value that has non-zero bits in both halves, more for testing
   // 64-bit implementation on 32-bit platforms.
   const AtomicType k_test_val = (GG_ULONGLONG(1) <<
                                  (NUM_BITS(AtomicType) - 2)) + 11;
   value = k_test_val;
   new_value = base::subtle::NoBarrier_AtomicExchange(&value, k_test_val);
-  ASSERT_EQ(k_test_val, value);
-  ASSERT_EQ(k_test_val, new_value);
+  CHECK_EQ(k_test_val, value);
+  CHECK_EQ(k_test_val, new_value);
 
   value = k_test_val;
   new_value = base::subtle::NoBarrier_AtomicExchange(&value, 5);
-  ASSERT_EQ(5, value);
-  ASSERT_EQ(k_test_val, new_value);
+  CHECK_EQ(5, value);
+  CHECK_EQ(k_test_val, new_value);
 }
 
 
 template <class AtomicType>
 static void TestAtomicIncrementBounds() {
   // Test increment at the half-width boundary of the atomic type.
   // It is primarily for testing at the 32-bit boundary for 64-bit atomic type.
   AtomicType test_val = GG_ULONGLONG(1) << (NUM_BITS(AtomicType) / 2);
   AtomicType value = test_val - 1;
   AtomicType new_value = base::subtle::NoBarrier_AtomicIncrement(&value, 1);
-  ASSERT_EQ(test_val, value);
-  ASSERT_EQ(value, new_value);
+  CHECK_EQ(test_val, value);
+  CHECK_EQ(value, new_value);
 
   base::subtle::NoBarrier_AtomicIncrement(&value, -1);
-  ASSERT_EQ(test_val - 1, value);
+  CHECK_EQ(test_val - 1, value);
 }
 
 // This is a simple sanity check that values are correct. Not testing
 // atomicity
 template <class AtomicType>
 static void TestStore() {
   const AtomicType kVal1 = static_cast<AtomicType>(0xa5a5a5a5a5a5a5a5LL);
   const AtomicType kVal2 = static_cast<AtomicType>(-1);
 
   AtomicType value;
 
   base::subtle::NoBarrier_Store(&value, kVal1);
-  ASSERT_EQ(kVal1, value);
+  CHECK_EQ(kVal1, value);
   base::subtle::NoBarrier_Store(&value, kVal2);
-  ASSERT_EQ(kVal2, value);
+  CHECK_EQ(kVal2, value);
 
   base::subtle::Acquire_Store(&value, kVal1);
-  ASSERT_EQ(kVal1, value);
+  CHECK_EQ(kVal1, value);
   base::subtle::Acquire_Store(&value, kVal2);
-  ASSERT_EQ(kVal2, value);
+  CHECK_EQ(kVal2, value);
 
   base::subtle::Release_Store(&value, kVal1);
-  ASSERT_EQ(kVal1, value);
+  CHECK_EQ(kVal1, value);
   base::subtle::Release_Store(&value, kVal2);
-  ASSERT_EQ(kVal2, value);
+  CHECK_EQ(kVal2, value);
 }
 
 // This is a simple sanity check that values are correct. Not testing
 // atomicity
 template <class AtomicType>
 static void TestLoad() {
   const AtomicType kVal1 = static_cast<AtomicType>(0xa5a5a5a5a5a5a5a5LL);
   const AtomicType kVal2 = static_cast<AtomicType>(-1);
 
   AtomicType value;
 
   value = kVal1;
-  ASSERT_EQ(kVal1, base::subtle::NoBarrier_Load(&value));
+  CHECK_EQ(kVal1, base::subtle::NoBarrier_Load(&value));
   value = kVal2;
-  ASSERT_EQ(kVal2, base::subtle::NoBarrier_Load(&value));
+  CHECK_EQ(kVal2, base::subtle::NoBarrier_Load(&value));
 
   value = kVal1;
-  ASSERT_EQ(kVal1, base::subtle::Acquire_Load(&value));
+  CHECK_EQ(kVal1, base::subtle::Acquire_Load(&value));
   value = kVal2;
-  ASSERT_EQ(kVal2, base::subtle::Acquire_Load(&value));
+  CHECK_EQ(kVal2, base::subtle::Acquire_Load(&value));
 
   value = kVal1;
-  ASSERT_EQ(kVal1, base::subtle::Release_Load(&value));
+  CHECK_EQ(kVal1, base::subtle::Release_Load(&value));
   value = kVal2;
-  ASSERT_EQ(kVal2, base::subtle::Release_Load(&value));
+  CHECK_EQ(kVal2, base::subtle::Release_Load(&value));
 }
 
 template <class AtomicType>
 static void TestAtomicOps() {
   TestCompareAndSwap<AtomicType>();
   TestAtomicExchange<AtomicType>();
   TestAtomicIncrementBounds<AtomicType>();
   TestStore<AtomicType>();
   TestLoad<AtomicType>();
 }
@@ skipping 17 matching lines @@
   // If we ever *do* want to enable this, try adding -msse (or -mmmx?)
   // to the CXXFLAGS in Makefile.am.
 #if 0 and defined(BASE_HAS_ATOMIC64)
   TestAtomicIncrement<base::subtle::Atomic64>();
   TestAtomicOps<base::subtle::Atomic64>();
 #endif
 
   printf("PASS\n");
   return 0;
 }