← Back to branch summary

~3v1n0/unity/light-shortcuts

« back to all changes in this revision

Viewing changes to tests/test_previews.cpp

  • Committer: Marco Trevisan (Treviño)
  • Date: 2013-04-26 12:41:09 UTC
  • Revision ID: mail@3v1n0.net-20130426124109-t3b2shjah2omiqa2
Unity: Remove all the views, but the Shortcuts

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_previews.cpp
1
 
// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
2
 
/*
3
 
 * Copyright (C) 2011 Canonical Ltd
4
 
 *
5
 
 * This program is free software: you can redistribute it and/or modify
6
 
 * it under the terms of the GNU General Public License version 3 as
7
 
 * published by the Free Software Foundation.
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, see <http://www.gnu.org/licenses/>.
16
 
 *
17
 
 * Authored by: Marco Trevisan (Treviño) <3v1n0@ubuntu.com>
18
 
 */
19
 
 
20
 
#include <list>
21
 
#include <algorithm>
22
 
#include <gmock/gmock.h>
23
 
#include <gio/gio.h>
24
 
#include <UnityCore/Variant.h>
25
 
#include <UnityCore/Preview.h>
26
 
#include <UnityCore/ApplicationPreview.h>
27
 
#include <UnityCore/MoviePreview.h>
28
 
#include <UnityCore/MusicPreview.h>
29
 
#include <UnityCore/SeriesPreview.h>
30
 
#include <unity-protocol.h>
31
 
 
32
 
using namespace std;
33
 
using namespace testing;
34
 
using namespace unity;
35
 
using namespace unity::glib;
36
 
using namespace unity::dash;
37
 
 
38
 
namespace
39
 
{
40
 
 
41
 
bool IsVariant(Variant const& variant)
42
 
{
43
 
  return g_variant_get_type_string(variant) != NULL;
44
 
}
45
 
 
46
 
TEST(TestPreviews, DeserializeGeneric)
47
 
{
48
 
  Object<GIcon> icon(g_icon_new_for_string("accessories", NULL));
49
 
  Object<UnityProtocolPreview> proto_obj(UNITY_PROTOCOL_PREVIEW(unity_protocol_generic_preview_new()));
50
 
  unity_protocol_preview_set_title(proto_obj, "Title");
51
 
  unity_protocol_preview_set_subtitle(proto_obj, "Subtitle");
52
 
  unity_protocol_preview_set_description(proto_obj, "Description");
53
 
  unity_protocol_preview_set_image(proto_obj, icon);
54
 
  unity_protocol_preview_set_image_source_uri(proto_obj, "Source");
55
 
 
56
 
  Variant v(dee_serializable_serialize(DEE_SERIALIZABLE(proto_obj.RawPtr())),
57
 
            glib::StealRef());
58
 
  EXPECT_TRUE(IsVariant(v));
59
 
 
60
 
  Preview::Ptr preview = Preview::PreviewForVariant(v);
61
 
  EXPECT_TRUE(preview != nullptr);
62
 
 
63
 
  EXPECT_EQ(preview->renderer_name, "preview-generic");
64
 
  EXPECT_EQ(preview->title, "Title");
65
 
  EXPECT_EQ(preview->subtitle, "Subtitle");
66
 
  EXPECT_EQ(preview->description, "Description");
67
 
  EXPECT_EQ(preview->image_source_uri, "Source");
68
 
  EXPECT_TRUE(g_icon_equal(preview->image(), icon) != FALSE);
69
 
}
70
 
 
71
 
TEST(TestPreviews, DeserializeGenericWithMeta)
72
 
{
73
 
  Object<GIcon> icon(g_icon_new_for_string("accessories", NULL));
74
 
  Object<UnityProtocolPreview> proto_obj(UNITY_PROTOCOL_PREVIEW(unity_protocol_generic_preview_new()));
75
 
  unity_protocol_preview_set_title(proto_obj, "Title");
76
 
  unity_protocol_preview_set_subtitle(proto_obj, "Subtitle");
77
 
  unity_protocol_preview_set_description(proto_obj, "Description");
78
 
  unity_protocol_preview_set_image(proto_obj, icon);
79
 
  unity_protocol_preview_set_image_source_uri(proto_obj, "Source");
80
 
 
81
 
  GHashTable* hints = g_hash_table_new(g_str_hash, g_str_equal);
82
 
  g_hash_table_insert(hints, g_strdup("extra-text"), g_variant_new_string("Foo"));
83
 
  unity_protocol_preview_add_action(proto_obj, "action1", "Action #1", NULL, 0);
84
 
  unity_protocol_preview_add_action_with_hints(proto_obj, "action2", "Action #2", NULL, 0, hints);
85
 
  unity_protocol_preview_add_info_hint(proto_obj, "hint1", "Hint 1", NULL, g_variant_new("i", 34));
86
 
  unity_protocol_preview_add_info_hint(proto_obj, "hint2", "Hint 2", NULL, g_variant_new("s", "string hint"));
87
 
 
88
 
  Variant v(dee_serializable_serialize(DEE_SERIALIZABLE(proto_obj.RawPtr())),
89
 
            glib::StealRef());
90
 
  EXPECT_TRUE(IsVariant(v));
91
 
 
92
 
  Preview::Ptr preview = Preview::PreviewForVariant(v);
93
 
  EXPECT_TRUE(preview != nullptr);
94
 
 
95
 
  EXPECT_EQ(preview->renderer_name, "preview-generic");
96
 
  EXPECT_EQ(preview->title, "Title");
97
 
  EXPECT_EQ(preview->subtitle, "Subtitle");
98
 
  EXPECT_EQ(preview->description, "Description");
99
 
  EXPECT_TRUE(g_icon_equal(preview->image(), icon) != FALSE);
100
 
  EXPECT_EQ(preview->image_source_uri, "Source");
101
 
 
102
 
  auto actions = preview->GetActions();
103
 
  auto info_hints = preview->GetInfoHints();
104
 
 
105
 
  EXPECT_EQ(actions.size(), 2);
106
 
 
107
 
  auto action1 = actions[0];
108
 
  EXPECT_EQ(action1->id, "action1");
109
 
  EXPECT_EQ(action1->display_name, "Action #1");
110
 
  EXPECT_EQ(action1->icon_hint, "");
111
 
  EXPECT_EQ(action1->layout_hint, 0);
112
 
  EXPECT_EQ(action1->extra_text, "");
113
 
 
114
 
  auto action2 = actions[1];
115
 
  EXPECT_EQ(action2->id, "action2");
116
 
  EXPECT_EQ(action2->display_name, "Action #2");
117
 
  EXPECT_EQ(action2->icon_hint, "");
118
 
  EXPECT_EQ(action2->extra_text, "Foo");
119
 
 
120
 
  EXPECT_EQ(info_hints.size(), 2);
121
 
  auto hint1 = info_hints[0];
122
 
  EXPECT_EQ(hint1->id, "hint1");
123
 
  EXPECT_EQ(hint1->display_name, "Hint 1");
124
 
  EXPECT_EQ(hint1->icon_hint, "");
125
 
  EXPECT_EQ(hint1->value.GetInt(), 34);
126
 
  auto hint2 = info_hints[1];
127
 
  EXPECT_EQ(hint2->id, "hint2");
128
 
  EXPECT_EQ(hint2->display_name, "Hint 2");
129
 
  EXPECT_EQ(hint2->icon_hint, "");
130
 
  EXPECT_EQ(hint2->value.GetString(), "string hint");
131
 
}
132
 
 
133
 
TEST(TestPreviews, DeserializeApplication)
134
 
{
135
 
  Object<GIcon> icon(g_icon_new_for_string("application", NULL));
136
 
  Object<UnityProtocolPreview> proto_obj(UNITY_PROTOCOL_PREVIEW(unity_protocol_application_preview_new()));
137
 
  unity_protocol_preview_set_title(proto_obj, "Title");
138
 
  unity_protocol_preview_set_subtitle(proto_obj, "Subtitle");
139
 
  unity_protocol_preview_set_description(proto_obj, "Description");
140
 
  unity_protocol_preview_set_image(proto_obj, icon);
141
 
  auto app_proto_obj = glib::object_cast<UnityProtocolApplicationPreview>(proto_obj);
142
 
  unity_protocol_application_preview_set_last_update(app_proto_obj, "2012/06/13");
143
 
  unity_protocol_application_preview_set_copyright(app_proto_obj, "(c) Canonical");
144
 
  unity_protocol_application_preview_set_license(app_proto_obj, "GPLv3");
145
 
  unity_protocol_application_preview_set_app_icon(app_proto_obj, icon);
146
 
  unity_protocol_application_preview_set_rating(app_proto_obj, 4.0);
147
 
  unity_protocol_application_preview_set_num_ratings(app_proto_obj, 12);
148
 
 
149
 
  Variant v(dee_serializable_serialize(DEE_SERIALIZABLE(proto_obj.RawPtr())),
150
 
            glib::StealRef());
151
 
  EXPECT_TRUE(IsVariant(v));
152
 
 
153
 
  Preview::Ptr base_preview = Preview::PreviewForVariant(v);
154
 
  ApplicationPreview::Ptr preview = std::dynamic_pointer_cast<ApplicationPreview>(base_preview);
155
 
  EXPECT_TRUE(preview != nullptr);
156
 
 
157
 
  EXPECT_EQ(preview->renderer_name, "preview-application");
158
 
  EXPECT_EQ(preview->title, "Title");
159
 
  EXPECT_EQ(preview->subtitle, "Subtitle");
160
 
  EXPECT_EQ(preview->description, "Description");
161
 
  EXPECT_TRUE(g_icon_equal(preview->image(), icon) != FALSE);
162
 
  EXPECT_EQ(preview->last_update, "2012/06/13");
163
 
  EXPECT_EQ(preview->copyright, "(c) Canonical");
164
 
  EXPECT_EQ(preview->license, "GPLv3");
165
 
  EXPECT_TRUE(g_icon_equal(preview->app_icon(), icon) != FALSE);
166
 
  EXPECT_EQ(preview->rating, 4.0);
167
 
  EXPECT_EQ(preview->num_ratings, static_cast<unsigned>(12));
168
 
}
169
 
 
170
 
TEST(TestPreviews, DeserializeMovie)
171
 
{
172
 
  Object<GIcon> icon(g_icon_new_for_string("movie", NULL));
173
 
  Object<UnityProtocolPreview> proto_obj(UNITY_PROTOCOL_PREVIEW(unity_protocol_movie_preview_new()));
174
 
  unity_protocol_preview_set_title(proto_obj, "Title");
175
 
  unity_protocol_preview_set_subtitle(proto_obj, "Subtitle");
176
 
  unity_protocol_preview_set_description(proto_obj, "Description");
177
 
  unity_protocol_preview_set_image(proto_obj, icon);
178
 
  auto movie_proto_obj = glib::object_cast<UnityProtocolMoviePreview>(proto_obj);
179
 
  unity_protocol_movie_preview_set_year(movie_proto_obj, "2012");
180
 
  unity_protocol_movie_preview_set_rating(movie_proto_obj, 4.0);
181
 
  unity_protocol_movie_preview_set_num_ratings(movie_proto_obj, 12);
182
 
 
183
 
  Variant v(dee_serializable_serialize(DEE_SERIALIZABLE(proto_obj.RawPtr())),
184
 
            glib::StealRef());
185
 
  EXPECT_TRUE(IsVariant(v));
186
 
 
187
 
  Preview::Ptr base_preview = Preview::PreviewForVariant(v);
188
 
  MoviePreview::Ptr preview = std::dynamic_pointer_cast<MoviePreview>(base_preview);
189
 
  EXPECT_TRUE(preview != nullptr);
190
 
 
191
 
  EXPECT_EQ(preview->renderer_name, "preview-movie");
192
 
  EXPECT_EQ(preview->title, "Title");
193
 
  EXPECT_EQ(preview->subtitle, "Subtitle");
194
 
  EXPECT_EQ(preview->description, "Description");
195
 
  EXPECT_TRUE(g_icon_equal(preview->image(), icon) != FALSE);
196
 
  EXPECT_EQ(preview->year, "2012");
197
 
  EXPECT_EQ(preview->rating, 4.0);
198
 
  EXPECT_EQ(preview->num_ratings, static_cast<unsigned int>(12));
199
 
}
200
 
 
201
 
TEST(TestPreviews, DeserializeMusic)
202
 
{
203
 
  Object<GIcon> icon(g_icon_new_for_string("music", NULL));
204
 
  Object<UnityProtocolPreview> proto_obj(UNITY_PROTOCOL_PREVIEW(unity_protocol_music_preview_new()));
205
 
  unity_protocol_preview_set_title(proto_obj, "Title");
206
 
  unity_protocol_preview_set_subtitle(proto_obj, "Subtitle");
207
 
  unity_protocol_preview_set_description(proto_obj, "Description");
208
 
  unity_protocol_preview_set_image(proto_obj, icon);
209
 
  auto music_proto_obj = glib::object_cast<UnityProtocolMusicPreview>(proto_obj);
210
 
 
211
 
  Variant v(dee_serializable_serialize(DEE_SERIALIZABLE(proto_obj.RawPtr())),
212
 
            glib::StealRef());
213
 
  EXPECT_TRUE(IsVariant(v));
214
 
 
215
 
  Preview::Ptr base_preview = Preview::PreviewForVariant(v);
216
 
  MusicPreview::Ptr preview = std::dynamic_pointer_cast<MusicPreview>(base_preview);
217
 
  EXPECT_TRUE(preview != nullptr);
218
 
 
219
 
  EXPECT_EQ(preview->renderer_name, "preview-music");
220
 
  EXPECT_EQ(preview->title, "Title");
221
 
  EXPECT_EQ(preview->subtitle, "Subtitle");
222
 
  EXPECT_EQ(preview->description, "Description");
223
 
  EXPECT_TRUE(g_icon_equal(preview->image(), icon) != FALSE);
224
 
}
225
 
 
226
 
TEST(TestPreviews, DeserializeSeries)
227
 
{
228
 
  Object<UnityProtocolPreview> proto_obj(UNITY_PROTOCOL_PREVIEW(unity_protocol_series_preview_new()));
229
 
  auto series_proto_obj = glib::object_cast<UnityProtocolSeriesPreview>(proto_obj);
230
 
  unity_protocol_series_preview_add_series_item(
231
 
      series_proto_obj, "#1", "scheme://path/0", NULL);
232
 
  unity_protocol_series_preview_add_series_item(
233
 
      series_proto_obj, "#2", "scheme://path/1", NULL);
234
 
  unity_protocol_series_preview_set_selected_item(series_proto_obj, 1);
235
 
 
236
 
  Object<GIcon> icon(g_icon_new_for_string("accessories", NULL));
237
 
  Object<UnityProtocolPreview> child_proto_obj(UNITY_PROTOCOL_PREVIEW(unity_protocol_generic_preview_new()));
238
 
  unity_protocol_preview_set_title(child_proto_obj, "Title");
239
 
  unity_protocol_preview_set_subtitle(child_proto_obj, "Subtitle");
240
 
  unity_protocol_preview_set_description(child_proto_obj, "Description");
241
 
  unity_protocol_preview_set_image(child_proto_obj, icon);
242
 
 
243
 
  unity_protocol_series_preview_set_child_preview(series_proto_obj,
244
 
      child_proto_obj);
245
 
 
246
 
  Variant v(dee_serializable_serialize(DEE_SERIALIZABLE(proto_obj.RawPtr())),
247
 
            glib::StealRef());
248
 
  EXPECT_TRUE(IsVariant(v));
249
 
 
250
 
  Preview::Ptr base_preview = Preview::PreviewForVariant(v);
251
 
  SeriesPreview::Ptr preview = std::dynamic_pointer_cast<SeriesPreview>(base_preview);
252
 
  EXPECT_TRUE(preview != nullptr);
253
 
 
254
 
  EXPECT_EQ(preview->renderer_name, "preview-series");
255
 
 
256
 
  auto items = preview->GetItems();
257
 
  EXPECT_EQ(items.size(), 2);
258
 
 
259
 
  auto item1 = preview->GetItems()[1];
260
 
  EXPECT_EQ(item1->uri, "scheme://path/1");
261
 
  EXPECT_EQ(item1->title, "#2");
262
 
 
263
 
  auto child_preview = preview->GetChildPreview();
264
 
  EXPECT_EQ(child_preview->renderer_name, "preview-generic");
265
 
  EXPECT_EQ(child_preview->title, "Title");
266
 
  EXPECT_EQ(child_preview->subtitle, "Subtitle");
267
 
  EXPECT_EQ(child_preview->description, "Description");
268
 
  EXPECT_TRUE(g_icon_equal(child_preview->image(), icon) != FALSE);
269
 
}
270
 
 
271
 
} // Namespace