win: warning fixes in minidump_thread_writer_test.cc

minidump/minidump_thread_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,
@@ skipping 69 matching lines @@
 
   minidump_file_writer.AddStream(thread_list_writer.Pass());
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   ASSERT_EQ(sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_THREAD_LIST),
             file_writer.string().size());
 
-  const MINIDUMP_THREAD_LIST* thread_list;
+  const MINIDUMP_THREAD_LIST* thread_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
       GetThreadListStream(file_writer.string(), &thread_list, nullptr));
 
   EXPECT_EQ(0u, thread_list->NumberOfThreads);
 }
 
 // The MINIDUMP_THREADs |expected| and |observed| are compared against each
 // other using gtest assertions. If |stack| is not nullptr, |observed| is
 // expected to contain a populated MINIDUMP_MEMORY_DESCRIPTOR in its Stack
 // field, otherwise, its Stack field is expected to be zeroed out. The memory
@@ skipping 60 matching lines @@
   minidump_file_writer.AddStream(thread_list_writer.Pass());
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   ASSERT_EQ(sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_THREAD_LIST) + 1 * sizeof(MINIDUMP_THREAD) +
                 1 * sizeof(MinidumpContextX86),
             file_writer.string().size());
 
-  const MINIDUMP_THREAD_LIST* thread_list;
+  const MINIDUMP_THREAD_LIST* thread_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
       GetThreadListStream(file_writer.string(), &thread_list, nullptr));
 
   EXPECT_EQ(1u, thread_list->NumberOfThreads);
 
   MINIDUMP_THREAD expected = {};
   expected.ThreadId = kThreadID;
   expected.SuspendCount = kSuspendCount;
   expected.PriorityClass = kPriorityClass;
   expected.Priority = kPriority;
   expected.Teb = kTEB;
   expected.ThreadContext.DataSize = sizeof(MinidumpContextX86);
 
-  const MinidumpContextX86* observed_context;
+  const MinidumpContextX86* observed_context = nullptr;
   ASSERT_NO_FATAL_FAILURE(
       ExpectThread(&expected,
                    &thread_list->Threads[0],
                    file_writer.string(),
                    nullptr,
                    reinterpret_cast<const void**>(&observed_context)));
 
   ASSERT_NO_FATAL_FAILURE(
       ExpectMinidumpContextX86(kSeed, observed_context, false));
 }
@@ skipping 16 matching lines @@
   thread_writer->SetThreadID(kThreadID);
   thread_writer->SetSuspendCount(kSuspendCount);
   thread_writer->SetPriorityClass(kPriorityClass);
   thread_writer->SetPriority(kPriority);
   thread_writer->SetTEB(kTEB);
 
   auto memory_writer = make_scoped_ptr(
       new TestMinidumpMemoryWriter(kMemoryBase, kMemorySize, kMemoryValue));
   thread_writer->SetStack(memory_writer.Pass());
 
+  MSVC_SUPPRESS_WARNING(4316)  // Object allocated on heap may not be aligned.

[Mark Mentovai, 2015/02/05 18:21:31]

A semicolon will make this look a little more code-y and will be more easily
dealt with by fake parsers.

   auto context_amd64_writer = make_scoped_ptr(new MinidumpContextAMD64Writer());
   InitializeMinidumpContextAMD64(context_amd64_writer->context(), kSeed);
   thread_writer->SetContext(context_amd64_writer.Pass());
 
   thread_list_writer->AddThread(thread_writer.Pass());
   minidump_file_writer.AddStream(thread_list_writer.Pass());
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   ASSERT_EQ(sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_THREAD_LIST) + 1 * sizeof(MINIDUMP_THREAD) +
                 1 * sizeof(MinidumpContextAMD64) + kMemorySize,
             file_writer.string().size());
 
-  const MINIDUMP_THREAD_LIST* thread_list;
+  const MINIDUMP_THREAD_LIST* thread_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
       GetThreadListStream(file_writer.string(), &thread_list, nullptr));
 
   EXPECT_EQ(1u, thread_list->NumberOfThreads);
 
   MINIDUMP_THREAD expected = {};
   expected.ThreadId = kThreadID;
   expected.SuspendCount = kSuspendCount;
   expected.PriorityClass = kPriorityClass;
   expected.Priority = kPriority;
   expected.Teb = kTEB;
   expected.Stack.StartOfMemoryRange = kMemoryBase;
   expected.Stack.Memory.DataSize = kMemorySize;
   expected.ThreadContext.DataSize = sizeof(MinidumpContextAMD64);
 
-  const MINIDUMP_MEMORY_DESCRIPTOR* observed_stack;
-  const MinidumpContextAMD64* observed_context;
+  const MINIDUMP_MEMORY_DESCRIPTOR* observed_stack = nullptr;
+  const MinidumpContextAMD64* observed_context = nullptr;
   ASSERT_NO_FATAL_FAILURE(
       ExpectThread(&expected,
                    &thread_list->Threads[0],
                    file_writer.string(),
                    &observed_stack,
                    reinterpret_cast<const void**>(&observed_context)));
 
   ASSERT_NO_FATAL_FAILURE(
       ExpectMinidumpMemoryDescriptorAndContents(&expected.Stack,
                                                 observed_stack,
@@ skipping 98 matching lines @@
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   ASSERT_EQ(sizeof(MINIDUMP_HEADER) + 2 * sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_THREAD_LIST) + 3 * sizeof(MINIDUMP_THREAD) +
                 sizeof(MINIDUMP_MEMORY_LIST) +
                 3 * sizeof(MINIDUMP_MEMORY_DESCRIPTOR) +
                 3 * sizeof(MinidumpContextX86) + kMemorySize0 + kMemorySize1 +
                 kMemorySize2 + 12,  // 12 for alignment
             file_writer.string().size());
 
-  const MINIDUMP_THREAD_LIST* thread_list;
-  const MINIDUMP_MEMORY_LIST* memory_list;
+  const MINIDUMP_THREAD_LIST* thread_list = nullptr;
+  const MINIDUMP_MEMORY_LIST* memory_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
       GetThreadListStream(file_writer.string(), &thread_list, &memory_list));
 
   EXPECT_EQ(3u, thread_list->NumberOfThreads);
   EXPECT_EQ(3u, memory_list->NumberOfMemoryRanges);
 
   {
     SCOPED_TRACE("thread 0");
 
     MINIDUMP_THREAD expected = {};
     expected.ThreadId = kThreadID0;
     expected.SuspendCount = kSuspendCount0;
     expected.PriorityClass = kPriorityClass0;
     expected.Priority = kPriority0;
     expected.Teb = kTEB0;
     expected.Stack.StartOfMemoryRange = kMemoryBase0;
     expected.Stack.Memory.DataSize = kMemorySize0;
     expected.ThreadContext.DataSize = sizeof(MinidumpContextX86);
 
-    const MINIDUMP_MEMORY_DESCRIPTOR* observed_stack;
-    const MinidumpContextX86* observed_context;
+    const MINIDUMP_MEMORY_DESCRIPTOR* observed_stack = nullptr;
+    const MinidumpContextX86* observed_context = nullptr;
     ASSERT_NO_FATAL_FAILURE(
         ExpectThread(&expected,
                      &thread_list->Threads[0],
                      file_writer.string(),
                      &observed_stack,
                      reinterpret_cast<const void**>(&observed_context)));
 
     ASSERT_NO_FATAL_FAILURE(
         ExpectMinidumpMemoryDescriptorAndContents(&expected.Stack,
                                                   observed_stack,
@@ skipping 12 matching lines @@
     MINIDUMP_THREAD expected = {};
     expected.ThreadId = kThreadID1;
     expected.SuspendCount = kSuspendCount1;
     expected.PriorityClass = kPriorityClass1;
     expected.Priority = kPriority1;
     expected.Teb = kTEB1;
     expected.Stack.StartOfMemoryRange = kMemoryBase1;
     expected.Stack.Memory.DataSize = kMemorySize1;
     expected.ThreadContext.DataSize = sizeof(MinidumpContextX86);
 
-    const MINIDUMP_MEMORY_DESCRIPTOR* observed_stack;
-    const MinidumpContextX86* observed_context;
+    const MINIDUMP_MEMORY_DESCRIPTOR* observed_stack = nullptr;
+    const MinidumpContextX86* observed_context = nullptr;
     ASSERT_NO_FATAL_FAILURE(
         ExpectThread(&expected,
                      &thread_list->Threads[1],
                      file_writer.string(),
                      &observed_stack,
                      reinterpret_cast<const void**>(&observed_context)));
 
     ASSERT_NO_FATAL_FAILURE(
         ExpectMinidumpMemoryDescriptorAndContents(&expected.Stack,
                                                   observed_stack,
@@ skipping 12 matching lines @@
     MINIDUMP_THREAD expected = {};
     expected.ThreadId = kThreadID2;
     expected.SuspendCount = kSuspendCount2;
     expected.PriorityClass = kPriorityClass2;
     expected.Priority = kPriority2;
     expected.Teb = kTEB2;
     expected.Stack.StartOfMemoryRange = kMemoryBase2;
     expected.Stack.Memory.DataSize = kMemorySize2;
     expected.ThreadContext.DataSize = sizeof(MinidumpContextX86);
 
-    const MINIDUMP_MEMORY_DESCRIPTOR* observed_stack;
-    const MinidumpContextX86* observed_context;
+    const MINIDUMP_MEMORY_DESCRIPTOR* observed_stack = nullptr;
+    const MinidumpContextX86* observed_context = nullptr;
     ASSERT_NO_FATAL_FAILURE(
         ExpectThread(&expected,
                      &thread_list->Threads[2],
                      file_writer.string(),
                      &observed_stack,
                      reinterpret_cast<const void**>(&observed_context)));
 
     ASSERT_NO_FATAL_FAILURE(
         ExpectMinidumpMemoryDescriptorAndContents(&expected.Stack,
                                                   observed_stack,
@@ skipping 82 matching lines @@
     thread_ids[0] = 0x0123456700000001;
     thread_ids[1] = 0x89abcdef00000001;
     thread_ids[2] = 4;
     expect_threads[0].ThreadId = 0;
     expect_threads[1].ThreadId = 1;
     expect_threads[2].ThreadId = 2;
   } else {
     thread_ids[0] = 1;
     thread_ids[1] = 11;
     thread_ids[2] = 22;
-    expect_threads[0].ThreadId = thread_ids[0];
-    expect_threads[1].ThreadId = thread_ids[1];
-    expect_threads[2].ThreadId = thread_ids[2];
+    expect_threads[0].ThreadId = static_cast<uint32_t>(thread_ids[0]);
+    expect_threads[1].ThreadId = static_cast<uint32_t>(thread_ids[1]);
+    expect_threads[2].ThreadId = static_cast<uint32_t>(thread_ids[2]);
   }
 
   PointerVector<TestThreadSnapshot> thread_snapshots_owner;
   std::vector<const ThreadSnapshot*> thread_snapshots;
   for (size_t index = 0; index < arraysize(expect_threads); ++index) {
     TestThreadSnapshot* thread_snapshot = new TestThreadSnapshot();
     thread_snapshots_owner.push_back(thread_snapshot);
 
     thread_snapshot->SetThreadID(thread_ids[index]);
     thread_snapshot->SetSuspendCount(expect_threads[index].SuspendCount);
@@ skipping 21 matching lines @@
   MinidumpThreadIDMap thread_id_map;
   thread_list_writer->InitializeFromSnapshot(thread_snapshots, &thread_id_map);
 
   MinidumpFileWriter minidump_file_writer;
   minidump_file_writer.AddStream(thread_list_writer.Pass());
   minidump_file_writer.AddStream(memory_list_writer.Pass());
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
-  const MINIDUMP_THREAD_LIST* thread_list;
-  const MINIDUMP_MEMORY_LIST* memory_list;
+  const MINIDUMP_THREAD_LIST* thread_list = nullptr;
+  const MINIDUMP_MEMORY_LIST* memory_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
       GetThreadListStream(file_writer.string(), &thread_list, &memory_list));
 
   ASSERT_EQ(3u, thread_list->NumberOfThreads);
   ASSERT_EQ(2u, memory_list->NumberOfMemoryRanges);
 
   size_t memory_index = 0;
   for (size_t index = 0; index < thread_list->NumberOfThreads; ++index) {
     SCOPED_TRACE(base::StringPrintf("index %zu", index));
 
-    const MINIDUMP_MEMORY_DESCRIPTOR* observed_stack;
+    const MINIDUMP_MEMORY_DESCRIPTOR* observed_stack = nullptr;
     const MINIDUMP_MEMORY_DESCRIPTOR** observed_stack_p =
         expect_threads[index].Stack.Memory.DataSize ? &observed_stack : nullptr;
-    const MinidumpContextType* observed_context;
+    const MinidumpContextType* observed_context = nullptr;
     ASSERT_NO_FATAL_FAILURE(
         ExpectThread(&expect_threads[index],
                      &thread_list->Threads[index],
                      file_writer.string(),
                      observed_stack_p,
                      reinterpret_cast<const void**>(&observed_context)));
 
     ASSERT_NO_FATAL_FAILURE(Traits::ExpectMinidumpContext(
         context_seeds[index], observed_context, true));
 
@@ skipping 40 matching lines @@
 
 TEST(MinidumpThreadWriterDeathTest, InitializeFromSnapshot_NoContext) {
   ASSERT_DEATH(
       RunInitializeFromSnapshotTest<InitializeFromSnapshotNoContextTraits>(
           false), "context_");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad