Mercurial > pidgin3 / file comparison

comparison: libpurple/tests/test_authorization_request.c

libpurple/tests/test_authorization_request.c

changeset 42941
d39faa3581eb
parent 42866
4b201e18638f
equal deleted inserted replaced
42940:240eb66a3795 42941:d39faa3581eb
55 /****************************************************************************** 55 /******************************************************************************
56 * Tests 56 * Tests
57 *****************************************************************************/ 57 *****************************************************************************/
58 static void 58 static void
59 test_purple_authorization_request_new(void) { 59 test_purple_authorization_request_new(void) {
60 PurpleAccount *account1 = NULL, *account2 = NULL; 60 PurpleAccount *account = NULL;
61 PurpleAuthorizationRequest *request = NULL; 61 PurpleAuthorizationRequest *request = NULL;
62 const char *username = NULL; 62 PurpleContact *contact = NULL;
63 63 PurpleContact *contact1 = NULL;
64 account1 = purple_account_new("test", "test"); 64
65 65 account = purple_account_new("test", "test");
66 request = purple_authorization_request_new(account1, "remote-username"); 66 contact = purple_contact_new(account, NULL);
67 request = purple_authorization_request_new(contact);
67 68
68 /* Make sure we got a valid authorization request. */ 69 /* Make sure we got a valid authorization request. */
69 g_assert_true(PURPLE_IS_AUTHORIZATION_REQUEST(request)); 70 g_assert_true(PURPLE_IS_AUTHORIZATION_REQUEST(request));
70 71
71 /* Verify the account is set properly. */ 72 /* Verify the contact is set properly. */
72 account2 = purple_authorization_request_get_account(request); 73 contact1 = purple_authorization_request_get_contact(request);
73 g_assert_nonnull(account2); 74 g_assert_true(contact1 == contact);
74 g_assert_true(account1 == account2); 75
75 76 g_assert_finalize_object(request);
76 /* Verify the username set properly. */ 77 g_assert_finalize_object(contact);
77 username = purple_authorization_request_get_username(request); 78 g_assert_finalize_object(account);
78 g_assert_cmpstr(username, ==, "remote-username");
79
80 /* Unref it to destroy it. */
81 g_clear_object(&request);
82
83 /* Clean up the account. */
84 g_clear_object(&account1);
85 } 79 }
86 80
87 static void 81 static void
88 test_purple_authorization_request_properties(void) { 82 test_purple_authorization_request_properties(void) {
89 PurpleAccount *account = NULL; 83 PurpleAccount *account = NULL;
90 PurpleAuthorizationRequest *request = NULL; 84 PurpleAuthorizationRequest *request = NULL;
85 PurpleContact *contact = NULL;
86 PurpleContact *contact1 = NULL;
87 char *message = NULL;
91 88
92 account = purple_account_new("test", "test"); 89 account = purple_account_new("test", "test");
93 request = purple_authorization_request_new(account, "username"); 90 contact = purple_contact_new(account, NULL);
91
92 request = g_object_new(
93 PURPLE_TYPE_AUTHORIZATION_REQUEST,
94 "contact", contact,
95 "message", "hello friend",
96 NULL);
94 97
95 g_assert_true(PURPLE_IS_AUTHORIZATION_REQUEST(request)); 98 g_assert_true(PURPLE_IS_AUTHORIZATION_REQUEST(request));
96 99
97 /* Verify the alias property works and is nullable. */ 100 g_object_get(
98 purple_authorization_request_set_alias(request, "alias"); 101 request,
99 g_assert_cmpstr(purple_authorization_request_get_alias(request), ==, 102 "contact", &contact1,
100 "alias"); 103 "message", &message,
101 purple_authorization_request_set_alias(request, NULL); 104 NULL);
102 g_assert_null(purple_authorization_request_get_alias(request)); 105
103 106 g_assert_true(contact1 == contact);
104 /* Verify the message property works and is nullable. */ 107 g_clear_object(&contact1);
105 purple_authorization_request_set_message(request, "message"); 108
106 g_assert_cmpstr(purple_authorization_request_get_message(request), ==, 109 g_assert_cmpstr(message, ==, "hello friend");
107 "message"); 110 g_clear_pointer(&message, g_free);
108 purple_authorization_request_set_message(request, NULL); 111
109 g_assert_null(purple_authorization_request_get_message(request)); 112 g_assert_finalize_object(request);
110 113 g_assert_finalize_object(contact);
111 /* Cleanup. */ 114 g_assert_finalize_object(account);
112 g_clear_object(&request);
113 g_clear_object(&account);
114 } 115 }
115 116
116 static void 117 static void
117 test_purple_authorization_request_accept(void) { 118 test_purple_authorization_request_accept(void) {
118 if(g_test_subprocess()) { 119 if(g_test_subprocess()) {
119 PurpleAccount *account = NULL; 120 PurpleAccount *account = NULL;
120 PurpleAuthorizationRequest *request = NULL; 121 PurpleAuthorizationRequest *request = NULL;
122 PurpleContact *contact = NULL;
121 guint counter = 0; 123 guint counter = 0;
122 124
123 account = purple_account_new("test", "test"); 125 account = purple_account_new("test", "test");
124 request = purple_authorization_request_new(account, "username"); 126 contact = purple_contact_new(account, NULL);
125 127 request = purple_authorization_request_new(contact);
126 g_assert_true(PURPLE_IS_AUTHORIZATION_REQUEST(request));
127 128
128 g_signal_connect(request, "accepted", 129 g_signal_connect(request, "accepted",
129 G_CALLBACK(test_purple_authorization_request_accepted_counter_cb), 130 G_CALLBACK(test_purple_authorization_request_accepted_counter_cb),
130 &counter); 131 &counter);
131 132
136 /* Accept the request again to trigger the critical. */ 137 /* Accept the request again to trigger the critical. */
137 purple_authorization_request_accept(request); 138 purple_authorization_request_accept(request);
138 g_assert_cmpuint(counter, ==, 1); 139 g_assert_cmpuint(counter, ==, 1);
139 140
140 /* Cleanup. */ 141 /* Cleanup. */
141 g_clear_object(&account); 142 g_assert_finalize_object(request);
142 g_clear_object(&request); 143 g_assert_finalize_object(contact);
144 g_assert_finalize_object(account);
143 } 145 }
144 146
145 g_test_trap_subprocess(NULL, 0, 0); 147 g_test_trap_subprocess(NULL, 0, 0);
146 g_test_trap_assert_stderr("*Purple-CRITICAL*request->handled*failed*"); 148 g_test_trap_assert_stderr("*Purple-CRITICAL*request->handled*failed*");
147 } 149 }
149 static void 151 static void
150 test_purple_authorization_request_accept_deny(void) { 152 test_purple_authorization_request_accept_deny(void) {
151 if(g_test_subprocess()) { 153 if(g_test_subprocess()) {
152 PurpleAccount *account = NULL; 154 PurpleAccount *account = NULL;
153 PurpleAuthorizationRequest *request = NULL; 155 PurpleAuthorizationRequest *request = NULL;
156 PurpleContact *contact = NULL;
154 guint counter = 0; 157 guint counter = 0;
155 158
156 account = purple_account_new("test", "test"); 159 account = purple_account_new("test", "test");
157 request = purple_authorization_request_new(account, "username"); 160 contact = purple_contact_new(account, NULL);
158 161 request = purple_authorization_request_new(contact);
159 g_assert_true(PURPLE_IS_AUTHORIZATION_REQUEST(request));
160 162
161 g_signal_connect(request, "accepted", 163 g_signal_connect(request, "accepted",
162 G_CALLBACK(test_purple_authorization_request_accepted_counter_cb), 164 G_CALLBACK(test_purple_authorization_request_accepted_counter_cb),
163 &counter); 165 &counter);
164 g_signal_connect(request, "denied", 166 g_signal_connect(request, "denied",
172 /* Deny the request to trigger the critical. */ 174 /* Deny the request to trigger the critical. */
173 purple_authorization_request_deny(request, NULL); 175 purple_authorization_request_deny(request, NULL);
174 g_assert_cmpuint(counter, ==, 1); 176 g_assert_cmpuint(counter, ==, 1);
175 177
176 /* Cleanup. */ 178 /* Cleanup. */
177 g_clear_object(&account); 179 g_assert_finalize_object(request);
178 g_clear_object(&request); 180 g_assert_finalize_object(contact);
181 g_assert_finalize_object(account);
179 } 182 }
180 183
181 g_test_trap_subprocess(NULL, 0, 0); 184 g_test_trap_subprocess(NULL, 0, 0);
182 g_test_trap_assert_stderr("*Purple-CRITICAL*request->handled*failed*"); 185 g_test_trap_assert_stderr("*Purple-CRITICAL*request->handled*failed*");
183 } 186 }
185 static void 188 static void
186 test_purple_authorization_request_deny(void) { 189 test_purple_authorization_request_deny(void) {
187 if(g_test_subprocess()) { 190 if(g_test_subprocess()) {
188 PurpleAccount *account = NULL; 191 PurpleAccount *account = NULL;
189 PurpleAuthorizationRequest *request = NULL; 192 PurpleAuthorizationRequest *request = NULL;
193 PurpleContact *contact = NULL;
190 guint counter = 0; 194 guint counter = 0;
191 195
192 account = purple_account_new("test", "test"); 196 account = purple_account_new("test", "test");
193 request = purple_authorization_request_new(account, "username"); 197 contact = purple_contact_new(account, NULL);
194 198 request = purple_authorization_request_new(contact);
195 g_assert_true(PURPLE_IS_AUTHORIZATION_REQUEST(request));
196 199
197 g_signal_connect(request, "denied", 200 g_signal_connect(request, "denied",
198 G_CALLBACK(test_purple_authorization_request_denied_counter_cb), 201 G_CALLBACK(test_purple_authorization_request_denied_counter_cb),
199 &counter); 202 &counter);
200 203
205 /* Deny the request again to trigger the critical. */ 208 /* Deny the request again to trigger the critical. */
206 purple_authorization_request_deny(request, NULL); 209 purple_authorization_request_deny(request, NULL);
207 g_assert_cmpuint(counter, ==, 1); 210 g_assert_cmpuint(counter, ==, 1);
208 211
209 /* Cleanup. */ 212 /* Cleanup. */
210 g_clear_object(&account); 213 g_assert_finalize_object(request);
211 g_clear_object(&request); 214 g_assert_finalize_object(contact);
215 g_assert_finalize_object(account);
212 } 216 }
213 217
214 g_test_trap_subprocess(NULL, 0, 0); 218 g_test_trap_subprocess(NULL, 0, 0);
215 g_test_trap_assert_stderr("*Purple-CRITICAL*request->handled*failed*"); 219 g_test_trap_assert_stderr("*Purple-CRITICAL*request->handled*failed*");
216 } 220 }
218 static void 222 static void
219 test_purple_authorization_request_deny_accept(void) { 223 test_purple_authorization_request_deny_accept(void) {
220 if(g_test_subprocess()) { 224 if(g_test_subprocess()) {
221 PurpleAccount *account = NULL; 225 PurpleAccount *account = NULL;
222 PurpleAuthorizationRequest *request = NULL; 226 PurpleAuthorizationRequest *request = NULL;
227 PurpleContact *contact = NULL;
223 guint counter = 0; 228 guint counter = 0;
224 229
225 account = purple_account_new("test", "test"); 230 account = purple_account_new("test", "test");
226 request = purple_authorization_request_new(account, "username"); 231 contact = purple_contact_new(account, NULL);
227 232 request = purple_authorization_request_new(contact);
228 g_assert_true(PURPLE_IS_AUTHORIZATION_REQUEST(request));
229 233
230 g_signal_connect(request, "denied", 234 g_signal_connect(request, "denied",
231 G_CALLBACK(test_purple_authorization_request_denied_counter_cb), 235 G_CALLBACK(test_purple_authorization_request_denied_counter_cb),
232 &counter); 236 &counter);
233 g_signal_connect(request, "accepted", 237 g_signal_connect(request, "accepted",
241 /* Deny the request again to trigger the critical. */ 245 /* Deny the request again to trigger the critical. */
242 purple_authorization_request_accept(request); 246 purple_authorization_request_accept(request);
243 g_assert_cmpuint(counter, ==, 1); 247 g_assert_cmpuint(counter, ==, 1);
244 248
245 /* Cleanup. */ 249 /* Cleanup. */
246 g_clear_object(&account); 250 g_assert_finalize_object(request);
247 g_clear_object(&request); 251 g_assert_finalize_object(contact);
252 g_assert_finalize_object(account);
248 } 253 }
249 254
250 g_test_trap_subprocess(NULL, 0, 0); 255 g_test_trap_subprocess(NULL, 0, 0);
251 g_test_trap_assert_stderr("*Purple-CRITICAL*request->handled*failed*"); 256 g_test_trap_assert_stderr("*Purple-CRITICAL*request->handled*failed*");
252 } 257 }
253 258
254 static void 259 static void
255 test_purple_authorization_request_deny_message_null(void) { 260 test_purple_authorization_request_deny_message_null(void) {
256 PurpleAccount *account = NULL; 261 PurpleAccount *account = NULL;
257 PurpleAuthorizationRequest *request = NULL; 262 PurpleAuthorizationRequest *request = NULL;
263 PurpleContact *contact = NULL;
258 264
259 account = purple_account_new("test", "test"); 265 account = purple_account_new("test", "test");
260 request = purple_authorization_request_new(account, "username"); 266 contact = purple_contact_new(account, NULL);
261 267 request = purple_authorization_request_new(contact);
262 g_assert_true(PURPLE_IS_AUTHORIZATION_REQUEST(request));
263 268
264 g_signal_connect(request, "denied", 269 g_signal_connect(request, "denied",
265 G_CALLBACK(test_purple_authorization_request_denied_message_cb), 270 G_CALLBACK(test_purple_authorization_request_denied_message_cb),
266 NULL); 271 NULL);
267 272
268 /* Deny the request the signal handler is expecting a message of NULL. */ 273 /* Deny the request the signal handler is expecting a message of NULL. */
269 purple_authorization_request_deny(request, NULL); 274 purple_authorization_request_deny(request, NULL);
270 275
271 /* Cleanup. */ 276 /* Cleanup. */
272 g_clear_object(&account); 277 g_assert_finalize_object(request);
273 g_clear_object(&request); 278 g_assert_finalize_object(contact);
279 g_assert_finalize_object(account);
274 } 280 }
275 281
276 static void 282 static void
277 test_purple_authorization_request_deny_message_non_null(void) { 283 test_purple_authorization_request_deny_message_non_null(void) {
278 PurpleAccount *account = NULL; 284 PurpleAccount *account = NULL;
279 PurpleAuthorizationRequest *request = NULL; 285 PurpleAuthorizationRequest *request = NULL;
286 PurpleContact *contact = NULL;
280 287
281 account = purple_account_new("test", "test"); 288 account = purple_account_new("test", "test");
282 request = purple_authorization_request_new(account, "username"); 289 contact = purple_contact_new(account, NULL);
283 290 request = purple_authorization_request_new(contact);
284 g_assert_true(PURPLE_IS_AUTHORIZATION_REQUEST(request));
285 291
286 g_signal_connect(request, "denied", 292 g_signal_connect(request, "denied",
287 G_CALLBACK(test_purple_authorization_request_denied_message_cb), 293 G_CALLBACK(test_purple_authorization_request_denied_message_cb),
288 "this is a message"); 294 "this is a message");
289 295
290 /* Deny the request the signal handler is expecting the above message. */ 296 /* Deny the request the signal handler is expecting the above message. */
291 purple_authorization_request_deny(request, "this is a message"); 297 purple_authorization_request_deny(request, "this is a message");
292 298
293 /* Cleanup. */ 299 /* Cleanup. */
294 g_clear_object(&account); 300 g_assert_finalize_object(request);
295 g_clear_object(&request); 301 g_assert_finalize_object(contact);
302 g_assert_finalize_object(account);
296 } 303 }
297 304
298 /****************************************************************************** 305 /******************************************************************************
299 * Main 306 * Main
300 *****************************************************************************/ 307 *****************************************************************************/

Mercurial Repository: pidgin3

mercurial