Make vboot_reference build in MSVC command line environment.

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"
 #include "crc32.h"
 #include "crc32_test.h"
 #include "gpt.h"
+#include "test_common.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)
@@ skipping 529 matching lines @@
  * NumberOfPartitionEntries bytes.
  */
 static int EntriesCrcTest() {
   GptData* gpt = GetEmptyGptData();
   GptHeader* h1 = (GptHeader*)gpt->primary_header;
   GptEntry* e1 = (GptEntry*)(gpt->primary_entries);
   GptEntry* e2 = (GptEntry*)(gpt->secondary_entries);
 
   /* Modify the first byte of primary entries, and expect the CRC is wrong. */
   BuildTestGptData(gpt);
-  EXPECT(0 == CheckEntries(e1, h1, gpt->drive_sectors));
-  EXPECT(0 == CheckEntries(e2, h1, gpt->drive_sectors));
+  EXPECT(0 == CheckEntries(e1, h1));
+  EXPECT(0 == CheckEntries(e2, h1));
   gpt->primary_entries[0] ^= 0xa5;  /* just XOR a non-zero value */
   gpt->secondary_entries[TOTAL_ENTRIES_SIZE-1] ^= 0x5a;
-  EXPECT(1 == CheckEntries(e1, h1, gpt->drive_sectors));
-  EXPECT(1 == CheckEntries(e2, h1, gpt->drive_sectors));
+  EXPECT(1 == CheckEntries(e1, h1));
+  EXPECT(1 == CheckEntries(e2, h1));
 
   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
  */
 static int ValidEntryTest() {
   GptData* gpt = GetEmptyGptData();
   GptHeader* h1 = (GptHeader*)gpt->primary_header;
   GptEntry* e1 = (GptEntry*)(gpt->primary_entries);
 
   /* error case: entry.StartingLBA < header.FirstUsableLBA */
   BuildTestGptData(gpt);
   e1[0].starting_lba = h1->first_usable_lba - 1;
   RefreshCrc32(gpt);
-  EXPECT(1 == CheckEntries(e1, h1, gpt->drive_sectors));
+  EXPECT(1 == CheckEntries(e1, h1));
 
   /* error case: entry.EndingLBA > header.LastUsableLBA */
   BuildTestGptData(gpt);
   e1[2].ending_lba = h1->last_usable_lba + 1;
   RefreshCrc32(gpt);
-  EXPECT(1 == CheckEntries(e1, h1, gpt->drive_sectors));
+  EXPECT(1 == CheckEntries(e1, h1));
 
   /* error case: entry.StartingLBA > entry.EndingLBA */
   BuildTestGptData(gpt);
   e1[3].starting_lba = e1[3].ending_lba + 1;
   RefreshCrc32(gpt);
-  EXPECT(1 == CheckEntries(e1, h1, gpt->drive_sectors));
+  EXPECT(1 == CheckEntries(e1, h1));
 
   /* case: non active entry should be ignored. */
   BuildTestGptData(gpt);
   Memset(&e1[1].type, 0, sizeof(e1[1].type));
   e1[1].starting_lba = e1[1].ending_lba + 1;
   RefreshCrc32(gpt);
-  EXPECT(0 == CheckEntries(e1, h1, gpt->drive_sectors));
+  EXPECT(0 == CheckEntries(e1, h1));
 
   return TEST_OK;
 }
 
 
 /* Tests if overlapped partition tables can be detected. */
 static int OverlappedPartitionTest() {
   GptData* gpt = GetEmptyGptData();
   GptHeader* h = (GptHeader*)gpt->primary_header;
   GptEntry* e = (GptEntry*)gpt->primary_entries;
@@ skipping 41 matching lines @@
       if (!cases[i].entries[j].starting_lba)
         break;
 
       if (cases[i].entries[j].active)
         Memcpy(&e[j].type, &guid_kernel, sizeof(Guid));
       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, gpt->drive_sectors));
+    EXPECT(cases[i].overlapped == CheckEntries(e, h));
   }
   return TEST_OK;
 }
 
 
 /* Test both sanity checking and repair. */
 static int SanityCheckTest() {
   GptData* gpt = GetEmptyGptData();
   GptHeader* h1 = (GptHeader*)gpt->primary_header;
 
@@ skipping 135 matching lines @@
   EXPECT((GPT_MODIFIED_HEADER2 | GPT_MODIFIED_ENTRIES2) == gpt->modified);
 
   return TEST_OK;
 }
 
 
 static int EntryAttributeGetSetTest() {
   GptData* gpt = GetEmptyGptData();
   GptEntry* e = (GptEntry*)(gpt->primary_entries);
 
-  e->attrs.whole = 0x0000000000000000LLU;
+  e->attrs.whole = 0x0000000000000000ULL;
   SetEntrySuccessful(e, 1);
-  EXPECT(0x0100000000000000LLU == e->attrs.whole);
+  EXPECT(0x0100000000000000ULL == e->attrs.whole);
   EXPECT(1 == GetEntrySuccessful(e));
-  e->attrs.whole = 0xFFFFFFFFFFFFFFFFLLU;
+  e->attrs.whole = 0xFFFFFFFFFFFFFFFFULL;
   SetEntrySuccessful(e, 0);
-  EXPECT(0xFEFFFFFFFFFFFFFFLLU == e->attrs.whole);
+  EXPECT(0xFEFFFFFFFFFFFFFFULL == e->attrs.whole);
   EXPECT(0 == GetEntrySuccessful(e));
 
-  e->attrs.whole = 0x0000000000000000LLU;
+  e->attrs.whole = 0x0000000000000000ULL;
   SetEntryTries(e, 15);
   EXPECT(15 == GetEntryTries(e));
-  EXPECT(0x00F0000000000000LLU == e->attrs.whole);
-  e->attrs.whole = 0xFFFFFFFFFFFFFFFFLLU;
+  EXPECT(0x00F0000000000000ULL == e->attrs.whole);
+  e->attrs.whole = 0xFFFFFFFFFFFFFFFFULL;
   SetEntryTries(e, 0);
-  EXPECT(0xFF0FFFFFFFFFFFFFLLU == e->attrs.whole);
+  EXPECT(0xFF0FFFFFFFFFFFFFULL == e->attrs.whole);
   EXPECT(0 == GetEntryTries(e));
 
-  e->attrs.whole = 0x0000000000000000LLU;
+  e->attrs.whole = 0x0000000000000000ULL;
   SetEntryPriority(e, 15);
-  EXPECT(0x000F000000000000LLU == e->attrs.whole);
+  EXPECT(0x000F000000000000ULL == e->attrs.whole);
   EXPECT(15 == GetEntryPriority(e));
-  e->attrs.whole = 0xFFFFFFFFFFFFFFFFLLU;
+  e->attrs.whole = 0xFFFFFFFFFFFFFFFFULL;
   SetEntryPriority(e, 0);
-  EXPECT(0xFFF0FFFFFFFFFFFFLLU == e->attrs.whole);
+  EXPECT(0xFFF0FFFFFFFFFFFFULL == e->attrs.whole);
   EXPECT(0 == GetEntryPriority(e));
 
-  e->attrs.whole = 0xFFFFFFFFFFFFFFFFLLU;
+  e->attrs.whole = 0xFFFFFFFFFFFFFFFFULL;
   EXPECT(1 == GetEntrySuccessful(e));
   EXPECT(15 == GetEntryPriority(e));
   EXPECT(15 == GetEntryTries(e));
 
-  e->attrs.whole = 0x0123000000000000LLU;
+  e->attrs.whole = 0x0123000000000000ULL;
   EXPECT(1 == GetEntrySuccessful(e));
   EXPECT(2 == GetEntryTries(e));
   EXPECT(3 == GetEntryPriority(e));
 
   return TEST_OK;
 }
 
 
 static int EntryTypeTest() {
   GptData* gpt = GetEmptyGptData();
@@ skipping 215 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;
 }
 
+/* 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;
   } test_cases[] = {
     { TEST_CASE(StructSizeTest), },
@@ skipping 40 matching lines @@
     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;
 }