base/memory/discardable_memory_unittest.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/memory/discardable_memory.h"
   6
   7 #include <limits>
   8
   9 #include "testing/gtest/include/gtest/gtest.h"
  10
  11 namespace base {
  12
  13 const size_t kSize = 1024;
  14
  15 #if defined(OS_ANDROID)
  16 TEST(DiscardableMemoryTest, TooLargeAllocationFails) {
  17   const size_t kPageSize = 4096;
  18   const size_t max_allowed_allocation_size =
  19       std::numeric_limits<size_t>::max() - kPageSize + 1;
  20   scoped_ptr<DiscardableMemory> memory(
  21       DiscardableMemory::CreateLockedMemory(max_allowed_allocation_size + 1));
  22   // On certain platforms (e.g. Android), page-alignment would have caused an
  23   // overflow resulting in a small allocation if the input size wasn't checked
  24   // correctly.
  25   ASSERT_FALSE(memory);
  26 }
  27 #endif
  28
  29 TEST(DiscardableMemoryTest, SupportedNatively) {
  30 #if defined(DISCARDABLE_MEMORY_ALWAYS_SUPPORTED_NATIVELY)
  31   ASSERT_TRUE(DiscardableMemory::SupportedNatively());
  32 #else
  33   // If we ever have a platform that decides at runtime if it can support
  34   // discardable memory natively, then we'll have to add a 'never supported
  35   // natively' define for this case. At present, if it's not always supported
  36   // natively, it's never supported.
  37   ASSERT_FALSE(DiscardableMemory::SupportedNatively());
  38 #endif
  39 }
  40
  41 // Test Lock() and Unlock() functionalities.
  42 TEST(DiscardableMemoryTest, LockAndUnLock) {
  43   const scoped_ptr<DiscardableMemory> memory(
  44       DiscardableMemory::CreateLockedMemory(kSize));
  45   ASSERT_TRUE(memory);
  46   void* addr = memory->Memory();
  47   ASSERT_NE(static_cast<void*>(NULL), addr);
  48
  49   memory->Unlock();
  50   // The system should have no reason to purge discardable blocks in this brief
  51   // interval, though technically speaking this might flake.
  52   EXPECT_EQ(DISCARDABLE_MEMORY_SUCCESS, memory->Lock());
  53   addr = memory->Memory();
  54   ASSERT_NE(static_cast<void*>(NULL), addr);
  55
  56   memory->Unlock();
  57 }
  58
  59 // Test delete a discardable memory while it is locked.
  60 TEST(DiscardableMemoryTest, DeleteWhileLocked) {
  61   const scoped_ptr<DiscardableMemory> memory(
  62       DiscardableMemory::CreateLockedMemory(kSize));
  63   ASSERT_TRUE(memory);
  64 }
  65
  66 #if !defined(OS_ANDROID)
  67 // Test forced purging.
  68 TEST(DiscardableMemoryTest, Purge) {
  69   ASSERT_TRUE(DiscardableMemory::PurgeForTestingSupported());
  70
  71   const scoped_ptr<DiscardableMemory> memory(
  72       DiscardableMemory::CreateLockedMemory(kSize));
  73   ASSERT_TRUE(memory);
  74   memory->Unlock();
  75
  76   DiscardableMemory::PurgeForTesting();
  77   EXPECT_EQ(DISCARDABLE_MEMORY_PURGED, memory->Lock());
  78 }
  79 #endif  // !OS_ANDROID
  80
  81 #if !defined(NDEBUG) && !defined(OS_ANDROID)
  82 // Death tests are not supported with Android APKs.
  83 TEST(DiscardableMemoryTest, UnlockedMemoryAccessCrashesInDebugMode) {
  84   const scoped_ptr<DiscardableMemory> memory(
  85       DiscardableMemory::CreateLockedMemory(kSize));
  86   ASSERT_TRUE(memory);
  87   memory->Unlock();
  88   ASSERT_DEATH_IF_SUPPORTED(
  89       { *static_cast<int*>(memory->Memory()) = 0xdeadbeef; }, ".*");
  90 }
  91 #endif
  92
  93 }