1 #include <stdio.h>
2 #include <string.h>
3 #include <CUnit/Basic.h>
4 #include "csound.h"
5
init_suite1(void)6 int init_suite1(void)
7 {
8 return 0;
9 }
10
clean_suite1(void)11 int clean_suite1(void)
12 {
13 return 0;
14 }
15
16 const char orc1[] = "chn_k \"testing\", 3\n instr 1\n endin\n";
17
test_control_channel_params(void)18 void test_control_channel_params(void)
19 {
20 csoundSetGlobalEnv("OPCODE6DIR64", "../../");
21 CSOUND *csound = csoundCreate(0);
22 csoundCreateMessageBuffer(csound, 0);
23 csoundSetOption(csound, "--logfile=NULL");
24 //int argc = 2;
25 csoundCompileOrc(csound, orc1);
26 CU_ASSERT(csoundStart(csound) == CSOUND_SUCCESS);
27 controlChannelHints_t hints;
28 hints.behav = CSOUND_CONTROL_CHANNEL_INT;
29 hints.dflt = 5;
30 hints.min = 1;
31 hints.max = 10;
32 hints.attributes = NULL;
33 csoundSetControlChannelHints(csound, "testing", hints);
34
35 controlChannelHints_t hints2;
36 csoundGetControlChannelHints(csound, "testing", &hints2);
37 CU_ASSERT(hints2.behav == CSOUND_CONTROL_CHANNEL_INT);
38 CU_ASSERT(hints2.dflt == 5);
39 CU_ASSERT(hints2.min == 1);
40 CU_ASSERT(hints2.max == 10);
41
42 csoundCleanup(csound);
43 csoundDestroyMessageBuffer(csound);
44 csoundDestroy(csound);
45 }
46
test_control_channel(void)47 void test_control_channel(void)
48 {
49 csoundSetGlobalEnv("OPCODE6DIR64", "../../");
50 CSOUND *csound = csoundCreate(0);
51 csoundCreateMessageBuffer(csound, 0);
52 csoundSetOption(csound, "--logfile=null");
53 //int argc = 2;
54 csoundCompileOrc(csound, orc1);
55 CU_ASSERT(csoundStart(csound) == CSOUND_SUCCESS);
56 csoundSetControlChannel(csound, "testing", 5.0);
57 CU_ASSERT_EQUAL(5.0, csoundGetControlChannel(csound, "testing", NULL));
58
59 csoundCleanup(csound);
60 csoundDestroyMessageBuffer(csound);
61 csoundDestroy(csound);
62 }
63
64 const char orc2[] = "chn_k \"testing\", 3, 1, 1, 0, 10\n chn_a \"testing2\", 3\n instr 1\n endin\n";
65
test_channel_list(void)66 void test_channel_list(void)
67 {
68 csoundSetGlobalEnv("OPCODE6DIR64", "../../");
69 CSOUND *csound = csoundCreate(0);
70 csoundCreateMessageBuffer(csound, 0);
71 csoundSetOption(csound, "--logfile=null");
72 //int argc = 2;
73 csoundCompileOrc(csound, orc2);
74 CU_ASSERT(csoundStart(csound) == CSOUND_SUCCESS);
75 controlChannelInfo_t *lst;
76 int numchnls = csoundListChannels(csound, &lst);
77 CU_ASSERT(numchnls == 2);
78 CU_ASSERT_STRING_EQUAL(lst->name, "testing");
79 CU_ASSERT_EQUAL(lst->type, CSOUND_CONTROL_CHANNEL | CSOUND_INPUT_CHANNEL
80 | CSOUND_OUTPUT_CHANNEL | CSOUND_CONTROL_CHANNEL_INT)
81 CU_ASSERT_STRING_EQUAL(lst[1].name, "testing2");
82
83 csoundDeleteChannelList(csound, lst);
84 csoundCleanup(csound);
85 csoundDestroyMessageBuffer(csound);
86 csoundDestroy(csound);
87 }
88
89 const char orc3[] = "instr 1\n kval invalue \"intest\"\n"
90 "outvalue \"intest\",kval\n"
91 "Sval invalue \"instrtest\"\n"
92 "outvalue \"instrtest\",Sval\n"
93 "endin\n"
94 "instr 2\n outvalue \"outtest\", 10\n endin\n";
95
96
inputCallback(CSOUND * csound,const char * channelName,void * channelValuePtr,void * channelType)97 void inputCallback(CSOUND *csound,
98 const char *channelName,
99 void *channelValuePtr,
100 void *channelType)
101 {
102 (void) csound;
103 (void) channelType;
104 if (strcmp(channelName, "intest") == 0 /*&& channelType == &CS_VAR_TYPE_K*/) {
105 MYFLT *v = (MYFLT *) channelValuePtr;
106 *v = 5.0;
107 }
108 if (strcmp(channelName, "instrtest") == 0 /*&& channelType == &CS_VAR_TYPE_S*/) {
109 char *v = (char *) channelValuePtr;
110 strcpy(v, "hello channels");
111 }
112 }
113
outputCallback(CSOUND * csound,const char * channelName,void * channelValuePtr,void * channelType)114 void outputCallback(CSOUND *csound,
115 const char *channelName,
116 void *channelValuePtr,
117 void *channelType)
118 {
119 (void) channelType; (void) csound;
120 if (strcmp(channelName, "intest") == 0 /*&& channelType == &CS_VAR_TYPE_K*/) {
121 MYFLT *v = (MYFLT *) channelValuePtr;
122 CU_ASSERT_DOUBLE_EQUAL(*v, 5.0, 0.0000001);
123 }
124 if (strcmp(channelName, "instrtest") == 0 /*&& channelType == &CS_VAR_TYPE_S*/) {
125 CU_ASSERT_STRING_EQUAL((char *) channelValuePtr, "hello channels");
126 }
127 if (strcmp(channelName, "outtest") == 0 /*&& channelType == &CS_VAR_TYPE_K*/) {
128 MYFLT *v = (MYFLT *) channelValuePtr;
129 CU_ASSERT_DOUBLE_EQUAL(*v, 10.0, 0.0000001);
130 }
131
132 }
133
test_channel_callbacks(void)134 void test_channel_callbacks(void)
135 {
136 csoundSetGlobalEnv("OPCODE6DIR64", "../../");
137 CSOUND *csound = csoundCreate(0);
138 csoundCreateMessageBuffer(csound, 0);
139 csoundSetOption(csound, "--logfile=null");
140 csoundCompileOrc(csound, orc3);
141 csoundSetInputChannelCallback(csound, (channelCallback_t) inputCallback);
142 csoundSetOutputChannelCallback(csound, (channelCallback_t) outputCallback);
143 int err = csoundStart(csound);
144 CU_ASSERT(err == CSOUND_SUCCESS);
145 MYFLT pFields[] = {1.0, 0.0, 1.0};
146 err = csoundScoreEvent(csound, 'i', pFields, 3);
147 MYFLT pFields2[] = {2.0, 0.0, 1.0};
148 err += csoundScoreEvent(csound, 'i', pFields2, 3);
149 CU_ASSERT(err == CSOUND_SUCCESS);
150 err = csoundPerformKsmps(csound);
151 CU_ASSERT(err == CSOUND_SUCCESS);
152 csoundCleanup(csound);
153 csoundDestroyMessageBuffer(csound);
154 csoundDestroy(csound);
155 }
156
157
158 const char orc4[] = "chn_k \"1\", 3\n"
159 "chn_k \"2\", 3\n"
160 "chn_k \"3\", 3\n"
161 "chn_k \"4\", 3\n"
162
163 "instr 1\n"
164 "kval invalue \"1\"\n"
165 "outvalue \"2\",kval\n"
166 "endin\n"
167
168 "instr 2\n"
169 "kval chani 2\n"
170 "chano kval + 1, 3\n"
171 "endin\n"
172
173 "instr 3\n"
174 "kval chnget \"3\"\n"
175 "chnset kval + 1, \"4\"\n"
176 "endin\n";
177
inputCallback2(CSOUND * csound,const char * channelName,void * channelValuePtr,void * channelType)178 void inputCallback2(CSOUND *csound,
179 const char *channelName,
180 void *channelValuePtr,
181 void *channelType)
182 {
183 (void) channelType;
184 MYFLT val = csoundGetControlChannel(csound, channelName, NULL);
185 MYFLT *valPtr = (MYFLT *) channelValuePtr;
186 *valPtr = val;
187 }
188
outputCallback2(CSOUND * csound,const char * channelName,void * channelValuePtr,void * channelType)189 void outputCallback2(CSOUND *csound,
190 const char *channelName,
191 void *channelValuePtr,
192 void *channelType)
193 {
194 (void) channelType;
195 MYFLT *valPtr = (MYFLT *) channelValuePtr;
196 csoundSetControlChannel(csound, channelName, *valPtr);
197 }
198
test_channel_opcodes(void)199 void test_channel_opcodes(void)
200 {
201 csoundSetGlobalEnv("OPCODE6DIR64", "../../");
202 CSOUND *csound = csoundCreate(0);
203 csoundCreateMessageBuffer(csound, 0);
204 csoundSetOption(csound, "--logfile=null");
205 csoundCompileOrc(csound, orc4);
206 csoundSetInputChannelCallback(csound, (channelCallback_t) inputCallback2);
207 csoundSetOutputChannelCallback(csound, (channelCallback_t) outputCallback2);
208 int err = csoundStart(csound);
209 CU_ASSERT(err == CSOUND_SUCCESS);
210 csoundGetControlChannel(csound, "1", &err);
211 CU_ASSERT(err == CSOUND_SUCCESS)
212 csoundSetControlChannel(csound, "1", 5.0);
213 MYFLT pFields[] = {1.0, 0.0, 1.0};
214 err = csoundScoreEvent(csound, 'i', pFields, 3);
215 err = csoundPerformKsmps(csound);
216 CU_ASSERT(err == CSOUND_SUCCESS);
217 CU_ASSERT_EQUAL(5.0, csoundGetControlChannel(csound, "2", NULL));
218 MYFLT pFields2[] = {2.0, 0.0, 1.0};
219 err = csoundScoreEvent(csound, 'i', pFields2, 3);
220 CU_ASSERT(err == CSOUND_SUCCESS);
221 err = csoundPerformKsmps(csound);
222 CU_ASSERT(err == CSOUND_SUCCESS);
223 CU_ASSERT_EQUAL(6.0, csoundGetControlChannel(csound, "3", NULL));
224 MYFLT pFields3[] = {3.0, 0.0, 1.0};
225 err = csoundScoreEvent(csound, 'i', pFields3, 3);
226 CU_ASSERT(err == CSOUND_SUCCESS);
227 err = csoundPerformKsmps(csound);
228 CU_ASSERT(err == CSOUND_SUCCESS);
229 CU_ASSERT_EQUAL(7.0, csoundGetControlChannel(csound, "4", NULL));
230
231 csoundCleanup(csound);
232 csoundDestroyMessageBuffer(csound);
233 csoundDestroy(csound);
234 }
235
236 const char orc5[] = "chn_k \"winsize\", 3\n"
237 "instr 1\n"
238 "finput pvsin 1 \n"
239 "ioverlap, inumbins, iwinsize, iformat pvsinfo finput\n"
240 "pvsout finput, 1\n"
241 "chnset iwinsize, \"winsize\"\n"
242 "endin\n";
243
test_pvs_opcodes(void)244 void test_pvs_opcodes(void)
245 {
246 csoundSetGlobalEnv("OPCODE6DIR64", "../../");
247 CSOUND *csound = csoundCreate(0);
248 csoundCreateMessageBuffer(csound, 0);
249 csoundSetOption(csound, "--logfile=null");
250 int err = csoundCompileOrc(csound, orc5);
251 CU_ASSERT(err == CSOUND_SUCCESS);
252 err = csoundStart(csound);
253 PVSDATEXT pvs_data, pvs_data2;
254 memset(&pvs_data,0,sizeof(PVSDATEXT));
255 memset(&pvs_data2,0,sizeof(PVSDATEXT));
256 pvs_data.N = 16;
257 pvs_data.winsize = 32;
258 err = csoundSetPvsChannel(csound, &pvs_data, "1");
259 err = csoundGetPvsChannel(csound, &pvs_data2, "1");
260 CU_ASSERT_EQUAL(pvs_data.N, pvs_data2.N);
261 MYFLT pFields[] = {1.0, 0.0, 1.0};
262 err = csoundScoreEvent(csound, 'i', pFields, 3);
263 err = csoundPerformKsmps(csound);
264 CU_ASSERT_EQUAL(32.0, csoundGetControlChannel(csound, "winsize", NULL));
265 csoundCleanup(csound);
266 csoundDestroyMessageBuffer(csound);
267 csoundDestroy(csound);
268 }
269
test_invalid_channel(void)270 void test_invalid_channel(void)
271 {
272 csoundSetGlobalEnv("OPCODE6DIR64", "../../");
273 CSOUND *csound = csoundCreate(0);
274 csoundCreateMessageBuffer(csound, 0);
275 csoundSetOption(csound, "--logfile=null");
276 csoundCompileOrc(csound, orc5);
277
278 int err;
279 CU_ASSERT_EQUAL(0.0, csoundGetControlChannel(csound, "nonexistent_channel", &err));
280 CU_ASSERT_EQUAL(err, CSOUND_SUCCESS);
281
282 csoundCleanup(csound);
283 csoundDestroyMessageBuffer(csound);
284 csoundDestroy(csound);
285
286 }
287
288 const char orc6[] = "chn_k \"chan\", 3, 2, 0.5, 0, 1, 10, 10, 50, 100\n"
289 "chn_k \"chan2\", 3, 2, 0.5, 0, 1, 10, 10, 50, 100, \"testattr\"\n"
290 "chn_k \"chan3\", 3, 2, 0.5, 0, 1\n"
291 "instr 1\n kval invalue \"1\"\n"
292 "outvalue \"2\",kval\n"
293 "endin\n";
294
test_chn_hints(void)295 void test_chn_hints(void)
296 {
297 csoundSetGlobalEnv("OPCODE6DIR64", "../../");
298 CSOUND *csound = csoundCreate(0);
299 csoundCreateMessageBuffer(csound, 0);
300 csoundSetOption(csound, "--logfile=null");
301 csoundCompileOrc(csound, orc6);
302 (void)csoundStart(csound);
303 // err = csoundPerformKsmps(csound); //Need this to load instr 0
304 controlChannelHints_t hints;
305 hints.attributes = 0;
306 CU_ASSERT_EQUAL(0, csoundGetControlChannelHints(csound, "chan", &hints));
307 CU_ASSERT_EQUAL(hints.x, 10);
308 CU_ASSERT_EQUAL(hints.y, 10);
309 CU_ASSERT_EQUAL(hints.width, 50);
310 CU_ASSERT_EQUAL(hints.height, 100);
311 CU_ASSERT_EQUAL(hints.attributes, 0);
312 CU_ASSERT_EQUAL(0, csoundGetControlChannelHints(csound, "chan2", &hints));
313 CU_ASSERT_EQUAL(hints.x, 10);
314 CU_ASSERT_EQUAL(hints.y, 10);
315 CU_ASSERT_EQUAL(hints.width, 50);
316 CU_ASSERT_EQUAL(hints.height, 100);
317 CU_ASSERT_STRING_EQUAL(hints.attributes, "testattr");
318
319 csoundCleanup(csound);
320 csoundDestroyMessageBuffer(csound);
321 csoundDestroy(csound);
322 }
323
324
test_string_channel(void)325 void test_string_channel(void)
326 {
327 const char orcS[] = "chn_S \"strchan1\",1\n chn_S \"strchan2\",2\n chn_S \"strchan3\",3\n instr 1\n endin\n";
328
329 csoundSetGlobalEnv("OPCODE6DIR64", "../../");
330 CSOUND *csound = csoundCreate(0);
331 csoundCreateMessageBuffer(csound, 0);
332 csoundSetOption(csound, "--logfile=NULL");
333 csoundCompileOrc(csound, orcS);
334 int err = csoundStart(csound);
335 CU_ASSERT(err == CSOUND_SUCCESS);
336
337 csoundSetStringChannel(csound, "testing", "ttt");
338 int len = csoundGetChannelDatasize(csound, "testing");
339 char string[len];
340 csoundGetStringChannel(csound, "testing", string);
341 CU_ASSERT_STRING_EQUAL(string, "ttt");
342
343 csoundSetStringChannel(csound, "strchan1", "strchan1_val");
344 csoundSetStringChannel(csound, "strchan2", "strchan2_val");
345 csoundSetStringChannel(csound, "strchan3", "strchan3_val");
346
347 csoundGetStringChannel(csound, "strchan1", string);
348 CU_ASSERT_STRING_EQUAL(string, "strchan1_val");
349
350 csoundGetStringChannel(csound, "strchan2", string);
351 CU_ASSERT_STRING_EQUAL(string, "strchan2_val");
352
353 csoundGetStringChannel(csound, "strchan3", string);
354 CU_ASSERT_STRING_EQUAL(string, "strchan3_val");
355
356 csoundCleanup(csound);
357 csoundDestroyMessageBuffer(csound);
358 csoundDestroy(csound);
359 }
360
main(void)361 int main(void)
362 {
363 CU_pSuite pSuite = NULL;
364
365 /* initialize the CUnit test registry */
366 if (CUE_SUCCESS != CU_initialize_registry())
367 return CU_get_error();
368
369 /* add a suite to the registry */
370 pSuite = CU_add_suite("Message Buffer Tests", init_suite1, clean_suite1);
371 if (NULL == pSuite) {
372 CU_cleanup_registry();
373 return CU_get_error();
374 }
375
376 /* add the tests to the suite */
377 if ((NULL == CU_add_test(pSuite, "Channel Lists", test_channel_list))
378 || (NULL == CU_add_test(pSuite, "Control channel", test_control_channel))
379 || (NULL == CU_add_test(pSuite, "Control channel parameters", test_control_channel_params))
380 || (NULL == CU_add_test(pSuite, "Callbacks", test_channel_callbacks))
381 || (NULL == CU_add_test(pSuite, "Opcodes", test_channel_opcodes))
382 || (NULL == CU_add_test(pSuite, "PVS Opcodes", test_pvs_opcodes))
383 || (NULL == CU_add_test(pSuite, "Invalid channels", test_invalid_channel))
384 || (NULL == CU_add_test(pSuite, "Channel hints", test_chn_hints))
385 || (NULL == CU_add_test(pSuite, "String channel", test_string_channel))
386 )
387 {
388 CU_cleanup_registry();
389 return CU_get_error();
390 }
391
392 /* Run all tests using the CUnit Basic interface */
393 CU_basic_set_mode(CU_BRM_VERBOSE);
394 CU_basic_run_tests();
395 CU_cleanup_registry();
396 return CU_get_error();
397 }
398
399