More cgptlib tests

tests/cgptlib_test.c

 /* Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <string.h>
 
 #include "cgptlib.h"
 #include "cgptlib_internal.h"
 #include "cgptlib_test.h"
@@ skipping 27 matching lines @@
 
 #define DEFAULT_SECTOR_SIZE 512
 #define MAX_SECTOR_SIZE 4096
 #define DEFAULT_DRIVE_SECTORS 467
 #define PARTITION_ENTRIES_SIZE TOTAL_ENTRIES_SIZE /* 16384 */
 
 static const Guid guid_zero = {{{0, 0, 0, 0, 0, {0, 0, 0, 0, 0, 0}}}};
 static const Guid guid_kernel = GPT_ENT_TYPE_CHROMEOS_KERNEL;
 static const Guid guid_rootfs = GPT_ENT_TYPE_CHROMEOS_ROOTFS;
 
+/* Copy a random-for-this-program-only Guid into the dest. The num parameter
+ * completely determines the Guid.
+ */
+static void SetGuid(void *dest, uint32_t num) {
+  Guid g = {{{num,0xd450,0x44bc,0xa6,0x93,{0xb8,0xac,0x75,0x5f,0xcd,0x48}}}};
+  Memcpy(dest, &g, sizeof(Guid));
+}
 
 /* Given a GptData pointer, first re-calculate entries CRC32 value,
  * then reset header CRC32 value to 0, and calculate header CRC32 value.
  * Both primary and secondary are updated. */
 static void RefreshCrc32(GptData* gpt) {
   GptHeader *header, *header2;
   GptEntry *entries, *entries2;
 
   header = (GptHeader*)gpt->primary_header;
   entries = (GptEntry*)gpt->primary_entries;
@@ skipping 82 matching lines @@
   header->size = sizeof(GptHeader);
   header->reserved_zero = 0;
   header->my_lba = 1;
   header->alternate_lba = DEFAULT_DRIVE_SECTORS - 1;
   header->first_usable_lba = 34;
   header->last_usable_lba = DEFAULT_DRIVE_SECTORS - 1 - 32 - 1;  /* 433 */
   header->entries_lba = 2;
   header->number_of_entries = 128;  /* 512B / 128B * 32sectors = 128 entries */
   header->size_of_entry = 128;  /* bytes */
   Memcpy(&entries[0].type, &chromeos_kernel, sizeof(chromeos_kernel));
+  SetGuid(&entries[0].unique, 0);
   entries[0].starting_lba = 34;
   entries[0].ending_lba = 133;
   Memcpy(&entries[1].type, &chromeos_rootfs, sizeof(chromeos_rootfs));
+  SetGuid(&entries[1].unique, 1);
   entries[1].starting_lba = 134;
   entries[1].ending_lba = 232;
   Memcpy(&entries[2].type, &chromeos_rootfs, sizeof(chromeos_rootfs));
+  SetGuid(&entries[2].unique, 2);
   entries[2].starting_lba = 234;
   entries[2].ending_lba = 331;
   Memcpy(&entries[3].type, &chromeos_kernel, sizeof(chromeos_kernel));
+  SetGuid(&entries[3].unique, 3);
   entries[3].starting_lba = 334;
   entries[3].ending_lba = 430;
 
   /* build secondary */
   header2 = (GptHeader*)gpt->secondary_header;
   entries2 = (GptEntry*)gpt->secondary_entries;
   Memcpy(header2, header, sizeof(GptHeader));
   Memcpy(entries2, entries, PARTITION_ENTRIES_SIZE);
   header2->my_lba = DEFAULT_DRIVE_SECTORS - 1;  /* 466 */
   header2->alternate_lba = 1;
@@ skipping 487 matching lines @@
 
   for (i = 0; i < ARRAY_SIZE(cases); ++i) {
     BuildTestGptData(gpt);
     ZeroEntries(gpt);
     for(j = 0; j < ARRAY_SIZE(cases[0].entries); ++j) {
       if (!cases[i].entries[j].starting_lba)
         break;
 
       if (cases[i].entries[j].active)
         Memcpy(&e[j].type, &guid_kernel, sizeof(Guid));
+      SetGuid(&e[j].unique, j);
       e[j].starting_lba = cases[i].entries[j].starting_lba;
       e[j].ending_lba = cases[i].entries[j].ending_lba;
     }
     RefreshCrc32(gpt);
 
     EXPECT(cases[i].overlapped == CheckEntries(e, h));
   }
   return TEST_OK;
 }
 
@@ skipping 94 matching lines @@
   gpt->secondary_entries[0]++;
   EXPECT(GPT_SUCCESS == GptSanityCheck(gpt));
   EXPECT(MASK_BOTH == gpt->valid_headers);
   EXPECT(MASK_PRIMARY == gpt->valid_entries);
   GptRepair(gpt);
   EXPECT(GPT_SUCCESS == GptSanityCheck(gpt));
   EXPECT(MASK_BOTH == gpt->valid_headers);
   EXPECT(MASK_BOTH == gpt->valid_entries);
   EXPECT(GPT_MODIFIED_ENTRIES2 == gpt->modified);
 
+  /* Modify both header and entries */
+  BuildTestGptData(gpt);
+  gpt->primary_header[0]++;
+  gpt->primary_entries[0]++;
+  EXPECT(GPT_SUCCESS == GptSanityCheck(gpt));
+  EXPECT(MASK_SECONDARY == gpt->valid_headers);
+  EXPECT(MASK_SECONDARY == gpt->valid_entries);
+  GptRepair(gpt);
+  EXPECT(GPT_SUCCESS == GptSanityCheck(gpt));
+  EXPECT(MASK_BOTH == gpt->valid_headers);
+  EXPECT(MASK_BOTH == gpt->valid_entries);
+  EXPECT((GPT_MODIFIED_HEADER1 | GPT_MODIFIED_ENTRIES1) == gpt->modified);
+
+  BuildTestGptData(gpt);
+  gpt->secondary_header[0]++;
+  gpt->secondary_entries[0]++;
+  EXPECT(GPT_SUCCESS == GptSanityCheck(gpt));
+  EXPECT(MASK_PRIMARY == gpt->valid_headers);
+  EXPECT(MASK_PRIMARY == gpt->valid_entries);
+  GptRepair(gpt);
+  EXPECT(GPT_SUCCESS == GptSanityCheck(gpt));
+  EXPECT(MASK_BOTH == gpt->valid_headers);
+  EXPECT(MASK_BOTH == gpt->valid_entries);
+  EXPECT((GPT_MODIFIED_HEADER2 | GPT_MODIFIED_ENTRIES2) == gpt->modified);
+
   /* Test cross-correction (h1+e2, h2+e1) */
   BuildTestGptData(gpt);
   gpt->primary_header[0]++;
   gpt->secondary_entries[0]++;
   EXPECT(GPT_SUCCESS == GptSanityCheck(gpt));
   EXPECT(MASK_SECONDARY == gpt->valid_headers);
   EXPECT(MASK_PRIMARY == gpt->valid_entries);
   GptRepair(gpt);
   EXPECT(GPT_SUCCESS == GptSanityCheck(gpt));
   EXPECT(MASK_BOTH == gpt->valid_headers);
@@ skipping 295 matching lines @@
   GptData* gpt = GetEmptyGptData();
 
   BuildTestGptData(gpt);
   gpt->current_kernel = 0;  /* anything, but not CGPT_KERNEL_ENTRY_NOT_FOUND */
   EXPECT(GPT_ERROR_INVALID_UPDATE_TYPE ==
          GptUpdateKernelEntry(gpt, 99));  /* any invalid update_type value */
 
   return TEST_OK;
 }
 
+
+/* Tests duplicate UniqueGuids can be detected. */
+static int DuplicateUniqueGuidTest() {
+  GptData* gpt = GetEmptyGptData();
+  GptHeader* h = (GptHeader*)gpt->primary_header;
+  GptEntry* e = (GptEntry*)gpt->primary_entries;
+  int i, j;
+
+  struct {
+    int duplicate;
+    struct {
+      uint64_t starting_lba;
+      uint64_t ending_lba;
+      uint32_t type_guid;
+      uint32_t unique_guid;
+    } entries[16];   /* enough for testing. */
+  } cases[] = {
+    {0, {{100, 109, 1, 1},
+         {110, 119, 2, 2},
+         {120, 129, 3, 3},
+         {130, 139, 4, 4},
+      }},
+    {0, {{100, 109, 1, 1},
+         {110, 119, 1, 2},
+         {120, 129, 2, 3},
+         {130, 139, 2, 4},
+      }},
+    {1, {{100, 109, 1, 1},
+         {110, 119, 2, 2},
+         {120, 129, 3, 1},
+         {130, 139, 4, 4},
+      }},
+    {1, {{100, 109, 1, 1},
+         {110, 119, 1, 2},
+         {120, 129, 2, 3},
+         {130, 139, 2, 2},
+      }},
+  };
+
+  for (i = 0; i < ARRAY_SIZE(cases); ++i) {
+    BuildTestGptData(gpt);
+    ZeroEntries(gpt);
+    for(j = 0; j < ARRAY_SIZE(cases[0].entries); ++j) {
+      if (!cases[i].entries[j].starting_lba)
+        break;
+
+      e[j].starting_lba = cases[i].entries[j].starting_lba;
+      e[j].ending_lba = cases[i].entries[j].ending_lba;
+      SetGuid(&e[j].type, cases[i].entries[j].type_guid);
+      SetGuid(&e[j].unique, cases[i].entries[j].unique_guid);
+    }
+    RefreshCrc32(gpt);
+
+    EXPECT(cases[i].duplicate == CheckEntries(e, h));
+  }
+  return TEST_OK;
+}
+
+
+
 /* disable MSVC warnings on unused arguments */
 __pragma(warning (disable: 4100))
 
 int main(int argc, char *argv[]) {
   int i;
   int error_count = 0;
   struct {
     char *name;
     test_func fp;
     int retval;
@@ skipping 16 matching lines @@
     { TEST_CASE(OverlappedPartitionTest), },
     { TEST_CASE(SanityCheckTest), },
     { TEST_CASE(NoValidKernelEntryTest), },
     { TEST_CASE(EntryAttributeGetSetTest), },
     { TEST_CASE(EntryTypeTest), },
     { TEST_CASE(GetNextNormalTest), },
     { TEST_CASE(GetNextPrioTest), },
     { TEST_CASE(GetNextTriesTest), },
     { TEST_CASE(GptUpdateTest), },
     { TEST_CASE(UpdateInvalidKernelTypeTest), },
+    { TEST_CASE(DuplicateUniqueGuidTest), },
     { TEST_CASE(TestCrc32TestVectors), },
   };
 
   for (i = 0; i < sizeof(test_cases)/sizeof(test_cases[0]); ++i) {
     printf("Running %s() ...\n", test_cases[i].name);
     test_cases[i].retval = test_cases[i].fp();
     if (test_cases[i].retval) {
       printf(COL_RED "[ERROR]\n\n" COL_STOP);
       ++error_count;
     } else {
       printf(COL_GREEN "[PASS]\n\n" COL_STOP);
     }
   }
 
   if (error_count) {
     printf("\n--------------------------------------------------\n");
     printf(COL_RED "The following %d test cases are failed:\n" COL_STOP,
            error_count);
     for (i = 0; i < sizeof(test_cases)/sizeof(test_cases[0]); ++i) {
       if (test_cases[i].retval)
         printf("  %s()\n", test_cases[i].name);
     }
   }
 
   return (error_count) ? 1 : 0;
 }