| 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_context_test_util.h" |
| 16 |
| 17 #include "base/basictypes.h" |
| 18 #include "gtest/gtest.h" |
| 19 |
| 20 namespace crashpad { |
| 21 namespace test { |
| 22 |
| 23 void InitializeMinidumpContextX86(MinidumpContextX86* context, uint32_t seed) { |
| 24 if (seed == 0) { |
| 25 memset(context, 0, sizeof(*context)); |
| 26 context->context_flags = kMinidumpContextX86; |
| 27 return; |
| 28 } |
| 29 |
| 30 context->context_flags = kMinidumpContextX86All; |
| 31 |
| 32 uint32_t value = seed; |
| 33 |
| 34 context->dr0 = value++; |
| 35 context->dr1 = value++; |
| 36 context->dr2 = value++; |
| 37 context->dr3 = value++; |
| 38 context->dr6 = value++; |
| 39 context->dr7 = value++; |
| 40 context->float_save.control_word = value++; |
| 41 context->float_save.status_word = value++; |
| 42 context->float_save.tag_word = value++; |
| 43 context->float_save.error_offset = value++; |
| 44 context->float_save.error_selector = value++; |
| 45 context->float_save.data_offset = value++; |
| 46 context->float_save.data_selector = value++; |
| 47 for (size_t index = 0; |
| 48 index < arraysize(context->float_save.register_area); |
| 49 ++index) { |
| 50 context->float_save.register_area[index] = value++; |
| 51 } |
| 52 context->float_save.spare_0 = value++; |
| 53 context->gs = value++; |
| 54 context->fs = value++; |
| 55 context->es = value++; |
| 56 context->ds = value++; |
| 57 context->edi = value++; |
| 58 context->esi = value++; |
| 59 context->ebx = value++; |
| 60 context->edx = value++; |
| 61 context->ecx = value++; |
| 62 context->eax = value++; |
| 63 context->ebp = value++; |
| 64 context->eip = value++; |
| 65 context->cs = value++; |
| 66 context->eflags = value++; |
| 67 context->esp = value++; |
| 68 context->ss = value++; |
| 69 for (size_t index = 0; index < arraysize(context->extended_registers); |
| 70 ++index) { |
| 71 context->extended_registers[index] = value++; |
| 72 } |
| 73 } |
| 74 |
| 75 void InitializeMinidumpContextAMD64(MinidumpContextAMD64* context, |
| 76 uint32_t seed) { |
| 77 if (seed == 0) { |
| 78 memset(context, 0, sizeof(*context)); |
| 79 context->context_flags = kMinidumpContextAMD64; |
| 80 return; |
| 81 } |
| 82 |
| 83 context->context_flags = kMinidumpContextAMD64All; |
| 84 |
| 85 uint32_t value = seed; |
| 86 |
| 87 context->p1_home = value++; |
| 88 context->p2_home = value++; |
| 89 context->p3_home = value++; |
| 90 context->p4_home = value++; |
| 91 context->p5_home = value++; |
| 92 context->p6_home = value++; |
| 93 context->mx_csr = value++; |
| 94 context->cs = value++; |
| 95 context->ds = value++; |
| 96 context->es = value++; |
| 97 context->fs = value++; |
| 98 context->gs = value++; |
| 99 context->ss = value++; |
| 100 context->eflags = value++; |
| 101 context->dr0 = value++; |
| 102 context->dr1 = value++; |
| 103 context->dr2 = value++; |
| 104 context->dr3 = value++; |
| 105 context->dr6 = value++; |
| 106 context->dr7 = value++; |
| 107 context->rax = value++; |
| 108 context->rcx = value++; |
| 109 context->rdx = value++; |
| 110 context->rbx = value++; |
| 111 context->rsp = value++; |
| 112 context->rbp = value++; |
| 113 context->rsi = value++; |
| 114 context->rdi = value++; |
| 115 context->r8 = value++; |
| 116 context->r9 = value++; |
| 117 context->r10 = value++; |
| 118 context->r11 = value++; |
| 119 context->r12 = value++; |
| 120 context->r13 = value++; |
| 121 context->r14 = value++; |
| 122 context->r15 = value++; |
| 123 context->rip = value++; |
| 124 context->float_save.control_word = value++; |
| 125 context->float_save.status_word = value++; |
| 126 context->float_save.tag_word = value++; |
| 127 context->float_save.reserved_1 = value++; |
| 128 context->float_save.error_opcode = value++; |
| 129 context->float_save.error_offset = value++; |
| 130 context->float_save.error_selector = value++; |
| 131 context->float_save.reserved_2 = value++; |
| 132 context->float_save.data_offset = value++; |
| 133 context->float_save.data_selector = value++; |
| 134 context->float_save.reserved_3 = value++; |
| 135 context->float_save.mx_csr = value++; |
| 136 context->float_save.mx_csr_mask = value++; |
| 137 for (size_t index = 0; |
| 138 index < arraysize(context->float_save.float_registers); |
| 139 ++index) { |
| 140 context->float_save.float_registers[index].lo = value++; |
| 141 context->float_save.float_registers[index].hi = value++; |
| 142 } |
| 143 for (size_t index = 0; |
| 144 index < arraysize(context->float_save.xmm_registers); |
| 145 ++index) { |
| 146 context->float_save.xmm_registers[index].lo = value++; |
| 147 context->float_save.xmm_registers[index].hi = value++; |
| 148 } |
| 149 for (size_t index = 0; |
| 150 index < arraysize(context->float_save.reserved_4); |
| 151 ++index) { |
| 152 context->float_save.reserved_4[index] = value++; |
| 153 } |
| 154 for (size_t index = 0; index < arraysize(context->vector_register); ++index) { |
| 155 context->vector_register[index].lo = value++; |
| 156 context->vector_register[index].hi = value++; |
| 157 } |
| 158 context->vector_control = value++; |
| 159 context->debug_control = value++; |
| 160 context->last_branch_to_rip = value++; |
| 161 context->last_branch_from_rip = value++; |
| 162 context->last_exception_to_rip = value++; |
| 163 context->last_exception_from_rip = value++; |
| 164 } |
| 165 |
| 166 void ExpectMinidumpContextX86(uint32_t expect_seed, |
| 167 const MinidumpContextX86* observed) { |
| 168 MinidumpContextX86 expected; |
| 169 InitializeMinidumpContextX86(&expected, expect_seed); |
| 170 |
| 171 EXPECT_EQ(expected.context_flags, observed->context_flags); |
| 172 EXPECT_EQ(expected.dr0, observed->dr0); |
| 173 EXPECT_EQ(expected.dr1, observed->dr1); |
| 174 EXPECT_EQ(expected.dr2, observed->dr2); |
| 175 EXPECT_EQ(expected.dr3, observed->dr3); |
| 176 EXPECT_EQ(expected.dr6, observed->dr6); |
| 177 EXPECT_EQ(expected.dr7, observed->dr7); |
| 178 EXPECT_EQ(expected.float_save.control_word, |
| 179 observed->float_save.control_word); |
| 180 EXPECT_EQ(expected.float_save.status_word, observed->float_save.status_word); |
| 181 EXPECT_EQ(expected.float_save.tag_word, observed->float_save.tag_word); |
| 182 EXPECT_EQ(expected.float_save.error_offset, |
| 183 observed->float_save.error_offset); |
| 184 EXPECT_EQ(expected.float_save.error_selector, |
| 185 observed->float_save.error_selector); |
| 186 EXPECT_EQ(expected.float_save.data_offset, observed->float_save.data_offset); |
| 187 EXPECT_EQ(expected.float_save.data_selector, |
| 188 observed->float_save.data_selector); |
| 189 for (size_t index = 0; |
| 190 index < arraysize(expected.float_save.register_area); |
| 191 ++index) { |
| 192 EXPECT_EQ(expected.float_save.register_area[index], |
| 193 observed->float_save.register_area[index]); |
| 194 } |
| 195 EXPECT_EQ(expected.float_save.spare_0, observed->float_save.spare_0); |
| 196 EXPECT_EQ(expected.gs, observed->gs); |
| 197 EXPECT_EQ(expected.fs, observed->fs); |
| 198 EXPECT_EQ(expected.es, observed->es); |
| 199 EXPECT_EQ(expected.ds, observed->ds); |
| 200 EXPECT_EQ(expected.edi, observed->edi); |
| 201 EXPECT_EQ(expected.esi, observed->esi); |
| 202 EXPECT_EQ(expected.ebx, observed->ebx); |
| 203 EXPECT_EQ(expected.edx, observed->edx); |
| 204 EXPECT_EQ(expected.ecx, observed->ecx); |
| 205 EXPECT_EQ(expected.eax, observed->eax); |
| 206 EXPECT_EQ(expected.ebp, observed->ebp); |
| 207 EXPECT_EQ(expected.eip, observed->eip); |
| 208 EXPECT_EQ(expected.cs, observed->cs); |
| 209 EXPECT_EQ(expected.eflags, observed->eflags); |
| 210 EXPECT_EQ(expected.esp, observed->esp); |
| 211 EXPECT_EQ(expected.ss, observed->ss); |
| 212 for (size_t index = 0; |
| 213 index < arraysize(expected.extended_registers); |
| 214 ++index) { |
| 215 EXPECT_EQ(expected.extended_registers[index], |
| 216 observed->extended_registers[index]); |
| 217 } |
| 218 } |
| 219 |
| 220 void ExpectMinidumpContextAMD64(uint32_t expect_seed, |
| 221 const MinidumpContextAMD64* observed) { |
| 222 MinidumpContextAMD64 expected; |
| 223 InitializeMinidumpContextAMD64(&expected, expect_seed); |
| 224 |
| 225 EXPECT_EQ(expected.context_flags, observed->context_flags); |
| 226 EXPECT_EQ(expected.p1_home, observed->p1_home); |
| 227 EXPECT_EQ(expected.p2_home, observed->p2_home); |
| 228 EXPECT_EQ(expected.p3_home, observed->p3_home); |
| 229 EXPECT_EQ(expected.p4_home, observed->p4_home); |
| 230 EXPECT_EQ(expected.p5_home, observed->p5_home); |
| 231 EXPECT_EQ(expected.p6_home, observed->p6_home); |
| 232 EXPECT_EQ(expected.mx_csr, observed->mx_csr); |
| 233 EXPECT_EQ(expected.cs, observed->cs); |
| 234 EXPECT_EQ(expected.ds, observed->ds); |
| 235 EXPECT_EQ(expected.es, observed->es); |
| 236 EXPECT_EQ(expected.fs, observed->fs); |
| 237 EXPECT_EQ(expected.gs, observed->gs); |
| 238 EXPECT_EQ(expected.ss, observed->ss); |
| 239 EXPECT_EQ(expected.eflags, observed->eflags); |
| 240 EXPECT_EQ(expected.dr0, observed->dr0); |
| 241 EXPECT_EQ(expected.dr1, observed->dr1); |
| 242 EXPECT_EQ(expected.dr2, observed->dr2); |
| 243 EXPECT_EQ(expected.dr3, observed->dr3); |
| 244 EXPECT_EQ(expected.dr6, observed->dr6); |
| 245 EXPECT_EQ(expected.dr7, observed->dr7); |
| 246 EXPECT_EQ(expected.rax, observed->rax); |
| 247 EXPECT_EQ(expected.rcx, observed->rcx); |
| 248 EXPECT_EQ(expected.rdx, observed->rdx); |
| 249 EXPECT_EQ(expected.rbx, observed->rbx); |
| 250 EXPECT_EQ(expected.rsp, observed->rsp); |
| 251 EXPECT_EQ(expected.rbp, observed->rbp); |
| 252 EXPECT_EQ(expected.rsi, observed->rsi); |
| 253 EXPECT_EQ(expected.rdi, observed->rdi); |
| 254 EXPECT_EQ(expected.r8, observed->r8); |
| 255 EXPECT_EQ(expected.r9, observed->r9); |
| 256 EXPECT_EQ(expected.r10, observed->r10); |
| 257 EXPECT_EQ(expected.r11, observed->r11); |
| 258 EXPECT_EQ(expected.r12, observed->r12); |
| 259 EXPECT_EQ(expected.r13, observed->r13); |
| 260 EXPECT_EQ(expected.r14, observed->r14); |
| 261 EXPECT_EQ(expected.r15, observed->r15); |
| 262 EXPECT_EQ(expected.rip, observed->rip); |
| 263 EXPECT_EQ(expected.float_save.control_word, |
| 264 observed->float_save.control_word); |
| 265 EXPECT_EQ(expected.float_save.status_word, observed->float_save.status_word); |
| 266 EXPECT_EQ(expected.float_save.tag_word, observed->float_save.tag_word); |
| 267 EXPECT_EQ(expected.float_save.reserved_1, observed->float_save.reserved_1); |
| 268 EXPECT_EQ(expected.float_save.error_opcode, |
| 269 observed->float_save.error_opcode); |
| 270 EXPECT_EQ(expected.float_save.error_offset, |
| 271 observed->float_save.error_offset); |
| 272 EXPECT_EQ(expected.float_save.error_selector, |
| 273 observed->float_save.error_selector); |
| 274 EXPECT_EQ(expected.float_save.reserved_2, observed->float_save.reserved_2); |
| 275 EXPECT_EQ(expected.float_save.data_offset, observed->float_save.data_offset); |
| 276 EXPECT_EQ(expected.float_save.data_selector, |
| 277 observed->float_save.data_selector); |
| 278 EXPECT_EQ(expected.float_save.reserved_3, observed->float_save.reserved_3); |
| 279 EXPECT_EQ(expected.float_save.mx_csr, observed->float_save.mx_csr); |
| 280 EXPECT_EQ(expected.float_save.mx_csr_mask, observed->float_save.mx_csr_mask); |
| 281 for (size_t index = 0; |
| 282 index < arraysize(expected.float_save.float_registers); |
| 283 ++index) { |
| 284 EXPECT_EQ(expected.float_save.float_registers[index].lo, |
| 285 observed->float_save.float_registers[index].lo); |
| 286 EXPECT_EQ(expected.float_save.float_registers[index].hi, |
| 287 observed->float_save.float_registers[index].hi); |
| 288 } |
| 289 for (size_t index = 0; |
| 290 index < arraysize(expected.float_save.xmm_registers); |
| 291 ++index) { |
| 292 EXPECT_EQ(expected.float_save.xmm_registers[index].lo, |
| 293 observed->float_save.xmm_registers[index].lo); |
| 294 EXPECT_EQ(expected.float_save.xmm_registers[index].hi, |
| 295 observed->float_save.xmm_registers[index].hi); |
| 296 } |
| 297 for (size_t index = 0; |
| 298 index < arraysize(expected.float_save.reserved_4); |
| 299 ++index) { |
| 300 EXPECT_EQ(expected.float_save.reserved_4[index], |
| 301 observed->float_save.reserved_4[index]); |
| 302 } |
| 303 for (size_t index = 0; index < arraysize(expected.vector_register); ++index) { |
| 304 EXPECT_EQ(expected.vector_register[index].lo, |
| 305 observed->vector_register[index].lo); |
| 306 EXPECT_EQ(expected.vector_register[index].hi, |
| 307 observed->vector_register[index].hi); |
| 308 } |
| 309 EXPECT_EQ(expected.vector_control, observed->vector_control); |
| 310 EXPECT_EQ(expected.debug_control, observed->debug_control); |
| 311 EXPECT_EQ(expected.last_branch_to_rip, observed->last_branch_to_rip); |
| 312 EXPECT_EQ(expected.last_branch_from_rip, observed->last_branch_from_rip); |
| 313 EXPECT_EQ(expected.last_exception_to_rip, observed->last_exception_to_rip); |
| 314 EXPECT_EQ(expected.last_exception_from_rip, |
| 315 observed->last_exception_from_rip); |
| 316 } |
| 317 |
| 318 } // namespace test |
| 319 } // namespace crashpad |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 628153004:
Add MinidumpContextWriter test (Closed)
Base URL: https://chromium.googlesource.com/crashpad/crashpad@master