1 /**
2 * \file TestAncestor.cpp
3 * \brief SBML ancestor objects unit tests
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/SBase.h>
45 #include <sbml/Compartment.h>
46 #include <sbml/CompartmentType.h>
47 #include <sbml/Constraint.h>
48 #include <sbml/Delay.h>
49 #include <sbml/Event.h>
50 #include <sbml/EventAssignment.h>
51 #include <sbml/FunctionDefinition.h>
52 #include <sbml/InitialAssignment.h>
53 #include <sbml/KineticLaw.h>
54 #include <sbml/ListOf.h>
55 #include <sbml/Model.h>
56 #include <sbml/Parameter.h>
57 #include <sbml/Reaction.h>
58
59 #include <sbml/AlgebraicRule.h>
60 #include <sbml/AssignmentRule.h>
61 #include <sbml/RateRule.h>
62
63 #include <sbml/SBMLDocument.h>
64 #include <sbml/Species.h>
65 #include <sbml/SpeciesReference.h>
66 #include <sbml/ModifierSpeciesReference.h>
67 #include <sbml/SpeciesType.h>
68 #include <sbml/Unit.h>
69 #include <sbml/UnitDefinition.h>
70 #include <sbml/units/FormulaUnitsData.h>
71
72 #include <sbml/math/ASTNode.h>
73 #include <sbml/math/FormulaParser.h>
74
75 #include <check.h>
76
77 /** @cond doxygenIgnored */
78
79 using namespace std;
80 LIBSBML_CPP_NAMESPACE_USE
81
82 /** @endcond */
83
84
85 CK_CPPSTART
START_TEST(test_Compartment_ancestor_add)86 START_TEST ( test_Compartment_ancestor_add )
87 {
88 Compartment *c = new Compartment(2, 4);
89 c->setId("C");
90 Model *m = new Model(2, 4);
91
92 m->addCompartment(c);
93
94 delete c;
95
96 ListOf *lo = m->getListOfCompartments();
97 Compartment *obj = m->getCompartment(0);
98
99 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
100 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
101 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
102 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
103
104 delete m;
105 }
106 END_TEST
107
108
START_TEST(test_CompartmentType_ancestor_add)109 START_TEST ( test_CompartmentType_ancestor_add )
110 {
111 CompartmentType *ct = new CompartmentType(2, 4);
112 Model *m = new Model(2, 4);
113
114 ct->setId("ct");
115 m->addCompartmentType(ct);
116
117 delete ct;
118
119 ListOf *lo = m->getListOfCompartmentTypes();
120 CompartmentType *obj = m->getCompartmentType(0);
121
122 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
123 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
124 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
125 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
126
127 delete m;
128 }
129 END_TEST
130
131
START_TEST(test_Constraint_ancestor_add)132 START_TEST ( test_Constraint_ancestor_add )
133 {
134 Constraint *ct = new Constraint(2, 4);
135 Model *m = new Model(2, 4);
136
137 ASTNode_t* math = SBML_parseFormula("k+k");
138 ct->setMath(math);
139 delete math;
140 m->addConstraint(ct);
141
142 delete ct;
143
144 ListOf *lo = m->getListOfConstraints();
145 Constraint *obj = m->getConstraint(0);
146
147 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
148 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
149 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
150 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
151
152 delete m;
153 }
154 END_TEST
155
156
START_TEST(test_Delay_ancestor_add)157 START_TEST ( test_Delay_ancestor_add )
158 {
159 Delay *d = new Delay(2, 4);
160 ASTNode_t* math = SBML_parseFormula("1");
161 d->setMath(math);
162 delete math;
163 Event *e = new Event(2, 4);
164
165 e->setDelay(d);
166
167 delete d;
168
169 Delay *obj = e->getDelay();
170
171 fail_unless(obj->getAncestorOfType(SBML_EVENT) == e);
172 fail_unless(obj->getAncestorOfType(SBML_MODEL) == NULL);
173 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
174
175 delete e;
176 }
177 END_TEST
178
179
START_TEST(test_Event_ancestor_add)180 START_TEST ( test_Event_ancestor_add )
181 {
182 Event *e = new Event(2, 4);
183 Model *m = new Model(2, 4);
184 Trigger *t = new Trigger(2, 4);
185 ASTNode_t* math = SBML_parseFormula("1");
186 t->setMath(math);
187 delete math;
188 e->setTrigger(t);
189 e->createEventAssignment();
190
191 m->addEvent(e);
192
193 delete e;
194
195 ListOf *lo = m->getListOfEvents();
196 Event *obj = m->getEvent(0);
197
198 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
199 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
200 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
201 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
202
203 delete m;
204 delete t;
205 }
206 END_TEST
207
208
START_TEST(test_EventAssignment_ancestor_add)209 START_TEST ( test_EventAssignment_ancestor_add )
210 {
211 Event *e = new Event(2, 4);
212 EventAssignment *ea = new EventAssignment(2, 4);
213 ea->setVariable("c");
214 ASTNode_t* math = SBML_parseFormula("K+L");
215 ea->setMath(math);
216 delete math;
217
218 e->addEventAssignment(ea);
219
220 delete ea;
221
222 ListOf *lo = e->getListOfEventAssignments();
223 EventAssignment *obj = e->getEventAssignment(0);
224
225 fail_unless(obj->getAncestorOfType(SBML_EVENT) == e);
226 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
227 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
228 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
229
230 delete e;
231 }
232 END_TEST
233
234
START_TEST(test_FunctionDefinition_ancestor_add)235 START_TEST ( test_FunctionDefinition_ancestor_add )
236 {
237 FunctionDefinition *fd = new FunctionDefinition(2, 4);
238 Model *m = new Model(2, 4);
239 fd->setId("fd");
240 ASTNode_t* math = SBML_parseFormula("l");
241 fd->setMath(math);
242 delete math;
243
244 m->addFunctionDefinition(fd);
245
246 delete fd;
247
248 ListOf *lo = m->getListOfFunctionDefinitions();
249 FunctionDefinition *obj = m->getFunctionDefinition(0);
250
251 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
252 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
253 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
254 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
255
256 delete m;
257 }
258 END_TEST
259
260
START_TEST(test_InitialAssignment_ancestor_add)261 START_TEST ( test_InitialAssignment_ancestor_add )
262 {
263 InitialAssignment *ia = new InitialAssignment(2, 4);
264 Model *m = new Model(2, 4);
265 ia->setSymbol("c");
266 ASTNode_t* math = SBML_parseFormula("9");
267 ia->setMath(math);
268 delete math;
269
270 m->addInitialAssignment(ia);
271
272 delete ia;
273
274 ListOf *lo = m->getListOfInitialAssignments();
275 InitialAssignment *obj = m->getInitialAssignment(0);
276
277 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
278 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
279 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
280 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
281
282 delete m;
283 }
284 END_TEST
285
286
START_TEST(test_KineticLaw_ancestor_add)287 START_TEST ( test_KineticLaw_ancestor_add )
288 {
289 KineticLaw* kl=new KineticLaw(2, 4);
290 ASTNode_t* math = SBML_parseFormula("1");
291 kl->setMath(math);
292 delete math;
293
294 Reaction * r = new Reaction(2, 4);
295
296 r->setKineticLaw(kl);
297 KineticLaw *obj = r->getKineticLaw();
298
299 fail_unless(obj->getAncestorOfType(SBML_REACTION) == r);
300 fail_unless(obj->getAncestorOfType(SBML_MODEL) == NULL);
301 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
302
303 delete r;
304 delete kl;
305 }
306 END_TEST
307
308
START_TEST(test_KineticLaw_Parameter_ancestor_add)309 START_TEST ( test_KineticLaw_Parameter_ancestor_add )
310 {
311 KineticLaw* kl=new KineticLaw(2, 4);
312
313 Parameter *p = new Parameter(2, 4);
314 p->setId("jake");
315 kl->addParameter(p);
316 delete p;
317
318 ListOfParameters *lop = kl->getListOfParameters();
319 Parameter *obj = kl->getParameter(0);
320
321 fail_unless(obj->getAncestorOfType(SBML_KINETIC_LAW) == kl);
322 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lop);
323 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
324 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
325
326 delete kl;
327 }
328 END_TEST
329
330
START_TEST(test_Model_ancestor_add)331 START_TEST ( test_Model_ancestor_add )
332 {
333 SBMLDocument *d = new SBMLDocument(2, 4);
334 Model *m = new Model(2, 4);
335
336 d->setModel(m);
337
338 fail_unless(d == d->getModel()->getAncestorOfType(SBML_DOCUMENT));
339
340 delete d;
341 delete m;
342 }
343 END_TEST
344
345
START_TEST(test_Parameter_ancestor_add)346 START_TEST ( test_Parameter_ancestor_add )
347 {
348 Parameter *ia = new Parameter(2, 4);
349 Model *m = new Model(2, 4);
350 ia->setId("p");
351
352 m->addParameter(ia);
353
354 delete ia;
355
356 ListOf *lo = m->getListOfParameters();
357 Parameter *obj = m->getParameter(0);
358
359 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
360 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
361 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
362 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
363
364 delete m;
365 }
366 END_TEST
367
368
START_TEST(test_Reaction_ancestor_add)369 START_TEST ( test_Reaction_ancestor_add )
370 {
371 Reaction *ia = new Reaction(2, 4);
372 Model *m = new Model(2, 4);
373 ia->setId("k");
374
375 m->addReaction(ia);
376
377 delete ia;
378
379 ListOf *lo = m->getListOfReactions();
380 Reaction *obj = m->getReaction(0);
381
382 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
383 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
384 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
385 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
386
387 delete m;
388 }
389 END_TEST
390
391
392
START_TEST(test_Rule_ancestor_add)393 START_TEST ( test_Rule_ancestor_add )
394 {
395 Rule *ia = new RateRule(2, 4);
396 ia->setVariable("a");
397 ASTNode_t* math = SBML_parseFormula("9");
398 ia->setMath(math);
399 delete math;
400
401 Model *m = new Model(2, 4);
402
403 m->addRule(ia);
404
405 delete ia;
406
407 ListOf *lo = m->getListOfRules();
408 Rule *obj = m->getRule(0);
409
410 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
411 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
412 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
413 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
414
415 delete m;
416 }
417 END_TEST
418
419
420
START_TEST(test_Species_ancestor_add)421 START_TEST ( test_Species_ancestor_add )
422 {
423 Species *ia = new Species(2, 4);
424 Model *m = new Model(2, 4);
425 ia->setId("s");
426 ia->setCompartment("c");
427
428 m->addSpecies(ia);
429
430 delete ia;
431
432 ListOf *lo = m->getListOfSpecies();
433 Species *obj = m->getSpecies(0);
434
435 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
436 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
437 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
438 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
439
440 delete m;
441 }
442 END_TEST
443
444
445
START_TEST(test_SpeciesReference_Product_ancestor_add)446 START_TEST ( test_SpeciesReference_Product_ancestor_add )
447 {
448 SpeciesReference *sr = new SpeciesReference(2, 4);
449 Reaction *r = new Reaction(2, 4);
450 sr->setSpecies("p");
451
452 r->addProduct(sr);
453
454 delete sr;
455
456 ListOf *lo = r->getListOfProducts();
457 SpeciesReference *obj = r->getProduct(0);
458
459 fail_unless(obj->getAncestorOfType(SBML_REACTION) == r);
460 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
461 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
462 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
463
464 delete r;
465 }
466 END_TEST
467
468
START_TEST(test_SpeciesReference_Reactant_ancestor_add)469 START_TEST ( test_SpeciesReference_Reactant_ancestor_add )
470 {
471 SpeciesReference *sr = new SpeciesReference(2, 4);
472 Reaction *r = new Reaction(2, 4);
473 sr->setSpecies("s");
474
475 r->addReactant(sr);
476
477 delete sr;
478
479 ListOf *lo = r->getListOfReactants();
480 SpeciesReference *obj = r->getReactant(0);
481
482 fail_unless(obj->getAncestorOfType(SBML_REACTION) == r);
483 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
484 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
485 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
486
487 delete r;
488 }
489 END_TEST
490
491
START_TEST(test_SpeciesReference_Modifier_ancestor_add)492 START_TEST ( test_SpeciesReference_Modifier_ancestor_add )
493 {
494 ModifierSpeciesReference *sr = new ModifierSpeciesReference(2, 4);
495 sr->setSpecies("s");
496 Reaction *r = new Reaction(2, 4);
497
498 r->addModifier(sr);
499
500 delete sr;
501
502 ListOf *lo = r->getListOfModifiers();
503 ModifierSpeciesReference *obj = r->getModifier(0);
504
505 fail_unless(obj->getAncestorOfType(SBML_REACTION) == r);
506 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
507 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
508 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
509
510 delete r;
511 }
512 END_TEST
513
514
START_TEST(test_SpeciesType_ancestor_add)515 START_TEST ( test_SpeciesType_ancestor_add )
516 {
517 SpeciesType *ia = new SpeciesType(2, 4);
518 Model *m = new Model(2, 4);
519 ia->setId("s");
520
521 m->addSpeciesType(ia);
522
523 delete ia;
524
525 ListOf *lo = m->getListOfSpeciesTypes();
526 SpeciesType *obj = m->getSpeciesType(0);
527
528 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
529 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
530 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
531 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
532
533 delete m;
534 }
535 END_TEST
536
537
START_TEST(test_StoichiometryMath_ancestor_add)538 START_TEST ( test_StoichiometryMath_ancestor_add )
539 {
540 StoichiometryMath *m = new StoichiometryMath(2, 4);
541 ASTNode_t* math = SBML_parseFormula("1");
542 m->setMath(math);
543 delete math;
544 SpeciesReference *sr = new SpeciesReference(2, 4);
545
546 sr->setStoichiometryMath(m);
547
548 delete m;
549
550 StoichiometryMath *obj = sr->getStoichiometryMath();
551
552 fail_unless(obj->getAncestorOfType(SBML_SPECIES_REFERENCE) == sr);
553 fail_unless(obj->getAncestorOfType(SBML_MODEL) == NULL);
554 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
555
556 delete sr;
557 }
558 END_TEST
559
560
START_TEST(test_Trigger_ancestor_add)561 START_TEST ( test_Trigger_ancestor_add )
562 {
563 Trigger *d = new Trigger(2, 4);
564 ASTNode_t* math = SBML_parseFormula("1");
565 d->setMath(math);
566 delete math;
567 Event *e = new Event(2, 4);
568
569 e->setTrigger(d);
570
571 delete d;
572
573 Trigger *obj = e->getTrigger();
574
575 fail_unless(obj->getAncestorOfType(SBML_EVENT) == e);
576 fail_unless(obj->getAncestorOfType(SBML_MODEL) == NULL);
577 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
578
579 delete e;
580 }
581 END_TEST
582
583
START_TEST(test_Unit_ancestor_add)584 START_TEST ( test_Unit_ancestor_add )
585 {
586 UnitDefinition* ud=new UnitDefinition(2, 4);
587
588 Unit * u = new Unit(2, 4);
589 u->setKind(UNIT_KIND_MOLE);
590 ud->addUnit(u);
591 delete u;
592
593 fail_unless(ud->getNumUnits() == 1);
594
595 ListOf *lo = ud->getListOfUnits();
596 Unit *obj = ud->getUnit(0);
597
598 fail_unless(obj->getAncestorOfType(SBML_UNIT_DEFINITION) == ud);
599 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
600 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
601 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
602
603 delete ud;
604 }
605 END_TEST
606
607
START_TEST(test_UnitDefinition_ancestor_add)608 START_TEST ( test_UnitDefinition_ancestor_add )
609 {
610 UnitDefinition *ia = new UnitDefinition(2, 4);
611 Model *m = new Model(2, 4);
612 ia->setId("u");
613 ia->createUnit();
614
615 m->addUnitDefinition(ia);
616
617 delete ia;
618
619 ListOf *lo = m->getListOfUnitDefinitions();
620 UnitDefinition *obj = m->getUnitDefinition(0);
621
622 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
623 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
624 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
625 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
626
627 delete m;
628 }
629 END_TEST
630
631
START_TEST(test_Compartment_ancestor_create)632 START_TEST ( test_Compartment_ancestor_create )
633 {
634 Model *m = new Model(2, 4);
635 Compartment *c = m->createCompartment();
636
637 ListOf *lo = m->getListOfCompartments();
638
639 fail_unless(c->getAncestorOfType(SBML_MODEL) == m);
640 fail_unless(c->getAncestorOfType(SBML_LIST_OF) == lo);
641 fail_unless(c->getAncestorOfType(SBML_DOCUMENT) == NULL);
642 fail_unless(c->getAncestorOfType(SBML_EVENT) == NULL);
643
644 Compartment *obj = m->getCompartment(0);
645
646 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
647 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
648 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
649 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
650
651 delete m;
652 }
653 END_TEST
654
655
START_TEST(test_CompartmentType_ancestor_create)656 START_TEST ( test_CompartmentType_ancestor_create )
657 {
658 Model *m = new Model(2, 4);
659 CompartmentType *ct = m->createCompartmentType();
660
661 ListOf *lo = m->getListOfCompartmentTypes();
662
663 fail_unless(ct->getAncestorOfType(SBML_MODEL) == m);
664 fail_unless(ct->getAncestorOfType(SBML_LIST_OF) == lo);
665 fail_unless(ct->getAncestorOfType(SBML_DOCUMENT) == NULL);
666 fail_unless(ct->getAncestorOfType(SBML_EVENT) == NULL);
667
668 CompartmentType *obj = m->getCompartmentType(0);
669
670 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
671 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
672 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
673 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
674
675 delete m;
676 }
677 END_TEST
678
679
START_TEST(test_Constraint_ancestor_create)680 START_TEST ( test_Constraint_ancestor_create )
681 {
682 Model *m = new Model(2, 4);
683 Constraint *ct = m->createConstraint();
684
685 ListOf *lo = m->getListOfConstraints();
686
687 fail_unless(ct->getAncestorOfType(SBML_MODEL) == m);
688 fail_unless(ct->getAncestorOfType(SBML_LIST_OF) == lo);
689 fail_unless(ct->getAncestorOfType(SBML_DOCUMENT) == NULL);
690 fail_unless(ct->getAncestorOfType(SBML_EVENT) == NULL);
691
692 Constraint *obj = m->getConstraint(0);
693
694 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
695 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
696 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
697 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
698
699 delete m;
700 }
701 END_TEST
702
703
START_TEST(test_Delay_ancestor_create)704 START_TEST ( test_Delay_ancestor_create )
705 {
706 Event *e = new Event(2, 4);
707
708 Delay *ea = e->createDelay();
709
710 fail_unless(ea->getAncestorOfType(SBML_EVENT) == e);
711 fail_unless(ea->getAncestorOfType(SBML_DOCUMENT) == NULL);
712 fail_unless(ea->getAncestorOfType(SBML_COMPARTMENT) == NULL);
713
714 Delay *obj = e->getDelay();
715
716 fail_unless(obj->getAncestorOfType(SBML_EVENT) == e);
717 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
718 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
719
720 delete e;
721 }
722 END_TEST
723
724
START_TEST(test_Delay_ancestor_create_model)725 START_TEST ( test_Delay_ancestor_create_model )
726 {
727 Model *m = new Model(2, 4);
728 Event *e = m->createEvent();
729
730 Delay *ea = m->createDelay();
731
732 fail_unless(ea->getAncestorOfType(SBML_EVENT) == e);
733 fail_unless(ea->getAncestorOfType(SBML_MODEL) == m);
734 fail_unless(ea->getAncestorOfType(SBML_DOCUMENT) == NULL);
735 fail_unless(ea->getAncestorOfType(SBML_COMPARTMENT) == NULL);
736
737 Delay *obj = e->getDelay();
738
739 fail_unless(obj->getAncestorOfType(SBML_EVENT) == e);
740 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
741 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
742 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
743
744 delete m;
745 }
746 END_TEST
747
748
START_TEST(test_Event_ancestor_create)749 START_TEST ( test_Event_ancestor_create )
750 {
751 Model *m = new Model(2, 4);
752 Event *e = m->createEvent();
753
754 ListOf *lo = m->getListOfEvents();
755
756 fail_unless(e->getAncestorOfType(SBML_MODEL) == m);
757 fail_unless(e->getAncestorOfType(SBML_LIST_OF) == lo);
758 fail_unless(e->getAncestorOfType(SBML_DOCUMENT) == NULL);
759 fail_unless(e->getAncestorOfType(SBML_PARAMETER) == NULL);
760
761 Event *obj = m->getEvent(0);
762
763 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
764 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
765 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
766 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
767
768 delete m;
769 }
770 END_TEST
771
772
START_TEST(test_EventAssignment_ancestor_create)773 START_TEST ( test_EventAssignment_ancestor_create )
774 {
775 Event *e = new Event(2, 4);
776
777 EventAssignment *ea = e->createEventAssignment();
778
779 ListOf *lo = e->getListOfEventAssignments();
780
781 fail_unless(ea->getAncestorOfType(SBML_EVENT) == e);
782 fail_unless(ea->getAncestorOfType(SBML_LIST_OF) == lo);
783 fail_unless(ea->getAncestorOfType(SBML_DOCUMENT) == NULL);
784 fail_unless(ea->getAncestorOfType(SBML_COMPARTMENT) == NULL);
785
786 EventAssignment *obj = e->getEventAssignment(0);
787
788 fail_unless(obj->getAncestorOfType(SBML_EVENT) == e);
789 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
790 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
791 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
792
793 delete e;
794 }
795 END_TEST
796
797
START_TEST(test_EventAssignment_ancestor_create_model)798 START_TEST ( test_EventAssignment_ancestor_create_model )
799 {
800 Model *m = new Model(2, 4);
801 Event *e = m->createEvent();
802
803 EventAssignment *ea = m->createEventAssignment();
804
805 ListOf *lo = e->getListOfEventAssignments();
806
807 fail_unless(ea->getAncestorOfType(SBML_EVENT) == e);
808 fail_unless(ea->getAncestorOfType(SBML_LIST_OF) == lo);
809 fail_unless(ea->getAncestorOfType(SBML_MODEL) == m);
810 fail_unless(ea->getAncestorOfType(SBML_DOCUMENT) == NULL);
811 fail_unless(ea->getAncestorOfType(SBML_COMPARTMENT) == NULL);
812
813 EventAssignment *obj = e->getEventAssignment(0);
814
815 fail_unless(obj->getAncestorOfType(SBML_EVENT) == e);
816 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
817 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
818 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
819 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
820
821 delete m;
822 }
823 END_TEST
824
825
START_TEST(test_FunctionDefinition_ancestor_create)826 START_TEST ( test_FunctionDefinition_ancestor_create )
827 {
828 Model *m = new Model(2, 4);
829 FunctionDefinition *fd = m->createFunctionDefinition();
830
831 ListOf *lo = m->getListOfFunctionDefinitions();
832
833 fail_unless(fd->getAncestorOfType(SBML_MODEL) == m);
834 fail_unless(fd->getAncestorOfType(SBML_LIST_OF) == lo);
835 fail_unless(fd->getAncestorOfType(SBML_DOCUMENT) == NULL);
836 fail_unless(fd->getAncestorOfType(SBML_EVENT) == NULL);
837
838 FunctionDefinition *obj = m->getFunctionDefinition(0);
839
840 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
841 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
842 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
843 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
844
845 delete m;
846 }
847 END_TEST
848
849
START_TEST(test_InitialAssignment_ancestor_create)850 START_TEST ( test_InitialAssignment_ancestor_create )
851 {
852 Model *m = new Model(2, 4);
853 InitialAssignment *ia = m->createInitialAssignment();
854
855 ListOf *lo = m->getListOfInitialAssignments();
856
857 fail_unless(ia->getAncestorOfType(SBML_MODEL) == m);
858 fail_unless(ia->getAncestorOfType(SBML_LIST_OF) == lo);
859 fail_unless(ia->getAncestorOfType(SBML_DOCUMENT) == NULL);
860 fail_unless(ia->getAncestorOfType(SBML_EVENT) == NULL);
861
862 InitialAssignment *obj = m->getInitialAssignment(0);
863
864 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
865 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
866 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
867 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
868
869 delete m;
870 }
871 END_TEST
872
873
START_TEST(test_KineticLaw_ancestor_create)874 START_TEST ( test_KineticLaw_ancestor_create )
875 {
876 Reaction * r = new Reaction(2, 4);
877 KineticLaw* kl = r->createKineticLaw();
878
879 fail_unless(kl->getAncestorOfType(SBML_REACTION) == r);
880 fail_unless(kl->getAncestorOfType(SBML_DELAY) == NULL);
881 fail_unless(kl->getAncestorOfType(SBML_MODEL) == NULL);
882 fail_unless(kl->getAncestorOfType(SBML_DOCUMENT) == NULL);
883
884 KineticLaw *obj = r->getKineticLaw();
885
886 fail_unless(obj->getAncestorOfType(SBML_REACTION) == r);
887 fail_unless(obj->getAncestorOfType(SBML_MODEL) == NULL);
888 fail_unless(obj->getAncestorOfType(SBML_DELAY) == NULL);
889 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
890
891 delete r;
892 }
893 END_TEST
894
895
START_TEST(test_KineticLaw_ancestor_create_model)896 START_TEST ( test_KineticLaw_ancestor_create_model )
897 {
898 Model *m = new Model(2, 4);
899 Reaction * r = m->createReaction();
900 KineticLaw* kl = r->createKineticLaw();
901
902 fail_unless(kl->getAncestorOfType(SBML_REACTION) == r);
903 fail_unless(kl->getAncestorOfType(SBML_MODEL) == m);
904 fail_unless(kl->getAncestorOfType(SBML_DELAY) == NULL);
905 fail_unless(kl->getAncestorOfType(SBML_DOCUMENT) == NULL);
906
907 KineticLaw *obj = r->getKineticLaw();
908
909 fail_unless(obj->getAncestorOfType(SBML_REACTION) == r);
910 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
911 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
912 fail_unless(obj->getAncestorOfType(SBML_DELAY) == NULL);
913
914 delete m;
915 }
916 END_TEST
917
918
START_TEST(test_KineticLaw_Parameter_ancestor_create)919 START_TEST ( test_KineticLaw_Parameter_ancestor_create )
920 {
921 KineticLaw* kl=new KineticLaw(2, 4);
922 Parameter * p = kl->createParameter();
923
924 fail_unless(kl->getNumParameters() == 1);
925
926 ListOfParameters *lop = kl->getListOfParameters();
927
928 fail_unless(p->getAncestorOfType(SBML_KINETIC_LAW) == kl);
929 fail_unless(p->getAncestorOfType(SBML_LIST_OF) == lop);
930 fail_unless(p->getAncestorOfType(SBML_DOCUMENT) == NULL);
931 fail_unless(p->getAncestorOfType(SBML_COMPARTMENT) == NULL);
932
933 Parameter *obj = kl->getParameter(0);
934
935 fail_unless(obj->getAncestorOfType(SBML_KINETIC_LAW) == kl);
936 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lop);
937 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
938 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
939
940 delete kl;
941 }
942 END_TEST
943
944
START_TEST(test_KineticLaw_Parameter_ancestor_create_model)945 START_TEST ( test_KineticLaw_Parameter_ancestor_create_model )
946 {
947 Model *m = new Model(2, 4);
948 Reaction *r = m->createReaction();
949 KineticLaw* kl = m->createKineticLaw();
950 Parameter * p = m->createKineticLawParameter();
951
952 fail_unless(kl->getNumParameters() == 1);
953
954 ListOfParameters *lop = kl->getListOfParameters();
955
956 fail_unless(p->getAncestorOfType(SBML_KINETIC_LAW) == kl);
957 fail_unless(p->getAncestorOfType(SBML_LIST_OF) == lop);
958 fail_unless(p->getAncestorOfType(SBML_REACTION) == r);
959 fail_unless(p->getAncestorOfType(SBML_MODEL) == m);
960 fail_unless(p->getAncestorOfType(SBML_DOCUMENT) == NULL);
961 fail_unless(p->getAncestorOfType(SBML_COMPARTMENT) == NULL);
962
963 Parameter *obj = kl->getParameter(0);
964
965 fail_unless(obj->getAncestorOfType(SBML_KINETIC_LAW) == kl);
966 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lop);
967 fail_unless(obj->getAncestorOfType(SBML_REACTION) == r);
968 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
969 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
970 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
971
972 delete m;
973 }
974 END_TEST
975
976
START_TEST(test_Model_ancestor_create)977 START_TEST ( test_Model_ancestor_create )
978 {
979 SBMLDocument *d = new SBMLDocument();
980 Model *m = d->createModel();
981
982 fail_unless(m->getAncestorOfType(SBML_DOCUMENT) == d);
983
984 Model *obj = d->getModel();
985
986 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == d);
987
988 delete d;
989 }
990 END_TEST
991
992
START_TEST(test_Parameter_ancestor_create)993 START_TEST ( test_Parameter_ancestor_create )
994 {
995 Model *m = new Model(2, 4);
996 Parameter *p = m->createParameter();
997
998 ListOf *lo = m->getListOfParameters();
999
1000 fail_unless(p->getAncestorOfType(SBML_MODEL) == m);
1001 fail_unless(p->getAncestorOfType(SBML_LIST_OF) == lo);
1002 fail_unless(p->getAncestorOfType(SBML_DOCUMENT) == NULL);
1003 fail_unless(p->getAncestorOfType(SBML_EVENT) == NULL);
1004
1005 Parameter *obj = m->getParameter(0);
1006
1007 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
1008 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
1009 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
1010 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
1011
1012 delete m;
1013 }
1014 END_TEST
1015
1016
START_TEST(test_Reaction_ancestor_create)1017 START_TEST ( test_Reaction_ancestor_create )
1018 {
1019 Model *m = new Model(2, 4);
1020 Reaction *r = m->createReaction();
1021
1022 ListOf *lo = m->getListOfReactions();
1023
1024 fail_unless(r->getAncestorOfType(SBML_MODEL) == m);
1025 fail_unless(r->getAncestorOfType(SBML_LIST_OF) == lo);
1026 fail_unless(r->getAncestorOfType(SBML_DOCUMENT) == NULL);
1027 fail_unless(r->getAncestorOfType(SBML_EVENT) == NULL);
1028
1029 Reaction *obj = m->getReaction(0);
1030
1031 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
1032 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
1033 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
1034 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
1035
1036 delete m;
1037 }
1038 END_TEST
1039
1040
START_TEST(test_AlgebraicRule_ancestor_create)1041 START_TEST ( test_AlgebraicRule_ancestor_create )
1042 {
1043 Model *m = new Model(2, 4);
1044 AlgebraicRule *r = m->createAlgebraicRule();
1045
1046 ListOf *lo = m->getListOfRules();
1047
1048 fail_unless(r->getAncestorOfType(SBML_MODEL) == m);
1049 fail_unless(r->getAncestorOfType(SBML_LIST_OF) == lo);
1050 fail_unless(r->getAncestorOfType(SBML_DOCUMENT) == NULL);
1051 fail_unless(r->getAncestorOfType(SBML_EVENT) == NULL);
1052
1053 Rule *obj = m->getRule(0);
1054
1055 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
1056 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
1057 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
1058 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
1059
1060 delete m;
1061 }
1062 END_TEST
1063
1064
START_TEST(test_AssignmentRule_ancestor_create)1065 START_TEST ( test_AssignmentRule_ancestor_create )
1066 {
1067 Model *m = new Model(2, 4);
1068 AssignmentRule *r = m->createAssignmentRule();
1069
1070 ListOf *lo = m->getListOfRules();
1071
1072 fail_unless(r->getAncestorOfType(SBML_MODEL) == m);
1073 fail_unless(r->getAncestorOfType(SBML_LIST_OF) == lo);
1074 fail_unless(r->getAncestorOfType(SBML_DOCUMENT) == NULL);
1075 fail_unless(r->getAncestorOfType(SBML_EVENT) == NULL);
1076
1077 Rule *obj = m->getRule(0);
1078
1079 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
1080 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
1081 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
1082 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
1083
1084 delete m;
1085 }
1086 END_TEST
1087
1088
START_TEST(test_RateRule_ancestor_create)1089 START_TEST ( test_RateRule_ancestor_create )
1090 {
1091 Model *m = new Model(2, 4);
1092 RateRule *r = m->createRateRule();
1093
1094 ListOf *lo = m->getListOfRules();
1095
1096 fail_unless(r->getAncestorOfType(SBML_MODEL) == m);
1097 fail_unless(r->getAncestorOfType(SBML_LIST_OF) == lo);
1098 fail_unless(r->getAncestorOfType(SBML_DOCUMENT) == NULL);
1099 fail_unless(r->getAncestorOfType(SBML_EVENT) == NULL);
1100
1101 Rule *obj = m->getRule(0);
1102
1103 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
1104 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
1105 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
1106 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
1107
1108 delete m;
1109 }
1110 END_TEST
1111
1112
START_TEST(test_Species_ancestor_create)1113 START_TEST ( test_Species_ancestor_create )
1114 {
1115 Model *m = new Model(2, 4);
1116 Species *s = m->createSpecies();
1117
1118 ListOf *lo = m->getListOfSpecies();
1119
1120 fail_unless(s->getAncestorOfType(SBML_MODEL) == m);
1121 fail_unless(s->getAncestorOfType(SBML_LIST_OF) == lo);
1122 fail_unless(s->getAncestorOfType(SBML_DOCUMENT) == NULL);
1123 fail_unless(s->getAncestorOfType(SBML_EVENT) == NULL);
1124
1125 Species *obj = m->getSpecies(0);
1126
1127 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
1128 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
1129 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
1130 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
1131
1132 delete m;
1133 }
1134 END_TEST
1135
1136
START_TEST(test_SpeciesReference_Product_ancestor_create)1137 START_TEST ( test_SpeciesReference_Product_ancestor_create )
1138 {
1139 Reaction *r = new Reaction(2, 4);
1140 SpeciesReference *sr = r->createProduct();
1141
1142 ListOf *lo = r->getListOfProducts();
1143
1144 fail_unless(sr->getAncestorOfType(SBML_REACTION) == r);
1145 fail_unless(sr->getAncestorOfType(SBML_LIST_OF) == lo);
1146 fail_unless(sr->getAncestorOfType(SBML_DOCUMENT) == NULL);
1147 fail_unless(sr->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1148
1149 SpeciesReference *obj = r->getProduct(0);
1150
1151 fail_unless(obj->getAncestorOfType(SBML_REACTION) == r);
1152 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
1153 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
1154 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1155
1156 delete r;
1157 }
1158 END_TEST
1159
1160
START_TEST(test_SpeciesReference_Product_ancestor_create_model)1161 START_TEST ( test_SpeciesReference_Product_ancestor_create_model )
1162 {
1163 Model *m = new Model(2, 4);
1164 Reaction *r = m->createReaction();
1165 SpeciesReference *sr = m->createProduct();
1166
1167 ListOf *lo = r->getListOfProducts();
1168
1169 fail_unless(sr->getAncestorOfType(SBML_REACTION) == r);
1170 fail_unless(sr->getAncestorOfType(SBML_LIST_OF) == lo);
1171 fail_unless(sr->getAncestorOfType(SBML_MODEL) == m);
1172 fail_unless(sr->getAncestorOfType(SBML_DOCUMENT) == NULL);
1173 fail_unless(sr->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1174
1175 SpeciesReference *obj = r->getProduct(0);
1176
1177 fail_unless(obj->getAncestorOfType(SBML_REACTION) == r);
1178 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
1179 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
1180 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
1181 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1182
1183 delete m;
1184 }
1185 END_TEST
1186
1187
START_TEST(test_SpeciesReference_Reactant_ancestor_create)1188 START_TEST ( test_SpeciesReference_Reactant_ancestor_create )
1189 {
1190 Reaction *r = new Reaction(2, 4);
1191 SpeciesReference *sr = r->createReactant();
1192
1193 ListOf *lo = r->getListOfReactants();
1194
1195 fail_unless(sr->getAncestorOfType(SBML_REACTION) == r);
1196 fail_unless(sr->getAncestorOfType(SBML_LIST_OF) == lo);
1197 fail_unless(sr->getAncestorOfType(SBML_DOCUMENT) == NULL);
1198 fail_unless(sr->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1199
1200 SpeciesReference *obj = r->getReactant(0);
1201
1202 fail_unless(obj->getAncestorOfType(SBML_REACTION) == r);
1203 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
1204 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
1205 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1206
1207 delete r;
1208 }
1209 END_TEST
1210
1211
START_TEST(test_SpeciesReference_Reactant_ancestor_create_model)1212 START_TEST ( test_SpeciesReference_Reactant_ancestor_create_model )
1213 {
1214 Model *m = new Model(2, 4);
1215 Reaction *r = m->createReaction();
1216 SpeciesReference *sr = m->createReactant();
1217
1218 ListOf *lo = r->getListOfReactants();
1219
1220 fail_unless(sr->getAncestorOfType(SBML_REACTION) == r);
1221 fail_unless(sr->getAncestorOfType(SBML_LIST_OF) == lo);
1222 fail_unless(sr->getAncestorOfType(SBML_MODEL) == m);
1223 fail_unless(sr->getAncestorOfType(SBML_DOCUMENT) == NULL);
1224 fail_unless(sr->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1225
1226 SpeciesReference *obj = r->getReactant(0);
1227
1228 fail_unless(obj->getAncestorOfType(SBML_REACTION) == r);
1229 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
1230 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
1231 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
1232 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1233
1234 delete m;
1235 }
1236 END_TEST
1237
1238
START_TEST(test_SpeciesReference_Modifier_ancestor_create)1239 START_TEST ( test_SpeciesReference_Modifier_ancestor_create )
1240 {
1241 Reaction *r = new Reaction(2, 4);
1242 ModifierSpeciesReference *sr = r->createModifier();
1243
1244 ListOf *lo = r->getListOfModifiers();
1245
1246 fail_unless(sr->getAncestorOfType(SBML_REACTION) == r);
1247 fail_unless(sr->getAncestorOfType(SBML_LIST_OF) == lo);
1248 fail_unless(sr->getAncestorOfType(SBML_DOCUMENT) == NULL);
1249 fail_unless(sr->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1250
1251 ModifierSpeciesReference *obj = r->getModifier(0);
1252
1253 fail_unless(obj->getAncestorOfType(SBML_REACTION) == r);
1254 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
1255 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
1256 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1257
1258 delete r;
1259 }
1260 END_TEST
1261
1262
START_TEST(test_SpeciesReference_Modifier_ancestor_create_model)1263 START_TEST ( test_SpeciesReference_Modifier_ancestor_create_model )
1264 {
1265 Model *m = new Model(2, 4);
1266 Reaction *r = m->createReaction();
1267 ModifierSpeciesReference *sr = m->createModifier();
1268
1269 ListOf *lo = r->getListOfModifiers();
1270
1271 fail_unless(sr->getAncestorOfType(SBML_REACTION) == r);
1272 fail_unless(sr->getAncestorOfType(SBML_LIST_OF) == lo);
1273 fail_unless(sr->getAncestorOfType(SBML_MODEL) == m);
1274 fail_unless(sr->getAncestorOfType(SBML_DOCUMENT) == NULL);
1275 fail_unless(sr->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1276
1277 ModifierSpeciesReference *obj = r->getModifier(0);
1278
1279 fail_unless(obj->getAncestorOfType(SBML_REACTION) == r);
1280 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
1281 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
1282 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
1283 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1284
1285 delete m;
1286 }
1287 END_TEST
1288
1289
START_TEST(test_SpeciesType_ancestor_create)1290 START_TEST ( test_SpeciesType_ancestor_create )
1291 {
1292 Model *m = new Model(2, 4);
1293 SpeciesType *st = m->createSpeciesType();
1294
1295 ListOf *lo = m->getListOfSpeciesTypes();
1296
1297 fail_unless(st->getAncestorOfType(SBML_MODEL) == m);
1298 fail_unless(st->getAncestorOfType(SBML_LIST_OF) == lo);
1299 fail_unless(st->getAncestorOfType(SBML_DOCUMENT) == NULL);
1300 fail_unless(st->getAncestorOfType(SBML_EVENT) == NULL);
1301
1302 SpeciesType *obj = m->getSpeciesType(0);
1303
1304 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
1305 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
1306 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
1307 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
1308
1309 delete m;
1310 }
1311 END_TEST
1312
1313
START_TEST(test_StoichiometryMath_ancestor_create)1314 START_TEST ( test_StoichiometryMath_ancestor_create )
1315 {
1316 SpeciesReference *sr = new SpeciesReference(2, 4);
1317 StoichiometryMath *sm = sr->createStoichiometryMath();
1318
1319 fail_unless(sm->getAncestorOfType(SBML_SPECIES_REFERENCE) == sr);
1320 fail_unless(sm->getAncestorOfType(SBML_DOCUMENT) == NULL);
1321 fail_unless(sm->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1322
1323 StoichiometryMath *obj = sr->getStoichiometryMath();
1324
1325 fail_unless(obj->getAncestorOfType(SBML_SPECIES_REFERENCE) == sr);
1326 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
1327 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1328
1329 delete sr;
1330 }
1331 END_TEST
1332
1333
START_TEST(test_Trigger_ancestor_create)1334 START_TEST ( test_Trigger_ancestor_create )
1335 {
1336 Event *e = new Event(2, 4);
1337
1338 Trigger *ea = e->createTrigger();
1339
1340 fail_unless(ea->getAncestorOfType(SBML_EVENT) == e);
1341 fail_unless(ea->getAncestorOfType(SBML_DOCUMENT) == NULL);
1342 fail_unless(ea->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1343
1344 Trigger *obj = e->getTrigger();
1345
1346 fail_unless(obj->getAncestorOfType(SBML_EVENT) == e);
1347 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
1348 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1349
1350 delete e;
1351 }
1352 END_TEST
1353
1354
START_TEST(test_Trigger_ancestor_create_model)1355 START_TEST ( test_Trigger_ancestor_create_model )
1356 {
1357 Model *m = new Model(2, 4);
1358 Event *e = m->createEvent();
1359
1360 Trigger *ea = m->createTrigger();
1361
1362 fail_unless(ea->getAncestorOfType(SBML_EVENT) == e);
1363 fail_unless(ea->getAncestorOfType(SBML_MODEL) == m);
1364 fail_unless(ea->getAncestorOfType(SBML_DOCUMENT) == NULL);
1365 fail_unless(ea->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1366
1367 Trigger *obj = e->getTrigger();
1368
1369 fail_unless(obj->getAncestorOfType(SBML_EVENT) == e);
1370 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
1371 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
1372 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1373
1374 delete m;
1375 }
1376 END_TEST
1377
1378
START_TEST(test_Unit_ancestor_create)1379 START_TEST ( test_Unit_ancestor_create )
1380 {
1381 UnitDefinition* ud = new UnitDefinition(2, 4);
1382 Unit * u = ud->createUnit();
1383
1384 fail_unless(ud->getNumUnits() == 1);
1385
1386 ListOf *lo = ud->getListOfUnits();
1387
1388 fail_unless(u->getAncestorOfType(SBML_UNIT_DEFINITION) == ud);
1389 fail_unless(u->getAncestorOfType(SBML_LIST_OF) == lo);
1390 fail_unless(u->getAncestorOfType(SBML_DOCUMENT) == NULL);
1391 fail_unless(u->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1392
1393 Unit *obj = ud->getUnit(0);
1394
1395 fail_unless(obj->getAncestorOfType(SBML_UNIT_DEFINITION) == ud);
1396 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
1397 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
1398 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1399
1400 delete ud;
1401 }
1402 END_TEST
1403
1404
START_TEST(test_Unit_ancestor_create_model)1405 START_TEST ( test_Unit_ancestor_create_model )
1406 {
1407 Model *m = new Model(2, 4);
1408 UnitDefinition* ud = m->createUnitDefinition();
1409 Unit * u = m->createUnit();
1410
1411 fail_unless(ud->getNumUnits() == 1);
1412
1413 ListOf *lo = ud->getListOfUnits();
1414
1415 fail_unless(u->getAncestorOfType(SBML_UNIT_DEFINITION) == ud);
1416 fail_unless(u->getAncestorOfType(SBML_LIST_OF) == lo);
1417 fail_unless(u->getAncestorOfType(SBML_MODEL) == m);
1418 fail_unless(u->getAncestorOfType(SBML_DOCUMENT) == NULL);
1419 fail_unless(u->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1420
1421 Unit *obj = ud->getUnit(0);
1422
1423 fail_unless(obj->getAncestorOfType(SBML_UNIT_DEFINITION) == ud);
1424 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
1425 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
1426 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
1427 fail_unless(obj->getAncestorOfType(SBML_COMPARTMENT) == NULL);
1428
1429 delete m;
1430 }
1431 END_TEST
1432
1433
START_TEST(test_UnitDefinition_ancestor_create)1434 START_TEST ( test_UnitDefinition_ancestor_create )
1435 {
1436 Model *m = new Model(2, 4);
1437 UnitDefinition *ud = m->createUnitDefinition();
1438
1439 ListOf *lo = m->getListOfUnitDefinitions();
1440
1441 fail_unless(ud->getAncestorOfType(SBML_MODEL) == m);
1442 fail_unless(ud->getAncestorOfType(SBML_LIST_OF) == lo);
1443 fail_unless(ud->getAncestorOfType(SBML_DOCUMENT) == NULL);
1444 fail_unless(ud->getAncestorOfType(SBML_EVENT) == NULL);
1445
1446 UnitDefinition *obj = m->getUnitDefinition(0);
1447
1448 fail_unless(obj->getAncestorOfType(SBML_MODEL) == m);
1449 fail_unless(obj->getAncestorOfType(SBML_LIST_OF) == lo);
1450 fail_unless(obj->getAncestorOfType(SBML_DOCUMENT) == NULL);
1451 fail_unless(obj->getAncestorOfType(SBML_EVENT) == NULL);
1452
1453 delete m;
1454 }
1455 END_TEST
1456
1457
1458 Suite *
create_suite_AncestorObject(void)1459 create_suite_AncestorObject (void)
1460 {
1461 Suite *suite = suite_create("AncestorObject");
1462 TCase *tcase = tcase_create("AncestorObject");
1463
1464 tcase_add_test( tcase, test_Compartment_ancestor_add );
1465 tcase_add_test( tcase, test_CompartmentType_ancestor_add );
1466 tcase_add_test( tcase, test_Constraint_ancestor_add );
1467 tcase_add_test( tcase, test_Delay_ancestor_add );
1468 tcase_add_test( tcase, test_Event_ancestor_add );
1469 tcase_add_test( tcase, test_EventAssignment_ancestor_add );
1470 tcase_add_test( tcase, test_FunctionDefinition_ancestor_add );
1471 tcase_add_test( tcase, test_InitialAssignment_ancestor_add );
1472 tcase_add_test( tcase, test_KineticLaw_ancestor_add );
1473 tcase_add_test( tcase, test_KineticLaw_Parameter_ancestor_add );
1474 tcase_add_test( tcase, test_Model_ancestor_add );
1475 tcase_add_test( tcase, test_Parameter_ancestor_add );
1476 tcase_add_test( tcase, test_Reaction_ancestor_add );
1477 tcase_add_test( tcase, test_Rule_ancestor_add );
1478 tcase_add_test( tcase, test_Species_ancestor_add );
1479 tcase_add_test( tcase, test_SpeciesReference_Product_ancestor_add );
1480 tcase_add_test( tcase, test_SpeciesReference_Reactant_ancestor_add );
1481 tcase_add_test( tcase, test_SpeciesReference_Modifier_ancestor_add );
1482 tcase_add_test( tcase, test_SpeciesType_ancestor_add );
1483 tcase_add_test( tcase, test_StoichiometryMath_ancestor_add );
1484 tcase_add_test( tcase, test_Trigger_ancestor_add );
1485 tcase_add_test( tcase, test_Unit_ancestor_add );
1486 tcase_add_test( tcase, test_UnitDefinition_ancestor_add );
1487 tcase_add_test( tcase, test_Compartment_ancestor_create );
1488 tcase_add_test( tcase, test_CompartmentType_ancestor_create );
1489 tcase_add_test( tcase, test_Constraint_ancestor_create );
1490 tcase_add_test( tcase, test_Delay_ancestor_create );
1491 tcase_add_test( tcase, test_Delay_ancestor_create_model );
1492 tcase_add_test( tcase, test_Event_ancestor_create );
1493 tcase_add_test( tcase, test_EventAssignment_ancestor_create );
1494 tcase_add_test( tcase, test_EventAssignment_ancestor_create_model );
1495 tcase_add_test( tcase, test_FunctionDefinition_ancestor_create );
1496 tcase_add_test( tcase, test_InitialAssignment_ancestor_create );
1497 tcase_add_test( tcase, test_KineticLaw_ancestor_create );
1498 tcase_add_test( tcase, test_KineticLaw_ancestor_create_model );
1499 tcase_add_test( tcase, test_KineticLaw_Parameter_ancestor_create );
1500 tcase_add_test( tcase, test_KineticLaw_Parameter_ancestor_create_model );
1501 tcase_add_test( tcase, test_Model_ancestor_create );
1502 tcase_add_test( tcase, test_Parameter_ancestor_create );
1503 tcase_add_test( tcase, test_Reaction_ancestor_create );
1504 tcase_add_test( tcase, test_AlgebraicRule_ancestor_create );
1505 tcase_add_test( tcase, test_AssignmentRule_ancestor_create );
1506 tcase_add_test( tcase, test_RateRule_ancestor_create );
1507 tcase_add_test( tcase, test_Species_ancestor_create );
1508 tcase_add_test( tcase, test_SpeciesReference_Product_ancestor_create );
1509 tcase_add_test( tcase, test_SpeciesReference_Product_ancestor_create_model );
1510 tcase_add_test( tcase, test_SpeciesReference_Reactant_ancestor_create );
1511 tcase_add_test( tcase, test_SpeciesReference_Reactant_ancestor_create_model );
1512 tcase_add_test( tcase, test_SpeciesReference_Modifier_ancestor_create );
1513 tcase_add_test( tcase, test_SpeciesReference_Modifier_ancestor_create_model );
1514 tcase_add_test( tcase, test_SpeciesType_ancestor_create );
1515 tcase_add_test( tcase, test_StoichiometryMath_ancestor_create );
1516 tcase_add_test( tcase, test_Trigger_ancestor_create );
1517 tcase_add_test( tcase, test_Trigger_ancestor_create_model );
1518 tcase_add_test( tcase, test_Unit_ancestor_create );
1519 tcase_add_test( tcase, test_Unit_ancestor_create_model );
1520 tcase_add_test( tcase, test_UnitDefinition_ancestor_create );
1521
1522 suite_add_tcase(suite, tcase);
1523
1524 return suite;
1525 }
1526 CK_CPPEND
1527
1528