Fix a -Wsign-compare error under GCC 4.9.2.

test/unittests/atomic-utils-unittest.cc

 // Copyright 2014 the V8 project 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 <limits.h>
 
 #include "src/atomic-utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace v8 {
 namespace internal {
 
 TEST(AtomicNumber, Constructor) {
   // Test some common types.
   AtomicNumber<int> zero_int;
   AtomicNumber<size_t> zero_size_t;
   AtomicNumber<intptr_t> zero_intptr_t;
   EXPECT_EQ(0, zero_int.Value());
-  EXPECT_EQ(0, zero_size_t.Value());
+  EXPECT_EQ(0U, zero_size_t.Value());
   EXPECT_EQ(0, zero_intptr_t.Value());
 }
 
 
 TEST(AtomicNumber, Value) {
   AtomicNumber<int> a(1);
   EXPECT_EQ(1, a.Value());
   AtomicNumber<int> b(-1);
   EXPECT_EQ(-1, b.Value());
   AtomicNumber<size_t> c(1);
-  EXPECT_EQ(1, c.Value());
+  EXPECT_EQ(1U, c.Value());
   AtomicNumber<size_t> d(static_cast<size_t>(-1));
   EXPECT_EQ(std::numeric_limits<size_t>::max(), d.Value());
 }
 
 
 TEST(AtomicNumber, SetValue) {
   AtomicNumber<int> a(1);
   a.SetValue(-1);
   EXPECT_EQ(-1, a.Value());
 }
 
 
 TEST(AtomicNumber, Increment) {
   AtomicNumber<int> a(std::numeric_limits<int>::max());
   a.Increment(1);
   EXPECT_EQ(std::numeric_limits<int>::min(), a.Value());
   // Check that potential signed-ness of the underlying storage has no impact
   // on unsigned types.
   AtomicNumber<size_t> b(std::numeric_limits<intptr_t>::max());
   b.Increment(1);
   EXPECT_EQ(static_cast<size_t>(std::numeric_limits<intptr_t>::max()) + 1,
             b.Value());
   // Should work as decrement as well.
   AtomicNumber<size_t> c(1);
   c.Increment(-1);
-  EXPECT_EQ(0, c.Value());
+  EXPECT_EQ(0U, c.Value());
   c.Increment(-1);
   EXPECT_EQ(std::numeric_limits<size_t>::max(), c.Value());
 }
 
 
 namespace {
 
 enum TestFlag {
   kA,
   kB,
@@ skipping 141 matching lines @@
   a.Add(kAA);
   EXPECT_FALSE(a == b);
   EXPECT_TRUE(a != b);
   b.Add(kAA);
   EXPECT_TRUE(a == b);
   EXPECT_FALSE(a != b);
 }
 
 }  // namespace internal
 }  // namespace v8