base: Discardable memory types.

base/memory/discardable_memory_unittest.cc

 // Copyright (c) 2013 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 <algorithm>
+#if defined(OS_ANDROID)
+#include <limits>
+#endif
+
 #include "base/memory/discardable_memory.h"
-
-#include <limits>
-
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
+namespace {
+
+class DiscardableMemoryTest
+    : public testing::TestWithParam<DiscardableMemoryType> {
+ public:
+  // Overridden from testing::Test:
+  virtual void SetUp() OVERRIDE {
+    old_type_ = DiscardableMemory::GetType();
+    DiscardableMemory::SetType(GetParam());
+  }
+  virtual void TearDown() OVERRIDE {
+    DiscardableMemory::SetType(old_type_);
+  }
+
+ private:
+  DiscardableMemoryType old_type_;
+};
 
 const size_t kSize = 1024;
 
 #if defined(OS_ANDROID)
-TEST(DiscardableMemoryTest, TooLargeAllocationFails) {
+TEST_P(DiscardableMemoryTest, TooLargeAllocationFails) {

[reveman, 2013/12/13 18:21:53]

Follow up patch will move this to _ashmem_unittest.cc.

[Philippe, 2013/12/17 14:28:21]

SGTM

+  if (GetParam() != DISCARDABLE_MEMORY_ANDROID)
+    return;
   const size_t kPageSize = 4096;
   const size_t max_allowed_allocation_size =
       std::numeric_limits<size_t>::max() - kPageSize + 1;
   scoped_ptr<DiscardableMemory> memory(
       DiscardableMemory::CreateLockedMemory(max_allowed_allocation_size + 1));
   // On certain platforms (e.g. Android), page-alignment would have caused an
   // overflow resulting in a small allocation if the input size wasn't checked
   // correctly.
   ASSERT_FALSE(memory);
 }
 #endif
 
-TEST(DiscardableMemoryTest, SupportedNatively) {
+bool IsNativeType(DiscardableMemoryType type) {
+  return type == DISCARDABLE_MEMORY_ANDROID || type == DISCARDABLE_MEMORY_MAC;
+}
+
+TEST_P(DiscardableMemoryTest, SupportedNatively) {
 #if defined(DISCARDABLE_MEMORY_ALWAYS_SUPPORTED_NATIVELY)
-  ASSERT_TRUE(DiscardableMemory::SupportedNatively());
+  ASSERT_TRUE(std::find_if(DiscardableMemory::GetSupportedTypes().begin(),

[Philippe, 2013/12/17 14:28:21]

JFYI, std::count_if() would be slightly more compact since you would not have to
compare the result with DiscardableMemory::GetSupportedTypes().end() but I'm
also fine with this.

[reveman, 2013/12/18 08:12:38]

Good idea. Done.

+                           DiscardableMemory::GetSupportedTypes().end(),
+                           IsNativeType) !=
+              DiscardableMemory::GetSupportedTypes().end());
 #else
   // If we ever have a platform that decides at runtime if it can support
   // discardable memory natively, then we'll have to add a 'never supported
   // natively' define for this case. At present, if it's not always supported
   // natively, it's never supported.
-  ASSERT_FALSE(DiscardableMemory::SupportedNatively());
+  ASSERT_FALSE(std::find_if(DiscardableMemory::GetSupportedTypes().begin(),
+                            DiscardableMemory::GetSupportedTypes().end(),
+                            IsNativeType) !=
+               DiscardableMemory::GetSupportedTypes().end());
 #endif
 }
 
 // Test Lock() and Unlock() functionalities.
-TEST(DiscardableMemoryTest, LockAndUnLock) {
+TEST_P(DiscardableMemoryTest, LockAndUnLock) {
   const scoped_ptr<DiscardableMemory> memory(
       DiscardableMemory::CreateLockedMemory(kSize));
   ASSERT_TRUE(memory);
   void* addr = memory->Memory();
   ASSERT_NE(static_cast<void*>(NULL), addr);
 
   memory->Unlock();
   // The system should have no reason to purge discardable blocks in this brief
   // interval, though technically speaking this might flake.
   EXPECT_EQ(DISCARDABLE_MEMORY_SUCCESS, memory->Lock());
   addr = memory->Memory();
   ASSERT_NE(static_cast<void*>(NULL), addr);
 
   memory->Unlock();
 }
 
 // Test delete a discardable memory while it is locked.
-TEST(DiscardableMemoryTest, DeleteWhileLocked) {
+TEST_P(DiscardableMemoryTest, DeleteWhileLocked) {
   const scoped_ptr<DiscardableMemory> memory(
       DiscardableMemory::CreateLockedMemory(kSize));
   ASSERT_TRUE(memory);
 }
 
 #if !defined(OS_ANDROID)
 // Test forced purging.
-TEST(DiscardableMemoryTest, Purge) {
+TEST_P(DiscardableMemoryTest, Purge) {
   ASSERT_TRUE(DiscardableMemory::PurgeForTestingSupported());
 
   const scoped_ptr<DiscardableMemory> memory(
       DiscardableMemory::CreateLockedMemory(kSize));
   ASSERT_TRUE(memory);
   memory->Unlock();
 
   DiscardableMemory::PurgeForTesting();
   EXPECT_EQ(DISCARDABLE_MEMORY_PURGED, memory->Lock());
 }
 #endif  // !OS_ANDROID
 
 #if !defined(NDEBUG) && !defined(OS_ANDROID)
 // Death tests are not supported with Android APKs.
-TEST(DiscardableMemoryTest, UnlockedMemoryAccessCrashesInDebugMode) {
+TEST_P(DiscardableMemoryTest, UnlockedMemoryAccessCrashesInDebugMode) {
   const scoped_ptr<DiscardableMemory> memory(
       DiscardableMemory::CreateLockedMemory(kSize));
   ASSERT_TRUE(memory);
   memory->Unlock();
   ASSERT_DEATH_IF_SUPPORTED(
       { *static_cast<int*>(memory->Memory()) = 0xdeadbeef; }, ".*");
 }
 #endif
 
-}
+INSTANTIATE_TEST_CASE_P(
+    DiscardableMemoryTests,
+    DiscardableMemoryTest,
+    ::testing::ValuesIn(DiscardableMemory::GetSupportedTypes()));

[reveman, 2013/12/16 21:05:51]

Runs all tests for all supported discardable memory types.

This file should only contain tests that apply to the general DiscardableMemory
API and not any implementation specific tests such as the current
TooLargeAllocationFails test.

All implementation specific tests should be moved into implementation specific
_unittest.cc files. I'm planning to do this in a follow up rather than include
it in this patch though.

[Philippe, 2013/12/17 14:28:21]

SGTM

+
+}  // namespace
+}  // namespace base