blob: 5789fb9f14208b5814394020115ca8cb2995ae97 [file] [log] [blame]
/*
* Copyright 2014 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "nb/fixed_no_free_allocator.h"
#include "nb/pointer_arithmetic.h"
#include "nb/starboard_aligned_memory_deleter.h"
#include "testing/gtest/include/gtest/gtest.h"
class FixedNoFreeAllocatorTest : public ::testing::Test {
public:
FixedNoFreeAllocatorTest();
protected:
static const std::size_t kAllocationSize = 8;
static const std::size_t kAllocationAlignment = 8;
static const std::size_t kMaxAllocations = 64;
static const std::size_t kBufferSize = kAllocationSize * kMaxAllocations;
std::unique_ptr<uint8_t, nb::AlignedMemoryDeleter> buffer_;
nb::FixedNoFreeAllocator allocator_;
};
FixedNoFreeAllocatorTest::FixedNoFreeAllocatorTest()
: buffer_(static_cast<uint8_t*>(
SbMemoryAllocateAligned(nb::Allocator::kMinAlignment, kBufferSize))),
allocator_(buffer_.get(), kBufferSize) {}
TEST_F(FixedNoFreeAllocatorTest, CanDoSimpleAllocations) {
void* allocation = allocator_.Allocate(kAllocationSize);
EXPECT_GE(allocation, buffer_.get());
EXPECT_LE(reinterpret_cast<uintptr_t>(allocation),
reinterpret_cast<uintptr_t>(buffer_.get()) + kBufferSize -
kAllocationSize);
}
TEST_F(FixedNoFreeAllocatorTest, CanDoMultipleAllocationsProperly) {
void* buffers[kMaxAllocations];
for (int i = 0; i < kMaxAllocations; ++i) {
buffers[i] = allocator_.Allocate(kAllocationSize);
EXPECT_GE(buffers[i], buffer_.get());
EXPECT_LE(reinterpret_cast<uintptr_t>(buffers[i]),
reinterpret_cast<uintptr_t>(buffer_.get()) + kBufferSize -
kAllocationSize);
// Make sure this allocation doesn't overlap with any previous ones.
for (int j = 0; j < i; ++j) {
EXPECT_NE(buffers[j], buffers[i]);
if (buffers[j] < buffers[i]) {
EXPECT_LE(nb::AsInteger(buffers[j]) + kAllocationSize,
nb::AsInteger(buffers[i]));
} else {
EXPECT_LE(nb::AsInteger(buffers[i]) + kAllocationSize,
nb::AsInteger(buffers[j]));
}
}
}
}
TEST_F(FixedNoFreeAllocatorTest, CanDoMultipleAllocationsAndFreesProperly) {
for (int i = 0; i < kMaxAllocations; ++i) {
void* current_allocation = allocator_.Allocate(kAllocationSize);
EXPECT_GE(current_allocation, buffer_.get());
EXPECT_LE(reinterpret_cast<uintptr_t>(current_allocation),
reinterpret_cast<uintptr_t>(buffer_.get()) + kBufferSize -
kAllocationSize);
allocator_.Free(current_allocation);
}
}
TEST_F(FixedNoFreeAllocatorTest, CanHandleOutOfMemory) {
for (int i = 0; i < kMaxAllocations; ++i) {
void* current_allocation = allocator_.Allocate(kAllocationSize);
EXPECT_GE(current_allocation, buffer_.get());
EXPECT_LE(reinterpret_cast<uintptr_t>(current_allocation),
reinterpret_cast<uintptr_t>(buffer_.get()) + kBufferSize -
kAllocationSize);
allocator_.Free(current_allocation);
}
// We should have exhausted our memory supply now, check that our next
// allocation returns null.
void* final_allocation = allocator_.Allocate(kAllocationSize);
EXPECT_EQ(final_allocation, reinterpret_cast<void*>(NULL));
}
TEST_F(FixedNoFreeAllocatorTest, CanHandleAlignedMemory) {
const int kMinimumAlignedMemoryAllocations =
kBufferSize / (kAllocationSize + kAllocationAlignment);
for (int i = 0; i < kMinimumAlignedMemoryAllocations; ++i) {
void* current_allocation =
allocator_.Allocate(kAllocationSize, kAllocationAlignment);
EXPECT_EQ(0, reinterpret_cast<uintptr_t>(current_allocation) %
kAllocationAlignment);
EXPECT_GE(current_allocation, buffer_.get());
EXPECT_LE(reinterpret_cast<uintptr_t>(current_allocation),
reinterpret_cast<uintptr_t>(buffer_.get()) + kBufferSize -
kAllocationSize);
allocator_.Free(current_allocation);
}
}