1 /**
2 * \file TestModel.c
3 * \brief SBML Model unit tests
4 * \author Ben Bornstein
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 #include <sbml/SBMLTypes.h>
44 #include <sbml/xml/XMLNamespaces.h>
45 #include <sbml/SBMLDocument.h>
46
47 #include <check.h>
48
49
50
51 #include <sbml/common/extern.h>
52
53 LIBSBML_CPP_NAMESPACE_USE
54
55
56 BEGIN_C_DECLS
57
58 static Model_t *M;
59
60
61 void
ModelTest_setup(void)62 ModelTest_setup (void)
63 {
64 M = Model_create(2, 4);
65
66 if (M == NULL)
67 {
68 fail("Model_create() returned a NULL pointer.");
69 }
70 }
71
72
73 void
ModelTest_teardown(void)74 ModelTest_teardown (void)
75 {
76 Model_free(M);
77 }
78
79
START_TEST(test_Model_create)80 START_TEST (test_Model_create)
81 {
82 fail_unless( SBase_getTypeCode ((SBase_t *) M) == SBML_MODEL );
83 fail_unless( SBase_getMetaId ((SBase_t *) M) == NULL );
84 fail_unless( SBase_getNotes ((SBase_t *) M) == NULL );
85 fail_unless( SBase_getAnnotation((SBase_t *) M) == NULL );
86
87 fail_unless( Model_getId (M) == NULL );
88 fail_unless( Model_getName(M) == NULL );
89
90 fail_unless( !Model_isSetId(M) );
91 fail_unless( !Model_isSetName(M) );
92
93 fail_unless( Model_getNumUnitDefinitions(M) == 0 );
94 fail_unless( Model_getNumCompartments (M) == 0 );
95 fail_unless( Model_getNumSpecies (M) == 0 );
96 fail_unless( Model_getNumParameters (M) == 0 );
97 fail_unless( Model_getNumReactions (M) == 0 );
98 }
99 END_TEST
100
101
START_TEST(test_Model_free_NULL)102 START_TEST (test_Model_free_NULL)
103 {
104 Model_free(NULL);
105 }
106 END_TEST
107
108
109 //START_TEST (test_Model_createWith)
110 //{
111 // Model_t *m = Model_createWith("repressilator", "");
112 //
113 //
114 // fail_unless( SBase_getTypeCode ((SBase_t *) m) == SBML_MODEL );
115 // fail_unless( SBase_getMetaId ((SBase_t *) m) == NULL );
116 // fail_unless( SBase_getNotes ((SBase_t *) m) == NULL );
117 // fail_unless( SBase_getAnnotation((SBase_t *) m) == NULL );
118 //
119 // fail_unless( Model_getName(m) == NULL );
120 //
121 // fail_unless( !strcmp(Model_getId(m), "repressilator") );
122 // fail_unless( Model_isSetId(m) );
123 //
124 // fail_unless( Model_getNumUnitDefinitions(m) == 0 );
125 // fail_unless( Model_getNumFunctionDefinitions(m) == 0 );
126 // fail_unless( Model_getNumCompartments (m) == 0 );
127 // fail_unless( Model_getNumSpecies (m) == 0 );
128 // fail_unless( Model_getNumParameters (m) == 0 );
129 // fail_unless( Model_getNumReactions (m) == 0 );
130 // fail_unless( Model_getNumRules (m) == 0 );
131 // fail_unless( Model_getNumConstraints (m) == 0 );
132 // fail_unless( Model_getNumEvents (m) == 0 );
133 // fail_unless( Model_getNumCompartmentTypes(m) == 0 );
134 // fail_unless( Model_getNumSpeciesTypes (m) == 0 );
135 // fail_unless( Model_getNumInitialAssignments (m) == 0 );
136 //
137 // Model_free(m);
138 //}
139 //END_TEST
140
141
START_TEST(test_Model_setId)142 START_TEST (test_Model_setId)
143 {
144 const char *id = "Branch";
145
146
147 Model_setId(M, id);
148
149 fail_unless( !strcmp(Model_getId(M), id) );
150 fail_unless( Model_isSetId(M) );
151
152 if (Model_getId(M) == id)
153 {
154 fail("Model_setId(...) did not make a copy of string.");
155 }
156
157 /* Reflexive case (pathological) */
158 Model_setId(M, Model_getId(M));
159 fail_unless( !strcmp(Model_getId(M), id) );
160
161 Model_setId(M, NULL);
162 fail_unless( !Model_isSetId(M) );
163
164 if (Model_getId(M) != NULL)
165 {
166 fail("Model_setId(M, NULL) did not clear string.");
167 }
168
169 Model_setId(M, id);
170 Model_unsetId(M);
171 fail_unless( !Model_isSetId(M) );
172
173 }
174 END_TEST
175
176
START_TEST(test_Model_setName)177 START_TEST (test_Model_setName)
178 {
179 const char *name = "My_Branch_Model";
180
181
182 Model_setName(M, name);
183
184 fail_unless( !strcmp(Model_getName(M), name) );
185 fail_unless( Model_isSetName(M) );
186
187 if (Model_getName(M) == name)
188 {
189 fail("Model_setName(...) did not make a copy of string.");
190 }
191
192 /* Reflexive case (pathological) */
193 Model_setName(M, Model_getName(M));
194 fail_unless( !strcmp(Model_getName(M), name) );
195
196 Model_setName(M, NULL);
197 fail_unless( !Model_isSetName(M) );
198
199 if (Model_getName(M) != NULL)
200 {
201 fail("Model_setName(M, NULL) did not clear string.");
202 }
203 }
204 END_TEST
205
START_TEST(test_Model_setgetModelHistory)206 START_TEST(test_Model_setgetModelHistory)
207 {
208 SBase_setMetaId((SBase_t *) (M), "_001");
209 ModelHistory_t * history = ModelHistory_create();
210 ModelCreator_t * mc = ModelCreator_create();
211 Date_t * date =
212 Date_createFromValues(2005, 12, 30, 12, 15, 45, 1, 2, 0);
213
214 ModelCreator_setFamilyName(mc, "Keating");
215 ModelCreator_setGivenName(mc, "Sarah");
216 ModelCreator_setEmail(mc, "sbml-team@caltech.edu");
217 ModelCreator_setOrganisation(mc, "UH");
218
219 ModelHistory_addCreator(history, mc);
220 ModelHistory_setCreatedDate(history, date);
221 ModelHistory_setModifiedDate(history, date);
222
223 fail_unless(Model_isSetModelHistory(M) == 0);
224
225 Model_setModelHistory(M, history);
226
227 fail_unless(Model_isSetModelHistory(M) == 1);
228
229 ModelCreator_t *newMC = ModelHistory_getCreator(history, 0);
230
231 fail_unless(newMC != NULL);
232
233 fail_unless(!strcmp(ModelCreator_getFamilyName(newMC), "Keating"));
234 fail_unless(!strcmp(ModelCreator_getGivenName(newMC), "Sarah"));
235 fail_unless(!strcmp(ModelCreator_getEmail(newMC), "sbml-team@caltech.edu"));
236 fail_unless(!strcmp(ModelCreator_getOrganisation(newMC), "UH"));
237
238 Model_unsetModelHistory(M);
239 fail_unless(Model_isSetModelHistory(M) == 0);
240
241
242 ModelHistory_free(history);
243 ModelCreator_free(mc);
244 Date_free(date);
245 }
246 END_TEST
247
248
START_TEST(test_Model_createFunctionDefinition)249 START_TEST (test_Model_createFunctionDefinition)
250 {
251 FunctionDefinition_t *fd = Model_createFunctionDefinition(M);
252
253
254 fail_unless( fd != NULL );
255 fail_unless( Model_getNumFunctionDefinitions(M) == 1 );
256 fail_unless( Model_getFunctionDefinition(M, 0) == fd );
257 }
258 END_TEST
259
260
START_TEST(test_Model_createUnitDefinition)261 START_TEST (test_Model_createUnitDefinition)
262 {
263 UnitDefinition_t *ud = Model_createUnitDefinition(M);
264
265
266 fail_unless( ud != NULL );
267 fail_unless( Model_getNumUnitDefinitions(M) == 1 );
268 fail_unless( Model_getUnitDefinition(M, 0) == ud );
269 }
270 END_TEST
271
272
START_TEST(test_Model_createUnit)273 START_TEST (test_Model_createUnit)
274 {
275 UnitDefinition_t *ud;
276 Unit_t *u;
277
278
279 Model_createUnitDefinition(M);
280 Model_createUnitDefinition(M);
281
282 u = Model_createUnit(M);
283
284 fail_unless( u != NULL );
285 fail_unless( Model_getNumUnitDefinitions(M) == 2 );
286
287 ud = Model_getUnitDefinition(M, 1);
288
289 fail_unless( UnitDefinition_getNumUnits(ud) == 1 );
290 fail_unless( UnitDefinition_getUnit(ud, 0) == u );
291 }
292 END_TEST
293
294
START_TEST(test_Model_createUnit_noUnitDefinition)295 START_TEST (test_Model_createUnit_noUnitDefinition)
296 {
297 fail_unless( Model_getNumUnitDefinitions(M) == 0 );
298 fail_unless( Model_createUnit(M) == NULL );
299 }
300 END_TEST
301
302
START_TEST(test_Model_createCompartment)303 START_TEST (test_Model_createCompartment)
304 {
305 Compartment_t *c = Model_createCompartment(M);
306
307
308 fail_unless( c != NULL );
309 fail_unless( Model_getNumCompartments(M) == 1 );
310 fail_unless( Model_getCompartment(M, 0) == c );
311 }
312 END_TEST
313
314
START_TEST(test_Model_createCompartmentType)315 START_TEST (test_Model_createCompartmentType)
316 {
317 CompartmentType_t *c = Model_createCompartmentType(M);
318
319
320 fail_unless( c != NULL );
321 fail_unless( Model_getNumCompartmentTypes(M) == 1 );
322 fail_unless( Model_getCompartmentType(M, 0) == c );
323 }
324 END_TEST
325
326
START_TEST(test_Model_createSpeciesType)327 START_TEST (test_Model_createSpeciesType)
328 {
329 SpeciesType_t *c = Model_createSpeciesType(M);
330
331
332 fail_unless( c != NULL );
333 fail_unless( Model_getNumSpeciesTypes(M) == 1 );
334 fail_unless( Model_getSpeciesType(M, 0) == c );
335 }
336 END_TEST
337
338
START_TEST(test_Model_createInitialAssignment)339 START_TEST (test_Model_createInitialAssignment)
340 {
341 InitialAssignment_t *c = Model_createInitialAssignment(M);
342
343
344 fail_unless( c != NULL );
345 fail_unless( Model_getNumInitialAssignments(M) == 1 );
346 fail_unless( Model_getInitialAssignment(M, 0) == c );
347 }
348 END_TEST
349
350
START_TEST(test_Model_createConstraint)351 START_TEST (test_Model_createConstraint)
352 {
353 Constraint_t *c = Model_createConstraint(M);
354
355
356 fail_unless( c != NULL );
357 fail_unless( Model_getNumConstraints(M) == 1 );
358 fail_unless( Model_getConstraint(M, 0) == c );
359 }
360 END_TEST
361
362
START_TEST(test_Model_createSpecies)363 START_TEST (test_Model_createSpecies)
364 {
365 Species_t *s = Model_createSpecies(M);
366
367
368 fail_unless( s != NULL );
369 fail_unless( Model_getNumSpecies(M) == 1 );
370 fail_unless( Model_getSpecies(M, 0) == s );
371 }
372 END_TEST
373
374
START_TEST(test_Model_createParameter)375 START_TEST (test_Model_createParameter)
376 {
377 Parameter_t *p = Model_createParameter(M);
378
379
380 fail_unless( p != NULL );
381 fail_unless( Model_getNumParameters(M) == 1 );
382 fail_unless( Model_getParameter(M, 0) == p );
383 }
384 END_TEST
385
386
START_TEST(test_Model_createAssignmentRule)387 START_TEST (test_Model_createAssignmentRule)
388 {
389 Rule_t *ar = Model_createAssignmentRule(M);
390
391
392 fail_unless( ar != NULL );
393 fail_unless( Model_getNumRules(M) == 1 );
394 fail_unless( Model_getRule(M, 0) == (Rule_t *) ar );
395 }
396 END_TEST
397
398
START_TEST(test_Model_createRateRule)399 START_TEST (test_Model_createRateRule)
400 {
401 Rule_t *rr = Model_createRateRule(M);
402
403
404 fail_unless( rr != NULL );
405 fail_unless( Model_getNumRules(M) == 1 );
406 fail_unless( Model_getRule(M, 0) == (Rule_t *) rr );
407 }
408 END_TEST
409
410
START_TEST(test_Model_createAlgebraicRule)411 START_TEST (test_Model_createAlgebraicRule)
412 {
413 Rule_t *ar = Model_createAlgebraicRule(M);
414
415
416 fail_unless( ar != NULL );
417 fail_unless( Model_getNumRules(M) == 1 );
418 fail_unless( Model_getRule(M, 0) == (Rule_t *) ar );
419 }
420 END_TEST
421
START_TEST(test_Model_createReaction)422 START_TEST (test_Model_createReaction)
423 {
424 Reaction_t *r = Model_createReaction(M);
425
426
427 fail_unless( r != NULL );
428 fail_unless( Model_getNumReactions(M) == 1 );
429 fail_unless( Model_getReaction(M, 0) == r );
430 }
431 END_TEST
432
433
START_TEST(test_Model_createReactant)434 START_TEST (test_Model_createReactant)
435 {
436 Reaction_t *r;
437 SpeciesReference_t *sr;
438
439
440 Model_createReaction(M);
441 Model_createReaction(M);
442
443 sr = Model_createReactant(M);
444
445 fail_unless( sr != NULL );
446 fail_unless( Model_getNumReactions(M) == 2 );
447
448 r = Model_getReaction(M, 1);
449
450 fail_unless( Reaction_getNumReactants(r) == 1 );
451 fail_unless( Reaction_getReactant(r, 0) == sr );
452 }
453 END_TEST
454
455
START_TEST(test_Model_createReactant_noReaction)456 START_TEST (test_Model_createReactant_noReaction)
457 {
458 fail_unless( Model_getNumReactions(M) == 0 );
459 fail_unless( Model_createReactant(M) == NULL );
460 }
461 END_TEST
462
463
START_TEST(test_Model_createProduct)464 START_TEST (test_Model_createProduct)
465 {
466 Reaction_t *r;
467 SpeciesReference_t *sr;
468
469
470 Model_createReaction(M);
471 Model_createReaction(M);
472
473 sr = Model_createProduct(M);
474
475 fail_unless( sr != NULL );
476 fail_unless( Model_getNumReactions(M) == 2 );
477
478 r = Model_getReaction(M, 1);
479
480 fail_unless( Reaction_getNumProducts(r) == 1 );
481 fail_unless( Reaction_getProduct(r, 0) == sr );
482 }
483 END_TEST
484
485
START_TEST(test_Model_createProduct_noReaction)486 START_TEST (test_Model_createProduct_noReaction)
487 {
488 fail_unless( Model_getNumReactions(M) == 0 );
489 fail_unless( Model_createProduct(M) == NULL );
490 }
491 END_TEST
492
493
START_TEST(test_Model_createModifier)494 START_TEST (test_Model_createModifier)
495 {
496 Reaction_t *r;
497 SpeciesReference_t *msr;
498
499
500 Model_createReaction(M);
501 Model_createReaction(M);
502
503 msr = Model_createModifier(M);
504
505 fail_unless( msr != NULL );
506 fail_unless( Model_getNumReactions(M) == 2 );
507
508 r = Model_getReaction(M, 1);
509
510 fail_unless( Reaction_getNumModifiers(r) == 1 );
511 fail_unless( Reaction_getModifier(r, 0) == msr );
512 }
513 END_TEST
514
515
START_TEST(test_Model_createModifier_noReaction)516 START_TEST (test_Model_createModifier_noReaction)
517 {
518 fail_unless( Model_getNumReactions(M) == 0 );
519 fail_unless( Model_createModifier(M) == NULL );
520 }
521 END_TEST
522
523
START_TEST(test_Model_createKineticLaw)524 START_TEST (test_Model_createKineticLaw)
525 {
526 Reaction_t *r;
527 KineticLaw_t *kl;
528
529
530 Model_createReaction(M);
531 Model_createReaction(M);
532
533 kl = Model_createKineticLaw(M);
534
535 fail_unless( kl != NULL );
536 fail_unless( Model_getNumReactions(M) == 2 );
537
538 r = Model_getReaction(M, 0);
539 fail_unless( Reaction_getKineticLaw(r) == NULL );
540
541 r = Model_getReaction(M, 1);
542 fail_unless( Reaction_getKineticLaw(r) == kl );
543 }
544 END_TEST
545
546
START_TEST(test_Model_createKineticLaw_alreadyExists)547 START_TEST (test_Model_createKineticLaw_alreadyExists)
548 {
549 Reaction_t *r;
550 KineticLaw_t *kl;
551
552
553 r = Model_createReaction(M);
554 kl = Model_createKineticLaw(M);
555
556 fail_unless( Reaction_getKineticLaw(r) == kl );
557 }
558 END_TEST
559
560
START_TEST(test_Model_createKineticLaw_noReaction)561 START_TEST (test_Model_createKineticLaw_noReaction)
562 {
563 fail_unless( Model_getNumReactions(M) == 0 );
564 fail_unless( Model_createKineticLaw(M) == NULL );
565 }
566 END_TEST
567
568
START_TEST(test_Model_createKineticLawParameter)569 START_TEST (test_Model_createKineticLawParameter)
570 {
571 Reaction_t *r;
572 KineticLaw_t *kl;
573 Parameter_t *p;
574
575
576 Model_createReaction(M);
577 Model_createReaction(M);
578 Model_createKineticLaw(M);
579
580 p = Model_createKineticLawParameter(M);
581
582 fail_unless( Model_getNumReactions(M) == 2 );
583
584 r = Model_getReaction(M, 0);
585 fail_unless( Reaction_getKineticLaw(r) == NULL );
586
587 r = Model_getReaction(M, 1);
588 fail_unless( Reaction_getKineticLaw(r) != NULL );
589
590 kl = Reaction_getKineticLaw(r);
591 fail_unless( KineticLaw_getNumParameters(kl) == 1 );
592 fail_unless( KineticLaw_getParameter(kl, 0) == p );
593 }
594 END_TEST
595
596
START_TEST(test_Model_createKineticLawParameter_noReaction)597 START_TEST (test_Model_createKineticLawParameter_noReaction)
598 {
599 fail_unless( Model_getNumReactions(M) == 0 );
600 fail_unless( Model_createKineticLawParameter(M) == NULL );
601 }
602 END_TEST
603
604
START_TEST(test_Model_createKineticLawParameter_noKineticLaw)605 START_TEST (test_Model_createKineticLawParameter_noKineticLaw)
606 {
607 Reaction_t *r;
608
609
610 r = Model_createReaction(M);
611
612 fail_unless( Reaction_getKineticLaw(r) == NULL );
613 fail_unless( Model_createKineticLawParameter(M) == NULL );
614 }
615 END_TEST
616
617
START_TEST(test_Model_createEvent)618 START_TEST (test_Model_createEvent)
619 {
620 Event_t *e = Model_createEvent(M);
621
622
623 fail_unless( e != NULL );
624 fail_unless( Model_getNumEvents(M) == 1 );
625 fail_unless( Model_getEvent(M, 0) == e );
626 }
627 END_TEST
628
629
START_TEST(test_Model_createEventAssignment)630 START_TEST (test_Model_createEventAssignment)
631 {
632 Event_t *e;
633 EventAssignment_t *ea;
634
635
636 Model_createEvent(M);
637 Model_createEvent(M);
638
639 ea = Model_createEventAssignment(M);
640
641 fail_unless( ea != NULL );
642 fail_unless( Model_getNumEvents(M) == 2 );
643
644 e = Model_getEvent(M, 1);
645
646 fail_unless( Event_getNumEventAssignments(e) == 1 );
647 fail_unless( Event_getEventAssignment(e, 0) == ea );
648 }
649 END_TEST
650
651
START_TEST(test_Model_createEventAssignment_noEvent)652 START_TEST (test_Model_createEventAssignment_noEvent)
653 {
654 fail_unless( Model_getNumEvents(M) == 0 );
655 fail_unless( Model_createEventAssignment(M) == NULL );
656 }
657 END_TEST
658
659
660 /**
661 * If I had time to do it over again, this is how I would write and
662 * combine the get / add tests for collection (see below).
663 */
START_TEST(test_Model_add_get_FunctionDefinitions)664 START_TEST (test_Model_add_get_FunctionDefinitions)
665 {
666 FunctionDefinition_t *fd1 = FunctionDefinition_create(2, 4);
667 FunctionDefinition_t *fd2 = FunctionDefinition_create(2, 4);
668
669 FunctionDefinition_setId(fd1, "fd1");
670 FunctionDefinition_setId(fd2, "fd2");
671
672 ASTNode_t* math = SBML_parseFormula("2");
673 FunctionDefinition_setMath(fd1, math);
674 FunctionDefinition_setMath(fd2, math);
675 ASTNode_free(math);
676
677 Model_addFunctionDefinition(M, fd1);
678 Model_addFunctionDefinition(M, fd2);
679
680 fail_unless( Model_getNumFunctionDefinitions(M) == 2 );
681 fail_unless( Model_getFunctionDefinition(M, 0) != fd1 );
682 fail_unless( Model_getFunctionDefinition(M, 1) != fd2 );
683 fail_unless( Model_getFunctionDefinition(M, 2) == NULL );
684
685 FunctionDefinition_free(fd1);
686 FunctionDefinition_free(fd2);
687 }
688 END_TEST
689
690
691 /**
692 * If I had time to do it over again, this is how I would write and
693 * combine the get / add tests for collection (see below).
694 */
START_TEST(test_Model_add_get_FunctionDefinitions_neg_arg)695 START_TEST (test_Model_add_get_FunctionDefinitions_neg_arg)
696 {
697 FunctionDefinition_t *fd1 = FunctionDefinition_create(2, 4);
698 FunctionDefinition_t *fd2 = FunctionDefinition_create(2, 4);
699
700 FunctionDefinition_setId(fd1, "fd1");
701 FunctionDefinition_setId(fd2, "fd2");
702
703 ASTNode_t* math = SBML_parseFormula("2");
704 FunctionDefinition_setMath(fd1, math);
705 FunctionDefinition_setMath(fd2, math);
706 ASTNode_free(math);
707
708 Model_addFunctionDefinition(M, fd1);
709 Model_addFunctionDefinition(M, fd2);
710
711 fail_unless( Model_getNumFunctionDefinitions(M) == 2 );
712 fail_unless( Model_getFunctionDefinition(M, -2) == NULL );
713
714 FunctionDefinition_free(fd1);
715 FunctionDefinition_free(fd2);
716 }
717 END_TEST
718
719
START_TEST(test_Model_add_get_UnitDefinitions)720 START_TEST (test_Model_add_get_UnitDefinitions)
721 {
722 UnitDefinition_t *ud1 = UnitDefinition_create(2, 4);
723 UnitDefinition_t *ud2 = UnitDefinition_create(2, 4);
724
725 UnitDefinition_setId(ud1, "ud1");
726 UnitDefinition_setId(ud2, "ud2");
727
728 UnitDefinition_createUnit(ud1);
729 UnitDefinition_createUnit(ud2);
730
731 Model_addUnitDefinition(M, ud1);
732 Model_addUnitDefinition(M, ud2);
733
734 fail_unless( Model_getNumUnitDefinitions(M) == 2 );
735 fail_unless( Model_getUnitDefinition(M, 0) != ud1 );
736 fail_unless( Model_getUnitDefinition(M, 1) != ud2 );
737 fail_unless( Model_getUnitDefinition(M, 2) == NULL );
738
739 UnitDefinition_free(ud1);
740 UnitDefinition_free(ud2);
741 }
742 END_TEST
743
744
START_TEST(test_Model_add_get_UnitDefinitions_neg_arg)745 START_TEST (test_Model_add_get_UnitDefinitions_neg_arg)
746 {
747 UnitDefinition_t *ud1 = UnitDefinition_create(2, 4);
748 UnitDefinition_t *ud2 = UnitDefinition_create(2, 4);
749
750 UnitDefinition_setId(ud1, "ud1");
751 UnitDefinition_setId(ud2, "ud2");
752
753 UnitDefinition_createUnit(ud1);
754 UnitDefinition_createUnit(ud2);
755
756 Model_addUnitDefinition(M, ud1);
757 Model_addUnitDefinition(M, ud2);
758
759 fail_unless( Model_getNumUnitDefinitions(M) == 2 );
760 fail_unless( Model_getUnitDefinition(M, -2) == NULL );
761
762 UnitDefinition_free(ud1);
763 UnitDefinition_free(ud2);
764 }
765 END_TEST
766
767
START_TEST(test_Model_addCompartment)768 START_TEST (test_Model_addCompartment)
769 {
770 Compartment_t *c = Compartment_create(2, 4);
771 Compartment_setId(c, "c");
772 Model_addCompartment(M, c);
773
774 fail_unless( Model_getNumCompartments(M) == 1 );
775 Compartment_free(c);
776 }
777 END_TEST
778
779
START_TEST(test_Model_addSpecies)780 START_TEST (test_Model_addSpecies)
781 {
782 Species_t * s = Species_create(2, 4);
783 Species_setId(s, "s");
784 Species_setCompartment(s, "c");
785 Model_addSpecies(M, s);
786
787 fail_unless( Model_getNumSpecies(M) == 1 );
788 Species_free(s);
789 }
790 END_TEST
791
792
START_TEST(test_Model_addParameter)793 START_TEST (test_Model_addParameter)
794 {
795 Parameter_t * p = Parameter_create(2, 4);
796 Parameter_setId(p, "p");
797 Model_addParameter(M, p);
798
799 fail_unless( Model_getNumParameters(M) == 1 );
800 Parameter_free(p);
801 }
802 END_TEST
803
804
START_TEST(test_Model_addRules)805 START_TEST (test_Model_addRules)
806 {
807 Rule_t *r1 = Rule_createAlgebraic(2, 4);
808 Rule_t *r2 = Rule_createAssignment(2, 4);
809 Rule_t *r3 = Rule_createRate(2, 4);
810
811 Rule_setVariable(r2, "r2");
812 Rule_setVariable(r3, "r3");
813
814 ASTNode_t* math = SBML_parseFormula("2");
815 Rule_setMath(r1, math);
816 Rule_setMath(r2, math);
817 Rule_setMath(r3, math);
818 ASTNode_free(math);
819
820 Model_addRule( M, r1);
821 Model_addRule( M, r2);
822 Model_addRule( M, r3);
823
824 fail_unless( Model_getNumRules(M) == 3 );
825
826 Rule_free(r1);
827 Rule_free(r2);
828 Rule_free(r3);
829 }
830 END_TEST
831
832
START_TEST(test_Model_addReaction)833 START_TEST (test_Model_addReaction)
834 {
835 Reaction_t *r = Reaction_create(2, 4);
836 Reaction_setId(r, "r");
837 Model_addReaction(M, r);
838
839 fail_unless( Model_getNumReactions(M) == 1 );
840 Reaction_free(r);
841 }
842 END_TEST
843
844
START_TEST(test_Model_add_get_Event)845 START_TEST (test_Model_add_get_Event)
846 {
847 Event_t *e1 = Event_create(2, 4);
848 Event_t *e2 = Event_create(2, 4);
849 Trigger_t *t = Trigger_create(2, 4);
850 ASTNode_t* math = SBML_parseFormula("true");
851 Trigger_setMath(t, math);
852 ASTNode_free(math);
853 Event_setTrigger(e1, t);
854 Event_setTrigger(e2, t);
855 Event_createEventAssignment(e1);
856 Event_createEventAssignment(e2);
857
858 Model_addEvent(M, e1);
859 Model_addEvent(M, e2);
860
861 fail_unless( Model_getNumEvents(M) == 2 );
862 fail_unless( Model_getEvent(M, 0) != e1 );
863 fail_unless( Model_getEvent(M, 1) != e2 );
864 fail_unless( Model_getEvent(M, 2) == NULL );
865
866 Event_free(e1);
867 Event_free(e2);
868 Trigger_free(t);
869 }
870 END_TEST
871
872
START_TEST(test_Model_add_get_Event_neg_arg)873 START_TEST (test_Model_add_get_Event_neg_arg)
874 {
875 Event_t *e1 = Event_create(2, 4);
876 Event_t *e2 = Event_create(2, 4);
877 Trigger_t *t = Trigger_create(2, 4);
878 ASTNode_t* math = SBML_parseFormula("true");
879 Trigger_setMath(t, math);
880 ASTNode_free(math);
881 Event_setTrigger(e1, t);
882 Event_setTrigger(e2, t);
883 Event_createEventAssignment(e1);
884 Event_createEventAssignment(e2);
885
886 Model_addEvent(M, e1);
887 Model_addEvent(M, e2);
888
889 fail_unless( Model_getNumEvents(M) == 2 );
890 fail_unless( Model_getEvent(M, -2) == NULL );
891
892 Event_free(e1);
893 Event_free(e2);
894 Trigger_free(t);
895 }
896 END_TEST
897
898
START_TEST(test_Model_getFunctionDefinitionById)899 START_TEST (test_Model_getFunctionDefinitionById)
900 {
901 FunctionDefinition_t *fd1 = FunctionDefinition_create(2, 4);
902 FunctionDefinition_t *fd2 = FunctionDefinition_create(2, 4);
903
904 FunctionDefinition_setId( fd1, "sin" );
905 FunctionDefinition_setId( fd2, "cos" );
906
907 ASTNode_t* math = SBML_parseFormula("2");
908 FunctionDefinition_setMath(fd1, math);
909 FunctionDefinition_setMath(fd2, math);
910 ASTNode_free(math);
911
912 Model_addFunctionDefinition(M, fd1);
913 Model_addFunctionDefinition(M, fd2);
914
915 fail_unless( Model_getNumFunctionDefinitions(M) == 2 );
916
917 fail_unless( Model_getFunctionDefinitionById(M, "sin" ) != fd1 );
918 fail_unless( Model_getFunctionDefinitionById(M, "cos" ) != fd2 );
919 fail_unless( Model_getFunctionDefinitionById(M, "tan" ) == NULL );
920
921 FunctionDefinition_free(fd1);
922 FunctionDefinition_free(fd2);
923 }
924 END_TEST
925
926
START_TEST(test_Model_getUnitDefinition)927 START_TEST (test_Model_getUnitDefinition)
928 {
929 UnitDefinition_t *ud1 = UnitDefinition_create(2, 4);
930 UnitDefinition_t *ud2 = UnitDefinition_create(2, 4);
931
932 UnitDefinition_setId( ud1, "mmls" );
933 UnitDefinition_setId( ud2, "volume" );
934
935 UnitDefinition_createUnit(ud1);
936 UnitDefinition_createUnit(ud2);
937
938 Model_addUnitDefinition(M, ud1);
939 Model_addUnitDefinition(M, ud2);
940
941 fail_unless( Model_getNumUnitDefinitions(M) == 2 );
942
943 UnitDefinition_free(ud1);
944 UnitDefinition_free(ud2);
945
946 ud1 = Model_getUnitDefinition(M, 0);
947 ud2 = Model_getUnitDefinition(M, 1);
948
949 fail_unless( !strcmp( UnitDefinition_getId(ud1), "mmls" ) );
950 fail_unless( !strcmp( UnitDefinition_getId(ud2), "volume" ) );
951 }
952 END_TEST
953
954
START_TEST(test_Model_getUnitDefinitionById)955 START_TEST (test_Model_getUnitDefinitionById)
956 {
957 UnitDefinition_t *ud1 = UnitDefinition_create(2, 4);
958 UnitDefinition_t *ud2 = UnitDefinition_create(2, 4);
959
960 UnitDefinition_setId( ud1, "mmls" );
961 UnitDefinition_setId( ud2, "volume" );
962
963 UnitDefinition_createUnit(ud1);
964 UnitDefinition_createUnit(ud2);
965
966 Model_addUnitDefinition(M, ud1);
967 Model_addUnitDefinition(M, ud2);
968
969 fail_unless( Model_getNumUnitDefinitions(M) == 2 );
970
971 fail_unless( Model_getUnitDefinitionById(M, "mmls" ) != ud1 );
972 fail_unless( Model_getUnitDefinitionById(M, "volume" ) != ud2 );
973 fail_unless( Model_getUnitDefinitionById(M, "rototillers") == NULL );
974
975 UnitDefinition_free(ud1);
976 UnitDefinition_free(ud2);
977 }
978 END_TEST
979
980
START_TEST(test_Model_getCompartment)981 START_TEST (test_Model_getCompartment)
982 {
983 Compartment_t *c1 = Compartment_create(2, 4);
984 Compartment_t *c2 = Compartment_create(2, 4);
985
986 Compartment_setId(c1, "A");
987 Compartment_setId(c2, "B");
988
989 Model_addCompartment(M, c1);
990 Model_addCompartment(M, c2);
991
992 fail_unless( Model_getNumCompartments(M) == 2 );
993
994 Compartment_free(c1);
995 Compartment_free(c2);
996
997 c1 = Model_getCompartment(M, 0);
998 c2 = Model_getCompartment(M, 1);
999
1000 fail_unless( !strcmp(Compartment_getId(c1), "A") );
1001 fail_unless( !strcmp(Compartment_getId(c2), "B") );
1002 }
1003 END_TEST
1004
1005
START_TEST(test_Model_getCompartmentById)1006 START_TEST (test_Model_getCompartmentById)
1007 {
1008 Compartment_t *c1 = Compartment_create(2, 4);
1009 Compartment_t *c2 = Compartment_create(2, 4);
1010
1011 Compartment_setId( c1, "A" );
1012 Compartment_setId( c2, "B" );
1013
1014 Model_addCompartment(M, c1);
1015 Model_addCompartment(M, c2);
1016
1017 fail_unless( Model_getNumCompartments(M) == 2 );
1018
1019 fail_unless( Model_getCompartmentById(M, "A" ) != c1 );
1020 fail_unless( Model_getCompartmentById(M, "B" ) != c2 );
1021 fail_unless( Model_getCompartmentById(M, "C" ) == NULL );
1022
1023 Compartment_free(c1);
1024 Compartment_free(c2);
1025 }
1026 END_TEST
1027
1028
START_TEST(test_Model_getSpecies)1029 START_TEST (test_Model_getSpecies)
1030 {
1031 Species_t *s1 = Species_create(2, 4);
1032 Species_t *s2 = Species_create(2, 4);
1033
1034 Species_setId( s1, "Glucose" );
1035 Species_setId( s2, "Glucose_6_P" );
1036
1037 Species_setCompartment( s1, "c");
1038 Species_setCompartment( s2, "c");
1039
1040 Model_addSpecies(M, s1);
1041 Model_addSpecies(M, s2);
1042
1043 fail_unless( Model_getNumSpecies(M) == 2 );
1044
1045 Species_free(s1);
1046 Species_free(s2);
1047
1048 s1 = Model_getSpecies(M, 0);
1049 s2 = Model_getSpecies(M, 1);
1050
1051 fail_unless( !strcmp( Species_getId(s1), "Glucose" ) );
1052 fail_unless( !strcmp( Species_getId(s2), "Glucose_6_P" ) );
1053 }
1054 END_TEST
1055
1056
START_TEST(test_Model_getSpeciesById)1057 START_TEST (test_Model_getSpeciesById)
1058 {
1059 Species_t *s1 = Species_create(2, 4);
1060 Species_t *s2 = Species_create(2, 4);
1061
1062 Species_setId( s1, "Glucose" );
1063 Species_setId( s2, "Glucose_6_P" );
1064
1065 Species_setCompartment( s1, "c");
1066 Species_setCompartment( s2, "c");
1067
1068 Model_addSpecies(M, s1);
1069 Model_addSpecies(M, s2);
1070
1071 fail_unless( Model_getNumSpecies(M) == 2 );
1072
1073 fail_unless( Model_getSpeciesById(M, "Glucose" ) != s1 );
1074 fail_unless( Model_getSpeciesById(M, "Glucose_6_P") != s2 );
1075 fail_unless( Model_getSpeciesById(M, "Glucose2" ) == NULL );
1076
1077 Species_free(s1);
1078 Species_free(s2);
1079 }
1080 END_TEST
1081
1082
START_TEST(test_Model_getParameter)1083 START_TEST (test_Model_getParameter)
1084 {
1085 Parameter_t *p1 = Parameter_create(2, 4);
1086 Parameter_t *p2 = Parameter_create(2, 4);
1087
1088 Parameter_setId(p1, "Km1");
1089 Parameter_setId(p2, "Km2");
1090
1091 Model_addParameter(M, p1);
1092 Model_addParameter(M, p2);
1093
1094 fail_unless( Model_getNumParameters(M) == 2 );
1095
1096 Parameter_free(p1);
1097 Parameter_free(p2);
1098
1099 p1 = Model_getParameter(M, 0);
1100 p2 = Model_getParameter(M, 1);
1101
1102 fail_unless( !strcmp(Parameter_getId(p1), "Km1") );
1103 fail_unless( !strcmp(Parameter_getId(p2), "Km2") );
1104 }
1105 END_TEST
1106
1107
START_TEST(test_Model_getParameterById)1108 START_TEST (test_Model_getParameterById)
1109 {
1110 Parameter_t *p1 = Parameter_create(2, 4);
1111 Parameter_t *p2 = Parameter_create(2, 4);
1112
1113 Parameter_setId( p1, "Km1" );
1114 Parameter_setId( p2, "Km2" );
1115
1116 Model_addParameter(M, p1);
1117 Model_addParameter(M, p2);
1118
1119 fail_unless( Model_getNumParameters(M) == 2 );
1120
1121 fail_unless( Model_getParameterById(M, "Km1" ) != p1 );
1122 fail_unless( Model_getParameterById(M, "Km2" ) != p2 );
1123 fail_unless( Model_getParameterById(M, "Km3" ) == NULL );
1124
1125 Parameter_free(p1);
1126 Parameter_free(p2);
1127 }
1128 END_TEST
1129
1130
START_TEST(test_Model_getRules)1131 START_TEST (test_Model_getRules)
1132 {
1133 Rule_t *ar = Rule_createAlgebraic(2, 4);
1134 Rule_t *scr = Rule_createAssignment(2, 4);
1135 Rule_t *cvr = Rule_createAssignment(2, 4);
1136 Rule_t *pr = Rule_createAssignment(2, 4);
1137
1138 Rule_setVariable(scr, "r2");
1139 Rule_setVariable(cvr, "r3");
1140 Rule_setVariable(pr, "r4");
1141
1142
1143 Rule_setFormula( ar , "x + 1" );
1144 Rule_setFormula( scr, "k * t/(1 + k)" );
1145 Rule_setFormula( cvr, "0.10 * t" );
1146 Rule_setFormula( pr , "k3/k2" );
1147
1148 Model_addRule( M, ar );
1149 Model_addRule( M, scr );
1150 Model_addRule( M, cvr );
1151 Model_addRule( M, pr );
1152
1153 fail_unless( Model_getNumRules(M) == 4 );
1154
1155 Rule_free(ar);
1156 Rule_free(scr);
1157 Rule_free(cvr);
1158 Rule_free(pr);
1159
1160 ar = Model_getRule(M, 0);
1161 scr = Model_getRule(M, 1);
1162 cvr = Model_getRule(M, 2);
1163 pr = Model_getRule(M, 3);
1164
1165 fail_unless( !strcmp(Rule_getFormula( ar) , "x + 1" ) );
1166 fail_unless( !strcmp(Rule_getFormula( scr), "k * t/(1 + k)") );
1167 fail_unless( !strcmp(Rule_getFormula( cvr), "0.10 * t" ) );
1168 fail_unless( !strcmp(Rule_getFormula( pr) , "k3/k2" ) );
1169 }
1170 END_TEST
1171
1172
START_TEST(test_Model_getReaction)1173 START_TEST (test_Model_getReaction)
1174 {
1175 Reaction_t *r1 = Reaction_create(2, 4);
1176 Reaction_t *r2 = Reaction_create(2, 4);
1177
1178 Reaction_setId(r1, "reaction_1");
1179 Reaction_setId(r2, "reaction_2");
1180
1181 Model_addReaction(M, r1);
1182 Model_addReaction(M, r2);
1183
1184 fail_unless( Model_getNumReactions(M) == 2 );
1185
1186 Reaction_free(r1);
1187 Reaction_free(r2);
1188
1189 r1 = Model_getReaction(M, 0);
1190 r2 = Model_getReaction(M, 1);
1191
1192 fail_unless( !strcmp(Reaction_getId(r1), "reaction_1") );
1193 fail_unless( !strcmp(Reaction_getId(r2), "reaction_2") );
1194 }
1195 END_TEST
1196
1197
START_TEST(test_Model_getReactionById)1198 START_TEST (test_Model_getReactionById)
1199 {
1200 Reaction_t *r1 = Reaction_create(2, 4);
1201 Reaction_t *r2 = Reaction_create(2, 4);
1202
1203 Reaction_setId( r1, "reaction_1" );
1204 Reaction_setId( r2, "reaction_2" );
1205
1206 Model_addReaction(M, r1);
1207 Model_addReaction(M, r2);
1208
1209 fail_unless( Model_getNumReactions(M) == 2 );
1210
1211 fail_unless( Model_getReactionById(M, "reaction_1" ) != r1 );
1212 fail_unless( Model_getReactionById(M, "reaction_2" ) != r2 );
1213 fail_unless( Model_getReactionById(M, "reaction_3" ) == NULL );
1214
1215 Reaction_free(r1);
1216 Reaction_free(r2);
1217 }
1218 END_TEST
1219
START_TEST(test_Model_getSpeciesReferenceById)1220 START_TEST (test_Model_getSpeciesReferenceById)
1221 {
1222 Reaction_t *r1 = Reaction_create(2, 4);
1223 Reaction_setId(r1, "r1");
1224
1225 SpeciesReference_t *sr = Reaction_createReactant(r1);
1226 SpeciesReference_setId(sr, "s1");
1227
1228 Model_addReaction(M, r1);
1229
1230 fail_unless( Model_getNumReactions(M) == 1 );
1231
1232 fail_unless( Model_getSpeciesReferenceById(M, "s1" ) != sr );
1233
1234 Reaction_free(r1);
1235 }
1236 END_TEST
1237
1238 /* THIS IS NOT LOGICAL BUT NEEDS A WHOLE MODEL TO TEST */
START_TEST(test_KineticLaw_getParameterById)1239 START_TEST (test_KineticLaw_getParameterById)
1240 {
1241 Parameter_t *k1 = Parameter_create(2, 4);
1242 Parameter_t *k2 = Parameter_create(2, 4);
1243
1244 Parameter_setId(k1, "k1");
1245 Parameter_setId(k2, "k2");
1246
1247 Parameter_setValue(k1, 3.14);
1248 Parameter_setValue(k2, 2.72);
1249
1250 Model_addParameter(M, k1);
1251 Model_addParameter(M, k2);
1252
1253 Reaction_t *r1 = Reaction_create(2, 4);
1254
1255 Reaction_setId( r1, "reaction_1" );
1256
1257 KineticLaw_t *kl = KineticLaw_create(2, 4);
1258 KineticLaw_setFormula(kl, "k1 * X0");
1259
1260 Parameter_t *k3 = Parameter_create(2, 4);
1261 Parameter_t *k4 = Parameter_create(2, 4);
1262
1263 Parameter_setId(k3, "k1");
1264 Parameter_setId(k4, "k2");
1265
1266 Parameter_setValue(k3, 2.72);
1267 Parameter_setValue(k4, 3.14);
1268
1269 KineticLaw_addParameter(kl, k3);
1270 KineticLaw_addParameter(kl, k4);
1271
1272 Reaction_setKineticLaw(r1, kl);
1273 Model_addReaction(M, r1);
1274
1275 KineticLaw_t * kl1 = Reaction_getKineticLaw(Model_getReaction(M,0));
1276
1277 fail_unless( KineticLaw_getParameterById(kl1, "k1" ) != k3 );
1278 fail_unless( KineticLaw_getParameterById(kl1, "k1" ) != k1 );
1279 fail_unless( KineticLaw_getParameterById(kl1, "k2" ) != k4 );
1280 fail_unless( KineticLaw_getParameterById(kl1, "k3" ) == NULL );
1281
1282 Parameter_free(k1);
1283 Parameter_free(k2);
1284 Reaction_free(r1);
1285 KineticLaw_free(kl);
1286 Parameter_free(k3);
1287 Parameter_free(k4);
1288 }
1289 END_TEST
1290
1291
START_TEST(test_Model_getEventById)1292 START_TEST (test_Model_getEventById)
1293 {
1294 Event_t *e1 = Event_create(2, 4);
1295 Event_t *e2 = Event_create(2, 4);
1296 Trigger_t *t = Trigger_create(2, 4);
1297 ASTNode_t* math = SBML_parseFormula("true");
1298 Trigger_setMath(t, math);
1299 ASTNode_free(math);
1300 Event_setTrigger(e1, t);
1301 Event_setTrigger(e2, t);
1302 Event_createEventAssignment(e1);
1303 Event_createEventAssignment(e2);
1304
1305 Event_setId( e1, "e1" );
1306 Event_setId( e2, "e2" );
1307
1308 Model_addEvent(M, e1);
1309 Model_addEvent(M, e2);
1310
1311 fail_unless( Model_getNumEvents(M) == 2 );
1312
1313 fail_unless( Model_getEventById(M, "e1" ) != e1 );
1314 fail_unless( Model_getEventById(M, "e2" ) != e2 );
1315 fail_unless( Model_getEventById(M, "e3" ) == NULL );
1316
1317 Event_free(e1);
1318 Event_free(e2);
1319 Trigger_free(t);
1320 }
1321 END_TEST
1322
1323
START_TEST(test_Model_getNumSpeciesWithBoundaryCondition)1324 START_TEST (test_Model_getNumSpeciesWithBoundaryCondition)
1325 {
1326 Species_t *s1 = Species_create(2, 4);
1327 Species_t *s2 = Species_create(2, 4);
1328 Species_t *s3 = Species_create(2, 4);
1329
1330 Species_setId(s1, "s1");
1331 Species_setId(s2, "s2");
1332 Species_setId(s3, "s3");
1333
1334 Species_setCompartment(s1, "c1");
1335 Species_setCompartment(s2, "c2");
1336 Species_setCompartment(s3, "c3");
1337
1338 Species_setBoundaryCondition(s1, 1);
1339 Species_setBoundaryCondition(s2, 0);
1340 Species_setBoundaryCondition(s3, 1);
1341
1342
1343 fail_unless( Model_getNumSpecies(M) == 0 );
1344 fail_unless( Model_getNumSpeciesWithBoundaryCondition(M) == 0 );
1345
1346 Model_addSpecies(M, s1);
1347
1348 fail_unless( Model_getNumSpecies(M) == 1 );
1349 fail_unless( Model_getNumSpeciesWithBoundaryCondition(M) == 1 );
1350
1351 Model_addSpecies(M, s2);
1352
1353 fail_unless( Model_getNumSpecies(M) == 2 );
1354 fail_unless( Model_getNumSpeciesWithBoundaryCondition(M) == 1 );
1355
1356 Model_addSpecies(M, s3);
1357
1358 fail_unless( Model_getNumSpecies(M) == 3 );
1359 fail_unless( Model_getNumSpeciesWithBoundaryCondition(M) == 2 );
1360
1361 Species_free(s1);
1362 Species_free(s2);
1363 Species_free(s3);
1364 }
1365 END_TEST
1366
1367
START_TEST(test_Model_createWithNS)1368 START_TEST (test_Model_createWithNS )
1369 {
1370 XMLNamespaces_t *xmlns = XMLNamespaces_create();
1371 XMLNamespaces_add(xmlns, "http://www.sbml.org", "testsbml");
1372 SBMLNamespaces_t *sbmlns = SBMLNamespaces_create(2,1);
1373 SBMLNamespaces_addNamespaces(sbmlns,xmlns);
1374
1375 Model_t *object =
1376 Model_createWithNS (sbmlns);
1377
1378
1379 fail_unless( SBase_getTypeCode ((SBase_t *) object) == SBML_MODEL );
1380 fail_unless( SBase_getMetaId ((SBase_t *) object) == NULL );
1381 fail_unless( SBase_getNotes ((SBase_t *) object) == NULL );
1382 fail_unless( SBase_getAnnotation((SBase_t *) object) == NULL );
1383
1384 fail_unless( SBase_getLevel ((SBase_t *) object) == 2 );
1385 fail_unless( SBase_getVersion ((SBase_t *) object) == 1 );
1386
1387 fail_unless( Model_getNamespaces (object) != NULL );
1388 fail_unless( XMLNamespaces_getLength(Model_getNamespaces(object)) == 2 );
1389
1390 Model_free(object);
1391 XMLNamespaces_free(xmlns);
1392 SBMLNamespaces_free(sbmlns);
1393 }
1394 END_TEST
1395
START_TEST(test_Model_removeFunctionDefinition)1396 START_TEST (test_Model_removeFunctionDefinition)
1397 {
1398 FunctionDefinition_t *o1, *o2, *o3;
1399
1400 o1 = Model_createFunctionDefinition(M);
1401 o2 = Model_createFunctionDefinition(M);
1402 o3 = Model_createFunctionDefinition(M);
1403 FunctionDefinition_setId(o3,"test");
1404
1405 fail_unless( Model_removeFunctionDefinition(M,0) == o1 );
1406 fail_unless( Model_getNumFunctionDefinitions(M) == 2 );
1407 fail_unless( Model_removeFunctionDefinition(M,0) == o2 );
1408 fail_unless( Model_getNumFunctionDefinitions(M) == 1 );
1409 fail_unless( Model_removeFunctionDefinitionById(M,"test") == o3 );
1410 fail_unless( Model_getNumFunctionDefinitions(M) == 0 );
1411
1412 FunctionDefinition_free(o1);
1413 FunctionDefinition_free(o2);
1414 FunctionDefinition_free(o3);
1415 }
1416 END_TEST
1417
1418
START_TEST(test_Model_removeUnitDefinition)1419 START_TEST (test_Model_removeUnitDefinition)
1420 {
1421 UnitDefinition_t *o1, *o2, *o3;
1422
1423 o1 = Model_createUnitDefinition(M);
1424 o2 = Model_createUnitDefinition(M);
1425 o3 = Model_createUnitDefinition(M);
1426 UnitDefinition_setId(o3,"test");
1427
1428 fail_unless( Model_removeUnitDefinition(M,0) == o1 );
1429 fail_unless( Model_getNumUnitDefinitions(M) == 2 );
1430 fail_unless( Model_removeUnitDefinition(M,0) == o2 );
1431 fail_unless( Model_getNumUnitDefinitions(M) == 1 );
1432 fail_unless( Model_removeUnitDefinitionById(M,"test") == o3 );
1433 fail_unless( Model_getNumUnitDefinitions(M) == 0 );
1434
1435 UnitDefinition_free(o1);
1436 UnitDefinition_free(o2);
1437 UnitDefinition_free(o3);
1438 }
1439 END_TEST
1440
1441
START_TEST(test_Model_removeCompartmentType)1442 START_TEST (test_Model_removeCompartmentType)
1443 {
1444 CompartmentType_t *o1, *o2, *o3;
1445
1446 o1 = Model_createCompartmentType(M);
1447 o2 = Model_createCompartmentType(M);
1448 o3 = Model_createCompartmentType(M);
1449 CompartmentType_setId(o3,"test");
1450
1451 fail_unless( Model_removeCompartmentType(M,0) == o1 );
1452 fail_unless( Model_getNumCompartmentTypes(M) == 2 );
1453 fail_unless( Model_removeCompartmentType(M,0) == o2 );
1454 fail_unless( Model_getNumCompartmentTypes(M) == 1 );
1455 fail_unless( Model_removeCompartmentTypeById(M,"test") == o3 );
1456 fail_unless( Model_getNumCompartmentTypes(M) == 0 );
1457
1458 CompartmentType_free(o1);
1459 CompartmentType_free(o2);
1460 CompartmentType_free(o3);
1461 }
1462 END_TEST
1463
1464
START_TEST(test_Model_removeSpeciesType)1465 START_TEST (test_Model_removeSpeciesType)
1466 {
1467 SpeciesType_t *o1, *o2, *o3;
1468
1469 o1 = Model_createSpeciesType(M);
1470 o2 = Model_createSpeciesType(M);
1471 o3 = Model_createSpeciesType(M);
1472 SpeciesType_setId(o3,"test");
1473
1474 fail_unless( Model_removeSpeciesType(M,0) == o1 );
1475 fail_unless( Model_getNumSpeciesTypes(M) == 2 );
1476 fail_unless( Model_removeSpeciesType(M,0) == o2 );
1477 fail_unless( Model_getNumSpeciesTypes(M) == 1 );
1478 fail_unless( Model_removeSpeciesTypeById(M,"test") == o3 );
1479 fail_unless( Model_getNumSpeciesTypes(M) == 0 );
1480
1481 SpeciesType_free(o1);
1482 SpeciesType_free(o2);
1483 SpeciesType_free(o3);
1484 }
1485 END_TEST
1486
1487
START_TEST(test_Model_removeCompartment)1488 START_TEST (test_Model_removeCompartment)
1489 {
1490 Compartment_t *o1, *o2, *o3;
1491
1492 o1 = Model_createCompartment(M);
1493 o2 = Model_createCompartment(M);
1494 o3 = Model_createCompartment(M);
1495 Compartment_setId(o3,"test");
1496
1497 fail_unless( Model_removeCompartment(M,0) == o1 );
1498 fail_unless( Model_getNumCompartments(M) == 2 );
1499 fail_unless( Model_removeCompartment(M,0) == o2 );
1500 fail_unless( Model_getNumCompartments(M) == 1 );
1501 fail_unless( Model_removeCompartmentById(M,"test") == o3 );
1502 fail_unless( Model_getNumCompartments(M) == 0 );
1503
1504 Compartment_free(o1);
1505 Compartment_free(o2);
1506 Compartment_free(o3);
1507 }
1508 END_TEST
1509
1510
START_TEST(test_Model_removeSpecies)1511 START_TEST (test_Model_removeSpecies)
1512 {
1513 Species_t *o1, *o2, *o3;
1514
1515 o1 = Model_createSpecies(M);
1516 o2 = Model_createSpecies(M);
1517 o3 = Model_createSpecies(M);
1518 Species_setId(o3,"test");
1519
1520 fail_unless( Model_removeSpecies(M,0) == o1 );
1521 fail_unless( Model_getNumSpecies(M) == 2 );
1522 fail_unless( Model_removeSpecies(M,0) == o2 );
1523 fail_unless( Model_getNumSpecies(M) == 1 );
1524 fail_unless( Model_removeSpeciesById(M,"test") == o3 );
1525 fail_unless( Model_getNumSpecies(M) == 0 );
1526
1527 Species_free(o1);
1528 Species_free(o2);
1529 Species_free(o3);
1530 }
1531 END_TEST
1532
1533
START_TEST(test_Model_removeParameter)1534 START_TEST (test_Model_removeParameter)
1535 {
1536 Parameter_t *o1, *o2, *o3;
1537
1538 o1 = Model_createParameter(M);
1539 o2 = Model_createParameter(M);
1540 o3 = Model_createParameter(M);
1541 Parameter_setId(o3,"test");
1542
1543 fail_unless( Model_removeParameter(M,0) == o1 );
1544 fail_unless( Model_getNumParameters(M) == 2 );
1545 fail_unless( Model_removeParameter(M,0) == o2 );
1546 fail_unless( Model_getNumParameters(M) == 1 );
1547 fail_unless( Model_removeParameterById(M,"test") == o3 );
1548 fail_unless( Model_getNumParameters(M) == 0 );
1549
1550 Parameter_free(o1);
1551 Parameter_free(o2);
1552 Parameter_free(o3);
1553 }
1554 END_TEST
1555
1556
START_TEST(test_Model_removeInitialAssignment)1557 START_TEST (test_Model_removeInitialAssignment)
1558 {
1559 InitialAssignment_t *o1, *o2, *o3;
1560
1561 o1 = Model_createInitialAssignment(M);
1562 o2 = Model_createInitialAssignment(M);
1563 o3 = Model_createInitialAssignment(M);
1564 InitialAssignment_setSymbol(o3,"test");
1565
1566 fail_unless( Model_removeInitialAssignment(M,0) == o1 );
1567 fail_unless( Model_getNumInitialAssignments(M) == 2 );
1568 fail_unless( Model_removeInitialAssignment(M,0) == o2 );
1569 fail_unless( Model_getNumInitialAssignments(M) == 1 );
1570 fail_unless( Model_removeInitialAssignmentBySym(M,"test") == o3 );
1571 fail_unless( Model_getNumInitialAssignments(M) == 0 );
1572
1573 InitialAssignment_free(o1);
1574 InitialAssignment_free(o2);
1575 InitialAssignment_free(o3);
1576 }
1577 END_TEST
1578
1579
START_TEST(test_Model_removeRule)1580 START_TEST (test_Model_removeRule)
1581 {
1582 Rule_t *o1, *o2, *o3;
1583
1584 o1 = Model_createAssignmentRule(M);
1585 o2 = Model_createAlgebraicRule(M);
1586 o3 = Model_createRateRule(M);
1587 Rule_setVariable(o3,"test");
1588
1589 fail_unless( Model_removeRule(M,0) == o1 );
1590 fail_unless( Model_getNumRules(M) == 2 );
1591 fail_unless( Model_removeRule(M,0) == o2 );
1592 fail_unless( Model_getNumRules(M) == 1 );
1593 fail_unless( Model_removeRuleByVar(M,"test") == o3 );
1594 fail_unless( Model_getNumRules(M) == 0 );
1595
1596 Rule_free(o1);
1597 Rule_free(o2);
1598 Rule_free(o3);
1599 }
1600 END_TEST
1601
1602
START_TEST(test_Model_removeConstraint)1603 START_TEST (test_Model_removeConstraint)
1604 {
1605 Constraint_t *o1, *o2, *o3;
1606
1607 o1 = Model_createConstraint(M);
1608 o2 = Model_createConstraint(M);
1609 o3 = Model_createConstraint(M);
1610
1611 fail_unless( Model_removeConstraint(M,0) == o1 );
1612 fail_unless( Model_getNumConstraints(M) == 2 );
1613 fail_unless( Model_removeConstraint(M,0) == o2 );
1614 fail_unless( Model_getNumConstraints(M) == 1 );
1615 fail_unless( Model_removeConstraint(M,0) == o3 );
1616 fail_unless( Model_getNumConstraints(M) == 0 );
1617
1618 Constraint_free(o1);
1619 Constraint_free(o2);
1620 Constraint_free(o3);
1621 }
1622 END_TEST
1623
1624
START_TEST(test_Model_removeReaction)1625 START_TEST (test_Model_removeReaction)
1626 {
1627 Reaction_t *o1, *o2, *o3;
1628
1629 o1 = Model_createReaction(M);
1630 o2 = Model_createReaction(M);
1631 o3 = Model_createReaction(M);
1632 Reaction_setId(o3,"test");
1633
1634 fail_unless( Model_removeReaction(M,0) == o1 );
1635 fail_unless( Model_getNumReactions(M) == 2 );
1636 fail_unless( Model_removeReaction(M,0) == o2 );
1637 fail_unless( Model_getNumReactions(M) == 1 );
1638 fail_unless( Model_removeReactionById(M,"test") == o3 );
1639 fail_unless( Model_getNumReactions(M) == 0 );
1640
1641 Reaction_free(o1);
1642 Reaction_free(o2);
1643 Reaction_free(o3);
1644 }
1645 END_TEST
1646
1647
START_TEST(test_Model_removeEvent)1648 START_TEST (test_Model_removeEvent)
1649 {
1650 Event_t *o1, *o2, *o3;
1651
1652 o1 = Model_createEvent(M);
1653 o2 = Model_createEvent(M);
1654 o3 = Model_createEvent(M);
1655 Event_setId(o3,"test");
1656
1657 fail_unless( Model_removeEvent(M,0) == o1 );
1658 fail_unless( Model_getNumEvents(M) == 2 );
1659 fail_unless( Model_removeEvent(M,0) == o2 );
1660 fail_unless( Model_getNumEvents(M) == 1 );
1661 fail_unless( Model_removeEventById(M,"test") == o3 );
1662 fail_unless( Model_getNumEvents(M) == 0 );
1663
1664 Event_free(o1);
1665 Event_free(o2);
1666 Event_free(o3);
1667 }
1668 END_TEST
1669
1670
START_TEST(test_Model_conversionFactor)1671 START_TEST (test_Model_conversionFactor)
1672 {
1673 fail_unless( !Model_isSetConversionFactor(M) );
1674 int ret = Model_unsetConversionFactor(M);
1675 fail_unless( ret == LIBSBML_UNEXPECTED_ATTRIBUTE );
1676 }
1677 END_TEST
1678
1679
1680
1681 Suite *
create_suite_Model(void)1682 create_suite_Model (void)
1683 {
1684 Suite *s = suite_create("Model");
1685 TCase *t = tcase_create("Model");
1686
1687
1688 tcase_add_checked_fixture(t, ModelTest_setup, ModelTest_teardown);
1689
1690 tcase_add_test( t, test_Model_create );
1691 tcase_add_test( t, test_Model_free_NULL );
1692 //tcase_add_test( t, test_Model_createWith );
1693 tcase_add_test( t, test_Model_setId );
1694 tcase_add_test( t, test_Model_setName );
1695
1696
1697 tcase_add_test( t, test_Model_setgetModelHistory );
1698 /**
1699 * Model_createXXX() methods
1700 */
1701 tcase_add_test( t, test_Model_createFunctionDefinition );
1702 tcase_add_test( t, test_Model_createUnitDefinition );
1703 tcase_add_test( t, test_Model_createUnit );
1704 tcase_add_test( t, test_Model_createUnit_noUnitDefinition );
1705 tcase_add_test( t, test_Model_createCompartment );
1706 tcase_add_test( t, test_Model_createCompartmentType );
1707 tcase_add_test( t, test_Model_createConstraint );
1708 tcase_add_test( t, test_Model_createSpeciesType );
1709 tcase_add_test( t, test_Model_createInitialAssignment );
1710 tcase_add_test( t, test_Model_createSpecies );
1711 tcase_add_test( t, test_Model_createParameter );
1712 tcase_add_test( t, test_Model_createAssignmentRule );
1713 tcase_add_test( t, test_Model_createRateRule );
1714 tcase_add_test( t, test_Model_createAlgebraicRule );
1715 tcase_add_test( t, test_Model_createReaction );
1716 tcase_add_test( t, test_Model_createReactant );
1717 tcase_add_test( t, test_Model_createReactant_noReaction );
1718 tcase_add_test( t, test_Model_createProduct );
1719 tcase_add_test( t, test_Model_createProduct_noReaction );
1720 tcase_add_test( t, test_Model_createModifier );
1721 tcase_add_test( t, test_Model_createModifier_noReaction );
1722 tcase_add_test( t, test_Model_createKineticLaw );
1723 tcase_add_test( t, test_Model_createKineticLaw_alreadyExists );
1724 tcase_add_test( t, test_Model_createKineticLaw_noReaction );
1725 tcase_add_test( t, test_Model_createKineticLawParameter );
1726 tcase_add_test( t, test_Model_createKineticLawParameter_noReaction );
1727 tcase_add_test( t, test_Model_createKineticLawParameter_noKineticLaw );
1728 tcase_add_test( t, test_Model_createEvent );
1729 tcase_add_test( t, test_Model_createEventAssignment );
1730 tcase_add_test( t, test_Model_createEventAssignment_noEvent );
1731
1732 /**
1733 * Model_addXXX() methods
1734 */
1735 tcase_add_test( t, test_Model_add_get_FunctionDefinitions );
1736 tcase_add_test( t, test_Model_add_get_FunctionDefinitions_neg_arg );
1737 tcase_add_test( t, test_Model_add_get_UnitDefinitions );
1738 tcase_add_test( t, test_Model_add_get_UnitDefinitions_neg_arg );
1739 tcase_add_test( t, test_Model_addCompartment );
1740 tcase_add_test( t, test_Model_addSpecies );
1741 tcase_add_test( t, test_Model_addParameter );
1742 tcase_add_test( t, test_Model_addRules );
1743 tcase_add_test( t, test_Model_addReaction );
1744 tcase_add_test( t, test_Model_add_get_Event );
1745 tcase_add_test( t, test_Model_add_get_Event_neg_arg );
1746
1747 /**
1748 * Model_getXXX() methods
1749 */
1750 tcase_add_test( t, test_Model_getFunctionDefinitionById );
1751 tcase_add_test( t, test_Model_getUnitDefinition );
1752 tcase_add_test( t, test_Model_getUnitDefinitionById );
1753 tcase_add_test( t, test_Model_getCompartment );
1754 tcase_add_test( t, test_Model_getCompartmentById );
1755 tcase_add_test( t, test_Model_getSpecies );
1756 tcase_add_test( t, test_Model_getSpeciesById );
1757 tcase_add_test( t, test_Model_getSpeciesReferenceById );
1758 tcase_add_test( t, test_Model_getParameter );
1759 tcase_add_test( t, test_Model_getParameterById );
1760 tcase_add_test( t, test_Model_getRules );
1761 tcase_add_test( t, test_Model_getReaction );
1762 tcase_add_test( t, test_Model_getReactionById );
1763 tcase_add_test( t, test_Model_getEventById );
1764
1765 tcase_add_test( t, test_KineticLaw_getParameterById );
1766
1767 tcase_add_test( t, test_Model_getNumSpeciesWithBoundaryCondition );
1768
1769 tcase_add_test( t, test_Model_createWithNS );
1770
1771 tcase_add_test( t, test_Model_conversionFactor );
1772
1773 /**
1774 * Model_removeXXX() methods
1775 */
1776 tcase_add_test( t, test_Model_removeFunctionDefinition );
1777 tcase_add_test( t, test_Model_removeUnitDefinition );
1778 tcase_add_test( t, test_Model_removeCompartmentType );
1779 tcase_add_test( t, test_Model_removeSpeciesType );
1780 tcase_add_test( t, test_Model_removeCompartment );
1781 tcase_add_test( t, test_Model_removeSpecies );
1782 tcase_add_test( t, test_Model_removeParameter );
1783 tcase_add_test( t, test_Model_removeInitialAssignment );
1784 tcase_add_test( t, test_Model_removeRule );
1785 tcase_add_test( t, test_Model_removeConstraint );
1786 tcase_add_test( t, test_Model_removeReaction );
1787 tcase_add_test( t, test_Model_removeEvent );
1788
1789 suite_add_tcase(s, t);
1790
1791 return s;
1792 }
1793
1794 END_C_DECLS
1795
1796
1797