← Back to branch summary

~vanvugt/compiz/fix-1023742

« back to all changes in this revision

Viewing changes to compizconfig/gsettings/tests/test_gsettings_tests.cpp

  • Committer: Tarmac
  • Author(s): smspillaz, Sam Spilsbury, Daniel van Vugt
  • Date: 2012-07-11 08:00:58 UTC
  • mfrom: (3262.3.80 gsettings)
  • Revision ID: tarmac-20120711080058-i4iax4g092e84s30
Add gsettings test cases and schema/path cleanups.. Fixes: . Approved by Daniel van Vugt.

Show diffs side-by-side

added added

removed removed

Lines of Context:
compizconfig/gsettings/tests/test_gsettings_tests.cpp
 
1
#include <boost/function.hpp>
 
2
#include <boost/bind.hpp>
 
3
 
 
4
#include "test_gsettings_tests.h"
 
5
#include "gsettings.h"
 
6
#include "gsettings_mocks.h"
 
7
 
 
8
using ::testing::Values;
 
9
using ::testing::ValuesIn;
 
10
using ::testing::Return;
 
11
 
 
12
TEST_P(CCSGSettingsTest, TestTestFixtures)
 
13
{
 
14
}
 
15
 
 
16
TEST_F(CCSGSettingsTestIndependent, TestTest)
 
17
{
 
18
}
 
19
 
 
20
TEST_F(CCSGSettingsTestIndependent, TestGetSchemaNameForPlugin)
 
21
{
 
22
    const gchar *plugin = "foo";
 
23
    gchar *schemaName = getSchemaNameForPlugin (plugin);
 
24
 
 
25
    std::string schemaNameStr (schemaName);
 
26
 
 
27
    size_t pos = schemaNameStr.find (PLUGIN_SCHEMA_ID_PREFIX, 0);
 
28
 
 
29
    EXPECT_EQ (pos, 0);
 
30
 
 
31
    g_free (schemaName);
 
32
}
 
33
 
 
34
TEST_F(CCSGSettingsTestIndependent, TestTruncateKeyForGSettingsOver)
 
35
{
 
36
    const unsigned int OVER_KEY_SIZE = MAX_GSETTINGS_KEY_SIZE + 1;
 
37
 
 
38
    std::string keyname;
 
39
 
 
40
    for (unsigned int i = 0; i <= OVER_KEY_SIZE - 1; i++)
 
41
        keyname.push_back ('a');
 
42
 
 
43
    ASSERT_EQ (keyname.size (), OVER_KEY_SIZE);
 
44
 
 
45
    gchar *truncated = truncateKeyForGSettings (keyname.c_str ());
 
46
 
 
47
    EXPECT_EQ (std::string (truncated).size (), MAX_GSETTINGS_KEY_SIZE);
 
48
 
 
49
    g_free (truncated);
 
50
}
 
51
 
 
52
TEST_F(CCSGSettingsTestIndependent, TestTruncateKeyForGSettingsUnder)
 
53
{
 
54
    const unsigned int UNDER_KEY_SIZE = MAX_GSETTINGS_KEY_SIZE - 1;
 
55
 
 
56
    std::string keyname;
 
57
 
 
58
    for (unsigned int i = 0; i <= UNDER_KEY_SIZE - 1; i++)
 
59
        keyname.push_back ('a');
 
60
 
 
61
    ASSERT_EQ (keyname.size (), UNDER_KEY_SIZE);
 
62
 
 
63
    gchar *truncated = truncateKeyForGSettings (keyname.c_str ());
 
64
 
 
65
    EXPECT_EQ (std::string (truncated).size (), UNDER_KEY_SIZE);
 
66
 
 
67
    g_free (truncated);
 
68
}
 
69
 
 
70
TEST_F(CCSGSettingsTestIndependent, TestTranslateUnderscoresToDashesForGSettings)
 
71
{
 
72
    std::string keyname ("plugin_option");
 
73
 
 
74
    gchar *translated = translateUnderscoresToDashesForGSettings (keyname.c_str ());
 
75
 
 
76
    std::string translatedKeyname (translated);
 
77
    EXPECT_EQ (translatedKeyname, std::string ("plugin-option"));
 
78
 
 
79
    g_free (translated);
 
80
}
 
81
 
 
82
TEST_F(CCSGSettingsTestIndependent, TestTranslateUpperToLowerForGSettings)
 
83
{
 
84
    gchar keyname[] = "PLUGIN-OPTION";
 
85
 
 
86
    translateToLowercaseForGSettings (keyname);
 
87
 
 
88
    EXPECT_EQ (std::string (keyname), "plugin-option");
 
89
}
 
90
 
 
91
TEST_F(CCSGSettingsTestIndependent, TestTranslateKeyForCCS)
 
92
{
 
93
    std::string keyname ("plugin-option");
 
94
 
 
95
    gchar *translated = translateKeyForCCS (keyname.c_str ());
 
96
 
 
97
    EXPECT_EQ (std::string (translated), "plugin_option");
 
98
 
 
99
    free (translated);
 
100
}
 
101
 
 
102
struct CCSTypeIsVariantType
 
103
{
 
104
    CCSSettingType settingType;
 
105
    bool           isVariantType;
 
106
};
 
107
 
 
108
class CCSGSettingsTestVariantTypeFixture :
 
109
    public ::testing::TestWithParam <CCSTypeIsVariantType>
 
110
{
 
111
    public:
 
112
 
 
113
        virtual void SetUp ()
 
114
        {
 
115
            mType = GetParam ();
 
116
        }
 
117
 
 
118
    protected:
 
119
 
 
120
        CCSTypeIsVariantType mType;
 
121
};
 
122
 
 
123
TEST_P(CCSGSettingsTestVariantTypeFixture, TestVariantType)
 
124
{
 
125
    EXPECT_EQ (mType.isVariantType, compizconfigTypeHasVariantType (mType.settingType));
 
126
}
 
127
 
 
128
namespace
 
129
{
 
130
    CCSTypeIsVariantType type[TypeNum + 1] =
 
131
    {
 
132
        { TypeBool, true },
 
133
        { TypeInt, true },
 
134
        { TypeFloat, true },
 
135
        { TypeString, true },
 
136
        { TypeColor, true },
 
137
        { TypeAction, false }, /* Cannot read raw actions */
 
138
        { TypeKey, false }, /* No actions in lists */
 
139
        { TypeButton, false }, /* No actions in lists */
 
140
        { TypeEdge, false }, /* No actions in lists */
 
141
        { TypeBell, false }, /* No actions in lists */
 
142
        { TypeMatch, true },
 
143
        { TypeList, false }, /* No lists in lists */
 
144
        { TypeNum, false }
 
145
    };
 
146
}
 
147
 
 
148
INSTANTIATE_TEST_CASE_P (CCSGSettingsTestVariantTypeInstantiation, CCSGSettingsTestVariantTypeFixture,
 
149
                         ValuesIn (type));
 
150
 
 
151
TEST_F(CCSGSettingsTestIndependent, TestDecomposeGSettingsPath)
 
152
{
 
153
    std::string compiz_gsettings_path (PROFILE_PATH_PREFIX);
 
154
    std::string fake_option_path ("PROFILENAME/plugins/PLUGINNAME");
 
155
 
 
156
    compiz_gsettings_path += fake_option_path;
 
157
 
 
158
    char *pluginName;
 
159
    unsigned int screenNum;
 
160
 
 
161
    ASSERT_TRUE (decomposeGSettingsPath (compiz_gsettings_path.c_str (), &pluginName, &screenNum));
 
162
    EXPECT_EQ (std::string (pluginName), "PLUGINNAME");
 
163
    EXPECT_EQ (screenNum, 0);
 
164
 
 
165
    g_free (pluginName);
 
166
}
 
167
 
 
168
TEST_F(CCSGSettingsTestIndependent, TestMakeCompizProfilePath)
 
169
{
 
170
    gchar *a = makeCompizProfilePath ("alpha");
 
171
    ASSERT_TRUE (a != NULL);
 
172
    EXPECT_EQ (std::string (a), "/org/compiz/profiles/alpha/");
 
173
    g_free (a);
 
174
 
 
175
    gchar *b = makeCompizProfilePath ("beta/");
 
176
    ASSERT_TRUE (b != NULL);
 
177
    EXPECT_EQ (std::string (b), "/org/compiz/profiles/beta/");
 
178
    g_free (b);
 
179
 
 
180
    gchar *c = makeCompizProfilePath ("/gamma");
 
181
    ASSERT_TRUE (c != NULL);
 
182
    EXPECT_EQ (std::string (c), "/org/compiz/profiles/gamma/");
 
183
    g_free (c);
 
184
 
 
185
    gchar *d = makeCompizProfilePath ("/delta");
 
186
    ASSERT_TRUE (d != NULL);
 
187
    EXPECT_EQ (std::string (d), "/org/compiz/profiles/delta/");
 
188
    g_free (d);
 
189
}
 
190
 
 
191
TEST_F(CCSGSettingsTestIndependent, TestMakeCompizPluginPath)
 
192
{
 
193
    gchar *x = makeCompizPluginPath ("one", "two");
 
194
    ASSERT_TRUE (x != NULL);
 
195
    EXPECT_EQ (std::string (x), "/org/compiz/profiles/one/plugins/two/");
 
196
    g_free (x);
 
197
 
 
198
    gchar *y = makeCompizPluginPath ("/three", "four/");
 
199
    ASSERT_TRUE (y != NULL);
 
200
    EXPECT_EQ (std::string (y), "/org/compiz/profiles/three/plugins/four/");
 
201
    g_free (y);
 
202
}
 
203
 
 
204
namespace GVariantSubtypeWrappers
 
205
{
 
206
    typedef gboolean (*IsSubtype) (GVariant *v);
 
207
 
 
208
    gboolean boolean (GVariant *v)
 
209
    {
 
210
        return g_variant_type_is_subtype_of (G_VARIANT_TYPE_BOOLEAN, g_variant_get_type (v));
 
211
    }
 
212
 
 
213
    gboolean bell (GVariant *v)
 
214
    {
 
215
        return boolean (v);
 
216
    }
 
217
 
 
218
    gboolean string (GVariant *v)
 
219
    {
 
220
        return g_variant_type_is_subtype_of (G_VARIANT_TYPE_STRING, g_variant_get_type (v));
 
221
    }
 
222
 
 
223
    gboolean match (GVariant *v)
 
224
    {
 
225
        return string (v);
 
226
    }
 
227
 
 
228
    gboolean color (GVariant *v)
 
229
    {
 
230
        return string (v);
 
231
    }
 
232
 
 
233
    gboolean key (GVariant *v)
 
234
    {
 
235
        return string (v);
 
236
    }
 
237
 
 
238
    gboolean button (GVariant *v)
 
239
    {
 
240
        return string (v);
 
241
    }
 
242
 
 
243
    gboolean edge (GVariant *v)
 
244
    {
 
245
        return string (v);
 
246
    }
 
247
 
 
248
    gboolean integer (GVariant *v)
 
249
    {
 
250
        return g_variant_type_is_subtype_of (G_VARIANT_TYPE_INT32, g_variant_get_type (v));
 
251
    }
 
252
 
 
253
    gboolean doubleprecision (GVariant *v)
 
254
    {
 
255
        return g_variant_type_is_subtype_of (G_VARIANT_TYPE_DOUBLE, g_variant_get_type (v));
 
256
    }
 
257
 
 
258
    gboolean list (GVariant *v)
 
259
    {
 
260
        return g_variant_type_is_array (g_variant_get_type (v));
 
261
    }
 
262
}
 
263
 
 
264
struct ArrayVariantInfo
 
265
{
 
266
    GVariantSubtypeWrappers::IsSubtype func;
 
267
    CCSSettingType                     ccsType;
 
268
    const char                         *vType;
 
269
};
 
270
 
 
271
namespace
 
272
{
 
273
    const char *vBoolean = "b";
 
274
    const char *vString = "s";
 
275
    const char *vInt = "i";
 
276
    const char *vDouble = "d";
 
277
    const char *vArray = "as";
 
278
 
 
279
    ArrayVariantInfo arrayVariantInfo[] =
 
280
    {
 
281
        { &GVariantSubtypeWrappers::boolean, TypeBool, vBoolean },
 
282
        { &GVariantSubtypeWrappers::bell, TypeBell, vBoolean },
 
283
        { &GVariantSubtypeWrappers::string, TypeString, vString },
 
284
        { &GVariantSubtypeWrappers::match, TypeMatch, vString },
 
285
        { &GVariantSubtypeWrappers::color, TypeColor, vString },
 
286
        { &GVariantSubtypeWrappers::key, TypeKey, vString },
 
287
        { &GVariantSubtypeWrappers::button, TypeButton, vString },
 
288
        { &GVariantSubtypeWrappers::edge, TypeEdge, vString },
 
289
        { &GVariantSubtypeWrappers::integer, TypeInt, vInt },
 
290
        { &GVariantSubtypeWrappers::doubleprecision, TypeFloat, vDouble },
 
291
        { &GVariantSubtypeWrappers::list, TypeList, vArray }
 
292
    };
 
293
}
 
294
 
 
295
class CCSGSettingsTestArrayVariantSubTypeFixture :
 
296
    public ::testing::TestWithParam <ArrayVariantInfo>
 
297
{
 
298
    public:
 
299
 
 
300
        virtual void SetUp ()
 
301
        {
 
302
            mAVInfo = GetParam ();
 
303
        }
 
304
 
 
305
        virtual void TearDown ()
 
306
        {
 
307
            g_variant_unref (v);
 
308
        }
 
309
 
 
310
    protected:
 
311
 
 
312
        ArrayVariantInfo mAVInfo;
 
313
        GVariant         *v;
 
314
};
 
315
 
 
316
TEST_P(CCSGSettingsTestArrayVariantSubTypeFixture, TestArrayVariantValidForCCSTypeBool)
 
317
{
 
318
    v = g_variant_new (vBoolean, TRUE);
 
319
 
 
320
    EXPECT_EQ ((*mAVInfo.func) (v), variantIsValidForCCSType (v, mAVInfo.ccsType));
 
321
}
 
322
 
 
323
TEST_P(CCSGSettingsTestArrayVariantSubTypeFixture, TestArrayVariantValidForCCSTypeString)
 
324
{
 
325
    v = g_variant_new (vString, "foo");
 
326
 
 
327
    EXPECT_EQ ((*mAVInfo.func) (v), variantIsValidForCCSType (v, mAVInfo.ccsType));
 
328
}
 
329
 
 
330
TEST_P(CCSGSettingsTestArrayVariantSubTypeFixture, TestArrayVariantValidForCCSTypeInt)
 
331
{
 
332
    v = g_variant_new (vInt, 1);
 
333
 
 
334
    EXPECT_EQ ((*mAVInfo.func) (v), variantIsValidForCCSType (v, mAVInfo.ccsType));
 
335
}
 
336
 
 
337
TEST_P(CCSGSettingsTestArrayVariantSubTypeFixture, TestArrayVariantValidForCCSTypeDouble)
 
338
{
 
339
    v = g_variant_new (vDouble, 2.0);
 
340
 
 
341
    EXPECT_EQ ((*mAVInfo.func) (v), variantIsValidForCCSType (v, mAVInfo.ccsType));
 
342
}
 
343
 
 
344
TEST_P(CCSGSettingsTestArrayVariantSubTypeFixture, TestArrayVariantValidForCCSTypeArray)
 
345
{
 
346
    GVariantBuilder vb;
 
347
 
 
348
    g_variant_builder_init (&vb, G_VARIANT_TYPE (vArray));
 
349
 
 
350
    g_variant_builder_add (&vb, "s", "foo");
 
351
    g_variant_builder_add (&vb, "s", "bar");
 
352
 
 
353
    v = g_variant_builder_end (&vb);
 
354
 
 
355
    EXPECT_EQ ((*mAVInfo.func) (v), variantIsValidForCCSType (v, mAVInfo.ccsType));
 
356
}
 
357
 
 
358
INSTANTIATE_TEST_CASE_P (CCSGSettingsTestArrayVariantSubTypeInstantiation, CCSGSettingsTestArrayVariantSubTypeFixture,
 
359
                         ValuesIn (arrayVariantInfo));
 
360
 
 
361
class CCSGSettingsTestPluginsWithSetKeysGVariantSetup :
 
362
    public CCSGSettingsTestIndependent
 
363
{
 
364
    public:
 
365
 
 
366
        virtual void SetUp ()
 
367
        {
 
368
            builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
 
369
 
 
370
            g_variant_builder_add (builder, "s", "foo");
 
371
            g_variant_builder_add (builder, "s", "bar");
 
372
 
 
373
            writtenPlugins = g_variant_new ("as", builder);
 
374
 
 
375
            g_variant_builder_unref (builder);
 
376
 
 
377
            newWrittenPlugins = NULL;
 
378
            newWrittenPluginsSize = 0;
 
379
        }
 
380
 
 
381
        virtual void TearDown ()
 
382
        {
 
383
            g_variant_unref (writtenPlugins);
 
384
            g_strfreev (newWrittenPlugins);
 
385
        }
 
386
 
 
387
    protected:
 
388
 
 
389
        GVariantBuilder *builder;
 
390
        GVariant        *writtenPlugins;
 
391
        char     **newWrittenPlugins;
 
392
        gsize    newWrittenPluginsSize;
 
393
 
 
394
};
 
395
 
 
396
TEST_F(CCSGSettingsTestPluginsWithSetKeysGVariantSetup, TestAppendToPluginsWithSetKeysListNewItem)
 
397
{
 
398
    EXPECT_TRUE (appendToPluginsWithSetKeysList ("plugin",
 
399
                                                 writtenPlugins,
 
400
                                                 &newWrittenPlugins,
 
401
                                                 &newWrittenPluginsSize));
 
402
 
 
403
    EXPECT_EQ (newWrittenPluginsSize, 3);
 
404
    EXPECT_EQ (std::string (newWrittenPlugins[0]), std::string ("foo"));
 
405
    EXPECT_EQ (std::string (newWrittenPlugins[1]), std::string ("bar"));
 
406
    EXPECT_EQ (std::string (newWrittenPlugins[2]), std::string ("plugin"));
 
407
}
 
408
 
 
409
TEST_F(CCSGSettingsTestPluginsWithSetKeysGVariantSetup, TestAppendToPluginsWithSetKeysListExistingItem)
 
410
{
 
411
    EXPECT_FALSE (appendToPluginsWithSetKeysList ("foo",
 
412
                                                  writtenPlugins,
 
413
                                                  &newWrittenPlugins,
 
414
                                                  &newWrittenPluginsSize));
 
415
 
 
416
    EXPECT_EQ (newWrittenPluginsSize, 2);
 
417
    EXPECT_EQ (std::string (newWrittenPlugins[0]), std::string ("foo"));
 
418
    EXPECT_EQ (std::string (newWrittenPlugins[1]), std::string ("bar"));
 
419
}
 
420
 
 
421
class CCSGSettingsTestGObjectListWithProperty :
 
422
    public CCSGSettingsTestIndependent
 
423
{
 
424
    public:
 
425
 
 
426
        virtual void SetUp ()
 
427
        {
 
428
            g_type_init ();
 
429
 
 
430
            objectSchemaList = NULL;
 
431
        }
 
432
 
 
433
        virtual void TearDown ()
 
434
        {
 
435
            GList *iter = objectSchemaList;
 
436
 
 
437
            while (iter)
 
438
            {
 
439
                g_object_unref ((GObject *) iter->data);
 
440
                iter = g_list_next (iter);
 
441
            }
 
442
 
 
443
            g_list_free (objectSchemaList);
 
444
            objectSchemaList = NULL;
 
445
        }
 
446
 
 
447
        CCSGSettingsWrapGSettings * AddObjectWithSchemaName (const std::string &schemaName)
 
448
        {
 
449
            CCSGSettingsWrapGSettings *wrapGSettingsObject =
 
450
                    compizconfig_gsettings_wrap_gsettings_new (COMPIZCONFIG_GSETTINGS_TYPE_MOCK_WRAP_GSETTINGS, schemaName.c_str ());
 
451
            objectSchemaList = g_list_append (objectSchemaList, wrapGSettingsObject);
 
452
 
 
453
            return wrapGSettingsObject;
 
454
        }
 
455
 
 
456
    protected:
 
457
 
 
458
        GList *objectSchemaList;
 
459
};
 
460
 
 
461
TEST_F(CCSGSettingsTestGObjectListWithProperty, TestFindExistingObjectWithSchema)
 
462
{
 
463
    GObject *obj = reinterpret_cast <GObject *> (AddObjectWithSchemaName ("foo"));
 
464
 
 
465
    EXPECT_EQ (findObjectInListWithPropertySchemaName ("foo", objectSchemaList), obj);
 
466
}
 
467
 
 
468
TEST_F(CCSGSettingsTestGObjectListWithProperty, TestNoFindNonexistingObjectWithSchema)
 
469
{
 
470
    AddObjectWithSchemaName ("bar");
 
471
 
 
472
    EXPECT_EQ (NULL, findObjectInListWithPropertySchemaName ("foo", objectSchemaList));
 
473
}
 
474
 
 
475
class CCSGSettingsTestFindSettingLossy :
 
476
    public CCSGSettingsTestIndependent
 
477
{
 
478
    public:
 
479
 
 
480
        virtual void SetUp ()
 
481
        {
 
482
            settingList = NULL;
 
483
        }
 
484
 
 
485
        virtual void TearDown ()
 
486
        {
 
487
            ccsSettingListFree (settingList, TRUE);
 
488
            settingList = NULL;
 
489
        }
 
490
 
 
491
        CCSSetting * AddMockSettingWithNameAndType (char              *name,
 
492
                                                    CCSSettingType    type)
 
493
        {
 
494
            CCSSetting *mockSetting = ccsMockSettingNew ();
 
495
 
 
496
            settingList = ccsSettingListAppend (settingList, mockSetting);
 
497
 
 
498
            CCSSettingGMock *gmock = reinterpret_cast <CCSSettingGMock *> (ccsObjectGetPrivate (mockSetting));
 
499
 
 
500
            ON_CALL (*gmock, getName ()).WillByDefault (Return (name));
 
501
            ON_CALL (*gmock, getType ()).WillByDefault (Return (type));
 
502
 
 
503
            return mockSetting;
 
504
        }
 
505
 
 
506
        void ExpectNameCallOnSetting (CCSSetting *setting)
 
507
        {
 
508
            CCSSettingGMock *gs = reinterpret_cast <CCSSettingGMock *> (ccsObjectGetPrivate (setting));
 
509
            EXPECT_CALL (*gs, getName ());
 
510
        }
 
511
 
 
512
        void ExpectTypeCallOnSetting (CCSSetting *setting)
 
513
        {
 
514
            CCSSettingGMock *gs = reinterpret_cast <CCSSettingGMock *> (ccsObjectGetPrivate (setting));
 
515
            EXPECT_CALL (*gs, getType ());
 
516
        }
 
517
 
 
518
    protected:
 
519
 
 
520
        CCSSettingList settingList;
 
521
};
 
522
 
 
523
TEST_F(CCSGSettingsTestFindSettingLossy, TestFilterAvailableSettingsByType)
 
524
{
 
525
    char *name1 = strdup ("foo_bar_baz");
 
526
    char *name2 = strdup ("foo_bar-baz");
 
527
 
 
528
    CCSSetting *s1 = AddMockSettingWithNameAndType (name1, TypeInt);
 
529
    CCSSetting *s2 = AddMockSettingWithNameAndType (name2, TypeBool);
 
530
 
 
531
    ExpectTypeCallOnSetting (s1);
 
532
    ExpectTypeCallOnSetting (s2);
 
533
 
 
534
    CCSSettingList filteredList = filterAllSettingsMatchingType (TypeInt, settingList);
 
535
 
 
536
    /* Needs to be expressed in terms of a boolean expression */
 
537
    ASSERT_TRUE (filteredList);
 
538
    EXPECT_EQ (ccsSettingListLength (filteredList), 1);
 
539
    EXPECT_EQ (filteredList->data, s1);
 
540
    EXPECT_NE (filteredList->data, s2);
 
541
    EXPECT_EQ (NULL, filteredList->next);
 
542
 
 
543
    free (name2);
 
544
    free (name1);
 
545
 
 
546
    ccsSettingListFree (filteredList, FALSE);
 
547
}
 
548
 
 
549
TEST_F(CCSGSettingsTestFindSettingLossy, TestFilterAvailableSettingsMatchingPartOfStringIgnoringDashesUnderscoresAndCase)
 
550
{
 
551
    char *name1 = strdup ("foo_bar_baz_bob");
 
552
    char *name2 = strdup ("FOO_bar_baz_fred");
 
553
    char *name3 = strdup ("foo-bar");
 
554
 
 
555
    CCSSetting *s1 = AddMockSettingWithNameAndType (name1, TypeInt);
 
556
    CCSSetting *s2 = AddMockSettingWithNameAndType (name2, TypeInt);
 
557
    CCSSetting *s3 = AddMockSettingWithNameAndType (name3, TypeInt);
 
558
 
 
559
    ExpectNameCallOnSetting (s1);
 
560
    ExpectNameCallOnSetting (s2);
 
561
    ExpectNameCallOnSetting (s3);
 
562
 
 
563
    CCSSettingList filteredList = filterAllSettingsMatchingPartOfStringIgnoringDashesUnderscoresAndCase ("foo-bar-baz",
 
564
                                                                                                         settingList);
 
565
 
 
566
    ASSERT_TRUE (filteredList);
 
567
    ASSERT_EQ (ccsSettingListLength (filteredList), 2);
 
568
    EXPECT_EQ (filteredList->data, s1);
 
569
    EXPECT_NE (filteredList->data, s3);
 
570
    ASSERT_TRUE (filteredList->next);
 
571
    EXPECT_EQ (filteredList->next->data, s2);
 
572
    EXPECT_NE (filteredList->data, s3);
 
573
    EXPECT_EQ (NULL, filteredList->next->next);
 
574
 
 
575
    free (name1);
 
576
    free (name2);
 
577
    free (name3);
 
578
 
 
579
    ccsSettingListFree (filteredList, FALSE);
 
580
}
 
581
 
 
582
TEST_F(CCSGSettingsTestFindSettingLossy, TestAttemptToFindCCSSettingFromLossyNameSuccess)
 
583
{
 
584
    char *name1 = strdup ("foo_bar_baz_bob");
 
585
    char *name2 = strdup ("FOO_bar_baz_bob-fred");
 
586
    char *name3 = strdup ("foo-bar");
 
587
    char *name4 = strdup ("FOO_bar_baz_bob-fred");
 
588
 
 
589
    CCSSetting *s1 = AddMockSettingWithNameAndType (name1, TypeInt);
 
590
    CCSSetting *s2 = AddMockSettingWithNameAndType (name2, TypeInt);
 
591
    CCSSetting *s3 = AddMockSettingWithNameAndType (name3, TypeInt);
 
592
    CCSSetting *s4 = AddMockSettingWithNameAndType (name4, TypeString);
 
593
 
 
594
    ExpectNameCallOnSetting (s1);
 
595
    ExpectNameCallOnSetting (s2);
 
596
    ExpectNameCallOnSetting (s3);
 
597
 
 
598
    ExpectTypeCallOnSetting (s1);
 
599
    ExpectTypeCallOnSetting (s2);
 
600
    ExpectTypeCallOnSetting (s3);
 
601
    ExpectTypeCallOnSetting (s4);
 
602
 
 
603
    CCSSetting *found = attemptToFindCCSSettingFromLossyName (settingList, "foo-bar-baz-bob-fred", TypeInt);
 
604
 
 
605
    EXPECT_EQ (found, s2);
 
606
    EXPECT_NE (found, s1);
 
607
    EXPECT_NE (found, s3);
 
608
    EXPECT_NE (found, s4);
 
609
 
 
610
    free (name1);
 
611
    free (name2);
 
612
    free (name3);
 
613
    free (name4);
 
614
}
 
615
 
 
616
TEST_F(CCSGSettingsTestFindSettingLossy, TestAttemptToFindCCSSettingFromLossyNameFailTooMany)
 
617
{
 
618
    char *name1 = strdup ("foo_bar_baz_bob");
 
619
    char *name2 = strdup ("FOO_bar_baz_bob-fred");
 
620
    char *name3 = strdup ("FOO_BAR_baz_bob-fred");
 
621
    char *name4 = strdup ("foo-bar");
 
622
    char *name5 = strdup ("FOO_bar_baz_bob-fred");
 
623
 
 
624
    CCSSetting *s1 = AddMockSettingWithNameAndType (name1, TypeInt);
 
625
    CCSSetting *s2 = AddMockSettingWithNameAndType (name2, TypeInt);
 
626
    CCSSetting *s3 = AddMockSettingWithNameAndType (name3, TypeInt);
 
627
    CCSSetting *s4 = AddMockSettingWithNameAndType (name4, TypeInt);
 
628
    CCSSetting *s5 = AddMockSettingWithNameAndType (name5, TypeString);
 
629
 
 
630
    ExpectNameCallOnSetting (s1);
 
631
    ExpectNameCallOnSetting (s2);
 
632
    ExpectNameCallOnSetting (s3);
 
633
    ExpectNameCallOnSetting (s4);
 
634
 
 
635
    ExpectTypeCallOnSetting (s1);
 
636
    ExpectTypeCallOnSetting (s2);
 
637
    ExpectTypeCallOnSetting (s3);
 
638
    ExpectTypeCallOnSetting (s4);
 
639
    ExpectTypeCallOnSetting (s5);
 
640
 
 
641
    CCSSetting *found = attemptToFindCCSSettingFromLossyName (settingList, "foo-bar-baz-bob-fred", TypeInt);
 
642
 
 
643
    ASSERT_FALSE (found);
 
644
    EXPECT_NE (found, s1);
 
645
    EXPECT_NE (found, s2);
 
646
    EXPECT_NE (found, s3);
 
647
    EXPECT_NE (found, s4);
 
648
    EXPECT_NE (found, s5);
 
649
 
 
650
    free (name1);
 
651
    free (name2);
 
652
    free (name3);
 
653
    free (name4);
 
654
    free (name5);
 
655
}
 
656
 
 
657
TEST_F(CCSGSettingsTestFindSettingLossy, TestAttemptToFindCCSSettingFromLossyNameFailNoMatches)
 
658
{
 
659
    char *name1 = strdup ("foo_bar_baz_bob");
 
660
    char *name2 = strdup ("FOO_bar_baz_bob-richard");
 
661
    char *name3 = strdup ("foo-bar");
 
662
    char *name4 = strdup ("FOO_bar_baz_bob-richard");
 
663
 
 
664
    CCSSetting *s1 = AddMockSettingWithNameAndType (name1, TypeInt);
 
665
    CCSSetting *s2 = AddMockSettingWithNameAndType (name2, TypeInt);
 
666
    CCSSetting *s3 = AddMockSettingWithNameAndType (name3, TypeInt);
 
667
    CCSSetting *s4 = AddMockSettingWithNameAndType (name4, TypeString);
 
668
 
 
669
    ExpectNameCallOnSetting (s1);
 
670
    ExpectNameCallOnSetting (s2);
 
671
    ExpectNameCallOnSetting (s3);
 
672
 
 
673
    ExpectTypeCallOnSetting (s1);
 
674
    ExpectTypeCallOnSetting (s2);
 
675
    ExpectTypeCallOnSetting (s3);
 
676
    ExpectTypeCallOnSetting (s4);
 
677
 
 
678
    CCSSetting *found = attemptToFindCCSSettingFromLossyName (settingList, "foo-bar-baz-bob-fred", TypeInt);
 
679
 
 
680
    ASSERT_FALSE (found);
 
681
    EXPECT_NE (found, s1);
 
682
    EXPECT_NE (found, s2);
 
683
    EXPECT_NE (found, s3);
 
684
    EXPECT_NE (found, s4);
 
685
 
 
686
    free (name1);
 
687
    free (name2);
 
688
    free (name3);
 
689
    free (name4);
 
690
}
 
691
 
 
692
namespace
 
693
{
 
694
    class GListContainerEqualityInterface
 
695
    {
 
696
        public:
 
697
 
 
698
            virtual ~GListContainerEqualityInterface () {}
 
699
 
 
700
            virtual bool operator== (GList *) const = 0;
 
701
            bool operator!= (GList *l) const
 
702
            {
 
703
                return !(*this == l);
 
704
            }
 
705
 
 
706
            friend bool operator== (GList *lhs, const GListContainerEqualityInterface &rhs);
 
707
            friend bool operator!= (GList *lhs, const GListContainerEqualityInterface &rhs);
 
708
    };
 
709
 
 
710
    bool
 
711
    operator== (GList *lhs, const GListContainerEqualityInterface &rhs)
 
712
    {
 
713
        return rhs == lhs;
 
714
    }
 
715
 
 
716
    bool
 
717
    operator!= (GList *lhs, const GListContainerEqualityInterface &rhs)
 
718
    {
 
719
        return !(rhs == lhs);
 
720
    }
 
721
 
 
722
    class GListContainerEqualityBase :
 
723
        public GListContainerEqualityInterface
 
724
    {
 
725
        public:
 
726
 
 
727
            typedef boost::function <GList * (void)> PopulateFunc;
 
728
 
 
729
            GListContainerEqualityBase (const PopulateFunc &populateGList) :
 
730
                mList (populateGList ())
 
731
            {
 
732
            }
 
733
 
 
734
            GListContainerEqualityBase (const GListContainerEqualityBase &other) :
 
735
                mList (g_list_copy (other.mList))
 
736
            {
 
737
            }
 
738
 
 
739
            GListContainerEqualityBase &
 
740
            operator= (GListContainerEqualityBase &other)
 
741
            {
 
742
                if (this == &other)
 
743
                    return *this;
 
744
 
 
745
                GListContainerEqualityBase tmp (other);
 
746
 
 
747
                tmp.swap (*this);
 
748
                return *this;
 
749
            }
 
750
 
 
751
            void swap (GListContainerEqualityBase &other)
 
752
            {
 
753
                std::swap (this->mList, other.mList);
 
754
            }
 
755
 
 
756
            bool operator== (GList *other) const
 
757
            {
 
758
                unsigned int numInternal = g_list_length (mList);
 
759
                unsigned int numOther = g_list_length (other);
 
760
 
 
761
                if (numInternal != numOther)
 
762
                    return false;
 
763
 
 
764
                GList *iterOther = other;
 
765
                GList *iterInternal = mList;
 
766
 
 
767
                for (unsigned int i = 0; i < numInternal; i++)
 
768
                {
 
769
                    if (static_cast <CCSSettingType> (GPOINTER_TO_INT (iterOther->data)) !=
 
770
                        static_cast <CCSSettingType> (GPOINTER_TO_INT (iterInternal->data)))
 
771
                        return false;
 
772
 
 
773
                    iterOther = g_list_next (iterOther);
 
774
                    iterInternal = g_list_next (iterInternal);
 
775
                }
 
776
 
 
777
                return true;
 
778
            }
 
779
 
 
780
            ~GListContainerEqualityBase ()
 
781
            {
 
782
                g_list_free (mList);
 
783
            }
 
784
 
 
785
        private:
 
786
 
 
787
            GList *mList;
 
788
    };
 
789
 
 
790
    GList * populateBoolCCSTypes ()
 
791
    {
 
792
        GList *ret = NULL;
 
793
        ret = g_list_append (ret, GINT_TO_POINTER (static_cast <int> (TypeBool)));
 
794
        ret = g_list_append (ret, GINT_TO_POINTER (static_cast <int> (TypeBell)));
 
795
        return ret;
 
796
    }
 
797
 
 
798
    GList * populateStringCCSTypes ()
 
799
    {
 
800
        GList *ret = NULL;
 
801
        ret = g_list_append (ret, GINT_TO_POINTER (static_cast <int> (TypeString)));
 
802
        ret = g_list_append (ret, GINT_TO_POINTER (static_cast <int> (TypeColor)));
 
803
        ret = g_list_append (ret, GINT_TO_POINTER (static_cast <int> (TypeKey)));
 
804
        ret = g_list_append (ret, GINT_TO_POINTER (static_cast <int> (TypeButton)));
 
805
        ret = g_list_append (ret, GINT_TO_POINTER (static_cast <int> (TypeEdge)));
 
806
        ret = g_list_append (ret, GINT_TO_POINTER (static_cast <int> (TypeMatch)));
 
807
        return ret;
 
808
    }
 
809
 
 
810
    GList * populateIntCCSTypes ()
 
811
    {
 
812
        GList *ret = NULL;
 
813
        ret = g_list_append (ret, GINT_TO_POINTER (static_cast <int> (TypeInt)));
 
814
        return ret;
 
815
    }
 
816
 
 
817
    GList * populateDoubleCCSTypes ()
 
818
    {
 
819
        GList *ret = NULL;
 
820
        ret = g_list_append (ret, GINT_TO_POINTER (static_cast <int> (TypeFloat)));
 
821
        return ret;
 
822
    }
 
823
 
 
824
    GList * populateArrayCCSTypes ()
 
825
    {
 
826
        GList *ret = NULL;
 
827
        ret = g_list_append (ret, GINT_TO_POINTER (static_cast <int> (TypeList)));
 
828
        return ret;
 
829
    }
 
830
 
 
831
    struct GListContainerVariantTypeWrapper
 
832
    {
 
833
        const gchar *variantType;
 
834
        GListContainerEqualityBase listOfCCSTypes;
 
835
    };
 
836
 
 
837
    GListContainerVariantTypeWrapper variantTypeToListOfCCSTypes[] =
 
838
    {
 
839
        { "b", GListContainerEqualityBase (boost::bind (populateBoolCCSTypes)) },
 
840
        { "s", GListContainerEqualityBase (boost::bind (populateStringCCSTypes)) },
 
841
        { "i", GListContainerEqualityBase (boost::bind (populateIntCCSTypes)) },
 
842
        { "d", GListContainerEqualityBase (boost::bind (populateDoubleCCSTypes)) },
 
843
        { "a", GListContainerEqualityBase (boost::bind (populateArrayCCSTypes)) }
 
844
    };
 
845
}
 
846
 
 
847
class CCSGSettingsTestVariantTypeToCCSTypeListFixture :
 
848
    public ::testing::TestWithParam <GListContainerVariantTypeWrapper>
 
849
{
 
850
    public:
 
851
 
 
852
        CCSGSettingsTestVariantTypeToCCSTypeListFixture () :
 
853
            mListContainer (GetParam ())
 
854
        {
 
855
        }
 
856
 
 
857
    protected:
 
858
 
 
859
        GListContainerVariantTypeWrapper mListContainer;
 
860
};
 
861
 
 
862
TEST_P(CCSGSettingsTestVariantTypeToCCSTypeListFixture, TestVariantTypesInListTemplate)
 
863
{
 
864
    GList *potentialTypeList = variantTypeToPossibleSettingType (mListContainer.variantType);
 
865
    EXPECT_EQ (mListContainer.listOfCCSTypes, potentialTypeList);
 
866
 
 
867
    g_list_free (potentialTypeList);
 
868
}
 
869
 
 
870
INSTANTIATE_TEST_CASE_P(CCSGSettingsTestVariantTypeToCCSTypeListInstantiation, CCSGSettingsTestVariantTypeToCCSTypeListFixture,
 
871
                        ValuesIn (variantTypeToListOfCCSTypes));