minidump: Use variable names in tests that match parallel array indices

minidump/minidump_memory_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 116 matching lines @@
                                             &memory_list->MemoryRanges[0],
                                             file_writer.string(),
                                             kValue,
                                             true);
 }
 
 TEST(MinidumpMemoryWriter, TwoMemoryRegions) {
   MinidumpFileWriter minidump_file_writer;
   MinidumpMemoryListWriter memory_list_writer;
 
-  const uint64_t kBaseAddress1 = 0xc0ffee;
-  const uint64_t kSize1 = 0x0100;
-  const uint8_t kValue1 = '6';
-  const uint64_t kBaseAddress2 = 0xfac00fac;
-  const uint64_t kSize2 = 0x0200;
-  const uint8_t kValue2 = '!';
+  const uint64_t kBaseAddress0 = 0xc0ffee;
+  const uint64_t kSize0 = 0x0100;
+  const uint8_t kValue0 = '6';
+  const uint64_t kBaseAddress1 = 0xfac00fac;
+  const uint64_t kSize1 = 0x0200;
+  const uint8_t kValue1 = '!';
 
+  TestMinidumpMemoryWriter memory_writer_0(kBaseAddress0, kSize0, kValue0);
+  memory_list_writer.AddMemory(&memory_writer_0);
   TestMinidumpMemoryWriter memory_writer_1(kBaseAddress1, kSize1, kValue1);
   memory_list_writer.AddMemory(&memory_writer_1);
-  TestMinidumpMemoryWriter memory_writer_2(kBaseAddress2, kSize2, kValue2);
-  memory_list_writer.AddMemory(&memory_writer_2);
 
   minidump_file_writer.AddStream(&memory_list_writer);
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   const MINIDUMP_MEMORY_LIST* memory_list;
   ASSERT_NO_FATAL_FAILURE(
       GetMemoryListStream(file_writer.string(), &memory_list, 1));
 
   EXPECT_EQ(2u, memory_list->NumberOfMemoryRanges);
 
   MINIDUMP_MEMORY_DESCRIPTOR expected;
 
   {
     SCOPED_TRACE("region 0");
 
-    expected.StartOfMemoryRange = kBaseAddress1;
-    expected.Memory.DataSize = kSize1;
+    expected.StartOfMemoryRange = kBaseAddress0;
+    expected.Memory.DataSize = kSize0;
     expected.Memory.Rva =
         sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
         sizeof(MINIDUMP_MEMORY_LIST) +
         memory_list->NumberOfMemoryRanges * sizeof(MINIDUMP_MEMORY_DESCRIPTOR);
     ExpectMinidumpMemoryDescriptorAndContents(&expected,
                                               &memory_list->MemoryRanges[0],
                                               file_writer.string(),
-                                              kValue1,
+                                              kValue0,
                                               false);
   }
 
   {
     SCOPED_TRACE("region 1");
 
-    expected.StartOfMemoryRange = kBaseAddress2;
-    expected.Memory.DataSize = kSize2;
+    expected.StartOfMemoryRange = kBaseAddress1;
+    expected.Memory.DataSize = kSize1;
     expected.Memory.Rva = memory_list->MemoryRanges[0].Memory.Rva +
                           memory_list->MemoryRanges[0].Memory.DataSize;
     ExpectMinidumpMemoryDescriptorAndContents(&expected,
                                               &memory_list->MemoryRanges[1],
                                               file_writer.string(),
-                                              kValue2,
+                                              kValue1,
                                               true);
   }
 }
 
 class TestMemoryStream final : public internal::MinidumpStreamWriter {
  public:
   TestMemoryStream(uint64_t base_address, size_t size, uint8_t value)
       : MinidumpStreamWriter(), memory_(base_address, size, value) {}
 
   ~TestMemoryStream() {}
@@ skipping 28 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TestMemoryStream);
 };
 
 TEST(MinidumpMemoryWriter, ExtraMemory) {
   // This tests MinidumpMemoryListWriter::AddExtraMemory(). That method adds
   // a MinidumpMemoryWriter to the MinidumpMemoryListWriter without making the
   // memory writer a child of the memory list writer.
   MinidumpFileWriter minidump_file_writer;
 
-  const uint64_t kBaseAddress1 = 0x1000;
-  const uint64_t kSize1 = 0x0400;
-  const uint8_t kValue1 = '1';
-  TestMemoryStream test_memory_stream(kBaseAddress1, kSize1, kValue1);
+  const uint64_t kBaseAddress0 = 0x1000;
+  const uint64_t kSize0 = 0x0400;
+  const uint8_t kValue0 = '1';
+  TestMemoryStream test_memory_stream(kBaseAddress0, kSize0, kValue0);
 
   MinidumpMemoryListWriter memory_list_writer;
   memory_list_writer.AddExtraMemory(test_memory_stream.memory());
 
   minidump_file_writer.AddStream(&test_memory_stream);
 
-  const uint64_t kBaseAddress2 = 0x2000;
-  const uint64_t kSize2 = 0x0400;
-  const uint8_t kValue2 = 'm';
+  const uint64_t kBaseAddress1 = 0x2000;
+  const uint64_t kSize1 = 0x0400;
+  const uint8_t kValue1 = 'm';
 
-  TestMinidumpMemoryWriter memory_writer(kBaseAddress2, kSize2, kValue2);
+  TestMinidumpMemoryWriter memory_writer(kBaseAddress1, kSize1, kValue1);
   memory_list_writer.AddMemory(&memory_writer);
 
   minidump_file_writer.AddStream(&memory_list_writer);
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   const MINIDUMP_MEMORY_LIST* memory_list;
   ASSERT_NO_FATAL_FAILURE(
       GetMemoryListStream(file_writer.string(), &memory_list, 2));
 
   EXPECT_EQ(2u, memory_list->NumberOfMemoryRanges);
 
   MINIDUMP_MEMORY_DESCRIPTOR expected;
 
   {
     SCOPED_TRACE("region 0");
 
-    expected.StartOfMemoryRange = kBaseAddress1;
-    expected.Memory.DataSize = kSize1;
+    expected.StartOfMemoryRange = kBaseAddress0;
+    expected.Memory.DataSize = kSize0;
     expected.Memory.Rva =
         sizeof(MINIDUMP_HEADER) + 2 * sizeof(MINIDUMP_DIRECTORY) +
         sizeof(MINIDUMP_MEMORY_LIST) +
         memory_list->NumberOfMemoryRanges * sizeof(MINIDUMP_MEMORY_DESCRIPTOR);
     ExpectMinidumpMemoryDescriptorAndContents(&expected,
                                               &memory_list->MemoryRanges[0],
                                               file_writer.string(),
-                                              kValue1,
+                                              kValue0,
                                               false);
   }
 
   {
     SCOPED_TRACE("region 1");
 
-    expected.StartOfMemoryRange = kBaseAddress2;
-    expected.Memory.DataSize = kSize2;
+    expected.StartOfMemoryRange = kBaseAddress1;
+    expected.Memory.DataSize = kSize1;
     expected.Memory.Rva = memory_list->MemoryRanges[0].Memory.Rva +
                           memory_list->MemoryRanges[0].Memory.DataSize;
     ExpectMinidumpMemoryDescriptorAndContents(&expected,
                                               &memory_list->MemoryRanges[1],
                                               file_writer.string(),
-                                              kValue2,
+                                              kValue1,
                                               true);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad