1 /**
2 * \file TestKineticLaw_newSetters.c
3 * \brief KineticLaw unit tests for new set function API
4 * \author Sarah Keating
5 *
6 * <!--------------------------------------------------------------------------
7 * This file is part of libSBML. Please visit http://sbml.org for more
8 * information about SBML, and the latest version of libSBML.
9 *
10 * Copyright (C) 2020 jointly by the following organizations:
11 * 1. California Institute of Technology, Pasadena, CA, USA
12 * 2. University of Heidelberg, Heidelberg, Germany
13 * 3. University College London, London, UK
14 *
15 * Copyright (C) 2019 jointly by the following organizations:
16 * 1. California Institute of Technology, Pasadena, CA, USA
17 * 2. University of Heidelberg, Heidelberg, Germany
18 *
19 * Copyright (C) 2013-2018 jointly by the following organizations:
20 * 1. California Institute of Technology, Pasadena, CA, USA
21 * 2. EMBL European Bioinformatics Institute (EMBL-EBI), Hinxton, UK
22 * 3. University of Heidelberg, Heidelberg, Germany
23 *
24 * Copyright (C) 2009-2013 jointly by the following organizations:
25 * 1. California Institute of Technology, Pasadena, CA, USA
26 * 2. EMBL European Bioinformatics Institute (EMBL-EBI), Hinxton, UK
27 *
28 * Copyright (C) 2006-2008 by the California Institute of Technology,
29 * Pasadena, CA, USA
30 *
31 * Copyright (C) 2002-2005 jointly by the following organizations:
32 * 1. California Institute of Technology, Pasadena, CA, USA
33 * 2. Japan Science and Technology Agency, Japan
34 *
35 * This library is free software; you can redistribute it and/or modify it
36 * under the terms of the GNU Lesser General Public License as published by
37 * the Free Software Foundation. A copy of the license agreement is provided
38 * in the file named "LICENSE.txt" included with this software distribution
39 * and also available online as http://sbml.org/software/libsbml/license.html
40 * ---------------------------------------------------------------------- -->*/
41
42 #include <sbml/common/common.h>
43
44 #include <sbml/math/FormulaFormatter.h>
45 #include <sbml/math/FormulaParser.h>
46
47 #include <sbml/SBase.h>
48 #include <sbml/Parameter.h>
49 #include <sbml/KineticLaw.h>
50 #include <sbml/xml/XMLNamespaces.h>
51 #include <sbml/SBMLDocument.h>
52
53 #include <check.h>
54
55
56
57 #include <sbml/common/extern.h>
58
59 LIBSBML_CPP_NAMESPACE_USE
60
61
62 BEGIN_C_DECLS
63
64 static KineticLaw_t *kl;
65
66
67 void
KineticLawTest1_setup(void)68 KineticLawTest1_setup (void)
69 {
70 kl = KineticLaw_create(2, 4);
71
72 if (kl == NULL)
73 {
74 fail("KineticLaw_create() returned a NULL pointer.");
75 }
76 }
77
78
79 void
KineticLawTest1_teardown(void)80 KineticLawTest1_teardown (void)
81 {
82 KineticLaw_free(kl);
83 }
84
85
86
START_TEST(test_KineticLaw_setFormula1)87 START_TEST (test_KineticLaw_setFormula1)
88 {
89 const char *formula = "k1*X0";
90
91 int i = KineticLaw_setFormula(kl, formula);
92
93 fail_unless( i == LIBSBML_OPERATION_SUCCESS);
94 fail_unless( !strcmp(KineticLaw_getFormula(kl), formula) );
95 fail_unless( KineticLaw_isSetFormula(kl) );
96 }
97 END_TEST
98
99
START_TEST(test_KineticLaw_setFormula2)100 START_TEST (test_KineticLaw_setFormula2)
101 {
102 int i = KineticLaw_setFormula(kl, NULL);
103
104 fail_unless( i == LIBSBML_OPERATION_SUCCESS);
105 fail_unless( !KineticLaw_isSetFormula(kl) );
106 }
107 END_TEST
108
109
START_TEST(test_KineticLaw_setFormula3)110 START_TEST (test_KineticLaw_setFormula3)
111 {
112 const char *formula = "k1 X0";
113
114 int i = KineticLaw_setFormula(kl, formula);
115
116 fail_unless( i == LIBSBML_INVALID_OBJECT);
117 fail_unless( !KineticLaw_isSetFormula(kl) );
118 }
119 END_TEST
120
121
START_TEST(test_KineticLaw_setMath1)122 START_TEST (test_KineticLaw_setMath1)
123 {
124 ASTNode_t *math = ASTNode_createWithType(AST_TIMES);
125 ASTNode_t *a = ASTNode_create();
126 ASTNode_t *b = ASTNode_create();
127 ASTNode_setName(a, "a");
128 ASTNode_setName(b, "b");
129 ASTNode_addChild(math, a);
130 ASTNode_addChild(math, b);
131 char *formula;
132 const ASTNode_t *math1;
133
134 int i = KineticLaw_setMath(kl, math);
135
136 fail_unless( i == LIBSBML_OPERATION_SUCCESS);
137 fail_unless( KineticLaw_isSetMath(kl) );
138
139 math1 = KineticLaw_getMath(kl);
140 fail_unless( math1 != NULL );
141
142 formula = SBML_formulaToString(math1);
143 fail_unless( formula != NULL );
144 fail_unless( !strcmp(formula, "a * b") );
145 safe_free(formula);
146
147 ASTNode_free(math);
148 }
149 END_TEST
150
151
START_TEST(test_KineticLaw_setMath2)152 START_TEST (test_KineticLaw_setMath2)
153 {
154 ASTNode_t *math = ASTNode_createWithType(AST_DIVIDE);
155 ASTNode_t *a = ASTNode_create();
156 ASTNode_setName(a, "a");
157 ASTNode_addChild(math, a);
158
159 int i = KineticLaw_setMath(kl, math);
160
161 fail_unless( i == LIBSBML_INVALID_OBJECT);
162 fail_unless( !KineticLaw_isSetMath(kl) );
163
164 ASTNode_free(math);
165 }
166 END_TEST
167
168
START_TEST(test_KineticLaw_setMath3)169 START_TEST (test_KineticLaw_setMath3)
170 {
171 int i = KineticLaw_setMath(kl, NULL);
172
173 fail_unless( i == LIBSBML_OPERATION_SUCCESS);
174 fail_unless( !KineticLaw_isSetMath(kl) );
175 }
176 END_TEST
177
178
START_TEST(test_KineticLaw_setTimeUnits1)179 START_TEST (test_KineticLaw_setTimeUnits1)
180 {
181 int i = KineticLaw_setTimeUnits(kl, "second");
182
183 fail_unless( i == LIBSBML_UNEXPECTED_ATTRIBUTE);
184 fail_unless( !KineticLaw_isSetTimeUnits(kl) );
185
186 i = KineticLaw_unsetTimeUnits(kl);
187
188 fail_unless( i == LIBSBML_UNEXPECTED_ATTRIBUTE);
189 fail_unless( !KineticLaw_isSetTimeUnits(kl) );
190 }
191 END_TEST
192
193
START_TEST(test_KineticLaw_setTimeUnits2)194 START_TEST (test_KineticLaw_setTimeUnits2)
195 {
196 KineticLaw_t *kl1 =
197 KineticLaw_create(1, 2);
198
199 int i = KineticLaw_setTimeUnits(kl1, "second");
200
201 fail_unless( i == LIBSBML_OPERATION_SUCCESS);
202 fail_unless( KineticLaw_isSetTimeUnits(kl1) );
203
204 i = KineticLaw_unsetTimeUnits(kl1);
205
206 fail_unless( i == LIBSBML_OPERATION_SUCCESS);
207 fail_unless( !KineticLaw_isSetTimeUnits(kl1) );
208
209 KineticLaw_free(kl1);
210 }
211 END_TEST
212
213
START_TEST(test_KineticLaw_setTimeUnits3)214 START_TEST (test_KineticLaw_setTimeUnits3)
215 {
216 KineticLaw_t *kl1 =
217 KineticLaw_create(1, 2);
218
219 int i = KineticLaw_setTimeUnits(kl1, "1second");
220
221 fail_unless( i == LIBSBML_INVALID_ATTRIBUTE_VALUE);
222 fail_unless( !KineticLaw_isSetTimeUnits(kl1) );
223
224 i = KineticLaw_unsetTimeUnits(kl1);
225
226 fail_unless( i == LIBSBML_OPERATION_SUCCESS);
227 fail_unless( !KineticLaw_isSetTimeUnits(kl1) );
228
229 KineticLaw_free(kl1);
230 }
231 END_TEST
232
233
START_TEST(test_KineticLaw_setTimeUnits4)234 START_TEST (test_KineticLaw_setTimeUnits4)
235 {
236 KineticLaw_t *kl1 =
237 KineticLaw_create(1, 2);
238
239 int i = KineticLaw_setTimeUnits(kl1, NULL);
240
241 fail_unless( i == LIBSBML_OPERATION_SUCCESS);
242 fail_unless( !KineticLaw_isSetTimeUnits(kl1) );
243
244 KineticLaw_free(kl1);
245 }
246 END_TEST
247
248
START_TEST(test_KineticLaw_setSubstanceUnits1)249 START_TEST (test_KineticLaw_setSubstanceUnits1)
250 {
251 int i = KineticLaw_setSubstanceUnits(kl, "mole");
252
253 fail_unless( i == LIBSBML_UNEXPECTED_ATTRIBUTE);
254 fail_unless( !KineticLaw_isSetSubstanceUnits(kl) );
255
256 i = KineticLaw_unsetSubstanceUnits(kl);
257
258 fail_unless( i == LIBSBML_UNEXPECTED_ATTRIBUTE);
259 fail_unless( !KineticLaw_isSetSubstanceUnits(kl) );
260 }
261 END_TEST
262
263
START_TEST(test_KineticLaw_setSubstanceUnits2)264 START_TEST (test_KineticLaw_setSubstanceUnits2)
265 {
266 KineticLaw_t *kl1 =
267 KineticLaw_create(1, 2);
268
269 int i = KineticLaw_setSubstanceUnits(kl1, "mole");
270
271 fail_unless( i == LIBSBML_OPERATION_SUCCESS);
272 fail_unless( KineticLaw_isSetSubstanceUnits(kl1) );
273
274 i = KineticLaw_unsetSubstanceUnits(kl1);
275
276 fail_unless( i == LIBSBML_OPERATION_SUCCESS);
277 fail_unless( !KineticLaw_isSetSubstanceUnits(kl1) );
278
279 KineticLaw_free(kl1);
280 }
281 END_TEST
282
283
START_TEST(test_KineticLaw_setSubstanceUnits3)284 START_TEST (test_KineticLaw_setSubstanceUnits3)
285 {
286 KineticLaw_t *kl1 =
287 KineticLaw_create(1, 2);
288
289 int i = KineticLaw_setSubstanceUnits(kl1, "1second");
290
291 fail_unless( i == LIBSBML_INVALID_ATTRIBUTE_VALUE);
292 fail_unless( !KineticLaw_isSetSubstanceUnits(kl1) );
293
294 i = KineticLaw_unsetSubstanceUnits(kl1);
295
296 fail_unless( i == LIBSBML_OPERATION_SUCCESS);
297 fail_unless( !KineticLaw_isSetSubstanceUnits(kl1) );
298
299 KineticLaw_free(kl1);
300 }
301 END_TEST
302
303
START_TEST(test_KineticLaw_setSubstanceUnits4)304 START_TEST (test_KineticLaw_setSubstanceUnits4)
305 {
306 KineticLaw_t *kl1 =
307 KineticLaw_create(1, 2);
308
309 int i = KineticLaw_setSubstanceUnits(kl1, NULL);
310
311 fail_unless( i == LIBSBML_OPERATION_SUCCESS);
312 fail_unless( !KineticLaw_isSetSubstanceUnits(kl1) );
313
314 KineticLaw_free(kl1);
315 }
316 END_TEST
317
318
START_TEST(test_KineticLaw_addParameter1)319 START_TEST (test_KineticLaw_addParameter1)
320 {
321 KineticLaw_t *kl = KineticLaw_create(2, 2);
322 Parameter_t *p
323 = Parameter_create(2, 2);
324
325 int i = KineticLaw_addParameter(kl, p);
326
327 fail_unless( i == LIBSBML_INVALID_OBJECT);
328
329 Parameter_setId(p, "p");
330 i = KineticLaw_addParameter(kl, p);
331
332 fail_unless( i == LIBSBML_OPERATION_SUCCESS);
333 fail_unless( KineticLaw_getNumParameters(kl) == 1);
334
335 Parameter_free(p);
336 KineticLaw_free(kl);
337 }
338 END_TEST
339
340
START_TEST(test_KineticLaw_addParameter2)341 START_TEST (test_KineticLaw_addParameter2)
342 {
343 KineticLaw_t *kl = KineticLaw_create(2, 2);
344 Parameter_t *p
345 = Parameter_create(2, 1);
346 Parameter_setId(p, "p");
347
348 int i = KineticLaw_addParameter(kl, p);
349
350 fail_unless( i == LIBSBML_VERSION_MISMATCH);
351 fail_unless( KineticLaw_getNumParameters(kl) == 0);
352
353 Parameter_free(p);
354 KineticLaw_free(kl);
355 }
356 END_TEST
357
358
START_TEST(test_KineticLaw_addParameter3)359 START_TEST (test_KineticLaw_addParameter3)
360 {
361 KineticLaw_t *kl = KineticLaw_create(2, 2);
362 Parameter_t *p
363 = Parameter_create(1, 2);
364 Parameter_setId(p, "p");
365
366 int i = KineticLaw_addParameter(kl, p);
367
368 fail_unless( i == LIBSBML_LEVEL_MISMATCH);
369 fail_unless( KineticLaw_getNumParameters(kl) == 0);
370
371 Parameter_free(p);
372 KineticLaw_free(kl);
373 }
374 END_TEST
375
376
START_TEST(test_KineticLaw_addParameter4)377 START_TEST (test_KineticLaw_addParameter4)
378 {
379 KineticLaw_t *kl = KineticLaw_create(2, 2);
380 Parameter_t *p = NULL;
381
382 int i = KineticLaw_addParameter(kl, p);
383
384 fail_unless( i == LIBSBML_OPERATION_FAILED);
385 fail_unless( KineticLaw_getNumParameters(kl) == 0);
386
387 KineticLaw_free(kl);
388 }
389 END_TEST
390
391
START_TEST(test_KineticLaw_createParameter)392 START_TEST (test_KineticLaw_createParameter)
393 {
394 KineticLaw_t *kl = KineticLaw_create(2, 2);
395
396 Parameter_t *p = KineticLaw_createParameter(kl);
397
398 fail_unless( KineticLaw_getNumParameters(kl) == 1);
399 fail_unless( SBase_getLevel((SBase_t *) (p)) == 2 );
400 fail_unless( SBase_getVersion((SBase_t *) (p)) == 2 );
401
402 KineticLaw_free(kl);
403 }
404 END_TEST
405
406
407 Suite *
create_suite_KineticLaw_newSetters(void)408 create_suite_KineticLaw_newSetters (void)
409 {
410 Suite *suite = suite_create("KineticLaw_newSetters");
411 TCase *tcase = tcase_create("KineticLaw_newSetters");
412
413
414 tcase_add_checked_fixture( tcase,
415 KineticLawTest1_setup,
416 KineticLawTest1_teardown );
417
418 tcase_add_test( tcase, test_KineticLaw_setFormula1 );
419 tcase_add_test( tcase, test_KineticLaw_setFormula2 );
420 tcase_add_test( tcase, test_KineticLaw_setFormula3 );
421 tcase_add_test( tcase, test_KineticLaw_setMath1 );
422 tcase_add_test( tcase, test_KineticLaw_setMath2 );
423 tcase_add_test( tcase, test_KineticLaw_setMath3 );
424 tcase_add_test( tcase, test_KineticLaw_setTimeUnits1 );
425 tcase_add_test( tcase, test_KineticLaw_setTimeUnits2 );
426 tcase_add_test( tcase, test_KineticLaw_setTimeUnits3 );
427 tcase_add_test( tcase, test_KineticLaw_setTimeUnits4 );
428 tcase_add_test( tcase, test_KineticLaw_setSubstanceUnits1 );
429 tcase_add_test( tcase, test_KineticLaw_setSubstanceUnits2 );
430 tcase_add_test( tcase, test_KineticLaw_setSubstanceUnits3 );
431 tcase_add_test( tcase, test_KineticLaw_setSubstanceUnits4 );
432 tcase_add_test( tcase, test_KineticLaw_addParameter1 );
433 tcase_add_test( tcase, test_KineticLaw_addParameter2 );
434 tcase_add_test( tcase, test_KineticLaw_addParameter3 );
435 tcase_add_test( tcase, test_KineticLaw_addParameter4 );
436 tcase_add_test( tcase, test_KineticLaw_createParameter );
437
438 suite_add_tcase(suite, tcase);
439
440 return suite;
441 }
442
443 END_C_DECLS
444
445
446