Code change to avoid signed/unsigned mismatch warnings

core/fxcodec/codec/fx_codec_jpx_unittest.cpp

 // Copyright 2014 PDFium 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 <stdint.h>
 
 #include <limits>
 
 #include "core/fxcodec/codec/codec_int.h"
 #include "testing/fx_string_testhelpers.h"
@@ skipping 278 matching lines @@
 
 // Note: Some care needs to be taken here because the skip/seek functions
 // take OPJ_OFF_T's as arguments, which are typically a signed type.
 TEST(fxcodec, DecodeDataSkip) {
   unsigned char buffer[16];
   {
     DecodeData dd(stream_data, sizeof(stream_data));
 
     // Skiping within buffer is allowed.
     memset(buffer, 0xbd, sizeof(buffer));
-    EXPECT_EQ(1, opj_skip_from_memory(1, &dd));
+    EXPECT_EQ(1u, opj_skip_from_memory(1, &dd));
     EXPECT_EQ(1u, opj_read_from_memory(buffer, 1, &dd));
     EXPECT_EQ(0x01, buffer[0]);
     EXPECT_EQ(0xbd, buffer[1]);
 
     // Skiping 0 bytes changes nothing.
     memset(buffer, 0xbd, sizeof(buffer));
     EXPECT_EQ(0, opj_skip_from_memory(0, &dd));
     EXPECT_EQ(1u, opj_read_from_memory(buffer, 1, &dd));
     EXPECT_EQ(0x02, buffer[0]);
     EXPECT_EQ(0xbd, buffer[1]);
 
     // Skiping to EOS-1 is possible.
     memset(buffer, 0xbd, sizeof(buffer));
-    EXPECT_EQ(4, opj_skip_from_memory(4, &dd));
+    EXPECT_EQ(4u, opj_skip_from_memory(4, &dd));
     EXPECT_EQ(1u, opj_read_from_memory(buffer, 1, &dd));
     EXPECT_EQ(0x87, buffer[0]);
     EXPECT_EQ(0xbd, buffer[1]);
 
     // Next read fails.
     memset(buffer, 0xbd, sizeof(buffer));
     EXPECT_EQ(kReadError, opj_read_from_memory(buffer, 1, &dd));
     EXPECT_EQ(0xbd, buffer[0]);
   }
   {
     DecodeData dd(stream_data, sizeof(stream_data));
 
     // Skiping directly to EOS is allowed.
     memset(buffer, 0xbd, sizeof(buffer));
-    EXPECT_EQ(8, opj_skip_from_memory(8, &dd));
+    EXPECT_EQ(8u, opj_skip_from_memory(8, &dd));
 
     // Next read fails.
     EXPECT_EQ(kReadError, opj_read_from_memory(buffer, 1, &dd));
     EXPECT_EQ(0xbd, buffer[0]);
   }
   {
     DecodeData dd(stream_data, sizeof(stream_data));
 
     // Skipping beyond end of stream is allowed and returns full distance.
     memset(buffer, 0xbd, sizeof(buffer));
-    EXPECT_EQ(9, opj_skip_from_memory(9, &dd));
+    EXPECT_EQ(9u, opj_skip_from_memory(9, &dd));
 
     // Next read fails.
     EXPECT_EQ(kReadError, opj_read_from_memory(buffer, 1, &dd));
     EXPECT_EQ(0xbd, buffer[0]);
   }
   {
     DecodeData dd(stream_data, sizeof(stream_data));
 
     // Skipping way beyond EOS is allowd, doesn't wrap, and returns
     // full distance.
     memset(buffer, 0xbd, sizeof(buffer));
-    EXPECT_EQ(4, opj_skip_from_memory(4, &dd));
+    EXPECT_EQ(4u, opj_skip_from_memory(4, &dd));
     EXPECT_EQ(std::numeric_limits<OPJ_OFF_T>::max(),
               opj_skip_from_memory(std::numeric_limits<OPJ_OFF_T>::max(), &dd));
 
     // Next read fails. If it succeeds, it may mean we wrapped.
     EXPECT_EQ(kReadError, opj_read_from_memory(buffer, 1, &dd));
     EXPECT_EQ(0xbd, buffer[0]);
   }
   {
     DecodeData dd(stream_data, sizeof(stream_data));
 
     // Negative skip within buffer not is allowed, position unchanged.
     memset(buffer, 0xbd, sizeof(buffer));
-    EXPECT_EQ(4, opj_skip_from_memory(4, &dd));
+    EXPECT_EQ(4u, opj_skip_from_memory(4, &dd));
     EXPECT_EQ(kSkipError, opj_skip_from_memory(-2, &dd));
 
     // Next read succeeds as if nothing has happenned.
     EXPECT_EQ(1u, opj_read_from_memory(buffer, 1, &dd));
     EXPECT_EQ(0x84, buffer[0]);
     EXPECT_EQ(0xbd, buffer[1]);
 
     // Negative skip before buffer is not allowed, position unchanged.
     memset(buffer, 0xbd, sizeof(buffer));
     EXPECT_EQ(kSkipError, opj_skip_from_memory(-4, &dd));
 
     // Next read succeeds as if nothing has happenned.
     EXPECT_EQ(1u, opj_read_from_memory(buffer, 1, &dd));
     EXPECT_EQ(0x85, buffer[0]);
     EXPECT_EQ(0xbd, buffer[1]);
   }
   {
     DecodeData dd(stream_data, sizeof(stream_data));
 
     // Negative skip way before buffer is not allowed, doesn't wrap
     memset(buffer, 0xbd, sizeof(buffer));
-    EXPECT_EQ(4, opj_skip_from_memory(4, &dd));
+    EXPECT_EQ(4u, opj_skip_from_memory(4, &dd));
     EXPECT_EQ(kSkipError,
               opj_skip_from_memory(std::numeric_limits<OPJ_OFF_T>::min(), &dd));
 
     // Next read succeeds. If it fails, it may mean we wrapped.
-    EXPECT_EQ(1, opj_read_from_memory(buffer, 1, &dd));
+    EXPECT_EQ(1u, opj_read_from_memory(buffer, 1, &dd));
     EXPECT_EQ(0x84, buffer[0]);
     EXPECT_EQ(0xbd, buffer[1]);
   }
   {
     DecodeData dd(stream_data, sizeof(stream_data));
 
     // Negative skip after EOS isn't alowed, still EOS.
     memset(buffer, 0xbd, sizeof(buffer));
-    EXPECT_EQ(8, opj_skip_from_memory(8, &dd));
+    EXPECT_EQ(8u, opj_skip_from_memory(8, &dd));
     EXPECT_EQ(kSkipError, opj_skip_from_memory(-4, &dd));
 
     // Next read fails.
     EXPECT_EQ(kReadError, opj_read_from_memory(buffer, 1, &dd));
     EXPECT_EQ(0xbd, buffer[0]);
   }
 }
 
 TEST(fxcodec, DecodeDataSeek) {
   unsigned char buffer[16];
   DecodeData dd(stream_data, sizeof(stream_data));
 
   // Seeking within buffer is allowed and read succeeds
   memset(buffer, 0xbd, sizeof(buffer));
   EXPECT_TRUE(opj_seek_from_memory(1, &dd));
   EXPECT_EQ(1u, opj_read_from_memory(buffer, 1, &dd));
   EXPECT_EQ(0x01, buffer[0]);
   EXPECT_EQ(0xbd, buffer[1]);
 
   // Seeking before start returns error leaving position unchanged.
   memset(buffer, 0xbd, sizeof(buffer));
   EXPECT_FALSE(opj_seek_from_memory(-1, &dd));
-  EXPECT_EQ(1, opj_read_from_memory(buffer, 1, &dd));
+  EXPECT_EQ(1u, opj_read_from_memory(buffer, 1, &dd));
   EXPECT_EQ(0x02, buffer[0]);
   EXPECT_EQ(0xbd, buffer[1]);
 
   // Seeking way before start returns error leaving position unchanged.
   memset(buffer, 0xbd, sizeof(buffer));
   EXPECT_FALSE(
       opj_seek_from_memory(std::numeric_limits<OPJ_OFF_T>::min(), &dd));
-  EXPECT_EQ(1, opj_read_from_memory(buffer, 1, &dd));
+  EXPECT_EQ(1u, opj_read_from_memory(buffer, 1, &dd));
   EXPECT_EQ(0x03, buffer[0]);
   EXPECT_EQ(0xbd, buffer[1]);
 
   // Seeking exactly to EOS is allowed but read fails.
   memset(buffer, 0xbd, sizeof(buffer));
   EXPECT_TRUE(opj_seek_from_memory(8, &dd));
   EXPECT_EQ(kReadError, opj_read_from_memory(buffer, 1, &dd));
   EXPECT_EQ(0xbd, buffer[0]);
 
   // Seeking back to zero offset is allowed and read succeeds.
@@ skipping 49 matching lines @@
   opj_image_t img;
   memset(&img, 0, sizeof(img));
   img.numcomps = 3;
   img.color_space = OPJ_CLRSPC_SYCC;
   img.comps = FX_Alloc(opj_image_comp_t, 3);
   const struct {
     OPJ_UINT32 w;
     bool expected;
   } cases[] = {{0, false}, {1, false},  {30, false}, {31, true},
                {32, true}, {33, false}, {34, false}, {UINT_MAX, false}};
-  for (int i = 0; i < sizeof(cases) / sizeof(cases[0]); ++i) {
+  for (size_t i = 0; i < sizeof(cases) / sizeof(cases[0]); ++i) {
     y.w = cases[i].w;
     y.h = y.w;
     img.x1 = y.w;
     img.y1 = y.h;
     y.data = FX_Alloc(OPJ_INT32, y.w * y.h);
     memset(y.data, 1, y.w * y.h * sizeof(OPJ_INT32));
     u.data = FX_Alloc(OPJ_INT32, u.w * u.h);
     memset(u.data, 0, u.w * u.h * sizeof(OPJ_INT32));
     v.data = FX_Alloc(OPJ_INT32, v.w * v.h);
     memset(v.data, 0, v.w * v.h * sizeof(OPJ_INT32));
@@ skipping 11 matching lines @@
       EXPECT_NE(img.comps[0].h, img.comps[1].h);
       EXPECT_NE(img.comps[0].w, img.comps[2].w);
       EXPECT_NE(img.comps[0].h, img.comps[2].h);
     }
     FX_Free(img.comps[0].data);
     FX_Free(img.comps[1].data);
     FX_Free(img.comps[2].data);
   }
   FX_Free(img.comps);
 }