Update Crashpad to b4095401639ebe2ad33169e5c1d994065cbff1b8

third_party/crashpad/crashpad/client/simulate_crash_mac_test.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 83 matching lines @@
                                    mach_msg_type_number_t old_state_count,
                                    thread_state_t new_state,
                                    mach_msg_type_number_t* new_state_count,
                                    const mach_msg_trailer_t* trailer,
                                    bool* destroy_complex_request) override {
     *destroy_complex_request = true;
 
     // Check the entire exception message, because most or all of it was
     // generated by SimulateCrash() instead of the kernel.
 
-    EXPECT_EQ(behavior_, behavior);
-    EXPECT_EQ(LocalPort(), exception_port);
+    EXPECT_EQ(behavior, behavior_);
+    EXPECT_EQ(exception_port, LocalPort());
     if (ExceptionBehaviorHasIdentity(behavior)) {
-      EXPECT_NE(THREAD_NULL, thread);
-      EXPECT_EQ(ChildTask(), task);
+      EXPECT_NE(thread, THREAD_NULL);
+      EXPECT_EQ(task, ChildTask());
     } else {
-      EXPECT_EQ(THREAD_NULL, thread);
-      EXPECT_EQ(TASK_NULL, task);
+      EXPECT_EQ(thread, THREAD_NULL);
+      EXPECT_EQ(task, TASK_NULL);
     }
-    EXPECT_EQ(kMachExceptionSimulated, exception);
-    EXPECT_EQ(2u, code_count);
+    EXPECT_EQ(exception, kMachExceptionSimulated);
+    EXPECT_EQ(code_count, 2u);
     if (code_count >= 1) {
-      EXPECT_EQ(0, code[0]);
+      EXPECT_EQ(code[0], 0);
     }
     if (code_count >= 2) {
-      EXPECT_EQ(0, code[1]);
+      EXPECT_EQ(code[1], 0);
     }
     if (!ExceptionBehaviorHasState(behavior)) {
-      EXPECT_EQ(THREAD_STATE_NONE, *flavor);
+      EXPECT_EQ(*flavor, THREAD_STATE_NONE);
     } else {
-      EXPECT_EQ(flavor_, *flavor);
+      EXPECT_EQ(*flavor, flavor_);
       switch (*flavor) {
 #if defined(ARCH_CPU_X86_FAMILY)
         case x86_THREAD_STATE: {
-          EXPECT_EQ(x86_THREAD_STATE_COUNT, old_state_count);
+          EXPECT_EQ(old_state_count, x86_THREAD_STATE_COUNT);
           const x86_thread_state* state =
               reinterpret_cast<const x86_thread_state*>(old_state);
           switch (state->tsh.flavor) {
             case x86_THREAD_STATE32:
-              EXPECT_EQ(implicit_cast<int>(x86_THREAD_STATE32_COUNT),
-                        state->tsh.count);
+              EXPECT_EQ(state->tsh.count,
+                        implicit_cast<int>(x86_THREAD_STATE32_COUNT));
               break;
             case x86_THREAD_STATE64:
-              EXPECT_EQ(implicit_cast<int>(x86_THREAD_STATE64_COUNT),
-                        state->tsh.count);
+              EXPECT_EQ(state->tsh.count,
+                        implicit_cast<int>(x86_THREAD_STATE64_COUNT));
               break;
             default:
               ADD_FAILURE() << "unexpected tsh.flavor " << state->tsh.flavor;
               break;
           }
           break;
         }
         case x86_FLOAT_STATE: {
-          EXPECT_EQ(x86_FLOAT_STATE_COUNT, old_state_count);
+          EXPECT_EQ(old_state_count, x86_FLOAT_STATE_COUNT);
           const x86_float_state* state =
               reinterpret_cast<const x86_float_state*>(old_state);
           switch (state->fsh.flavor) {
             case x86_FLOAT_STATE32:
-              EXPECT_EQ(implicit_cast<int>(x86_FLOAT_STATE32_COUNT),
-                        state->fsh.count);
+              EXPECT_EQ(state->fsh.count,
+                        implicit_cast<int>(x86_FLOAT_STATE32_COUNT));
               break;
             case x86_FLOAT_STATE64:
-              EXPECT_EQ(implicit_cast<int>(x86_FLOAT_STATE64_COUNT),
-                        state->fsh.count);
+              EXPECT_EQ(state->fsh.count,
+                        implicit_cast<int>(x86_FLOAT_STATE64_COUNT));
               break;
             default:
               ADD_FAILURE() << "unexpected fsh.flavor " << state->fsh.flavor;
               break;
           }
           break;
         }
         case x86_DEBUG_STATE: {
-          EXPECT_EQ(x86_DEBUG_STATE_COUNT, old_state_count);
+          EXPECT_EQ(old_state_count, x86_DEBUG_STATE_COUNT);
           const x86_debug_state* state =
               reinterpret_cast<const x86_debug_state*>(old_state);
           switch (state->dsh.flavor) {
             case x86_DEBUG_STATE32:
-              EXPECT_EQ(implicit_cast<int>(x86_DEBUG_STATE32_COUNT),
-                        state->dsh.count);
+              EXPECT_EQ(state->dsh.count,
+                        implicit_cast<int>(x86_DEBUG_STATE32_COUNT));
               break;
             case x86_DEBUG_STATE64:
-              EXPECT_EQ(implicit_cast<int>(x86_DEBUG_STATE64_COUNT),
-                        state->dsh.count);
+              EXPECT_EQ(state->dsh.count,
+                        implicit_cast<int>(x86_DEBUG_STATE64_COUNT));
               break;
             default:
               ADD_FAILURE() << "unexpected dsh.flavor " << state->dsh.flavor;
               break;
           }
           break;
         }
         case x86_THREAD_STATE32:
-          EXPECT_EQ(x86_THREAD_STATE32_COUNT, old_state_count);
+          EXPECT_EQ(old_state_count, x86_THREAD_STATE32_COUNT);
           break;
         case x86_FLOAT_STATE32:
-          EXPECT_EQ(x86_FLOAT_STATE32_COUNT, old_state_count);
+          EXPECT_EQ(old_state_count, x86_FLOAT_STATE32_COUNT);
           break;
         case x86_DEBUG_STATE32:
-          EXPECT_EQ(x86_DEBUG_STATE32_COUNT, old_state_count);
+          EXPECT_EQ(old_state_count, x86_DEBUG_STATE32_COUNT);
           break;
         case x86_THREAD_STATE64:
-          EXPECT_EQ(x86_THREAD_STATE64_COUNT, old_state_count);
+          EXPECT_EQ(old_state_count, x86_THREAD_STATE64_COUNT);
           break;
         case x86_FLOAT_STATE64:
-          EXPECT_EQ(x86_FLOAT_STATE64_COUNT, old_state_count);
+          EXPECT_EQ(old_state_count, x86_FLOAT_STATE64_COUNT);
           break;
         case x86_DEBUG_STATE64:
-          EXPECT_EQ(x86_DEBUG_STATE64_COUNT, old_state_count);
+          EXPECT_EQ(old_state_count, x86_DEBUG_STATE64_COUNT);
           break;
 #else
 #error Port to your CPU architecture
 #endif
         default:
           ADD_FAILURE() << "unexpected flavor " << *flavor;
           break;
       }
 
       // Attempt to set a garbage thread state, which would cause the child to
       // crash inside SimulateCrash() if it actually succeeded. This tests that
       // SimulateCrash() ignores new_state instead of attempting to set the
       // state as the kernel would do. This operates in conjunction with the
       // |true| argument to ExcServerSuccessfulReturnValue() below.
       *new_state_count = old_state_count;
       size_t new_state_size = sizeof(natural_t) * old_state_count;
       memset(new_state, 0xa5, new_state_size);
     }
 
     if (!succeed_) {
       // The client has registered EXC_CRASH handlers for both its thread and
       // task targets, and sent a simulated exception message to its
       // thread-level EXC_CRASH handler. To test that it will fall back to
       // trying the task-level EXC_CRASH handler, return a failure code, which
       // should cause SimulateCrash() to try the next target.
-      EXPECT_EQ(kExceptionPortsTargetBoth, target_);
+      EXPECT_EQ(target_, kExceptionPortsTargetBoth);
       return KERN_ABORTED;
     }
 
     ExcServerCopyState(
         behavior, old_state, old_state_count, new_state, new_state_count);
 
     return ExcServerSuccessfulReturnValue(exception, behavior, true);
   }
 
  private:
@@ skipping 15 matching lines @@
       // task targets. Run a server that will return a failure code when the
       // exception message is sent to the thread target, which will cause the
       // client to fall back to the task target and send another message.
       succeed_ = false;
       mr = MachMessageServer::Run(&universal_mach_exc_server,
                                   LocalPort(),
                                   MACH_MSG_OPTION_NONE,
                                   MachMessageServer::kOneShot,
                                   MachMessageServer::kReceiveLargeError,
                                   kMachMessageTimeoutWaitIndefinitely);
-      EXPECT_EQ(MACH_MSG_SUCCESS, mr)
+      EXPECT_EQ(mr, MACH_MSG_SUCCESS)
           << MachErrorMessage(mr, "MachMessageServer::Run");
     }
 
     succeed_ = true;
     mr = MachMessageServer::Run(&universal_mach_exc_server,
                                 LocalPort(),
                                 MACH_MSG_OPTION_NONE,
                                 MachMessageServer::kOneShot,
                                 MachMessageServer::kReceiveLargeError,
                                 kMachMessageTimeoutWaitIndefinitely);
-    EXPECT_EQ(MACH_MSG_SUCCESS, mr)
+    EXPECT_EQ(mr, MACH_MSG_SUCCESS)
         << MachErrorMessage(mr, "MachMessageServer::Run");
   }
 
   void MachMultiprocessChild() override {
     bool task_valid = target_ == kExceptionPortsTargetTask ||
                       target_ == kExceptionPortsTargetBoth;
     ExceptionPorts task_exception_ports(ExceptionPorts::kTargetTypeTask,
                                         TASK_NULL);
     ASSERT_TRUE(task_exception_ports.SetExceptionPort(
         EXC_MASK_CRASH,
@@ skipping 95 matching lines @@
           test_simulate_crash_mac.Run();
         }
       }
     }
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad