win: Fixes for minidump_misc_info_writer_test.cc

minidump/minidump_misc_info_writer_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,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "minidump/minidump_misc_info_writer.h"
 
 #include <windows.h>
 #include <dbghelp.h>
 #include <string.h>
 
 #include <string>
 
 #include "base/basictypes.h"
+#include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "gtest/gtest.h"
 #include "minidump/minidump_file_writer.h"
 #include "minidump/test/minidump_file_writer_test_util.h"
 #include "minidump/test/minidump_writable_test_util.h"
 #include "snapshot/test/test_process_snapshot.h"
 #include "snapshot/test/test_system_snapshot.h"
 #include "util/file/string_file_writer.h"
@@ skipping 58 matching lines @@
   EXPECT_EQ(expected->ProcessId, observed->ProcessId);
   EXPECT_EQ(expected->ProcessCreateTime, observed->ProcessCreateTime);
   EXPECT_EQ(expected->ProcessUserTime, observed->ProcessUserTime);
   EXPECT_EQ(expected->ProcessKernelTime, observed->ProcessKernelTime);
 }
 
 template <>
 void ExpectMiscInfoEqual<MINIDUMP_MISC_INFO_2>(
     const MINIDUMP_MISC_INFO_2* expected,
     const MINIDUMP_MISC_INFO_2* observed) {
-  ExpectMiscInfoEqual<MINIDUMP_MISC_INFO>(expected, observed);
+  ExpectMiscInfoEqual<MINIDUMP_MISC_INFO>(
+      reinterpret_cast<const MINIDUMP_MISC_INFO*>(expected),
+      reinterpret_cast<const MINIDUMP_MISC_INFO*>(observed));
   EXPECT_EQ(expected->ProcessorMaxMhz, observed->ProcessorMaxMhz);
   EXPECT_EQ(expected->ProcessorCurrentMhz, observed->ProcessorCurrentMhz);
   EXPECT_EQ(expected->ProcessorMhzLimit, observed->ProcessorMhzLimit);
   EXPECT_EQ(expected->ProcessorMaxIdleState, observed->ProcessorMaxIdleState);
   EXPECT_EQ(expected->ProcessorCurrentIdleState,
             observed->ProcessorCurrentIdleState);
 }
 
 template <>
 void ExpectMiscInfoEqual<MINIDUMP_MISC_INFO_3>(
     const MINIDUMP_MISC_INFO_3* expected,
     const MINIDUMP_MISC_INFO_3* observed) {
-  ExpectMiscInfoEqual<MINIDUMP_MISC_INFO_2>(expected, observed);
+  ExpectMiscInfoEqual<MINIDUMP_MISC_INFO_2>(
+      reinterpret_cast<const MINIDUMP_MISC_INFO_2*>(expected),
+      reinterpret_cast<const MINIDUMP_MISC_INFO_2*>(observed));
   EXPECT_EQ(expected->ProcessIntegrityLevel, observed->ProcessIntegrityLevel);
   EXPECT_EQ(expected->ProcessExecuteFlags, observed->ProcessExecuteFlags);
   EXPECT_EQ(expected->ProtectedProcess, observed->ProtectedProcess);
   EXPECT_EQ(expected->TimeZoneId, observed->TimeZoneId);
   EXPECT_EQ(expected->TimeZone.Bias, observed->TimeZone.Bias);
   {
     SCOPED_TRACE("Standard");
     ExpectNULPaddedString16Equal(expected->TimeZone.StandardName,
                                  observed->TimeZone.StandardName,
                                  arraysize(expected->TimeZone.StandardName));
     ExpectSystemTimeEqual(&expected->TimeZone.StandardDate,
                           &observed->TimeZone.StandardDate);
     EXPECT_EQ(expected->TimeZone.StandardBias, observed->TimeZone.StandardBias);
   }
   {
     SCOPED_TRACE("Daylight");
     ExpectNULPaddedString16Equal(expected->TimeZone.DaylightName,
                                  observed->TimeZone.DaylightName,
                                  arraysize(expected->TimeZone.DaylightName));
     ExpectSystemTimeEqual(&expected->TimeZone.DaylightDate,
                           &observed->TimeZone.DaylightDate);
     EXPECT_EQ(expected->TimeZone.DaylightBias, observed->TimeZone.DaylightBias);
   }
 }
 
 template <>
 void ExpectMiscInfoEqual<MINIDUMP_MISC_INFO_4>(
     const MINIDUMP_MISC_INFO_4* expected,
     const MINIDUMP_MISC_INFO_4* observed) {
-  ExpectMiscInfoEqual<MINIDUMP_MISC_INFO_3>(expected, observed);
+  ExpectMiscInfoEqual<MINIDUMP_MISC_INFO_3>(
+      reinterpret_cast<const MINIDUMP_MISC_INFO_3*>(expected),
+      reinterpret_cast<const MINIDUMP_MISC_INFO_3*>(observed));
   {
     SCOPED_TRACE("BuildString");
     ExpectNULPaddedString16Equal(expected->BuildString,
                                  observed->BuildString,
                                  arraysize(expected->BuildString));
   }
   {
     SCOPED_TRACE("DbgBldStr");
     ExpectNULPaddedString16Equal(expected->DbgBldStr,
                                  observed->DbgBldStr,
@@ skipping 229 matching lines @@
 
 TEST(MinidumpMiscInfoWriter, TimeZoneStringsOverflow) {
   // This test makes sure that the time zone name strings are truncated properly
   // to the widths of their fields.
 
   MinidumpFileWriter minidump_file_writer;
   auto misc_info_writer = make_scoped_ptr(new MinidumpMiscInfoWriter());
 
   const uint32_t kTimeZoneId = 2;
   const int32_t kBias = 300;
-  std::string standard_name(
-      arraysize(decltype(MINIDUMP_MISC_INFO_N::TimeZone)::StandardName) + 1,
-      's');
+  MINIDUMP_MISC_INFO_N tmp;
+  ALLOW_UNUSED_LOCAL(tmp);
+  std::string standard_name(arraysize(tmp.TimeZone.StandardName) + 1, 's');
   const int32_t kStandardBias = 0;
-  std::string daylight_name(
-      arraysize(decltype(MINIDUMP_MISC_INFO_N::TimeZone)::DaylightName), 'd');
+  std::string daylight_name(arraysize(tmp.TimeZone.DaylightName), 'd');
   const int32_t kDaylightBias = -60;
 
   // Test using kSystemTimeZero, because not all platforms will be able to
   // provide daylight saving time transition times.
   const SYSTEMTIME kSystemTimeZero = {};
 
   misc_info_writer->SetTimeZone(kTimeZoneId,
                                 kBias,
                                 standard_name,
                                 kSystemTimeZero,
@@ skipping 66 matching lines @@
   ExpectMiscInfoEqual(&expected, observed);
 }
 
 TEST(MinidumpMiscInfoWriter, BuildStringsOverflow) {
   // This test makes sure that the build strings are truncated properly to the
   // widths of their fields.
 
   MinidumpFileWriter minidump_file_writer;
   auto misc_info_writer = make_scoped_ptr(new MinidumpMiscInfoWriter());
 
-  std::string build_string(arraysize(MINIDUMP_MISC_INFO_N::BuildString) + 1,
-                           'B');
-  std::string debug_build_string(arraysize(MINIDUMP_MISC_INFO_N::DbgBldStr),
-                                 'D');
+  MINIDUMP_MISC_INFO_4 tmp;
+  ALLOW_UNUSED_LOCAL(tmp);
+  std::string build_string(arraysize(tmp.BuildString) + 1, 'B');
+  std::string debug_build_string(arraysize(tmp.DbgBldStr), 'D');
 
   misc_info_writer->SetBuildString(build_string, debug_build_string);
 
   minidump_file_writer.AddStream(misc_info_writer.Pass());
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   const MINIDUMP_MISC_INFO_4* observed;
   ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(file_writer.string(), &observed));
@@ skipping 162 matching lines @@
           arraysize(expect_misc_info.TimeZone.DaylightName));
   expect_misc_info.TimeZone.DaylightBias = -60;
   c16lcpy(expect_misc_info.BuildString,
           build_string_utf16.c_str(),
           arraysize(expect_misc_info.BuildString));
   c16lcpy(expect_misc_info.DbgBldStr,
           debug_build_string_utf16.c_str(),
           arraysize(expect_misc_info.DbgBldStr));
 
   const timeval kStartTime =
-      { implicit_cast<time_t>(expect_misc_info.ProcessCreateTime), 0 };
+      { static_cast<time_t>(expect_misc_info.ProcessCreateTime), 0 };
   const timeval kUserCPUTime =
-      { implicit_cast<time_t>(expect_misc_info.ProcessUserTime), 0 };
+      { static_cast<time_t>(expect_misc_info.ProcessUserTime), 0 };
   const timeval kSystemCPUTime =
-      { implicit_cast<time_t>(expect_misc_info.ProcessKernelTime), 0 };
+      { static_cast<time_t>(expect_misc_info.ProcessKernelTime), 0 };
 
   TestProcessSnapshot process_snapshot;
   process_snapshot.SetProcessID(expect_misc_info.ProcessId);
   process_snapshot.SetProcessStartTime(kStartTime);
   process_snapshot.SetProcessCPUTimes(kUserCPUTime, kSystemCPUTime);
 
   auto system_snapshot = make_scoped_ptr(new TestSystemSnapshot());
-  const uint64_t kHzPerMHz = 1E6;
+  const uint64_t kHzPerMHz = static_cast<uint64_t>(1E6);
   system_snapshot->SetCPUFrequency(
       expect_misc_info.ProcessorCurrentMhz * kHzPerMHz,
       expect_misc_info.ProcessorMaxMhz * kHzPerMHz);
   system_snapshot->SetTimeZone(SystemSnapshot::kObservingStandardTime,
                                expect_misc_info.TimeZone.Bias * -60,
                                (expect_misc_info.TimeZone.Bias +
                                 expect_misc_info.TimeZone.DaylightBias) * -60,
                                kStandardTimeName,
                                kDaylightTimeName);
   system_snapshot->SetOSVersionFull(kOSVersionFull);
@@ skipping 12 matching lines @@
 
   const MINIDUMP_MISC_INFO_4* misc_info;
   ASSERT_NO_FATAL_FAILURE(GetMiscInfoStream(file_writer.string(), &misc_info));
 
   ExpectMiscInfoEqual(&expect_misc_info, misc_info);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad