summaryrefslogtreecommitdiff
path: root/auto_tests/toxav_basic_test.c
diff options
context:
space:
mode:
Diffstat (limited to 'auto_tests/toxav_basic_test.c')
-rw-r--r--auto_tests/toxav_basic_test.c891
1 files changed, 355 insertions, 536 deletions
diff --git a/auto_tests/toxav_basic_test.c b/auto_tests/toxav_basic_test.c
index af8d91e9..abe5d034 100644
--- a/auto_tests/toxav_basic_test.c
+++ b/auto_tests/toxav_basic_test.c
@@ -9,11 +9,11 @@
9#include <check.h> 9#include <check.h>
10#include <stdlib.h> 10#include <stdlib.h>
11#include <time.h> 11#include <time.h>
12#include <assert.h>
13 12
14#include <vpx/vpx_image.h> 13#include <vpx/vpx_image.h>
15 14
16#include "../toxcore/tox.h" 15#include "../toxcore/tox.h"
16#include "../toxcore/util.h"
17#include "../toxcore/logger.h" 17#include "../toxcore/logger.h"
18#include "../toxcore/crypto_core.h" 18#include "../toxcore/crypto_core.h"
19#include "../toxav/toxav.h" 19#include "../toxav/toxav.h"
@@ -28,604 +28,425 @@
28#endif 28#endif
29 29
30 30
31#define TEST_REGULAR_AV 1
32#define TEST_REGULAR_A 1
33#define TEST_REGULAR_V 1
34#define TEST_REJECT 1
35#define TEST_CANCEL 1
36#define TEST_MUTE_UNMUTE 1
31 37
32typedef enum _CallStatus {
33 none,
34 InCall,
35 Ringing,
36 Ended,
37 Rejected,
38 Canceled,
39 TimedOut
40 38
41} CallStatus; 39typedef struct {
40 bool incoming;
41 uint32_t state;
42
43} CallControl;
42 44
43typedef struct _Party {
44 CallStatus status;
45 ToxAv *av;
46 time_t *CallStarted;
47 int call_index;
48} Party;
49 45
50typedef struct _Status { 46/**
51 Party Alice; 47 * Callbacks
52 Party Bob; 48 */
53} Status; 49void t_toxav_call_cb(ToxAV *av, uint32_t friend_number, bool audio_enabled, bool video_enabled, void *user_data)
54
55/* My default settings */
56static ToxAvCSettings muhcaps;
57
58void accept_friend_request(Tox *m, const uint8_t *public_key, const uint8_t *data, size_t length, void *userdata)
59{
60 if (length == 7 && memcmp("gentoo", data, 7) == 0) {
61 tox_friend_add_norequest(m, public_key, 0);
62 }
63}
64
65
66/******************************************************************************/
67void callback_recv_invite ( void *av, int32_t call_index, void *_arg )
68{
69 Status *cast = _arg;
70
71 if (cast->Alice.av == av) {
72 // ...
73 } else if (cast->Bob.av == av) {
74 /* Bob always receives invite */
75 cast->Bob.status = Ringing;
76 cast->Bob.call_index = call_index;
77 }
78}
79void callback_recv_ringing ( void *av, int32_t call_index, void *_arg )
80{
81 Status *cast = _arg;
82
83 if (cast->Alice.av == av) {
84 /* Alice always sends invite */
85 cast->Alice.status = Ringing;
86 } else if (cast->Bob.av == av) {
87 // ...
88 }
89}
90
91
92void callback_call_started ( void *av, int32_t call_index, void *_arg )
93{
94 Status *cast = _arg;
95
96 if (cast->Alice.av == av) {
97 printf("Call started on Alices side...\n");
98 cast->Alice.status = InCall;
99 toxav_prepare_transmission(av, call_index, 1);
100 } else if (cast->Bob.av == av) {
101 printf("Call started on Bob side...\n");
102 cast->Bob.status = InCall;
103 toxav_prepare_transmission(av, call_index, 1);
104 }
105}
106void callback_call_canceled ( void *av, int32_t call_index, void *_arg )
107{ 50{
108 Status *cast = _arg; 51 (void) av;
109 52 (void) friend_number;
110 if (cast->Alice.av == av) { 53 (void) audio_enabled;
111 // ... 54 (void) video_enabled;
112 } else if (cast->Bob.av == av) { 55
113 printf ( "Call Canceled for Bob!\n" ); 56 printf("Handling CALL callback\n");
114 cast->Bob.status = Canceled; 57 ((CallControl*)user_data)->incoming = true;
115 }
116} 58}
117void callback_call_rejected ( void *av, int32_t call_index, void *_arg ) 59void t_toxav_call_state_cb(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_data)
118{ 60{
119 Status *cast = _arg; 61 (void) av;
120 62 (void) friend_number;
121 printf ( "Call rejected by Bob!\n" 63
122 "Call ended for Alice!\n" ); 64 printf("Handling CALL STATE callback: %d\n", state);
123 65 ((CallControl*)user_data)->state = state;
124 /* If Bob rejects, call is ended for alice and she sends ending */
125 if (cast->Alice.av == av) {
126 cast->Alice.status = Rejected;
127 } else if (cast->Bob.av == av) {
128 //... ignor
129 }
130} 66}
131void callback_call_ended ( void *av, int32_t call_index, void *_arg ) 67void t_toxav_receive_video_frame_cb(ToxAV *av, uint32_t friend_number,
68 uint16_t width, uint16_t height,
69 uint8_t const *y, uint8_t const *u, uint8_t const *v,
70 int32_t ystride, int32_t ustride, int32_t vstride,
71 void *user_data)
132{ 72{
133 Status *cast = _arg; 73 (void) av;
134 74 (void) friend_number;
135 if (cast->Alice.av == av) { 75 (void) width;
136 printf ( "Call ended for Alice!\n" ); 76 (void) height;
137 cast->Alice.status = Ended; 77 (void) y;
138 } else if (cast->Bob.av == av) { 78 (void) u;
139 printf ( "Call ended for Bob!\n" ); 79 (void) v;
140 cast->Bob.status = Ended; 80 (void) ystride;
141 } 81 (void) ustride;
82 (void) vstride;
83 (void) user_data;
142} 84}
143 85void t_toxav_receive_audio_frame_cb(ToxAV *av, uint32_t friend_number,
144void callback_peer_cs_change ( void *av, int32_t call_index, void *_arg ) 86 int16_t const *pcm,
87 size_t sample_count,
88 uint8_t channels,
89 uint32_t sampling_rate,
90 void *user_data)
145{ 91{
146 ToxAvCSettings csettings; 92 (void) av;
147 toxav_get_peer_csettings(av, call_index, 0, &csettings); 93 (void) friend_number;
148 94 (void) pcm;
149 printf("Peer changing settings to: \n" 95 (void) sample_count;
150 "Type: %u \n" 96 (void) channels;
151 "Video bitrate: %u \n" 97 (void) sampling_rate;
152 "Video height: %u \n" 98 (void) user_data;
153 "Video width: %u \n"
154 "Audio bitrate: %u \n"
155 "Audio framedur: %u \n"
156 "Audio sample rate: %u \n"
157 "Audio channels: %u \n",
158 csettings.call_type,
159 csettings.video_bitrate,
160 csettings.max_video_height,
161 csettings.max_video_width,
162 csettings.audio_bitrate,
163 csettings.audio_frame_duration,
164 csettings.audio_sample_rate,
165 csettings.audio_channels
166 );
167} 99}
168 100void t_accept_friend_request_cb(Tox *m, const uint8_t *public_key, const uint8_t *data, size_t length, void *userdata)
169void callback_self_cs_change ( void *av, int32_t call_index, void *_arg )
170{ 101{
171 ToxAvCSettings csettings; 102 (void) userdata;
172 toxav_get_peer_csettings(av, call_index, 0, &csettings); 103
173 104 if (length == 7 && memcmp("gentoo", data, 7) == 0) {
174 printf("Changed settings to: \n" 105 ck_assert(tox_friend_add_norequest(m, public_key, NULL) != (uint32_t) ~0);
175 "Type: %u \n"
176 "Video bitrate: %u \n"
177 "Video height: %u \n"
178 "Video width: %u \n"
179 "Audio bitrate: %u \n"
180 "Audio framedur: %u \n"
181 "Audio sample rate: %u \n"
182 "Audio channels: %u \n",
183 csettings.call_type,
184 csettings.video_bitrate,
185 csettings.max_video_height,
186 csettings.max_video_width,
187 csettings.audio_bitrate,
188 csettings.audio_frame_duration,
189 csettings.audio_sample_rate,
190 csettings.audio_channels
191 );
192}
193
194void callback_requ_timeout ( void *av, int32_t call_index, void *_arg )
195{
196 Status *cast = _arg;
197 printf("Call timed-out!\n");
198
199 if (cast->Alice.av == av) {
200 cast->Alice.status = TimedOut;
201 } else if (cast->Bob.av == av) {
202 cast->Bob.status = TimedOut;
203 } 106 }
204} 107}
205 108
206void callback_audio (void *agent, int32_t call_idx, const int16_t *PCM, uint16_t size, void *data)
207{}
208
209void callback_video (void *agent, int32_t call_idx, const vpx_image_t *img, void *data)
210{}
211 109
212void register_callbacks(ToxAv *av, void *data) 110/**
111 * Iterate helper
112 */
113int iterate_tox(Tox* bootstrap, Tox* Alice, Tox* Bob)
213{ 114{
214 toxav_register_callstate_callback(av, callback_call_started, av_OnStart, data); 115 tox_iterate(bootstrap);
215 toxav_register_callstate_callback(av, callback_call_canceled, av_OnCancel, data); 116 tox_iterate(Alice);
216 toxav_register_callstate_callback(av, callback_call_rejected, av_OnReject, data); 117 tox_iterate(Bob);
217 toxav_register_callstate_callback(av, callback_call_ended, av_OnEnd, data); 118
218 toxav_register_callstate_callback(av, callback_recv_invite, av_OnInvite, data); 119 return MIN(tox_iteration_interval(Alice), tox_iteration_interval(Bob));
219 toxav_register_callstate_callback(av, callback_recv_ringing, av_OnRinging, data);
220 toxav_register_callstate_callback(av, callback_requ_timeout, av_OnRequestTimeout, data);
221 toxav_register_callstate_callback(av, callback_peer_cs_change, av_OnPeerCSChange, data);
222 toxav_register_callstate_callback(av, callback_self_cs_change, av_OnSelfCSChange, data);
223 toxav_register_audio_callback(av, callback_audio, NULL);
224 toxav_register_video_callback(av, callback_video, NULL);
225} 120}
226 121
227 122
228/*************************************************************************************************/
229
230/* Alice calls bob and the call starts.
231 * What happens during the call is defined after. To quit the loop use: step++;
232 */
233#define CALL_AND_START_LOOP(AliceCallType, BobCallType) \
234{ int step = 0, running = 1; while (running) {\
235 tox_iterate(bootstrap_node); tox_iterate(Alice); tox_iterate(Bob); \
236 toxav_do(status_control.Bob.av); toxav_do(status_control.Alice.av); \
237 switch ( step ) {\
238 case 0: /* Alice */ printf("Alice is calling...\n");\
239 toxav_call(status_control.Alice.av, &status_control.Alice.call_index, 0, &muhcaps, 10); step++; break;\
240 case 1: /* Bob */ if (status_control.Bob.status == Ringing) { printf("Bob answers...\n");\
241 cur_time = time(NULL); toxav_answer(status_control.Bob.av, status_control.Bob.call_index, &muhcaps); step++; } break; \
242 case 2: /* Rtp transmission */ \
243 if (status_control.Bob.status == InCall && status_control.Alice.status == InCall)
244
245
246#define TERMINATE_SCOPE() break;\
247case 3: /* Wait for Both to have status ended */\
248if (status_control.Alice.status == Ended && status_control.Bob.status == Ended) running = 0; break; } c_sleep(20); } } printf("\n");
249 123
250START_TEST(test_AV_flows) 124START_TEST(test_AV_flows)
251{ 125{
126 Tox* Alice, *Bob, *bootstrap;
127 ToxAV* AliceAV, *BobAV;
128
129 CallControl AliceCC, BobCC;
130
131 {
132 TOX_ERR_NEW error;
133
134 bootstrap = tox_new(NULL, &error);
135 ck_assert(error == TOX_ERR_NEW_OK);
136
137 Alice = tox_new(NULL, &error);
138 ck_assert(error == TOX_ERR_NEW_OK);
139
140 Bob = tox_new(NULL, &error);
141 ck_assert(error == TOX_ERR_NEW_OK);
142 }
143
144 printf("Created 3 instances of Tox\n");
145 printf("Preparing network...\n");
252 long long unsigned int cur_time = time(NULL); 146 long long unsigned int cur_time = time(NULL);
253 Tox *bootstrap_node = tox_new(0, 0); 147
254 Tox *Alice = tox_new(0, 0);
255 Tox *Bob = tox_new(0, 0);
256
257 ck_assert_msg(bootstrap_node || Alice || Bob, "Failed to create 3 tox instances");
258
259 uint32_t to_compare = 974536; 148 uint32_t to_compare = 974536;
260 tox_callback_friend_request(Alice, accept_friend_request, &to_compare);
261 uint8_t address[TOX_ADDRESS_SIZE]; 149 uint8_t address[TOX_ADDRESS_SIZE];
150
151 tox_callback_friend_request(Alice, t_accept_friend_request_cb, &to_compare);
262 tox_self_get_address(Alice, address); 152 tox_self_get_address(Alice, address);
263 uint32_t test = tox_friend_add(Bob, address, (uint8_t *)"gentoo", 7, 0); 153
264 154
265 ck_assert_msg(test == 0, "Failed to add friend error code: %i", test); 155 ck_assert(tox_friend_add(Bob, address, (uint8_t *)"gentoo", 7, NULL) != (uint32_t) ~0);
266 156
267 uint8_t off = 1; 157 uint8_t off = 1;
268 158
269 while (1) { 159 while (1) {
270 tox_iterate(bootstrap_node); 160 iterate_tox(bootstrap, Alice, Bob);
271 tox_iterate(Alice); 161
272 tox_iterate(Bob); 162 if (tox_self_get_connection_status(bootstrap) &&
273 163 tox_self_get_connection_status(Alice) &&
274 if (tox_self_get_connection_status(bootstrap_node) && tox_self_get_connection_status(Alice) 164 tox_self_get_connection_status(Bob) && off) {
275 && tox_self_get_connection_status(Bob)
276 && off) {
277 printf("Toxes are online, took %llu seconds\n", time(NULL) - cur_time); 165 printf("Toxes are online, took %llu seconds\n", time(NULL) - cur_time);
278 off = 0; 166 off = 0;
279 } 167 }
280 168
281 if (tox_friend_get_connection_status(Alice, 0, 0) && tox_friend_get_connection_status(Bob, 0, 0)) 169 if (tox_friend_get_connection_status(Alice, 0, NULL) == TOX_CONNECTION_UDP &&
170 tox_friend_get_connection_status(Bob, 0, NULL) == TOX_CONNECTION_UDP)
282 break; 171 break;
283 172
284 c_sleep(20); 173 c_sleep(20);
285 } 174 }
286 175
287 printf("All set after %llu seconds! Starting call...\n", time(NULL) - cur_time); 176
288 177 {
289 muhcaps = av_DefaultSettings; 178 TOXAV_ERR_NEW error;
290 muhcaps.max_video_height = muhcaps.max_video_width = 128; 179 AliceAV = toxav_new(Alice, &error);
291 180 ck_assert(error == TOXAV_ERR_NEW_OK);
292 Status status_control = { 181
293 {none, toxav_new(Alice, 1), NULL, -1}, 182 BobAV = toxav_new(Bob, &error);
294 {none, toxav_new(Bob, 1), NULL, -1}, 183 ck_assert(error == TOXAV_ERR_NEW_OK);
295 };
296
297 ck_assert_msg(status_control.Alice.av || status_control.Bob.av, "Failed to create 2 toxav instances");
298
299
300 register_callbacks(status_control.Alice.av, &status_control);
301 register_callbacks(status_control.Bob.av, &status_control);
302
303 const int frame_size = (av_DefaultSettings.audio_sample_rate * av_DefaultSettings.audio_frame_duration / 1000);
304 int16_t sample_payload[frame_size];
305 randombytes((uint8_t *)sample_payload, sizeof(int16_t) * frame_size);
306
307 uint8_t prepared_payload[RTP_PAYLOAD_SIZE];
308 int payload_size;
309
310 vpx_image_t *sample_image = vpx_img_alloc(NULL, VPX_IMG_FMT_I420, 128, 128, 1);
311
312 memcpy(sample_image->planes[VPX_PLANE_Y], sample_payload, 10);
313 memcpy(sample_image->planes[VPX_PLANE_U], sample_payload, 10);
314 memcpy(sample_image->planes[VPX_PLANE_V], sample_payload, 10);
315
316
317 /*************************************************************************************************
318 * Successful flows (when call starts)
319 */
320
321 /*
322 * Call with audio only on both sides. Alice calls Bob.
323 */
324
325
326 CALL_AND_START_LOOP(TypeAudio, TypeAudio) {
327 /* Both send */
328 payload_size = toxav_prepare_audio_frame(status_control.Alice.av, status_control.Alice.call_index, prepared_payload,
329 1000, sample_payload, frame_size);
330
331 if ( payload_size < 0 ) {
332 ck_assert_msg ( 0, "Failed to encode payload" );
333 }
334
335 toxav_send_audio(status_control.Alice.av, status_control.Alice.call_index, prepared_payload, payload_size);
336
337 payload_size = toxav_prepare_audio_frame(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, 1000,
338 sample_payload, frame_size);
339
340 if ( payload_size < 0 ) {
341 ck_assert_msg ( 0, "Failed to encode payload" );
342 }
343
344 toxav_send_audio(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, payload_size);
345
346 if (time(NULL) - cur_time > 10) { /* Transmit for 10 seconds */
347 step++; /* This terminates the loop */
348 toxav_kill_transmission(status_control.Alice.av, status_control.Alice.call_index);
349 toxav_kill_transmission(status_control.Bob.av, status_control.Bob.call_index);
350
351 /* Call over Alice hangs up */
352 toxav_hangup(status_control.Alice.av, status_control.Alice.call_index);
353 }
354 } 184 }
355 TERMINATE_SCOPE() 185
356 186 toxav_callback_call(AliceAV, t_toxav_call_cb, &AliceCC);
357 187 toxav_callback_call_state(AliceAV, t_toxav_call_state_cb, &AliceCC);
358 /* 188 toxav_callback_video_receive_frame(AliceAV, t_toxav_receive_video_frame_cb, &AliceCC);
359 * Call with audio on both sides and video on one side. Alice calls Bob. 189 toxav_callback_audio_receive_frame(AliceAV, t_toxav_receive_audio_frame_cb, &AliceCC);
360 */ 190
361 CALL_AND_START_LOOP(TypeAudio, TypeVideo) { 191 toxav_callback_call(BobAV, t_toxav_call_cb, &BobCC);
362 /* Both send */ 192 toxav_callback_call_state(BobAV, t_toxav_call_state_cb, &BobCC);
363 payload_size = toxav_prepare_audio_frame(status_control.Alice.av, status_control.Alice.call_index, prepared_payload, 193 toxav_callback_video_receive_frame(BobAV, t_toxav_receive_video_frame_cb, &BobCC);
364 1000, sample_payload, frame_size); 194 toxav_callback_audio_receive_frame(BobAV, t_toxav_receive_audio_frame_cb, &BobCC);
365 195
366 if ( payload_size < 0 ) { 196 printf("Created 2 instances of ToxAV\n");
367 ck_assert_msg ( 0, "Failed to encode payload" ); 197 printf("All set after %llu seconds!\n", time(NULL) - cur_time);
368 } 198
369 199
370 toxav_send_audio(status_control.Alice.av, status_control.Alice.call_index, prepared_payload, payload_size); 200#define REGULAR_CALL_FLOW(A_BR, V_BR) \
371 201 do { \
372 payload_size = toxav_prepare_audio_frame(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, 1000, 202 memset(&AliceCC, 0, sizeof(CallControl)); \
373 sample_payload, frame_size); 203 memset(&BobCC, 0, sizeof(CallControl)); \
374 204 \
375 if ( payload_size < 0 ) { 205 TOXAV_ERR_CALL rc; \
376 ck_assert_msg ( 0, "Failed to encode payload" ); 206 toxav_call(AliceAV, 0, A_BR, V_BR, &rc); \
377 } 207 \
378 208 if (rc != TOXAV_ERR_CALL_OK) { \
379 toxav_send_audio(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, payload_size); 209 printf("toxav_call failed: %d\n", rc); \
380 210 ck_assert(0); \
381// toxav_send_video(status_control.Bob.av, status_control.Bob.call_index, sample_image); 211 } \
382 212 \
383 if (time(NULL) - cur_time > 10) { /* Transmit for 10 seconds */ 213 \
384 step++; /* This terminates the loop */ 214 long long unsigned int start_time = time(NULL); \
385 toxav_kill_transmission(status_control.Alice.av, status_control.Alice.call_index); 215 \
386 toxav_kill_transmission(status_control.Bob.av, status_control.Bob.call_index); 216 \
387 217 while (BobCC.state != TOXAV_CALL_STATE_FINISHED) { \
388 /* Call over Alice hangs up */ 218 \
389 toxav_hangup(status_control.Alice.av, status_control.Alice.call_index); 219 if (BobCC.incoming) { \
390 } 220 TOXAV_ERR_ANSWER rc; \
221 toxav_answer(BobAV, 0, A_BR, V_BR, &rc); \
222 \
223 if (rc != TOXAV_ERR_ANSWER_OK) { \
224 printf("toxav_answer failed: %d\n", rc); \
225 ck_assert(0); \
226 } \
227 BobCC.incoming = false; \
228 } else { \
229 /* TODO rtp */ \
230 \
231 if (time(NULL) - start_time >= 1) { \
232 \
233 TOXAV_ERR_CALL_CONTROL rc; \
234 toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc); \
235 \
236 if (rc != TOXAV_ERR_CALL_CONTROL_OK) { \
237 printf("toxav_call_control failed: %d\n", rc); \
238 ck_assert(0); \
239 } \
240 } \
241 } \
242 \
243 iterate_tox(bootstrap, Alice, Bob); \
244 } \
245 printf("Success!\n");\
246 } while(0)
247
248 if (TEST_REGULAR_AV) {
249 printf("\nTrying regular call (Audio and Video)...\n");
250 REGULAR_CALL_FLOW(48, 4000);
391 } 251 }
392 TERMINATE_SCOPE() 252
393 253 if (TEST_REGULAR_A) {
394 254 printf("\nTrying regular call (Audio only)...\n");
395 /* 255 REGULAR_CALL_FLOW(48, 0);
396 * Call with audio and video on both sides. Alice calls Bob.
397 */
398 CALL_AND_START_LOOP(TypeVideo, TypeVideo) {
399 /* Both send */
400
401 payload_size = toxav_prepare_audio_frame(status_control.Alice.av, status_control.Alice.call_index, prepared_payload,
402 1000, sample_payload, frame_size);
403
404 if ( payload_size < 0 ) {
405 ck_assert_msg ( 0, "Failed to encode payload" );
406 }
407
408 toxav_send_audio(status_control.Alice.av, status_control.Alice.call_index, prepared_payload, payload_size);
409
410 payload_size = toxav_prepare_audio_frame(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, 1000,
411 sample_payload, frame_size);
412
413 if ( payload_size < 0 ) {
414 ck_assert_msg ( 0, "Failed to encode payload" );
415 }
416
417 toxav_send_audio(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, payload_size);
418
419// toxav_send_video(status_control.Alice.av, status_control.Alice.call_index, sample_image);
420// toxav_send_video(status_control.Bob.av, status_control.Bob.call_index, sample_image);
421
422
423 if (time(NULL) - cur_time > 10) { /* Transmit for 10 seconds */
424 step++; /* This terminates the loop */
425 toxav_kill_transmission(status_control.Alice.av, status_control.Alice.call_index);
426 toxav_kill_transmission(status_control.Bob.av, status_control.Bob.call_index);
427
428 /* Call over Alice hangs up */
429 toxav_hangup(status_control.Alice.av, status_control.Alice.call_index);
430 }
431 } 256 }
432 TERMINATE_SCOPE() 257
433 258 if (TEST_REGULAR_V) {
434 259 printf("\nTrying regular call (Video only)...\n");
435 uint64_t times_they_are_a_changin = time(NULL); 260 REGULAR_CALL_FLOW(0, 4000);
436 /* Media change */ 261 }
437 CALL_AND_START_LOOP(TypeAudio, TypeAudio) { 262
438 /* Both send */ 263#undef REGULAR_CALL_FLOW
439 payload_size = toxav_prepare_audio_frame(status_control.Alice.av, status_control.Alice.call_index, prepared_payload, 264
440 1000, sample_payload, frame_size); 265 if (TEST_REJECT) { /* Alice calls; Bob rejects */
441 266 printf("\nTrying reject flow...\n");
442 if ( payload_size < 0 ) { 267
443 ck_assert_msg ( 0, "Failed to encode payload" ); 268 memset(&AliceCC, 0, sizeof(CallControl));
269 memset(&BobCC, 0, sizeof(CallControl));
270
271 {
272 TOXAV_ERR_CALL rc;
273 toxav_call(AliceAV, 0, 48, 0, &rc);
274
275 if (rc != TOXAV_ERR_CALL_OK) {
276 printf("toxav_call failed: %d\n", rc);
277 ck_assert(0);
278 }
444 } 279 }
445 280
446 toxav_send_audio(status_control.Alice.av, status_control.Alice.call_index, prepared_payload, payload_size); 281 while (!BobCC.incoming)
447 282 iterate_tox(bootstrap, Alice, Bob);
448 payload_size = toxav_prepare_audio_frame(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, 1000, 283
449 sample_payload, frame_size); 284 /* Reject */
450 285 {
451 if ( payload_size < 0 ) { 286 TOXAV_ERR_CALL_CONTROL rc;
452 ck_assert_msg ( 0, "Failed to encode payload" ); 287 toxav_call_control(BobAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
288
289 if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
290 printf("toxav_call_control failed: %d\n", rc);
291 ck_assert(0);
292 }
453 } 293 }
454 294
455 toxav_send_audio(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, payload_size); 295 while (AliceCC.state != TOXAV_CALL_STATE_FINISHED)
456 296 iterate_tox(bootstrap, Alice, Bob);
457 /* Wait 2 seconds and change transmission type */ 297
458 if (time(NULL) - times_they_are_a_changin > 2) { 298 printf("Success!\n");
459 times_they_are_a_changin = time(NULL); 299 }
460 muhcaps.audio_bitrate ++; 300
461 toxav_change_settings(status_control.Alice.av, status_control.Alice.call_index, &muhcaps); 301 if (TEST_CANCEL) { /* Alice calls; Alice cancels while ringing */
302 printf("\nTrying cancel (while ringing) flow...\n");
303
304 memset(&AliceCC, 0, sizeof(CallControl));
305 memset(&BobCC, 0, sizeof(CallControl));
306
307 {
308 TOXAV_ERR_CALL rc;
309 toxav_call(AliceAV, 0, 48, 0, &rc);
310
311 if (rc != TOXAV_ERR_CALL_OK) {
312 printf("toxav_call failed: %d\n", rc);
313 ck_assert(0);
314 }
462 } 315 }
463 316
464 if (time(NULL) - cur_time > 10) { /* Transmit for 10 seconds */ 317 while (!BobCC.incoming)
465 step++; /* This terminates the loop */ 318 iterate_tox(bootstrap, Alice, Bob);
466 toxav_kill_transmission(status_control.Alice.av, status_control.Alice.call_index); 319
467 toxav_kill_transmission(status_control.Bob.av, status_control.Bob.call_index); 320 /* Cancel */
468 321 {
469 /* Call over Alice hangs up */ 322 TOXAV_ERR_CALL_CONTROL rc;
470 toxav_hangup(status_control.Alice.av, status_control.Alice.call_index); 323 toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
324
325 if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
326 printf("toxav_call_control failed: %d\n", rc);
327 ck_assert(0);
328 }
471 } 329 }
330
331 /* Alice will not receive end state */
332 while (BobCC.state != TOXAV_CALL_STATE_FINISHED)
333 iterate_tox(bootstrap, Alice, Bob);
334
335 printf("Success!\n");
472 } 336 }
473 TERMINATE_SCOPE() 337
474 338 if (TEST_MUTE_UNMUTE) { /* Check Mute-Unmute etc */
475 339 printf("\nTrying mute functionality...\n");
476 /************************************************************************************************* 340
477 * Other flows 341 memset(&AliceCC, 0, sizeof(CallControl));
478 */ 342 memset(&BobCC, 0, sizeof(CallControl));
479 343
480 /* 344 /* Assume sending audio and video */
481 * Call and reject 345 {
482 */ 346 TOXAV_ERR_CALL rc;
483 { 347 toxav_call(AliceAV, 0, 48, 1000, &rc);
484 int step = 0; 348
485 int running = 1; 349 if (rc != TOXAV_ERR_CALL_OK) {
486 350 printf("toxav_call failed: %d\n", rc);
487 while (running) { 351 ck_assert(0);
488 tox_iterate(bootstrap_node);
489 tox_iterate(Alice);
490 tox_iterate(Bob);
491
492 switch ( step ) {
493 case 0: /* Alice */
494 printf("Alice is calling...\n");
495 toxav_call(status_control.Alice.av, &status_control.Alice.call_index, 0, &muhcaps, 10);
496 step++;
497 break;
498
499 case 1: /* Bob */
500 if (status_control.Bob.status == Ringing) {
501 printf("Bob rejects...\n");
502 toxav_reject(status_control.Bob.av, status_control.Bob.call_index, "Who likes D's anyway?");
503 step++;
504 }
505
506 break;
507
508 case 2: /* Wait for Both to have status ended */
509 if (status_control.Alice.status == Rejected && status_control.Bob.status == Ended) running = 0;
510
511 break;
512 } 352 }
513
514 c_sleep(20);
515 } 353 }
516 354
517 printf("\n"); 355 while (!BobCC.incoming)
518 } 356 iterate_tox(bootstrap, Alice, Bob);
519 357
520 358 /* At first try all stuff while in invalid state */
521 /* 359 ck_assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_PAUSE, NULL));
522 * Call and cancel 360 ck_assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_RESUME, NULL));
523 */ 361 ck_assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_MUTE_AUDIO, NULL));
524 { 362 ck_assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_UNMUTE_AUDIO, NULL));
525 int step = 0; 363 ck_assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_HIDE_VIDEO, NULL));
526 int running = 1; 364 ck_assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_SHOW_VIDEO, NULL));
527 365
528 while (running) { 366 {
529 tox_iterate(bootstrap_node); 367 TOXAV_ERR_ANSWER rc;
530 tox_iterate(Alice); 368 toxav_answer(BobAV, 0, 48, 4000, &rc);
531 tox_iterate(Bob); 369
532 370 if (rc != TOXAV_ERR_ANSWER_OK) {
533 toxav_do(status_control.Alice.av); 371 printf("toxav_answer failed: %d\n", rc);
534 toxav_do(status_control.Bob.av); 372 ck_assert(0);
535
536
537 switch ( step ) {
538 case 0: /* Alice */
539 printf("Alice is calling...\n");
540 toxav_call(status_control.Alice.av, &status_control.Alice.call_index, 0, &muhcaps, 10);
541 step++;
542 break;
543
544
545 case 1: /* Alice again */
546 if (status_control.Bob.status == Ringing) {
547 printf("Alice cancels...\n");
548 toxav_cancel(status_control.Alice.av, status_control.Alice.call_index, 0, "Who likes D's anyway?");
549 step++;
550 }
551
552 break;
553
554 case 2: /* Wait for Both to have status ended */
555 if (status_control.Bob.status == Canceled) running = 0;
556
557 break;
558 } 373 }
559
560 c_sleep(20);
561 } 374 }
562 375
563 printf("\n"); 376 iterate_tox(bootstrap, Alice, Bob);
564 } 377
565 378 /* Pause and Resume */
566 /* 379 printf("Pause and Resume\n");
567 * Timeout 380 ck_assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_PAUSE, NULL));
568 */ 381 iterate_tox(bootstrap, Alice, Bob);
569 { 382 ck_assert(BobCC.state == 0);
570 int step = 0; 383 ck_assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_RESUME, NULL));
571 int running = 1; 384 iterate_tox(bootstrap, Alice, Bob);
572 385 ck_assert(BobCC.state & (TOXAV_CALL_STATE_SENDING_A | TOXAV_CALL_STATE_SENDING_V));
573 while (running) { 386
574 tox_iterate(bootstrap_node); 387 /* Mute/Unmute single */
575 tox_iterate(Alice); 388 printf("Mute/Unmute single\n");
576 tox_iterate(Bob); 389 ck_assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_MUTE_AUDIO, NULL));
577 390 iterate_tox(bootstrap, Alice, Bob);
578 toxav_do(status_control.Alice.av); 391 ck_assert(BobCC.state ^ TOXAV_CALL_STATE_RECEIVING_A);
579 toxav_do(status_control.Bob.av); 392 ck_assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_UNMUTE_AUDIO, NULL));
580 393 iterate_tox(bootstrap, Alice, Bob);
581 switch ( step ) { 394 ck_assert(BobCC.state & TOXAV_CALL_STATE_RECEIVING_A);
582 case 0: 395
583 printf("Alice is calling...\n"); 396 /* Mute/Unmute both */
584 toxav_call(status_control.Alice.av, &status_control.Alice.call_index, 0, &muhcaps, 10); 397 printf("Mute/Unmute both\n");
585 step++; 398 ck_assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_MUTE_AUDIO, NULL));
586 break; 399 iterate_tox(bootstrap, Alice, Bob);
587 400 ck_assert(BobCC.state ^ TOXAV_CALL_STATE_RECEIVING_A);
588 case 1: 401 ck_assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_HIDE_VIDEO, NULL));
589 if (status_control.Alice.status == TimedOut) running = 0; 402 iterate_tox(bootstrap, Alice, Bob);
590 403 ck_assert(BobCC.state ^ TOXAV_CALL_STATE_RECEIVING_V);
591 break; 404 ck_assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_UNMUTE_AUDIO, NULL));
405 iterate_tox(bootstrap, Alice, Bob);
406 ck_assert(BobCC.state & TOXAV_CALL_STATE_RECEIVING_A);
407 ck_assert(toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_SHOW_VIDEO, NULL));
408 iterate_tox(bootstrap, Alice, Bob);
409 ck_assert(BobCC.state & TOXAV_CALL_STATE_RECEIVING_V);
410
411 {
412 TOXAV_ERR_CALL_CONTROL rc;
413 toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
414
415 if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
416 printf("toxav_call_control failed: %d\n", rc);
417 ck_assert(0);
592 } 418 }
593
594 c_sleep(20);
595 } 419 }
596 420
597 printf("\n"); 421 iterate_tox(bootstrap, Alice, Bob);
422 ck_assert(BobCC.state == TOXAV_CALL_STATE_FINISHED);
423
424 printf("Success!\n");
598 } 425 }
599 426
600 vpx_img_free(sample_image); 427 toxav_kill(BobAV);
601 toxav_kill(status_control.Alice.av); 428 toxav_kill(AliceAV);
602 toxav_kill(status_control.Bob.av);
603 tox_kill(bootstrap_node);
604 tox_kill(Alice);
605 tox_kill(Bob); 429 tox_kill(Bob);
606 430 tox_kill(Alice);
607 printf("Calls ended!\n"); 431 tox_kill(bootstrap);
432
433 printf("\nTest successful!\n");
608} 434}
609END_TEST 435END_TEST
610 436
611/*************************************************************************************************/
612
613
614/*************************************************************************************************/
615
616/*************************************************************************************************/
617
618 437
619Suite *tox_suite(void) 438Suite *tox_suite(void)
620{ 439{
621 Suite *s = suite_create("ToxAV"); 440 Suite *s = suite_create("ToxAV");
622 441
623 DEFTESTCASE_SLOW(AV_flows, 200); 442 DEFTESTCASE_SLOW(AV_flows, 200);
624
625 return s; 443 return s;
626} 444}
627int main(int argc, char *argv[]) 445int main(int argc, char *argv[])
628{ 446{
447 (void) argc;
448 (void) argv;
449
629 Suite *tox = tox_suite(); 450 Suite *tox = tox_suite();
630 SRunner *test_runner = srunner_create(tox); 451 SRunner *test_runner = srunner_create(tox);
631 452
@@ -637,6 +458,4 @@ int main(int argc, char *argv[])
637 srunner_free(test_runner); 458 srunner_free(test_runner);
638 459
639 return number_failed; 460 return number_failed;
640
641// return test_AV_flows();
642} 461}
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-13 19:45:07 +0000