clang/win: Let some chromium_code targets build with -Wextra.

sandbox/win/src/policy_opcodes_unittest.cc

 // Copyright (c) 2006-2008 The Chromium 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 "sandbox/win/src/sandbox_types.h"
 #include "sandbox/win/src/sandbox_nt_types.h"
 #include "sandbox/win/src/policy_engine_params.h"
 #include "sandbox/win/src/policy_engine_opcodes.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 104 matching lines @@
   ASSERT_NE(nullptr, op4);
   EXPECT_EQ(EVAL_FALSE, op4->Evaluate(&ppb1, 1, NULL));
 
   // Test that we clear the match context
   PolicyOpcode* op5 = opcode_maker.MakeOpAlwaysTrue(kPolClearContext);
   ASSERT_NE(nullptr, op5);
   MatchContext context;
   context.position = 1;
   context.options = kPolUseOREval;
   EXPECT_EQ(EVAL_TRUE, op5->Evaluate(&ppb1, 1, &context));
-  EXPECT_EQ(0, context.position);
+  EXPECT_EQ(0u, context.position);
   MatchContext context2;
   EXPECT_EQ(context2.options, context.options);
 }
 
 TEST(PolicyEngineTest, OpcodeMakerCase1) {
   // Testing that the opcode maker does not overrun the
   // supplied buffer. It should only be able to make 'count' opcodes.
   void* dummy = NULL;
   ParameterSet ppb1 = ParamPickerMake(dummy);
 
@@ skipping 137 matching lines @@
   EXPECT_TRUE(_countof(txt3) + _countof(txt2) == mc1.position + 2);
 
   // We now keep on matching but now we skip 6 characters which means
   // we skip the string ' over '. And we zero the match context. This is
   // the primitive that we use to build '??'.
   PolicyOpcode* op4 = opcode_maker.MakeOpWStringMatch(0, txt4, 6,
                                                       CASE_SENSITIVE,
                                                       kPolClearContext);
   ASSERT_NE(nullptr, op4);
   EXPECT_EQ(EVAL_TRUE, op4->Evaluate(&pp_tc1, 1, &mc1));
-  EXPECT_EQ(0, mc1.position);
+  EXPECT_EQ(0u, mc1.position);
 
   // Test that we can properly match the last part of the string
   PolicyOpcode* op4b = opcode_maker.MakeOpWStringMatch(0, txt4, kSeekToEnd,
                                                        CASE_SENSITIVE,
                                                        kPolClearContext);
   ASSERT_NE(nullptr, op4b);
   EXPECT_EQ(EVAL_TRUE, op4b->Evaluate(&pp_tc1, 1, &mc1));
-  EXPECT_EQ(0, mc1.position);
+  EXPECT_EQ(0u, mc1.position);
 
   // Test matching 'jumps over' over the entire string. This is the
   // primitive we build '*' from.
   PolicyOpcode* op5 = opcode_maker.MakeOpWStringMatch(0, txt5, kSeekForward,
                                                       CASE_SENSITIVE, kPolNone);
   ASSERT_NE(nullptr, op5);
   EXPECT_EQ(EVAL_TRUE, op5->Evaluate(&pp_tc1, 1, &mc1));
-  EXPECT_EQ(24, mc1.position);
+  EXPECT_EQ(24u, mc1.position);
 
   // Test that we don't match because it is not at the end of the string
   PolicyOpcode* op5b = opcode_maker.MakeOpWStringMatch(0, txt5, kSeekToEnd,
                                                        CASE_SENSITIVE,
                                                        kPolNone);
   ASSERT_NE(nullptr, op5b);
   EXPECT_EQ(EVAL_FALSE, op5b->Evaluate(&pp_tc1, 1, &mc1));
-  EXPECT_EQ(24, mc1.position);
+  EXPECT_EQ(24u, mc1.position);
 
   // Test that we function if the string does not fit. In this case we
   // try to match 'the lazy dog' against 'he lazy dog'.
   PolicyOpcode* op6 = opcode_maker.MakeOpWStringMatch(0, txt4, 2,
                                                       CASE_SENSITIVE, kPolNone);
   ASSERT_NE(nullptr, op6);
   EXPECT_EQ(EVAL_FALSE, op6->Evaluate(&pp_tc1, 1, &mc1));
 
   // Testing matching against 'g' which should be the last char.
   MatchContext mc2;
   PolicyOpcode* op7 = opcode_maker.MakeOpWStringMatch(0, txt6, kSeekForward,
                                                       CASE_SENSITIVE, kPolNone);
   ASSERT_NE(nullptr, op7);
   EXPECT_EQ(EVAL_TRUE, op7->Evaluate(&pp_tc1, 1, &mc2));
-  EXPECT_EQ(37, mc2.position);
+  EXPECT_EQ(37u, mc2.position);
 
   // Trying to match again should fail since we are in the last char.
   // This also covers a couple of boundary conditions.
   EXPECT_EQ(EVAL_FALSE, op7->Evaluate(&pp_tc1, 1, &mc2));
-  EXPECT_EQ(37, mc2.position);
+  EXPECT_EQ(37u, mc2.position);
 }
 
 TEST(PolicyEngineTest, WCharOpcodes2) {
   SetupNtdllImports();
 
   const wchar_t* path1 = L"c:\\documents and settings\\Microsoft\\BLAH.txt";
   const wchar_t txt1[] = L"Settings\\microsoft";
   ParameterSet pp_tc1 = ParamPickerMake(path1);
 
   char memory[kOpcodeMemory];
   OpcodeFactory opcode_maker(memory, sizeof(memory));
   MatchContext mc1;
 
   // Testing case-insensitive does not buy us much since it this option
   // is just passed to the Microsoft API that we use normally, but just for
   // coverage, here it is:
   PolicyOpcode* op1s = opcode_maker.MakeOpWStringMatch(0, txt1, kSeekForward,
                                                       CASE_SENSITIVE, kPolNone);
   ASSERT_NE(nullptr, op1s);
   PolicyOpcode* op1i = opcode_maker.MakeOpWStringMatch(0, txt1, kSeekForward,
                                                        CASE_INSENSITIVE,
                                                        kPolNone);
   ASSERT_NE(nullptr, op1i);
   EXPECT_EQ(EVAL_FALSE, op1s->Evaluate(&pp_tc1, 1, &mc1));
   EXPECT_EQ(EVAL_TRUE, op1i->Evaluate(&pp_tc1, 1, &mc1));
-  EXPECT_EQ(35, mc1.position);
+  EXPECT_EQ(35u, mc1.position);
 }
 
 TEST(PolicyEngineTest, ActionOpcodes) {
   char memory[kOpcodeMemory];
   OpcodeFactory opcode_maker(memory, sizeof(memory));
   MatchContext mc1;
   void* dummy = NULL;
   ParameterSet ppb1 = ParamPickerMake(dummy);
 
   PolicyOpcode* op1 = opcode_maker.MakeOpAction(ASK_BROKER, kPolNone);
   ASSERT_NE(nullptr, op1);
   EXPECT_TRUE(op1->IsAction());
   EXPECT_EQ(ASK_BROKER, op1->Evaluate(&ppb1, 1, &mc1));
 }
 
 }  // namespace sandbox