Fix non-noise cpplint errors in //crypto.

crypto/rsa_private_key_unittest.cc

 // Copyright (c) 2011 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 "crypto/rsa_private_key.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 85 matching lines @@
   ASSERT_TRUE(keypair3.get());
   ASSERT_TRUE(keypair4.get());
 
   std::vector<uint8_t> privkey3;
   std::vector<uint8_t> privkey4;
   ASSERT_TRUE(keypair3->ExportPrivateKey(&privkey3));
   ASSERT_TRUE(keypair4->ExportPrivateKey(&privkey4));
 
   ASSERT_EQ(privkey1.size(), privkey3.size());
   ASSERT_EQ(privkey2.size(), privkey4.size());
-  ASSERT_TRUE(0 == memcmp(&privkey1.front(), &privkey3.front(),
-                          privkey1.size()));
-  ASSERT_TRUE(0 == memcmp(&privkey2.front(), &privkey4.front(),
-                          privkey2.size()));
+  ASSERT_EQ(0, memcmp(&privkey1.front(), &privkey3.front(), privkey1.size()));
+  ASSERT_EQ(0, memcmp(&privkey2.front(), &privkey4.front(), privkey2.size()));
 }
 
 // Test Copy() method.
 TEST(RSAPrivateKeyUnitTest, CopyTest) {
   std::vector<uint8_t> input(kTestPrivateKeyInfo,
                              kTestPrivateKeyInfo + sizeof(kTestPrivateKeyInfo));
 
   std::unique_ptr<crypto::RSAPrivateKey> key(
       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(input));
 
@@ skipping 68 matching lines @@
   std::vector<uint8_t> input(kTestPrivateKeyInfo,
                              kTestPrivateKeyInfo + sizeof(kTestPrivateKeyInfo));
 
   std::unique_ptr<crypto::RSAPrivateKey> key(
       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(input));
   ASSERT_TRUE(key.get());
 
   std::vector<uint8_t> output;
   ASSERT_TRUE(key->ExportPublicKey(&output));
 
-  ASSERT_TRUE(
-      memcmp(expected_public_key_info, &output.front(), output.size()) == 0);
+  ASSERT_EQ(0,
+            memcmp(expected_public_key_info, &output.front(), output.size()));
 }
 
 // These two test keys each contain an integer that has 0x00 for its most
 // significant byte. When encoded as ASN.1, this byte is dropped and there are
 // two interesting sub-cases. When the sign bit of the integer is set, an extra
 // null byte is added back to force the encoded value to be positive. When the
 // sign bit is not set, the encoded integer is just left shorter than usual.
 // See also: http://code.google.com/p/chromium/issues/detail?id=14877.
 //
 // Before we were handling this correctly, we would see one of two failures:
@@ skipping 132 matching lines @@
   ASSERT_TRUE(keypair1.get());
   ASSERT_TRUE(keypair2.get());
 
   std::vector<uint8_t> output1;
   std::vector<uint8_t> output2;
   ASSERT_TRUE(keypair1->ExportPrivateKey(&output1));
   ASSERT_TRUE(keypair2->ExportPrivateKey(&output2));
 
   ASSERT_EQ(input1.size(), output1.size());
   ASSERT_EQ(input2.size(), output2.size());
-  ASSERT_TRUE(0 == memcmp(&output1.front(), &input1.front(),
-                          input1.size()));
-  ASSERT_TRUE(0 == memcmp(&output2.front(), &input2.front(),
-                          input2.size()));
+  ASSERT_EQ(0, memcmp(&output1.front(), &input1.front(), input1.size()));
+  ASSERT_EQ(0, memcmp(&output2.front(), &input2.front(), input2.size()));
 }
 
 TEST(RSAPrivateKeyUnitTest, CreateFromKeyTest) {
   std::unique_ptr<crypto::RSAPrivateKey> key_pair(
       crypto::RSAPrivateKey::Create(512));
   ASSERT_TRUE(key_pair.get());
 
   std::unique_ptr<crypto::RSAPrivateKey> key_copy(
       crypto::RSAPrivateKey::CreateFromKey(key_pair->key()));
   ASSERT_TRUE(key_copy.get());
 
   std::vector<uint8_t> privkey;
   std::vector<uint8_t> pubkey;
   ASSERT_TRUE(key_pair->ExportPrivateKey(&privkey));
   ASSERT_TRUE(key_pair->ExportPublicKey(&pubkey));
 
   std::vector<uint8_t> privkey_copy;
   std::vector<uint8_t> pubkey_copy;
   ASSERT_TRUE(key_copy->ExportPrivateKey(&privkey_copy));
   ASSERT_TRUE(key_copy->ExportPublicKey(&pubkey_copy));
 
   ASSERT_EQ(privkey, privkey_copy);
   ASSERT_EQ(pubkey, pubkey_copy);
 }