git migration: Refactor the ASTERISK_FILE_VERSION macro
[asterisk/asterisk.git] / tests / test_format_cache.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2014, Digium, Inc.
5  *
6  * Joshua Colp <jcolp@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*!
20  * \file
21  * \brief Format Cache API Unit Tests
22  *
23  * \author Joshua Colp <jcolp@digium.com>
24  *
25  */
26
27 /*** MODULEINFO
28         <depend>TEST_FRAMEWORK</depend>
29         <support_level>core</support_level>
30  ***/
31
32 #include "asterisk.h"
33
34 ASTERISK_REGISTER_FILE()
35
36 #include "asterisk/test.h"
37 #include "asterisk/module.h"
38 #include "asterisk/codec.h"
39 #include "asterisk/format.h"
40 #include "asterisk/format_cache.h"
41
42 AST_TEST_DEFINE(format_cache_set)
43 {
44         RAII_VAR(struct ast_codec *, codec, NULL, ao2_cleanup);
45         RAII_VAR(struct ast_format *, format, NULL, ao2_cleanup);
46
47         switch (cmd) {
48         case TEST_INIT:
49                 info->name = "format_cache_set";
50                 info->category = "/main/format_cache/";
51                 info->summary = "format cache add unit test";
52                 info->description =
53                         "Test that adding of a cached format succeeds";
54                 return AST_TEST_NOT_RUN;
55         case TEST_EXECUTE:
56                 break;
57         }
58
59         codec = ast_codec_get("ulaw", AST_MEDIA_TYPE_AUDIO, 8000);
60         if (!codec) {
61                 ast_test_status_update(test, "Could not retrieve built-in ulaw codec\n");
62                 return AST_TEST_FAIL;
63         }
64
65         format = ast_format_create_named("ulaw@20_1", codec);
66         if (!format) {
67                 ast_test_status_update(test, "Could not create format using built-in codec\n");
68                 return AST_TEST_FAIL;
69         }
70
71         if (ast_format_cache_set(format)) {
72                 ast_test_status_update(test, "Could not add just created format to cache\n");
73                 return AST_TEST_FAIL;
74         }
75
76         return AST_TEST_PASS;
77 }
78
79 AST_TEST_DEFINE(format_cache_set_duplicate)
80 {
81         RAII_VAR(struct ast_codec *, codec, NULL, ao2_cleanup);
82         RAII_VAR(struct ast_format *, format, NULL, ao2_cleanup);
83
84         switch (cmd) {
85         case TEST_INIT:
86                 info->name = "format_cache_set_duplicate";
87                 info->category = "/main/format_cache/";
88                 info->summary = "format cache add unit test";
89                 info->description =
90                         "Test that adding of a cached format multiple times succeeds";
91                 return AST_TEST_NOT_RUN;
92         case TEST_EXECUTE:
93                 break;
94         }
95
96         codec = ast_codec_get("ulaw", AST_MEDIA_TYPE_AUDIO, 8000);
97         if (!codec) {
98                 ast_test_status_update(test, "Could not retrieve built-in ulaw codec\n");
99                 return AST_TEST_FAIL;
100         }
101
102         format = ast_format_create_named("ulaw@20_2", codec);
103         if (!format) {
104                 ast_test_status_update(test, "Could not create format using built-in codec\n");
105                 return AST_TEST_FAIL;
106         }
107
108         if (ast_format_cache_set(format)) {
109                 ast_test_status_update(test, "Could not add just created format to cache\n");
110                 return AST_TEST_FAIL;
111         }
112
113         if (ast_format_cache_set(format)) {
114                 ast_test_status_update(test, "Failed to update cached format\n");
115                 return AST_TEST_FAIL;
116         }
117
118         return AST_TEST_PASS;
119 }
120
121 AST_TEST_DEFINE(format_cache_set_null)
122 {
123         RAII_VAR(struct ast_codec *, codec, NULL, ao2_cleanup);
124         RAII_VAR(struct ast_format *, format, NULL, ao2_cleanup);
125
126         switch (cmd) {
127         case TEST_INIT:
128                 info->name = "format_cache_set_null";
129                 info->category = "/main/format_cache/";
130                 info->summary = "format cache add unit test";
131                 info->description =
132                         "Test that adding a NULL or empty format to the cache does not succeed";
133                 return AST_TEST_NOT_RUN;
134         case TEST_EXECUTE:
135                 break;
136         }
137
138         codec = ast_codec_get("ulaw", AST_MEDIA_TYPE_AUDIO, 8000);
139         if (!codec) {
140                 ast_test_status_update(test, "Could not retrieve built-in ulaw codec\n");
141                 return AST_TEST_FAIL;
142         }
143
144         format = ast_format_create_named("", codec);
145         if (!format) {
146                 ast_test_status_update(test, "Could not create format using built-in codec\n");
147                 return AST_TEST_FAIL;
148         }
149
150         if (!ast_format_cache_set(format)) {
151                 ast_test_status_update(test, "Successfully cached a format with an empty name\n");
152                 return AST_TEST_FAIL;
153         }
154
155         return AST_TEST_PASS;
156 }
157
158 AST_TEST_DEFINE(format_cache_get)
159 {
160         RAII_VAR(struct ast_codec *, codec, NULL, ao2_cleanup);
161         RAII_VAR(struct ast_format *, format, NULL, ao2_cleanup);
162         RAII_VAR(struct ast_format *, cached, NULL, ao2_cleanup);
163
164         switch (cmd) {
165         case TEST_INIT:
166                 info->name = "format_cache_get";
167                 info->category = "/main/format_cache/";
168                 info->summary = "format cache get unit test";
169                 info->description =
170                         "Test that getting of a cached format succeeds";
171                 return AST_TEST_NOT_RUN;
172         case TEST_EXECUTE:
173                 break;
174         }
175
176         codec = ast_codec_get("ulaw", AST_MEDIA_TYPE_AUDIO, 8000);
177         if (!codec) {
178                 ast_test_status_update(test, "Could not retrieve built-in ulaw codec\n");
179                 return AST_TEST_FAIL;
180         }
181
182         format = ast_format_create_named("ulaw@20", codec);
183         if (!format) {
184                 ast_test_status_update(test, "Could not create format using built-in codec\n");
185                 return AST_TEST_FAIL;
186         }
187
188         if (ast_format_cache_set(format)) {
189                 ast_test_status_update(test, "Could not add just created format to cache\n");
190                 return AST_TEST_FAIL;
191         }
192
193         cached = ast_format_cache_get("ulaw@20");
194         if (!cached) {
195                 ast_test_status_update(test, "Failed to retrieve a format we just cached\n");
196                 return AST_TEST_FAIL;
197         } else if (cached != format) {
198                 ast_test_status_update(test, "Returned cached format does not match format we just added\n");
199                 return AST_TEST_FAIL;
200         }
201
202         return AST_TEST_PASS;
203 }
204
205 AST_TEST_DEFINE(format_cache_get_nonexistent)
206 {
207         RAII_VAR(struct ast_codec *, codec, NULL, ao2_cleanup);
208         RAII_VAR(struct ast_format *, format, NULL, ao2_cleanup);
209         RAII_VAR(struct ast_format *, cached, NULL, ao2_cleanup);
210
211         switch (cmd) {
212         case TEST_INIT:
213                 info->name = "format_cache_get_nonxistent";
214                 info->category = "/main/format_cache/";
215                 info->summary = "format cache get unit test";
216                 info->description =
217                         "Test that getting of a non-existent cached format does not succeed";
218                 return AST_TEST_NOT_RUN;
219         case TEST_EXECUTE:
220                 break;
221         }
222
223         codec = ast_codec_get("ulaw", AST_MEDIA_TYPE_AUDIO, 8000);
224         if (!codec) {
225                 ast_test_status_update(test, "Could not retrieve built-in ulaw codec\n");
226                 return AST_TEST_FAIL;
227         }
228
229         format = ast_format_create_named("ulaw@40", codec);
230         if (!format) {
231                 ast_test_status_update(test, "Could not create format using built-in codec\n");
232                 return AST_TEST_FAIL;
233         }
234
235         if (ast_format_cache_set(format)) {
236                 ast_test_status_update(test, "Could not add just created format to cache\n");
237                 return AST_TEST_FAIL;
238         }
239
240         cached = ast_format_cache_get("ulaw@60");
241         if (cached) {
242                 ast_test_status_update(test, "Retrieved a cached format when one should not have existed\n");
243                 return AST_TEST_FAIL;
244         }
245
246         cached = ast_format_cache_get("");
247         if (cached) {
248                 ast_test_status_update(test, "Retrieved a cached format when we provided an empty name\n");
249                 return AST_TEST_FAIL;
250         }
251
252         cached = ast_format_cache_get(NULL);
253         if (cached) {
254                 ast_test_status_update(test, "Retrieved a cached format when we provided a NULL name\n");
255                 return AST_TEST_FAIL;
256         }
257
258         return AST_TEST_PASS;
259 }
260
261 static int unload_module(void)
262 {
263         AST_TEST_UNREGISTER(format_cache_set);
264         AST_TEST_UNREGISTER(format_cache_set_duplicate);
265         AST_TEST_UNREGISTER(format_cache_set_null);
266         AST_TEST_UNREGISTER(format_cache_get);
267         AST_TEST_UNREGISTER(format_cache_get_nonexistent);
268         return 0;
269 }
270
271 static int load_module(void)
272 {
273         AST_TEST_REGISTER(format_cache_set);
274         AST_TEST_REGISTER(format_cache_set_duplicate);
275         AST_TEST_REGISTER(format_cache_set_null);
276         AST_TEST_REGISTER(format_cache_get);
277         AST_TEST_REGISTER(format_cache_get_nonexistent);
278         return AST_MODULE_LOAD_SUCCESS;
279 }
280
281 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Format cache API test module");