Refactor net tests to use GMock matchers for checking net::Error results

net/ssl/default_channel_id_store_unittest.cc

 // Copyright 2014 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 "net/ssl/default_channel_id_store.h"
 
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "crypto/ec_private_key.h"
 #include "net/base/net_errors.h"
 #include "net/test/channel_id_test_util.h"
+#include "net/test/gtest_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using net::test::IsError;
+using net::test::IsOk;
+
 namespace net {
 
 namespace {
 
 void CallCounter(int* counter) {
   (*counter)++;
 }
 
 void GetChannelIDCallbackNotCalled(
     int err,
@@ skipping 174 matching lines @@
   EXPECT_EQ(ERR_IO_PENDING,
             store.GetChannelID("verisign.com", &key,
                                base::Bind(&AsyncGetChannelIDHelper::Callback,
                                           base::Unretained(&helper))));
 
   // Wait for load & queued get tasks.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, store.GetChannelIDCount());
   EXPECT_FALSE(key);
   EXPECT_TRUE(helper.called_);
-  EXPECT_EQ(OK, helper.err_);
+  EXPECT_THAT(helper.err_, IsOk());
   EXPECT_EQ("verisign.com", helper.server_identifier_);
   EXPECT_TRUE(KeysEqual(expected_key.get(), helper.key_.get()));
 }
 
 TEST(DefaultChannelIDStoreTest, TestDeleteAll) {
   scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore);
   DefaultChannelIDStore store(persistent_store.get());
 
   store.SetChannelID(base::WrapUnique(new ChannelIDStore::ChannelID(
       "verisign.com", base::Time(), crypto::ECPrivateKey::Create())));
@@ skipping 137 matching lines @@
 
   EXPECT_EQ(0, delete_finished);
   EXPECT_FALSE(a_helper.called_);
   EXPECT_FALSE(b_helper.called_);
   // Wait for load & queued tasks.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, delete_finished);
   EXPECT_EQ(1, store.GetChannelIDCount());
   EXPECT_FALSE(key);
   EXPECT_TRUE(a_helper.called_);
-  EXPECT_EQ(ERR_FILE_NOT_FOUND, a_helper.err_);
+  EXPECT_THAT(a_helper.err_, IsError(ERR_FILE_NOT_FOUND));
   EXPECT_EQ("a.com", a_helper.server_identifier_);
   EXPECT_FALSE(a_helper.key_);
   EXPECT_TRUE(b_helper.called_);
-  EXPECT_EQ(OK, b_helper.err_);
+  EXPECT_THAT(b_helper.err_, IsOk());
   EXPECT_EQ("b.com", b_helper.server_identifier_);
   EXPECT_TRUE(KeysEqual(expected_key.get(), b_helper.key_.get()));
 }
 
 TEST(DefaultChannelIDStoreTest, TestGetAll) {
   scoped_refptr<MockPersistentStore> persistent_store(new MockPersistentStore);
   DefaultChannelIDStore store(persistent_store.get());
 
   EXPECT_EQ(0, store.GetChannelIDCount());
   store.SetChannelID(base::WrapUnique(new ChannelIDStore::ChannelID(
@@ skipping 97 matching lines @@
   ++channel_id;
   EXPECT_EQ("copied.com", channel_id->server_identifier());
   EXPECT_TRUE(KeysEqual(copied_key.get(), channel_id->key()));
 
   ++channel_id;
   EXPECT_EQ("preexisting.com", channel_id->server_identifier());
   EXPECT_TRUE(KeysEqual(preexisting_key.get(), channel_id->key()));
 }
 
 }  // namespace net