← Back to branch summary

~elementary-os/elementaryos/os-patch-indicator-session-trusty

« back to all changes in this revision

Viewing changes to tests/backend-dbus/mock-login1-manager.cc

  • Committer: Cody Garver
  • Date: 2014-04-03 17:08:08 UTC
  • Revision ID: cody@elementaryos.org-20140403170808-z56s93rorb1dzvmk
Initial import, version 12.10.5+14.04.20140324-0ubuntu1

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/backend-dbus/mock-login1-manager.cc
 
1
/*
 
2
 * Copyright 2013 Canonical Ltd.
 
3
 *
 
4
 * Authors:
 
5
 *   Charles Kerr <charles.kerr@canonical.com>
 
6
 *
 
7
 * This program is free software: you can redistribute it and/or modify it
 
8
 * under the terms of the GNU General Public License version 3, as published
 
9
 * by the Free Software Foundation.
 
10
 *
 
11
 * This program is distributed in the hope that it will be useful, but
 
12
 * WITHOUT ANY WARRANTY; without even the implied warranties of
 
13
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
 
14
 * PURPOSE.  See the GNU General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU General Public License along
 
17
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 
18
 */
 
19
 
 
20
#include "mock-login1-manager.h"
 
21
#include "mock-login1-seat.h"
 
22
#include "mock-user.h"
 
23
 
 
24
namespace
 
25
{
 
26
  const char * const BUS_NAME = "org.freedesktop.login1";
 
27
  
 
28
  const char * const BUS_PATH = "/org/freedesktop/login1";
 
29
}
 
30
 
 
31
/***
 
32
****
 
33
***/
 
34
 
 
35
void
 
36
MockLogin1Manager :: emit_session_new (MockLogin1Seat * seat, int tag) const
 
37
{
 
38
  std::string id;
 
39
  std::string path;
 
40
  seat->get_session_id_and_path_for_tag (tag, id, path);
 
41
 
 
42
  login1_manager_emit_session_new (my_skeleton, id.c_str(), path.c_str());
 
43
}
 
44
 
 
45
int
 
46
MockLogin1Manager :: add_session (MockLogin1Seat * seat, MockUser * user)
 
47
{
 
48
  g_assert (my_seats.count(seat) == 1);
 
49
 
 
50
  const int session_tag = seat->add_session (user);
 
51
  emit_session_new (seat, session_tag);
 
52
  return session_tag;
 
53
}
 
54
 
 
55
void
 
56
MockLogin1Manager :: emit_session_removed (MockLogin1Seat * seat, int tag) const
 
57
{
 
58
  std::string id;
 
59
  std::string path;
 
60
  seat->get_session_id_and_path_for_tag (tag, id, path);
 
61
 
 
62
  login1_manager_emit_session_removed (my_skeleton, id.c_str(), path.c_str());
 
63
}
 
64
 
 
65
void
 
66
MockLogin1Manager :: remove_session (MockLogin1Seat * seat, int session_tag)
 
67
{
 
68
  seat->remove_session (session_tag);
 
69
  emit_session_removed (seat, session_tag);
 
70
}
 
71
 
 
72
void
 
73
MockLogin1Manager :: add_seat (MockLogin1Seat * seat)
 
74
{
 
75
  g_assert (my_seats.count(seat) == 0);
 
76
 
 
77
  my_seats.insert (seat);
 
78
  std::set<int> sessions = seat->sessions ();
 
79
  for (auto tag : sessions)
 
80
    emit_session_new (seat, tag);
 
81
}
 
82
 
 
83
/***
 
84
****
 
85
***/
 
86
         
 
87
GVariant *
 
88
MockLogin1Manager :: list_sessions () const
 
89
{
 
90
  GVariantBuilder b;
 
91
 
 
92
  g_variant_builder_init (&b, G_VARIANT_TYPE("a(susso)"));
 
93
 
 
94
  for (auto seat : my_seats)
 
95
    {
 
96
      GVariant * seat_sessions = seat->list_sessions ();
 
97
 
 
98
      GVariantIter iter;
 
99
      g_variant_iter_init (&iter, seat_sessions);
 
100
      GVariant * child;
 
101
      while ((child = g_variant_iter_next_value (&iter)))
 
102
        {
 
103
          g_variant_builder_add_value (&b, child);
 
104
          g_variant_unref (child);
 
105
        }
 
106
    }
 
107
 
 
108
  return g_variant_builder_end (&b);
 
109
}
 
110
 
 
111
/***
 
112
****  Skeleton Handlers
 
113
***/
 
114
 
 
115
gboolean
 
116
MockLogin1Manager :: handle_list_sessions (Login1Manager       * m,
 
117
                                         GDBusMethodInvocation * inv,
 
118
                                         gpointer                gself)
 
119
{
 
120
  GVariant * sessions = static_cast<MockLogin1Manager*>(gself)->list_sessions();
 
121
  login1_manager_complete_list_sessions (m, inv, sessions);
 
122
  return true;
 
123
}
 
124
 
 
125
gboolean
 
126
MockLogin1Manager :: handle_can_suspend (Login1Manager         * m,
 
127
                                         GDBusMethodInvocation * inv,
 
128
                                         gpointer                gself)
 
129
{
 
130
  const std::string& s = static_cast<MockLogin1Manager*>(gself)->can_suspend();
 
131
  login1_manager_complete_can_suspend (m, inv, s.c_str());
 
132
  return true;
 
133
}
 
134
 
 
135
gboolean
 
136
MockLogin1Manager :: handle_can_hibernate (Login1Manager         * m,
 
137
                                           GDBusMethodInvocation * inv,
 
138
                                           gpointer                gself)
 
139
{
 
140
  const std::string& s = static_cast<MockLogin1Manager*>(gself)->can_hibernate();
 
141
  login1_manager_complete_can_hibernate (m, inv, s.c_str());
 
142
  return true;
 
143
}
 
144
 
 
145
gboolean
 
146
MockLogin1Manager :: handle_reboot (Login1Manager         * m,
 
147
                                    GDBusMethodInvocation * inv,
 
148
                                    gboolean                interactive G_GNUC_UNUSED,
 
149
                                    gpointer                gself)
 
150
{
 
151
  static_cast<MockLogin1Manager*>(gself)->my_last_action = "reboot";
 
152
  login1_manager_complete_reboot (m, inv);
 
153
  return true;
 
154
}
 
155
 
 
156
gboolean
 
157
MockLogin1Manager :: handle_power_off (Login1Manager         * m,
 
158
                                       GDBusMethodInvocation * inv,
 
159
                                       gboolean                interactive G_GNUC_UNUSED,
 
160
                                       gpointer                gself)
 
161
{
 
162
  static_cast<MockLogin1Manager*>(gself)->my_last_action = "power-off";
 
163
  login1_manager_complete_power_off (m, inv);
 
164
  return true;
 
165
}
 
166
 
 
167
gboolean
 
168
MockLogin1Manager :: handle_suspend (Login1Manager         * m,
 
169
                                     GDBusMethodInvocation * inv,
 
170
                                     gboolean                interactive G_GNUC_UNUSED,
 
171
                                     gpointer                gself)
 
172
{
 
173
  static_cast<MockLogin1Manager*>(gself)->my_last_action = "suspend";
 
174
  login1_manager_complete_suspend (m, inv);
 
175
  return true;
 
176
}
 
177
 
 
178
gboolean
 
179
MockLogin1Manager :: handle_hibernate (Login1Manager         * m,
 
180
                                       GDBusMethodInvocation * inv,
 
181
                                       gboolean                interactive G_GNUC_UNUSED,
 
182
                                       gpointer                gself)
 
183
{
 
184
  static_cast<MockLogin1Manager*>(gself)->my_last_action = "hibernate";
 
185
  login1_manager_complete_hibernate (m, inv);
 
186
  return true;
 
187
}
 
188
 
 
189
/***
 
190
****
 
191
***/
 
192
 
 
193
const std::string&
 
194
MockLogin1Manager :: can_suspend () const
 
195
{
 
196
  return my_can_suspend;
 
197
}
 
198
 
 
199
const std::string&
 
200
MockLogin1Manager :: can_hibernate () const
 
201
{
 
202
  return my_can_hibernate;
 
203
}
 
204
 
 
205
/***
 
206
****
 
207
***/
 
208
 
 
209
MockLogin1Manager :: MockLogin1Manager (GMainLoop       * loop,
 
210
                                        GDBusConnection * conn):
 
211
  MockObject (loop, conn, BUS_NAME, BUS_PATH),
 
212
  my_skeleton (login1_manager_skeleton_new ()),
 
213
  my_can_suspend ("yes"),
 
214
  my_can_hibernate ("yes")
 
215
{
 
216
  g_signal_connect (my_skeleton, "handle-can-suspend",
 
217
                    G_CALLBACK(handle_can_suspend), this);
 
218
  g_signal_connect (my_skeleton, "handle-can-hibernate",
 
219
                    G_CALLBACK(handle_can_hibernate), this);
 
220
  g_signal_connect (my_skeleton, "handle_reboot",
 
221
                    G_CALLBACK(handle_reboot), this);
 
222
  g_signal_connect (my_skeleton, "handle-power-off",
 
223
                    G_CALLBACK(handle_power_off), this);
 
224
  g_signal_connect (my_skeleton, "handle-suspend",
 
225
                    G_CALLBACK(handle_suspend), this);
 
226
  g_signal_connect (my_skeleton, "handle-hibernate",
 
227
                    G_CALLBACK(handle_hibernate), this);
 
228
  g_signal_connect (my_skeleton, "handle-list-sessions",
 
229
                    G_CALLBACK(handle_list_sessions), this);
 
230
 
 
231
  set_skeleton (G_DBUS_INTERFACE_SKELETON(my_skeleton));
 
232
}
 
233
 
 
234
MockLogin1Manager :: ~MockLogin1Manager ()
 
235
{
 
236
  for (auto seat : my_seats)
 
237
    delete seat;
 
238
 
 
239
  g_signal_handlers_disconnect_by_data (my_skeleton, this);
 
240
  g_clear_object (&my_skeleton);
 
241
}