1 /*
2 * Copyright �� 2012 Canonical Ltd
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software Foundation,
16 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17 *
18 * Authored By: Sam Spilsbury <sam.spilsbury@canonical.com>
19 */
20 #include <cstring>
21
22 #include <tr1/tuple>
23
24 #include <gtest/gtest.h>
25 #include <gmock/gmock.h>
26
27 #include <boost/bind.hpp>
28 #include <boost/function.hpp>
29 #include <boost/shared_ptr.hpp>
30 #include <boost/make_shared.hpp>
31 #include <boost/algorithm/string.hpp>
32
33 #include <glib-object.h>
34
35 #include <gio/gio.h>
36
37 #include <glib_gslice_off_env.h>
38 #include <glib_gsettings_memory_backend_env.h>
39
40 #include <gtest_unspecified_bool_type_matcher.h>
41
42 #include "compiz_gwd_tests.h"
43
44 #include "gwd-settings-interface.h"
45 #include "gwd-settings.h"
46 #include "gwd-settings-storage-gsettings.h"
47 #include "gwd-settings-writable-interface.h"
48 #include "gwd-settings-storage-interface.h"
49 #include "gwd-settings-notified-interface.h"
50
51 #include "decoration.h"
52
53 #include "compiz_gwd_mock_settings.h"
54 #include "compiz_gwd_mock_settings_writable.h"
55 #include "compiz_gwd_mock_settings_storage.h"
56 #include "compiz_gwd_mock_settings_notified.h"
57
58 using ::testing::TestWithParam;
59 using ::testing::Eq;
60 using ::testing::Return;
61 using ::testing::InvokeWithoutArgs;
62 using ::testing::IgnoreResult;
63 using ::testing::MatcherInterface;
64 using ::testing::MakeMatcher;
65 using ::testing::MatchResultListener;
66 using ::testing::Matcher;
67 using ::testing::Action;
68 using ::testing::ActionInterface;
69 using ::testing::MakeAction;
70 using ::testing::IsNull;
71 using ::testing::Values;
72 using ::testing::_;
73 using ::testing::StrictMock;
74 using ::testing::InSequence;
75
76 template <class ValueCType>
77 class GValueCmp
78 {
79 public:
80
81 typedef ValueCType (*GetFunc) (const GValue *value);
82
83 bool compare (const ValueCType &val,
84 GValue *value,
85 GetFunc get)
86 {
87 const ValueCType &valForValue = (*get) (value);
88 return valForValue == val;
89 }
90 };
91
92 template <>
93 class GValueCmp <decor_shadow_options_t>
94 {
95 public:
96
97 typedef gpointer (*GetFunc) (const GValue *value);
98
99 bool compare (const decor_shadow_options_t &val,
100 GValue *value,
101 GetFunc get)
102 {
103 gpointer shadowOptionsPtr = (*get) (value);
104 const decor_shadow_options_t &shadowOptions = *(reinterpret_cast <decor_shadow_options_t *> (shadowOptionsPtr));
105 if (decor_shadow_options_cmp (&val, &shadowOptions))
106 return true;
107 else
108 return false;
109 }
110 };
111
112 template <>
113 class GValueCmp <std::string>
114 {
115 public:
116
117 typedef const gchar * (*GetFunc) (const GValue *value);
118
119 bool compare (const std::string &val,
120 GValue *value,
121 GetFunc get)
122 {
123 const gchar *valueForValue = (*get) (value);
124 const std::string valueForValueStr (valueForValue);\
125
126 return val == valueForValueStr;
127 }
128 };
129
130 namespace
131 {
132 std::ostream &
133 operator<< (std::ostream &os, const decor_shadow_options_t &options)
134 {
135 os << " radius: " << options.shadow_radius <<
136 " opacity: " << options.shadow_opacity <<
137 " offset: (" << options.shadow_offset_x << ", " << options.shadow_offset_y << ")" <<
138 " color: r: " << options.shadow_color[0] <<
139 " g: " << options.shadow_color[1] <<
140 " b: " << options.shadow_color[2];
141
142 return os;
143 }
144 }
145
146 template <class ValueCType>
147 class GObjectPropertyMatcher :
148 public ::testing::MatcherInterface <GValue *>
149 {
150 public:
151
152 GObjectPropertyMatcher (const ValueCType &value,
153 typename GValueCmp<ValueCType>::GetFunc func) :
154 mValue (value),
155 mGetFunc (func)
156 {
157 }
158
159 virtual bool MatchAndExplain (GValue *value, MatchResultListener *listener) const
160 {
161 return GValueCmp <ValueCType> ().compare (mValue, value, mGetFunc);
162 }
163
164 virtual void DescribeTo (std::ostream *os) const
165 {
166 *os << "value contains " << mValue;
167 }
168
169 virtual void DescribeNegationTo (std::ostream *os) const
170 {
171 *os << "value does not contain " << mValue;
172 }
173
174 private:
175
176 const ValueCType &mValue;
177 typename GValueCmp<ValueCType>::GetFunc mGetFunc;
178 };
179
180 namespace testing_values
181 {
182 const gdouble ACTIVE_SHADOW_OPACITY_VALUE = 1.0;
183 const gdouble ACTIVE_SHADOW_RADIUS_VALUE = 2.0;
184 const gdouble ACTIVE_SHADOW_OFFSET_X_VALUE = 3.0;
185 const gint ACTIVE_SHADOW_OFFSET_X_INT_VALUE = ACTIVE_SHADOW_OFFSET_X_VALUE;
186 const gdouble ACTIVE_SHADOW_OFFSET_Y_VALUE = 4.0;
187 const gint ACTIVE_SHADOW_OFFSET_Y_INT_VALUE = ACTIVE_SHADOW_OFFSET_Y_VALUE;
188 const std::string ACTIVE_SHADOW_COLOR_STR_VALUE ("#ffffffff");
189 const gushort ACTIVE_SHADOW_COLOR_VALUE[] = { 255, 255, 255 };
190 const gdouble INACTIVE_SHADOW_OPACITY_VALUE = 5.0;
191 const gdouble INACTIVE_SHADOW_RADIUS_VALUE = 6.0;
192 const gdouble INACTIVE_SHADOW_OFFSET_X_VALUE = 7.0;
193 const gint INACTIVE_SHADOW_OFFSET_X_INT_VALUE = INACTIVE_SHADOW_OFFSET_X_VALUE;
194 const gdouble INACTIVE_SHADOW_OFFSET_Y_VALUE = 8.0;
195 const gint INACTIVE_SHADOW_OFFSET_Y_INT_VALUE = INACTIVE_SHADOW_OFFSET_Y_VALUE;
196 const std::string INACTIVE_SHADOW_COLOR_STR_VALUE ("#00000000");
197 const gushort INACTIVE_SHADOW_COLOR_VALUE[] = { 0, 0, 0 };
198 const gboolean USE_TOOLTIPS_VALUE = !USE_TOOLTIPS_DEFAULT;
199 const guint DRAGGABLE_BORDER_WIDTH_VALUE = 1;
200 const gboolean ATTACH_MODAL_DIALOGS_VALUE = TRUE;
201 const std::string BLUR_TYPE_TITLEBAR_VALUE ("titlebar");
202 const gint BLUR_TYPE_TITLEBAR_INT_VALUE = BLUR_TYPE_TITLEBAR;
203 const std::string BLUR_TYPE_ALL_VALUE ("all");
204 const gint BLUR_TYPE_ALL_INT_VALUE = BLUR_TYPE_ALL;
205 const std::string BLUR_TYPE_NONE_VALUE ("none");
206 const gint BLUR_TYPE_NONE_INT_VALUE = BLUR_TYPE_NONE;
207 const gboolean USE_METACITY_THEME_VALUE = TRUE;
208 const std::string METACITY_THEME_VALUE ("metacity_theme");
209 const gboolean NO_USE_METACITY_THEME_VALUE = FALSE;
210 const std::string NO_METACITY_THEME_VALUE ("");
211 const gdouble ACTIVE_OPACITY_VALUE = 0.9;
212 const gdouble INACTIVE_OPACITY_VALUE = 0.8;
213 const gboolean ACTIVE_SHADE_OPACITY_VALUE = !METACITY_ACTIVE_SHADE_OPACITY_DEFAULT;
214 const gboolean INACTIVE_SHADE_OPACITY_VALUE = !METACITY_INACTIVE_SHADE_OPACITY_DEFAULT;
215 const std::string BUTTON_LAYOUT_VALUE ("button_layout");
216 const gboolean USE_SYSTEM_FONT_VALUE = TRUE;
217 const gboolean NO_USE_SYSTEM_FONT_VALUE = FALSE;
218 const std::string TITLEBAR_FONT_VALUE ("Ubuntu 12");
219 const std::string TITLEBAR_ACTION_SHADE ("toggle_shade");
220 const std::string TITLEBAR_ACTION_MAX_VERT ("toggle_maximize_vertically");
221 const std::string TITLEBAR_ACTION_MAX_HORZ ("toggle_maximize_horizontally");
222 const std::string TITLEBAR_ACTION_MAX ("toggle_maximize");
223 const std::string TITLEBAR_ACTION_MINIMIZE ("minimize");
224 const std::string TITLEBAR_ACTION_MENU ("menu");
225 const std::string TITLEBAR_ACTION_LOWER ("lower");
226 const std::string TITLEBAR_ACTION_NONE ("none");
227 const std::string MOUSE_WHEEL_ACTION_SHADE ("shade");
228 }
229
230 template <class ValueCType>
231 inline Matcher<GValue *>
232 GValueMatch (const ValueCType &value,
233 typename GValueCmp<ValueCType>::GetFunc func)
234 {
235 return MakeMatcher (new GObjectPropertyMatcher <ValueCType> (value, func));
236 }
237
238 class GWDSettingsTestCommon :
239 public ::testing::Test
240 {
241 public:
242 virtual void SetUp ()
243 {
244 env.SetUpEnv ();
245 g_type_init ();
246 }
247 virtual void TearDown ()
248 {
249 env.TearDownEnv ();
250 }
251 private:
252
253 CompizGLibGSliceOffEnv env;
254 };
255
256 class GWDMockSettingsWritableTest :
257 public GWDSettingsTestCommon
258 {
259 };
260
261 const GValue referenceGValue = G_VALUE_INIT;
262
263 namespace
264 {
265 void gwd_settings_storage_unref (GWDSettingsStorage *storage)
266 {
267 g_object_unref (G_OBJECT (storage));
268 }
269
270 void gwd_settings_writable_unref (GWDSettingsWritable *writable)
271 {
272 g_object_unref (G_OBJECT (writable));
273 }
274
275 void gwd_settings_unref (GWDSettingsImpl *settings)
276 {
277 g_object_unref (G_OBJECT (settings));
278 }
279
280 void gwd_settings_notified_do_nothing (GWDSettingsNotified *notified)
281 {
282 }
283
284 class AutoUnsetGValue
285 {
286 public:
287
288 AutoUnsetGValue (GType type)
289 {
290 memcpy (&mValue, &referenceGValue, sizeof (GValue));
291 g_value_init (&mValue, type);
292 }
293
294 ~AutoUnsetGValue ()
295 {
296 g_value_unset (&mValue);
297 }
298
299 operator GValue & ()
300 {
301 return mValue;
302 }
303
304 private:
305
306 GValue mValue;
307 };
308 }
309
310 TEST_F(GWDMockSettingsWritableTest, TestMock)
311 {
312 GWDMockSettingsWritableGMock writableGMock;
313 boost::shared_ptr <GWDSettingsWritable> writableMock (gwd_mock_settings_writable_new (&writableGMock),
314 boost::bind (gwd_settings_writable_unref, _1));
315
316
317 EXPECT_CALL (writableGMock, freezeUpdates ());
318 EXPECT_CALL (writableGMock, thawUpdates ());
319 EXPECT_CALL (writableGMock, shadowPropertyChanged (testing_values::ACTIVE_SHADOW_RADIUS_VALUE,
320 testing_values::ACTIVE_SHADOW_OPACITY_VALUE,
321 testing_values::ACTIVE_SHADOW_OFFSET_X_VALUE,
322 testing_values::ACTIVE_SHADOW_OFFSET_Y_VALUE,
323 Eq (testing_values::ACTIVE_SHADOW_COLOR_STR_VALUE),
324 testing_values::INACTIVE_SHADOW_RADIUS_VALUE,
325 testing_values::INACTIVE_SHADOW_OPACITY_VALUE,
326 testing_values::INACTIVE_SHADOW_OFFSET_X_VALUE,
327 testing_values::INACTIVE_SHADOW_OFFSET_Y_VALUE,
328 Eq (testing_values::INACTIVE_SHADOW_COLOR_STR_VALUE))).WillOnce (Return (TRUE));
329 EXPECT_CALL (writableGMock, useTooltipsChanged (testing_values::USE_TOOLTIPS_VALUE)).WillOnce (Return (TRUE));
330 EXPECT_CALL (writableGMock, draggableBorderWidthChanged (testing_values::DRAGGABLE_BORDER_WIDTH_VALUE)).WillOnce (Return (TRUE));
331 EXPECT_CALL (writableGMock, attachModalDialogsChanged (testing_values::ATTACH_MODAL_DIALOGS_VALUE)).WillOnce (Return (TRUE));
332 EXPECT_CALL (writableGMock, blurChanged (Eq (testing_values::BLUR_TYPE_TITLEBAR_VALUE))).WillOnce (Return (TRUE));
333 EXPECT_CALL (writableGMock, metacityThemeChanged (TRUE, Eq (testing_values::METACITY_THEME_VALUE))).WillOnce (Return (TRUE));
334 EXPECT_CALL (writableGMock, opacityChanged (testing_values::ACTIVE_OPACITY_VALUE,
335 testing_values::INACTIVE_OPACITY_VALUE,
336 testing_values::ACTIVE_SHADE_OPACITY_VALUE,
337 testing_values::INACTIVE_SHADE_OPACITY_VALUE)).WillOnce (Return (TRUE));
338 EXPECT_CALL (writableGMock, buttonLayoutChanged (Eq (testing_values::BUTTON_LAYOUT_VALUE))).WillOnce (Return (TRUE));
339 EXPECT_CALL (writableGMock, fontChanged (testing_values::USE_SYSTEM_FONT_VALUE,
340 testing_values::TITLEBAR_FONT_VALUE.c_str ())).WillOnce (Return (TRUE));
341 EXPECT_CALL (writableGMock, titlebarActionsChanged (Eq (testing_values::TITLEBAR_ACTION_MAX),
342 Eq (testing_values::TITLEBAR_ACTION_MENU),
343 Eq (testing_values::TITLEBAR_ACTION_LOWER),
344 Eq (testing_values::TITLEBAR_ACTION_SHADE))).WillOnce (Return (TRUE));
345
346 EXPECT_CALL (writableGMock, dispose ());
347 EXPECT_CALL (writableGMock, finalize ());
348
349 gwd_settings_writable_freeze_updates (writableMock.get ());
350 gwd_settings_writable_thaw_updates (writableMock.get ());
351
352 EXPECT_THAT (gwd_settings_writable_shadow_property_changed (writableMock.get (),
353 testing_values::ACTIVE_SHADOW_RADIUS_VALUE,
354 testing_values::ACTIVE_SHADOW_OPACITY_VALUE,
355 testing_values::ACTIVE_SHADOW_OFFSET_X_VALUE,
356 testing_values::ACTIVE_SHADOW_OFFSET_Y_VALUE,
357 testing_values::ACTIVE_SHADOW_COLOR_STR_VALUE.c_str (),
358 testing_values::INACTIVE_SHADOW_RADIUS_VALUE,
359 testing_values::INACTIVE_SHADOW_OPACITY_VALUE,
360 testing_values::INACTIVE_SHADOW_OFFSET_X_VALUE,
361 testing_values::INACTIVE_SHADOW_OFFSET_Y_VALUE,
362 testing_values::INACTIVE_SHADOW_COLOR_STR_VALUE.c_str ()), IsTrue ());
363 EXPECT_THAT (gwd_settings_writable_use_tooltips_changed (writableMock.get (), testing_values::USE_TOOLTIPS_VALUE), IsTrue ());
364 EXPECT_THAT (gwd_settings_writable_draggable_border_width_changed (writableMock.get (), testing_values::DRAGGABLE_BORDER_WIDTH_VALUE), IsTrue ());
365 EXPECT_THAT (gwd_settings_writable_attach_modal_dialogs_changed (writableMock.get (), testing_values::ATTACH_MODAL_DIALOGS_VALUE), IsTrue ());
366 EXPECT_THAT (gwd_settings_writable_blur_changed (writableMock.get (), testing_values::BLUR_TYPE_TITLEBAR_VALUE.c_str ()), IsTrue ());
367 EXPECT_THAT (gwd_settings_writable_metacity_theme_changed (writableMock.get (),
368 testing_values::USE_METACITY_THEME_VALUE,
369 testing_values::METACITY_THEME_VALUE.c_str ()), IsTrue ());
370 EXPECT_THAT (gwd_settings_writable_opacity_changed (writableMock.get (),
371 testing_values::ACTIVE_OPACITY_VALUE,
372 testing_values::INACTIVE_OPACITY_VALUE,
373 testing_values::ACTIVE_SHADE_OPACITY_VALUE,
374 testing_values::INACTIVE_SHADE_OPACITY_VALUE), IsTrue ());
375 EXPECT_THAT (gwd_settings_writable_button_layout_changed (writableMock.get (),
376 testing_values::BUTTON_LAYOUT_VALUE.c_str ()), IsTrue ());
377 EXPECT_THAT (gwd_settings_writable_font_changed (writableMock.get (),
378 testing_values::USE_SYSTEM_FONT_VALUE,
379 testing_values::TITLEBAR_FONT_VALUE.c_str ()), IsTrue ());
380 EXPECT_THAT (gwd_settings_writable_titlebar_actions_changed (writableMock.get (),
381 testing_values::TITLEBAR_ACTION_MAX.c_str (),
382 testing_values::TITLEBAR_ACTION_MENU.c_str (),
383 testing_values::TITLEBAR_ACTION_LOWER.c_str (),
384 testing_values::TITLEBAR_ACTION_SHADE.c_str ()), IsTrue ());
385 }
386
387 class GWDMockSettingsTest :
388 public GWDSettingsTestCommon
389 {
390 };
391
392 TEST_F(GWDMockSettingsTest, TestMock)
393 {
394 GWDMockSettingsGMock settingsGMock;
395 boost::shared_ptr <GWDSettingsImpl> settingsMock (gwd_mock_settings_new (&settingsGMock),
396 boost::bind (gwd_settings_unref, _1));
397
398 AutoUnsetGValue pointerValue (G_TYPE_POINTER);
399 AutoUnsetGValue booleanValue (G_TYPE_BOOLEAN);
400 AutoUnsetGValue stringValue (G_TYPE_STRING);
401 AutoUnsetGValue integerValue (G_TYPE_INT);
402 AutoUnsetGValue doubleValue (G_TYPE_DOUBLE);
403
404 GValue &pointerGValue = pointerValue;
405 GValue &booleanGValue = booleanValue;
406 GValue &stringGValue = stringValue;
407 GValue &integerGValue = integerValue;
408 GValue &doubleGValue = doubleValue;
409
410 int POINTEE_VALUE = 1;
411 gpointer POINTER_VALUE = &POINTEE_VALUE;
412 const std::string STRING_VALUE ("test");
413 const int INTEGER_VALUE = 2;
414 const gboolean BOOLEAN_VALUE = TRUE;
415 const gdouble DOUBLE_VALUE = 2.0;
416
417 g_value_set_pointer (&pointerGValue, POINTER_VALUE);
418 g_value_set_boolean (&booleanGValue, BOOLEAN_VALUE);
419 g_value_set_string (&stringGValue, STRING_VALUE.c_str ());
420 g_value_set_int (&integerGValue, INTEGER_VALUE);
421 g_value_set_double (&doubleGValue, DOUBLE_VALUE);
422
423 EXPECT_CALL (settingsGMock, dispose ());
424 EXPECT_CALL (settingsGMock, finalize ());
425
426 /* calling g_object_get_property actually resets
427 * the value so expecting 0x0 is correct */
428 EXPECT_CALL (settingsGMock, getProperty (GWD_MOCK_SETTINGS_PROPERTY_ACTIVE_SHADOW,
429 GValueMatch <gpointer> (0x0, g_value_get_pointer),
430 _));
431 EXPECT_CALL (settingsGMock, getProperty (GWD_MOCK_SETTINGS_PROPERTY_INACTIVE_SHADOW,
432 GValueMatch <gpointer> (0x0, g_value_get_pointer),
433 _));
434 EXPECT_CALL (settingsGMock, getProperty (GWD_MOCK_SETTINGS_PROPERTY_USE_TOOLTIPS,
435 GValueMatch <gboolean> (FALSE, g_value_get_boolean),
436 _));
437 EXPECT_CALL (settingsGMock, getProperty (GWD_MOCK_SETTINGS_PROPERTY_DRAGGABLE_BORDER_WIDTH,
438 GValueMatch <gint> (0, g_value_get_int),
439 _));
440 EXPECT_CALL (settingsGMock, getProperty (GWD_MOCK_SETTINGS_PROPERTY_ATTACH_MODAL_DIALOGS,
441 GValueMatch <gboolean> (FALSE, g_value_get_boolean),
442 _));
443 EXPECT_CALL (settingsGMock, getProperty (GWD_MOCK_SETTINGS_PROPERTY_BLUR_CHANGED,
444 GValueMatch <gint> (0, g_value_get_int),
445 _));
446 EXPECT_CALL (settingsGMock, getProperty (GWD_MOCK_SETTINGS_PROPERTY_METACITY_THEME,
447 GValueMatch <const gchar *> (NULL, g_value_get_string),
448 _));
449 EXPECT_CALL (settingsGMock, getProperty (GWD_MOCK_SETTINGS_PROPERTY_ACTIVE_OPACITY,
450 GValueMatch <gdouble> (0.0, g_value_get_double),
451 _));
452 EXPECT_CALL (settingsGMock, getProperty (GWD_MOCK_SETTINGS_PROPERTY_INACTIVE_OPACITY,
453 GValueMatch <gdouble> (0.0, g_value_get_double),
454 _));
455 EXPECT_CALL (settingsGMock, getProperty (GWD_MOCK_SETTINGS_PROPERTY_ACTIVE_SHADE_OPACITY,
456 GValueMatch <gboolean> (FALSE, g_value_get_boolean),
457 _));
458 EXPECT_CALL (settingsGMock, getProperty (GWD_MOCK_SETTINGS_PROPERTY_INACTIVE_SHADE_OPACITY,
459 GValueMatch <gboolean> (FALSE, g_value_get_boolean),
460 _));
461 EXPECT_CALL (settingsGMock, getProperty (GWD_MOCK_SETTINGS_PROPERTY_BUTTON_LAYOUT,
462 GValueMatch <const gchar *> (NULL, g_value_get_string),
463 _));
464 EXPECT_CALL (settingsGMock, getProperty (GWD_MOCK_SETTINGS_PROPERTY_TITLEBAR_ACTION_DOUBLE_CLICK,
465 GValueMatch <gint> (0, g_value_get_int),
466 _));
467 EXPECT_CALL (settingsGMock, getProperty (GWD_MOCK_SETTINGS_PROPERTY_TITLEBAR_ACTION_MIDDLE_CLICK,
468 GValueMatch <gint> (0, g_value_get_int),
469 _));
470 EXPECT_CALL (settingsGMock, getProperty (GWD_MOCK_SETTINGS_PROPERTY_TITLEBAR_ACTION_RIGHT_CLICK,
471 GValueMatch <gint> (0, g_value_get_int),
472 _));
473 EXPECT_CALL (settingsGMock, getProperty (GWD_MOCK_SETTINGS_PROPERTY_MOUSE_WHEEL_ACTION,
474 GValueMatch <gint> (0, g_value_get_int),
475 _));
476 EXPECT_CALL (settingsGMock, getProperty (GWD_MOCK_SETTINGS_PROPERTY_TITLEBAR_FONT,
477 GValueMatch <const gchar *> (NULL, g_value_get_string),
478 _));
479
480 g_object_get_property (G_OBJECT (settingsMock.get ()),
481 "active-shadow",
482 &pointerGValue);
483 g_object_get_property (G_OBJECT (settingsMock.get ()),
484 "inactive-shadow",
485 &pointerGValue);
486 g_object_get_property (G_OBJECT (settingsMock.get ()),
487 "use-tooltips",
488 &booleanGValue);
489 g_object_get_property (G_OBJECT (settingsMock.get ()),
490 "draggable-border-width",
491 &integerGValue);
492 g_object_get_property (G_OBJECT (settingsMock.get ()),
493 "attach-modal-dialogs",
494 &booleanGValue);
495 g_object_get_property (G_OBJECT (settingsMock.get ()),
496 "blur",
497 &integerGValue);
498 g_object_get_property (G_OBJECT (settingsMock.get ()),
499 "metacity-theme",
500 &stringGValue);
501 g_object_get_property (G_OBJECT (settingsMock.get ()),
502 "metacity-active-opacity",
503 &doubleGValue);
504 g_object_get_property (G_OBJECT (settingsMock.get ()),
505 "metacity-inactive-opacity",
506 &doubleGValue);
507 g_object_get_property (G_OBJECT (settingsMock.get ()),
508 "metacity-active-shade-opacity",
509 &booleanGValue);
510 g_object_get_property (G_OBJECT (settingsMock.get ()),
511 "metacity-inactive-shade-opacity",
512 &booleanGValue);
513 g_object_get_property (G_OBJECT (settingsMock.get ()),
514 "metacity-button-layout",
515 &stringGValue);
516 g_object_get_property (G_OBJECT (settingsMock.get ()),
517 "titlebar-double-click-action",
518 &integerGValue);
519 g_object_get_property (G_OBJECT (settingsMock.get ()),
520 "titlebar-middle-click-action",
521 &integerGValue);
522 g_object_get_property (G_OBJECT (settingsMock.get ()),
523 "titlebar-right-click-action",
524 &integerGValue);
525 g_object_get_property (G_OBJECT (settingsMock.get ()),
526 "mouse-wheel-action",
527 &integerGValue);
528 g_object_get_property (G_OBJECT (settingsMock.get ()),
529 "titlebar-font",
530 &stringGValue);
531 }
532
533 namespace
534 {
535 void ExpectAllNotificationsOnce (boost::shared_ptr <StrictMock <GWDMockSettingsNotifiedGMock> > &gmockNotified,
536 boost::shared_ptr <GWDSettingsImpl> &settings)
537 {
538 InSequence s;
539
540 EXPECT_CALL (*gmockNotified, updateMetacityTheme ()).Times (1);
541 EXPECT_CALL (*gmockNotified, updateMetacityButtonLayout ()).Times (1);
542 EXPECT_CALL (*gmockNotified, updateFrames ()).Times (1);
543 EXPECT_CALL (*gmockNotified, updateDecorations ()).Times (1);
544
545 gwd_settings_writable_thaw_updates (GWD_SETTINGS_WRITABLE_INTERFACE (settings.get ()));
546 }
547 }
548
549 class GWDSettingsTest :
550 public GWDSettingsTestCommon
551 {
552 public:
553
554 virtual void SetUp ()
555 {
556 GWDSettingsTestCommon::SetUp ();
557 mGMockNotified.reset (new StrictMock <GWDMockSettingsNotifiedGMock> ());
558 mMockNotified.reset (gwd_mock_settings_notified_new (mGMockNotified.get ()),
559 boost::bind (gwd_settings_notified_do_nothing, _1));
560 mSettings.reset (gwd_settings_impl_new (NULL,
561 NULL,
562 mMockNotified.get ()),
563 boost::bind (gwd_settings_unref, _1));
564 ExpectAllNotificationsOnce (mGMockNotified, mSettings);
565 }
566
567 virtual void TearDown ()
568 {
569 EXPECT_CALL (*mGMockNotified, dispose ());
570 EXPECT_CALL (*mGMockNotified, finalize ());
571 }
572
573 protected:
574
575 boost::shared_ptr <StrictMock <GWDMockSettingsNotifiedGMock> > mGMockNotified;
576 boost::shared_ptr <GWDSettingsNotified> mMockNotified;
577 boost::shared_ptr <GWDSettingsImpl> mSettings;
578 };
579
580 TEST_F(GWDSettingsTest, TestGWDSettingsInstantiation)
581 {
582 }
583
584 /* Won't fail if the code in SetUp succeeds */
585 TEST_F(GWDSettingsTest, TestUpdateAllOnInstantiation)
586 {
587 }
588
589 /* We're just using use_tooltips here as an example */
590 TEST_F(GWDSettingsTest, TestFreezeUpdatesNoUpdates)
591 {
592 gwd_settings_writable_freeze_updates (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()));
593 EXPECT_THAT (gwd_settings_writable_use_tooltips_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
594 testing_values::USE_TOOLTIPS_VALUE), IsTrue ());
595 }
596
597 /* We're just using use_tooltips here as an example */
598 TEST_F(GWDSettingsTest, TestFreezeUpdatesNoUpdatesThawUpdatesAllUpdates)
599 {
600 gwd_settings_writable_freeze_updates (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()));
601 EXPECT_THAT (gwd_settings_writable_use_tooltips_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
602 testing_values::USE_TOOLTIPS_VALUE), IsTrue ());
603
604 EXPECT_CALL (*mGMockNotified, updateDecorations ());
605 gwd_settings_writable_thaw_updates (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()));
606 }
607
608 /* We're just using use_tooltips here as an example */
609 TEST_F(GWDSettingsTest, TestFreezeUpdatesNoUpdatesThawUpdatesAllUpdatesNoDupes)
610 {
611 gwd_settings_writable_freeze_updates (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()));
612 EXPECT_THAT (gwd_settings_writable_use_tooltips_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
613 testing_values::USE_TOOLTIPS_VALUE), IsTrue ());
614 EXPECT_THAT (gwd_settings_writable_use_tooltips_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
615 !testing_values::USE_TOOLTIPS_VALUE), IsTrue ());
616 EXPECT_THAT (gwd_settings_writable_use_tooltips_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
617 testing_values::USE_TOOLTIPS_VALUE), IsTrue ());
618
619 EXPECT_CALL (*mGMockNotified, updateDecorations ()).Times (1);
620 gwd_settings_writable_thaw_updates (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()));
621 }
622
623 TEST_F(GWDSettingsTest, TestShadowPropertyChanged)
624 {
625 EXPECT_CALL (*mGMockNotified, updateDecorations ());
626 EXPECT_THAT (gwd_settings_writable_shadow_property_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
627 testing_values::ACTIVE_SHADOW_OPACITY_VALUE,
628 testing_values::ACTIVE_SHADOW_RADIUS_VALUE,
629 testing_values::ACTIVE_SHADOW_OFFSET_X_VALUE,
630 testing_values::ACTIVE_SHADOW_OFFSET_Y_VALUE,
631 testing_values::ACTIVE_SHADOW_COLOR_STR_VALUE.c_str (),
632 testing_values::INACTIVE_SHADOW_OPACITY_VALUE,
633 testing_values::INACTIVE_SHADOW_RADIUS_VALUE,
634 testing_values::INACTIVE_SHADOW_OFFSET_X_VALUE,
635 testing_values::INACTIVE_SHADOW_OFFSET_Y_VALUE,
636 testing_values::INACTIVE_SHADOW_COLOR_STR_VALUE.c_str ()), IsTrue ());
637
638 AutoUnsetGValue activeShadowValue (G_TYPE_POINTER);
639 AutoUnsetGValue inactiveShadowValue (G_TYPE_POINTER);
640
641 GValue &activeShadowGValue = activeShadowValue;
642 GValue &inactiveShadowGValue = inactiveShadowValue;
643
644 g_object_get_property (G_OBJECT (mSettings.get ()),
645 "active-shadow",
646 &activeShadowGValue);
647
648 g_object_get_property (G_OBJECT (mSettings.get ()),
649 "inactive-shadow",
650 &inactiveShadowGValue);
651
652 decor_shadow_options_t activeShadow;
653
654 activeShadow.shadow_opacity = testing_values::ACTIVE_SHADOW_OPACITY_VALUE;
655 activeShadow.shadow_radius = testing_values::ACTIVE_SHADOW_RADIUS_VALUE;
656 activeShadow.shadow_offset_x = testing_values::ACTIVE_SHADOW_OFFSET_X_INT_VALUE;
657 activeShadow.shadow_offset_y = testing_values::ACTIVE_SHADOW_OFFSET_Y_INT_VALUE;
658 activeShadow.shadow_color[0] = testing_values::ACTIVE_SHADOW_COLOR_VALUE[0];
659 activeShadow.shadow_color[1] = testing_values::ACTIVE_SHADOW_COLOR_VALUE[1];
660 activeShadow.shadow_color[2] = testing_values::ACTIVE_SHADOW_COLOR_VALUE[2];
661
662 decor_shadow_options_t inactiveShadow;
663
664 inactiveShadow.shadow_opacity = testing_values::INACTIVE_SHADOW_OPACITY_VALUE;
665 inactiveShadow.shadow_radius = testing_values::INACTIVE_SHADOW_RADIUS_VALUE;
666 inactiveShadow.shadow_offset_x = testing_values::INACTIVE_SHADOW_OFFSET_X_INT_VALUE;
667 inactiveShadow.shadow_offset_y = testing_values::INACTIVE_SHADOW_OFFSET_Y_INT_VALUE;
668 inactiveShadow.shadow_color[0] = testing_values::INACTIVE_SHADOW_COLOR_VALUE[0];
669 inactiveShadow.shadow_color[1] = testing_values::INACTIVE_SHADOW_COLOR_VALUE[1];
670 inactiveShadow.shadow_color[2] = testing_values::INACTIVE_SHADOW_COLOR_VALUE[2];
671
672 EXPECT_THAT (&activeShadowGValue, GValueMatch <decor_shadow_options_t> (activeShadow,
673 g_value_get_pointer));
674 EXPECT_THAT (&inactiveShadowGValue, GValueMatch <decor_shadow_options_t> (inactiveShadow,
675 g_value_get_pointer));
676 }
677
678 TEST_F(GWDSettingsTest, TestShadowPropertyChangedIsDefault)
679 {
680 EXPECT_THAT (gwd_settings_writable_shadow_property_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
681 ACTIVE_SHADOW_RADIUS_DEFAULT,
682 ACTIVE_SHADOW_OPACITY_DEFAULT,
683 ACTIVE_SHADOW_OFFSET_X_DEFAULT,
684 ACTIVE_SHADOW_OFFSET_Y_DEFAULT,
685 ACTIVE_SHADOW_COLOR_DEFAULT,
686 INACTIVE_SHADOW_RADIUS_DEFAULT,
687 INACTIVE_SHADOW_OPACITY_DEFAULT,
688 INACTIVE_SHADOW_OFFSET_X_DEFAULT,
689 INACTIVE_SHADOW_OFFSET_Y_DEFAULT,
690 INACTIVE_SHADOW_COLOR_DEFAULT), IsFalse ());
691 }
692
693 TEST_F(GWDSettingsTest, TestUseTooltipsChanged)
694 {
695 EXPECT_CALL (*mGMockNotified, updateDecorations ());
696 EXPECT_THAT (gwd_settings_writable_use_tooltips_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
697 testing_values::USE_TOOLTIPS_VALUE), IsTrue ());
698
699 AutoUnsetGValue useTooltipsValue (G_TYPE_BOOLEAN);
700 GValue &useTooltipsGValue = useTooltipsValue;
701
702 g_object_get_property (G_OBJECT (mSettings.get ()),
703 "use-tooltips",
704 &useTooltipsGValue);
705
706 EXPECT_THAT (&useTooltipsGValue, GValueMatch <gboolean> (testing_values::USE_TOOLTIPS_VALUE,
707 g_value_get_boolean));
708 }
709
710 TEST_F(GWDSettingsTest, TestUseTooltipsChangedIsDefault)
711 {
712 EXPECT_THAT (gwd_settings_writable_use_tooltips_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
713 USE_TOOLTIPS_DEFAULT), IsFalse ());
714 }
715
716 TEST_F(GWDSettingsTest, TestDraggableBorderWidthChanged)
717 {
718 EXPECT_CALL (*mGMockNotified, updateDecorations ());
719 EXPECT_THAT (gwd_settings_writable_draggable_border_width_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
720 testing_values::DRAGGABLE_BORDER_WIDTH_VALUE), IsTrue ());
721
722 AutoUnsetGValue draggableBorderWidthValue (G_TYPE_INT);
723 GValue &draggableBorderWidthGValue = draggableBorderWidthValue;
724
725 g_object_get_property (G_OBJECT (mSettings.get ()),
726 "draggable-border-width",
727 &draggableBorderWidthGValue);
728
729 EXPECT_THAT (&draggableBorderWidthGValue, GValueMatch <gint> (testing_values::DRAGGABLE_BORDER_WIDTH_VALUE,
730 g_value_get_int));
731 }
732
733 TEST_F(GWDSettingsTest, TestDraggableBorderWidthChangedIsDefault)
734 {
735 EXPECT_THAT (gwd_settings_writable_draggable_border_width_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
736 DRAGGABLE_BORDER_WIDTH_DEFAULT), IsFalse ());
737 }
738
739 TEST_F(GWDSettingsTest, TestAttachModalDialogsChanged)
740 {
741 EXPECT_CALL (*mGMockNotified, updateDecorations ());
742 EXPECT_THAT (gwd_settings_writable_attach_modal_dialogs_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
743 testing_values::ATTACH_MODAL_DIALOGS_VALUE), IsTrue ());
744
745 AutoUnsetGValue attachModalDialogsValue (G_TYPE_BOOLEAN);
746 GValue &attachModalDialogsGValue = attachModalDialogsValue;
747
748 g_object_get_property (G_OBJECT (mSettings.get ()),
749 "attach-modal-dialogs",
750 &attachModalDialogsGValue);
751
752 EXPECT_THAT (&attachModalDialogsGValue, GValueMatch <gboolean> (testing_values::ATTACH_MODAL_DIALOGS_VALUE,
753 g_value_get_boolean));
754 }
755
756 TEST_F(GWDSettingsTest, TestAttachModalDialogsChangedIsDefault)
757 {
758 EXPECT_THAT (gwd_settings_writable_attach_modal_dialogs_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
759 ATTACH_MODAL_DIALOGS_DEFAULT), IsFalse ());
760 }
761
762 TEST_F(GWDSettingsTest, TestBlurChangedTitlebar)
763 {
764 EXPECT_CALL (*mGMockNotified, updateDecorations ());
765 EXPECT_THAT (gwd_settings_writable_blur_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
766 testing_values::BLUR_TYPE_TITLEBAR_VALUE.c_str ()), IsTrue ());
767
768 AutoUnsetGValue blurValue (G_TYPE_INT);
769 GValue &blurGValue = blurValue;
770
771 g_object_get_property (G_OBJECT (mSettings.get ()),
772 "blur",
773 &blurGValue);
774
775 EXPECT_THAT (&blurGValue, GValueMatch <gint> (testing_values::BLUR_TYPE_TITLEBAR_INT_VALUE,
776 g_value_get_int));
777 }
778
779 TEST_F(GWDSettingsTest, TestBlurChangedAll)
780 {
781 EXPECT_CALL (*mGMockNotified, updateDecorations ());
782 EXPECT_THAT (gwd_settings_writable_blur_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
783 testing_values::BLUR_TYPE_ALL_VALUE.c_str ()), IsTrue ());
784
785 AutoUnsetGValue blurValue (G_TYPE_INT);
786 GValue &blurGValue = blurValue;
787
788 g_object_get_property (G_OBJECT (mSettings.get ()),
789 "blur",
790 &blurGValue);
791
792 EXPECT_THAT (&blurGValue, GValueMatch <gint> (testing_values::BLUR_TYPE_ALL_INT_VALUE,
793 g_value_get_int));
794 }
795
796 TEST_F(GWDSettingsTest, TestBlurChangedNone)
797 {
798 EXPECT_THAT (gwd_settings_writable_blur_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
799 testing_values::BLUR_TYPE_NONE_VALUE.c_str ()), IsFalse ());
800
801 AutoUnsetGValue blurValue (G_TYPE_INT);
802 GValue &blurGValue = blurValue;
803
804 g_object_get_property (G_OBJECT (mSettings.get ()),
805 "blur",
806 &blurGValue);
807
808 EXPECT_THAT (&blurGValue, GValueMatch <gint> (testing_values::BLUR_TYPE_NONE_INT_VALUE,
809 g_value_get_int));
810 }
811
812 TEST_F(GWDSettingsTest, TestBlurSetCommandLine)
813 {
814 gint blurType = testing_values::BLUR_TYPE_ALL_INT_VALUE;
815
816 /* We need to increment the reference count so that it doesn't
817 * go away when we create a new GWDSettingsImpl */
818 g_object_ref (mMockNotified.get ());
819 mSettings.reset (gwd_settings_impl_new (&blurType,
820 NULL,
821 mMockNotified.get ()),
822 boost::bind (gwd_settings_unref, _1));
823
824 EXPECT_THAT (gwd_settings_writable_blur_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
825 testing_values::BLUR_TYPE_NONE_VALUE.c_str ()), IsFalse ());
826
827 AutoUnsetGValue blurValue (G_TYPE_INT);
828 GValue &blurGValue = blurValue;
829
830 g_object_get_property (G_OBJECT (mSettings.get ()),
831 "blur",
832 &blurGValue);
833
834 EXPECT_THAT (&blurGValue, GValueMatch <gint> (testing_values::BLUR_TYPE_ALL_INT_VALUE,
835 g_value_get_int));
836 }
837
838 TEST_F(GWDSettingsTest, TestMetacityThemeChanged)
839 {
840 EXPECT_CALL (*mGMockNotified, updateMetacityTheme ());
841 EXPECT_CALL (*mGMockNotified, updateDecorations ());
842 EXPECT_THAT (gwd_settings_writable_metacity_theme_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
843 testing_values::USE_METACITY_THEME_VALUE,
844 testing_values::METACITY_THEME_VALUE.c_str ()), IsTrue ());
845
846 AutoUnsetGValue metacityThemeValue (G_TYPE_STRING);
847 GValue &metacityThemeGValue = metacityThemeValue;
848
849 g_object_get_property (G_OBJECT (mSettings.get ()),
850 "metacity-theme",
851 &metacityThemeGValue);
852
853 EXPECT_THAT (&metacityThemeGValue, GValueMatch <std::string> (testing_values::METACITY_THEME_VALUE,
854 g_value_get_string));
855 }
856
857 TEST_F(GWDSettingsTest, TestMetacityThemeChangedNoUseMetacityTheme)
858 {
859 EXPECT_CALL (*mGMockNotified, updateMetacityTheme ());
860 EXPECT_CALL (*mGMockNotified, updateDecorations ());
861 EXPECT_THAT (gwd_settings_writable_metacity_theme_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
862 testing_values::NO_USE_METACITY_THEME_VALUE,
863 testing_values::METACITY_THEME_VALUE.c_str ()), IsTrue ());
864
865 AutoUnsetGValue metacityThemeValue (G_TYPE_STRING);
866 GValue &metacityThemeGValue = metacityThemeValue;
867
868 g_object_get_property (G_OBJECT (mSettings.get ()),
869 "metacity-theme",
870 &metacityThemeGValue);
871
872 EXPECT_THAT (&metacityThemeGValue, GValueMatch <std::string> (testing_values::NO_METACITY_THEME_VALUE,
873 g_value_get_string));
874 }
875
876 TEST_F(GWDSettingsTest, TestMetacityThemeChangedIsDefault)
877 {
878 EXPECT_THAT (gwd_settings_writable_metacity_theme_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
879 testing_values::USE_METACITY_THEME_VALUE,
880 METACITY_THEME_DEFAULT), IsFalse ());
881 }
882
883 TEST_F(GWDSettingsTest, TestMetacityThemeSetCommandLine)
884 {
885 const gchar *metacityTheme = "Ambiance";
886
887 g_object_ref (mMockNotified.get ());
888 mSettings.reset (gwd_settings_impl_new (NULL,
889 &metacityTheme,
890 mMockNotified.get ()),
891 boost::bind (gwd_settings_unref, _1));
892
893 EXPECT_THAT (gwd_settings_writable_metacity_theme_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
894 testing_values::USE_METACITY_THEME_VALUE,
895 testing_values::METACITY_THEME_VALUE.c_str ()), IsFalse ());
896
897 AutoUnsetGValue metacityThemeValue (G_TYPE_STRING);
898 GValue &metacityThemeGValue = metacityThemeValue;
899
900 g_object_get_property (G_OBJECT (mSettings.get ()),
901 "metacity-theme",
902 &metacityThemeGValue);
903
904 EXPECT_THAT (&metacityThemeGValue, GValueMatch <std::string> (std::string (metacityTheme),
905 g_value_get_string));
906 }
907
908 TEST_F(GWDSettingsTest, TestMetacityOpacityChanged)
909 {
910 EXPECT_CALL (*mGMockNotified, updateDecorations ());
911 EXPECT_THAT (gwd_settings_writable_opacity_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
912 testing_values::ACTIVE_OPACITY_VALUE,
913 testing_values::INACTIVE_OPACITY_VALUE,
914 testing_values::ACTIVE_SHADE_OPACITY_VALUE,
915 testing_values::INACTIVE_SHADE_OPACITY_VALUE), IsTrue ());
916
917 AutoUnsetGValue metacityInactiveOpacityValue (G_TYPE_DOUBLE);
918 AutoUnsetGValue metacityActiveOpacityValue (G_TYPE_DOUBLE);
919 AutoUnsetGValue metacityInactiveShadeOpacityValue (G_TYPE_BOOLEAN);
920 AutoUnsetGValue metacityActiveShadeOpacityValue (G_TYPE_BOOLEAN);
921
922 GValue &metacityInactiveOpacityGValue = metacityInactiveOpacityValue;
923 GValue &metacityActiveOpacityGValue = metacityActiveOpacityValue;
924 GValue &metacityInactiveShadeOpacityGValue = metacityInactiveShadeOpacityValue;
925 GValue &metacityActiveShadeOpacityGValue = metacityActiveShadeOpacityValue;
926
927 g_object_get_property (G_OBJECT (mSettings.get ()),
928 "metacity-inactive-opacity",
929 &metacityInactiveOpacityGValue);
930 g_object_get_property (G_OBJECT (mSettings.get ()),
931 "metacity-active-opacity",
932 &metacityActiveOpacityGValue);
933 g_object_get_property (G_OBJECT (mSettings.get ()),
934 "metacity-inactive-shade-opacity",
935 &metacityInactiveShadeOpacityGValue);
936 g_object_get_property (G_OBJECT (mSettings.get ()),
937 "metacity-active-shade-opacity",
938 &metacityActiveShadeOpacityGValue);
939
940 EXPECT_THAT (&metacityInactiveOpacityGValue, GValueMatch <gdouble> (testing_values::INACTIVE_OPACITY_VALUE,
941 g_value_get_double));
942 EXPECT_THAT (&metacityActiveOpacityGValue, GValueMatch <gdouble> (testing_values::ACTIVE_OPACITY_VALUE,
943 g_value_get_double));
944 EXPECT_THAT (&metacityInactiveShadeOpacityGValue, GValueMatch <gboolean> (testing_values::INACTIVE_SHADE_OPACITY_VALUE,
945 g_value_get_boolean));
946 EXPECT_THAT (&metacityActiveShadeOpacityGValue, GValueMatch <gboolean> (testing_values::ACTIVE_SHADE_OPACITY_VALUE,
947 g_value_get_boolean));
948 }
949
950 TEST_F(GWDSettingsTest, TestMetacityOpacityChangedIsDefault)
951 {
952 EXPECT_THAT (gwd_settings_writable_opacity_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
953 METACITY_ACTIVE_OPACITY_DEFAULT,
954 METACITY_INACTIVE_OPACITY_DEFAULT,
955 METACITY_ACTIVE_SHADE_OPACITY_DEFAULT,
956 METACITY_INACTIVE_SHADE_OPACITY_DEFAULT), IsFalse ());
957 }
958
959 TEST_F(GWDSettingsTest, TestButtonLayoutChanged)
960 {
961 EXPECT_CALL (*mGMockNotified, updateMetacityButtonLayout ());
962 EXPECT_CALL (*mGMockNotified, updateDecorations ());
963 EXPECT_THAT (gwd_settings_writable_button_layout_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
964 testing_values::BUTTON_LAYOUT_VALUE.c_str ()), IsTrue ());
965
966 AutoUnsetGValue buttonLayoutValue (G_TYPE_STRING);
967 GValue &buttonLayoutGValue = buttonLayoutValue;
968
969 g_object_get_property (G_OBJECT (mSettings.get ()),
970 "metacity-button-layout",
971 &buttonLayoutGValue);
972
973 EXPECT_THAT (&buttonLayoutGValue, GValueMatch <std::string> (testing_values::BUTTON_LAYOUT_VALUE,
974 g_value_get_string));
975 }
976
977 TEST_F(GWDSettingsTest, TestButtonLayoutChangedIsDefault)
978 {
979 EXPECT_THAT (gwd_settings_writable_button_layout_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
980 METACITY_BUTTON_LAYOUT_DEFAULT), IsFalse ());
981 }
982
983 TEST_F(GWDSettingsTest, TestTitlebarFontChanged)
984 {
985 EXPECT_CALL (*mGMockNotified, updateFrames ());
986 EXPECT_CALL (*mGMockNotified, updateDecorations ());
987 EXPECT_THAT (gwd_settings_writable_font_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
988 testing_values::NO_USE_SYSTEM_FONT_VALUE,
989 testing_values::TITLEBAR_FONT_VALUE.c_str ()), IsTrue ());
990
991 AutoUnsetGValue fontValue (G_TYPE_STRING);
992 GValue &fontGValue = fontValue;
993
994 g_object_get_property (G_OBJECT (mSettings.get ()),
995 "titlebar-font",
996 &fontGValue);
997
998 EXPECT_THAT (&fontGValue, GValueMatch <std::string> (testing_values::TITLEBAR_FONT_VALUE.c_str (),
999 g_value_get_string));
1000 }
1001
1002 TEST_F(GWDSettingsTest, TestTitlebarFontChangedUseSystemFont)
1003 {
1004 EXPECT_CALL (*mGMockNotified, updateFrames ());
1005 EXPECT_CALL (*mGMockNotified, updateDecorations ());
1006 EXPECT_THAT (gwd_settings_writable_font_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
1007 testing_values::USE_SYSTEM_FONT_VALUE,
1008 testing_values::TITLEBAR_FONT_VALUE.c_str ()), IsTrue ());
1009
1010 AutoUnsetGValue fontValue (G_TYPE_STRING);
1011 GValue &fontGValue = fontValue;
1012
1013 g_object_get_property (G_OBJECT (mSettings.get ()),
1014 "titlebar-font",
1015 &fontGValue);
1016
1017 EXPECT_THAT (&fontGValue, GValueMatch <const gchar *> (NULL,
1018 g_value_get_string));
1019 }
1020
1021
1022 TEST_F(GWDSettingsTest, TestTitlebarFontChangedIsDefault)
1023 {
1024 EXPECT_THAT (gwd_settings_writable_font_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
1025 testing_values::NO_USE_SYSTEM_FONT_VALUE,
1026 TITLEBAR_FONT_DEFAULT), IsFalse ());
1027 }
1028
1029 namespace
1030 {
1031 class GWDTitlebarActionInfo
1032 {
1033 public:
1034
1035 GWDTitlebarActionInfo (const std::string &titlebarAction,
1036 const std::string &mouseWheelAction,
1037 const gint titlebarActionId,
1038 const gint mouseWheelActionId) :
1039 mTitlebarAction (titlebarAction),
1040 mMouseWheelAction (mouseWheelAction),
1041 mTitlebarActionId (titlebarActionId),
1042 mMouseWheelActionId (mouseWheelActionId)
1043 {
1044 }
1045
1046 const std::string & titlebarAction () const { return mTitlebarAction; }
1047 const std::string & mouseWheelAction () const { return mMouseWheelAction; }
1048 const gint & titlebarActionId () const { return mTitlebarActionId; }
1049 const gint & mouseWheelActionId () const { return mMouseWheelActionId; }
1050
1051 private:
1052
1053 std::string mTitlebarAction;
1054 std::string mMouseWheelAction;
1055 gint mTitlebarActionId;
1056 gint mMouseWheelActionId;
1057 };
1058 }
1059
1060 class GWDSettingsTestClickActions :
1061 public GWDSettingsTestCommon,
1062 public ::testing::WithParamInterface <GWDTitlebarActionInfo>
1063 {
1064 public:
1065
1066 virtual void SetUp ()
1067 {
1068 GWDSettingsTestCommon::SetUp ();
1069 mGMockNotified.reset (new GWDMockSettingsNotifiedGMock ());
1070 mMockNotified.reset (gwd_mock_settings_notified_new (mGMockNotified.get ()),
1071 boost::bind (gwd_settings_notified_do_nothing, _1));
1072 mSettings.reset (gwd_settings_impl_new (NULL,
1073 NULL,
1074 mMockNotified.get ()),
1075 boost::bind (gwd_settings_unref, _1));
1076 }
1077
1078 virtual void TearDown ()
1079 {
1080 EXPECT_CALL (*mGMockNotified, dispose ());
1081 EXPECT_CALL (*mGMockNotified, finalize ());
1082
1083 GWDSettingsTestCommon::TearDown ();
1084 }
1085
1086 protected:
1087
1088 boost::shared_ptr <GWDMockSettingsNotifiedGMock> mGMockNotified;
1089 boost::shared_ptr <GWDSettingsNotified> mMockNotified;
1090 boost::shared_ptr <GWDSettingsImpl> mSettings;
1091 };
1092
1093 TEST_P(GWDSettingsTestClickActions, TestClickActionsAndMouseActions)
1094 {
1095 gwd_settings_writable_titlebar_actions_changed (GWD_SETTINGS_WRITABLE_INTERFACE (mSettings.get ()),
1096 GetParam ().titlebarAction ().c_str (),
1097 GetParam ().titlebarAction ().c_str (),
1098 GetParam ().titlebarAction ().c_str (),
1099 GetParam ().mouseWheelAction ().c_str ());
1100
1101 AutoUnsetGValue doubleClickActionValue (G_TYPE_INT);
1102 AutoUnsetGValue middleClickActionValue (G_TYPE_INT);
1103 AutoUnsetGValue rightClickActionValue (G_TYPE_INT);
1104 AutoUnsetGValue mouseWheelActionValue (G_TYPE_INT);
1105
1106 GValue &doubleClickActionGValue = doubleClickActionValue;
1107 GValue &middleClickActionGValue = middleClickActionValue;
1108 GValue &rightClickActionGValue = rightClickActionValue;
1109 GValue &mouseWheelActionGValue = mouseWheelActionValue;
1110
1111 g_object_get_property (G_OBJECT (mSettings.get ()),
1112 "titlebar-double-click-action",
1113 &doubleClickActionGValue);
1114
1115 g_object_get_property (G_OBJECT (mSettings.get ()),
1116 "titlebar-middle-click-action",
1117 &middleClickActionGValue);
1118
1119 g_object_get_property (G_OBJECT (mSettings.get ()),
1120 "titlebar-right-click-action",
1121 &rightClickActionGValue);
1122
1123 g_object_get_property (G_OBJECT (mSettings.get ()),
1124 "mouse-wheel-action",
1125 &mouseWheelActionGValue);
1126
1127 EXPECT_THAT (&doubleClickActionGValue, GValueMatch <gint> (GetParam ().titlebarActionId (),
1128 g_value_get_int));
1129 EXPECT_THAT (&middleClickActionGValue, GValueMatch <gint> (GetParam ().titlebarActionId (),
1130 g_value_get_int));
1131 EXPECT_THAT (&rightClickActionGValue, GValueMatch <gint> (GetParam ().titlebarActionId (),
1132 g_value_get_int));
1133 EXPECT_THAT (&mouseWheelActionGValue, GValueMatch <gint> (GetParam ().mouseWheelActionId (),
1134 g_value_get_int));
1135 }
1136
1137 INSTANTIATE_TEST_CASE_P (MouseActions, GWDSettingsTestClickActions,
1138 ::testing::Values (GWDTitlebarActionInfo (testing_values::TITLEBAR_ACTION_NONE,
1139 testing_values::TITLEBAR_ACTION_NONE,
1140 CLICK_ACTION_NONE,
1141 WHEEL_ACTION_NONE),
1142 GWDTitlebarActionInfo (testing_values::TITLEBAR_ACTION_SHADE,
1143 testing_values::MOUSE_WHEEL_ACTION_SHADE,
1144 CLICK_ACTION_SHADE,
1145 WHEEL_ACTION_SHADE),
1146 GWDTitlebarActionInfo (testing_values::TITLEBAR_ACTION_MAX,
1147 testing_values::MOUSE_WHEEL_ACTION_SHADE,
1148 CLICK_ACTION_MAXIMIZE,
1149 WHEEL_ACTION_SHADE),
1150 GWDTitlebarActionInfo (testing_values::TITLEBAR_ACTION_MINIMIZE,
1151 testing_values::MOUSE_WHEEL_ACTION_SHADE,
1152 CLICK_ACTION_MINIMIZE,
1153 WHEEL_ACTION_SHADE),
1154 GWDTitlebarActionInfo (testing_values::TITLEBAR_ACTION_LOWER,
1155 testing_values::MOUSE_WHEEL_ACTION_SHADE,
1156 CLICK_ACTION_LOWER,
1157 WHEEL_ACTION_SHADE),
1158 GWDTitlebarActionInfo (testing_values::TITLEBAR_ACTION_MENU,
1159 testing_values::MOUSE_WHEEL_ACTION_SHADE,
1160 CLICK_ACTION_MENU,
1161 WHEEL_ACTION_SHADE)));
1162
1163 class GWDSettingsStorageFactoryWrapperInterface
1164 {
1165 public:
1166
1167 typedef boost::shared_ptr <GWDSettingsStorageFactoryWrapperInterface> Ptr;
1168 virtual ~GWDSettingsStorageFactoryWrapperInterface () {}
1169
1170 virtual void SetUp (GWDSettingsWritable *writable) = 0;
1171 virtual GWDSettingsStorage * GetStorage () = 0;
1172 virtual void SetUseTooltips (gboolean useTooltips) = 0;
1173 virtual void SetDraggableBorderWidth (gint draggableBorderWidth) = 0;
1174 virtual void SetAttachModalDialogs (gboolean attachModalDialogs) = 0;
1175 virtual void SetBlur (const std::string &blurType) = 0;
1176 virtual void SetOpacity (gdouble activeOpacity,
1177 gdouble inactiveOpacity,
1178 gboolean activeShadeOpacity,
1179 gboolean inactiveShadeOpacity) = 0;
1180 virtual void SetMetacityTheme (gboolean useMetacityTheme,
1181 const std::string &metacityTheme) = 0;
1182 virtual void SetButtonLayout (const std::string &buttonLayout) = 0;
1183 virtual void SetFont (gboolean useSystemFont, const std::string &titlebarFont) = 0;
1184 virtual void SetTitlebarActions (const std::string &doubleClickAction,
1185 const std::string &middleClickAction,
1186 const std::string &rightClickAction,
1187 const std::string &mouseWheelAction) = 0;
1188 virtual void TearDown () = 0;
1189 };
1190
1191 class GWDSettingsTestStorageUpdates :
1192 public GWDSettingsTestCommon,
1193 public ::testing::WithParamInterface <GWDSettingsStorageFactoryWrapperInterface::Ptr>
1194 {
1195 public:
1196
1197 virtual void SetUp ()
1198 {
1199 GWDSettingsTestCommon::SetUp ();
1200 mSettingsMock.reset (new GWDMockSettingsWritableGMock ());
1201 mSettings.reset (gwd_mock_settings_writable_new (mSettingsMock.get ()),
1202 boost::bind (gwd_settings_writable_unref, _1));
1203
1204 GetParam ()->SetUp (mSettings.get ());
1205 }
1206
1207 virtual void TearDown ()
1208 {
1209 EXPECT_CALL (*mSettingsMock, dispose ());
1210 EXPECT_CALL (*mSettingsMock, finalize ());
1211
1212 GetParam ()->TearDown ();
1213 GWDSettingsTestCommon::TearDown ();
1214 }
1215
1216 protected:
1217
1218 boost::shared_ptr <GWDMockSettingsWritableGMock> mSettingsMock;
1219 boost::shared_ptr <GWDSettingsWritable> mSettings;
1220 };
1221
1222 ACTION_P (InvokeFunctor, p) { return p (); }
1223
1224 TEST_P (GWDSettingsTestStorageUpdates, TestInstantiation)
1225 {
1226 }
1227
1228 TEST_P (GWDSettingsTestStorageUpdates, TestSetUseTooltips)
1229 {
1230 GWDSettingsStorage *storage = GetParam ()->GetStorage ();
1231 GetParam ()->SetUseTooltips (testing_values::USE_TOOLTIPS_VALUE);
1232
1233 EXPECT_CALL (*mSettingsMock, useTooltipsChanged (testing_values::USE_TOOLTIPS_VALUE));
1234
1235 gwd_settings_storage_update_use_tooltips (storage);
1236 }
1237
1238 TEST_P (GWDSettingsTestStorageUpdates, TestSetDraggableBorderWidth)
1239 {
1240 GWDSettingsStorage *storage = GetParam ()->GetStorage ();
1241 GetParam ()->SetDraggableBorderWidth (testing_values::DRAGGABLE_BORDER_WIDTH_VALUE);
1242
1243 EXPECT_CALL (*mSettingsMock, draggableBorderWidthChanged (testing_values::DRAGGABLE_BORDER_WIDTH_VALUE));
1244
1245 gwd_settings_storage_update_draggable_border_width (storage);
1246 }
1247
1248 TEST_P (GWDSettingsTestStorageUpdates, TestSetAttachModalDialogs)
1249 {
1250 GWDSettingsStorage *storage = GetParam ()->GetStorage ();
1251 GetParam ()->SetAttachModalDialogs (testing_values::ATTACH_MODAL_DIALOGS_VALUE);
1252
1253 EXPECT_CALL (*mSettingsMock, attachModalDialogsChanged (testing_values::ATTACH_MODAL_DIALOGS_VALUE));
1254
1255 gwd_settings_storage_update_attach_modal_dialogs (storage);
1256 }
1257
1258 TEST_P (GWDSettingsTestStorageUpdates, TestSetBlur)
1259 {
1260 GWDSettingsStorage *storage = GetParam ()->GetStorage ();
1261 GetParam ()->SetBlur (testing_values::BLUR_TYPE_ALL_VALUE);
1262
1263 EXPECT_CALL (*mSettingsMock, blurChanged (Eq (testing_values::BLUR_TYPE_ALL_VALUE)));
1264
1265 gwd_settings_storage_update_blur (storage);
1266 }
1267
1268 TEST_P (GWDSettingsTestStorageUpdates, TestSetButtonLayout)
1269 {
1270 GWDSettingsStorage *storage = GetParam ()->GetStorage ();
1271 GetParam ()->SetButtonLayout (testing_values::BUTTON_LAYOUT_VALUE);
1272
1273 EXPECT_CALL (*mSettingsMock, buttonLayoutChanged (Eq (testing_values::BUTTON_LAYOUT_VALUE)));
1274
1275 gwd_settings_storage_update_button_layout (storage);
1276 }
1277
1278 TEST_P (GWDSettingsTestStorageUpdates, TestSetOpacity)
1279 {
1280 GWDSettingsStorage *storage = GetParam ()->GetStorage ();
1281 GetParam ()->SetOpacity (testing_values::ACTIVE_OPACITY_VALUE,
1282 testing_values::INACTIVE_OPACITY_VALUE,
1283 testing_values::ACTIVE_SHADE_OPACITY_VALUE,
1284 testing_values::INACTIVE_SHADE_OPACITY_VALUE);
1285
1286 EXPECT_CALL (*mSettingsMock, opacityChanged (testing_values::ACTIVE_OPACITY_VALUE,
1287 testing_values::INACTIVE_OPACITY_VALUE,
1288 testing_values::ACTIVE_SHADE_OPACITY_VALUE,
1289 testing_values::INACTIVE_SHADE_OPACITY_VALUE));
1290
1291 gwd_settings_storage_update_opacity (storage);
1292 }
1293
1294 TEST_P (GWDSettingsTestStorageUpdates, TestSetMetacityTheme)
1295 {
1296 GWDSettingsStorage *storage = GetParam ()->GetStorage ();
1297 GetParam ()->SetMetacityTheme (testing_values::USE_METACITY_THEME_VALUE,
1298 testing_values::METACITY_THEME_VALUE);
1299
1300 EXPECT_CALL (*mSettingsMock, metacityThemeChanged (testing_values::USE_METACITY_THEME_VALUE,
1301 Eq (testing_values::METACITY_THEME_VALUE)));
1302
1303 gwd_settings_storage_update_metacity_theme (storage);
1304 }
1305
1306 TEST_P (GWDSettingsTestStorageUpdates, TestSetFont)
1307 {
1308 GWDSettingsStorage *storage = GetParam ()->GetStorage ();
1309 GetParam ()->SetFont (testing_values::USE_SYSTEM_FONT_VALUE,
1310 testing_values::TITLEBAR_FONT_VALUE);
1311
1312 EXPECT_CALL (*mSettingsMock, fontChanged (testing_values::USE_SYSTEM_FONT_VALUE,
1313 Eq (testing_values::TITLEBAR_FONT_VALUE)));
1314
1315 gwd_settings_storage_update_font (storage);
1316 }
1317
1318 TEST_P (GWDSettingsTestStorageUpdates, TestSetTitlebarActions)
1319 {
1320 GWDSettingsStorage *storage = GetParam ()->GetStorage ();
1321 GetParam ()->SetTitlebarActions (testing_values::TITLEBAR_ACTION_LOWER,
1322 testing_values::TITLEBAR_ACTION_MAX,
1323 testing_values::TITLEBAR_ACTION_MENU,
1324 testing_values::TITLEBAR_ACTION_SHADE);
1325
1326 EXPECT_CALL (*mSettingsMock, titlebarActionsChanged (Eq (testing_values::TITLEBAR_ACTION_LOWER),
1327 Eq (testing_values::TITLEBAR_ACTION_MAX),
1328 Eq (testing_values::TITLEBAR_ACTION_MENU),
1329 Eq (testing_values::TITLEBAR_ACTION_SHADE)));
1330
1331 gwd_settings_storage_update_titlebar_actions (storage);
1332 }
1333
1334 class GWDMockSettingsStorageFactoryWrapper :
1335 public GWDSettingsStorageFactoryWrapperInterface
1336 {
1337 public:
1338
1339 virtual void SetUp (GWDSettingsWritable *writable)
1340 {
1341 mWritable = writable;
1342 mStorageMock.reset (new GWDMockSettingsStorageGMock ());
1343 mStorage.reset (gwd_mock_settings_storage_new (mStorageMock.get ()),
1344 boost::bind (gwd_settings_storage_unref, _1));
1345 }
1346
1347 virtual GWDSettingsStorage * GetStorage ()
1348 {
1349 return mStorage.get ();
1350 }
1351
1352 virtual void SetUseTooltips (gboolean useTooltips)
1353 {
1354 EXPECT_CALL (*mStorageMock, updateUseTooltips ())
1355 .WillOnce (
1356 InvokeFunctor (
1357 boost::bind (
1358 gwd_settings_writable_use_tooltips_changed, mWritable, useTooltips)));
1359 }
1360
1361 virtual void SetDraggableBorderWidth (gint draggableBorderWidth)
1362 {
1363 EXPECT_CALL (*mStorageMock, updateDraggableBorderWidth ())
1364 .WillOnce (
1365 InvokeFunctor (
1366 boost::bind (
1367 gwd_settings_writable_draggable_border_width_changed, mWritable, draggableBorderWidth)));
1368 }
1369
1370 virtual void SetAttachModalDialogs (gboolean attachModalDialogs)
1371 {
1372 EXPECT_CALL (*mStorageMock, updateAttachModalDialogs ())
1373 .WillOnce (
1374 InvokeFunctor (
1375 boost::bind (
1376 gwd_settings_writable_attach_modal_dialogs_changed, mWritable, attachModalDialogs)));
1377 }
1378
1379 virtual void SetBlur (const std::string &blurType)
1380 {
1381 EXPECT_CALL (*mStorageMock, updateBlur ())
1382 .WillOnce (
1383 InvokeFunctor (
1384 boost::bind (
1385 gwd_settings_writable_blur_changed, mWritable, blurType.c_str ())));
1386 }
1387
1388 virtual void SetOpacity (gdouble activeOpacity,
1389 gdouble inactiveOpacity,
1390 gboolean activeShadeOpacity,
1391 gboolean inactiveShadeOpacity)
1392 {
1393 EXPECT_CALL (*mStorageMock, updateOpacity ())
1394 .WillOnce (
1395 InvokeFunctor (
1396 boost::bind (
1397 gwd_settings_writable_opacity_changed,
1398 mWritable,
1399 activeOpacity,
1400 inactiveOpacity,
1401 activeShadeOpacity,
1402 inactiveShadeOpacity)));
1403 }
1404
1405 virtual void SetMetacityTheme (gboolean useMetacityTheme,
1406 const std::string &metacityTheme)
1407 {
1408 EXPECT_CALL (*mStorageMock, updateMetacityTheme ())
1409 .WillOnce (
1410 InvokeFunctor (
1411 boost::bind (
1412 gwd_settings_writable_metacity_theme_changed,
1413 mWritable,
1414 useMetacityTheme,
1415 metacityTheme.c_str ())));
1416 }
1417
1418 virtual void SetButtonLayout (const std::string &buttonLayout)
1419 {
1420 EXPECT_CALL (*mStorageMock, updateButtonLayout ())
1421 .WillOnce (
1422 InvokeFunctor (
1423 boost::bind (
1424 gwd_settings_writable_button_layout_changed, mWritable, buttonLayout.c_str ())));
1425 }
1426
1427 virtual void SetFont (gboolean useSystemFont, const std::string &titlebarFont)
1428 {
1429 EXPECT_CALL (*mStorageMock, updateFont ())
1430 .WillOnce (
1431 InvokeFunctor (
1432 boost::bind (
1433 gwd_settings_writable_font_changed,
1434 mWritable,
1435 useSystemFont,
1436 titlebarFont.c_str ())));
1437 }
1438
1439 virtual void SetTitlebarActions (const std::string &doubleClickAction,
1440 const std::string &middleClickAction,
1441 const std::string &rightClickAction,
1442 const std::string &mouseWheelAction)
1443 {
1444 EXPECT_CALL (*mStorageMock, updateTitlebarActions ())
1445 .WillOnce (
1446 InvokeFunctor (
1447 boost::bind (
1448 gwd_settings_writable_titlebar_actions_changed,
1449 mWritable,
1450 doubleClickAction.c_str (),
1451 middleClickAction.c_str (),
1452 rightClickAction.c_str (),
1453 mouseWheelAction.c_str ())));
1454 }
1455
1456 virtual void TearDown ()
1457 {
1458 if (mStorage)
1459 {
1460 EXPECT_CALL (*mStorageMock, dispose ());
1461 EXPECT_CALL (*mStorageMock, finalize ());
1462 }
1463
1464 mStorage.reset ();
1465 mStorageMock.reset ();
1466 }
1467
1468 private:
1469
CID 12558 - UNINIT_CTOR
The compiler-generated constructor for this class does not initialize "mWritable".
1470 GWDSettingsWritable *mWritable;
1471 boost::shared_ptr <GWDMockSettingsStorageGMock> mStorageMock;
1472 boost::shared_ptr <GWDSettingsStorage> mStorage;
1473 };
1474
1475 INSTANTIATE_TEST_CASE_P (MockStorageUpdates, GWDSettingsTestStorageUpdates,
1476 ::testing::Values (boost::shared_static_cast <GWDSettingsStorageFactoryWrapperInterface> (boost::make_shared <GWDMockSettingsStorageFactoryWrapper> ())));
1477
1478 #ifdef USE_GSETTINGS
1479 class GWDSettingsStorageGSettingsTest :
1480 public GWDSettingsTestCommon
1481 {
1482 };
1483
1484 TEST_F (GWDSettingsStorageGSettingsTest, TestNoDeathOnConnectingSignalToNULLObject)
1485 {
1486 boost::shared_ptr <GWDMockSettingsStorageGMock> mStorageMock (new GWDMockSettingsStorageGMock ());
1487 boost::shared_ptr <GWDSettingsStorage> mStorage (gwd_mock_settings_storage_new (mStorageMock.get ()),
1488 boost::bind (gwd_settings_storage_unref, _1));
1489
1490 gwd_connect_org_compiz_gwd_settings (NULL, mStorage.get ());
1491 gwd_connect_org_gnome_mutter_settings (NULL, mStorage.get ());
1492 gwd_connect_org_gnome_desktop_wm_preferences_settings (NULL, mStorage.get ());
1493
1494 EXPECT_CALL (*mStorageMock, dispose ());
1495 EXPECT_CALL (*mStorageMock, finalize ());
1496 }
1497
1498 class GWDSettingsStorageGSettingsFactoryWrapper :
1499 public GWDSettingsStorageFactoryWrapperInterface
1500 {
1501 public:
1502
1503 virtual void SetUp (GWDSettingsWritable *writable)
1504 {
1505 gsliceEnv.SetUpEnv ();
1506 gsettingsEnv.SetUpEnv (MOCK_PATH);
1507
1508 /* We do not need to keep a reference to these */
1509 mGWDSettings = gwd_get_org_compiz_gwd_settings ();
1510 mMutterSettings = gwd_get_org_gnome_mutter_settings ();
1511 mDesktopSettings = gwd_get_org_gnome_desktop_wm_preferences_settings ();
1512
1513 mStorage.reset (gwd_settings_storage_gsettings_new (mDesktopSettings,
1514 mMutterSettings,
1515 mGWDSettings,
1516 writable),
1517 boost::bind (gwd_settings_storage_unref, _1));
1518 }
1519
1520 virtual GWDSettingsStorage * GetStorage ()
1521 {
1522 return mStorage.get ();
1523 }
1524
1525 virtual void SetUseTooltips (gboolean useTooltips)
1526 {
1527 g_settings_set_boolean (mGWDSettings, ORG_COMPIZ_GWD_KEY_USE_TOOLTIPS, useTooltips);
1528 }
1529
1530 virtual void SetDraggableBorderWidth (gint draggableBorderWidth)
1531 {
1532 g_settings_set_int (mMutterSettings, ORG_GNOME_MUTTER_DRAGGABLE_BORDER_WIDTH, draggableBorderWidth);
1533 }
1534
1535 virtual void SetAttachModalDialogs (gboolean attachModalDialogs)
1536 {
1537 g_settings_set_boolean (mMutterSettings, ORG_GNOME_MUTTER_ATTACH_MODAL_DIALOGS, attachModalDialogs);
1538 }
1539
1540 virtual void SetBlur (const std::string &blurType)
1541 {
1542 g_settings_set_string (mGWDSettings, ORG_COMPIZ_GWD_KEY_BLUR_TYPE, blurType.c_str ());
1543 }
1544
1545 virtual void SetOpacity (gdouble activeOpacity,
1546 gdouble inactiveOpacity,
1547 gboolean activeShadeOpacity,
1548 gboolean inactiveShadeOpacity)
1549 {
1550 g_settings_set_double (mGWDSettings, ORG_COMPIZ_GWD_KEY_METACITY_THEME_ACTIVE_OPACITY, activeOpacity);
1551 g_settings_set_double (mGWDSettings, ORG_COMPIZ_GWD_KEY_METACITY_THEME_INACTIVE_OPACITY, inactiveOpacity);
1552 g_settings_set_boolean (mGWDSettings, ORG_COMPIZ_GWD_KEY_METACITY_THEME_ACTIVE_SHADE_OPACITY, activeShadeOpacity);
1553 g_settings_set_boolean (mGWDSettings, ORG_COMPIZ_GWD_KEY_METACITY_THEME_INACTIVE_SHADE_OPACITY, inactiveShadeOpacity);
1554 }
1555
1556 virtual void SetMetacityTheme (gboolean useMetacityTheme,
1557 const std::string &metacityTheme)
1558 {
1559 g_settings_set_boolean (mGWDSettings, ORG_COMPIZ_GWD_KEY_USE_METACITY_THEME, useMetacityTheme);
1560 g_settings_set_string (mDesktopSettings, ORG_GNOME_DESKTOP_WM_PREFERENCES_THEME, metacityTheme.c_str ());
1561 }
1562
1563 virtual void SetButtonLayout (const std::string &buttonLayout)
1564 {
1565 g_settings_set_string (mDesktopSettings,
1566 ORG_GNOME_DESKTOP_WM_PREFERENCES_BUTTON_LAYOUT,
1567 buttonLayout.c_str ());
1568 }
1569
1570 virtual void SetFont (gboolean useSystemFont, const std::string &titlebarFont)
1571 {
1572 g_settings_set_boolean (mDesktopSettings,
1573 ORG_GNOME_DESKTOP_WM_PREFERENCES_TITLEBAR_USES_SYSTEM_FONT,
1574 useSystemFont);
1575 g_settings_set_string (mDesktopSettings,
1576 ORG_GNOME_DESKTOP_WM_PREFERENCES_TITLEBAR_FONT,
1577 titlebarFont.c_str ());
1578 }
1579
1580 virtual void SetTitlebarActions (const std::string &doubleClickAction,
1581 const std::string &middleClickAction,
1582 const std::string &rightClickAction,
1583 const std::string &mouseWheelAction)
1584 {
1585 std::string translatedDC (doubleClickAction);
1586 std::string translatedMC (middleClickAction);
1587 std::string translatedRC (rightClickAction);
1588
1589 boost::replace_all (translatedDC, "_", "-");
1590 boost::replace_all (translatedMC, "_", "-");
1591 boost::replace_all (translatedRC, "_", "-");
1592
1593 g_settings_set_string (mDesktopSettings,
1594 ORG_GNOME_DESKTOP_WM_PREFERENCES_ACTION_DOUBLE_CLICK_TITLEBAR,
1595 translatedDC.c_str ());
1596 g_settings_set_string (mDesktopSettings,
1597 ORG_GNOME_DESKTOP_WM_PREFERENCES_ACTION_MIDDLE_CLICK_TITLEBAR,
1598 translatedMC.c_str ());
1599 g_settings_set_string (mDesktopSettings,
1600 ORG_GNOME_DESKTOP_WM_PREFERENCES_ACTION_RIGHT_CLICK_TITLEBAR,
1601 translatedRC.c_str ());
1602 g_settings_set_string (mGWDSettings,
1603 ORG_COMPIZ_GWD_KEY_MOUSE_WHEEL_ACTION,
1604 mouseWheelAction.c_str ());
1605 }
1606
1607 virtual void TearDown ()
1608 {
1609 mStorage.reset ();
1610 mGWDSettings = NULL;
1611 mMutterSettings = NULL;
1612 mDesktopSettings = NULL;
1613 gsettingsEnv.TearDownEnv ();
1614 gsliceEnv.TearDownEnv ();
1615 }
1616
1617 private:
1618
1619 GSettings *mGWDSettings;
1620 GSettings *mMutterSettings;
1621 GSettings *mDesktopSettings;
1622 boost::shared_ptr <GWDSettingsStorage> mStorage;
1623 CompizGLibGSliceOffEnv gsliceEnv;
1624 CompizGLibGSettingsMemoryBackendTestingEnv gsettingsEnv;
1625 };
1626
1627 INSTANTIATE_TEST_CASE_P (GSettingsStorageUpdates, GWDSettingsTestStorageUpdates,
1628 ::testing::Values (boost::shared_static_cast <GWDSettingsStorageFactoryWrapperInterface> (boost::make_shared <GWDSettingsStorageGSettingsFactoryWrapper> ())));
1629
1630 #endif