1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include <Allocator.h> 18 19 #include <ScopedDisableMalloc.h> 20 #include <gtest/gtest.h> 21 22 namespace android { 23 24 std::function<void()> ScopedAlarm::func_; 25 26 class AllocatorTest : public testing::Test { 27 protected: 28 AllocatorTest() : heap(), disable_malloc_() {} 29 virtual void SetUp() { heap_count = 0; } 30 virtual void TearDown() { 31 ASSERT_EQ(heap_count, 0); 32 ASSERT_TRUE(heap.empty()); 33 ASSERT_FALSE(disable_malloc_.timed_out()); 34 } 35 Heap heap; 36 37 private: 38 ScopedDisableMallocTimeout disable_malloc_; 39 }; 40 41 TEST_F(AllocatorTest, simple) { 42 Allocator<char[100]> allocator(heap); 43 void* ptr = allocator.allocate(); 44 ASSERT_TRUE(ptr != NULL); 45 allocator.deallocate(ptr); 46 } 47 48 TEST_F(AllocatorTest, multiple) { 49 Allocator<char[100]> allocator(heap); 50 void* ptr1 = allocator.allocate(); 51 ASSERT_TRUE(ptr1 != NULL); 52 void* ptr2 = allocator.allocate(); 53 ASSERT_TRUE(ptr2 != NULL); 54 ASSERT_NE(ptr1, ptr2); 55 allocator.deallocate(ptr1); 56 void* ptr3 = allocator.allocate(); 57 ASSERT_EQ(ptr1, ptr3); 58 allocator.deallocate(ptr3); 59 allocator.deallocate(ptr2); 60 } 61 62 TEST_F(AllocatorTest, many) { 63 const int num = 4096; 64 const int size = 128; 65 Allocator<char[size]> allocator(heap); 66 void* ptr[num]; 67 for (int i = 0; i < num; i++) { 68 ptr[i] = allocator.allocate(); 69 memset(ptr[i], 0xaa, size); 70 *(reinterpret_cast<unsigned char*>(ptr[i])) = i; 71 } 72 73 for (int i = 0; i < num; i++) { 74 for (int j = 0; j < num; j++) { 75 if (i != j) { 76 ASSERT_NE(ptr[i], ptr[j]); 77 } 78 } 79 } 80 81 for (int i = 0; i < num; i++) { 82 ASSERT_EQ(*(reinterpret_cast<unsigned char*>(ptr[i])), i & 0xFF); 83 allocator.deallocate(ptr[i]); 84 } 85 } 86 87 TEST_F(AllocatorTest, large) { 88 const size_t size = 1024 * 1024; 89 Allocator<char[size]> allocator(heap); 90 void* ptr = allocator.allocate(); 91 memset(ptr, 0xaa, size); 92 allocator.deallocate(ptr); 93 } 94 95 TEST_F(AllocatorTest, many_large) { 96 const int num = 128; 97 const int size = 1024 * 1024; 98 Allocator<char[size]> allocator(heap); 99 void* ptr[num]; 100 for (int i = 0; i < num; i++) { 101 ptr[i] = allocator.allocate(); 102 memset(ptr[i], 0xaa, size); 103 *(reinterpret_cast<unsigned char*>(ptr[i])) = i; 104 } 105 106 for (int i = 0; i < num; i++) { 107 ASSERT_EQ(*(reinterpret_cast<unsigned char*>(ptr[i])), i & 0xFF); 108 allocator.deallocate(ptr[i]); 109 } 110 } 111 112 TEST_F(AllocatorTest, copy) { 113 Allocator<char[100]> a(heap); 114 Allocator<char[200]> b = a; 115 Allocator<char[300]> c(b); 116 Allocator<char[100]> d(a); 117 Allocator<char[100]> e(heap); 118 119 ASSERT_EQ(a, b); 120 ASSERT_EQ(a, c); 121 ASSERT_EQ(a, d); 122 ASSERT_EQ(a, e); 123 124 void* ptr1 = a.allocate(); 125 void* ptr2 = b.allocate(); 126 void* ptr3 = c.allocate(); 127 void* ptr4 = d.allocate(); 128 129 b.deallocate(ptr1); 130 d.deallocate(ptr2); 131 a.deallocate(ptr3); 132 c.deallocate(ptr4); 133 } 134 135 TEST_F(AllocatorTest, stl_vector) { 136 auto v = allocator::vector<int>(Allocator<int>(heap)); 137 for (int i = 0; i < 1024; i++) { 138 v.push_back(i); 139 } 140 for (int i = 0; i < 1024; i++) { 141 ASSERT_EQ(v[i], i); 142 } 143 v.clear(); 144 } 145 146 TEST_F(AllocatorTest, stl_list) { 147 auto v = allocator::list<int>(Allocator<int>(heap)); 148 for (int i = 0; i < 1024; i++) { 149 v.push_back(i); 150 } 151 int i = 0; 152 for (auto iter = v.begin(); iter != v.end(); iter++, i++) { 153 ASSERT_EQ(*iter, i); 154 } 155 v.clear(); 156 } 157 158 TEST_F(AllocatorTest, shared) { 159 Allocator<int> allocator(heap); 160 161 Allocator<int>::shared_ptr ptr = allocator.make_shared(0); 162 { 163 auto ptr2 = ptr; // NOLINT, test copy of ptr 164 } 165 ASSERT_NE(ptr, nullptr); 166 } 167 168 TEST_F(AllocatorTest, unique) { 169 Allocator<int> allocator(heap); 170 171 Allocator<int>::unique_ptr ptr = allocator.make_unique(0); 172 173 ASSERT_NE(ptr, nullptr); 174 } 175 176 } // namespace android 177
