components/scheduler/child/task_queue_sets_unittest.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/scheduler/child/task_queue_sets.h"
   6
   7 #include "components/scheduler/child/task_queue_impl.h"
   8 #include "testing/gmock/include/gmock/gmock.h"
   9
  10 namespace scheduler {
  11 namespace internal {
  12
  13 class TaskQueueSetsTest : public testing::Test {
  14  public:
  15   void SetUp() override { task_queue_sets_.reset(new TaskQueueSets(kNumSets)); }
  16
  17  protected:
  18   enum {
  19     kNumSets = 5  // An arbitary choice.
  20   };
  21
  22   TaskQueueImpl* NewTaskQueue(const char* queue_name) {
  23     scoped_refptr<internal::TaskQueueImpl> queue =
  24         make_scoped_refptr(new internal::TaskQueueImpl(
  25             nullptr, TaskQueue::Spec(queue_name), "test", "test"));
  26     task_queues_.push_back(queue);
  27     return queue.get();
  28   }
  29
  30   TaskQueueImpl::Task FakeTaskWithEnqueueOrder(int enqueue_order) {
  31     TaskQueueImpl::Task fake_task(FROM_HERE, base::Closure(), 0, true);
  32     fake_task.set_enqueue_order(enqueue_order);
  33     return fake_task;
  34   }
  35
  36   std::vector<scoped_refptr<internal::TaskQueueImpl>> task_queues_;
  37   scoped_ptr<TaskQueueSets> task_queue_sets_;
  38 };
  39
  40 TEST_F(TaskQueueSetsTest, AssignQueueToSet) {
  41   internal::TaskQueueImpl* queue = NewTaskQueue("queue");
  42   size_t set = TaskQueue::NORMAL_PRIORITY;
  43   task_queue_sets_->AssignQueueToSet(queue, set);
  44
  45   EXPECT_EQ(set, queue->get_task_queue_set_index());
  46 }
  47
  48 TEST_F(TaskQueueSetsTest, GetOldestQueueInSet_QueueEmpty) {
  49   internal::TaskQueueImpl* queue = NewTaskQueue("queue");
  50   size_t set = TaskQueue::NORMAL_PRIORITY;
  51   task_queue_sets_->AssignQueueToSet(queue, set);
  52
  53   internal::TaskQueueImpl* selected_queue;
  54   EXPECT_FALSE(task_queue_sets_->GetOldestQueueInSet(set, &selected_queue));
  55 }
  56
  57 TEST_F(TaskQueueSetsTest, OnPushQueue) {
  58   internal::TaskQueueImpl* queue = NewTaskQueue("queue");
  59   size_t set = TaskQueue::NORMAL_PRIORITY;
  60   task_queue_sets_->AssignQueueToSet(queue, set);
  61
  62   internal::TaskQueueImpl* selected_queue;
  63   EXPECT_FALSE(task_queue_sets_->GetOldestQueueInSet(set, &selected_queue));
  64
  65   queue->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(10));
  66   task_queue_sets_->OnPushQueue(queue);
  67
  68   EXPECT_TRUE(task_queue_sets_->GetOldestQueueInSet(set, &selected_queue));
  69   EXPECT_EQ(queue, selected_queue);
  70 }
  71
  72 TEST_F(TaskQueueSetsTest, GetOldestQueueInSet_SingleTaskInSet) {
  73   internal::TaskQueueImpl* queue = NewTaskQueue("queue");
  74   queue->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(10));
  75   size_t set = 1;
  76   task_queue_sets_->AssignQueueToSet(queue, set);
  77
  78   internal::TaskQueueImpl* selected_queue;
  79   EXPECT_TRUE(task_queue_sets_->GetOldestQueueInSet(set, &selected_queue));
  80   EXPECT_EQ(queue, selected_queue);
  81 }
  82
  83 TEST_F(TaskQueueSetsTest, GetOldestQueueInSet_MultipleAgesInSet) {
  84   internal::TaskQueueImpl* queue1 = NewTaskQueue("queue1");
  85   internal::TaskQueueImpl* queue2 = NewTaskQueue("queue2");
  86   internal::TaskQueueImpl* queue3 = NewTaskQueue("queue2");
  87   queue1->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(6));
  88   queue2->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(5));
  89   queue3->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(4));
  90   size_t set = 2;
  91   task_queue_sets_->AssignQueueToSet(queue1, set);
  92   task_queue_sets_->AssignQueueToSet(queue2, set);
  93   task_queue_sets_->AssignQueueToSet(queue3, set);
  94
  95   internal::TaskQueueImpl* selected_queue;
  96   EXPECT_TRUE(task_queue_sets_->GetOldestQueueInSet(set, &selected_queue));
  97   EXPECT_EQ(queue3, selected_queue);
  98 }
  99
 100 TEST_F(TaskQueueSetsTest, OnPopQueue) {
 101   internal::TaskQueueImpl* queue1 = NewTaskQueue("queue1");
 102   internal::TaskQueueImpl* queue2 = NewTaskQueue("queue2");
 103   internal::TaskQueueImpl* queue3 = NewTaskQueue("queue3");
 104   queue1->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(6));
 105   queue2->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(3));
 106   queue2->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(1));
 107   queue3->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(4));
 108   size_t set = 3;
 109   task_queue_sets_->AssignQueueToSet(queue1, set);
 110   task_queue_sets_->AssignQueueToSet(queue2, set);
 111   task_queue_sets_->AssignQueueToSet(queue3, set);
 112
 113   internal::TaskQueueImpl* selected_queue;
 114   EXPECT_TRUE(task_queue_sets_->GetOldestQueueInSet(set, &selected_queue));
 115   EXPECT_EQ(queue2, selected_queue);
 116
 117   queue2->PopTaskFromWorkQueueForTest();
 118   task_queue_sets_->OnPopQueue(queue2);
 119
 120   EXPECT_TRUE(task_queue_sets_->GetOldestQueueInSet(set, &selected_queue));
 121   EXPECT_EQ(queue2, selected_queue);
 122 }
 123
 124 TEST_F(TaskQueueSetsTest, OnPopQueue_QueueBecomesEmpty) {
 125   internal::TaskQueueImpl* queue1 = NewTaskQueue("queue");
 126   internal::TaskQueueImpl* queue2 = NewTaskQueue("queue");
 127   internal::TaskQueueImpl* queue3 = NewTaskQueue("queue");
 128   queue1->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(6));
 129   queue2->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(5));
 130   queue3->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(4));
 131   size_t set = 4;
 132   task_queue_sets_->AssignQueueToSet(queue1, set);
 133   task_queue_sets_->AssignQueueToSet(queue2, set);
 134   task_queue_sets_->AssignQueueToSet(queue3, set);
 135
 136   internal::TaskQueueImpl* selected_queue;
 137   EXPECT_TRUE(task_queue_sets_->GetOldestQueueInSet(set, &selected_queue));
 138   EXPECT_EQ(queue3, selected_queue);
 139
 140   queue3->PopTaskFromWorkQueueForTest();
 141   task_queue_sets_->OnPopQueue(queue3);
 142
 143   EXPECT_TRUE(task_queue_sets_->GetOldestQueueInSet(set, &selected_queue));
 144   EXPECT_EQ(queue2, selected_queue);
 145 }
 146
 147 TEST_F(TaskQueueSetsTest,
 148        GetOldestQueueInSet_MultipleAgesInSetIntegerRollover) {
 149   internal::TaskQueueImpl* queue1 = NewTaskQueue("queue1");
 150   internal::TaskQueueImpl* queue2 = NewTaskQueue("queue2");
 151   internal::TaskQueueImpl* queue3 = NewTaskQueue("queue3");
 152   queue1->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(0x7ffffff1));
 153   queue2->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(0x7ffffff0));
 154   queue3->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(-0x7ffffff1));
 155   size_t set = 0;
 156   task_queue_sets_->AssignQueueToSet(queue1, set);
 157   task_queue_sets_->AssignQueueToSet(queue2, set);
 158   task_queue_sets_->AssignQueueToSet(queue3, set);
 159
 160   internal::TaskQueueImpl* selected_queue;
 161   EXPECT_TRUE(task_queue_sets_->GetOldestQueueInSet(set, &selected_queue));
 162   EXPECT_EQ(queue2, selected_queue);
 163 }
 164
 165 TEST_F(TaskQueueSetsTest, GetOldestQueueInSet_MultipleAgesInSet_RemoveQueue) {
 166   internal::TaskQueueImpl* queue1 = NewTaskQueue("queue1");
 167   internal::TaskQueueImpl* queue2 = NewTaskQueue("queue2");
 168   internal::TaskQueueImpl* queue3 = NewTaskQueue("queue3");
 169   queue1->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(6));
 170   queue2->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(5));
 171   queue3->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(4));
 172   size_t set = 1;
 173   task_queue_sets_->AssignQueueToSet(queue1, set);
 174   task_queue_sets_->AssignQueueToSet(queue2, set);
 175   task_queue_sets_->AssignQueueToSet(queue3, set);
 176   task_queue_sets_->RemoveQueue(queue3);
 177
 178   internal::TaskQueueImpl* selected_queue;
 179   EXPECT_TRUE(task_queue_sets_->GetOldestQueueInSet(set, &selected_queue));
 180   EXPECT_EQ(queue2, selected_queue);
 181 }
 182
 183 TEST_F(TaskQueueSetsTest, AssignQueueToSet_Complex) {
 184   internal::TaskQueueImpl* queue1 = NewTaskQueue("queue1");
 185   internal::TaskQueueImpl* queue2 = NewTaskQueue("queue2");
 186   internal::TaskQueueImpl* queue3 = NewTaskQueue("queue3");
 187   internal::TaskQueueImpl* queue4 = NewTaskQueue("queue4");
 188   queue1->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(6));
 189   queue2->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(5));
 190   queue3->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(4));
 191   queue4->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(3));
 192   size_t set1 = 1;
 193   size_t set2 = 2;
 194   task_queue_sets_->AssignQueueToSet(queue1, set1);
 195   task_queue_sets_->AssignQueueToSet(queue2, set1);
 196   task_queue_sets_->AssignQueueToSet(queue3, set2);
 197   task_queue_sets_->AssignQueueToSet(queue4, set2);
 198
 199   internal::TaskQueueImpl* selected_queue;
 200   EXPECT_TRUE(task_queue_sets_->GetOldestQueueInSet(set1, &selected_queue));
 201   EXPECT_EQ(queue2, selected_queue);
 202
 203   EXPECT_TRUE(task_queue_sets_->GetOldestQueueInSet(set2, &selected_queue));
 204   EXPECT_EQ(queue4, selected_queue);
 205
 206   task_queue_sets_->AssignQueueToSet(queue4, set1);
 207
 208   EXPECT_TRUE(task_queue_sets_->GetOldestQueueInSet(set1, &selected_queue));
 209   EXPECT_EQ(queue4, selected_queue);
 210
 211   EXPECT_TRUE(task_queue_sets_->GetOldestQueueInSet(set2, &selected_queue));
 212   EXPECT_EQ(queue3, selected_queue);
 213 }
 214
 215 TEST_F(TaskQueueSetsTest, IsSetEmpty_NoWork) {
 216   size_t set = 0;
 217   EXPECT_TRUE(task_queue_sets_->IsSetEmpty(set));
 218
 219   internal::TaskQueueImpl* queue = NewTaskQueue("queue");
 220   task_queue_sets_->AssignQueueToSet(queue, set);
 221   EXPECT_TRUE(task_queue_sets_->IsSetEmpty(set));
 222 }
 223
 224 TEST_F(TaskQueueSetsTest, IsSetEmpty_Work) {
 225   size_t set = 0;
 226   EXPECT_TRUE(task_queue_sets_->IsSetEmpty(set));
 227
 228   internal::TaskQueueImpl* queue = NewTaskQueue("queue");
 229   queue->PushTaskOntoWorkQueueForTest(FakeTaskWithEnqueueOrder(1));
 230   task_queue_sets_->AssignQueueToSet(queue, set);
 231   EXPECT_FALSE(task_queue_sets_->IsSetEmpty(set));
 232
 233   queue->PopTaskFromWorkQueueForTest();
 234   task_queue_sets_->OnPopQueue(queue);
 235   EXPECT_TRUE(task_queue_sets_->IsSetEmpty(set));
 236 }
 237
 238 }  // namespace internal
 239 }  // namespace scheduler