ExcServerVariants test: use constructors to initialize test structures

util/mach/exc_server_variants_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 59 matching lines @@
 }
 
 // The definitions of the request and reply structures from mach_exc.h aren’t
 // available here. They need custom initialization code, and the reply
 // structures need verification code too, so duplicate the expected definitions
 // of the structures from both exc.h and mach_exc.h here in this file, and
 // provide the initialization and verification code as methods in true
 // object-oriented fashion.
 
 struct __attribute__((packed, aligned(4))) ExceptionRaiseRequest {
-  mach_msg_header_t Head;
-  mach_msg_body_t msgh_body;
-  mach_msg_port_descriptor_t thread;
-  mach_msg_port_descriptor_t task;
-  NDR_record_t NDR;
-  exception_type_t exception;
-  mach_msg_type_number_t codeCnt;
-  integer_t code[2];
-
-  void InitializeForTesting() {
+  ExceptionRaiseRequest() {
     memset(this, 0xa5, sizeof(*this));
     Head.msgh_bits =
         MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND) |
         MACH_MSGH_BITS_COMPLEX;
     Head.msgh_size = sizeof(*this);
     Head.msgh_remote_port = kClientRemotePort;
     Head.msgh_local_port = kServerLocalPort;
     Head.msgh_id = 2401;
     msgh_body.msgh_descriptor_count = 2;
     InitializeMachMsgPortDescriptor(&thread, kExceptionThreadPort);
     InitializeMachMsgPortDescriptor(&task, kExceptionTaskPort);
     NDR = NDR_record;
     exception = kExceptionType;
     codeCnt = 2;
     code[0] = kTestExceptonCodes[0];
     code[1] = kTestExceptonCodes[1];
   }
+
+  mach_msg_header_t Head;
+  mach_msg_body_t msgh_body;
+  mach_msg_port_descriptor_t thread;
+  mach_msg_port_descriptor_t task;
+  NDR_record_t NDR;
+  exception_type_t exception;
+  mach_msg_type_number_t codeCnt;
+  integer_t code[2];
 };
 
 struct __attribute__((packed, aligned(4))) ExceptionRaiseReply {
-  mach_msg_header_t Head;
-  NDR_record_t NDR;
-  kern_return_t RetCode;
-
-  void InitializeForTesting() {
+  ExceptionRaiseReply() {
     memset(this, 0x5a, sizeof(*this));
     RetCode = KERN_FAILURE;
   }
 
   // Verify accepts a |behavior| parameter because the same message format and
   // verification function is used for ExceptionRaiseReply and
   // MachExceptionRaiseReply. Knowing which behavior is expected allows the
   // message ID to be checked.
   void Verify(exception_behavior_t behavior) {
     EXPECT_EQ(implicit_cast<mach_msg_bits_t>(
@@ skipping 10 matching lines @@
         EXPECT_EQ(2505, Head.msgh_id);
         break;
       default:
         ADD_FAILURE() << "behavior " << behavior << ", Head.msgh_id "
                       << Head.msgh_id;
         break;
     }
     EXPECT_EQ(0, memcmp(&NDR, &NDR_record, sizeof(NDR)));
     EXPECT_EQ(KERN_SUCCESS, RetCode);
   }
+
+  mach_msg_header_t Head;
+  NDR_record_t NDR;
+  kern_return_t RetCode;
 };
 
 struct __attribute__((packed, aligned(4))) ExceptionRaiseStateRequest {
-  mach_msg_header_t Head;
-  NDR_record_t NDR;
-  exception_type_t exception;
-  mach_msg_type_number_t codeCnt;
-  integer_t code[2];
-  int flavor;
-  mach_msg_type_number_t old_stateCnt;
-  natural_t old_state[THREAD_STATE_MAX];
-
-  void InitializeForTesting() {
+  ExceptionRaiseStateRequest() {
     memset(this, 0xa5, sizeof(*this));
     Head.msgh_bits =
         MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND);
     Head.msgh_size = sizeof(*this);
     Head.msgh_remote_port = kClientRemotePort;
     Head.msgh_local_port = kServerLocalPort;
     Head.msgh_id = 2402;
     NDR = NDR_record;
     exception = kExceptionType;
     codeCnt = 2;
     code[0] = kTestExceptonCodes[0];
     code[1] = kTestExceptonCodes[1];
     flavor = kThreadStateFlavor;
     old_stateCnt = kThreadStateFlavorCount;
 
     // Adjust the message size for the data that it’s actually carrying, which
     // may be smaller than the maximum that it can carry.
     Head.msgh_size += sizeof(old_state[0]) * old_stateCnt - sizeof(old_state);
   }
+
+  mach_msg_header_t Head;
+  NDR_record_t NDR;
+  exception_type_t exception;
+  mach_msg_type_number_t codeCnt;
+  integer_t code[2];
+  int flavor;
+  mach_msg_type_number_t old_stateCnt;
+  natural_t old_state[THREAD_STATE_MAX];
 };
 
 struct __attribute__((packed, aligned(4))) ExceptionRaiseStateReply {
-  mach_msg_header_t Head;
-  NDR_record_t NDR;
-  kern_return_t RetCode;
-  int flavor;
-  mach_msg_type_number_t new_stateCnt;
-  natural_t new_state[THREAD_STATE_MAX];
-
-  void InitializeForTesting() {
+  ExceptionRaiseStateReply() {
     memset(this, 0x5a, sizeof(*this));
     RetCode = KERN_FAILURE;
   }
 
   // Verify accepts a |behavior| parameter because the same message format and
   // verification function is used for ExceptionRaiseStateReply,
   // ExceptionRaiseStateIdentityReply, MachExceptionRaiseStateReply, and
   // MachExceptionRaiseStateIdentityReply. Knowing which behavior is expected
   // allows the message ID to be checked.
   void Verify(exception_behavior_t behavior) {
@@ skipping 19 matching lines @@
       default:
         ADD_FAILURE() << "behavior " << behavior << ", Head.msgh_id "
                       << Head.msgh_id;
         break;
     }
     EXPECT_EQ(0, memcmp(&NDR, &NDR_record, sizeof(NDR)));
     EXPECT_EQ(KERN_SUCCESS, RetCode);
     EXPECT_EQ(kThreadStateFlavor, flavor);
     EXPECT_EQ(arraysize(new_state), new_stateCnt);
   }
+
+  mach_msg_header_t Head;
+  NDR_record_t NDR;
+  kern_return_t RetCode;
+  int flavor;
+  mach_msg_type_number_t new_stateCnt;
+  natural_t new_state[THREAD_STATE_MAX];
 };
 
 struct __attribute__((packed, aligned(4))) ExceptionRaiseStateIdentityRequest {
-  mach_msg_header_t Head;
-  mach_msg_body_t msgh_body;
-  mach_msg_port_descriptor_t thread;
-  mach_msg_port_descriptor_t task;
-  NDR_record_t NDR;
-  exception_type_t exception;
-  mach_msg_type_number_t codeCnt;
-  integer_t code[2];
-  int flavor;
-  mach_msg_type_number_t old_stateCnt;
-  natural_t old_state[THREAD_STATE_MAX];
-
-  void InitializeForTesting() {
+  ExceptionRaiseStateIdentityRequest() {
     memset(this, 0xa5, sizeof(*this));
     Head.msgh_bits =
         MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND) |
         MACH_MSGH_BITS_COMPLEX;
     Head.msgh_size = sizeof(*this);
     Head.msgh_remote_port = kClientRemotePort;
     Head.msgh_local_port = kServerLocalPort;
     Head.msgh_id = 2403;
     msgh_body.msgh_descriptor_count = 2;
     InitializeMachMsgPortDescriptor(&thread, kExceptionThreadPort);
     InitializeMachMsgPortDescriptor(&task, kExceptionTaskPort);
     NDR = NDR_record;
     exception = kExceptionType;
     codeCnt = 2;
     code[0] = kTestExceptonCodes[0];
     code[1] = kTestExceptonCodes[1];
     flavor = kThreadStateFlavor;
     old_stateCnt = kThreadStateFlavorCount;
 
     // Adjust the message size for the data that it’s actually carrying, which
     // may be smaller than the maximum that it can carry.
     Head.msgh_size += sizeof(old_state[0]) * old_stateCnt - sizeof(old_state);
   }
-};
 
-// The reply messages for exception_raise_state and
-// exception_raise_state_identity are identical.
-using ExceptionRaiseStateIdentityReply = ExceptionRaiseStateReply;
-
-struct __attribute__((packed, aligned(4))) MachExceptionRaiseRequest {
   mach_msg_header_t Head;
   mach_msg_body_t msgh_body;
   mach_msg_port_descriptor_t thread;
   mach_msg_port_descriptor_t task;
   NDR_record_t NDR;
   exception_type_t exception;
   mach_msg_type_number_t codeCnt;
-  int64_t code[2];
+  integer_t code[2];
+  int flavor;
+  mach_msg_type_number_t old_stateCnt;
+  natural_t old_state[THREAD_STATE_MAX];
+};
 
-  void InitializeForTesting() {
+// The reply messages for exception_raise_state and
+// exception_raise_state_identity are identical.
+using ExceptionRaiseStateIdentityReply = ExceptionRaiseStateReply;
+
+struct __attribute__((packed, aligned(4))) MachExceptionRaiseRequest {
+  MachExceptionRaiseRequest() {
     memset(this, 0xa5, sizeof(*this));
     Head.msgh_bits =
         MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND) |
         MACH_MSGH_BITS_COMPLEX;
     Head.msgh_size = sizeof(*this);
     Head.msgh_remote_port = kClientRemotePort;
     Head.msgh_local_port = kServerLocalPort;
     Head.msgh_id = 2405;
     msgh_body.msgh_descriptor_count = 2;
     InitializeMachMsgPortDescriptor(&thread, kExceptionThreadPort);
     InitializeMachMsgPortDescriptor(&task, kExceptionTaskPort);
     NDR = NDR_record;
     exception = kExceptionType;
     codeCnt = 2;
     code[0] = kTestMachExceptionCodes[0];
     code[1] = kTestMachExceptionCodes[1];
   }
+
+  mach_msg_header_t Head;
+  mach_msg_body_t msgh_body;
+  mach_msg_port_descriptor_t thread;
+  mach_msg_port_descriptor_t task;
+  NDR_record_t NDR;
+  exception_type_t exception;
+  mach_msg_type_number_t codeCnt;
+  int64_t code[2];
 };
 
 // The reply messages for exception_raise and mach_exception_raise are
 // identical.
 using MachExceptionRaiseReply = ExceptionRaiseReply;
 
 struct __attribute__((packed, aligned(4))) MachExceptionRaiseStateRequest {
-  mach_msg_header_t Head;
-  NDR_record_t NDR;
-  exception_type_t exception;
-  mach_msg_type_number_t codeCnt;
-  int64_t code[2];
-  int flavor;
-  mach_msg_type_number_t old_stateCnt;
-  natural_t old_state[THREAD_STATE_MAX];
-
-  void InitializeForTesting() {
+  MachExceptionRaiseStateRequest() {
     memset(this, 0xa5, sizeof(*this));
     Head.msgh_bits =
         MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND);
     Head.msgh_size = sizeof(*this);
     Head.msgh_remote_port = kClientRemotePort;
     Head.msgh_local_port = kServerLocalPort;
     Head.msgh_id = 2406;
     NDR = NDR_record;
     exception = kExceptionType;
     codeCnt = 2;
     code[0] = kTestMachExceptionCodes[0];
     code[1] = kTestMachExceptionCodes[1];
     flavor = kThreadStateFlavor;
     old_stateCnt = kThreadStateFlavorCount;
 
     // Adjust the message size for the data that it’s actually carrying, which
     // may be smaller than the maximum that it can carry.
     Head.msgh_size += sizeof(old_state[0]) * old_stateCnt - sizeof(old_state);
   }
-};
 
-// The reply messages for exception_raise_state and mach_exception_raise_state
-// are identical.
-using MachExceptionRaiseStateReply = ExceptionRaiseStateReply;
-
-struct __attribute__((packed,
-                      aligned(4))) MachExceptionRaiseStateIdentityRequest {
   mach_msg_header_t Head;
-  mach_msg_body_t msgh_body;
-  mach_msg_port_descriptor_t thread;
-  mach_msg_port_descriptor_t task;
   NDR_record_t NDR;
   exception_type_t exception;
   mach_msg_type_number_t codeCnt;
   int64_t code[2];
   int flavor;
   mach_msg_type_number_t old_stateCnt;
   natural_t old_state[THREAD_STATE_MAX];
+};
 
-  void InitializeForTesting() {
+// The reply messages for exception_raise_state and mach_exception_raise_state
+// are identical.
+using MachExceptionRaiseStateReply = ExceptionRaiseStateReply;
+
+struct __attribute__((packed,
+                      aligned(4))) MachExceptionRaiseStateIdentityRequest {
+  MachExceptionRaiseStateIdentityRequest() {
     memset(this, 0xa5, sizeof(*this));
     Head.msgh_bits =
         MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND) |
         MACH_MSGH_BITS_COMPLEX;
     Head.msgh_size = sizeof(*this);
     Head.msgh_remote_port = kClientRemotePort;
     Head.msgh_local_port = kServerLocalPort;
     Head.msgh_id = 2407;
     msgh_body.msgh_descriptor_count = 2;
     InitializeMachMsgPortDescriptor(&thread, kExceptionThreadPort);
     InitializeMachMsgPortDescriptor(&task, kExceptionTaskPort);
     NDR = NDR_record;
     exception = kExceptionType;
     codeCnt = 2;
     code[0] = kTestMachExceptionCodes[0];
     code[1] = kTestMachExceptionCodes[1];
     flavor = kThreadStateFlavor;
     old_stateCnt = kThreadStateFlavorCount;
 
     // Adjust the message size for the data that it’s actually carrying, which
     // may be smaller than the maximum that it can carry.
     Head.msgh_size += sizeof(old_state[0]) * old_stateCnt - sizeof(old_state);
   }
+
+  mach_msg_header_t Head;
+  mach_msg_body_t msgh_body;
+  mach_msg_port_descriptor_t thread;
+  mach_msg_port_descriptor_t task;
+  NDR_record_t NDR;
+  exception_type_t exception;
+  mach_msg_type_number_t codeCnt;
+  int64_t code[2];
+  int flavor;
+  mach_msg_type_number_t old_stateCnt;
+  natural_t old_state[THREAD_STATE_MAX];
 };
 
 // The reply messages for exception_raise_state_identity and
 // mach_exception_raise_state_identity are identical.
 using MachExceptionRaiseStateIdentityReply = ExceptionRaiseStateIdentityReply;
 
 // InvalidRequest and BadIDErrorReply are used to test that
 // UniversalMachExcServer deals appropriately with messages that it does not
 // understand: messages with an unknown Head.msgh_id.
 
-struct __attribute__((packed, aligned(4))) InvalidRequest
-    : public mach_msg_empty_send_t {
-  void InitializeForTesting(mach_msg_id_t id) {
+struct InvalidRequest : public mach_msg_empty_send_t {
+  explicit InvalidRequest(mach_msg_id_t id) {
     memset(this, 0xa5, sizeof(*this));
     header.msgh_bits =
         MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND);
     header.msgh_size = sizeof(*this);
     header.msgh_remote_port = kClientRemotePort;
     header.msgh_local_port = kServerLocalPort;
     header.msgh_id = id;
   }
 };
 
-struct __attribute__((packed, aligned(4))) BadIDErrorReply
-    : public mig_reply_error_t {
-  void InitializeForTesting() {
+struct BadIDErrorReply : public mig_reply_error_t {
+  BadIDErrorReply() {
     memset(this, 0x5a, sizeof(*this));
     RetCode = KERN_FAILURE;
   }
 
   void Verify(mach_msg_id_t id) {
     EXPECT_EQ(implicit_cast<mach_msg_bits_t>(
                   MACH_MSGH_BITS(MACH_MSG_TYPE_MOVE_SEND_ONCE, 0)),
               Head.msgh_bits);
     EXPECT_EQ(sizeof(*this), Head.msgh_size);
     EXPECT_EQ(kClientRemotePort, Head.msgh_remote_port);
@@ skipping 128 matching lines @@
   ~ScopedDefaultValue() { DefaultValue<T>::Clear(); }
 };
 
 TEST(ExcServerVariants, MockExceptionRaise) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
 
   ExceptionRaiseRequest request;
   EXPECT_LE(sizeof(request), server.MachMessageServerRequestSize());
-  request.InitializeForTesting();
 
   ExceptionRaiseReply reply;
   EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
-  reply.InitializeForTesting();
 
   const exception_behavior_t kExceptionBehavior = EXCEPTION_DEFAULT;
 
   EXPECT_CALL(server,
               MockCatchMachException(kExceptionBehavior,
                                      kServerLocalPort,
                                      kExceptionThreadPort,
                                      kExceptionTaskPort,
                                      kExceptionType,
                                      AreExceptionCodes(kTestExceptonCodes[0],
@@ skipping 14 matching lines @@
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockExceptionRaiseState) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
 
   ExceptionRaiseStateRequest request;
   EXPECT_LE(sizeof(request), server.MachMessageServerRequestSize());
-  request.InitializeForTesting();
 
   ExceptionRaiseStateReply reply;
   EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
-  reply.InitializeForTesting();
 
   const exception_behavior_t kExceptionBehavior = EXCEPTION_STATE;
 
   EXPECT_CALL(
       server,
       MockCatchMachException(
           kExceptionBehavior,
           kServerLocalPort,
           THREAD_NULL,
           TASK_NULL,
@@ skipping 18 matching lines @@
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockExceptionRaiseStateIdentity) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
 
   ExceptionRaiseStateIdentityRequest request;
   EXPECT_LE(sizeof(request), server.MachMessageServerRequestSize());
-  request.InitializeForTesting();
 
   ExceptionRaiseStateIdentityReply reply;
   EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
-  reply.InitializeForTesting();
 
   const exception_behavior_t kExceptionBehavior = EXCEPTION_STATE_IDENTITY;
 
   EXPECT_CALL(
       server,
       MockCatchMachException(
           kExceptionBehavior,
           kServerLocalPort,
           kExceptionThreadPort,
           kExceptionTaskPort,
@@ skipping 15 matching lines @@
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockMachExceptionRaise) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
 
   MachExceptionRaiseRequest request;
   EXPECT_LE(sizeof(request), server.MachMessageServerRequestSize());
-  request.InitializeForTesting();
 
   MachExceptionRaiseReply reply;
   EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
-  reply.InitializeForTesting();
 
   const exception_behavior_t kExceptionBehavior =
       EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES;
 
   EXPECT_CALL(
       server,
       MockCatchMachException(kExceptionBehavior,
                              kServerLocalPort,
                              kExceptionThreadPort,
                              kExceptionTaskPort,
@@ skipping 16 matching lines @@
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockMachExceptionRaiseState) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
 
   MachExceptionRaiseStateRequest request;
   EXPECT_LE(sizeof(request), server.MachMessageServerRequestSize());
-  request.InitializeForTesting();
 
   MachExceptionRaiseStateReply reply;
   EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
-  reply.InitializeForTesting();
 
   const exception_behavior_t kExceptionBehavior =
       EXCEPTION_STATE | MACH_EXCEPTION_CODES;
 
   EXPECT_CALL(
       server,
       MockCatchMachException(kExceptionBehavior,
                              kServerLocalPort,
                              THREAD_NULL,
                              TASK_NULL,
@@ skipping 19 matching lines @@
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockMachExceptionRaiseStateIdentity) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
 
   MachExceptionRaiseStateIdentityRequest request;
   EXPECT_LE(sizeof(request), server.MachMessageServerRequestSize());
-  request.InitializeForTesting();
 
   MachExceptionRaiseStateIdentityReply reply;
   EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
-  reply.InitializeForTesting();
 
   const exception_behavior_t kExceptionBehavior =
       EXCEPTION_STATE_IDENTITY | MACH_EXCEPTION_CODES;
 
   EXPECT_CALL(
       server,
       MockCatchMachException(kExceptionBehavior,
                              kServerLocalPort,
                              kExceptionThreadPort,
                              kExceptionTaskPort,
@@ skipping 52 matching lines @@
       2506,
       2507,
       2508,
   };
 
   for (size_t index = 0; index < arraysize(unknown_ids); ++index) {
     mach_msg_id_t id = unknown_ids[index];
 
     SCOPED_TRACE(base::StringPrintf("unknown id %d", id));
 
-    InvalidRequest request;
+    InvalidRequest request(id);
     EXPECT_LE(sizeof(request), server.MachMessageServerRequestSize());
-    request.InitializeForTesting(id);
 
     BadIDErrorReply reply;
     EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
-    reply.InitializeForTesting();
 
     bool destroy_complex_request = false;
     EXPECT_FALSE(server.MachMessageServerFunction(
         reinterpret_cast<mach_msg_header_t*>(&request),
         reinterpret_cast<mach_msg_header_t*>(&reply),
         &destroy_complex_request));
 
     // The request wasn’t handled, nothing got a chance to change the value of
     // this variable. MachMessageServer would destroy the request if it was
     // complex, regardless of what was done to this variable, because the
@@ skipping 313 matching lines @@
 
     EXPECT_EQ(test_data.kr,
               ExcServerSuccessfulReturnValue(test_data.behavior,
                                              test_data.set_thread_state));
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad