← Back to branch summary

~ken-vandine/indicator-transfer/ual_api_change

« back to all changes in this revision

Viewing changes to tests/test-controller.cpp

  • Committer: CI Train Bot
  • Author(s): Renato Araujo Oliveira Filho
  • Date: 2015-08-19 19:17:06 UTC
  • mfrom: (29.6.11 add-plugins-fix-model-clear)
  • Revision ID: ci-train-bot@canonical.com-20150819191706-k1jnor3lh4n26zax
Added 'clear' function into the Source interface.
Call 'Source.clear' in the 'Controller.clear_all' function.
Does not keep a separated copy of source model inside of the Controller class.
Changed the return of 'Source.get_model()' to const.
Update unit tests.
Approved by: Charles Kerr, PS Jenkins bot

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test-controller.cpp
36
36
  GTestDBus* bus = nullptr;
37
37
 
38
38
  std::shared_ptr<MockSource> m_source;
39
 
  std::shared_ptr<MutableModel> m_model;
40
39
  std::shared_ptr<Controller> m_controller;
41
40
 
42
41
  void SetUp()
44
43
    super::SetUp();
45
44
 
46
45
    m_source.reset(new MockSource);
47
 
    m_model.reset(new MutableModel);
48
 
    m_controller.reset(new Controller(m_model, m_source));
 
46
    m_controller.reset(new Controller(m_source));
49
47
  }
50
48
 
51
49
  void TearDown()
52
50
  {
53
51
    m_controller.reset();
54
 
    m_model.reset();
55
52
    m_source.reset();
56
53
 
57
54
    super::TearDown();
102
99
      auto t = std::make_shared<Transfer>();
103
100
      t->state = transfer.state;
104
101
      t->id = transfer.id;
105
 
      m_model->add(t);
 
102
      m_source->m_model->add(t);
106
103
    }
107
104
 
108
105
  // make sure all the transfers made it into the model
109
 
  auto ids = m_model->get_ids();
110
 
  EXPECT_EQ(G_N_ELEMENTS(transfers), ids.size());
 
106
  EXPECT_EQ(G_N_ELEMENTS(transfers), m_controller->size());
111
107
  for (const auto& transfer : transfers)
112
 
    EXPECT_EQ(1, ids.count(transfer.id));
 
108
    {
 
109
      EXPECT_EQ(1, m_controller->count(transfer.id));
 
110
      EXPECT_CALL(*m_source, clear(transfer.id)).Times(transfer.can_clear?1:0);
 
111
    }
113
112
 
114
113
  // call clear-all
115
114
  m_controller->clear_all();
116
115
 
117
 
  // make sure all the clearable transfers are gone
118
 
  ids = m_model->get_ids();
 
116
  // make sure all the clearable transfers are gone from controler and source
 
117
  auto source_ids = m_source->get_model()->get_ids();
 
118
 
119
119
  for (const auto& transfer : transfers)
120
 
    EXPECT_EQ((transfer.can_clear ? 0 : 1), ids.count(transfer.id));
 
120
    {
 
121
      int expect_count = (transfer.can_clear ? 0 : 1);
 
122
      EXPECT_EQ(source_ids.count(transfer.id), expect_count);
 
123
      EXPECT_EQ(m_controller->count(transfer.id), expect_count);
 
124
    }
121
125
}
122
126
 
123
127
/**
145
149
      auto t = std::make_shared<Transfer>();
146
150
      t->state = transfer.state;
147
151
      t->id = transfer.id;
148
 
      m_model->add(t);
 
152
      m_source->m_model->add(t);
149
153
      EXPECT_EQ(transfer.can_pause, t->can_pause());
150
154
      EXPECT_CALL(*m_source, pause(transfer.id)).Times(transfer.can_pause?1:0);
151
155
    }
178
182
      auto t = std::make_shared<Transfer>();
179
183
      t->state = transfer.state;
180
184
      t->id = transfer.id;
181
 
      m_model->add(t);
 
185
      m_source->m_model->add(t);
182
186
      EXPECT_EQ(transfer.can_resume, t->can_resume());
183
187
      EXPECT_CALL(*m_source, resume(transfer.id)).Times(transfer.can_resume?1:0);
184
188
    }
196
200
  auto t = std::make_shared<Transfer>();
197
201
  t->state = Transfer::QUEUED;
198
202
  t->id = id;
199
 
  m_model->add(t);
 
203
  m_source->m_model->add(t);
200
204
 
201
205
  t->state = Transfer::QUEUED;
202
206
  EXPECT_CALL(*m_source, start(id)).Times(1);
269
273
  auto t = std::make_shared<Transfer>();
270
274
  t->id = id;
271
275
  t->state = Transfer::QUEUED;
272
 
  m_model->add(t);
 
276
  m_source->m_model->add(t);
273
277
 
274
278
  for (const auto& state : all_states)
275
279
    {
289
293
  auto t = std::make_shared<Transfer>();
290
294
  t->id = id;
291
295
  t->state = Transfer::QUEUED;
292
 
  m_model->add(t);
 
296
  m_source->m_model->add(t);
293
297
 
294
298
  for (const auto& state : all_states)
295
299
    {
309
313
  auto t = std::make_shared<Transfer>();
310
314
  t->id = id;
311
315
  t->state = Transfer::QUEUED;
312
 
  m_model->add(t);
 
316
  m_source->m_model->add(t);
313
317
 
314
318
  for (const auto& state : all_states)
315
319
    {
329
333
  auto t = std::make_shared<Transfer>();
330
334
  t->id = id;
331
335
  t->state = Transfer::QUEUED;
332
 
  m_model->add(t);
 
336
  m_source->m_model->add(t);
333
337
 
334
338
  for (const auto& state : all_states)
335
339
    {