win: Fixes for minidump_string_writer_test.cc

minidump/minidump_string_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_string_writer.h"
 
 #include <windows.h>
 #include <dbghelp.h>
 #include <sys/types.h>
 
 #include <string>
 
 #include "base/basictypes.h"
+#include "base/compiler_specific.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "gtest/gtest.h"
 #include "minidump/test/minidump_rva_list_test_util.h"
 #include "minidump/test/minidump_string_writer_test_util.h"
 #include "minidump/test/minidump_writable_test_util.h"
 #include "util/file/string_file_writer.h"
 
 namespace crashpad {
@@ skipping 14 matching lines @@
         MinidumpStringAtRVA(file_writer.string(), 0);
     EXPECT_TRUE(minidump_string);
     EXPECT_EQ(base::string16(),
               MinidumpStringAtRVAAsString(file_writer.string(), 0));
   }
 
   const struct {
     size_t input_length;
     const char* input_string;
     size_t output_length;
-    const base::char16 output_string[10];
+    base::char16 output_string[10];

[Mark Mentovai, 2015/02/05 17:14:52]

Yeah, this is better. The data should be const enough because of the “const” on
line 55 anyway.

   } kTestData[] = {
       {0, "", 0, {}},
       {1, "a", 1, {'a'}},
       {2, "\0b", 2, {0, 'b'}},
       {3, "cde", 3, {'c', 'd', 'e'}},
       {9, "Hi world!", 9, {'H', 'i', ' ', 'w', 'o', 'r', 'l', 'd', '!'}},
       {7, "ret\nurn", 7, {'r', 'e', 't', '\n', 'u', 'r', 'n'}},
       {2, "\303\251", 1, {0x00e9}},  // é
 
       // oóöőo
@@ skipping 13 matching lines @@
             .output_string[arraysize(kTestData[index].output_string) - 1]);
 
     file_writer.Reset();
     crashpad::internal::MinidumpUTF16StringWriter string_writer;
     string_writer.SetUTF8(std::string(kTestData[index].input_string,
                                       kTestData[index].input_length));
     EXPECT_TRUE(string_writer.WriteEverything(&file_writer));
 
     const size_t expected_utf16_units_with_nul =
         kTestData[index].output_length + 1;
+    MINIDUMP_STRING tmp = {0};

[Mark Mentovai, 2015/02/05 17:14:52]

Is the initialization required? Line 138 too.

[scottmg, 2015/02/05 17:41:57]

Yes, because of zero-sized array (same as
https://codereview.chromium.org/886143004/).

+    ALLOW_UNUSED_LOCAL(tmp);
     const size_t expected_utf16_bytes =
-        expected_utf16_units_with_nul * sizeof(MINIDUMP_STRING::Buffer[0]);
+        expected_utf16_units_with_nul * sizeof(tmp.Buffer[0]);
     ASSERT_EQ(sizeof(MINIDUMP_STRING) + expected_utf16_bytes,
               file_writer.string().size());
 
     const MINIDUMP_STRING* minidump_string =
         MinidumpStringAtRVA(file_writer.string(), 0);
     EXPECT_TRUE(minidump_string);
     base::string16 expect_string = base::string16(
         kTestData[index].output_string, kTestData[index].output_length);
     EXPECT_EQ(expect_string,
               MinidumpStringAtRVAAsString(file_writer.string(), 0));
@@ skipping 21 matching lines @@
     EXPECT_TRUE(string_writer.WriteEverything(&file_writer));
 
     // The requirements for conversion of invalid UTF-8 input are lax. Make sure
     // that at least enough data was written for a string that has one unit and
     // a NUL terminator, make sure that the length field matches the length of
     // data written, and make sure that at least one U+FFFD replacement
     // character was written.
     const MINIDUMP_STRING* minidump_string =
         MinidumpStringAtRVA(file_writer.string(), 0);
     EXPECT_TRUE(minidump_string);
+    MINIDUMP_STRING tmp = {0};
+    ALLOW_UNUSED_LOCAL(tmp);
     EXPECT_EQ(file_writer.string().size() - sizeof(MINIDUMP_STRING) -
-                  sizeof(MINIDUMP_STRING::Buffer[0]),
+                  sizeof(tmp.Buffer[0]),
               minidump_string->Length);
     base::string16 output_string =
         MinidumpStringAtRVAAsString(file_writer.string(), 0);
     EXPECT_FALSE(output_string.empty());
     EXPECT_NE(base::string16::npos, output_string.find(0xfffd));
   }
 }
 
 TEST(MinidumpStringWriter, MinidumpUTF8StringWriter) {
   StringFileWriter file_writer;
@@ skipping 106 matching lines @@
   MinidumpStringListTest<MinidumpUTF16StringListWriterTraits>();
 }
 
 TEST(MinidumpStringWriter, MinidumpUTF8StringList) {
   MinidumpStringListTest<MinidumpUTF8StringListWriterTraits>();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad