Use EXPECT_STREQ(a, b) when a and b are both const char*

util/mach/exception_ports_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 343 matching lines @@
     // Wait for the child process to be ready. It needs to have all of its
     // threads set up before proceeding if in kSetOutOfProcess mode.
     char c;
     CheckedReadFile(ReadPipeHandle(), &c, 1);
     EXPECT_EQ('\0', c);
 
     mach_port_t local_port = LocalPort();
 
     // Get an ExceptionPorts object for the task and each of its threads.
     ExceptionPorts task_ports(ExceptionPorts::kTargetTypeTask, ChildTask());
-    EXPECT_EQ("task", task_ports.TargetTypeName());
+    EXPECT_STREQ("task", task_ports.TargetTypeName());
 
     // Hopefully the threads returned by task_threads() are in order, with the
     // main thread first and the other thread second. This is currently always
     // the case, although nothing guarantees that it will remain so.
     thread_act_array_t threads;
     mach_msg_type_number_t thread_count = 0;
     kern_return_t kr = task_threads(ChildTask(), &threads, &thread_count);
     ASSERT_EQ(KERN_SUCCESS, kr) << MachErrorMessage(kr, "task_threads");
 
     ScopedForbidReturn threads_need_owners;
     ASSERT_EQ(2u, thread_count);
     base::mac::ScopedMachSendRight main_thread(threads[0]);
     base::mac::ScopedMachSendRight other_thread(threads[1]);
     threads_need_owners.Disarm();
 
     ExceptionPorts main_thread_ports(ExceptionPorts::kTargetTypeThread,
                                      main_thread);
     ExceptionPorts other_thread_ports(ExceptionPorts::kTargetTypeThread,
                                       other_thread);
-    EXPECT_EQ("thread", main_thread_ports.TargetTypeName());
-    EXPECT_EQ("thread", other_thread_ports.TargetTypeName());
+    EXPECT_STREQ("thread", main_thread_ports.TargetTypeName());
+    EXPECT_STREQ("thread", other_thread_ports.TargetTypeName());
 
     if (set_type_ == kSetOutOfProcess) {
       // Test ExceptionPorts::SetExceptionPorts() being called from
       // out-of-process.
       //
       // local_port is only a receive right, but a send right is needed for
       // ExceptionPorts::SetExceptionPort(). Make a send right, which can be
       // deallocated once the calls to ExceptionPorts::SetExceptionPort() are
       // done.
       kr = mach_port_insert_right(
@@ skipping 184 matching lines @@
   // ExceptionPorts isn’t expected to work as non-root. Just do a quick test to
   // make sure that TargetTypeName() returns the right string, and that the
   // underlying host_get_exception_ports() function appears to be called by
   // looking for a KERN_INVALID_ARGUMENT return value. Or, on the off chance
   // that the test is being run as root, just look for KERN_SUCCESS.
   // host_set_exception_ports() is not tested, because if the test were running
   // as root and the call succeeded, it would have global effects.
 
   base::mac::ScopedMachSendRight host(mach_host_self());
   ExceptionPorts explicit_host_ports(ExceptionPorts::kTargetTypeHost, host);
-  EXPECT_EQ("host", explicit_host_ports.TargetTypeName());
+  EXPECT_STREQ("host", explicit_host_ports.TargetTypeName());
 
   std::vector<ExceptionPorts::ExceptionHandler> handlers;
   bool rv = explicit_host_ports.GetExceptionPorts(
       ExcMaskAll() | EXC_MASK_CRASH, &handlers);
   if (geteuid() == 0) {
     EXPECT_TRUE(rv);
   } else {
     EXPECT_FALSE(rv);
   }
 
   ExceptionPorts implicit_host_ports(ExceptionPorts::kTargetTypeHost,
                                      HOST_NULL);
-  EXPECT_EQ("host", implicit_host_ports.TargetTypeName());
+  EXPECT_STREQ("host", implicit_host_ports.TargetTypeName());
 
   rv = implicit_host_ports.GetExceptionPorts(
       ExcMaskAll() | EXC_MASK_CRASH, &handlers);
   if (geteuid() == 0) {
     EXPECT_TRUE(rv);
   } else {
     EXPECT_FALSE(rv);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad