188
203
CompPlugin::unload(cp);
191
TEST(PluginTest, when_we_push_plugin_init_is_called)
193
MockPluginFilesystem mockfs;
195
using namespace testing;
197
EXPECT_CALL(mockfs, LoadPlugin(Ne((void*)0), EndsWith(HOME_PLUGINDIR), StrEq("dummy"))).
198
WillOnce(Return(true));
200
EXPECT_CALL(mockfs, LoadPlugin(Ne((void*)0), EndsWith(PLUGINDIR), StrEq("dummy"))).
203
EXPECT_CALL(mockfs, LoadPlugin(Ne((void*)0), Eq((void*)0), StrEq("dummy"))).
206
EXPECT_CALL(mockfs, UnloadPlugin(_)).Times(1);
208
MockVTable mockVtable;
209
EXPECT_CALL(mockVtable, init()).WillOnce(Return(true));
211
CompPlugin* cp = CompPlugin::load("dummy");
213
cp->vTable = &mockVtable;
215
CompPlugin::push(cp);
216
ASSERT_EQ(cp, CompPlugin::pop());
217
CompPlugin::unload(cp);
206
TEST_F (PluginTest, when_we_load_plugin_init_load_is_called_without_null_pointer)
208
using namespace testing;
210
EXPECT_CALL (mockfs, LoadPlugin (NotNull (),
211
EndsWith(HOME_PLUGINDIR),
214
.WillOnce (Return (true));
216
EXPECT_CALL(mockfs, UnloadPlugin(_)).Times(AtLeast (0));
218
CompPlugin* cp = CompPlugin::load("dummy");
219
CompPlugin::unload(cp);
222
TEST_F (PluginTest, when_we_push_plugin_init_is_called)
224
using namespace testing;
226
EXPECT_CALL (mockfs, LoadPlugin (_, _, _)).Times (AtLeast (0));
227
EXPECT_CALL (mockfs, UnloadPlugin(_)).Times (AtLeast (0));
229
ON_CALL(mockfs, LoadPlugin (_, _, _)).
230
WillByDefault (Return (true));
232
MockVTable mockVtable;
233
EXPECT_CALL (mockVtable, markReadyToInstantiate ()).Times (AtLeast (0));
234
EXPECT_CALL (mockVtable, markNoFurtherInstantiation ())
235
.Times (AtLeast (0));
236
EXPECT_CALL (mockVtable, init ()).WillOnce (Return (true));
238
CompPlugin* cp = CompPlugin::load("dummy");
240
cp->vTable = &mockVtable;
242
CompPlugin::push(cp);
244
CompPlugin::unload(cp);
247
TEST_F (PluginTest, when_we_push_plugin_mark_ready_to_instantiate_is_called)
249
using namespace testing;
251
EXPECT_CALL (mockfs, LoadPlugin (_, _, _)).Times (AtLeast (0));
252
EXPECT_CALL (mockfs, UnloadPlugin(_)).Times (AtLeast (0));
254
ON_CALL(mockfs, LoadPlugin (_, _, _)).
255
WillByDefault (Return (true));
257
MockVTable mockVtable;
258
EXPECT_CALL (mockVtable, init ())
260
.WillOnce (Return (true));
261
EXPECT_CALL (mockVtable, markReadyToInstantiate ()).Times (1);
262
EXPECT_CALL (mockVtable, markNoFurtherInstantiation ())
263
.Times (AtLeast (0));
265
CompPlugin* cp = CompPlugin::load("dummy");
267
cp->vTable = &mockVtable;
269
CompPlugin::push(cp);
271
CompPlugin::unload(cp);
274
TEST_F (PluginTest, when_we_pop_plugin_mark_no_further_instantiation_is_called)
276
using namespace testing;
278
EXPECT_CALL (mockfs, LoadPlugin (_, _, _)).Times (AtLeast (0));
279
EXPECT_CALL (mockfs, UnloadPlugin(_)).Times (AtLeast (0));
281
ON_CALL(mockfs, LoadPlugin (_, _, _)).
282
WillByDefault (Return (true));
284
MockVTable mockVtable;
285
EXPECT_CALL (mockVtable, init ())
287
.WillOnce (Return (true));
288
EXPECT_CALL (mockVtable, markReadyToInstantiate ()).Times (AtLeast (0));
290
CompPlugin* cp = CompPlugin::load("dummy");
292
cp->vTable = &mockVtable;
294
CompPlugin::push(cp);
296
EXPECT_CALL (mockVtable, markNoFurtherInstantiation ())
300
CompPlugin::unload(cp);
303
TEST_F (PluginTest, pop_returns_plugin_pointer)
305
using namespace testing;
307
EXPECT_CALL (mockfs, LoadPlugin (_, _, _)).Times (AtLeast (0));
308
EXPECT_CALL (mockfs, UnloadPlugin(_)).Times (AtLeast (0));
310
ON_CALL(mockfs, LoadPlugin (_, _, _)).
311
WillByDefault (Return (true));
313
MockVTable mockVtable;
314
EXPECT_CALL (mockVtable, init ())
316
.WillOnce (Return (true));
317
EXPECT_CALL (mockVtable, markReadyToInstantiate ())
318
.Times (AtLeast (0));
319
EXPECT_CALL (mockVtable, markNoFurtherInstantiation ())
320
.Times (AtLeast (0));
322
CompPlugin* cp = CompPlugin::load("dummy");
324
cp->vTable = &mockVtable;
326
CompPlugin::push(cp);
327
EXPECT_EQ (cp, CompPlugin::pop ());
328
CompPlugin::unload(cp);
331
TEST_F (PluginTest, unload_calls_unload_on_fs)
333
using namespace testing;
335
EXPECT_CALL (mockfs, LoadPlugin (_, _, _)).Times (AtLeast (0));
337
ON_CALL(mockfs, LoadPlugin (_, _, _)).
338
WillByDefault (Return (true));
340
CompPlugin* cp = CompPlugin::load("dummy");
342
EXPECT_CALL (mockfs, UnloadPlugin (cp)).Times (1);
344
CompPlugin::unload(cp);
350
/* TODO (cleanup): Extract this into a separate library because it
351
* duplicates what's in test-pluginclasshandler */
352
template <typename BaseType>
354
public PluginClassStorage
358
typedef BaseType Type;
363
static unsigned int allocPluginClassIndex ();
364
static void freePluginClassIndex (unsigned int index);
368
static PluginClassStorage::Indices indices;
369
static std::list <Base *> bases;
372
template <typename BaseType>
373
PluginClassStorage::Indices Base <BaseType>::indices;
375
template <typename BaseType>
376
std::list <Base <BaseType> * > Base <BaseType>::bases;
378
template <typename BaseType>
379
Base <BaseType>::Base () :
380
PluginClassStorage (indices)
382
bases.push_back (this);
385
template <typename BaseType>
386
Base <BaseType>::~Base ()
391
template <typename BaseType>
393
Base <BaseType>::allocPluginClassIndex ()
395
unsigned int i = PluginClassStorage::allocatePluginClassIndex (indices);
397
foreach (Base *b, bases)
399
if (indices.size () != b->pluginClasses.size ())
400
b->pluginClasses.resize (indices.size ());
406
template <typename BaseType>
408
Base <BaseType>::freePluginClassIndex (unsigned int index)
410
PluginClassStorage::freePluginClassIndex (indices, index);
412
foreach (Base *b, bases)
414
if (indices.size () != b->pluginClasses.size ())
415
b->pluginClasses.resize (indices.size ());
420
public Base <BaseScreen>
425
public Base <BaseWindow>
429
class DestructionVerifier
433
DestructionVerifier ();
435
virtual ~DestructionVerifier ();
436
MOCK_METHOD0 (destroy, void ());
439
DestructionVerifier::DestructionVerifier ()
441
using namespace testing;
443
/* By default we don't care */
444
EXPECT_CALL (*this, destroy ()).Times (AtLeast (0));
447
DestructionVerifier::~DestructionVerifier ()
453
public PluginClassHandler <PluginScreen, BaseScreen>,
454
public DestructionVerifier
458
PluginScreen (BaseScreen *s);
462
public PluginClassHandler <PluginWindow, BaseWindow>,
463
public DestructionVerifier
467
virtual ~PluginWindow () {}
468
PluginWindow (BaseWindow *s);
471
PluginScreen::PluginScreen (BaseScreen *s) :
472
PluginClassHandler (s)
476
PluginWindow::PluginWindow (BaseWindow *w) :
477
PluginClassHandler (w)
481
class MockScreenAndWindowVTable :
482
public CompPlugin::VTableForScreenAndWindow <PluginScreen, PluginWindow>
486
MOCK_METHOD0 (init, bool ());
489
template <class BasePluginType>
490
class PluginClassIntegrationTest :
495
PluginClassIntegrationTest ();
496
~PluginClassIntegrationTest ();
498
boost::shared_ptr <CompPlugin>
499
LoadPlugin (MockScreenAndWindowVTable &);
501
MockPluginFilesystem mockfs;
502
ValueHolder *valueHolder;
506
PopAndUnloadPlugin (CompPlugin *p)
508
ASSERT_EQ (p, CompPlugin::pop ());
509
CompPlugin::unload (p);
512
template <class BasePluginType>
513
boost::shared_ptr <CompPlugin>
514
PluginClassIntegrationTest <BasePluginType>::LoadPlugin (MockScreenAndWindowVTable &v)
516
typedef PluginClassIntegrationTest <BasePluginType> TestParam;
518
using namespace testing;
520
EXPECT_CALL (TestParam::mockfs, LoadPlugin (_, _, _))
522
.WillOnce (Return (true));
523
EXPECT_CALL (TestParam::mockfs, UnloadPlugin(_))
524
.Times (AtLeast (0));
526
/* Load a plugin, we'll assign the vtable later */
527
CompPlugin *cp = CompPlugin::load("dummy");
530
EXPECT_CALL (v, init ())
532
.WillOnce (Return (true));
534
CompPlugin::push(cp);
536
return AutoDestroy (cp,
540
template <class BasePluginType>
541
PluginClassIntegrationTest <BasePluginType>::PluginClassIntegrationTest ()
543
valueHolder = new ValueHolder ();
544
ValueHolder::SetDefault (valueHolder);
547
template <class BasePluginType>
548
PluginClassIntegrationTest <BasePluginType>::~PluginClassIntegrationTest ()
551
ValueHolder::SetDefault (NULL);
554
template <typename BaseType, typename PluginType>
555
class BasePluginTemplate
559
typedef BaseType Base;
560
typedef PluginType Plugin;
563
typedef BasePluginTemplate <BaseScreen, PluginScreen> BasePluginScreen;
564
typedef BasePluginTemplate <BaseWindow, PluginWindow> BasePluginWindow;
568
/* TODO: Extract actual interfaces out of CompScreen
569
* and CompWindow that can be passed to the vTables without
570
* using a link-seam like this one */
581
typedef ::testing::Types <BasePluginScreen, BasePluginWindow> PluginTypes;
582
TYPED_TEST_CASE (PluginClassIntegrationTest, PluginTypes);
584
TYPED_TEST (PluginClassIntegrationTest, get_plugin_structure_null_on_not_loaded)
586
using namespace testing;
588
/* Can't figure out how to get this out of TestParam::base at the moment */
589
typename TypeParam::Base base;
590
typename TypeParam::Plugin *p = TypeParam::Plugin::get (&base);
592
EXPECT_THAT (p, IsNull ());
595
TYPED_TEST (PluginClassIntegrationTest, get_plugin_structure_nonnull_on_loaded)
597
using namespace testing;
599
typedef PluginClassIntegrationTest <TypeParam> TestParam;
601
MockScreenAndWindowVTable vTable;
602
boost::shared_ptr <CompPlugin> cp (TestParam::LoadPlugin (vTable));
604
typename TypeParam::Base base;
605
typedef boost::shared_ptr <typename TypeParam::Plugin> PluginPtr;
607
/* Because CompScreen is not available, we just need to delete
608
* the plugin structure ourselves */
609
PluginPtr p (TypeParam::Plugin::get (&base));
611
EXPECT_THAT (p.get (), NotNull ());
614
TYPED_TEST (PluginClassIntegrationTest, plugin_class_destroyed_when_vtable_is)
616
using namespace testing;
618
typedef PluginClassIntegrationTest <TypeParam> TestParam;
620
MockScreenAndWindowVTable vTable;
621
boost::shared_ptr <CompPlugin> cp (TestParam::LoadPlugin (vTable));
623
typename TypeParam::Base base;
624
typedef boost::shared_ptr <typename TypeParam::Plugin> PluginPtr;
626
/* Because CompScreen is not available, we just need to delete
627
* the plugin structure ourselves */
628
PluginPtr p (TypeParam::Plugin::get (&base));
630
EXPECT_CALL (*p, destroy ()).Times (1);