1 // Copyright (c) 2011, Google Inc.
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
6 // met:
7 //
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above
11 // copyright notice, this list of conditions and the following disclaimer
12 // in the documentation and/or other materials provided with the
13 // distribution.
14 // * Neither the name of Google Inc. nor the names of its
15 // contributors may be used to endorse or promote products derived from
16 // this software without specific prior written permission.
17 //
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30 // minidump_memory_range_unittest.cc:
31 // Unit tests for google_breakpad::MinidumpMemoryRange.
32
33 #include "breakpad_googletest_includes.h"
34 #include "tools/linux/md2core/minidump_memory_range.h"
35
36 using google_breakpad::MinidumpMemoryRange;
37 using testing::Message;
38
39 namespace {
40
41 const uint32_t kBuffer[10] = { 0 };
42 const size_t kBufferSize = sizeof(kBuffer);
43 const uint8_t* kBufferPointer = reinterpret_cast<const uint8_t*>(kBuffer);
44
45 // Test vectors for verifying Covers, GetData, and Subrange.
46 const struct {
47 bool valid;
48 size_t offset;
49 size_t length;
50 } kSubranges[] = {
51 { true, 0, 0 },
52 { true, 0, 2 },
53 { true, 0, kBufferSize },
54 { true, 2, 0 },
55 { true, 2, 4 },
56 { true, 2, kBufferSize - 2 },
57 { true, kBufferSize - 1, 1 },
58 { false, kBufferSize, 0 },
59 { false, kBufferSize, static_cast<size_t>(-1) },
60 { false, kBufferSize + 1, 0 },
61 { false, static_cast<size_t>(-1), 2 },
62 { false, 1, kBufferSize },
63 { false, kBufferSize - 1, 2 },
64 { false, 0, static_cast<size_t>(-1) },
65 { false, 1, static_cast<size_t>(-1) },
66 };
67 const size_t kNumSubranges = sizeof(kSubranges) / sizeof(kSubranges[0]);
68
69 // Test vectors for verifying GetArrayElement.
70 const struct {
71 size_t offset;
72 size_t size;
73 size_t index;
74 const void* const pointer;
75 } kElements[] = {
76 // Valid array elemenets
77 { 0, 1, 0, kBufferPointer },
78 { 0, 1, 1, kBufferPointer + 1 },
79 { 0, 1, kBufferSize - 1, kBufferPointer + kBufferSize - 1 },
80 { 0, 2, 1, kBufferPointer + 2 },
81 { 0, 4, 2, kBufferPointer + 8 },
82 { 0, 4, 9, kBufferPointer + 36 },
83 { kBufferSize - 1, 1, 0, kBufferPointer + kBufferSize - 1 },
84 // Invalid array elemenets
85 { 0, 1, kBufferSize, NULL },
86 { 0, 4, 10, NULL },
87 { kBufferSize - 1, 1, 1, NULL },
88 { kBufferSize - 1, 2, 0, NULL },
89 { kBufferSize, 1, 0, NULL },
90 };
91 const size_t kNumElements = sizeof(kElements) / sizeof(kElements[0]);
92
93 } // namespace
94
TEST(MinidumpMemoryRangeTest,DefaultConstructor)95 TEST(MinidumpMemoryRangeTest, DefaultConstructor) {
96 MinidumpMemoryRange range;
97 EXPECT_EQ(NULL, range.data());
98 EXPECT_EQ(0U, range.length());
99 }
100
TEST(MinidumpMemoryRangeTest,ConstructorWithDataAndLength)101 TEST(MinidumpMemoryRangeTest, ConstructorWithDataAndLength) {
102 MinidumpMemoryRange range(kBuffer, kBufferSize);
103 EXPECT_EQ(kBufferPointer, range.data());
104 EXPECT_EQ(kBufferSize, range.length());
105 }
106
TEST(MinidumpMemoryRangeTest,Reset)107 TEST(MinidumpMemoryRangeTest, Reset) {
108 MinidumpMemoryRange range;
109 range.Reset();
110 EXPECT_EQ(NULL, range.data());
111 EXPECT_EQ(0U, range.length());
112
113 range.Set(kBuffer, kBufferSize);
114 EXPECT_EQ(kBufferPointer, range.data());
115 EXPECT_EQ(kBufferSize, range.length());
116
117 range.Reset();
118 EXPECT_EQ(NULL, range.data());
119 EXPECT_EQ(0U, range.length());
120 }
121
TEST(MinidumpMemoryRangeTest,Set)122 TEST(MinidumpMemoryRangeTest, Set) {
123 MinidumpMemoryRange range;
124 range.Set(kBuffer, kBufferSize);
125 EXPECT_EQ(kBufferPointer, range.data());
126 EXPECT_EQ(kBufferSize, range.length());
127
128 range.Set(NULL, 0);
129 EXPECT_EQ(NULL, range.data());
130 EXPECT_EQ(0U, range.length());
131 }
132
TEST(MinidumpMemoryRangeTest,SubrangeOfEmptyMemoryRange)133 TEST(MinidumpMemoryRangeTest, SubrangeOfEmptyMemoryRange) {
134 MinidumpMemoryRange range;
135 MinidumpMemoryRange subrange = range.Subrange(0, 10);
136 EXPECT_EQ(NULL, subrange.data());
137 EXPECT_EQ(0U, subrange.length());
138 }
139
TEST(MinidumpMemoryRangeTest,SubrangeAndGetData)140 TEST(MinidumpMemoryRangeTest, SubrangeAndGetData) {
141 MinidumpMemoryRange range(kBuffer, kBufferSize);
142 for (size_t i = 0; i < kNumSubranges; ++i) {
143 bool valid = kSubranges[i].valid;
144 size_t sub_offset = kSubranges[i].offset;
145 size_t sub_length = kSubranges[i].length;
146 SCOPED_TRACE(Message() << "offset=" << sub_offset
147 << ", length=" << sub_length);
148
149 MinidumpMemoryRange subrange = range.Subrange(sub_offset, sub_length);
150 if (valid) {
151 EXPECT_TRUE(range.Covers(sub_offset, sub_length));
152 EXPECT_EQ(kBufferPointer + sub_offset,
153 range.GetData(sub_offset, sub_length));
154 EXPECT_EQ(kBufferPointer + sub_offset, subrange.data());
155 EXPECT_EQ(sub_length, subrange.length());
156 } else {
157 EXPECT_FALSE(range.Covers(sub_offset, sub_length));
158 EXPECT_EQ(NULL, range.GetData(sub_offset, sub_length));
159 EXPECT_EQ(NULL, subrange.data());
160 EXPECT_EQ(0U, subrange.length());
161 }
162 }
163 }
164
TEST(MinidumpMemoryRangeTest,SubrangeWithMDLocationDescriptor)165 TEST(MinidumpMemoryRangeTest, SubrangeWithMDLocationDescriptor) {
166 MinidumpMemoryRange range(kBuffer, kBufferSize);
167 for (size_t i = 0; i < kNumSubranges; ++i) {
168 bool valid = kSubranges[i].valid;
169 size_t sub_offset = kSubranges[i].offset;
170 size_t sub_length = kSubranges[i].length;
171 SCOPED_TRACE(Message() << "offset=" << sub_offset
172 << ", length=" << sub_length);
173
174 MDLocationDescriptor location;
175 location.rva = sub_offset;
176 location.data_size = sub_length;
177 MinidumpMemoryRange subrange = range.Subrange(location);
178 if (valid) {
179 EXPECT_TRUE(range.Covers(sub_offset, sub_length));
180 EXPECT_EQ(kBufferPointer + sub_offset,
181 range.GetData(sub_offset, sub_length));
182 EXPECT_EQ(kBufferPointer + sub_offset, subrange.data());
183 EXPECT_EQ(sub_length, subrange.length());
184 } else {
185 EXPECT_FALSE(range.Covers(sub_offset, sub_length));
186 EXPECT_EQ(NULL, range.GetData(sub_offset, sub_length));
187 EXPECT_EQ(NULL, subrange.data());
188 EXPECT_EQ(0U, subrange.length());
189 }
190 }
191 }
192
TEST(MinidumpMemoryRangeTest,GetDataWithTemplateType)193 TEST(MinidumpMemoryRangeTest, GetDataWithTemplateType) {
194 MinidumpMemoryRange range(kBuffer, kBufferSize);
195 const char* char_pointer = range.GetData<char>(0);
196 EXPECT_EQ(reinterpret_cast<const char*>(kBufferPointer), char_pointer);
197 const int* int_pointer = range.GetData<int>(0);
198 EXPECT_EQ(reinterpret_cast<const int*>(kBufferPointer), int_pointer);
199 }
200
TEST(MinidumpMemoryRangeTest,GetArrayElement)201 TEST(MinidumpMemoryRangeTest, GetArrayElement) {
202 MinidumpMemoryRange range(kBuffer, kBufferSize);
203 for (size_t i = 0; i < kNumElements; ++i) {
204 size_t element_offset = kElements[i].offset;
205 size_t element_size = kElements[i].size;
206 unsigned element_index = kElements[i].index;
207 const void* const element_pointer = kElements[i].pointer;
208 SCOPED_TRACE(Message() << "offset=" << element_offset
209 << ", size=" << element_size
210 << ", index=" << element_index);
211 EXPECT_EQ(element_pointer, range.GetArrayElement(
212 element_offset, element_size, element_index));
213 }
214 }
215
TEST(MinidumpMemoryRangeTest,GetArrayElmentWithTemplateType)216 TEST(MinidumpMemoryRangeTest, GetArrayElmentWithTemplateType) {
217 MinidumpMemoryRange range(kBuffer, kBufferSize);
218 const char* char_pointer = range.GetArrayElement<char>(0, 0);
219 EXPECT_EQ(reinterpret_cast<const char*>(kBufferPointer), char_pointer);
220 const int* int_pointer = range.GetArrayElement<int>(0, 0);
221 EXPECT_EQ(reinterpret_cast<const int*>(kBufferPointer), int_pointer);
222 }
223
TEST(MinidumpMemoryRangeTest,GetAsciiMDString)224 TEST(MinidumpMemoryRangeTest, GetAsciiMDString) {
225 uint8_t buffer[100] = { 0 };
226
227 MDString* md_str = reinterpret_cast<MDString*>(buffer);
228 md_str->length = 4;
229 md_str->buffer[0] = 'T';
230 md_str->buffer[1] = 'e';
231 md_str->buffer[2] = 's';
232 md_str->buffer[3] = 't';
233 md_str->buffer[4] = '\0';
234
235 size_t str2_offset =
236 sizeof(MDString) + (md_str->length + 1) * sizeof(uint16_t);
237
238 md_str = reinterpret_cast<MDString*>(buffer + str2_offset);
239 md_str->length = 9; // Test length larger than actual string
240 md_str->buffer[0] = 'S';
241 md_str->buffer[1] = 't';
242 md_str->buffer[2] = 'r';
243 md_str->buffer[3] = 'i';
244 md_str->buffer[4] = 'n';
245 md_str->buffer[5] = 'g';
246 md_str->buffer[6] = '\0';
247 md_str->buffer[7] = '1';
248 md_str->buffer[8] = '2';
249
250 MinidumpMemoryRange range(buffer, sizeof(buffer));
251 EXPECT_EQ("Test", range.GetAsciiMDString(0));
252 EXPECT_EQ("String", range.GetAsciiMDString(str2_offset));
253
254 // Test out-of-bounds cases.
255 EXPECT_EQ("", range.GetAsciiMDString(
256 sizeof(buffer) - sizeof(MDString) + 1));
257 EXPECT_EQ("", range.GetAsciiMDString(sizeof(buffer)));
258 }
259