OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2014 The Crashpad Authors. All rights reserved. | |
2 // | |
3 // Licensed under the Apache License, Version 2.0 (the "License"); | |
4 // you may not use this file except in compliance with the License. | |
5 // You may obtain a copy of the License at | |
6 // | |
7 // http://www.apache.org/licenses/LICENSE-2.0 | |
8 // | |
9 // Unless required by applicable law or agreed to in writing, software | |
10 // distributed under the License is distributed on an "AS IS" BASIS, | |
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
12 // See the License for the specific language governing permissions and | |
13 // limitations under the License. | |
14 | |
15 #include "minidump/minidump_simple_string_dictionary_writer.h" | |
16 | |
17 #include <string> | |
18 | |
19 #include "gtest/gtest.h" | |
20 #include "minidump/minidump_extensions.h" | |
21 #include "util/file/string_file_writer.h" | |
22 | |
23 namespace crashpad { | |
24 namespace test { | |
25 namespace { | |
26 | |
27 const MinidumpSimpleStringDictionary* MinidumpSimpleStringDictionaryCast( | |
28 const StringFileWriter& file_writer) { | |
29 return reinterpret_cast<const MinidumpSimpleStringDictionary*>( | |
30 &file_writer.string()[0]); | |
31 } | |
32 | |
33 TEST(MinidumpSimpleStringDictionaryWriter, EmptySimpleStringDictionary) { | |
34 StringFileWriter file_writer; | |
35 | |
36 MinidumpSimpleStringDictionaryWriter dictionary_writer; | |
37 | |
38 EXPECT_TRUE(dictionary_writer.WriteEverything(&file_writer)); | |
39 ASSERT_EQ(sizeof(MinidumpSimpleStringDictionary), | |
40 file_writer.string().size()); | |
41 | |
42 const MinidumpSimpleStringDictionary* dictionary = | |
43 MinidumpSimpleStringDictionaryCast(file_writer); | |
44 EXPECT_EQ(0u, dictionary->count); | |
45 } | |
46 | |
47 std::string MinidumpUTF8StringAtRVA(const StringFileWriter& file_writer, | |
48 RVA rva) { | |
49 if (rva == 0) { | |
50 return std::string(); | |
51 } | |
52 | |
53 const MinidumpUTF8String* minidump_string = | |
54 reinterpret_cast<const MinidumpUTF8String*>(&file_writer.string()[rva]); | |
Robert Sesek
2014/10/16 18:07:59
Check if the rva is within bounds first? At the ve
| |
55 std::string minidump_string_data( | |
56 reinterpret_cast<const char*>(&minidump_string->Buffer[0]), | |
57 minidump_string->Length); | |
58 return minidump_string_data; | |
59 } | |
60 | |
61 TEST(MinidumpSimpleStringDictionaryWriter, EmptyKeyValue) { | |
62 StringFileWriter file_writer; | |
63 | |
64 MinidumpSimpleStringDictionaryWriter dictionary_writer; | |
65 MinidumpSimpleStringDictionaryEntryWriter entry_writer; | |
66 dictionary_writer.AddEntry(&entry_writer); | |
67 | |
68 EXPECT_TRUE(dictionary_writer.WriteEverything(&file_writer)); | |
69 ASSERT_EQ(sizeof(MinidumpSimpleStringDictionary) + | |
70 sizeof(MinidumpSimpleStringDictionaryEntry) + | |
71 2 * sizeof(MinidumpUTF8String) + 1 + 3 + 1, // 3 for padding | |
72 file_writer.string().size()); | |
73 | |
74 const MinidumpSimpleStringDictionary* dictionary = | |
75 MinidumpSimpleStringDictionaryCast(file_writer); | |
76 EXPECT_EQ(1u, dictionary->count); | |
77 EXPECT_EQ(12u, dictionary->entries[0].key); | |
78 EXPECT_EQ(20u, dictionary->entries[0].value); | |
79 EXPECT_EQ("", | |
80 MinidumpUTF8StringAtRVA(file_writer, dictionary->entries[0].key)); | |
81 EXPECT_EQ("", | |
82 MinidumpUTF8StringAtRVA(file_writer, dictionary->entries[0].value)); | |
83 } | |
84 | |
85 TEST(MinidumpSimpleStringDictionaryWriter, OneKeyValue) { | |
86 StringFileWriter file_writer; | |
87 | |
88 char kKey[] = "key"; | |
89 char kValue[] = "value"; | |
90 | |
91 MinidumpSimpleStringDictionaryWriter dictionary_writer; | |
92 MinidumpSimpleStringDictionaryEntryWriter entry_writer; | |
93 entry_writer.SetKeyValue(kKey, kValue); | |
94 dictionary_writer.AddEntry(&entry_writer); | |
95 | |
96 EXPECT_TRUE(dictionary_writer.WriteEverything(&file_writer)); | |
97 ASSERT_EQ(sizeof(MinidumpSimpleStringDictionary) + | |
98 sizeof(MinidumpSimpleStringDictionaryEntry) + | |
99 2 * sizeof(MinidumpUTF8String) + sizeof(kKey) + sizeof(kValue), | |
100 file_writer.string().size()); | |
101 | |
102 const MinidumpSimpleStringDictionary* dictionary = | |
103 MinidumpSimpleStringDictionaryCast(file_writer); | |
104 EXPECT_EQ(1u, dictionary->count); | |
105 EXPECT_EQ(12u, dictionary->entries[0].key); | |
106 EXPECT_EQ(20u, dictionary->entries[0].value); | |
107 EXPECT_EQ(kKey, | |
108 MinidumpUTF8StringAtRVA(file_writer, dictionary->entries[0].key)); | |
109 EXPECT_EQ(kValue, | |
110 MinidumpUTF8StringAtRVA(file_writer, dictionary->entries[0].value)); | |
111 } | |
112 | |
113 TEST(MinidumpSimpleStringDictionaryWriter, ThreeKeysValues) { | |
114 StringFileWriter file_writer; | |
115 | |
116 char kKey0[] = "mmm0"; | |
117 char kValue0[] = "value0"; | |
118 char kKey1[] = "zzz1"; | |
Robert Sesek
2014/10/16 18:07:59
These are all the same length. May be good to vary
| |
119 char kValue1[] = "value1"; | |
120 char kKey2[] = "aaa2"; | |
121 char kValue2[] = "value2"; | |
122 | |
123 MinidumpSimpleStringDictionaryWriter dictionary_writer; | |
124 MinidumpSimpleStringDictionaryEntryWriter entry_writer_0; | |
125 entry_writer_0.SetKeyValue(kKey0, kValue0); | |
126 dictionary_writer.AddEntry(&entry_writer_0); | |
127 MinidumpSimpleStringDictionaryEntryWriter entry_writer_1; | |
128 entry_writer_1.SetKeyValue(kKey1, kValue1); | |
129 dictionary_writer.AddEntry(&entry_writer_1); | |
130 MinidumpSimpleStringDictionaryEntryWriter entry_writer_2; | |
131 entry_writer_2.SetKeyValue(kKey2, kValue2); | |
132 dictionary_writer.AddEntry(&entry_writer_2); | |
133 | |
134 EXPECT_TRUE(dictionary_writer.WriteEverything(&file_writer)); | |
135 ASSERT_EQ(sizeof(MinidumpSimpleStringDictionary) + | |
136 3 * sizeof(MinidumpSimpleStringDictionaryEntry) + | |
137 6 * sizeof(MinidumpUTF8String) + sizeof(kKey0) + 3 + | |
138 sizeof(kValue1) + 1 + sizeof(kKey1) + 3 + sizeof(kValue1) + 1 + | |
139 sizeof(kKey2) + 3 + sizeof(kValue2), | |
140 file_writer.string().size()); | |
141 | |
142 const MinidumpSimpleStringDictionary* dictionary = | |
143 MinidumpSimpleStringDictionaryCast(file_writer); | |
144 EXPECT_EQ(3u, dictionary->count); | |
145 EXPECT_EQ(28u, dictionary->entries[0].key); | |
146 EXPECT_EQ(40u, dictionary->entries[0].value); | |
147 EXPECT_EQ(52u, dictionary->entries[1].key); | |
148 EXPECT_EQ(64u, dictionary->entries[1].value); | |
149 EXPECT_EQ(76u, dictionary->entries[2].key); | |
150 EXPECT_EQ(88u, dictionary->entries[2].value); | |
151 | |
152 // The entries don’t appear in the order they were added. The current | |
153 // implementation uses a std::map and sorts keys, so the entires appear in | |
154 // alphabetical order. However, this is an implementation detail, and it’s OK | |
155 // if the writer stops sorting in this order. Testing for a specific order is | |
156 // just the easiest way to write this test while the writer will output things | |
157 // in a known order. | |
158 EXPECT_EQ(kKey2, | |
159 MinidumpUTF8StringAtRVA(file_writer, dictionary->entries[0].key)); | |
160 EXPECT_EQ(kValue2, | |
161 MinidumpUTF8StringAtRVA(file_writer, dictionary->entries[0].value)); | |
162 EXPECT_EQ(kKey0, | |
163 MinidumpUTF8StringAtRVA(file_writer, dictionary->entries[1].key)); | |
164 EXPECT_EQ(kValue0, | |
165 MinidumpUTF8StringAtRVA(file_writer, dictionary->entries[1].value)); | |
166 EXPECT_EQ(kKey1, | |
167 MinidumpUTF8StringAtRVA(file_writer, dictionary->entries[2].key)); | |
168 EXPECT_EQ(kValue1, | |
169 MinidumpUTF8StringAtRVA(file_writer, dictionary->entries[2].value)); | |
170 } | |
171 | |
172 TEST(MinidumpSimpleStringDictionaryWriter, DuplicateKeyValue) { | |
173 StringFileWriter file_writer; | |
174 | |
175 char kKey[] = "key"; | |
176 char kValue0[] = "fake_value"; | |
177 char kValue1[] = "value"; | |
178 | |
179 MinidumpSimpleStringDictionaryWriter dictionary_writer; | |
180 MinidumpSimpleStringDictionaryEntryWriter entry_writer_0; | |
181 entry_writer_0.SetKeyValue(kKey, kValue0); | |
182 dictionary_writer.AddEntry(&entry_writer_0); | |
183 MinidumpSimpleStringDictionaryEntryWriter entry_writer_1; | |
184 entry_writer_1.SetKeyValue(kKey, kValue1); | |
185 dictionary_writer.AddEntry(&entry_writer_1); | |
186 | |
187 EXPECT_TRUE(dictionary_writer.WriteEverything(&file_writer)); | |
188 ASSERT_EQ(sizeof(MinidumpSimpleStringDictionary) + | |
189 sizeof(MinidumpSimpleStringDictionaryEntry) + | |
190 2 * sizeof(MinidumpUTF8String) + sizeof(kKey) + sizeof(kValue1), | |
191 file_writer.string().size()); | |
192 | |
193 const MinidumpSimpleStringDictionary* dictionary = | |
194 MinidumpSimpleStringDictionaryCast(file_writer); | |
195 EXPECT_EQ(1u, dictionary->count); | |
196 EXPECT_EQ(12u, dictionary->entries[0].key); | |
197 EXPECT_EQ(20u, dictionary->entries[0].value); | |
198 EXPECT_EQ(kKey, | |
199 MinidumpUTF8StringAtRVA(file_writer, dictionary->entries[0].key)); | |
200 EXPECT_EQ(kValue1, | |
201 MinidumpUTF8StringAtRVA(file_writer, dictionary->entries[0].value)); | |
202 } | |
203 | |
204 } // namespace | |
205 } // namespace test | |
206 } // namespace crashpad | |
OLD | NEW |