Make vboot_reference build in MSVC command line environment.

tests/vboot_common2_tests.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.
  *
  * Tests for firmware image library.
  */
 
 #include <stdio.h>
 #include <stdlib.h>
 
@@ skipping 16 matching lines @@
           "PublicKeyToRSA() invalid algorithm");
 
   PublicKeyCopy(key, orig_key);
   key->key_size -= 1;
   TEST_EQ((size_t)PublicKeyToRSA(key), 0,
           "PublicKeyToRSA() invalid size");
 
   rsa = PublicKeyToRSA(orig_key);
   TEST_NEQ((size_t)rsa, 0, "PublicKeyToRSA() ok");
   if (rsa) {
-    TEST_EQ(rsa->algorithm, key->algorithm, "PublicKeyToRSA() algorithm");
+    TEST_EQ((int)rsa->algorithm, (int)key->algorithm,
+            "PublicKeyToRSA() algorithm");
     RSAPublicKeyFree(rsa);
   }
 }
 
 
 static void VerifyDataTest(const VbPublicKey* public_key,
                            const VbPrivateKey* private_key) {
 
   const uint8_t test_data[] = "This is some test data to sign.";
   VbSignature* sig;
@@ skipping 22 matching lines @@
 static void VerifyDigestTest(const VbPublicKey* public_key,
                            const VbPrivateKey* private_key) {
 
   const uint8_t test_data[] = "This is some other test data to sign.";
   VbSignature* sig;
   RSAPublicKey* rsa;
   uint8_t* digest;
 
   sig = CalculateSignature(test_data, sizeof(test_data), private_key);
   rsa = PublicKeyToRSA(public_key);
-  digest = DigestBuf(test_data, sizeof(test_data), public_key->algorithm);
+  digest = DigestBuf(test_data, sizeof(test_data), (int)public_key->algorithm);
   TEST_NEQ(sig && rsa && digest, 0, "VerifyData() prerequisites");
   if (!sig || !rsa || !digest)
     return;
 
   TEST_EQ(VerifyDigest(digest, sig, rsa), 0, "VerifyDigest() ok");
 
   GetSignatureData(sig)[0] ^= 0x5A;
   TEST_EQ(VerifyDigest(digest, sig, rsa), 1, "VerifyDigest() wrong sig");
 
   RSAPublicKeyFree(rsa);
@@ skipping 11 matching lines @@
   Free(sig);
 }
 
 
 static void VerifyKernelPreambleTest(const VbPublicKey* public_key,
                                      const VbPrivateKey* private_key) {
 
   VbKernelPreambleHeader *hdr;
   VbKernelPreambleHeader *h;
   RSAPublicKey* rsa;
-  uint64_t hsize;
+  unsigned hsize;
 
   /* Create a dummy signature */
   VbSignature *body_sig = SignatureAlloc(56, 78);
 
   rsa = PublicKeyToRSA(public_key);
   hdr = CreateKernelPreamble(0x1234, 0x100000, 0x300000, 0x4000, body_sig,
                              0, private_key);
   TEST_NEQ(hdr && rsa, 0, "VerifyKernelPreamble2() prerequisites");
   if (!hdr)
     return;
-  hsize = hdr->preamble_size;
+  hsize = (unsigned) hdr->preamble_size;
   h = (VbKernelPreambleHeader*)Malloc(hsize + 16384);
 
   TEST_EQ(VerifyKernelPreamble2(hdr, hsize, rsa), 0,
           "VerifyKernelPreamble2() ok using key");
   TEST_NEQ(VerifyKernelPreamble2(hdr, hsize - 1, rsa), 0,
            "VerifyKernelPreamble2() size--");
   TEST_EQ(VerifyKernelPreamble2(hdr, hsize + 1, rsa), 0,
            "VerifyKernelPreamble2() size++");
 
   /* Care about major version but not minor */
@@ skipping 95 matching lines @@
   VerifyDigestTest(public_key, private_key);
   VerifyKernelPreambleTest(public_key, private_key);
 
   if (public_key)
     Free(public_key);
   if (private_key)
     Free(private_key);
 
   return error_code;
 }