OLD | NEW |
1 // Copyright 2014 The Crashpad Authors. All rights reserved. | 1 // Copyright 2014 The Crashpad Authors. All rights reserved. |
2 // | 2 // |
3 // Licensed under the Apache License, Version 2.0 (the "License"); | 3 // Licensed under the Apache License, Version 2.0 (the "License"); |
4 // you may not use this file except in compliance with 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 | 5 // You may obtain a copy of the License at |
6 // | 6 // |
7 // http://www.apache.org/licenses/LICENSE-2.0 | 7 // http://www.apache.org/licenses/LICENSE-2.0 |
8 // | 8 // |
9 // Unless required by applicable law or agreed to in writing, software | 9 // Unless required by applicable law or agreed to in writing, software |
10 // distributed under the License is distributed on an "AS IS" BASIS, | 10 // distributed under the License is distributed on an "AS IS" BASIS, |
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
12 // See the License for the specific language governing permissions and | 12 // See the License for the specific language governing permissions and |
13 // limitations under the License. | 13 // limitations under the License. |
14 | 14 |
15 #include "minidump/minidump_string_writer.h" | 15 #include "minidump/minidump_string_writer.h" |
16 | 16 |
17 #include <dbghelp.h> | 17 #include <dbghelp.h> |
18 | 18 |
19 #include <string> | 19 #include <string> |
20 | 20 |
21 #include "base/basictypes.h" | 21 #include "base/basictypes.h" |
22 #include "base/strings/string16.h" | 22 #include "base/strings/string16.h" |
23 #include "base/strings/stringprintf.h" | 23 #include "base/strings/stringprintf.h" |
24 #include "gtest/gtest.h" | 24 #include "gtest/gtest.h" |
| 25 #include "minidump/test/minidump_string_writer_test_util.h" |
25 #include "util/file/string_file_writer.h" | 26 #include "util/file/string_file_writer.h" |
26 | 27 |
27 namespace crashpad { | 28 namespace crashpad { |
28 namespace test { | 29 namespace test { |
29 namespace { | 30 namespace { |
30 | 31 |
31 const MINIDUMP_STRING* MinidumpStringCast(const StringFileWriter& file_writer) { | |
32 return reinterpret_cast<const MINIDUMP_STRING*>(&file_writer.string()[0]); | |
33 } | |
34 | |
35 TEST(MinidumpStringWriter, MinidumpUTF16StringWriter) { | 32 TEST(MinidumpStringWriter, MinidumpUTF16StringWriter) { |
36 StringFileWriter file_writer; | 33 StringFileWriter file_writer; |
37 | 34 |
38 { | 35 { |
39 SCOPED_TRACE("unset"); | 36 SCOPED_TRACE("unset"); |
40 file_writer.Reset(); | 37 file_writer.Reset(); |
41 crashpad::internal::MinidumpUTF16StringWriter string_writer; | 38 crashpad::internal::MinidumpUTF16StringWriter string_writer; |
42 EXPECT_TRUE(string_writer.WriteEverything(&file_writer)); | 39 EXPECT_TRUE(string_writer.WriteEverything(&file_writer)); |
43 ASSERT_EQ(6u, file_writer.string().size()); | 40 ASSERT_EQ(6u, file_writer.string().size()); |
44 const MINIDUMP_STRING* minidump_string = MinidumpStringCast(file_writer); | 41 |
45 EXPECT_EQ(0u, minidump_string->Length); | 42 const MINIDUMP_STRING* minidump_string = |
46 EXPECT_EQ(0, minidump_string->Buffer[0]); | 43 MinidumpStringAtRVA(file_writer.string(), 0); |
| 44 EXPECT_TRUE(minidump_string); |
| 45 EXPECT_EQ(string16(), MinidumpStringAtRVAAsString(file_writer.string(), 0)); |
47 } | 46 } |
48 | 47 |
49 const struct { | 48 const struct { |
50 size_t input_length; | 49 size_t input_length; |
51 const char* input_string; | 50 const char* input_string; |
52 size_t output_length; | 51 size_t output_length; |
53 const char16 output_string[10]; | 52 const char16 output_string[10]; |
54 } kTestData[] = { | 53 } kTestData[] = { |
55 {0, "", 0, {}}, | 54 {0, "", 0, {}}, |
56 {1, "a", 1, {'a'}}, | 55 {1, "a", 1, {'a'}}, |
(...skipping 24 matching lines...) Expand all Loading... |
81 string_writer.SetUTF8(std::string(kTestData[index].input_string, | 80 string_writer.SetUTF8(std::string(kTestData[index].input_string, |
82 kTestData[index].input_length)); | 81 kTestData[index].input_length)); |
83 EXPECT_TRUE(string_writer.WriteEverything(&file_writer)); | 82 EXPECT_TRUE(string_writer.WriteEverything(&file_writer)); |
84 | 83 |
85 const size_t expected_utf16_units_with_nul = | 84 const size_t expected_utf16_units_with_nul = |
86 kTestData[index].output_length + 1; | 85 kTestData[index].output_length + 1; |
87 const size_t expected_utf16_bytes = | 86 const size_t expected_utf16_bytes = |
88 expected_utf16_units_with_nul * sizeof(MINIDUMP_STRING::Buffer[0]); | 87 expected_utf16_units_with_nul * sizeof(MINIDUMP_STRING::Buffer[0]); |
89 ASSERT_EQ(sizeof(MINIDUMP_STRING) + expected_utf16_bytes, | 88 ASSERT_EQ(sizeof(MINIDUMP_STRING) + expected_utf16_bytes, |
90 file_writer.string().size()); | 89 file_writer.string().size()); |
91 const MINIDUMP_STRING* minidump_string = MinidumpStringCast(file_writer); | 90 |
92 EXPECT_EQ( | 91 const MINIDUMP_STRING* minidump_string = |
93 kTestData[index].output_length * sizeof(minidump_string->Buffer[0]), | 92 MinidumpStringAtRVA(file_writer.string(), 0); |
94 minidump_string->Length); | 93 EXPECT_TRUE(minidump_string); |
95 EXPECT_EQ(0, | 94 string16 expect_string = string16(kTestData[index].output_string, |
96 base::c16memcmp(kTestData[index].output_string, | 95 kTestData[index].output_length); |
97 minidump_string->Buffer, | 96 EXPECT_EQ(expect_string, |
98 expected_utf16_units_with_nul)); | 97 MinidumpStringAtRVAAsString(file_writer.string(), 0)); |
99 } | 98 } |
100 } | 99 } |
101 | 100 |
102 TEST(MinidumpStringWriter, ConvertInvalidUTF8ToUTF16) { | 101 TEST(MinidumpStringWriter, ConvertInvalidUTF8ToUTF16) { |
103 StringFileWriter file_writer; | 102 StringFileWriter file_writer; |
104 | 103 |
105 const char* kTestData[] = { | 104 const char* kTestData[] = { |
106 "\200", // continuation byte | 105 "\200", // continuation byte |
107 "\300", // start byte followed by EOF | 106 "\300", // start byte followed by EOF |
108 "\310\177", // start byte without continuation | 107 "\310\177", // start byte without continuation |
109 "\340\200", // EOF in middle of 3-byte sequence | 108 "\340\200", // EOF in middle of 3-byte sequence |
110 "\340\200\115", // invalid 3-byte sequence | 109 "\340\200\115", // invalid 3-byte sequence |
111 "\303\0\251", // NUL in middle of valid sequence | 110 "\303\0\251", // NUL in middle of valid sequence |
112 }; | 111 }; |
113 | 112 |
114 for (size_t index = 0; index < arraysize(kTestData); ++index) { | 113 for (size_t index = 0; index < arraysize(kTestData); ++index) { |
115 SCOPED_TRACE( | 114 SCOPED_TRACE( |
116 base::StringPrintf("index %zu, input %s", index, kTestData[index])); | 115 base::StringPrintf("index %zu, input %s", index, kTestData[index])); |
117 file_writer.Reset(); | 116 file_writer.Reset(); |
118 crashpad::internal::MinidumpUTF16StringWriter string_writer; | 117 crashpad::internal::MinidumpUTF16StringWriter string_writer; |
119 string_writer.SetUTF8(kTestData[index]); | 118 string_writer.SetUTF8(kTestData[index]); |
120 EXPECT_TRUE(string_writer.WriteEverything(&file_writer)); | 119 EXPECT_TRUE(string_writer.WriteEverything(&file_writer)); |
121 | 120 |
122 // The requirements for conversion of invalid UTF-8 input are lax. Make sure | 121 // The requirements for conversion of invalid UTF-8 input are lax. Make sure |
123 // that at least enough data was written for a string that has one unit and | 122 // that at least enough data was written for a string that has one unit and |
124 // a NUL terminator, make sure that the length field matches the length of | 123 // a NUL terminator, make sure that the length field matches the length of |
125 // data written, make sure the data is NUL-terminated, and make sure that at | 124 // data written, and make sure that at least one U+FFFD replacement |
126 // least one U+FFFD replacement character was written. | 125 // character was written. |
127 ASSERT_GE(file_writer.string().size(), | 126 const MINIDUMP_STRING* minidump_string = |
128 sizeof(MINIDUMP_STRING) + 2 * sizeof(MINIDUMP_STRING::Buffer[0])); | 127 MinidumpStringAtRVA(file_writer.string(), 0); |
129 const MINIDUMP_STRING* minidump_string = MinidumpStringCast(file_writer); | 128 EXPECT_TRUE(minidump_string); |
130 EXPECT_EQ(file_writer.string().size() - sizeof(MINIDUMP_STRING) - | 129 EXPECT_EQ(file_writer.string().size() - sizeof(MINIDUMP_STRING) - |
131 sizeof(MINIDUMP_STRING::Buffer[0]), | 130 sizeof(MINIDUMP_STRING::Buffer[0]), |
132 minidump_string->Length); | 131 minidump_string->Length); |
133 size_t out_units = | 132 string16 output_string = |
134 minidump_string->Length / sizeof(minidump_string->Buffer[0]); | 133 MinidumpStringAtRVAAsString(file_writer.string(), 0); |
135 EXPECT_EQ(0, minidump_string->Buffer[out_units]); | 134 EXPECT_FALSE(output_string.empty()); |
136 EXPECT_NE(nullptr, | 135 EXPECT_NE(string16::npos, output_string.find(0xfffd)); |
137 base::c16memchr(minidump_string->Buffer, 0xfffd, out_units)); | |
138 } | 136 } |
139 } | 137 } |
140 | 138 |
141 const MinidumpUTF8String* MinidumpUTF8StringCast( | |
142 const StringFileWriter& file_writer) { | |
143 return reinterpret_cast<const MinidumpUTF8String*>(&file_writer.string()[0]); | |
144 } | |
145 | |
146 TEST(MinidumpStringWriter, MinidumpUTF8StringWriter) { | 139 TEST(MinidumpStringWriter, MinidumpUTF8StringWriter) { |
147 StringFileWriter file_writer; | 140 StringFileWriter file_writer; |
148 | 141 |
149 { | 142 { |
150 SCOPED_TRACE("unset"); | 143 SCOPED_TRACE("unset"); |
151 file_writer.Reset(); | 144 file_writer.Reset(); |
152 crashpad::internal::MinidumpUTF8StringWriter string_writer; | 145 crashpad::internal::MinidumpUTF8StringWriter string_writer; |
153 EXPECT_TRUE(string_writer.WriteEverything(&file_writer)); | 146 EXPECT_TRUE(string_writer.WriteEverything(&file_writer)); |
154 ASSERT_EQ(5u, file_writer.string().size()); | 147 ASSERT_EQ(5u, file_writer.string().size()); |
| 148 |
155 const MinidumpUTF8String* minidump_string = | 149 const MinidumpUTF8String* minidump_string = |
156 MinidumpUTF8StringCast(file_writer); | 150 MinidumpUTF8StringAtRVA(file_writer.string(), 0); |
157 EXPECT_EQ(0u, minidump_string->Length); | 151 EXPECT_TRUE(minidump_string); |
158 EXPECT_EQ(0, minidump_string->Buffer[0]); | 152 EXPECT_EQ(std::string(), |
| 153 MinidumpUTF8StringAtRVAAsString(file_writer.string(), 0)); |
159 } | 154 } |
160 | 155 |
161 const struct { | 156 const struct { |
162 size_t length; | 157 size_t length; |
163 const char* string; | 158 const char* string; |
164 } kTestData[] = { | 159 } kTestData[] = { |
165 {0, ""}, | 160 {0, ""}, |
166 {1, "a"}, | 161 {1, "a"}, |
167 {2, "\0b"}, | 162 {2, "\0b"}, |
168 {3, "cde"}, | 163 {3, "cde"}, |
(...skipping 13 matching lines...) Expand all Loading... |
182 file_writer.Reset(); | 177 file_writer.Reset(); |
183 crashpad::internal::MinidumpUTF8StringWriter string_writer; | 178 crashpad::internal::MinidumpUTF8StringWriter string_writer; |
184 std::string test_string(kTestData[index].string, kTestData[index].length); | 179 std::string test_string(kTestData[index].string, kTestData[index].length); |
185 string_writer.SetUTF8(test_string); | 180 string_writer.SetUTF8(test_string); |
186 EXPECT_EQ(test_string, string_writer.UTF8()); | 181 EXPECT_EQ(test_string, string_writer.UTF8()); |
187 EXPECT_TRUE(string_writer.WriteEverything(&file_writer)); | 182 EXPECT_TRUE(string_writer.WriteEverything(&file_writer)); |
188 | 183 |
189 const size_t expected_utf8_bytes_with_nul = kTestData[index].length + 1; | 184 const size_t expected_utf8_bytes_with_nul = kTestData[index].length + 1; |
190 ASSERT_EQ(sizeof(MinidumpUTF8String) + expected_utf8_bytes_with_nul, | 185 ASSERT_EQ(sizeof(MinidumpUTF8String) + expected_utf8_bytes_with_nul, |
191 file_writer.string().size()); | 186 file_writer.string().size()); |
| 187 |
192 const MinidumpUTF8String* minidump_string = | 188 const MinidumpUTF8String* minidump_string = |
193 MinidumpUTF8StringCast(file_writer); | 189 MinidumpUTF8StringAtRVA(file_writer.string(), 0); |
194 EXPECT_EQ(kTestData[index].length, minidump_string->Length); | 190 EXPECT_TRUE(minidump_string); |
195 EXPECT_EQ(0, | 191 EXPECT_EQ(test_string, |
196 memcmp(kTestData[index].string, | 192 MinidumpUTF8StringAtRVAAsString(file_writer.string(), 0)); |
197 minidump_string->Buffer, | |
198 expected_utf8_bytes_with_nul)); | |
199 } | 193 } |
200 } | 194 } |
201 | 195 |
202 } // namespace | 196 } // namespace |
203 } // namespace test | 197 } // namespace test |
204 } // namespace crashpad | 198 } // namespace crashpad |
OLD | NEW |