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 "cgptlib_test.h"
#include <string.h>
#include "cgptlib.h"
#include "cgptlib_internal.h"
#include "crc32.h"
#include "crc32_test.h"
#include "gpt.h"
#include "quick_sort_test.h"
#include "utility.h"

/* Testing partition layout (sector_bytes=512)
 *
 *     LBA   Size  Usage
 * ---------------------------------------------------------
 *       0      1  PMBR
 *       1      1  primary partition header
 *       2     32  primary partition entries (128B * 128)
 *      34    100  kernel A (index: 0)
 *     134    100  root A (index: 1)
 *     234    100  root B (index: 2)
 *     334    100  kernel B (index: 3)
 *     434     32  secondary partition entries
 *     466      1  secondary partition header
 *     467
 */
#define KERNEL_A 0
#define ROOTFS_A 1
#define ROOTFS_B 2
#define KERNEL_B 3

#define DEFAULT_SECTOR_SIZE 512
#define MAX_SECTOR_SIZE 4096
#define DEFAULT_DRIVE_SECTORS 467
#define PARTITION_ENTRIES_SIZE TOTAL_ENTRIES_SIZE /* 16384 */

/* 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. */
void RefreshCrc32(GptData *gpt) {
  GptHeader *header, *header2;
  GptEntry *entries, *entries2;

  header = (GptHeader*)gpt->primary_header;
  entries = (GptEntry*)gpt->primary_entries;
  header2 = (GptHeader*)gpt->secondary_header;
  entries2 = (GptEntry*)gpt->secondary_entries;

  header->entries_crc32 =
      Crc32((uint8_t*)entries,
            header->number_of_entries * header->size_of_entry);
  header->header_crc32 = 0;
  header->header_crc32 = Crc32((uint8_t*)header, header->size);
  header2->entries_crc32 =
      Crc32((uint8_t*)entries2,
            header2->number_of_entries * header2->size_of_entry);
  header2->header_crc32 = 0;
  header2->header_crc32 = Crc32((uint8_t*)header2, header2->size);
}

void ZeroHeaders(GptData* gpt) {
  Memset(gpt->primary_header, 0, MAX_SECTOR_SIZE);
  Memset(gpt->secondary_header, 0, MAX_SECTOR_SIZE);
}

void ZeroEntries(GptData* gpt) {
  Memset(gpt->primary_entries, 0, PARTITION_ENTRIES_SIZE);
  Memset(gpt->secondary_entries, 0, PARTITION_ENTRIES_SIZE);
}

void ZeroHeadersEntries(GptData* gpt) {
  ZeroHeaders(gpt);
  ZeroEntries(gpt);
}

/* Returns a pointer to a static GptData instance (no free is required).
 * All fields are zero except 4 pointers linking to header and entries.
 * All content of headers and entries are zero. */
GptData* GetEmptyGptData() {
  static GptData gpt;
  static uint8_t primary_header[MAX_SECTOR_SIZE];
  static uint8_t primary_entries[PARTITION_ENTRIES_SIZE];
  static uint8_t secondary_header[MAX_SECTOR_SIZE];
  static uint8_t secondary_entries[PARTITION_ENTRIES_SIZE];

  Memset(&gpt, 0, sizeof(gpt));
  gpt.primary_header = primary_header;
  gpt.primary_entries = primary_entries;
  gpt.secondary_header = secondary_header;
  gpt.secondary_entries = secondary_entries;
  ZeroHeadersEntries(&gpt);

  /* Initialize GptData internal states. */
  gpt.current_kernel = CGPT_KERNEL_ENTRY_NOT_FOUND;

  return &gpt;
}

/* Fills in most of fields and creates the layout described in the top of this
 * file. Before calling this function, primary/secondary header/entries must
 * have been pointed to the buffer, say, a gpt returned from GetEmptyGptData().
 * This function returns a good (valid) copy of GPT layout described in top of
 * this file. */
void BuildTestGptData(GptData *gpt) {
  GptHeader *header, *header2;
  GptEntry *entries, *entries2;
  Guid chromeos_kernel = GPT_ENT_TYPE_CHROMEOS_KERNEL;
  Guid chromeos_rootfs = GPT_ENT_TYPE_CHROMEOS_ROOTFS;

  gpt->sector_bytes = DEFAULT_SECTOR_SIZE;
  gpt->drive_sectors = DEFAULT_DRIVE_SECTORS;
  gpt->current_kernel = CGPT_KERNEL_ENTRY_NOT_FOUND;
  gpt->valid_headers = MASK_BOTH;
  gpt->valid_entries = MASK_BOTH;

  /* build primary */
  header = (GptHeader*)gpt->primary_header;
  entries = (GptEntry*)gpt->primary_entries;
  Memcpy(header->signature, GPT_HEADER_SIGNATURE, sizeof(GPT_HEADER_SIGNATURE));
  header->revision = GPT_HEADER_REVISION;
  header->size = sizeof(GptHeader) - sizeof(header->padding);
  header->reserved = 0;
  header->my_lba = 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));
  entries[0].starting_lba = 34;
  entries[0].ending_lba = 133;
  Memcpy(&entries[1].type, &chromeos_rootfs, sizeof(chromeos_rootfs));
  entries[1].starting_lba = 134;
  entries[1].ending_lba = 233;
  Memcpy(&entries[2].type, &chromeos_rootfs, sizeof(chromeos_rootfs));
  entries[2].starting_lba = 234;
  entries[2].ending_lba = 333;
  Memcpy(&entries[3].type, &chromeos_kernel, sizeof(chromeos_kernel));
  entries[3].starting_lba = 334;
  entries[3].ending_lba = 433;
  header->padding = 0;

  /* 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->entries_lba = DEFAULT_DRIVE_SECTORS - 1 - 32;  /* 434 */

  RefreshCrc32(gpt);
}

/* Dumps memory starting from [vp] with [len] bytes.
 * Prints [memo] if not NULL. Example output:
 *
 *  00 01 02 03 04 05 06 07 - 08 09 0a 0b 0c 0d 0e 0f
 *  10 11 12 13 14 15 16 17 - 18 19 1a 1b 1c 1d 1e 1f
 *  ...
 */
static void Dump(void *vp, int len, char* memo) {
  uint8_t *start = vp;
  int i;
  if (memo) printf("--[%s]----------\n", memo);
  for (i = 0; i < len; ++i) {
    printf("%02x%s", start[i],
                     (!(~i & 15) ? "\n" :
                      !(~i & 7) ? " - ": " "));
  }
  if (i&15) printf("\n");
}

/* More formatted dump with GptData. */
void DumpGptData(GptData *gpt) {
  printf("DumpGptData(%p)...\n", gpt);
  Dump(gpt, sizeof(gpt), NULL);
  Dump(gpt->primary_header, sizeof(GptHeader), "Primary header");
  Dump(gpt->primary_entries, sizeof(GptEntry) * 8, "Primary entries");
  Dump(gpt->secondary_header, sizeof(GptHeader), "Secondary header");
  Dump(gpt->secondary_entries, sizeof(GptEntry) * 8,
       "Secondary entries");
}

/* Tests if the default structure returned by BuildTestGptData() is good. */
int TestBuildTestGptData() {
  GptData *gpt;
  gpt = GetEmptyGptData();
  BuildTestGptData(gpt);
  EXPECT(GPT_SUCCESS == GptInit(gpt));
  return TEST_OK;
}

/* Tests if wrong sector_bytes or drive_sectors is detected by GptInit().
 * Currently we only support 512 bytes per sector.
 * In the future, we may support other sizes.
 * A too small drive_sectors should be rejected by GptInit(). */
int ParameterTests() {
  GptData *gpt;
  struct {
    uint32_t sector_bytes;
    uint64_t drive_sectors;
    int expected_retval;
  } cases[] = {
    {512, DEFAULT_DRIVE_SECTORS, GPT_SUCCESS},
    {520, DEFAULT_DRIVE_SECTORS, GPT_ERROR_INVALID_SECTOR_SIZE},
    {512, 0, GPT_ERROR_INVALID_SECTOR_NUMBER},
    {512, 66, GPT_ERROR_INVALID_SECTOR_NUMBER},
    {512, GPT_PMBR_SECTOR + GPT_HEADER_SECTOR * 2 + GPT_ENTRIES_SECTORS * 2,
          GPT_SUCCESS},
    {4096, DEFAULT_DRIVE_SECTORS, GPT_ERROR_INVALID_SECTOR_SIZE},
  };
  int i;

  gpt = GetEmptyGptData();
  for (i = 0; i < ARRAY_SIZE(cases); ++i) {
    BuildTestGptData(gpt);
    gpt->sector_bytes = cases[i].sector_bytes;
    gpt->drive_sectors = cases[i].drive_sectors;
    EXPECT(cases[i].expected_retval == CheckParameters(gpt));
  }

  return TEST_OK;
}

/* Tests if signature ("EFI PART") is checked. */
int SignatureTest() {
  int i;
  GptData *gpt;
  int test_mask;
  GptHeader *headers[2];

  gpt = GetEmptyGptData();
  headers[PRIMARY] = (GptHeader*)gpt->primary_header;
  headers[SECONDARY] = (GptHeader*)gpt->secondary_header;

  for (test_mask = MASK_PRIMARY; test_mask <= MASK_BOTH; ++test_mask) {
    for (i = 0; i < 8; ++i) {
      BuildTestGptData(gpt);
      if (test_mask & MASK_PRIMARY)
        headers[PRIMARY]->signature[i] ^= 0xff;
      if (test_mask & MASK_SECONDARY)
        headers[SECONDARY]->signature[i] ^= 0xff;
      EXPECT((MASK_BOTH ^ test_mask) == CheckHeaderSignature(gpt));
    }
  }

  return TEST_OK;
}

/* The revision we currently support is GPT_HEADER_REVISION.
 * If the revision in header is not that, we expect the header is invalid. */
int RevisionTest() {
  GptData *gpt;
  struct {
    uint32_t value_to_test;
    int is_valid_value;
  } cases[] = {
    {0x01000000, 0},
    {0x00010000, 1},  /* GPT_HEADER_REVISION */
    {0x00000100, 0},
    {0x00000001, 0},
    {0x23010456, 0},
  };
  int i;
  int test_mask;
  GptHeader *headers[2];
  uint32_t valid_headers;

  gpt = GetEmptyGptData();
  headers[PRIMARY] = (GptHeader*)gpt->primary_header;
  headers[SECONDARY] = (GptHeader*)gpt->secondary_header;

  for (i = 0; i < ARRAY_SIZE(cases); ++i) {
    for (test_mask = MASK_PRIMARY; test_mask <= MASK_BOTH; ++test_mask) {
      BuildTestGptData(gpt);
      if (test_mask & MASK_PRIMARY)
        headers[PRIMARY]->revision = cases[i].value_to_test;
      if (test_mask & MASK_SECONDARY)
        headers[SECONDARY]->revision = cases[i].value_to_test;
      valid_headers = CheckRevision(gpt);
      if (cases[i].is_valid_value)
        EXPECT(MASK_BOTH == valid_headers);
      else
        EXPECT((MASK_BOTH ^ test_mask) == valid_headers);
    }
  }
  return TEST_OK;
}

int SizeTest() {
  GptData *gpt;
  struct {
    uint32_t value_to_test;
    int is_valid_value;
  } cases[] = {
    {91, 0},
    {92, 1},
    {93, 1},
    {511, 1},
    {512, 1},
    {513, 0},
  };
  int i;
  int test_mask;
  GptHeader *headers[2];
  uint32_t valid_headers;

  gpt = GetEmptyGptData();
  headers[PRIMARY] = (GptHeader*)gpt->primary_header;
  headers[SECONDARY] = (GptHeader*)gpt->secondary_header;

  for (i = 0; i < ARRAY_SIZE(cases); ++i) {
    for (test_mask = MASK_PRIMARY; test_mask <= MASK_BOTH; ++test_mask) {
      BuildTestGptData(gpt);
      if (test_mask & MASK_PRIMARY)
        headers[PRIMARY]->size = cases[i].value_to_test;
      if (test_mask & MASK_SECONDARY)
        headers[SECONDARY]->size = cases[i].value_to_test;
      valid_headers = CheckSize(gpt);
      if (cases[i].is_valid_value)
        EXPECT(MASK_BOTH == valid_headers);
      else
        EXPECT((MASK_BOTH ^ test_mask) == valid_headers);
    }
  }
  return TEST_OK;
}

/* Tests if reserved fields are checked.
 * We'll try non-zero values to test. */
int ReservedFieldsTest() {
  GptData *gpt;
  GptHeader *primary_header, *secondary_header;

  gpt = GetEmptyGptData();
  primary_header = (GptHeader*)gpt->primary_header;
  secondary_header = (GptHeader*)gpt->secondary_header;

  /* expect secondary is still valid. */
  BuildTestGptData(gpt);
  primary_header->reserved ^= 0x12345678;  /* whatever random */
  EXPECT(MASK_SECONDARY == CheckReservedFields(gpt));

  /* expect secondary is still valid. */
  BuildTestGptData(gpt);
  primary_header->padding ^= 0x12345678;  /* whatever random */
  EXPECT(MASK_SECONDARY == CheckReservedFields(gpt));

  /* expect primary is still valid. */
  BuildTestGptData(gpt);
  secondary_header->reserved ^= 0x12345678;  /* whatever random */
  EXPECT(MASK_PRIMARY == CheckReservedFields(gpt));

  /* expect primary is still valid. */
  BuildTestGptData(gpt);
  secondary_header->padding ^= 0x12345678;  /* whatever random */
  EXPECT(MASK_PRIMARY == CheckReservedFields(gpt));

  return TEST_OK;
}

/* Tests if myLBA field is checked (1 for primary, last for secondary). */
int MyLbaTest() {
  GptData *gpt;
  int test_mask;
  GptHeader *headers[2];
  uint32_t valid_headers;

  gpt = GetEmptyGptData();
  headers[PRIMARY] = (GptHeader*)gpt->primary_header;
  headers[SECONDARY] = (GptHeader*)gpt->secondary_header;

  for (test_mask = MASK_PRIMARY; test_mask <= MASK_BOTH; ++test_mask) {
    BuildTestGptData(gpt);
    if (test_mask & MASK_PRIMARY)
      ++headers[PRIMARY]->my_lba;
    if (test_mask & MASK_SECONDARY)
      --headers[SECONDARY]->my_lba;
    valid_headers = CheckMyLba(gpt);
    EXPECT((MASK_BOTH ^ test_mask) == valid_headers);
  }
  return TEST_OK;
}

/* Tests if SizeOfPartitionEntry is checked. SizeOfPartitionEntry must be
 * between 128 and 512, and a multiple of 8. */
int SizeOfPartitionEntryTest() {
  GptData *gpt;
  struct {
    uint32_t value_to_test;
    int is_valid_value;
  } cases[] = {
    {127, 0},
    {128, 1},
    {129, 0},
    {130, 0},
    {131, 0},
    {132, 0},
    {133, 0},
    {134, 0},
    {135, 0},
    {136, 1},
    {144, 1},
    {160, 1},
    {192, 1},
    {256, 1},
    {384, 1},
    {504, 1},
    {512, 1},
    {513, 0},
    {520, 0},
  };
  int i;
  int test_mask;
  GptHeader *headers[2];
  uint32_t valid_headers;

  gpt = GetEmptyGptData();
  headers[PRIMARY] = (GptHeader*)gpt->primary_header;
  headers[SECONDARY] = (GptHeader*)gpt->secondary_header;

  for (i = 0; i < ARRAY_SIZE(cases); ++i) {
    for (test_mask = MASK_PRIMARY; test_mask <= MASK_BOTH; ++test_mask) {
      BuildTestGptData(gpt);
      if (test_mask & MASK_PRIMARY) {
        headers[PRIMARY]->size_of_entry = cases[i].value_to_test;
        headers[PRIMARY]->number_of_entries =
            TOTAL_ENTRIES_SIZE / cases[i].value_to_test;
      }
      if (test_mask & MASK_SECONDARY) {
        headers[SECONDARY]->size_of_entry = cases[i].value_to_test;
        headers[SECONDARY]->number_of_entries =
            TOTAL_ENTRIES_SIZE / cases[i].value_to_test;
      }
      valid_headers = CheckSizeOfPartitionEntry(gpt);
      if (cases[i].is_valid_value)
        EXPECT(MASK_BOTH == valid_headers);
      else
        EXPECT((MASK_BOTH ^ test_mask) == valid_headers);
    }
  }
  return TEST_OK;
}

/* Tests if NumberOfPartitionEntries is checes. NumberOfPartitionEntries must
 * be between 32 and 512, and SizeOfPartitionEntry * NumberOfPartitionEntries
 * must be 16384. */
int NumberOfPartitionEntriesTest() {
  GptData *gpt;
  struct {
    uint32_t size_of_entry;
    uint32_t number_of_entries;
    int is_valid_value;
  } cases[] = {
    {111, 147, 0},
    {111, 149, 0},
    {128, 32, 0},
    {128, 64, 0},
    {128, 127, 0},
    {128, 128, 1},
    {128, 129, 0},
    {128, 256, 0},
    {256, 32, 0},
    {256, 64, 1},
    {256, 128, 0},
    {256, 256, 0},
    {512, 32, 1},
    {512, 64, 0},
    {512, 128, 0},
    {512, 256, 0},
    {1024, 128, 0},
  };
  int i;
  int test_mask;
  GptHeader *headers[2];
  uint32_t valid_headers;

  gpt = GetEmptyGptData();
  headers[PRIMARY] = (GptHeader*)gpt->primary_header;
  headers[SECONDARY] = (GptHeader*)gpt->secondary_header;

  for (i = 0; i < ARRAY_SIZE(cases); ++i) {
    for (test_mask = MASK_PRIMARY; test_mask <= MASK_BOTH; ++test_mask) {
      BuildTestGptData(gpt);
      if (test_mask & MASK_PRIMARY) {
        headers[PRIMARY]->size_of_entry = cases[i].size_of_entry;
        headers[PRIMARY]->number_of_entries = cases[i].number_of_entries;
      }
      if (test_mask & MASK_SECONDARY) {
        headers[SECONDARY]->size_of_entry = cases[i].size_of_entry;
        headers[SECONDARY]->number_of_entries = cases[i].number_of_entries;
      }
      valid_headers = CheckNumberOfEntries(gpt);
      if (cases[i].is_valid_value)
        EXPECT(MASK_BOTH == valid_headers);
      else
        EXPECT((MASK_BOTH ^ test_mask) == valid_headers);
    }
  }
  return TEST_OK;
}

/* Tests if PartitionEntryLBA in primary/secondary headers is checked. */
int PartitionEntryLbaTest() {
  GptData *gpt;
  int test_mask;
  GptHeader *headers[2];
  uint32_t valid_headers;

  gpt = GetEmptyGptData();
  headers[PRIMARY] = (GptHeader*)gpt->primary_header;
  headers[SECONDARY] = (GptHeader*)gpt->secondary_header;

  for (test_mask = MASK_PRIMARY; test_mask <= MASK_BOTH; ++test_mask) {
    BuildTestGptData(gpt);
    if (test_mask & MASK_PRIMARY)
      headers[PRIMARY]->entries_lba = 0;
    if (test_mask & MASK_SECONDARY)
      headers[SECONDARY]->entries_lba = DEFAULT_DRIVE_SECTORS - 31 - 1;
    valid_headers = CheckEntriesLba(gpt);
    EXPECT((MASK_BOTH ^ test_mask) == valid_headers);
  }
  return TEST_OK;
}

/* Tests if FirstUsableLBA and LastUsableLBA are checked.
 * FirstUsableLBA must be after the end of the primary GPT table array.
 * LastUsableLBA must be before the start of the secondary GPT table array.
 * FirstUsableLBA <= LastUsableLBA. */
int FirstUsableLbaAndLastUsableLbaTest() {
  GptData *gpt;
  GptHeader *primary_header, *secondary_header;
  uint32_t valid_headers;
  int i;
  struct {
    uint64_t primary_entries_lba;
    uint64_t primary_first_usable_lba;
    uint64_t primary_last_usable_lba;
    uint64_t secondary_first_usable_lba;
    uint64_t secondary_last_usable_lba;
    uint64_t secondary_entries_lba;
    int expected_masks;
  } cases[] = {
    {2, 34, 433, 34, 433, 434, MASK_BOTH},
    {2, 34, 432, 34, 430, 434, MASK_BOTH},
    {2, 33, 433, 33, 433, 434, MASK_NONE},
    {3, 34, 433, 35, 433, 434, MASK_SECONDARY},
    {3, 35, 433, 33, 433, 434, MASK_PRIMARY},
    {2, 34, 434, 34, 433, 434, MASK_SECONDARY},
    {2, 34, 433, 34, 434, 434, MASK_PRIMARY},
    {2, 35, 433, 35, 433, 434, MASK_BOTH},
    {2, 433, 433, 433, 433, 434, MASK_BOTH},
    {2, 434, 433, 434, 434, 434, MASK_NONE},
    {2, 433, 34, 34, 433, 434, MASK_SECONDARY},
    {2, 34, 433, 433, 34, 434, MASK_PRIMARY},
  };

  gpt = GetEmptyGptData();
  primary_header = (GptHeader*)gpt->primary_header;
  secondary_header = (GptHeader*)gpt->secondary_header;

  for (i = 0; i < ARRAY_SIZE(cases); ++i) {
    BuildTestGptData(gpt);
    primary_header->entries_lba = cases[i].primary_entries_lba;
    primary_header->first_usable_lba = cases[i].primary_first_usable_lba;
    primary_header->last_usable_lba = cases[i].primary_last_usable_lba;
    secondary_header->entries_lba = cases[i].secondary_entries_lba;
    secondary_header->first_usable_lba = cases[i].secondary_first_usable_lba;
    secondary_header->last_usable_lba = cases[i].secondary_last_usable_lba;
    valid_headers = CheckValidUsableLbas(gpt);
    EXPECT(cases[i].expected_masks == valid_headers);
  }

  return TEST_OK;
}

/* Tests if header CRC in two copies are calculated. */
int HeaderCrcTest() {
  GptData *gpt;
  GptHeader *primary_header, *secondary_header;

  gpt = GetEmptyGptData();
  primary_header = (GptHeader*)gpt->primary_header;
  secondary_header = (GptHeader*)gpt->secondary_header;

  /* Modify the first byte of primary header, and expect the CRC is wrong. */
  BuildTestGptData(gpt);
  gpt->primary_header[0] ^= 0xa5;  /* just XOR a non-zero value */
  EXPECT(MASK_SECONDARY == CheckHeaderCrc(gpt));

  /* Modify the last byte of secondary header, and expect the CRC is wrong. */
  BuildTestGptData(gpt);
  gpt->secondary_header[secondary_header->size-1] ^= 0x5a;
  EXPECT(MASK_PRIMARY == CheckHeaderCrc(gpt));

  /* Modify out of CRC range, expect CRC is still right. */
  BuildTestGptData(gpt);
  gpt->primary_header[primary_header->size] ^= 0x87;
  EXPECT(MASK_BOTH == CheckHeaderCrc(gpt));

  /* Very long header (actually invalid header). Expect will be ignored. */
  primary_header->size = 0x12345678;
  secondary_header->size = 0x87654321;
  gpt->valid_headers = MASK_NONE;
  EXPECT(MASK_NONE == CheckHeaderCrc(gpt));

  return TEST_OK;
}

/* Tests if PartitionEntryArrayCRC32 is checked.
 * PartitionEntryArrayCRC32 must be calculated over SizeOfPartitionEntry *
 * NumberOfPartitionEntries bytes.
 */
int EntriesCrcTest() {
  GptData *gpt;

  gpt = GetEmptyGptData();

  /* Modify the first byte of primary entries, and expect the CRC is wrong. */
  BuildTestGptData(gpt);
  gpt->primary_entries[0] ^= 0xa5;  /* just XOR a non-zero value */
  EXPECT(MASK_SECONDARY == CheckEntriesCrc(gpt));

  /* Modify the last byte of secondary entries, and expect the CRC is wrong. */
  BuildTestGptData(gpt);
  gpt->secondary_entries[TOTAL_ENTRIES_SIZE-1] ^= 0x5a;
  EXPECT(MASK_PRIMARY == CheckEntriesCrc(gpt));

  return TEST_OK;
}

/* Tests if GptInit() handles non-identical partition entries well.
 * Two copies of partition table entries must be identical. If not, we trust the
 * primary table entries, and mark secondary as modified. */
int IdenticalEntriesTest() {
  GptData *gpt;

  gpt = GetEmptyGptData();

  /* Tests RepairEntries() first. */
  BuildTestGptData(gpt);
  EXPECT(0 == RepairEntries(gpt, MASK_BOTH));
  gpt->secondary_entries[0] ^= 0xa5;  /* XOR any number */
  EXPECT(GPT_MODIFIED_ENTRIES2 == RepairEntries(gpt, MASK_BOTH));
  EXPECT(GPT_MODIFIED_ENTRIES2 == RepairEntries(gpt, MASK_PRIMARY));
  EXPECT(GPT_MODIFIED_ENTRIES1 == RepairEntries(gpt, MASK_SECONDARY));
  EXPECT(0 == RepairEntries(gpt, MASK_NONE));

  /* The first byte is different. We expect secondary entries is marked as
   * modified. */
  BuildTestGptData(gpt);
  gpt->primary_entries[0] ^= 0xff;
  RefreshCrc32(gpt);
  EXPECT(GPT_SUCCESS == GptInit(gpt));
  EXPECT(GPT_MODIFIED_ENTRIES2 == gpt->modified);
  EXPECT(0 ==  Memcmp(gpt->primary_entries, gpt->secondary_entries,
                      TOTAL_ENTRIES_SIZE));

  /* The last byte is different, but the primary entries CRC is bad.
   * We expect primary entries is marked as modified. */
  BuildTestGptData(gpt);
  gpt->primary_entries[TOTAL_ENTRIES_SIZE-1] ^= 0xff;
  EXPECT(GPT_SUCCESS == GptInit(gpt));
  EXPECT(GPT_MODIFIED_ENTRIES1 == gpt->modified);
  EXPECT(0 == Memcmp(gpt->primary_entries, gpt->secondary_entries,
                     TOTAL_ENTRIES_SIZE));

  return TEST_OK;
}

/* Tests if GptInit() handles synonymous headers well.
 * Note that two partition headers are NOT bit-swise identical.
 * For exmaple, my_lba must be different (pointing to respective self).
 * So in normal case, they are synonymous, not identical.
 * If not synonymous, we trust the primary partition header, and
 * overwrite secondary, then mark secondary as modified.*/
int SynonymousHeaderTest() {
  GptData *gpt;
  GptHeader *primary_header, *secondary_header;

  gpt = GetEmptyGptData();
  primary_header = (GptHeader*)gpt->primary_header;
  secondary_header = (GptHeader*)gpt->secondary_header;

  /* Tests RepairHeader() for synonymous cases first. */
  BuildTestGptData(gpt);
  EXPECT(0 == RepairHeader(gpt, MASK_BOTH));
  EXPECT(GPT_MODIFIED_HEADER2 == RepairHeader(gpt, MASK_PRIMARY));
  EXPECT(GPT_MODIFIED_HEADER1 == RepairHeader(gpt, MASK_SECONDARY));
  EXPECT(0 == RepairHeader(gpt, MASK_NONE));
  /* Then tests non-synonymous cases. */
  BuildTestGptData(gpt);
  ++secondary_header->first_usable_lba;  /* chnage any bit */
  EXPECT(GPT_MODIFIED_HEADER2 == RepairHeader(gpt, MASK_BOTH));
  EXPECT(primary_header->first_usable_lba ==
         secondary_header->first_usable_lba);
  /* ---- */
  BuildTestGptData(gpt);
  --secondary_header->last_usable_lba;
  EXPECT(GPT_MODIFIED_HEADER2 == RepairHeader(gpt, MASK_BOTH));
  EXPECT(primary_header->last_usable_lba == secondary_header->last_usable_lba);
  /* ---- */
  BuildTestGptData(gpt);
  ++secondary_header->number_of_entries;
  EXPECT(GPT_MODIFIED_HEADER2 == RepairHeader(gpt, MASK_BOTH));
  EXPECT(primary_header->number_of_entries ==
         secondary_header->number_of_entries);
  /* ---- */
  BuildTestGptData(gpt);
  --secondary_header->size_of_entry;
  EXPECT(GPT_MODIFIED_HEADER2 == RepairHeader(gpt, MASK_BOTH));
  EXPECT(primary_header->size_of_entry ==
         secondary_header->size_of_entry);
  /* ---- */
  BuildTestGptData(gpt);
  secondary_header->disk_uuid.u.raw[0] ^= 0x56;
  EXPECT(GPT_MODIFIED_HEADER2 == RepairHeader(gpt, MASK_BOTH));
  EXPECT(0 == Memcmp(&primary_header->disk_uuid,
                     &secondary_header->disk_uuid, sizeof(Guid)));

  /* Consider header repairing in GptInit(). */
  BuildTestGptData(gpt);
  ++secondary_header->first_usable_lba;
  RefreshCrc32(gpt);
  EXPECT(GPT_SUCCESS == GptInit(gpt));
  EXPECT((gpt->modified & (GPT_MODIFIED_HEADER1 | GPT_MODIFIED_HEADER2)) ==
         GPT_MODIFIED_HEADER2);
  EXPECT(primary_header->first_usable_lba ==
         secondary_header->first_usable_lba);

  return TEST_OK;
}

/* Tests if partition geometry is checked.
 * All active (non-zero PartitionTypeGUID) partition entries should have:
 *   entry.StartingLBA >= header.FirstUsableLBA
 *   entry.EndingLBA <= header.LastUsableLBA
 *   entry.StartingLBA <= entry.EndingLBA
 */
int ValidEntryTest() {
  GptData *gpt;
  GptHeader *primary_header, *secondary_header;
  GptEntry *primary_entries, *secondary_entries;

  gpt = GetEmptyGptData();
  primary_header = (GptHeader*)gpt->primary_header;
  secondary_header = (GptHeader*)gpt->secondary_header;
  primary_entries = (GptEntry*)gpt->primary_entries;
  secondary_entries = (GptEntry*)gpt->secondary_entries;

  /* error case: entry.StartingLBA < header.FirstUsableLBA */
  BuildTestGptData(gpt);
  primary_entries[0].starting_lba = primary_header->first_usable_lba - 1;
  EXPECT(MASK_SECONDARY == CheckValidEntries(gpt));
  secondary_entries[1].starting_lba = secondary_header->first_usable_lba - 1;
  EXPECT(MASK_NONE == CheckValidEntries(gpt));

  /* error case: entry.EndingLBA > header.LastUsableLBA */
  BuildTestGptData(gpt);
  primary_entries[2].ending_lba = primary_header->last_usable_lba + 1;
  EXPECT(MASK_SECONDARY == CheckValidEntries(gpt));
  secondary_entries[3].ending_lba = secondary_header->last_usable_lba + 1;
  EXPECT(MASK_NONE == CheckValidEntries(gpt));

  /* error case: entry.StartingLBA > entry.EndingLBA */
  BuildTestGptData(gpt);
  primary_entries[3].starting_lba = primary_entries[3].ending_lba + 1;
  EXPECT(MASK_SECONDARY == CheckValidEntries(gpt));
  secondary_entries[1].starting_lba = secondary_entries[1].ending_lba + 1;
  EXPECT(MASK_NONE == CheckValidEntries(gpt));

  /* case: non active entry should be ignored. */
  BuildTestGptData(gpt);
  Memset(&primary_entries[1].type, 0, sizeof(primary_entries[1].type));
  primary_entries[1].starting_lba = primary_entries[1].ending_lba + 1;
  EXPECT(MASK_BOTH == CheckValidEntries(gpt));
  Memset(&secondary_entries[2].type, 0, sizeof(secondary_entries[2].type));
  secondary_entries[2].starting_lba = secondary_entries[2].ending_lba + 1;
  EXPECT(MASK_BOTH == CheckValidEntries(gpt));

  return TEST_OK;
}

/* Tests if overlapped partition tables can be detected. */
int OverlappedPartitionTest() {
  GptData *gpt;
  struct {
    int overlapped;
    struct {
      int active;
      uint64_t starting_lba;
      uint64_t ending_lba;
    } entries[16];  /* enough for testing. */
  } cases[] = {
    {0, {{0, 100, 199}, {0, 0, 0}}},
    {0, {{1, 100, 199}, {0, 0, 0}}},
    {0, {{1, 100, 150}, {1, 200, 250}, {1, 300, 350}, {0, 0, 0}}},
    {1, {{1, 200, 299}, {1, 100, 199}, {1, 100, 100}, {0, 0, 0}}},
    {1, {{1, 200, 299}, {1, 100, 199}, {1, 299, 299}, {0, 0, 0}}},
    {0, {{1, 300, 399}, {1, 200, 299}, {1, 100, 199}, {0, 0, 0}}},
    {1, {{1, 100, 199}, {1, 199, 299}, {1, 299, 399}, {0, 0, 0}}},
    {1, {{1, 100, 199}, {1, 200, 299}, {1, 75, 399}, {0, 0, 0}}},
    {1, {{1, 100, 199}, {1, 75, 250}, {1, 200, 299}, {0, 0, 0}}},
    {1, {{1, 75, 150}, {1, 100, 199}, {1, 200, 299}, {0, 0, 0}}},
    {1, {{1, 200, 299}, {1, 100, 199}, {1, 300, 399}, {1, 100, 399},
         {0, 0, 0}}},
    {0, {{1, 200, 299}, {1, 100, 199}, {1, 300, 399}, {0, 100, 399},
         {0, 0, 0}}},
    {1, {{1, 200, 300}, {1, 100, 200}, {1, 100, 400}, {1, 300, 400},
         {0, 0, 0}}},
    {1, {{0, 200, 300}, {1, 100, 200}, {1, 100, 400}, {1, 300, 400},
         {0, 0, 0}}},
    {0, {{1, 200, 300}, {1, 100, 199}, {0, 100, 400}, {0, 300, 400},
         {0, 0, 0}}},
    {1, {{1, 200, 299}, {1, 100, 199}, {1, 199, 199}, {0, 0, 0}}},
    {0, {{1, 200, 299}, {0, 100, 199}, {1, 199, 199}, {0, 0, 0}}},
    {0, {{1, 200, 299}, {1, 100, 199}, {0, 199, 199}, {0, 0, 0}}},
    {1, {{1, 199, 199}, {1, 200, 200}, {1, 201, 201}, {1, 202, 202},
         {1, 203, 203}, {1, 204, 204}, {1, 205, 205}, {1, 206, 206},
         {1, 207, 207}, {1, 208, 208}, {1, 199, 199}, {0, 0, 0}}},
    {0, {{1, 199, 199}, {1, 200, 200}, {1, 201, 201}, {1, 202, 202},
         {1, 203, 203}, {1, 204, 204}, {1, 205, 205}, {1, 206, 206},
         {1, 207, 207}, {1, 208, 208}, {0, 199, 199}, {0, 0, 0}}},
  };
  Guid any_type = GPT_ENT_TYPE_CHROMEOS_KERNEL;
  int i, j;
  int test_mask;
  GptEntry *entries[2];

  gpt = GetEmptyGptData();
  entries[PRIMARY] = (GptEntry*)gpt->primary_entries;
  entries[SECONDARY] = (GptEntry*)gpt->secondary_entries;

  for (i = 0; i < ARRAY_SIZE(cases); ++i) {
    for (test_mask = MASK_PRIMARY; test_mask <= MASK_BOTH; ++test_mask) {
      BuildTestGptData(gpt);
      ZeroEntries(gpt);
      for(j = 0; j < ARRAY_SIZE(cases[0].entries); ++j) {
        if (!cases[i].entries[j].starting_lba) break;
        if (test_mask & MASK_PRIMARY) {
          if (cases[i].entries[j].active)
            Memcpy(&entries[PRIMARY][j].type, &any_type, sizeof(any_type));
          entries[PRIMARY][j].starting_lba = cases[i].entries[j].starting_lba;
          entries[PRIMARY][j].ending_lba = cases[i].entries[j].ending_lba;
        }
        if (test_mask & MASK_SECONDARY) {
          if (cases[i].entries[j].active)
            Memcpy(&entries[SECONDARY][j].type, &any_type, sizeof(any_type));
          entries[SECONDARY][j].starting_lba = cases[i].entries[j].starting_lba;
          entries[SECONDARY][j].ending_lba = cases[i].entries[j].ending_lba;
        }
      }
      EXPECT((cases[i].overlapped * test_mask) ==
             (OverlappedEntries(entries[PRIMARY], j) |
              (OverlappedEntries(entries[SECONDARY], j) << SECONDARY))
      );

      EXPECT((MASK_BOTH ^ (cases[i].overlapped * test_mask)) ==
             CheckOverlappedPartition(gpt));
    }
  }
  return TEST_OK;
}

/* Tests if GptInit() can survive in different corrupt header/entries
 * combinations, like:
 *   primary GPT header         - valid
 *   primary partition table    - invalid
 *   secondary GPT header       - invalid
 *   secondary partition table  - valid
 */
int CorruptCombinationTest() {
  GptData *gpt;
  GptHeader *primary_header, *secondary_header;
  GptEntry *primary_entries, *secondary_entries;

  gpt = GetEmptyGptData();
  primary_header = (GptHeader*)gpt->primary_header;
  secondary_header = (GptHeader*)gpt->secondary_header;
  primary_entries = (GptEntry*)gpt->primary_entries;
  secondary_entries = (GptEntry*)gpt->secondary_entries;

  /* Make primary entries and secondary header invalid, we expect GptInit()
   * can recover them (returns GPT_SUCCESS and MODIFIED flasgs). */
  BuildTestGptData(gpt);
  primary_entries[0].type.u.raw[0] ^= 0x33;
  secondary_header->header_crc32 ^= 0x55;
  EXPECT(GPT_SUCCESS == GptInit(gpt));
  EXPECT((GPT_MODIFIED_HEADER2 | GPT_MODIFIED_ENTRIES1) == gpt->modified);
  EXPECT(0 == Memcmp(primary_entries, secondary_entries, TOTAL_ENTRIES_SIZE));
  /* We expect the modified header/entries can pass GptInit(). */
  EXPECT(GPT_SUCCESS == GptInit(gpt));
  EXPECT(0 == gpt->modified);

  /* Make primary header invalid (the entries is not damaged actually). */
  BuildTestGptData(gpt);
  primary_header->entries_crc32 ^= 0x73;
  EXPECT(GPT_SUCCESS == GptInit(gpt));
  /* After header is repaired, the entries are valid actually. */
  EXPECT((gpt->modified & (GPT_MODIFIED_HEADER1 | GPT_MODIFIED_HEADER2)) ==
         GPT_MODIFIED_HEADER1);
  /* We expect the modified header/entries can pass GptInit(). */
  EXPECT(GPT_SUCCESS == GptInit(gpt));
  EXPECT(0 == gpt->modified);

  return TEST_OK;
}

/* Invalidate all kernel entries and expect GptNextKernelEntry() cannot find
 * any usable kernel entry.
 */
int NoValidKernelEntryTest() {
  GptData *gpt;
  GptEntry *entries, *entries2;

  gpt = GetEmptyGptData();
  entries = (GptEntry*)gpt->primary_entries;
  entries2 = (GptEntry*)gpt->secondary_entries;

  BuildTestGptData(gpt);
  entries[KERNEL_A].attributes |= CGPT_ATTRIBUTE_BAD_MASK;
  Memset(&entries[KERNEL_B].type, 0, sizeof(Guid));
  RefreshCrc32(gpt);

  EXPECT(GPT_ERROR_NO_VALID_KERNEL == GptNextKernelEntry(gpt, NULL, NULL));

  return TEST_OK;
}

/* This is the combination test. Both kernel A and B could be either inactive
 * or invalid. We expect GptNextKetnelEntry() returns good kernel or
 * GPT_ERROR_NO_VALID_KERNEL if no kernel is available. */
enum FAILURE_MASK {
  MASK_INACTIVE = 1,
  MASK_BAD_ENTRY = 2,
  MASK_FAILURE_BOTH = 3,
};
void BreakAnEntry(GptEntry *entry, enum FAILURE_MASK failure) {
  if (failure & MASK_INACTIVE)
    Memset(&entry->type, 0, sizeof(Guid));
  if (failure & MASK_BAD_ENTRY)
    entry->attributes |= CGPT_ATTRIBUTE_BAD_MASK;
}

int CombinationalNextKernelEntryTest() {
  GptData *gpt;
  enum {
    MASK_KERNEL_A = 1,
    MASK_KERNEL_B = 2,
    MASK_KERNEL_BOTH = 3,
  } kernel;
  enum FAILURE_MASK failure;
  uint64_t start_sector, size;
  int retval;

  for (kernel = MASK_KERNEL_A; kernel <= MASK_KERNEL_BOTH; ++kernel) {
    for (failure = MASK_INACTIVE; failure < MASK_FAILURE_BOTH; ++failure) {
      gpt = GetEmptyGptData();
      BuildTestGptData(gpt);

      if (kernel & MASK_KERNEL_A)
        BreakAnEntry(GetEntry(gpt, PRIMARY, KERNEL_A), failure);
      if (kernel & MASK_KERNEL_B)
        BreakAnEntry(GetEntry(gpt, PRIMARY, KERNEL_B), failure);

      retval = GptNextKernelEntry(gpt, &start_sector, &size);

      if (kernel == MASK_KERNEL_A) {
        EXPECT(retval == GPT_SUCCESS);
        EXPECT(start_sector == 334);
      } else if (kernel == MASK_KERNEL_B) {
        EXPECT(retval == GPT_SUCCESS);
        EXPECT(start_sector == 34);
      } else {  /* MASK_KERNEL_BOTH */
        EXPECT(retval == GPT_ERROR_NO_VALID_KERNEL);
      }
    }
  }
  return TEST_OK;
}

/* Increase tries value from zero, expect it won't explode/overflow after
 * CGPT_ATTRIBUTE_TRIES_MASK.
 */
/* Tries would not count up after CGPT_ATTRIBUTE_MAX_TRIES. */
#define EXPECTED_TRIES(tries) \
    ((tries >= CGPT_ATTRIBUTE_MAX_TRIES) ? CGPT_ATTRIBUTE_MAX_TRIES \
                                         : tries)
int IncreaseTriesTest() {
  GptData *gpt;
  int kernel_index[] = {
    KERNEL_B,
    KERNEL_A,
  };
  int i, tries, j;

  gpt = GetEmptyGptData();
  for (i = 0; i < ARRAY_SIZE(kernel_index); ++i) {
    GptEntry *entries[2] = {
      (GptEntry*)gpt->primary_entries,
      (GptEntry*)gpt->secondary_entries,
    };
    int current;

    BuildTestGptData(gpt);
    current = gpt->current_kernel = kernel_index[i];

    for (tries = 0; tries < 2 * CGPT_ATTRIBUTE_MAX_TRIES; ++tries) {
      for (j = 0; j < ARRAY_SIZE(entries); ++j) {
        EXPECT(EXPECTED_TRIES(tries) ==
               ((entries[j][current].attributes & CGPT_ATTRIBUTE_TRIES_MASK) >>
                CGPT_ATTRIBUTE_TRIES_OFFSET));
      }

      EXPECT(GPT_SUCCESS == GptUpdateKernelEntry(gpt, GPT_UPDATE_ENTRY_TRY));
      /* The expected tries value will be checked in next iteration. */

      if (tries < CGPT_ATTRIBUTE_MAX_TRIES)
        EXPECT((GPT_MODIFIED_HEADER1 | GPT_MODIFIED_ENTRIES1 |
                GPT_MODIFIED_HEADER2 | GPT_MODIFIED_ENTRIES2) == gpt->modified);
      gpt->modified = 0;  /* reset before next test */
      EXPECT(0 ==
             Memcmp(entries[PRIMARY], entries[SECONDARY], TOTAL_ENTRIES_SIZE));
    }
  }
  return TEST_OK;
}

/* Mark a kernel as bad. Expect:
 *   1. the both bad bits of kernel A in primary and secondary entries are set.
 *   2. headers and entries are marked as modified.
 *   3. primary and secondary entries are identical.
 */
int MarkBadKernelEntryTest() {
  GptData *gpt;
  GptEntry *entries, *entries2;

  gpt = GetEmptyGptData();
  entries = (GptEntry*)gpt->primary_entries;
  entries2 = (GptEntry*)gpt->secondary_entries;

  BuildTestGptData(gpt);
  gpt->current_kernel = KERNEL_A;
  EXPECT(GPT_SUCCESS == GptUpdateKernelEntry(gpt, GPT_UPDATE_ENTRY_BAD));
  EXPECT((GPT_MODIFIED_HEADER1 | GPT_MODIFIED_ENTRIES1 |
          GPT_MODIFIED_HEADER2 | GPT_MODIFIED_ENTRIES2) == gpt->modified);
  EXPECT(entries[KERNEL_A].attributes & CGPT_ATTRIBUTE_BAD_MASK);
  EXPECT(entries2[KERNEL_A].attributes & CGPT_ATTRIBUTE_BAD_MASK);
  EXPECT(0 == Memcmp(entries, entries2, TOTAL_ENTRIES_SIZE));

  return TEST_OK;
}

/* Given an invalid kernel type, and expect GptUpdateKernelEntry() returns
 * GPT_ERROR_INVALID_UPDATE_TYPE. */
int UpdateInvalidKernelTypeTest() {
  GptData *gpt;

  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;
}

/* A normal boot case:
 *   GptInit()
 *   GptNextKernelEntry()
 *   GptUpdateKernelEntry()
 */
int NormalBootCase() {
  GptData *gpt;
  GptEntry *entries;
  uint64_t start_sector, size;

  gpt = GetEmptyGptData();
  entries = (GptEntry*)gpt->primary_entries;
  BuildTestGptData(gpt);

  EXPECT(GPT_SUCCESS == GptInit(gpt));
  EXPECT(GPT_SUCCESS == GptNextKernelEntry(gpt, &start_sector, &size));
  EXPECT(start_sector == 34);  /* Kernel A, see top of this file. */
  EXPECT(size == 100);

  EXPECT(GPT_SUCCESS == GptUpdateKernelEntry(gpt, GPT_UPDATE_ENTRY_TRY));
  EXPECT(((entries[KERNEL_A].attributes & CGPT_ATTRIBUTE_TRIES_MASK) >>
           CGPT_ATTRIBUTE_TRIES_OFFSET) == 1);

  return TEST_OK;
}

/* Higher priority kernel should boot first.
 *   KERNEL_A is low priority
 *   KERNEL_B is high priority.
 * We expect KERNEL_B is selected in first run, and then KERNEL_A.
 * We also expect the GptNextKernelEntry() wraps back to KERNEL_B if it's called
 * after twice.
 */
int HigherPriorityTest() {
  GptData *gpt;
  GptEntry *entries;

  gpt = GetEmptyGptData();
  entries = (GptEntry*)gpt->primary_entries;
  BuildTestGptData(gpt);

  SetPriority(gpt, PRIMARY, KERNEL_A, 0);
  SetPriority(gpt, PRIMARY, KERNEL_B, 1);
  RefreshCrc32(gpt);

  EXPECT(GPT_SUCCESS == GptInit(gpt));
  EXPECT(GPT_SUCCESS == GptNextKernelEntry(gpt, NULL, NULL));
  EXPECT(KERNEL_B == gpt->current_kernel);

  EXPECT(GPT_SUCCESS == GptNextKernelEntry(gpt, NULL, NULL));
  EXPECT(KERNEL_A == gpt->current_kernel);

  EXPECT(GPT_SUCCESS == GptNextKernelEntry(gpt, NULL, NULL));
  EXPECT(KERNEL_B == gpt->current_kernel);

  return TEST_OK;
}

int main(int argc, char *argv[]) {
  int i;
  int error_count = 0;
  struct {
    char *name;
    test_func fp;
    int retval;
  } test_cases[] = {
    { TEST_CASE(TestBuildTestGptData), },
    { TEST_CASE(ParameterTests), },
    { TEST_CASE(SignatureTest), },
    { TEST_CASE(RevisionTest), },
    { TEST_CASE(SizeTest), },
    { TEST_CASE(ReservedFieldsTest), },
    { TEST_CASE(MyLbaTest), },
    { TEST_CASE(SizeOfPartitionEntryTest), },
    { TEST_CASE(NumberOfPartitionEntriesTest), },
    { TEST_CASE(PartitionEntryLbaTest), },
    { TEST_CASE(FirstUsableLbaAndLastUsableLbaTest), },
    { TEST_CASE(HeaderCrcTest), },
    { TEST_CASE(EntriesCrcTest), },
    { TEST_CASE(IdenticalEntriesTest), },
    { TEST_CASE(SynonymousHeaderTest), },
    { TEST_CASE(ValidEntryTest), },
    { TEST_CASE(OverlappedPartitionTest), },
    { TEST_CASE(CorruptCombinationTest), },
    { TEST_CASE(TestQuickSortFixed), },
    { TEST_CASE(TestQuickSortRandom), },
    { TEST_CASE(NoValidKernelEntryTest), },
    { TEST_CASE(CombinationalNextKernelEntryTest), },
    { TEST_CASE(IncreaseTriesTest), },
    { TEST_CASE(MarkBadKernelEntryTest), },
    { TEST_CASE(UpdateInvalidKernelTypeTest), },
    { TEST_CASE(NormalBootCase), },
    { TEST_CASE(HigherPriorityTest), },
    { 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;
}