1 /* GSequencer - Advanced GTK Sequencer
2 * Copyright (C) 2018 Joël Krähemann
3 *
4 * This file is part of GSequencer.
5 *
6 * GSequencer is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * GSequencer is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with GSequencer. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include <glib.h>
21 #include <glib-object.h>
22
23 #include <ags/libags.h>
24 #include <ags/libags-audio.h>
25
26 #include <CUnit/CUnit.h>
27 #include <CUnit/Automated.h>
28 #include <CUnit/Basic.h>
29
30 int ags_ladspa_conversion_test_init_suite();
31 int ags_ladspa_conversion_test_clean_suite();
32
33 void ags_ladspa_conversion_test_test_flags();
34 void ags_ladspa_conversion_test_set_flags();
35 void ags_ladspa_conversion_test_unset_flags();
36 void ags_ladspa_conversion_test_convert();
37
38 #define AGS_LADSPA_CONVERSION_TEST_CONVERT_SAMPLERATE (44100)
39
40 /* The suite initialization time.
41 * Opens the temporary file used by the tests.
42 * Returns zero on success, non-zero otherwise.
43 */
44 int
ags_ladspa_conversion_test_init_suite()45 ags_ladspa_conversion_test_init_suite()
46 {
47 return(0);
48 }
49
50 /* The suite cleanup time.
51 * Closes the temporary file used by the tests.
52 * Returns zero on success, non-zero otherwise.
53 */
54 int
ags_ladspa_conversion_test_clean_suite()55 ags_ladspa_conversion_test_clean_suite()
56 {
57 return(0);
58 }
59
60 void
ags_ladspa_conversion_test_test_flags()61 ags_ladspa_conversion_test_test_flags()
62 {
63 AgsLadspaConversion *ladspa_conversion;
64
65 ladspa_conversion = ags_ladspa_conversion_new();
66 ladspa_conversion->flags = 0;
67
68 /* test flags - samplerate */
69 CU_ASSERT(!ags_ladspa_conversion_test_flags(ladspa_conversion, AGS_LADSPA_CONVERSION_SAMPLERATE));
70
71 /* test flags - bounded below */
72 CU_ASSERT(!ags_ladspa_conversion_test_flags(ladspa_conversion, AGS_LADSPA_CONVERSION_BOUNDED_BELOW));
73
74 /* test flags - bounded above */
75 CU_ASSERT(!ags_ladspa_conversion_test_flags(ladspa_conversion, AGS_LADSPA_CONVERSION_BOUNDED_ABOVE));
76
77 /* test flags - logarithmic */
78 CU_ASSERT(!ags_ladspa_conversion_test_flags(ladspa_conversion, AGS_LADSPA_CONVERSION_LOGARITHMIC));
79
80 /* set flags */
81 ladspa_conversion->flags = (AGS_LADSPA_CONVERSION_SAMPLERATE |
82 AGS_LADSPA_CONVERSION_BOUNDED_BELOW |
83 AGS_LADSPA_CONVERSION_BOUNDED_ABOVE |
84 AGS_LADSPA_CONVERSION_LOGARITHMIC);
85
86 /* test flags - samplerate */
87 CU_ASSERT(ags_ladspa_conversion_test_flags(ladspa_conversion, AGS_LADSPA_CONVERSION_SAMPLERATE));
88
89 /* test flags - bounded below */
90 CU_ASSERT(ags_ladspa_conversion_test_flags(ladspa_conversion, AGS_LADSPA_CONVERSION_BOUNDED_BELOW));
91
92 /* test flags - bounded above */
93 CU_ASSERT(ags_ladspa_conversion_test_flags(ladspa_conversion, AGS_LADSPA_CONVERSION_BOUNDED_ABOVE));
94
95 /* test flags - logarithmic */
96 CU_ASSERT(ags_ladspa_conversion_test_flags(ladspa_conversion, AGS_LADSPA_CONVERSION_LOGARITHMIC));
97 }
98
99 void
ags_ladspa_conversion_test_set_flags()100 ags_ladspa_conversion_test_set_flags()
101 {
102 AgsLadspaConversion *ladspa_conversion;
103
104 ladspa_conversion = ags_ladspa_conversion_new();
105 ladspa_conversion->flags = 0;
106
107 /* set flags - samplerate */
108 ags_ladspa_conversion_set_flags(ladspa_conversion, AGS_LADSPA_CONVERSION_SAMPLERATE);
109
110 CU_ASSERT((AGS_LADSPA_CONVERSION_SAMPLERATE & (ladspa_conversion->flags)) != 0);
111
112 /* set flags - bounded below */
113 ags_ladspa_conversion_set_flags(ladspa_conversion, AGS_LADSPA_CONVERSION_BOUNDED_BELOW);
114
115 CU_ASSERT((AGS_LADSPA_CONVERSION_BOUNDED_BELOW & (ladspa_conversion->flags)) != 0);
116
117 /* set flags - bounded above */
118 ags_ladspa_conversion_set_flags(ladspa_conversion, AGS_LADSPA_CONVERSION_BOUNDED_ABOVE);
119
120 CU_ASSERT((AGS_LADSPA_CONVERSION_BOUNDED_ABOVE & (ladspa_conversion->flags)) != 0);
121
122 /* set flags - logarithmic */
123 ags_ladspa_conversion_set_flags(ladspa_conversion, AGS_LADSPA_CONVERSION_LOGARITHMIC);
124
125 CU_ASSERT((AGS_LADSPA_CONVERSION_LOGARITHMIC & (ladspa_conversion->flags)) != 0);
126 }
127
128 void
ags_ladspa_conversion_test_unset_flags()129 ags_ladspa_conversion_test_unset_flags()
130 {
131 AgsLadspaConversion *ladspa_conversion;
132
133 ladspa_conversion = ags_ladspa_conversion_new();
134
135 ladspa_conversion->flags = (AGS_LADSPA_CONVERSION_SAMPLERATE |
136 AGS_LADSPA_CONVERSION_BOUNDED_BELOW |
137 AGS_LADSPA_CONVERSION_BOUNDED_ABOVE |
138 AGS_LADSPA_CONVERSION_LOGARITHMIC);
139
140 /* unset flags - samplerate */
141 ags_ladspa_conversion_unset_flags(ladspa_conversion, AGS_LADSPA_CONVERSION_SAMPLERATE);
142
143 CU_ASSERT((AGS_LADSPA_CONVERSION_SAMPLERATE & (ladspa_conversion->flags)) == 0);
144
145 /* unset flags - bounded below */
146 ags_ladspa_conversion_unset_flags(ladspa_conversion, AGS_LADSPA_CONVERSION_BOUNDED_BELOW);
147
148 CU_ASSERT((AGS_LADSPA_CONVERSION_BOUNDED_BELOW & (ladspa_conversion->flags)) == 0);
149
150 /* unset flags - bounded above */
151 ags_ladspa_conversion_unset_flags(ladspa_conversion, AGS_LADSPA_CONVERSION_BOUNDED_ABOVE);
152
153 CU_ASSERT((AGS_LADSPA_CONVERSION_BOUNDED_ABOVE & (ladspa_conversion->flags)) == 0);
154
155 /* unset flags - logarithmic */
156 ags_ladspa_conversion_unset_flags(ladspa_conversion, AGS_LADSPA_CONVERSION_LOGARITHMIC);
157
158 CU_ASSERT((AGS_LADSPA_CONVERSION_LOGARITHMIC & (ladspa_conversion->flags)) == 0);
159 }
160
161 void
ags_ladspa_conversion_test_convert()162 ags_ladspa_conversion_test_convert()
163 {
164 AgsLadspaConversion *ladspa_conversion;
165
166 gdouble retval;
167
168 ladspa_conversion = ags_ladspa_conversion_new();
169 g_object_set(ladspa_conversion,
170 "samplerate", AGS_LADSPA_CONVERSION_TEST_CONVERT_SAMPLERATE,
171 NULL);
172
173 /* convert - #0 */
174 ags_ladspa_conversion_set_flags(ladspa_conversion, AGS_LADSPA_CONVERSION_LOGARITHMIC);
175
176 retval = ags_conversion_convert(ladspa_conversion,
177 0.25,
178 FALSE);
179 CU_ASSERT(retval != 0.0);
180
181 retval = ags_conversion_convert(ladspa_conversion,
182 exp(0.25),
183 TRUE);
184 CU_ASSERT(retval != 0.0);
185
186 /* convert - #1 */
187 ags_ladspa_conversion_set_flags(ladspa_conversion, AGS_LADSPA_CONVERSION_SAMPLERATE);
188
189 retval = ags_conversion_convert(ladspa_conversion,
190 0.25,
191 FALSE);
192 CU_ASSERT(retval != 0.0);
193
194 retval = ags_conversion_convert(ladspa_conversion,
195 exp(0.25),
196 TRUE);
197 CU_ASSERT(retval != 0.0);
198 }
199
200 int
main(int argc,char ** argv)201 main(int argc, char **argv)
202 {
203 CU_pSuite pSuite = NULL;
204
205 /* initialize the CUnit test registry */
206 if(CUE_SUCCESS != CU_initialize_registry()){
207 return CU_get_error();
208 }
209
210 /* add a suite to the registry */
211 pSuite = CU_add_suite("AgsLadspaConversionTest", ags_ladspa_conversion_test_init_suite, ags_ladspa_conversion_test_clean_suite);
212
213 if(pSuite == NULL){
214 CU_cleanup_registry();
215
216 return CU_get_error();
217 }
218
219 /* add the tests to the suite */
220 if((CU_add_test(pSuite, "test of AgsLadspaConversion test flags", ags_ladspa_conversion_test_test_flags) == NULL) ||
221 (CU_add_test(pSuite, "test of AgsLadspaConversion set flags", ags_ladspa_conversion_test_set_flags) == NULL) ||
222 (CU_add_test(pSuite, "test of AgsLadspaConversion unset flags", ags_ladspa_conversion_test_unset_flags) == NULL) ||
223 (CU_add_test(pSuite, "test of AgsLadspaConversion convert", ags_ladspa_conversion_test_convert) == NULL)){
224 CU_cleanup_registry();
225
226 return CU_get_error();
227 }
228
229 /* Run all tests using the CUnit Basic interface */
230 CU_basic_set_mode(CU_BRM_VERBOSE);
231 CU_basic_run_tests();
232
233 CU_cleanup_registry();
234
235 return(CU_get_error());
236 }
237