Asterisk - The Open Source Telephony Project GIT-master-7e7a603
Functions | Variables
test_format_cap.c File Reference

Format Capabilities API Unit Tests. More...

#include "asterisk.h"
#include "asterisk/test.h"
#include "asterisk/module.h"
#include "asterisk/codec.h"
#include "asterisk/frame.h"
#include "asterisk/format.h"
#include "asterisk/format_cap.h"
Include dependency graph for test_format_cap.c:

Go to the source code of this file.

Functions

static void __reg_module (void)
 
static void __unreg_module (void)
 
struct ast_module * AST_MODULE_SELF_SYM (void)
 
 AST_TEST_DEFINE (format_cap_alloc)
 
 AST_TEST_DEFINE (format_cap_append_all_audio)
 
 AST_TEST_DEFINE (format_cap_append_all_unknown)
 
 AST_TEST_DEFINE (format_cap_append_duplicate)
 
 AST_TEST_DEFINE (format_cap_append_from_cap)
 
 AST_TEST_DEFINE (format_cap_append_from_cap_duplicate)
 
 AST_TEST_DEFINE (format_cap_append_multiple)
 
 AST_TEST_DEFINE (format_cap_append_single)
 
 AST_TEST_DEFINE (format_cap_best_by_type)
 
 AST_TEST_DEFINE (format_cap_get_compatible)
 
 AST_TEST_DEFINE (format_cap_get_compatible_format)
 
 AST_TEST_DEFINE (format_cap_get_names)
 
 AST_TEST_DEFINE (format_cap_iscompatible)
 
 AST_TEST_DEFINE (format_cap_iscompatible_format)
 
 AST_TEST_DEFINE (format_cap_remove_all)
 
 AST_TEST_DEFINE (format_cap_remove_bytype)
 
 AST_TEST_DEFINE (format_cap_remove_multiple)
 
 AST_TEST_DEFINE (format_cap_remove_single)
 
 AST_TEST_DEFINE (format_cap_replace_from_cap)
 
 AST_TEST_DEFINE (format_cap_set_framing)
 
static int load_module (void)
 
static int test_law_clone (const struct ast_format *src, struct ast_format *dst)
 
static enum ast_format_cmp_res test_law_cmp (const struct ast_format *format1, const struct ast_format *format2)
 
static void test_law_destroy (struct ast_format *format)
 
static int test_law_length (unsigned int samples)
 
static int test_law_samples (struct ast_frame *frame)
 
static int unload_module (void)
 

Variables

static struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Format capabilities API test module" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }
 
static const struct ast_module_info * ast_module_info = &__mod_info
 
static struct ast_codec test_law
 
static struct ast_format_interface test_law_interface
 

Detailed Description

Format Capabilities API Unit Tests.

Author
Joshua Colp jcolp.nosp@m.@dig.nosp@m.ium.c.nosp@m.om

Definition in file test_format_cap.c.

Function Documentation

◆ __reg_module()

static void __reg_module ( void  )
static

Definition at line 1477 of file test_format_cap.c.

◆ __unreg_module()

static void __unreg_module ( void  )
static

Definition at line 1477 of file test_format_cap.c.

◆ AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM ( void  )

Definition at line 1477 of file test_format_cap.c.

◆ AST_TEST_DEFINE() [1/20]

AST_TEST_DEFINE ( format_cap_alloc  )

Definition at line 41 of file test_format_cap.c.

42{
43 struct ast_format_cap *caps;
44
45 switch (cmd) {
46 case TEST_INIT:
47 info->name = "format_cap_alloc";
48 info->category = "/main/format_cap/";
49 info->summary = "format capabilities allocation unit test";
50 info->description =
51 "Test that allocation of a format capabilities structure succeeds";
52 return AST_TEST_NOT_RUN;
53 case TEST_EXECUTE:
54 break;
55 }
56
57 caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
58 if (!caps) {
59 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
60 return AST_TEST_FAIL;
61 }
62 ao2_ref(caps, -1);
63
64 return AST_TEST_PASS;
65}
ao2_ref
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
Definition: astobj2.h:459
AST_FORMAT_CAP_FLAG_DEFAULT
@ AST_FORMAT_CAP_FLAG_DEFAULT
Definition: format_cap.h:38
ast_format_cap_alloc
#define ast_format_cap_alloc(flags)
Allocate a new ast_format_cap structure.
Definition: format_cap.h:49
sip_to_pjsip.info
def info(msg)
Definition: sip_to_pjsip.py:1313
ast_format_cap
Format capabilities structure, holds formats + preference order + etc.
Definition: format_cap.c:54
TEST_INIT
@ TEST_INIT
Definition: test.h:200
TEST_EXECUTE
@ TEST_EXECUTE
Definition: test.h:201
ast_test_status_update
#define ast_test_status_update(a, b, c...)
Definition: test.h:129
AST_TEST_PASS
@ AST_TEST_PASS
Definition: test.h:195
AST_TEST_FAIL
@ AST_TEST_FAIL
Definition: test.h:196
AST_TEST_NOT_RUN
@ AST_TEST_NOT_RUN
Definition: test.h:194

References ao2_ref, ast_format_cap_alloc, AST_FORMAT_CAP_FLAG_DEFAULT, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), TEST_EXECUTE, and TEST_INIT.

◆ AST_TEST_DEFINE() [2/20]

AST_TEST_DEFINE ( format_cap_append_all_audio  )

Definition at line 254 of file test_format_cap.c.

255{
256 RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
257
258 switch (cmd) {
259 case TEST_INIT:
260 info->name = __PRETTY_FUNCTION__;
261 info->category = "/main/format_cap/";
262 info->summary = "format capabilities adding unit test";
263 info->description =
264 "Test that adding of all audio formats to a format capabilities structure succeeds";
265 return AST_TEST_NOT_RUN;
266 case TEST_EXECUTE:
267 break;
268 }
269
270 caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
271 if (!caps) {
272 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
273 return AST_TEST_FAIL;
274 } else if (ast_format_cap_append_by_type(caps, AST_MEDIA_TYPE_AUDIO)) {
275 ast_test_status_update(test, "Failed to add all audio media formats to capabilities structure\n");
276 return AST_TEST_FAIL;
277 } else if (!ast_format_cap_has_type(caps, AST_MEDIA_TYPE_AUDIO)) {
278 ast_test_status_update(test, "Added audio media formats but no audio formats exist when they should\n");
279 return AST_TEST_FAIL;
280 } else if (ast_format_cap_has_type(caps, AST_MEDIA_TYPE_VIDEO)) {
281 ast_test_status_update(test, "Added only audio media formats but video formats exist when they should not\n");
282 return AST_TEST_FAIL;
283 } else if (ast_format_cap_has_type(caps, AST_MEDIA_TYPE_TEXT)) {
284 ast_test_status_update(test, "Added only audio media formats but text formats exist when they should not\n");
285 return AST_TEST_FAIL;
286 } else if (ast_format_cap_has_type(caps, AST_MEDIA_TYPE_IMAGE)) {
287 ast_test_status_update(test, "Added only audio media formats but image formats exist when they should not\n");
288 return AST_TEST_FAIL;
289 }
290
291 return AST_TEST_PASS;
292}
ao2_cleanup
#define ao2_cleanup(obj)
Definition: astobj2.h:1934
AST_MEDIA_TYPE_AUDIO
@ AST_MEDIA_TYPE_AUDIO
Definition: codec.h:32
AST_MEDIA_TYPE_VIDEO
@ AST_MEDIA_TYPE_VIDEO
Definition: codec.h:33
AST_MEDIA_TYPE_IMAGE
@ AST_MEDIA_TYPE_IMAGE
Definition: codec.h:34
AST_MEDIA_TYPE_TEXT
@ AST_MEDIA_TYPE_TEXT
Definition: codec.h:35
ast_format_cap_append_by_type
int ast_format_cap_append_by_type(struct ast_format_cap *cap, enum ast_media_type type)
Add all codecs Asterisk knows about for a specific type to the capabilities structure.
Definition: format_cap.c:216
ast_format_cap_has_type
int ast_format_cap_has_type(const struct ast_format_cap *cap, enum ast_media_type type)
Find out if the capabilities structure has any formats of a specific type.
Definition: format_cap.c:613
NULL
#define NULL
Definition: resample.c:96
RAII_VAR
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
Definition: utils.h:941

References ao2_cleanup, ast_format_cap_alloc, ast_format_cap_append_by_type(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_has_type(), AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_IMAGE, AST_MEDIA_TYPE_TEXT, AST_MEDIA_TYPE_VIDEO, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

◆ AST_TEST_DEFINE() [3/20]

AST_TEST_DEFINE ( format_cap_append_all_unknown  )

Definition at line 217 of file test_format_cap.c.

218{
219 RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
220
221 switch (cmd) {
222 case TEST_INIT:
223 info->name = __PRETTY_FUNCTION__;
224 info->category = "/main/format_cap/";
225 info->summary = "format capabilities adding unit test";
226 info->description =
227 "Test that adding of all formats to a format capabilities structure succeeds";
228 return AST_TEST_NOT_RUN;
229 case TEST_EXECUTE:
230 break;
231 }
232
233 caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
234 if (!caps) {
235 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
236 return AST_TEST_FAIL;
237 } else if (ast_format_cap_append_by_type(caps, AST_MEDIA_TYPE_UNKNOWN)) {
238 ast_test_status_update(test, "Failed to add all media formats of all types to capabilities structure\n");
239 return AST_TEST_FAIL;
240 } else if (!ast_format_cap_has_type(caps, AST_MEDIA_TYPE_AUDIO)) {
241 ast_test_status_update(test, "Added all media formats but no audio formats exist when they should\n");
242 return AST_TEST_FAIL;
243 } else if (!ast_format_cap_has_type(caps, AST_MEDIA_TYPE_VIDEO)) {
244 ast_test_status_update(test, "Added all media formats but no video formats exist when they should\n");
245 return AST_TEST_FAIL;
246 } else if ((ast_format_cap_count(caps) + 1) != (ast_codec_get_max() - 1)) {
247 ast_test_status_update(test, "The number of formats in the capabilities structure does not match known number\n");
248 return AST_TEST_FAIL;
249 }
250
251 return AST_TEST_PASS;
252}
AST_MEDIA_TYPE_UNKNOWN
@ AST_MEDIA_TYPE_UNKNOWN
Definition: codec.h:31
ast_codec_get_max
int ast_codec_get_max(void)
Retrieve the current maximum identifier for codec iteration.
Definition: codec.c:343
ast_format_cap_count
size_t ast_format_cap_count(const struct ast_format_cap *cap)
Get the number of formats present within the capabilities structure.
Definition: format_cap.c:395

References ao2_cleanup, ast_codec_get_max(), ast_format_cap_alloc, ast_format_cap_append_by_type(), ast_format_cap_count(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_has_type(), AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_UNKNOWN, AST_MEDIA_TYPE_VIDEO, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

◆ AST_TEST_DEFINE() [4/20]

AST_TEST_DEFINE ( format_cap_append_duplicate  )

Definition at line 294 of file test_format_cap.c.

295{
296 RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
297 RAII_VAR(struct ast_codec *, codec, NULL, ao2_cleanup);
298 RAII_VAR(struct ast_format *, format, NULL, ao2_cleanup);
299 RAII_VAR(struct ast_format *, format_named, NULL, ao2_cleanup);
300 RAII_VAR(struct ast_format *, retrieved, NULL, ao2_cleanup);
301
302 switch (cmd) {
303 case TEST_INIT:
304 info->name = __PRETTY_FUNCTION__;
305 info->category = "/main/format_cap/";
306 info->summary = "format capabilities duplication unit test";
307 info->description =
308 "Test that adding a single format multiple times to a capabilities structure results in only a single format";
309 return AST_TEST_NOT_RUN;
310 case TEST_EXECUTE:
311 break;
312 }
313
314 caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
315 if (!caps) {
316 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
317 return AST_TEST_FAIL;
318 }
319
320 codec = ast_codec_get("ulaw", AST_MEDIA_TYPE_AUDIO, 8000);
321 if (!codec) {
322 ast_test_status_update(test, "Could not retrieve built-in ulaw codec\n");
323 return AST_TEST_FAIL;
324 }
325
326 format = ast_format_create(codec);
327 if (!format) {
328 ast_test_status_update(test, "Could not create format using built-in codec\n");
329 return AST_TEST_FAIL;
330 }
331
332 format_named = ast_format_create_named("ulaw@20", codec);
333 if (!format_named) {
334 ast_test_status_update(test, "Could not create named format using built-in codec\n");
335 return AST_TEST_FAIL;
336 }
337
338 if (ast_format_cap_append(caps, format, 42)) {
339 ast_test_status_update(test, "Could not add newly created format to capabilities structure\n");
340 return AST_TEST_FAIL;
341 } else if (ast_format_cap_count(caps) != 1) {
342 ast_test_status_update(test, "Number of formats in capabilities structure should be 1 but is %zu\n",
343 ast_format_cap_count(caps));
344 return AST_TEST_FAIL;
345 }
346
347 /* Note: regardless of it being a duplicate, ast_format_cap_append should return success */
348 if (ast_format_cap_append(caps, format, 0)) {
349 ast_test_status_update(test, "Adding of duplicate format to capabilities structure failed\n");
350 return AST_TEST_FAIL;
351 } else if (ast_format_cap_count(caps) != 1) {
352 ast_test_status_update(test, "Number of formats in capabilities structure should be 1 but is %zu\n",
353 ast_format_cap_count(caps));
354 return AST_TEST_FAIL;
355 }
356
357 if (ast_format_cap_append(caps, format_named, 0)) {
358 ast_test_status_update(test, "Adding of duplicate named format to capabilities structure failed\n");
359 return AST_TEST_FAIL;
360 } else if (ast_format_cap_count(caps) != 1) {
361 ast_test_status_update(test, "Number of formats in capabilities structure should be 1 but is %zu\n",
362 ast_format_cap_count(caps));
363 return AST_TEST_FAIL;
364 }
365
366 retrieved = ast_format_cap_get_format(caps, 0);
367 if (!retrieved) {
368 ast_test_status_update(test, "Attempted to get single format from capabilities structure but got nothing\n");
369 return AST_TEST_FAIL;
370 } else if (retrieved != format) {
371 ast_test_status_update(test, "Retrieved format is not the same as the one we added\n");
372 return AST_TEST_FAIL;
373 } else if (ast_format_cap_get_format_framing(caps, retrieved) != 42) {
374 ast_test_status_update(test, "Framing for format in capabilities structure does not match what we provided\n");
375 return AST_TEST_FAIL;
376 }
377
378 return AST_TEST_PASS;
379}
ast_codec_get
struct ast_codec * ast_codec_get(const char *name, enum ast_media_type type, unsigned int sample_rate)
Retrieve a codec given a name, type, and sample rate.
Definition: codec.c:327
ast_format_create_named
struct ast_format * ast_format_create_named(const char *format_name, struct ast_codec *codec)
Create a new media format with a specific name.
Definition: format.c:157
ast_format_create
struct ast_format * ast_format_create(struct ast_codec *codec)
Create a new media format.
Definition: format.c:196
ast_format_cap_get_format
struct ast_format * ast_format_cap_get_format(const struct ast_format_cap *cap, int position)
Get the format at a specific index.
Definition: format_cap.c:400
ast_format_cap_get_format_framing
unsigned int ast_format_cap_get_format_framing(const struct ast_format_cap *cap, const struct ast_format *format)
Get the framing for a format.
Definition: format_cap.c:443
ast_format_cap_append
#define ast_format_cap_append(cap, format, framing)
Add format capability to capabilities structure.
Definition: format_cap.h:99
ast_codec
Represents a media codec within Asterisk.
Definition: codec.h:42
ast_format
Definition of a media format.
Definition: format.c:43

References ao2_cleanup, ast_codec_get(), ast_format_cap_alloc, ast_format_cap_append, ast_format_cap_count(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_format(), ast_format_cap_get_format_framing(), ast_format_create(), ast_format_create_named(), AST_MEDIA_TYPE_AUDIO, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

◆ AST_TEST_DEFINE() [5/20]

AST_TEST_DEFINE ( format_cap_append_from_cap  )

Definition at line 381 of file test_format_cap.c.

382{
383 RAII_VAR(struct ast_format_cap *, dst_caps, NULL, ao2_cleanup);
384 RAII_VAR(struct ast_format_cap *, src_caps, NULL, ao2_cleanup);
385
386 switch (cmd) {
387 case TEST_INIT:
388 info->name = __PRETTY_FUNCTION__;
389 info->category = "/main/format_cap/";
390 info->summary = "format capabilities append unit test";
391 info->description =
392 "Test that appending video formats from one capabilities structure to another succeeds";
393 return AST_TEST_NOT_RUN;
394 case TEST_EXECUTE:
395 break;
396 }
397
398 dst_caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
399 if (!dst_caps) {
400 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
401 return AST_TEST_FAIL;
402 } else if (ast_format_cap_append_by_type(dst_caps, AST_MEDIA_TYPE_AUDIO)) {
403 ast_test_status_update(test, "Failed to add all audio media formats to capabilities structure\n");
404 return AST_TEST_FAIL;
405 }
406
407 src_caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
408 if (!src_caps) {
409 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
410 return AST_TEST_FAIL;
411 } else if (ast_format_cap_append_by_type(src_caps, AST_MEDIA_TYPE_VIDEO)) {
412 ast_test_status_update(test, "Failed to add all video media formats to capabilities structure\n");
413 return AST_TEST_FAIL;
414 }
415
416 if (ast_format_cap_append_from_cap(dst_caps, src_caps, AST_MEDIA_TYPE_UNKNOWN)) {
417 ast_test_status_update(test, "Failed to append formats to capabilities structure\n");
418 return AST_TEST_FAIL;
419 } else if (!ast_format_cap_has_type(dst_caps, AST_MEDIA_TYPE_AUDIO)) {
420 ast_test_status_update(test, "Successfully appended video formats to destination capabilities but it no longer contains audio formats\n");
421 return AST_TEST_FAIL;
422 } else if (!ast_format_cap_has_type(dst_caps, AST_MEDIA_TYPE_VIDEO)) {
423 ast_test_status_update(test, "Successfully appended formats but video formats do not exist in destination capabilities\n");
424 return AST_TEST_FAIL;
425 }
426
427 return AST_TEST_PASS;
428}
ast_format_cap_append_from_cap
int ast_format_cap_append_from_cap(struct ast_format_cap *dst, const struct ast_format_cap *src, enum ast_media_type type)
Append the formats of provided type in src to dst.
Definition: format_cap.c:269

References ao2_cleanup, ast_format_cap_alloc, ast_format_cap_append_by_type(), ast_format_cap_append_from_cap(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_has_type(), AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_UNKNOWN, AST_MEDIA_TYPE_VIDEO, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

◆ AST_TEST_DEFINE() [6/20]

AST_TEST_DEFINE ( format_cap_append_from_cap_duplicate  )

Definition at line 430 of file test_format_cap.c.

431{
432 RAII_VAR(struct ast_format_cap *, dst_caps, NULL, ao2_cleanup);
433 RAII_VAR(struct ast_format_cap *, src_caps, NULL, ao2_cleanup);
434 unsigned int count;
435 unsigned int total_count;
436
437 switch (cmd) {
438 case TEST_INIT:
439 info->name = __PRETTY_FUNCTION__;
440 info->category = "/main/format_cap/";
441 info->summary = "format capabilities append duplicate unit test";
442 info->description =
443 "Test that appending capabilities structures multiple times does not result in duplicate formats";
444 return AST_TEST_NOT_RUN;
445 case TEST_EXECUTE:
446 break;
447 }
448
449 dst_caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
450 if (!dst_caps) {
451 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
452 return AST_TEST_FAIL;
453 } else if (ast_format_cap_append_by_type(dst_caps, AST_MEDIA_TYPE_AUDIO)) {
454 ast_test_status_update(test, "Failed to add all audio media formats to capabilities structure\n");
455 return AST_TEST_FAIL;
456 }
457
458 src_caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
459 if (!src_caps) {
460 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
461 return AST_TEST_FAIL;
462 } else if (ast_format_cap_append_by_type(src_caps, AST_MEDIA_TYPE_VIDEO)) {
463 ast_test_status_update(test, "Failed to add all video media formats to capabilities structure\n");
464 return AST_TEST_FAIL;
465 }
466
467 total_count = ast_format_cap_count(src_caps) + ast_format_cap_count(dst_caps);
468
469 if (ast_format_cap_append_from_cap(dst_caps, src_caps, AST_MEDIA_TYPE_UNKNOWN)) {
470 ast_test_status_update(test, "Failed to append formats to capabilities structure\n");
471 return AST_TEST_FAIL;
472 } else if (!ast_format_cap_has_type(dst_caps, AST_MEDIA_TYPE_AUDIO)) {
473 ast_test_status_update(test, "Successfully appended video formats to destination capabilities but it no longer contains audio formats\n");
474 return AST_TEST_FAIL;
475 } else if (!ast_format_cap_has_type(dst_caps, AST_MEDIA_TYPE_VIDEO)) {
476 ast_test_status_update(test, "Successfully appended formats but video formats do not exist in destination capabilities\n");
477 return AST_TEST_FAIL;
478 }
479
480 count = ast_format_cap_count(dst_caps);
481
482 if (ast_format_cap_append_from_cap(dst_caps, src_caps, AST_MEDIA_TYPE_UNKNOWN)) {
483 ast_test_status_update(test, "Failed to append duplicate formats to capabilities structure\n");
484 return AST_TEST_FAIL;
485 }
486
487 ast_test_validate(test, count == ast_format_cap_count(dst_caps));
488 ast_test_validate(test, count == total_count);
489
490 return AST_TEST_PASS;
491}

References ao2_cleanup, ast_format_cap_alloc, ast_format_cap_append_by_type(), ast_format_cap_append_from_cap(), ast_format_cap_count(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_has_type(), AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_UNKNOWN, AST_MEDIA_TYPE_VIDEO, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

◆ AST_TEST_DEFINE() [7/20]

AST_TEST_DEFINE ( format_cap_append_multiple  )

Definition at line 128 of file test_format_cap.c.

129{
130 RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
131 RAII_VAR(struct ast_codec *, ulaw, NULL, ao2_cleanup);
132 RAII_VAR(struct ast_format *, ulaw_format, NULL, ao2_cleanup);
133 RAII_VAR(struct ast_codec *, alaw, NULL, ao2_cleanup);
134 RAII_VAR(struct ast_format *, alaw_format, NULL, ao2_cleanup);
135 RAII_VAR(struct ast_format *, retrieved, NULL, ao2_cleanup);
136
137 switch (cmd) {
138 case TEST_INIT:
139 info->name = __PRETTY_FUNCTION__;
140 info->category = "/main/format_cap/";
141 info->summary = "format capabilities adding unit test";
142 info->description =
143 "Test that adding multiple formats to a format capabilities structure succeeds";
144 return AST_TEST_NOT_RUN;
145 case TEST_EXECUTE:
146 break;
147 }
148
149 caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
150 if (!caps) {
151 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
152 return AST_TEST_FAIL;
153 }
154
155 ulaw = ast_codec_get("ulaw", AST_MEDIA_TYPE_AUDIO, 8000);
156 if (!ulaw) {
157 ast_test_status_update(test, "Could not retrieve built-in ulaw codec\n");
158 return AST_TEST_FAIL;
159 }
160
161 ulaw_format = ast_format_create(ulaw);
162 if (!ulaw_format) {
163 ast_test_status_update(test, "Could not create ulaw format using built-in codec\n");
164 return AST_TEST_FAIL;
165 }
166
167 alaw = ast_codec_get("alaw", AST_MEDIA_TYPE_AUDIO, 8000);
168 if (!alaw) {
169 ast_test_status_update(test, "Could not retrieve built-in alaw codec\n");
170 return AST_TEST_FAIL;
171 }
172
173 alaw_format = ast_format_create(alaw);
174 if (!alaw_format) {
175 ast_test_status_update(test, "Could not create alaw format using built-in codec\n");
176 return AST_TEST_FAIL;
177 }
178
179 if (ast_format_cap_append(caps, ulaw_format, 42)) {
180 ast_test_status_update(test, "Could not add newly created ulaw format to capabilities structure\n");
181 return AST_TEST_FAIL;
182 } else if (ast_format_cap_append(caps, alaw_format, 84)) {
183 ast_test_status_update(test, "Could not add newly created alaw format to capabilities structure\n");
184 return AST_TEST_FAIL;
185 } else if (ast_format_cap_count(caps) != 2) {
186 ast_test_status_update(test, "Number of formats in capabilities structure should be 2 but is %zu\n",
187 ast_format_cap_count(caps));
188 return AST_TEST_FAIL;
189 }
190
191 retrieved = ast_format_cap_get_format(caps, 0);
192 if (!retrieved) {
193 ast_test_status_update(test, "Attempted to get first format from capabilities structure but got nothing\n");
194 return AST_TEST_FAIL;
195 } else if (retrieved != ulaw_format) {
196 ast_test_status_update(test, "First retrieved format is not the ulaw one we added\n");
197 return AST_TEST_FAIL;
198 } else if (ast_format_cap_get_format_framing(caps, retrieved) != 42) {
199 ast_test_status_update(test, "Framing for ulaw format in capabilities structure does not match what we provided\n");
200 }
201 ao2_ref(retrieved, -1);
202
203 retrieved = ast_format_cap_get_format(caps, 1);
204 if (!retrieved) {
205 ast_test_status_update(test, "Attempted to get second format from capabilities structure but got nothing\n");
206 return AST_TEST_FAIL;
207 } else if (retrieved != alaw_format) {
208 ast_test_status_update(test, "First retrieved format is not the alaw one we added\n");
209 return AST_TEST_FAIL;
210 } else if (ast_format_cap_get_format_framing(caps, retrieved) != 84) {
211 ast_test_status_update(test, "Framing for alaw format in capabilities structure does not match what we provided\n");
212 }
213
214 return AST_TEST_PASS;
215}
ulaw
static struct ast_codec ulaw
Definition: codec_builtin.c:167
alaw
static struct ast_codec alaw
Definition: codec_builtin.c:182

References alaw, ao2_cleanup, ao2_ref, ast_codec_get(), ast_format_cap_alloc, ast_format_cap_append, ast_format_cap_count(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_format(), ast_format_cap_get_format_framing(), ast_format_create(), AST_MEDIA_TYPE_AUDIO, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_EXECUTE, TEST_INIT, and ulaw.

◆ AST_TEST_DEFINE() [8/20]

AST_TEST_DEFINE ( format_cap_append_single  )

Definition at line 67 of file test_format_cap.c.

68{
69 RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
70 RAII_VAR(struct ast_codec *, codec, NULL, ao2_cleanup);
71 RAII_VAR(struct ast_format *, format, NULL, ao2_cleanup);
72 RAII_VAR(struct ast_format *, retrieved, NULL, ao2_cleanup);
73
74 switch (cmd) {
75 case TEST_INIT:
76 info->name = __PRETTY_FUNCTION__;
77 info->category = "/main/format_cap/";
78 info->summary = "format capabilities adding unit test";
79 info->description =
80 "Test that adding a single format to a format capabilities structure succeeds";
81 return AST_TEST_NOT_RUN;
82 case TEST_EXECUTE:
83 break;
84 }
85
86 caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
87 if (!caps) {
88 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
89 return AST_TEST_FAIL;
90 }
91
92 codec = ast_codec_get("ulaw", AST_MEDIA_TYPE_AUDIO, 8000);
93 if (!codec) {
94 ast_test_status_update(test, "Could not retrieve built-in ulaw codec\n");
95 return AST_TEST_FAIL;
96 }
97
98 format = ast_format_create(codec);
99 if (!format) {
100 ast_test_status_update(test, "Could not create format using built-in codec\n");
101 return AST_TEST_FAIL;
102 }
103
104 if (ast_format_cap_append(caps, format, 42)) {
105 ast_test_status_update(test, "Could not add newly created format to capabilities structure\n");
106 return AST_TEST_FAIL;
107 } else if (ast_format_cap_count(caps) != 1) {
108 ast_test_status_update(test, "Number of formats in capabilities structure should be 1 but is %zu\n",
109 ast_format_cap_count(caps));
110 return AST_TEST_FAIL;
111 }
112
113 retrieved = ast_format_cap_get_format(caps, 0);
114 if (!retrieved) {
115 ast_test_status_update(test, "Attempted to get single format from capabilities structure but got nothing\n");
116 return AST_TEST_FAIL;
117 } else if (retrieved != format) {
118 ast_test_status_update(test, "Retrieved format is not the same as the one we added\n");
119 return AST_TEST_FAIL;
120 } else if (ast_format_cap_get_format_framing(caps, retrieved) != 42) {
121 ast_test_status_update(test, "Framing for format in capabilities structure does not match what we provided\n");
122 return AST_TEST_FAIL;
123 }
124
125 return AST_TEST_PASS;
126}

References ao2_cleanup, ast_codec_get(), ast_format_cap_alloc, ast_format_cap_append, ast_format_cap_count(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_format(), ast_format_cap_get_format_framing(), ast_format_create(), AST_MEDIA_TYPE_AUDIO, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

◆ AST_TEST_DEFINE() [9/20]

AST_TEST_DEFINE ( format_cap_best_by_type  )

Definition at line 1170 of file test_format_cap.c.

1171{
1172 RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
1173 RAII_VAR(struct ast_codec *, ulaw, NULL, ao2_cleanup);
1174 RAII_VAR(struct ast_format *, ulaw_format, NULL, ao2_cleanup);
1175 RAII_VAR(struct ast_codec *, alaw, NULL, ao2_cleanup);
1176 RAII_VAR(struct ast_format *, alaw_format, NULL, ao2_cleanup);
1177 RAII_VAR(struct ast_codec *, h263, NULL, ao2_cleanup);
1178 RAII_VAR(struct ast_format *, h263_format, NULL, ao2_cleanup);
1179 RAII_VAR(struct ast_format *, best_format, NULL, ao2_cleanup);
1180
1181 switch (cmd) {
1182 case TEST_INIT:
1183 info->name = __PRETTY_FUNCTION__;
1184 info->category = "/main/format_cap/";
1185 info->summary = "format capabilities best by type unit test";
1186 info->description =
1187 "Test that we can get the best format type out of a capabilities structure";
1188 return AST_TEST_NOT_RUN;
1189 case TEST_EXECUTE:
1190 break;
1191 }
1192
1193 caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
1194 if (!caps) {
1195 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
1196 return AST_TEST_FAIL;
1197 }
1198
1199 ulaw = ast_codec_get("ulaw", AST_MEDIA_TYPE_AUDIO, 8000);
1200 if (!ulaw) {
1201 ast_test_status_update(test, "Could not retrieve built-in ulaw codec\n");
1202 return AST_TEST_FAIL;
1203 }
1204
1205 ulaw_format = ast_format_create(ulaw);
1206 if (!ulaw_format) {
1207 ast_test_status_update(test, "Could not create ulaw format using built-in codec\n");
1208 return AST_TEST_FAIL;
1209 }
1210
1211 alaw = ast_codec_get("alaw", AST_MEDIA_TYPE_AUDIO, 8000);
1212 if (!alaw) {
1213 ast_test_status_update(test, "Could not retrieve built-in alaw codec\n");
1214 return AST_TEST_FAIL;
1215 }
1216
1217 alaw_format = ast_format_create(alaw);
1218 if (!alaw_format) {
1219 ast_test_status_update(test, "Could not create alaw format using built-in codec\n");
1220 return AST_TEST_FAIL;
1221 }
1222
1223 h263 = ast_codec_get("h263", AST_MEDIA_TYPE_VIDEO, 0);
1224 if (!h263) {
1225 ast_test_status_update(test, "Could not retrieve built-in h263 codec\n");
1226 return AST_TEST_FAIL;
1227 }
1228
1229 h263_format = ast_format_create(h263);
1230 if (!alaw_format) {
1231 ast_test_status_update(test, "Could not create h263 format using built-in codec\n");
1232 return AST_TEST_FAIL;
1233 }
1234
1235 if (ast_format_cap_append(caps, ulaw_format, 0)) {
1236 ast_test_status_update(test, "Could not add ulaw format to capabilities\n");
1237 return AST_TEST_FAIL;
1238 } else if (ast_format_cap_append(caps, alaw_format, 0)) {
1239 ast_test_status_update(test, "Could not add alaw format to capabilities\n");
1240 return AST_TEST_FAIL;
1241 } else if (ast_format_cap_append(caps, h263_format, 0)) {
1242 ast_test_status_update(test, "Could not add h263 format to capabilities\n");
1243 return AST_TEST_FAIL;
1244 }
1245
1246 best_format = ast_format_cap_get_best_by_type(caps, AST_MEDIA_TYPE_UNKNOWN);
1247 ast_test_validate(test, ast_format_cmp(best_format, ulaw_format) == AST_FORMAT_CMP_EQUAL);
1248 ao2_ref(best_format, -1);
1249
1250 best_format = ast_format_cap_get_best_by_type(caps, AST_MEDIA_TYPE_AUDIO);
1251 ast_test_validate(test, ast_format_cmp(best_format, ulaw_format) == AST_FORMAT_CMP_EQUAL);
1252 ao2_ref(best_format, -1);
1253
1254 best_format = ast_format_cap_get_best_by_type(caps, AST_MEDIA_TYPE_VIDEO);
1255 ast_test_validate(test, ast_format_cmp(best_format, h263_format) == AST_FORMAT_CMP_EQUAL);
1256 ao2_ref(best_format, -1);
1257
1258 best_format = ast_format_cap_get_best_by_type(caps, AST_MEDIA_TYPE_IMAGE);
1259 ast_test_validate(test, best_format == NULL);
1260
1261 best_format = ast_format_cap_get_best_by_type(caps, AST_MEDIA_TYPE_TEXT);
1262 ast_test_validate(test, best_format == NULL);
1263
1264 return AST_TEST_PASS;
1265}
h263
static struct ast_codec h263
Definition: codec_builtin.c:802
ast_format_cmp
enum ast_format_cmp_res ast_format_cmp(const struct ast_format *format1, const struct ast_format *format2)
Compare two formats.
Definition: format.c:201
AST_FORMAT_CMP_EQUAL
@ AST_FORMAT_CMP_EQUAL
Definition: format.h:36
ast_format_cap_get_best_by_type
struct ast_format * ast_format_cap_get_best_by_type(const struct ast_format_cap *cap, enum ast_media_type type)
Get the most preferred format for a particular media type.
Definition: format_cap.c:417

References alaw, ao2_cleanup, ao2_ref, ast_codec_get(), ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_best_by_type(), ast_format_cmp(), AST_FORMAT_CMP_EQUAL, ast_format_create(), AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_IMAGE, AST_MEDIA_TYPE_TEXT, AST_MEDIA_TYPE_UNKNOWN, AST_MEDIA_TYPE_VIDEO, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, h263, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_EXECUTE, TEST_INIT, and ulaw.

◆ AST_TEST_DEFINE() [10/20]

AST_TEST_DEFINE ( format_cap_get_compatible  )

Definition at line 909 of file test_format_cap.c.

910{
911 RAII_VAR(struct ast_format_cap *, alaw_caps, NULL, ao2_cleanup);
912 RAII_VAR(struct ast_format_cap *, ulaw_caps, NULL, ao2_cleanup);
913 RAII_VAR(struct ast_format_cap *, compatible_caps, NULL, ao2_cleanup);
914 RAII_VAR(struct ast_codec *, ulaw, NULL, ao2_cleanup);
915 RAII_VAR(struct ast_format *, ulaw_format, NULL, ao2_cleanup);
916 RAII_VAR(struct ast_codec *, alaw, NULL, ao2_cleanup);
917 RAII_VAR(struct ast_format *, alaw_format, NULL, ao2_cleanup);
918
919 switch (cmd) {
920 case TEST_INIT:
921 info->name = "format_cap_get_compatible";
922 info->category = "/main/format_cap/";
923 info->summary = "format capabilities negotiation unit test";
924 info->description =
925 "Test that getting the compatible formats between two capabilities structures succeeds";
926 return AST_TEST_NOT_RUN;
927 case TEST_EXECUTE:
928 break;
929 }
930
931 alaw_caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
932 if (!alaw_caps) {
933 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
934 return AST_TEST_FAIL;
935 }
936
937 ulaw_caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
938 if (!ulaw_caps) {
939 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
940 return AST_TEST_FAIL;
941 }
942
943 compatible_caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
944 if (!compatible_caps) {
945 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
946 return AST_TEST_FAIL;
947 }
948
949 ulaw = ast_codec_get("ulaw", AST_MEDIA_TYPE_AUDIO, 8000);
950 if (!ulaw) {
951 ast_test_status_update(test, "Could not retrieve built-in ulaw codec\n");
952 return AST_TEST_FAIL;
953 }
954
955 ulaw_format = ast_format_create(ulaw);
956 if (!ulaw_format) {
957 ast_test_status_update(test, "Could not create ulaw format using built-in codec\n");
958 return AST_TEST_FAIL;
959 }
960
961 alaw = ast_codec_get("alaw", AST_MEDIA_TYPE_AUDIO, 8000);
962 if (!alaw) {
963 ast_test_status_update(test, "Could not retrieve built-in alaw codec\n");
964 return AST_TEST_FAIL;
965 }
966
967 alaw_format = ast_format_create(alaw);
968 if (!alaw_format) {
969 ast_test_status_update(test, "Could not create alaw format using built-in codec\n");
970 return AST_TEST_FAIL;
971 }
972
973 if (ast_format_cap_append(ulaw_caps, ulaw_format, 0)) {
974 ast_test_status_update(test, "Could not add ulaw format to ulaw capabilities\n");
975 return AST_TEST_FAIL;
976 } else if (ast_format_cap_append(alaw_caps, alaw_format, 0)) {
977 ast_test_status_update(test, "Could not add alaw format to alaw capabilities\n");
978 return AST_TEST_FAIL;
979 }
980
981 ast_format_cap_get_compatible(ulaw_caps, alaw_caps, compatible_caps);
982 if (ast_format_cap_count(compatible_caps)) {
983 ast_test_status_update(test, "A compatible format exists when none should\n");
984 return AST_TEST_FAIL;
985 }
986
987 ast_format_cap_get_compatible(ulaw_caps, ulaw_caps, compatible_caps);
988 if (!ast_format_cap_count(compatible_caps)) {
989 ast_test_status_update(test, "No compatible formats exist when 1 should\n");
990 return AST_TEST_FAIL;
991 }
992
993 return AST_TEST_PASS;
994}
ast_format_cap_get_compatible
int ast_format_cap_get_compatible(const struct ast_format_cap *cap1, const struct ast_format_cap *cap2, struct ast_format_cap *result)
Find the compatible formats between two capabilities structures.
Definition: format_cap.c:628

References alaw, ao2_cleanup, ast_codec_get(), ast_format_cap_alloc, ast_format_cap_append, ast_format_cap_count(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_compatible(), ast_format_create(), AST_MEDIA_TYPE_AUDIO, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_EXECUTE, TEST_INIT, and ulaw.

◆ AST_TEST_DEFINE() [11/20]

AST_TEST_DEFINE ( format_cap_get_compatible_format  )

Definition at line 771 of file test_format_cap.c.

772{
773 RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
774 RAII_VAR(struct ast_codec *, ulaw, NULL, ao2_cleanup);
775 RAII_VAR(struct ast_format *, ulaw_format, NULL, ao2_cleanup);
776 RAII_VAR(struct ast_codec *, alaw, NULL, ao2_cleanup);
777 RAII_VAR(struct ast_format *, alaw_format, NULL, ao2_cleanup);
778 RAII_VAR(struct ast_format *, compatible, NULL, ao2_cleanup);
779
780 switch (cmd) {
781 case TEST_INIT:
782 info->name = "format_cap_get_compatible_format";
783 info->category = "/main/format_cap/";
784 info->summary = "format capabilities negotiation unit test";
785 info->description =
786 "Test that getting a compatible format from a capabilities structure succeeds";
787 return AST_TEST_NOT_RUN;
788 case TEST_EXECUTE:
789 break;
790 }
791
792 caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
793 if (!caps) {
794 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
795 return AST_TEST_FAIL;
796 }
797
798 ulaw = ast_codec_get("ulaw", AST_MEDIA_TYPE_AUDIO, 8000);
799 if (!ulaw) {
800 ast_test_status_update(test, "Could not retrieve built-in ulaw codec\n");
801 return AST_TEST_FAIL;
802 }
803
804 ulaw_format = ast_format_create(ulaw);
805 if (!ulaw_format) {
806 ast_test_status_update(test, "Could not create ulaw format using built-in codec\n");
807 return AST_TEST_FAIL;
808 }
809
810 alaw = ast_codec_get("alaw", AST_MEDIA_TYPE_AUDIO, 8000);
811 if (!alaw) {
812 ast_test_status_update(test, "Could not retrieve built-in alaw codec\n");
813 return AST_TEST_FAIL;
814 }
815
816 alaw_format = ast_format_create(alaw);
817 if (!alaw_format) {
818 ast_test_status_update(test, "Could not create alaw format using built-in codec\n");
819 return AST_TEST_FAIL;
820 }
821
822 if (ast_format_cap_append(caps, ulaw_format, 42)) {
823 ast_test_status_update(test, "Could not add newly created ulaw format to capabilities structure\n");
824 return AST_TEST_FAIL;
825 }
826
827 compatible = ast_format_cap_get_compatible_format(caps, alaw_format);
828 if (compatible) {
829 ast_test_status_update(test, "Retrieved a compatible format from capabilities structure when none should exist\n");
830 return AST_TEST_FAIL;
831 }
832
833 compatible = ast_format_cap_get_compatible_format(caps, ulaw_format);
834 if (!compatible) {
835 ast_test_status_update(test, "Did not retrieve a compatible format from capabilities structure when there should be one\n");
836 return AST_TEST_FAIL;
837 } else if (compatible != ulaw_format) {
838 ast_test_status_update(test, "Compatible format is not the format we added to the capabilities structure\n");
839 return AST_TEST_FAIL;
840 }
841
842 return AST_TEST_PASS;
843}
ast_format_cap_get_compatible_format
struct ast_format * ast_format_cap_get_compatible_format(const struct ast_format_cap *cap, const struct ast_format *format)
Find if input ast_format is within the capabilities of the ast_format_cap object then return the comp...
Definition: format_cap.c:546

References alaw, ao2_cleanup, ast_codec_get(), ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_compatible_format(), ast_format_create(), AST_MEDIA_TYPE_AUDIO, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_EXECUTE, TEST_INIT, and ulaw.

◆ AST_TEST_DEFINE() [12/20]

AST_TEST_DEFINE ( format_cap_get_names  )

Definition at line 1070 of file test_format_cap.c.

1071{
1072 RAII_VAR(struct ast_format_cap *, empty_caps, NULL, ao2_cleanup);
1073 RAII_VAR(struct ast_format_cap *, multi_caps, NULL, ao2_cleanup);
1074 RAII_VAR(struct ast_format_cap *, alaw_caps, NULL, ao2_cleanup);
1075 RAII_VAR(struct ast_format_cap *, ulaw_caps, NULL, ao2_cleanup);
1076 RAII_VAR(struct ast_codec *, ulaw, NULL, ao2_cleanup);
1077 RAII_VAR(struct ast_format *, ulaw_format, NULL, ao2_cleanup);
1078 RAII_VAR(struct ast_codec *, alaw, NULL, ao2_cleanup);
1079 RAII_VAR(struct ast_format *, alaw_format, NULL, ao2_cleanup);
1080 struct ast_str *buffer = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
1081
1082 switch (cmd) {
1083 case TEST_INIT:
1084 info->name = "format_cap_get_names";
1085 info->category = "/main/format_cap/";
1086 info->summary = "Test getting the names of formats";
1087 info->description =
1088 "Test that obtaining the names from a format capabilities structure\n"
1089 "produces the expected output.";
1090 return AST_TEST_NOT_RUN;
1091 case TEST_EXECUTE:
1092 break;
1093 }
1094
1095 empty_caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
1096 if (!empty_caps) {
1097 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
1098 return AST_TEST_FAIL;
1099 }
1100
1101 multi_caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
1102 if (!multi_caps) {
1103 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
1104 return AST_TEST_FAIL;
1105 }
1106
1107 alaw_caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
1108 if (!alaw_caps) {
1109 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
1110 return AST_TEST_FAIL;
1111 }
1112
1113 ulaw_caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
1114 if (!ulaw_caps) {
1115 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
1116 return AST_TEST_FAIL;
1117 }
1118
1119 ulaw = ast_codec_get("ulaw", AST_MEDIA_TYPE_AUDIO, 8000);
1120 if (!ulaw) {
1121 ast_test_status_update(test, "Could not retrieve built-in ulaw codec\n");
1122 return AST_TEST_FAIL;
1123 }
1124
1125 ulaw_format = ast_format_create(ulaw);
1126 if (!ulaw_format) {
1127 ast_test_status_update(test, "Could not create ulaw format using built-in codec\n");
1128 return AST_TEST_FAIL;
1129 }
1130
1131 alaw = ast_codec_get("alaw", AST_MEDIA_TYPE_AUDIO, 8000);
1132 if (!alaw) {
1133 ast_test_status_update(test, "Could not retrieve built-in alaw codec\n");
1134 return AST_TEST_FAIL;
1135 }
1136
1137 alaw_format = ast_format_create(alaw);
1138 if (!alaw_format) {
1139 ast_test_status_update(test, "Could not create alaw format using built-in codec\n");
1140 return AST_TEST_FAIL;
1141 }
1142
1143 if (ast_format_cap_append(ulaw_caps, ulaw_format, 0)) {
1144 ast_test_status_update(test, "Could not add ulaw format to ulaw capabilities\n");
1145 return AST_TEST_FAIL;
1146 } else if (ast_format_cap_append(alaw_caps, alaw_format, 0)) {
1147 ast_test_status_update(test, "Could not add alaw format to alaw capabilities\n");
1148 return AST_TEST_FAIL;
1149 } else if (ast_format_cap_append(multi_caps, ulaw_format, 0)) {
1150 ast_test_status_update(test, "Could not add ulaw format to multi capabilities\n");
1151 return AST_TEST_FAIL;
1152 } else if (ast_format_cap_append(multi_caps, alaw_format, 0)) {
1153 ast_test_status_update(test, "Could not add alaw format to multi capabilities\n");
1154 return AST_TEST_FAIL;
1155 }
1156
1157 ast_format_cap_get_names(empty_caps, &buffer);
1158 ast_test_validate(test, !strcmp(ast_str_buffer(buffer), "(nothing)"));
1159 ast_format_cap_get_names(ulaw_caps, &buffer);
1160 ast_test_validate(test, !strcmp(ast_str_buffer(buffer), "(ulaw)"));
1161 ast_format_cap_get_names(alaw_caps, &buffer);
1162 ast_test_validate(test, !strcmp(ast_str_buffer(buffer), "(alaw)"));
1163 ast_format_cap_get_names(multi_caps, &buffer);
1164 ast_test_validate(test, !strcmp(ast_str_buffer(buffer), "(ulaw|alaw)"));
1165
1166
1167 return AST_TEST_PASS;
1168}
AST_FORMAT_CAP_NAMES_LEN
#define AST_FORMAT_CAP_NAMES_LEN
Definition: format_cap.h:324
ast_format_cap_get_names
const char * ast_format_cap_get_names(const struct ast_format_cap *cap, struct ast_str **buf)
Get the names of codecs of a set of formats.
Definition: format_cap.c:734
ast_str_buffer
char * ast_str_buffer(const struct ast_str *buf)
Returns the string buffer within the ast_str buf.
Definition: strings.h:761
ast_str_alloca
#define ast_str_alloca(init_len)
Definition: strings.h:848
ast_str
Support for dynamic strings.
Definition: strings.h:623

References alaw, ao2_cleanup, ast_codec_get(), ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_names(), AST_FORMAT_CAP_NAMES_LEN, ast_format_create(), AST_MEDIA_TYPE_AUDIO, ast_str_alloca, ast_str_buffer(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_EXECUTE, TEST_INIT, and ulaw.

◆ AST_TEST_DEFINE() [13/20]

AST_TEST_DEFINE ( format_cap_iscompatible  )

Definition at line 996 of file test_format_cap.c.

997{
998 RAII_VAR(struct ast_format_cap *, alaw_caps, NULL, ao2_cleanup);
999 RAII_VAR(struct ast_format_cap *, ulaw_caps, NULL, ao2_cleanup);
1000 RAII_VAR(struct ast_codec *, ulaw, NULL, ao2_cleanup);
1001 RAII_VAR(struct ast_format *, ulaw_format, NULL, ao2_cleanup);
1002 RAII_VAR(struct ast_codec *, alaw, NULL, ao2_cleanup);
1003 RAII_VAR(struct ast_format *, alaw_format, NULL, ao2_cleanup);
1004
1005 switch (cmd) {
1006 case TEST_INIT:
1007 info->name = "format_cap_iscompatible";
1008 info->category = "/main/format_cap/";
1009 info->summary = "format capabilities negotiation unit test";
1010 info->description =
1011 "Test that checking if there are compatible formats between two capabilities structures succeeds";
1012 return AST_TEST_NOT_RUN;
1013 case TEST_EXECUTE:
1014 break;
1015 }
1016
1017 alaw_caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
1018 if (!alaw_caps) {
1019 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
1020 return AST_TEST_FAIL;
1021 }
1022
1023 ulaw_caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
1024 if (!ulaw_caps) {
1025 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
1026 return AST_TEST_FAIL;
1027 }
1028
1029 ulaw = ast_codec_get("ulaw", AST_MEDIA_TYPE_AUDIO, 8000);
1030 if (!ulaw) {
1031 ast_test_status_update(test, "Could not retrieve built-in ulaw codec\n");
1032 return AST_TEST_FAIL;
1033 }
1034
1035 ulaw_format = ast_format_create(ulaw);
1036 if (!ulaw_format) {
1037 ast_test_status_update(test, "Could not create ulaw format using built-in codec\n");
1038 return AST_TEST_FAIL;
1039 }
1040
1041 alaw = ast_codec_get("alaw", AST_MEDIA_TYPE_AUDIO, 8000);
1042 if (!alaw) {
1043 ast_test_status_update(test, "Could not retrieve built-in alaw codec\n");
1044 return AST_TEST_FAIL;
1045 }
1046
1047 alaw_format = ast_format_create(alaw);
1048 if (!alaw_format) {
1049 ast_test_status_update(test, "Could not create alaw format using built-in codec\n");
1050 return AST_TEST_FAIL;
1051 }
1052
1053 if (ast_format_cap_append(ulaw_caps, ulaw_format, 0)) {
1054 ast_test_status_update(test, "Could not add ulaw format to ulaw capabilities\n");
1055 return AST_TEST_FAIL;
1056 } else if (ast_format_cap_append(alaw_caps, alaw_format, 0)) {
1057 ast_test_status_update(test, "Could not add alaw format to alaw capabilities\n");
1058 return AST_TEST_FAIL;
1059 } else if (ast_format_cap_iscompatible(ulaw_caps, alaw_caps)) {
1060 ast_test_status_update(test, "Two capability structures that should not be compatible are\n");
1061 return AST_TEST_FAIL;
1062 } else if (!ast_format_cap_iscompatible(ulaw_caps, ulaw_caps)) {
1063 ast_test_status_update(test, "Capability structure is not compatible with itself\n");
1064 return AST_TEST_FAIL;
1065 }
1066
1067 return AST_TEST_PASS;
1068}
ast_format_cap_iscompatible
int ast_format_cap_iscompatible(const struct ast_format_cap *cap1, const struct ast_format_cap *cap2)
Determine if any joint capabilities exist between two capabilities structures.
Definition: format_cap.c:653

References alaw, ao2_cleanup, ast_codec_get(), ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_iscompatible(), ast_format_create(), AST_MEDIA_TYPE_AUDIO, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_EXECUTE, TEST_INIT, and ulaw.

◆ AST_TEST_DEFINE() [14/20]

AST_TEST_DEFINE ( format_cap_iscompatible_format  )

Definition at line 845 of file test_format_cap.c.

846{
847 RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
848 RAII_VAR(struct ast_codec *, ulaw, NULL, ao2_cleanup);
849 RAII_VAR(struct ast_format *, ulaw_format, NULL, ao2_cleanup);
850 RAII_VAR(struct ast_codec *, alaw, NULL, ao2_cleanup);
851 RAII_VAR(struct ast_format *, alaw_format, NULL, ao2_cleanup);
852
853 switch (cmd) {
854 case TEST_INIT:
855 info->name = "format_cap_iscompatible_format";
856 info->category = "/main/format_cap/";
857 info->summary = "format capabilities negotiation unit test";
858 info->description =
859 "Test that checking whether a format is compatible with a capabilities structure succeeds";
860 return AST_TEST_NOT_RUN;
861 case TEST_EXECUTE:
862 break;
863 }
864
865 caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
866 if (!caps) {
867 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
868 return AST_TEST_FAIL;
869 }
870
871 ulaw = ast_codec_get("ulaw", AST_MEDIA_TYPE_AUDIO, 8000);
872 if (!ulaw) {
873 ast_test_status_update(test, "Could not retrieve built-in ulaw codec\n");
874 return AST_TEST_FAIL;
875 }
876
877 ulaw_format = ast_format_create(ulaw);
878 if (!ulaw_format) {
879 ast_test_status_update(test, "Could not create ulaw format using built-in codec\n");
880 return AST_TEST_FAIL;
881 }
882
883 alaw = ast_codec_get("alaw", AST_MEDIA_TYPE_AUDIO, 8000);
884 if (!alaw) {
885 ast_test_status_update(test, "Could not retrieve built-in alaw codec\n");
886 return AST_TEST_FAIL;
887 }
888
889 alaw_format = ast_format_create(alaw);
890 if (!alaw_format) {
891 ast_test_status_update(test, "Could not create alaw format using built-in codec\n");
892 return AST_TEST_FAIL;
893 }
894
895 if (ast_format_cap_append(caps, ulaw_format, 42)) {
896 ast_test_status_update(test, "Could not add newly created ulaw format to capabilities structure\n");
897 return AST_TEST_FAIL;
898 } else if (ast_format_cap_iscompatible_format(caps, alaw_format) != AST_FORMAT_CMP_NOT_EQUAL) {
899 ast_test_status_update(test, "Alaw format is compatible with capabilities structure when it only contains ulaw\n");
900 return AST_TEST_FAIL;
901 } else if (ast_format_cap_iscompatible_format(caps, ulaw_format) == AST_FORMAT_CMP_NOT_EQUAL) {
902 ast_test_status_update(test, "Ulaw format is not compatible with capabilities structure when it should be\n");
903 return AST_TEST_FAIL;
904 }
905
906 return AST_TEST_PASS;
907}
AST_FORMAT_CMP_NOT_EQUAL
@ AST_FORMAT_CMP_NOT_EQUAL
Definition: format.h:38
ast_format_cap_iscompatible_format
enum ast_format_cmp_res ast_format_cap_iscompatible_format(const struct ast_format_cap *cap, const struct ast_format *format)
Find if ast_format is within the capabilities of the ast_format_cap object.
Definition: format_cap.c:581

References alaw, ao2_cleanup, ast_codec_get(), ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_iscompatible_format(), AST_FORMAT_CMP_NOT_EQUAL, ast_format_create(), AST_MEDIA_TYPE_AUDIO, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_EXECUTE, TEST_INIT, and ulaw.

◆ AST_TEST_DEFINE() [15/20]

AST_TEST_DEFINE ( format_cap_remove_all  )

Definition at line 736 of file test_format_cap.c.

737{
738 RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
739
740 switch (cmd) {
741 case TEST_INIT:
742 info->name = "format_cap_remove_all";
743 info->category = "/main/format_cap/";
744 info->summary = "format capabilities removal unit test";
745 info->description =
746 "Test that removal of all formats from a format capabilities structure succeeds";
747 return AST_TEST_NOT_RUN;
748 case TEST_EXECUTE:
749 break;
750 }
751
752 caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
753 if (!caps) {
754 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
755 return AST_TEST_FAIL;
756 } else if (ast_format_cap_append_by_type(caps, AST_MEDIA_TYPE_UNKNOWN)) {
757 ast_test_status_update(test, "Failed to add all media formats of all types to capabilities structure\n");
758 return AST_TEST_FAIL;
759 }
760
761 ast_format_cap_remove_by_type(caps, AST_MEDIA_TYPE_UNKNOWN);
762
763 if (ast_format_cap_count(caps)) {
764 ast_test_status_update(test, "Removed all formats from capabilities structure but some remain\n");
765 return AST_TEST_FAIL;
766 }
767
768 return AST_TEST_PASS;
769}
ast_format_cap_remove_by_type
void ast_format_cap_remove_by_type(struct ast_format_cap *cap, enum ast_media_type type)
Remove all formats matching a specific format type.
Definition: format_cap.c:523

References ao2_cleanup, ast_format_cap_alloc, ast_format_cap_append_by_type(), ast_format_cap_count(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_remove_by_type(), AST_MEDIA_TYPE_UNKNOWN, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

◆ AST_TEST_DEFINE() [16/20]

AST_TEST_DEFINE ( format_cap_remove_bytype  )

Definition at line 699 of file test_format_cap.c.

700{
701 RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
702
703 switch (cmd) {
704 case TEST_INIT:
705 info->name = "format_cap_remove_bytype";
706 info->category = "/main/format_cap/";
707 info->summary = "format capabilities removal unit test";
708 info->description =
709 "Test that removal of a specific type of format from a format capabilities structure succeeds";
710 return AST_TEST_NOT_RUN;
711 case TEST_EXECUTE:
712 break;
713 }
714
715 caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
716 if (!caps) {
717 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
718 return AST_TEST_FAIL;
719 } else if (ast_format_cap_append_by_type(caps, AST_MEDIA_TYPE_UNKNOWN)) {
720 ast_test_status_update(test, "Failed to add all media formats of all types to capabilities structure\n");
721 return AST_TEST_FAIL;
722 }
723
724 ast_format_cap_remove_by_type(caps, AST_MEDIA_TYPE_AUDIO);
725 if (ast_format_cap_has_type(caps, AST_MEDIA_TYPE_AUDIO)) {
726 ast_test_status_update(test, "Removed all audio type formats from capabilities structure but some remain\n");
727 return AST_TEST_FAIL;
728 } else if (!ast_format_cap_has_type(caps, AST_MEDIA_TYPE_VIDEO)) {
729 ast_test_status_update(test, "Removed audio type formats from capabilities structure but video are gone as well\n");
730 return AST_TEST_FAIL;
731 }
732
733 return AST_TEST_PASS;
734}

References ao2_cleanup, ast_format_cap_alloc, ast_format_cap_append_by_type(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_has_type(), ast_format_cap_remove_by_type(), AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_UNKNOWN, AST_MEDIA_TYPE_VIDEO, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

◆ AST_TEST_DEFINE() [17/20]

AST_TEST_DEFINE ( format_cap_remove_multiple  )

Definition at line 621 of file test_format_cap.c.

622{
623 RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
624 RAII_VAR(struct ast_codec *, ulaw, NULL, ao2_cleanup);
625 RAII_VAR(struct ast_format *, ulaw_format, NULL, ao2_cleanup);
626 RAII_VAR(struct ast_codec *, alaw, NULL, ao2_cleanup);
627 RAII_VAR(struct ast_format *, alaw_format, NULL, ao2_cleanup);
628 RAII_VAR(struct ast_format *, retrieved, NULL, ao2_cleanup);
629
630 switch (cmd) {
631 case TEST_INIT:
632 info->name = "format_cap_remove_multiple";
633 info->category = "/main/format_cap/";
634 info->summary = "format capabilities removal unit test";
635 info->description =
636 "Test that removing a format from a format capabilities structure containing multiple formats succeeds";
637 return AST_TEST_NOT_RUN;
638 case TEST_EXECUTE:
639 break;
640 }
641
642 caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
643 if (!caps) {
644 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
645 return AST_TEST_FAIL;
646 }
647
648 ulaw = ast_codec_get("ulaw", AST_MEDIA_TYPE_AUDIO, 8000);
649 if (!ulaw) {
650 ast_test_status_update(test, "Could not retrieve built-in ulaw codec\n");
651 return AST_TEST_FAIL;
652 }
653
654 ulaw_format = ast_format_create(ulaw);
655 if (!ulaw_format) {
656 ast_test_status_update(test, "Could not create ulaw format using built-in codec\n");
657 return AST_TEST_FAIL;
658 }
659
660 alaw = ast_codec_get("alaw", AST_MEDIA_TYPE_AUDIO, 8000);
661 if (!alaw) {
662 ast_test_status_update(test, "Could not retrieve built-in alaw codec\n");
663 return AST_TEST_FAIL;
664 }
665
666 alaw_format = ast_format_create(alaw);
667 if (!alaw_format) {
668 ast_test_status_update(test, "Could not create alaw format using built-in codec\n");
669 return AST_TEST_FAIL;
670 }
671
672 if (ast_format_cap_append(caps, ulaw_format, 42)) {
673 ast_test_status_update(test, "Could not add newly created ulaw format to capabilities structure\n");
674 return AST_TEST_FAIL;
675 } else if (ast_format_cap_append(caps, alaw_format, 84)) {
676 ast_test_status_update(test, "Could not add newly created alaw format to capabilities structure\n");
677 return AST_TEST_FAIL;
678 } else if (ast_format_cap_remove(caps, ulaw_format)) {
679 ast_test_status_update(test, "Could not remove the ulaw format we just added to capabilities structure\n");
680 return AST_TEST_FAIL;
681 } else if (ast_format_cap_count(caps) != 1) {
682 ast_test_status_update(test, "Capabilities structure should contain 1 format but it contains '%zu'\n",
683 ast_format_cap_count(caps));
684 return AST_TEST_FAIL;
685 }
686
687 retrieved = ast_format_cap_get_format(caps, 0);
688 if (!retrieved) {
689 ast_test_status_update(test, "Attempted to get first format from capabilities structure but got nothing\n");
690 return AST_TEST_FAIL;
691 } else if (retrieved != alaw_format) {
692 ast_test_status_update(test, "First retrieved format is not the alaw one we added\n");
693 return AST_TEST_FAIL;
694 }
695
696 return AST_TEST_PASS;
697}
ast_format_cap_remove
int ast_format_cap_remove(struct ast_format_cap *cap, struct ast_format *format)
Remove format capability from capability structure.
Definition: format_cap.c:495

References alaw, ao2_cleanup, ast_codec_get(), ast_format_cap_alloc, ast_format_cap_append, ast_format_cap_count(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_format(), ast_format_cap_remove(), ast_format_create(), AST_MEDIA_TYPE_AUDIO, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_EXECUTE, TEST_INIT, and ulaw.

◆ AST_TEST_DEFINE() [18/20]

AST_TEST_DEFINE ( format_cap_remove_single  )

Definition at line 567 of file test_format_cap.c.

568{
569 RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
570 RAII_VAR(struct ast_codec *, codec, NULL, ao2_cleanup);
571 RAII_VAR(struct ast_format *, format, NULL, ao2_cleanup);
572
573 switch (cmd) {
574 case TEST_INIT:
575 info->name = "format_cap_remove_single";
576 info->category = "/main/format_cap/";
577 info->summary = "format capabilities removal unit test";
578 info->description =
579 "Test that removing a single format from a format capabilities structure succeeds";
580 return AST_TEST_NOT_RUN;
581 case TEST_EXECUTE:
582 break;
583 }
584
585 caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
586 if (!caps) {
587 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
588 return AST_TEST_FAIL;
589 }
590
591 codec = ast_codec_get("ulaw", AST_MEDIA_TYPE_AUDIO, 8000);
592 if (!codec) {
593 ast_test_status_update(test, "Could not retrieve built-in ulaw codec\n");
594 return AST_TEST_FAIL;
595 }
596
597 format = ast_format_create(codec);
598 if (!format) {
599 ast_test_status_update(test, "Could not create format using built-in codec\n");
600 return AST_TEST_FAIL;
601 }
602
603 if (ast_format_cap_append(caps, format, 42)) {
604 ast_test_status_update(test, "Could not add newly created format to capabilities structure\n");
605 return AST_TEST_FAIL;
606 } else if (ast_format_cap_remove(caps, format)) {
607 ast_test_status_update(test, "Could not remove format that was just added to capabilities structure\n");
608 return AST_TEST_FAIL;
609 } else if (!ast_format_cap_remove(caps, format)) {
610 ast_test_status_update(test, "Successfully removed a format twice from the capabilities structure\n");
611 return AST_TEST_FAIL;
612 } else if (ast_format_cap_count(caps)) {
613 ast_test_status_update(test, "Capabilities structure should be empty but instead it contains '%zu' formats\n",
614 ast_format_cap_count(caps));
615 return AST_TEST_FAIL;
616 }
617
618 return AST_TEST_PASS;
619}

References ao2_cleanup, ast_codec_get(), ast_format_cap_alloc, ast_format_cap_append, ast_format_cap_count(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_remove(), ast_format_create(), AST_MEDIA_TYPE_AUDIO, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

◆ AST_TEST_DEFINE() [19/20]

AST_TEST_DEFINE ( format_cap_replace_from_cap  )

Definition at line 1311 of file test_format_cap.c.

1312{
1313 RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
1314 RAII_VAR(struct ast_format_cap *, replace_caps, NULL, ao2_cleanup);
1315 RAII_VAR(struct ast_format_cap *, result_caps, NULL, ao2_cleanup);
1316 RAII_VAR(struct ast_codec *, ulaw, NULL, ao2_cleanup);
1317 RAII_VAR(struct ast_format *, ulaw_format, NULL, ao2_cleanup);
1318 RAII_VAR(struct ast_format *, ulaw_format_variant, NULL, ao2_cleanup);
1319 RAII_VAR(struct ast_codec *, alaw, NULL, ao2_cleanup);
1320 RAII_VAR(struct ast_format *, alaw_format, NULL, ao2_cleanup);
1321
1322 switch (cmd) {
1323 case TEST_INIT:
1324 info->name = __PRETTY_FUNCTION__;
1325 info->category = "/main/format_cap/";
1326 info->summary = "format capabilities adding unit test";
1327 info->description =
1328 "Test that adding multiple formats to a format capabilities structure succeeds";
1329 return AST_TEST_NOT_RUN;
1330 case TEST_EXECUTE:
1331 break;
1332 }
1333
1334 caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
1335 replace_caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
1336 result_caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
1337 if (!caps || !replace_caps || !result_caps) {
1338 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
1339 return AST_TEST_FAIL;
1340 }
1341
1342 ulaw = ast_codec_get("test_law", AST_MEDIA_TYPE_AUDIO, 8000);
1343 if (!ulaw) {
1344 ast_test_status_update(test, "Could not retrieve test_law codec\n");
1345 return AST_TEST_FAIL;
1346 }
1347
1348 ulaw_format = ast_format_create(ulaw);
1349 if (!ulaw_format) {
1350 ast_test_status_update(test, "Could not create ulaw format using built-in codec\n");
1351 return AST_TEST_FAIL;
1352 }
1353
1354 ulaw_format_variant = ast_format_create(ulaw);
1355 if (!ulaw_format_variant) {
1356 ast_test_status_update(test, "Could not create ulaw format variant using built-in codec\n");
1357 return AST_TEST_FAIL;
1358 }
1359
1360 alaw = ast_codec_get("alaw", AST_MEDIA_TYPE_AUDIO, 8000);
1361 if (!alaw) {
1362 ast_test_status_update(test, "Could not retrieve built-in alaw codec\n");
1363 return AST_TEST_FAIL;
1364 }
1365
1366 alaw_format = ast_format_create(alaw);
1367 if (!alaw_format) {
1368 ast_test_status_update(test, "Could not create alaw format using built-in codec\n");
1369 return AST_TEST_FAIL;
1370 }
1371
1372 /* fill caps with ulaw and alaw */
1373 if (ast_format_cap_append(caps, ulaw_format, 42)) {
1374 ast_test_status_update(test, "Could not add ulaw format to capabilities structure\n");
1375 return AST_TEST_FAIL;
1376 }
1377 if (ast_format_cap_append(caps, alaw_format, 84)) {
1378 ast_test_status_update(test, "Could not add alaw format to capabilities structure\n");
1379 return AST_TEST_FAIL;
1380 }
1381 if (ast_format_cap_count(caps) != 2) {
1382 ast_test_status_update(test, "Number of formats in capabilities structure should be 2 but is %zu\n",
1383 ast_format_cap_count(caps));
1384 return AST_TEST_FAIL;
1385 }
1386
1387 /* fill replace_caps with the ulaw variant */
1388 if (ast_format_cap_append(replace_caps, ulaw_format_variant, 42)) {
1389 ast_test_status_update(test, "Could not add ulaw format to capabilities structure\n");
1390 return AST_TEST_FAIL;
1391 }
1392 if (ast_format_cap_count(replace_caps) != 1) {
1393 ast_test_status_update(test, "Number of formats in capabilities structure should be 1 but is %zu\n",
1394 ast_format_cap_count(replace_caps));
1395 return AST_TEST_FAIL;
1396 }
1397
1398 /* fill result_caps with ulaw_variant and alaw */
1399 if (ast_format_cap_append(result_caps, ulaw_format_variant, 42)) {
1400 ast_test_status_update(test, "Could not add ulaw variant to capabilities structure\n");
1401 return AST_TEST_FAIL;
1402 }
1403 if (ast_format_cap_append(result_caps, alaw_format, 84)) {
1404 ast_test_status_update(test, "Could not add alaw format to capabilities structure\n");
1405 return AST_TEST_FAIL;
1406 }
1407 if (ast_format_cap_count(result_caps) != 2) {
1408 ast_test_status_update(test, "Number of formats in capabilities structure should be 2 but is %zu\n",
1409 ast_format_cap_count(result_caps));
1410 return AST_TEST_FAIL;
1411 }
1412
1413 /* replace caps formats from replace_caps */
1414 ast_format_cap_replace_from_cap(caps, replace_caps, AST_MEDIA_TYPE_UNKNOWN);
1415
1416 /* compare result_caps with caps */
1417 if (!ast_format_cap_identical(caps, result_caps)) {
1418 ast_test_status_update(test, "Actual and expected result caps differ\n");
1419 return AST_TEST_FAIL;
1420 }
1421
1422 return AST_TEST_PASS;
1423}
ast_format_cap_replace_from_cap
void ast_format_cap_replace_from_cap(struct ast_format_cap *dst, const struct ast_format_cap *src, enum ast_media_type type)
Replace the formats of provided type in dst with equivalent formats from src.
Definition: format_cap.c:306
ast_format_cap_identical
int ast_format_cap_identical(const struct ast_format_cap *cap1, const struct ast_format_cap *cap2)
Determine if two capabilities structures are identical.
Definition: format_cap.c:687

References alaw, ao2_cleanup, ast_codec_get(), ast_format_cap_alloc, ast_format_cap_append, ast_format_cap_count(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_identical(), ast_format_cap_replace_from_cap(), ast_format_create(), AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_UNKNOWN, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_EXECUTE, TEST_INIT, and ulaw.

◆ AST_TEST_DEFINE() [20/20]

AST_TEST_DEFINE ( format_cap_set_framing  )

Definition at line 493 of file test_format_cap.c.

494{
495 RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
496 RAII_VAR(struct ast_codec *, ulaw, NULL, ao2_cleanup);
497 RAII_VAR(struct ast_format *, ulaw_format, NULL, ao2_cleanup);
498 RAII_VAR(struct ast_codec *, alaw, NULL, ao2_cleanup);
499 RAII_VAR(struct ast_format *, alaw_format, NULL, ao2_cleanup);
500
501 switch (cmd) {
502 case TEST_INIT:
503 info->name = "format_cap_set_framing";
504 info->category = "/main/format_cap/";
505 info->summary = "format capabilities framing unit test";
506 info->description =
507 "Test that global framing on a format capabilities structure is used when it should be";
508 return AST_TEST_NOT_RUN;
509 case TEST_EXECUTE:
510 break;
511 }
512
513 caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
514 if (!caps) {
515 ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
516 return AST_TEST_FAIL;
517 }
518
519 ast_format_cap_set_framing(caps, 160);
520
521 ast_test_validate(test, ast_format_cap_get_framing(caps) == 160);
522
523 ulaw = ast_codec_get("ulaw", AST_MEDIA_TYPE_AUDIO, 8000);
524 if (!ulaw) {
525 ast_test_status_update(test, "Could not retrieve built-in ulaw codec\n");
526 return AST_TEST_FAIL;
527 }
528
529 ulaw_format = ast_format_create(ulaw);
530 if (!ulaw_format) {
531 ast_test_status_update(test, "Could not create ulaw format using built-in codec\n");
532 return AST_TEST_FAIL;
533 }
534
535 alaw = ast_codec_get("alaw", AST_MEDIA_TYPE_AUDIO, 8000);
536 if (!alaw) {
537 ast_test_status_update(test, "Could not retrieve built-in alaw codec\n");
538 return AST_TEST_FAIL;
539 }
540
541 alaw_format = ast_format_create(alaw);
542 if (!alaw_format) {
543 ast_test_status_update(test, "Could not create alaw format using built-in codec\n");
544 return AST_TEST_FAIL;
545 }
546
547 if (ast_format_cap_append(caps, ulaw_format, 42)) {
548 ast_test_status_update(test, "Could not add newly created ulaw format to capabilities structure\n");
549 return AST_TEST_FAIL;
550 } else if (ast_format_cap_append(caps, alaw_format, 0)) {
551 ast_test_status_update(test, "Could not add newly created alaw format to capabilities structure\n");
552 return AST_TEST_FAIL;
553 }
554
555 if (ast_format_cap_get_format_framing(caps, ulaw_format) != 42) {
556 ast_test_status_update(test, "Added ulaw format to capabilities structure with explicit framing but did not get it back\n");
557 return AST_TEST_FAIL;
558 } else if (ast_format_cap_get_format_framing(caps, alaw_format) != ast_format_get_default_ms(alaw_format)) {
559 ast_test_status_update(test, "Added alaw format to capabilities structure with no explicit framing but did not get global back\n");
560 return AST_TEST_FAIL;
561 }
562 ast_test_validate(test, ast_format_cap_get_framing(caps) == ast_format_get_default_ms(alaw_format));
563
564 return AST_TEST_PASS;
565}
ast_format_get_default_ms
unsigned int ast_format_get_default_ms(const struct ast_format *format)
Get the default framing size (in milliseconds) for a format.
Definition: format.c:359
ast_format_cap_get_framing
unsigned int ast_format_cap_get_framing(const struct ast_format_cap *cap)
Get the global framing.
Definition: format_cap.c:438
ast_format_cap_set_framing
void ast_format_cap_set_framing(struct ast_format_cap *cap, unsigned int framing)
Set the global framing.
Definition: format_cap.c:136

References alaw, ao2_cleanup, ast_codec_get(), ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_format_framing(), ast_format_cap_get_framing(), ast_format_cap_set_framing(), ast_format_create(), ast_format_get_default_ms(), AST_MEDIA_TYPE_AUDIO, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_EXECUTE, TEST_INIT, and ulaw.

◆ load_module()

static int load_module ( void  )
static

Definition at line 1450 of file test_format_cap.c.

1451{
1452 AST_TEST_REGISTER(format_cap_alloc);
1453 AST_TEST_REGISTER(format_cap_append_single);
1454 AST_TEST_REGISTER(format_cap_append_multiple);
1455 AST_TEST_REGISTER(format_cap_append_all_unknown);
1456 AST_TEST_REGISTER(format_cap_append_all_audio);
1457 AST_TEST_REGISTER(format_cap_append_duplicate);
1458 AST_TEST_REGISTER(format_cap_append_from_cap);
1459 AST_TEST_REGISTER(format_cap_append_from_cap_duplicate);
1460 AST_TEST_REGISTER(format_cap_set_framing);
1461 AST_TEST_REGISTER(format_cap_remove_single);
1462 AST_TEST_REGISTER(format_cap_remove_multiple);
1463 AST_TEST_REGISTER(format_cap_remove_bytype);
1464 AST_TEST_REGISTER(format_cap_remove_all);
1465 AST_TEST_REGISTER(format_cap_get_names);
1466 AST_TEST_REGISTER(format_cap_get_compatible_format);
1467 AST_TEST_REGISTER(format_cap_iscompatible_format);
1468 AST_TEST_REGISTER(format_cap_get_compatible);
1469 AST_TEST_REGISTER(format_cap_iscompatible);
1470 AST_TEST_REGISTER(format_cap_best_by_type);
1471 AST_TEST_REGISTER(format_cap_replace_from_cap);
1472 ast_codec_register(&test_law);
1473 ast_format_interface_register("test_law", &test_law_interface);
1474 return AST_MODULE_LOAD_SUCCESS;
1475}
ast_codec_register
#define ast_codec_register(codec)
This function is used to register a codec with the Asterisk core. Registering allows it to be passed ...
Definition: codec.h:124
ast_format_interface_register
#define ast_format_interface_register(codec, interface)
Register a format interface for use with the provided codec.
Definition: format.h:273
AST_MODULE_LOAD_SUCCESS
@ AST_MODULE_LOAD_SUCCESS
Definition: module.h:70
AST_TEST_REGISTER
#define AST_TEST_REGISTER(cb)
Definition: test.h:127
test_law
static struct ast_codec test_law
Definition: test_format_cap.c:1277
test_law_interface
static struct ast_format_interface test_law_interface
Definition: test_format_cap.c:1305

References ast_codec_register, ast_format_interface_register, AST_MODULE_LOAD_SUCCESS, AST_TEST_REGISTER, test_law, and test_law_interface.

◆ test_law_clone()

static int test_law_clone ( const struct ast_format *  src,
struct ast_format *  dst 
)
static

Definition at line 1300 of file test_format_cap.c.

1301{
1302 return 0;
1303}

◆ test_law_cmp()

static enum ast_format_cmp_res test_law_cmp ( const struct ast_format *  format1,
const struct ast_format *  format2 
)
static

Definition at line 1290 of file test_format_cap.c.

1291{
1292 ast_log(LOG_ERROR, "Comparing format1 %p and format2 %p\n", format1, format2);
1293 return format1 == format2 ? AST_FORMAT_CMP_EQUAL : AST_FORMAT_CMP_NOT_EQUAL;
1294}
ast_log
#define ast_log
Definition: astobj2.c:42
LOG_ERROR
#define LOG_ERROR
Definition: include/asterisk/logger.h:286

References AST_FORMAT_CMP_EQUAL, AST_FORMAT_CMP_NOT_EQUAL, ast_log, and LOG_ERROR.

◆ test_law_destroy()

static void test_law_destroy ( struct ast_format *  format)
static

Definition at line 1296 of file test_format_cap.c.

1297{
1298}

◆ test_law_length()

static int test_law_length ( unsigned int  samples)
static

Definition at line 1272 of file test_format_cap.c.

1273{
1274 return samples;
1275}

◆ test_law_samples()

static int test_law_samples ( struct ast_frame *  frame)
static

Definition at line 1267 of file test_format_cap.c.

1268{
1269 return frame->datalen;
1270}
ast_frame::datalen
int datalen
Definition: include/asterisk/frame.h:171

References ast_frame::datalen.

◆ unload_module()

static int unload_module ( void  )
static

Definition at line 1425 of file test_format_cap.c.

1426{
1427 AST_TEST_UNREGISTER(format_cap_alloc);
1428 AST_TEST_UNREGISTER(format_cap_append_single);
1429 AST_TEST_UNREGISTER(format_cap_append_multiple);
1430 AST_TEST_UNREGISTER(format_cap_append_all_unknown);
1431 AST_TEST_UNREGISTER(format_cap_append_all_audio);
1432 AST_TEST_UNREGISTER(format_cap_append_duplicate);
1433 AST_TEST_UNREGISTER(format_cap_append_from_cap);
1434 AST_TEST_UNREGISTER(format_cap_append_from_cap_duplicate);
1435 AST_TEST_UNREGISTER(format_cap_set_framing);
1436 AST_TEST_UNREGISTER(format_cap_remove_single);
1437 AST_TEST_UNREGISTER(format_cap_remove_multiple);
1438 AST_TEST_UNREGISTER(format_cap_remove_bytype);
1439 AST_TEST_UNREGISTER(format_cap_remove_all);
1440 AST_TEST_UNREGISTER(format_cap_get_names);
1441 AST_TEST_UNREGISTER(format_cap_get_compatible_format);
1442 AST_TEST_UNREGISTER(format_cap_iscompatible_format);
1443 AST_TEST_UNREGISTER(format_cap_get_compatible);
1444 AST_TEST_UNREGISTER(format_cap_iscompatible);
1445 AST_TEST_UNREGISTER(format_cap_best_by_type);
1446 AST_TEST_UNREGISTER(format_cap_replace_from_cap);
1447 return 0;
1448}
AST_TEST_UNREGISTER
#define AST_TEST_UNREGISTER(cb)
Definition: test.h:128

References AST_TEST_UNREGISTER.

Variable Documentation

◆ __mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Format capabilities API test module" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }
static

Definition at line 1477 of file test_format_cap.c.

◆ ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info
static

Definition at line 1477 of file test_format_cap.c.

◆ test_law

struct ast_codec test_law
static

Definition at line 1277 of file test_format_cap.c.

Referenced by load_module().

◆ test_law_interface

struct ast_format_interface test_law_interface
static
Initial value:
= {
.format_cmp = test_law_cmp,
.format_clone = test_law_clone,
.format_destroy = test_law_destroy,
}
test_law_clone
static int test_law_clone(const struct ast_format *src, struct ast_format *dst)
Definition: test_format_cap.c:1300
test_law_destroy
static void test_law_destroy(struct ast_format *format)
Definition: test_format_cap.c:1296
test_law_cmp
static enum ast_format_cmp_res test_law_cmp(const struct ast_format *format1, const struct ast_format *format2)
Definition: test_format_cap.c:1290

Definition at line 1305 of file test_format_cap.c.

Referenced by load_module().

Generated on Wed Apr 24 2024 20:04:54 for Asterisk - The Open Source Telephony Project by doxygen 1.9.4