Update Crashpad to b4095401639ebe2ad33169e5c1d994065cbff1b8

third_party/crashpad/crashpad/util/mach/composite_mach_message_server_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 13 matching lines @@
 namespace crashpad {
 namespace test {
 namespace {
 
 TEST(CompositeMachMessageServer, Empty) {
   CompositeMachMessageServer server;
 
   EXPECT_TRUE(server.MachMessageServerRequestIDs().empty());
 
   mach_msg_empty_rcv_t request = {};
-  EXPECT_EQ(sizeof(request.header), server.MachMessageServerRequestSize());
+  EXPECT_EQ(server.MachMessageServerRequestSize(), sizeof(request.header));
 
   mig_reply_error_t reply = {};
-  EXPECT_EQ(sizeof(reply), server.MachMessageServerReplySize());
+  EXPECT_EQ(server.MachMessageServerReplySize(), sizeof(reply));
 
   bool destroy_complex_request = false;
   EXPECT_FALSE(server.MachMessageServerFunction(
       &request.header, &reply.Head, &destroy_complex_request));
-  EXPECT_EQ(MIG_BAD_ID, reply.RetCode);
+  EXPECT_EQ(reply.RetCode, MIG_BAD_ID);
 }
 
 class TestMachMessageHandler : public MachMessageServer::Interface {
  public:
   TestMachMessageHandler()
       : MachMessageServer::Interface(),
         request_ids_(),
         request_size_(0),
         reply_size_(0),
         return_code_(KERN_FAILURE),
@@ skipping 22 matching lines @@
 
   void SetReplySize(mach_msg_size_t reply_size) {
     reply_size_ = reply_size;
   }
 
   // MachMessageServer::Interface:
 
   bool MachMessageServerFunction(const mach_msg_header_t* in,
                                  mach_msg_header_t* out,
                                  bool* destroy_complex_request) override {
-    EXPECT_NE(request_ids_.end(), request_ids_.find(in->msgh_id));
+    EXPECT_NE(request_ids_.find(in->msgh_id), request_ids_.end());
 
     *destroy_complex_request = destroy_complex_request_;
     PrepareMIGReplyFromRequest(in, out);
     SetMIGReplyError(out, return_code_);
     return return_value_;
   }
 
   std::set<mach_msg_id_t> MachMessageServerRequestIDs() override {
     return request_ids_;
   }
@@ skipping 19 matching lines @@
 
 TEST(CompositeMachMessageServer, HandlerDoesNotHandle) {
   TestMachMessageHandler handler;
 
   CompositeMachMessageServer server;
   server.AddHandler(&handler);
 
   EXPECT_TRUE(server.MachMessageServerRequestIDs().empty());
 
   mach_msg_empty_rcv_t request = {};
-  EXPECT_EQ(sizeof(request.header), server.MachMessageServerRequestSize());
+  EXPECT_EQ(server.MachMessageServerRequestSize(), sizeof(request.header));
 
   mig_reply_error_t reply = {};
-  EXPECT_EQ(sizeof(reply), server.MachMessageServerReplySize());
+  EXPECT_EQ(server.MachMessageServerReplySize(), sizeof(reply));
 
   bool destroy_complex_request = false;
   EXPECT_FALSE(server.MachMessageServerFunction(
       &request.header, &reply.Head, &destroy_complex_request));
-  EXPECT_EQ(MIG_BAD_ID, reply.RetCode);
+  EXPECT_EQ(reply.RetCode, MIG_BAD_ID);
   EXPECT_FALSE(destroy_complex_request);
 }
 
 TEST(CompositeMachMessageServer, OneHandler) {
   const mach_msg_id_t kRequestID = 100;
   const mach_msg_size_t kRequestSize = 256;
   const mach_msg_size_t kReplySize = 128;
   const kern_return_t kReturnCode = KERN_SUCCESS;
 
   TestMachMessageHandler handler;
   handler.AddRequestID(kRequestID);
   handler.SetRequestSize(kRequestSize);
   handler.SetReplySize(kReplySize);
   handler.SetReturnCodes(true, kReturnCode, true);
 
   CompositeMachMessageServer server;
 
   // The chosen request and reply sizes must be larger than the defaults for
   // that portion fo the test to be valid.
   EXPECT_GT(kRequestSize, server.MachMessageServerRequestSize());
   EXPECT_GT(kReplySize, server.MachMessageServerReplySize());
 
   server.AddHandler(&handler);
 
   std::set<mach_msg_id_t> expect_request_ids;
   expect_request_ids.insert(kRequestID);
-  EXPECT_EQ(expect_request_ids, server.MachMessageServerRequestIDs());
+  EXPECT_EQ(server.MachMessageServerRequestIDs(), expect_request_ids);
 
-  EXPECT_EQ(kRequestSize, server.MachMessageServerRequestSize());
-  EXPECT_EQ(kReplySize, server.MachMessageServerReplySize());
+  EXPECT_EQ(server.MachMessageServerRequestSize(), kRequestSize);
+  EXPECT_EQ(server.MachMessageServerReplySize(), kReplySize);
 
   mach_msg_empty_rcv_t request = {};
   mig_reply_error_t reply = {};
 
   // Send a message with an unknown request ID.
   request.header.msgh_id = 0;
   bool destroy_complex_request = false;
   EXPECT_FALSE(server.MachMessageServerFunction(
       &request.header, &reply.Head, &destroy_complex_request));
-  EXPECT_EQ(MIG_BAD_ID, reply.RetCode);
+  EXPECT_EQ(reply.RetCode, MIG_BAD_ID);
   EXPECT_FALSE(destroy_complex_request);
 
   // Send a message with a known request ID.
   request.header.msgh_id = kRequestID;
   EXPECT_TRUE(server.MachMessageServerFunction(
       &request.header, &reply.Head, &destroy_complex_request));
-  EXPECT_EQ(kReturnCode, reply.RetCode);
+  EXPECT_EQ(reply.RetCode, kReturnCode);
   EXPECT_TRUE(destroy_complex_request);
 }
 
 TEST(CompositeMachMessageServer, ThreeHandlers) {
   const mach_msg_id_t kRequestIDs0[] = {5};
   const kern_return_t kReturnCode0 = KERN_SUCCESS;
 
   const mach_msg_id_t kRequestIDs1[] = {4, 7};
   const kern_return_t kReturnCode1 = KERN_PROTECTION_FAILURE;
 
@@ skipping 36 matching lines @@
 
   // The chosen request and reply sizes must be larger than the defaults for
   // that portion fo the test to be valid.
   EXPECT_GT(kRequestSize2, server.MachMessageServerRequestSize());
   EXPECT_GT(kReplySize2, server.MachMessageServerReplySize());
 
   server.AddHandler(&handlers[0]);
   server.AddHandler(&handlers[1]);
   server.AddHandler(&handlers[2]);
 
-  EXPECT_EQ(expect_request_ids, server.MachMessageServerRequestIDs());
+  EXPECT_EQ(server.MachMessageServerRequestIDs(), expect_request_ids);
 
-  EXPECT_EQ(kRequestSize2, server.MachMessageServerRequestSize());
-  EXPECT_EQ(kReplySize2, server.MachMessageServerReplySize());
+  EXPECT_EQ(server.MachMessageServerRequestSize(), kRequestSize2);
+  EXPECT_EQ(server.MachMessageServerReplySize(), kReplySize2);
 
   mach_msg_empty_rcv_t request = {};
   mig_reply_error_t reply = {};
 
   // Send a message with an unknown request ID.
   request.header.msgh_id = 100;
   bool destroy_complex_request = false;
   EXPECT_FALSE(server.MachMessageServerFunction(
       &request.header, &reply.Head, &destroy_complex_request));
-  EXPECT_EQ(MIG_BAD_ID, reply.RetCode);
+  EXPECT_EQ(reply.RetCode, MIG_BAD_ID);
   EXPECT_FALSE(destroy_complex_request);
 
   // Send messages with known request IDs.
 
   for (size_t index = 0; index < arraysize(kRequestIDs0); ++index) {
     request.header.msgh_id = kRequestIDs0[index];
     SCOPED_TRACE(base::StringPrintf(
         "handler 0, index %zu, id %d", index, request.header.msgh_id));
 
     EXPECT_TRUE(server.MachMessageServerFunction(
         &request.header, &reply.Head, &destroy_complex_request));
-    EXPECT_EQ(kReturnCode0, reply.RetCode);
+    EXPECT_EQ(reply.RetCode, kReturnCode0);
     EXPECT_FALSE(destroy_complex_request);
   }
 
   for (size_t index = 0; index < arraysize(kRequestIDs1); ++index) {
     request.header.msgh_id = kRequestIDs1[index];
     SCOPED_TRACE(base::StringPrintf(
         "handler 1, index %zu, id %d", index, request.header.msgh_id));
 
     EXPECT_FALSE(server.MachMessageServerFunction(
         &request.header, &reply.Head, &destroy_complex_request));
-    EXPECT_EQ(kReturnCode1, reply.RetCode);
+    EXPECT_EQ(reply.RetCode, kReturnCode1);
     EXPECT_TRUE(destroy_complex_request);
   }
 
   for (size_t index = 0; index < arraysize(kRequestIDs2); ++index) {
     request.header.msgh_id = kRequestIDs2[index];
     SCOPED_TRACE(base::StringPrintf(
         "handler 2, index %zu, id %d", index, request.header.msgh_id));
 
     EXPECT_TRUE(server.MachMessageServerFunction(
         &request.header, &reply.Head, &destroy_complex_request));
-    EXPECT_EQ(kReturnCode2, reply.RetCode);
+    EXPECT_EQ(reply.RetCode, kReturnCode2);
     EXPECT_TRUE(destroy_complex_request);
   }
 }
 
 // CompositeMachMessageServer can’t deal with two handlers that want to handle
 // the same request ID.
 TEST(CompositeMachMessageServerDeathTest, DuplicateRequestID) {
   const mach_msg_id_t kRequestID = 400;
 
   TestMachMessageHandler handlers[2];
   handlers[0].AddRequestID(kRequestID);
   handlers[1].AddRequestID(kRequestID);
 
   CompositeMachMessageServer server;
 
   server.AddHandler(&handlers[0]);
   EXPECT_DEATH_CHECK(server.AddHandler(&handlers[1]), "duplicate request ID");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad