1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/toolkit/crashreporter/google-breakpad/src/common/memory_range_unittest.cc Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,193 @@
1.4 +// Copyright (c) 2011, Google Inc.
1.5 +// All rights reserved.
1.6 +//
1.7 +// Redistribution and use in source and binary forms, with or without
1.8 +// modification, are permitted provided that the following conditions are
1.9 +// met:
1.10 +//
1.11 +// * Redistributions of source code must retain the above copyright
1.12 +// notice, this list of conditions and the following disclaimer.
1.13 +// * Redistributions in binary form must reproduce the above
1.14 +// copyright notice, this list of conditions and the following disclaimer
1.15 +// in the documentation and/or other materials provided with the
1.16 +// distribution.
1.17 +// * Neither the name of Google Inc. nor the names of its
1.18 +// contributors may be used to endorse or promote products derived from
1.19 +// this software without specific prior written permission.
1.20 +//
1.21 +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
1.22 +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
1.23 +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
1.24 +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
1.25 +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
1.26 +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
1.27 +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
1.28 +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
1.29 +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
1.30 +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
1.31 +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1.32 +
1.33 +// memory_range_unittest.cc: Unit tests for google_breakpad::MemoryRange.
1.34 +
1.35 +#include "breakpad_googletest_includes.h"
1.36 +#include "common/memory_range.h"
1.37 +
1.38 +using google_breakpad::MemoryRange;
1.39 +using testing::Message;
1.40 +
1.41 +namespace {
1.42 +
1.43 +const uint32_t kBuffer[10] = { 0 };
1.44 +const size_t kBufferSize = sizeof(kBuffer);
1.45 +const uint8_t* kBufferPointer = reinterpret_cast<const uint8_t*>(kBuffer);
1.46 +
1.47 +// Test vectors for verifying Covers, GetData, and Subrange.
1.48 +const struct {
1.49 + bool valid;
1.50 + size_t offset;
1.51 + size_t length;
1.52 +} kSubranges[] = {
1.53 + { true, 0, 0 },
1.54 + { true, 0, 2 },
1.55 + { true, 0, kBufferSize },
1.56 + { true, 2, 0 },
1.57 + { true, 2, 4 },
1.58 + { true, 2, kBufferSize - 2 },
1.59 + { true, kBufferSize - 1, 1 },
1.60 + { false, kBufferSize, 0 },
1.61 + { false, kBufferSize, static_cast<size_t>(-1) },
1.62 + { false, kBufferSize + 1, 0 },
1.63 + { false, static_cast<size_t>(-1), 2 },
1.64 + { false, 1, kBufferSize },
1.65 + { false, kBufferSize - 1, 2 },
1.66 + { false, 0, static_cast<size_t>(-1) },
1.67 + { false, 1, static_cast<size_t>(-1) },
1.68 +};
1.69 +const size_t kNumSubranges = sizeof(kSubranges) / sizeof(kSubranges[0]);
1.70 +
1.71 +// Test vectors for verifying GetArrayElement.
1.72 +const struct {
1.73 + size_t offset;
1.74 + size_t size;
1.75 + size_t index;
1.76 + const void* const pointer;
1.77 +} kElements[] = {
1.78 + // Valid array elemenets
1.79 + { 0, 1, 0, kBufferPointer },
1.80 + { 0, 1, 1, kBufferPointer + 1 },
1.81 + { 0, 1, kBufferSize - 1, kBufferPointer + kBufferSize - 1 },
1.82 + { 0, 2, 1, kBufferPointer + 2 },
1.83 + { 0, 4, 2, kBufferPointer + 8 },
1.84 + { 0, 4, 9, kBufferPointer + 36 },
1.85 + { kBufferSize - 1, 1, 0, kBufferPointer + kBufferSize - 1 },
1.86 + // Invalid array elemenets
1.87 + { 0, 1, kBufferSize, NULL },
1.88 + { 0, 4, 10, NULL },
1.89 + { kBufferSize - 1, 1, 1, NULL },
1.90 + { kBufferSize - 1, 2, 0, NULL },
1.91 + { kBufferSize, 1, 0, NULL },
1.92 +};
1.93 +const size_t kNumElements = sizeof(kElements) / sizeof(kElements[0]);
1.94 +
1.95 +} // namespace
1.96 +
1.97 +TEST(MemoryRangeTest, DefaultConstructor) {
1.98 + MemoryRange range;
1.99 + EXPECT_EQ(NULL, range.data());
1.100 + EXPECT_EQ(0U, range.length());
1.101 +}
1.102 +
1.103 +TEST(MemoryRangeTest, ConstructorWithDataAndLength) {
1.104 + MemoryRange range(kBuffer, kBufferSize);
1.105 + EXPECT_EQ(kBufferPointer, range.data());
1.106 + EXPECT_EQ(kBufferSize, range.length());
1.107 +}
1.108 +
1.109 +TEST(MemoryRangeTest, Reset) {
1.110 + MemoryRange range;
1.111 + range.Reset();
1.112 + EXPECT_EQ(NULL, range.data());
1.113 + EXPECT_EQ(0U, range.length());
1.114 +
1.115 + range.Set(kBuffer, kBufferSize);
1.116 + EXPECT_EQ(kBufferPointer, range.data());
1.117 + EXPECT_EQ(kBufferSize, range.length());
1.118 +
1.119 + range.Reset();
1.120 + EXPECT_EQ(NULL, range.data());
1.121 + EXPECT_EQ(0U, range.length());
1.122 +}
1.123 +
1.124 +TEST(MemoryRangeTest, Set) {
1.125 + MemoryRange range;
1.126 + range.Set(kBuffer, kBufferSize);
1.127 + EXPECT_EQ(kBufferPointer, range.data());
1.128 + EXPECT_EQ(kBufferSize, range.length());
1.129 +
1.130 + range.Set(NULL, 0);
1.131 + EXPECT_EQ(NULL, range.data());
1.132 + EXPECT_EQ(0U, range.length());
1.133 +}
1.134 +
1.135 +TEST(MemoryRangeTest, SubrangeOfEmptyMemoryRange) {
1.136 + MemoryRange range;
1.137 + MemoryRange subrange = range.Subrange(0, 10);
1.138 + EXPECT_EQ(NULL, subrange.data());
1.139 + EXPECT_EQ(0U, subrange.length());
1.140 +}
1.141 +
1.142 +TEST(MemoryRangeTest, SubrangeAndGetData) {
1.143 + MemoryRange range(kBuffer, kBufferSize);
1.144 + for (size_t i = 0; i < kNumSubranges; ++i) {
1.145 + bool valid = kSubranges[i].valid;
1.146 + size_t sub_offset = kSubranges[i].offset;
1.147 + size_t sub_length = kSubranges[i].length;
1.148 + SCOPED_TRACE(Message() << "offset=" << sub_offset
1.149 + << ", length=" << sub_length);
1.150 +
1.151 + MemoryRange subrange = range.Subrange(sub_offset, sub_length);
1.152 + if (valid) {
1.153 + EXPECT_TRUE(range.Covers(sub_offset, sub_length));
1.154 + EXPECT_EQ(kBufferPointer + sub_offset,
1.155 + range.GetData(sub_offset, sub_length));
1.156 + EXPECT_EQ(kBufferPointer + sub_offset, subrange.data());
1.157 + EXPECT_EQ(sub_length, subrange.length());
1.158 + } else {
1.159 + EXPECT_FALSE(range.Covers(sub_offset, sub_length));
1.160 + EXPECT_EQ(NULL, range.GetData(sub_offset, sub_length));
1.161 + EXPECT_EQ(NULL, subrange.data());
1.162 + EXPECT_EQ(0U, subrange.length());
1.163 + }
1.164 + }
1.165 +}
1.166 +
1.167 +TEST(MemoryRangeTest, GetDataWithTemplateType) {
1.168 + MemoryRange range(kBuffer, kBufferSize);
1.169 + const char* char_pointer = range.GetData<char>(0);
1.170 + EXPECT_EQ(reinterpret_cast<const char*>(kBufferPointer), char_pointer);
1.171 + const int* int_pointer = range.GetData<int>(0);
1.172 + EXPECT_EQ(reinterpret_cast<const int*>(kBufferPointer), int_pointer);
1.173 +}
1.174 +
1.175 +TEST(MemoryRangeTest, GetArrayElement) {
1.176 + MemoryRange range(kBuffer, kBufferSize);
1.177 + for (size_t i = 0; i < kNumElements; ++i) {
1.178 + size_t element_offset = kElements[i].offset;
1.179 + size_t element_size = kElements[i].size;
1.180 + unsigned element_index = kElements[i].index;
1.181 + const void* const element_pointer = kElements[i].pointer;
1.182 + SCOPED_TRACE(Message() << "offset=" << element_offset
1.183 + << ", size=" << element_size
1.184 + << ", index=" << element_index);
1.185 + EXPECT_EQ(element_pointer, range.GetArrayElement(
1.186 + element_offset, element_size, element_index));
1.187 + }
1.188 +}
1.189 +
1.190 +TEST(MemoryRangeTest, GetArrayElmentWithTemplateType) {
1.191 + MemoryRange range(kBuffer, kBufferSize);
1.192 + const char* char_pointer = range.GetArrayElement<char>(0, 0);
1.193 + EXPECT_EQ(reinterpret_cast<const char*>(kBufferPointer), char_pointer);
1.194 + const int* int_pointer = range.GetArrayElement<int>(0, 0);
1.195 + EXPECT_EQ(reinterpret_cast<const int*>(kBufferPointer), int_pointer);
1.196 +}
