Be explicit about namespace testing to not mix it with blink::testing

third_party/WebKit/Source/platform/scheduler/base/task_queue_selector_unittest.cc

 // Copyright 2015 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 "platform/scheduler/base/task_queue_selector.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/pending_task.h"
 #include "platform/scheduler/base/task_queue_impl.h"
 #include "platform/scheduler/base/virtual_time_domain.h"
 #include "platform/scheduler/base/work_queue.h"
 #include "platform/scheduler/base/work_queue_sets.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using testing::_;
+using ::testing::_;
 
 namespace blink {
 namespace scheduler {
 namespace internal {
 
 class MockObserver : public TaskQueueSelector::Observer {
  public:
   MockObserver() {}
   virtual ~MockObserver() {}
 
   MOCK_METHOD1(OnTaskQueueEnabled, void(internal::TaskQueueImpl*));
   MOCK_METHOD1(OnTriedToSelectBlockedWorkQueue, void(internal::WorkQueue*));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockObserver);
 };
 
 class TaskQueueSelectorForTest : public TaskQueueSelector {
  public:
   using TaskQueueSelector::SetImmediateStarvationCountForTest;
   using TaskQueueSelector::PrioritizingSelector;
   using TaskQueueSelector::enabled_selector_for_test;
 };
 
-class TaskQueueSelectorTest : public testing::Test {
+class TaskQueueSelectorTest : public ::testing::Test {
  public:
   TaskQueueSelectorTest()
       : test_closure_(base::Bind(&TaskQueueSelectorTest::TestFunction)) {}
   ~TaskQueueSelectorTest() override {}
 
   TaskQueueSelectorForTest::PrioritizingSelector* enabled_selector() {
     return selector_.enabled_selector_for_test();
   }
 
   WorkQueueSets* delayed_work_queue_sets() {
@@ skipping 98 matching lines @@
   base::Closure test_closure_;
   TaskQueueSelectorForTest selector_;
   std::unique_ptr<VirtualTimeDomain> virtual_time_domain_;
   std::vector<scoped_refptr<TaskQueueImpl>> task_queues_;
   std::map<TaskQueueImpl*, size_t> queue_to_index_map_;
 };
 
 TEST_F(TaskQueueSelectorTest, TestDefaultPriority) {
   size_t queue_order[] = {4, 3, 2, 1, 0};
   PushTasks(queue_order, 5);
-  EXPECT_THAT(PopTasks(), testing::ElementsAre(4, 3, 2, 1, 0));
+  EXPECT_THAT(PopTasks(), ::testing::ElementsAre(4, 3, 2, 1, 0));
 }
 
 TEST_F(TaskQueueSelectorTest, TestHighPriority) {
   size_t queue_order[] = {0, 1, 2, 3, 4};
   PushTasks(queue_order, 5);
   selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::HIGH_PRIORITY);
-  EXPECT_THAT(PopTasks(), testing::ElementsAre(2, 0, 1, 3, 4));
+  EXPECT_THAT(PopTasks(), ::testing::ElementsAre(2, 0, 1, 3, 4));
 }
 
 TEST_F(TaskQueueSelectorTest, TestLowPriority) {
   size_t queue_order[] = {0, 1, 2, 3, 4};
   PushTasks(queue_order, 5);
   selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::LOW_PRIORITY);
-  EXPECT_THAT(PopTasks(), testing::ElementsAre(0, 1, 3, 4, 2));
+  EXPECT_THAT(PopTasks(), ::testing::ElementsAre(0, 1, 3, 4, 2));
 }
 
 TEST_F(TaskQueueSelectorTest, TestBestEffortPriority) {
   size_t queue_order[] = {0, 1, 2, 3, 4};
   PushTasks(queue_order, 5);
   selector_.SetQueuePriority(task_queues_[0].get(),
                              TaskQueue::BEST_EFFORT_PRIORITY);
   selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::LOW_PRIORITY);
   selector_.SetQueuePriority(task_queues_[3].get(), TaskQueue::HIGH_PRIORITY);
-  EXPECT_THAT(PopTasks(), testing::ElementsAre(3, 1, 4, 2, 0));
+  EXPECT_THAT(PopTasks(), ::testing::ElementsAre(3, 1, 4, 2, 0));
 }
 
 TEST_F(TaskQueueSelectorTest, TestControlPriority) {
   size_t queue_order[] = {0, 1, 2, 3, 4};
   PushTasks(queue_order, 5);
   selector_.SetQueuePriority(task_queues_[4].get(),
                              TaskQueue::CONTROL_PRIORITY);
   EXPECT_EQ(TaskQueue::CONTROL_PRIORITY, task_queues_[4]->GetQueuePriority());
   selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::HIGH_PRIORITY);
   EXPECT_EQ(TaskQueue::HIGH_PRIORITY, task_queues_[2]->GetQueuePriority());
-  EXPECT_THAT(PopTasks(), testing::ElementsAre(4, 2, 0, 1, 3));
+  EXPECT_THAT(PopTasks(), ::testing::ElementsAre(4, 2, 0, 1, 3));
 }
 
 TEST_F(TaskQueueSelectorTest, TestObserverWithEnabledQueue) {
   std::unique_ptr<TaskQueue::QueueEnabledVoter> voter1 =
       task_queues_[1]->CreateQueueEnabledVoter();
   DisableQueue(voter1.get());
   MockObserver mock_observer;
   selector_.SetTaskQueueSelectorObserver(&mock_observer);
   EXPECT_CALL(mock_observer, OnTaskQueueEnabled(_)).Times(1);
   EnableQueue(voter1.get());
@@ skipping 16 matching lines @@
   PushTasks(queue_order, 5);
   std::unique_ptr<TaskQueue::QueueEnabledVoter> voter2 =
       task_queues_[2]->CreateQueueEnabledVoter();
   std::unique_ptr<TaskQueue::QueueEnabledVoter> voter4 =
       task_queues_[4]->CreateQueueEnabledVoter();
   DisableQueue(voter2.get());
   DisableQueue(voter4.get());
   // Disabling a queue should not affect its priority.
   EXPECT_EQ(TaskQueue::NORMAL_PRIORITY, task_queues_[2]->GetQueuePriority());
   EXPECT_EQ(TaskQueue::NORMAL_PRIORITY, task_queues_[4]->GetQueuePriority());
-  EXPECT_THAT(PopTasks(), testing::ElementsAre(0, 1, 3));
+  EXPECT_THAT(PopTasks(), ::testing::ElementsAre(0, 1, 3));
 
   EXPECT_CALL(mock_observer, OnTaskQueueEnabled(_)).Times(2);
   EnableQueue(voter2.get());
   selector_.SetQueuePriority(task_queues_[2].get(),
                              TaskQueue::BEST_EFFORT_PRIORITY);
-  EXPECT_THAT(PopTasks(), testing::ElementsAre(2));
+  EXPECT_THAT(PopTasks(), ::testing::ElementsAre(2));
   EnableQueue(voter4.get());
-  EXPECT_THAT(PopTasks(), testing::ElementsAre(4));
+  EXPECT_THAT(PopTasks(), ::testing::ElementsAre(4));
 }
 
 TEST_F(TaskQueueSelectorTest, TestDisableChangePriorityThenEnable) {
   EXPECT_TRUE(task_queues_[2]->delayed_work_queue()->Empty());
   EXPECT_TRUE(task_queues_[2]->immediate_work_queue()->Empty());
 
   std::unique_ptr<TaskQueue::QueueEnabledVoter> voter2 =
       task_queues_[2]->CreateQueueEnabledVoter();
   DisableQueue(voter2.get());
   selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::HIGH_PRIORITY);
 
   size_t queue_order[] = {0, 1, 2, 3, 4};
   PushTasks(queue_order, 5);
 
   EXPECT_TRUE(task_queues_[2]->delayed_work_queue()->Empty());
   EXPECT_FALSE(task_queues_[2]->immediate_work_queue()->Empty());
   EnableQueue(voter2.get());
 
   EXPECT_EQ(TaskQueue::HIGH_PRIORITY, task_queues_[2]->GetQueuePriority());
-  EXPECT_THAT(PopTasks(), testing::ElementsAre(2, 0, 1, 3, 4));
+  EXPECT_THAT(PopTasks(), ::testing::ElementsAre(2, 0, 1, 3, 4));
 }
 
 TEST_F(TaskQueueSelectorTest, TestEmptyQueues) {
   WorkQueue* chosen_work_queue = nullptr;
   EXPECT_FALSE(selector_.SelectWorkQueueToService(&chosen_work_queue));
 
   // Test only disabled queues.
   size_t queue_order[] = {0};
   PushTasks(queue_order, 1);
   std::unique_ptr<TaskQueue::QueueEnabledVoter> voter0 =
       task_queues_[0]->CreateQueueEnabledVoter();
   DisableQueue(voter0.get());
   EXPECT_FALSE(selector_.SelectWorkQueueToService(&chosen_work_queue));
 
   // These tests are unusual since there's no TQM. To avoid a later DCHECK when
   // deleting the task queue, we re-enable the queue here so the selector
   // doesn't get out of sync.
   EnableQueue(voter0.get());
 }
 
 TEST_F(TaskQueueSelectorTest, TestAge) {
   size_t enqueue_order[] = {10, 1, 2, 9, 4};
   size_t queue_order[] = {0, 1, 2, 3, 4};
   PushTasksWithEnqueueOrder(queue_order, enqueue_order, 5);
-  EXPECT_THAT(PopTasks(), testing::ElementsAre(1, 2, 4, 3, 0));
+  EXPECT_THAT(PopTasks(), ::testing::ElementsAre(1, 2, 4, 3, 0));
 }
 
 TEST_F(TaskQueueSelectorTest, TestControlStarvesOthers) {
   size_t queue_order[] = {0, 1, 2, 3};
   PushTasks(queue_order, 4);
   selector_.SetQueuePriority(task_queues_[3].get(),
                              TaskQueue::CONTROL_PRIORITY);
   selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::HIGH_PRIORITY);
   selector_.SetQueuePriority(task_queues_[1].get(),
                              TaskQueue::BEST_EFFORT_PRIORITY);
@@ skipping 204 matching lines @@
                             true);
   task1.set_enqueue_order(0);
   task2.set_enqueue_order(1);
   task_queue->immediate_work_queue()->Push(std::move(task1));
   task_queue2->immediate_work_queue()->Push(std::move(task2));
 
   // Should still only see one call to OnTriedToSelectBlockedWorkQueue.
   WorkQueue* chosen_work_queue;
   EXPECT_CALL(mock_observer, OnTriedToSelectBlockedWorkQueue(_)).Times(1);
   EXPECT_FALSE(selector.SelectWorkQueueToService(&chosen_work_queue));
-  testing::Mock::VerifyAndClearExpectations(&mock_observer);
+  ::testing::Mock::VerifyAndClearExpectations(&mock_observer);
 
   EXPECT_CALL(mock_observer, OnTaskQueueEnabled(_)).Times(2);
 
   voter.reset();
   selector.EnableQueue(task_queue.get());
 
   // Removing the second queue and selecting again should result in another
   // notification.
   task_queue->UnregisterTaskQueue();
   selector.RemoveQueue(task_queue.get());
@@ skipping 17 matching lines @@
 static const ChooseOldestWithPriorityTestParam
     kChooseOldestWithPriorityTestCases[] = {
         {1, 2, 0, "delayed", true},    {1, 2, 1, "delayed", true},
         {1, 2, 2, "delayed", true},    {1, 2, 3, "immediate", false},
         {1, 2, 4, "immediate", false}, {2, 1, 4, "immediate", false},
         {2, 1, 4, "immediate", false},
 };
 
 class ChooseOldestWithPriorityTest
     : public TaskQueueSelectorTest,
-      public testing::WithParamInterface<ChooseOldestWithPriorityTestParam> {};
+      public ::testing::WithParamInterface<ChooseOldestWithPriorityTestParam> {
+};
 
 TEST_P(ChooseOldestWithPriorityTest, RoundRobinTest) {
   task_queues_[0]->immediate_work_queue()->Push(
       TaskQueueImpl::Task(FROM_HERE, test_closure_, base::TimeTicks(),
                           GetParam().immediate_task_enqueue_order, true,
                           GetParam().immediate_task_enqueue_order));
 
   task_queues_[0]->delayed_work_queue()->Push(
       TaskQueueImpl::Task(FROM_HERE, test_closure_, base::TimeTicks(),
                           GetParam().delayed_task_enqueue_order, true,
                           GetParam().delayed_task_enqueue_order));
 
   selector_.SetImmediateStarvationCountForTest(
       GetParam().immediate_starvation_count);
 
   WorkQueue* chosen_work_queue = nullptr;
   bool chose_delayed_over_immediate = false;
   EXPECT_TRUE(enabled_selector()->ChooseOldestWithPriority(
       TaskQueue::NORMAL_PRIORITY, &chose_delayed_over_immediate,
       &chosen_work_queue));
   EXPECT_EQ(chosen_work_queue->task_queue(), task_queues_[0].get());
   EXPECT_STREQ(chosen_work_queue->GetName(),
                GetParam().expected_work_queue_name);
   EXPECT_EQ(chose_delayed_over_immediate,
             GetParam().expected_did_starve_immediate_queue);
 }
 
-INSTANTIATE_TEST_CASE_P(ChooseOldestWithPriorityTest,
-                        ChooseOldestWithPriorityTest,
-                        testing::ValuesIn(kChooseOldestWithPriorityTestCases));
+INSTANTIATE_TEST_CASE_P(
+    ChooseOldestWithPriorityTest,
+    ChooseOldestWithPriorityTest,
+    ::testing::ValuesIn(kChooseOldestWithPriorityTestCases));
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink