← Back to branch summary

~unity8-desktop-session-team/indicator-session/indicator-session-using-upstart

« back to all changes in this revision

Viewing changes to tests/backend-mock-users.c

  • Committer: Charles Kerr
  • Date: 2013-06-25 16:16:34 UTC
  • mto: This revision was merged to the branch mainline in revision 399.
  • Revision ID: charles.kerr@canonical.com-20130625161634-ht9ef3n5s63rnmmr
in IndicatorSessionUsers, use the uid as the user's key. Users.ActivateUser is now green.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/backend-mock-users.c
58
58
}
59
59
 
60
60
static void
61
 
my_activate_user (IndicatorSessionUsers * users, const char * key)
 
61
my_activate_user (IndicatorSessionUsers * users, guint uid)
62
62
{
63
 
  g_message ("%s %s users %p key %s FIXME", G_STRLOC, G_STRFUNC, (void*)users, key);
 
63
  g_message ("%s %s users %p uid %u FIXME", G_STRLOC, G_STRFUNC, (void*)users, uid);
64
64
}
65
65
 
66
 
static GStrv
67
 
my_get_keys (IndicatorSessionUsers * users)
 
66
static GList *
 
67
my_get_uids (IndicatorSessionUsers * users)
68
68
{
69
 
  int i;
70
 
  priv_t * p;
71
 
  gchar ** keys;
72
 
  GHashTableIter iter;
73
 
  gpointer key;
74
 
 
75
69
  g_return_val_if_fail (INDICATOR_IS_SESSION_USERS_MOCK(users), NULL);
76
 
  p = INDICATOR_SESSION_USERS_MOCK (users)->priv;
77
 
 
78
 
  i = 0;
79
 
  keys = g_new (gchar*, g_hash_table_size(p->users)+1);
80
 
  g_hash_table_iter_init (&iter, p->users);
81
 
  while (g_hash_table_iter_next (&iter, &key, NULL))
82
 
    keys[i++] = g_strdup (key);
83
 
  keys[i] = NULL;
84
 
 
85
 
  return keys;
 
70
 
 
71
  return g_hash_table_get_keys (INDICATOR_SESSION_USERS_MOCK(users)->priv->users);
86
72
}
87
73
 
88
74
static IndicatorSessionUser *
89
 
my_get_user (IndicatorSessionUsers * self, const gchar * key)
 
75
my_get_user (IndicatorSessionUsers * self, guint uid)
90
76
{
91
77
  priv_t * p;
92
78
  const IndicatorSessionUser * src;
95
81
  g_return_val_if_fail (INDICATOR_IS_SESSION_USERS_MOCK(self), NULL);
96
82
  p = INDICATOR_SESSION_USERS_MOCK (self)->priv;
97
83
 
98
 
  if ((src = g_hash_table_lookup (p->users, key)))
 
84
  if ((src = g_hash_table_lookup (p->users, GUINT_TO_POINTER(uid))))
99
85
    {
100
86
      ret = g_new0 (IndicatorSessionUser, 1);
101
87
      ret->is_current_user = src->is_current_user;
123
109
 
124
110
  users_class = INDICATOR_SESSION_USERS_CLASS (klass);
125
111
  users_class->is_live_session = my_is_live_session;
126
 
  users_class->get_keys = my_get_keys;
 
112
  users_class->get_uids = my_get_uids;
127
113
  users_class->get_user = my_get_user;
128
114
  users_class->activate_user = my_activate_user;
129
115
 
141
127
                                   IndicatorSessionUsersMockPriv);
142
128
  self->priv = p;
143
129
 
144
 
  p->users = g_hash_table_new_full (g_str_hash,
145
 
                                    g_str_equal,
146
 
                                    g_free,
 
130
  p->users = g_hash_table_new_full (g_direct_hash,
 
131
                                    g_direct_equal,
 
132
                                    NULL,
147
133
                                    (GDestroyNotify)indicator_session_user_free);
148
134
 
149
135
  g_signal_connect_swapped (mock_settings, "changed::is-live-session",
165
151
 
166
152
void
167
153
indicator_session_users_mock_add_user (IndicatorSessionUsersMock * self,
168
 
                                       const char                * key,
169
154
                                       IndicatorSessionUser      * user)
170
155
{
171
156
  g_return_if_fail (INDICATOR_IS_SESSION_USERS_MOCK (self));
172
 
  g_return_if_fail (key && *key);
173
157
  g_return_if_fail (user != NULL);
 
158
  g_return_if_fail (user->uid > 0);
 
159
  g_return_if_fail (!g_hash_table_contains (self->priv->users, GUINT_TO_POINTER(user->uid)));
174
160
 
175
 
  g_hash_table_insert (self->priv->users, g_strdup(key), user);
176
 
  indicator_session_users_added (INDICATOR_SESSION_USERS (self), key);
 
161
  g_hash_table_insert (self->priv->users, GUINT_TO_POINTER(user->uid), user);
 
162
  indicator_session_users_added (INDICATOR_SESSION_USERS (self), user->uid);
177
163
}
178
164
 
179
165
void
180
166
indicator_session_users_mock_remove_user (IndicatorSessionUsersMock * self,
181
 
                                          const char                * key)
 
167
                                          guint                       uid)
182
168
{
183
169
  g_return_if_fail (INDICATOR_IS_SESSION_USERS_MOCK (self));
184
 
  g_return_if_fail (key && *key);
 
170
  g_return_if_fail (uid > 0);
185
171
 
186
 
  g_hash_table_remove (self->priv->users, key);
187
 
  indicator_session_users_removed (INDICATOR_SESSION_USERS (self), key);
 
172
  g_hash_table_remove (self->priv->users, GUINT_TO_POINTER(uid));
 
173
  indicator_session_users_removed (INDICATOR_SESSION_USERS (self), uid);
188
174
}
189
175