1 /**
2 * Filename : TestCubicBezier.cpp
3 * Description : Unit tests for CubicBezier
4 * Organization: European Media Laboratories Research gGmbH
5 * Created : 2005-05-03
6 *
7 * <!--------------------------------------------------------------------------
8 * This file is part of libSBML. Please visit http://sbml.org for more
9 * information about SBML, and the latest version of libSBML.
10 *
11 * Copyright (C) 2020 jointly by the following organizations:
12 * 1. California Institute of Technology, Pasadena, CA, USA
13 * 2. University of Heidelberg, Heidelberg, Germany
14 * 3. University College London, London, UK
15 *
16 * Copyright (C) 2019 jointly by the following organizations:
17 * 1. California Institute of Technology, Pasadena, CA, USA
18 * 2. University of Heidelberg, Heidelberg, Germany
19 *
20 * Copyright (C) 2013-2018 jointly by the following organizations:
21 * 1. California Institute of Technology, Pasadena, CA, USA
22 * 2. EMBL European Bioinformatics Institute (EMBL-EBI), Hinxton, UK
23 * 3. University of Heidelberg, Heidelberg, Germany
24 *
25 * Copyright (C) 2009-2013 jointly by the following organizations:
26 * 1. California Institute of Technology, Pasadena, CA, USA
27 * 2. EMBL European Bioinformatics Institute (EMBL-EBI), Hinxton, UK
28 *
29 * Copyright (C) 2004-2008 by European Media Laboratories Research gGmbH,
30 * Heidelberg, Germany
31 *
32 * This library is free software; you can redistribute it and/or modify it
33 * under the terms of the GNU Lesser General Public License as published by
34 * the Free Software Foundation. A copy of the license agreement is provided
35 * in the file named "LICENSE.txt" included with this software distribution
36 * and also available online as http://sbml.org/software/libsbml/license.html
37 * ------------------------------------------------------------------------ -->
38 */
39
40 #include <sbml/common/common.h>
41 #include <sbml/common/extern.h>
42
43 #include <sbml/SBase.h>
44 #include <sbml/packages/layout/sbml/CubicBezier.h>
45 #include <sbml/packages/layout/sbml/Point.h>
46
47 #include <check.h>
48
49 LIBSBML_CPP_NAMESPACE_USE
50
51 BEGIN_C_DECLS
52
53 static CubicBezier_t* CB;
54 static LayoutPkgNamespaces* LN;
55
56 void
CubicBezierTest_setup(void)57 CubicBezierTest_setup (void)
58 {
59 CB = CubicBezier_create();
60 LN = new LayoutPkgNamespaces();
61 if(CB == NULL)
62 {
63 fail("CubicBezier_create(); returned a NULL pointer.");
64 }
65 }
66
67 void
CubicBezierTest_teardown(void)68 CubicBezierTest_teardown (void)
69 {
70 CubicBezier_free(CB);
71 delete LN;
72 }
73
START_TEST(test_CubicBezier_create)74 START_TEST ( test_CubicBezier_create )
75 {
76 fail_unless( CB->getPackageName() == "layout");
77 fail_unless( CB->getTypeCode() == SBML_LAYOUT_CUBICBEZIER);
78 fail_unless( SBase_getMetaId ((SBase_t*) CB) == NULL );
79
80 Point_t *pos=CubicBezier_getStart(CB);
81 fail_unless(pos != NULL);
82 fail_unless(Point_getXOffset(pos) == 0.0);
83 fail_unless(Point_getYOffset(pos) == 0.0);
84 fail_unless(Point_getZOffset(pos) == 0.0);
85
86 pos=CubicBezier_getBasePoint1(CB);
87 fail_unless(pos != NULL);
88 fail_unless(Point_getXOffset(pos) == 0.0);
89 fail_unless(Point_getYOffset(pos) == 0.0);
90 fail_unless(Point_getZOffset(pos) == 0.0);
91
92 pos=CubicBezier_getBasePoint2(CB);
93 fail_unless(pos != NULL);
94 fail_unless(Point_getXOffset(pos) == 0.0);
95 fail_unless(Point_getYOffset(pos) == 0.0);
96 fail_unless(Point_getZOffset(pos) == 0.0);
97
98 pos=CubicBezier_getEnd(CB);
99 fail_unless(pos != NULL);
100 fail_unless(Point_getXOffset(pos) == 0.0);
101 fail_unless(Point_getYOffset(pos) == 0.0);
102 fail_unless(Point_getZOffset(pos) == 0.0);
103
104 }
105 END_TEST
106
START_TEST(test_CubicBezier_createWithPoints)107 START_TEST ( test_CubicBezier_createWithPoints )
108 {
109 Point_t *start= new (std::nothrow) Point(LN,1.1,-2.2,3.3);
110 Point_t *base1= new (std::nothrow) Point(LN,-0.5,2.4,5.6);
111 Point_t *base2= new (std::nothrow) Point(LN,7.8,-0.3,-1.2);
112 Point_t *end = new (std::nothrow) Point(LN,-4.4,5.5,-6.6);
113
114 CubicBezier_t *cb= new CubicBezier(LN,start,base1,base2,end);
115
116 fail_unless( cb->getPackageName() == "layout");
117 fail_unless( cb->getTypeCode() == SBML_LAYOUT_CUBICBEZIER);
118 fail_unless( SBase_getMetaId ((SBase_t*) cb) == NULL );
119
120 Point_t *pos=CubicBezier_getStart(cb);
121 fail_unless(pos != NULL);
122 fail_unless(Point_getXOffset(pos) == Point_getXOffset(start));
123 fail_unless(Point_getYOffset(pos) == Point_getYOffset(start));
124 fail_unless(Point_getZOffset(pos) == Point_getZOffset(start));
125
126 pos=CubicBezier_getBasePoint1(cb);
127 fail_unless(pos != NULL);
128 fail_unless(Point_getXOffset(pos) == Point_getXOffset(base1));
129 fail_unless(Point_getYOffset(pos) == Point_getYOffset(base1));
130 fail_unless(Point_getZOffset(pos) == Point_getZOffset(base1));
131
132 pos=CubicBezier_getBasePoint2(cb);
133 fail_unless(pos != NULL);
134 fail_unless(Point_getXOffset(pos) == Point_getXOffset(base2));
135 fail_unless(Point_getYOffset(pos) == Point_getYOffset(base2));
136 fail_unless(Point_getZOffset(pos) == Point_getZOffset(base2));
137
138 pos=CubicBezier_getEnd(cb);
139 fail_unless(pos != NULL);
140 fail_unless(Point_getXOffset(pos) == Point_getXOffset(end));
141 fail_unless(Point_getYOffset(pos) == Point_getYOffset(end));
142 fail_unless(Point_getZOffset(pos) == Point_getZOffset(end));
143
144 Point_free(start);
145 Point_free(base1);
146 Point_free(base2);
147 Point_free(end);
148 CubicBezier_free(cb);
149 }
150 END_TEST
151
START_TEST(test_CubicBezier_createWithPoints_NULL)152 START_TEST ( test_CubicBezier_createWithPoints_NULL )
153 {
154 Point* nullPoint = NULL;
155 CubicBezier_t *cb=new CubicBezier(LN,
156 nullPoint,
157 nullPoint,
158 nullPoint,
159 nullPoint);
160
161 fail_unless( cb->getPackageName() == "layout");
162 fail_unless( cb->getTypeCode() == SBML_LAYOUT_CUBICBEZIER);
163 fail_unless( SBase_getMetaId ((SBase_t*) cb) == NULL );
164
165 Point_t *pos=CubicBezier_getStart(cb);
166 fail_unless(pos != NULL);
167 fail_unless(Point_getXOffset(pos) == 0.0);
168 fail_unless(Point_getYOffset(pos) == 0.0);
169 fail_unless(Point_getZOffset(pos) == 0.0);
170
171 pos=CubicBezier_getBasePoint1(cb);
172 fail_unless(pos != NULL);
173 fail_unless(Point_getXOffset(pos) == 0.0);
174 fail_unless(Point_getYOffset(pos) == 0.0);
175 fail_unless(Point_getZOffset(pos) == 0.0);
176
177 pos=CubicBezier_getBasePoint2(cb);
178 fail_unless(pos != NULL);
179 fail_unless(Point_getXOffset(pos) == 0.0);
180 fail_unless(Point_getYOffset(pos) == 0.0);
181 fail_unless(Point_getZOffset(pos) == 0.0);
182
183 pos=CubicBezier_getEnd(cb);
184 fail_unless(pos != NULL);
185 fail_unless(Point_getXOffset(pos) == 0.0);
186 fail_unless(Point_getYOffset(pos) == 0.0);
187 fail_unless(Point_getZOffset(pos) == 0.0);
188
189 CubicBezier_free(cb);
190 }
191 END_TEST
192
START_TEST(test_CubicBezier_createWithCoordinates)193 START_TEST ( test_CubicBezier_createWithCoordinates )
194 {
195 Point p1(LN,1.1,-2.2,3.3);
196 Point p2(LN,-4.4,5.5,-6.6);
197 Point p3(LN,7.7,-8.8,9.9);
198 Point p4(LN,-10.10,11.11,-12.12);
199
200 CubicBezier_t* cb= new CubicBezier(LN, &p1, &p2, &p3, &p4);
201
202 fail_unless( cb->getPackageName() == "layout");
203 fail_unless( cb->getTypeCode() == SBML_LAYOUT_CUBICBEZIER);
204 fail_unless( SBase_getMetaId ((SBase_t*) cb) == NULL );
205
206 Point_t *pos=CubicBezier_getStart(cb);
207 fail_unless(pos != NULL);
208 fail_unless(pos->getXOffset() == 1.1);
209 fail_unless(pos->getYOffset() == -2.2);
210 fail_unless(pos->getZOffset() == 3.3);
211
212 pos=CubicBezier_getBasePoint1(cb);
213 fail_unless(pos != NULL);
214 fail_unless(pos->getXOffset() == -4.4);
215 fail_unless(pos->getYOffset() == 5.5);
216 fail_unless(pos->getZOffset() == -6.6);
217
218 pos=CubicBezier_getBasePoint2(cb);
219 fail_unless(pos != NULL);
220 fail_unless(pos->getXOffset() == 7.7);
221 fail_unless(pos->getYOffset() == -8.8);
222 fail_unless(pos->getZOffset() == 9.9);
223
224 pos=CubicBezier_getEnd(cb);
225 fail_unless(pos != NULL);
226 fail_unless(pos->getXOffset() == -10.10);
227 fail_unless(pos->getYOffset() == 11.11);
228 fail_unless(pos->getZOffset() == -12.12);
229
230 CubicBezier_free(cb);
231 }
232 END_TEST
233
START_TEST(test_CubicBezier_free_NULL)234 START_TEST (test_CubicBezier_free_NULL)
235 {
236 CubicBezier_free(NULL);
237 }
238 END_TEST
239
START_TEST(test_CubicBezier_setStart)240 START_TEST (test_CubicBezier_setStart)
241 {
242 Point_t *pos= new (std::nothrow) Point(LN,1.1,-2.2,3.3);
243 CubicBezier_setStart(CB,pos);
244
245 Point_t* POS=CubicBezier_getStart(CB);
246
247 fail_unless(Point_getXOffset(pos) == Point_getXOffset(POS));
248 fail_unless(Point_getYOffset(pos) == Point_getYOffset(POS));
249 fail_unless(Point_getZOffset(pos) == Point_getZOffset(POS));
250 Point_free(pos);
251
252 }
253 END_TEST
254
START_TEST(test_CubicBezier_setBasePoint1)255 START_TEST (test_CubicBezier_setBasePoint1 )
256 {
257 Point_t *pos= new (std::nothrow) Point(LN,7.7,-8.8,9.9);
258 CubicBezier_setBasePoint1(CB,pos);
259
260 Point_t* POS=CubicBezier_getBasePoint1(CB);
261
262 fail_unless(Point_getXOffset(pos) == Point_getXOffset(POS));
263 fail_unless(Point_getYOffset(pos) == Point_getYOffset(POS));
264 fail_unless(Point_getZOffset(pos) == Point_getZOffset(POS));
265 Point_free(pos);
266 }
267 END_TEST
268
START_TEST(test_CubicBezier_setBasePoint2)269 START_TEST (test_CubicBezier_setBasePoint2 )
270 {
271 Point_t *pos= new (std::nothrow) Point(LN,-10.10,11.11,-12.12);
272 CubicBezier_setBasePoint2(CB,pos);
273
274 Point_t* POS=CubicBezier_getBasePoint2(CB);
275
276 fail_unless(Point_getXOffset(pos) == Point_getXOffset(POS));
277 fail_unless(Point_getYOffset(pos) == Point_getYOffset(POS));
278 fail_unless(Point_getZOffset(pos) == Point_getZOffset(POS));
279
280 Point_free(pos);
281 }
282 END_TEST
283
START_TEST(test_CubicBezier_setEnd)284 START_TEST (test_CubicBezier_setEnd )
285 {
286 Point_t *pos= new (std::nothrow) Point(LN,-4.4,5.5,-6.6);
287 CubicBezier_setEnd(CB,pos);
288
289 Point_t* POS=CubicBezier_getEnd(CB);
290
291 fail_unless(Point_getXOffset(pos) == Point_getXOffset(POS));
292 fail_unless(Point_getYOffset(pos) == Point_getYOffset(POS));
293 fail_unless(Point_getZOffset(pos) == Point_getZOffset(POS));
294 Point_free(pos);
295 }
296 END_TEST
297
START_TEST(test_CubicBezier_createFrom)298 START_TEST ( test_CubicBezier_createFrom )
299 {
300 Point_t* start= new (std::nothrow) Point(LN,1.1,-2.2,3.3);
301 Point_t* base1= new (std::nothrow) Point(LN,-4.4,5.5,-6.6);
302 Point_t* base2= new (std::nothrow) Point(LN,7.7,-8.8,9.9);
303 Point_t* end= new (std::nothrow) Point(LN,-10.10,11.11,-12.12);
304 CubicBezier_setStart(CB,start);
305 CubicBezier_setBasePoint1(CB,base1);
306 CubicBezier_setBasePoint2(CB,base2);
307 CubicBezier_setEnd(CB,end);
308 CubicBezier_t* cb=CubicBezier_createFrom(CB);
309 fail_unless( cb->getPackageName() == "layout");
310 fail_unless( cb->getTypeCode() == SBML_LAYOUT_CUBICBEZIER);
311 if(SBase_isSetMetaId((SBase_t*)CB))
312 {
313 std::string c1=SBase_getMetaId((SBase_t*)CB);
314 std::string c2=SBase_getMetaId((SBase_t*)cb);
315 fail_unless( c1 == c2 );
316 }
317
318 // c1=SBase_getNotes((SBase_t*)CB);
319 // c2=SBase_getNotes((SBase_t*)cb);
320 // if(SBase_isSetNotes((SBase_t*)CB))
321 // {
322 // fail_unless( strncmp(c1 , c2 ,strlen( c1)+1 )==0 );
323 // }
324 // else{
325 // fail_unless(!(c1 || c2));
326 // }
327
328 // c1=SBase_getAnnotation((SBase_t*)CB);
329 // c2=SBase_getAnnotation((SBase_t*)cb);
330 // if(SBase_isSetAnnotation((SBase_t*)CB))
331 // {
332 // fail_unless( strncmp(c1 , c2 ,strlen( c1)+1 )==0 );
333 // }
334 // else{
335 // fail_unless(!(c1 || c2));
336 // }
337
338 Point_t *pos=CubicBezier_getStart(cb);
339 Point_t *POS=CubicBezier_getStart(CB);
340 fail_unless(pos != NULL);
341 fail_unless(Point_getXOffset(pos) == Point_getXOffset(POS));
342 fail_unless(Point_getYOffset(pos) == Point_getYOffset(POS));
343 fail_unless(Point_getZOffset(pos) == Point_getZOffset(POS));
344
345 pos=CubicBezier_getBasePoint1(cb);
346 POS=CubicBezier_getBasePoint1(CB);
347 fail_unless(pos != NULL);
348 fail_unless(Point_getXOffset(pos) == Point_getXOffset(POS));
349 fail_unless(Point_getYOffset(pos) == Point_getYOffset(POS));
350 fail_unless(Point_getZOffset(pos) == Point_getZOffset(POS));
351
352 pos=CubicBezier_getBasePoint2(cb);
353 POS=CubicBezier_getBasePoint2(CB);
354 fail_unless(pos != NULL);
355 fail_unless(Point_getXOffset(pos) == Point_getXOffset(POS));
356 fail_unless(Point_getYOffset(pos) == Point_getYOffset(POS));
357 fail_unless(Point_getZOffset(pos) == Point_getZOffset(POS));
358
359 pos=CubicBezier_getEnd(cb);
360 POS=CubicBezier_getEnd(CB);
361 fail_unless(pos != NULL);
362 fail_unless(Point_getXOffset(pos) == Point_getXOffset(POS));
363 fail_unless(Point_getYOffset(pos) == Point_getYOffset(POS));
364 fail_unless(Point_getZOffset(pos) == Point_getZOffset(POS));
365 Point_free(start);
366 Point_free(base1);
367 Point_free(base2);
368 Point_free(end);
369
370 CubicBezier_free(cb);
371 }
372 END_TEST
373
START_TEST(test_CubicBezier_setStart_NULL)374 START_TEST (test_CubicBezier_setStart_NULL )
375 {
376 CubicBezier_setStart(CB,NULL);
377
378 Point_t *pos=CubicBezier_getStart(CB);
379 fail_unless(pos != NULL);
380 fail_unless(Point_getXOffset(pos) == 0.0);
381 fail_unless(Point_getYOffset(pos) == 0.0);
382 fail_unless(Point_getZOffset(pos) == 0.0);
383 }
384 END_TEST
385
START_TEST(test_CubicBezier_setBasePoint1_NULL)386 START_TEST (test_CubicBezier_setBasePoint1_NULL )
387 {
388 CubicBezier_setBasePoint1(CB,NULL);
389
390 Point_t *pos=CubicBezier_getBasePoint1(CB);
391 fail_unless(pos != NULL);
392 fail_unless(Point_getXOffset(pos) == 0.0);
393 fail_unless(Point_getYOffset(pos) == 0.0);
394 fail_unless(Point_getZOffset(pos) == 0.0);
395 }
396 END_TEST
397
START_TEST(test_CubicBezier_setBasePoint2_NULL)398 START_TEST (test_CubicBezier_setBasePoint2_NULL )
399 {
400 CubicBezier_setBasePoint2(CB,NULL);
401
402 Point_t *pos=CubicBezier_getBasePoint2(CB);
403 fail_unless(pos != NULL);
404 fail_unless(Point_getXOffset(pos) == 0.0);
405 fail_unless(Point_getYOffset(pos) == 0.0);
406 fail_unless(Point_getZOffset(pos) == 0.0);
407 }
408 END_TEST
409
410
START_TEST(test_CubicBezier_setEnd_NULL)411 START_TEST (test_CubicBezier_setEnd_NULL )
412 {
413 CubicBezier_setEnd(CB,NULL);
414 Point_t *pos=CubicBezier_getEnd(CB);
415 fail_unless(pos != NULL);
416 fail_unless(Point_getXOffset(pos) == 0.0);
417 fail_unless(Point_getYOffset(pos) == 0.0);
418 fail_unless(Point_getZOffset(pos) == 0.0);
419 }
420 END_TEST
421
START_TEST(test_CubicBezier_copyConstructor)422 START_TEST ( test_CubicBezier_copyConstructor )
423 {
424 CubicBezier* cb1=new CubicBezier();
425 XMLNode notes;
426 cb1->setNotes(¬es);
427 XMLNode annotation;
428 cb1->setAnnotation(&annotation);
429 CubicBezier* cb2=new CubicBezier(*cb1);
430 delete cb2;
431 delete cb1;
432 }
433 END_TEST
434
START_TEST(test_CubicBezier_assignmentOperator)435 START_TEST ( test_CubicBezier_assignmentOperator )
436 {
437 CubicBezier* cb1=new CubicBezier();
438 XMLNode notes;
439 cb1->setNotes(¬es);
440 XMLNode annotation;
441 cb1->setAnnotation(&annotation);
442 CubicBezier cb2=*cb1;
443 delete cb1;
444 }
445 END_TEST
446
447 Suite *
create_suite_CubicBezier(void)448 create_suite_CubicBezier (void)
449 {
450 Suite *suite = suite_create("CubicBezier");
451 TCase *tcase = tcase_create("CubicBezier");
452
453
454 tcase_add_checked_fixture( tcase,
455 CubicBezierTest_setup,
456 CubicBezierTest_teardown );
457
458 tcase_add_test( tcase, test_CubicBezier_create );
459 tcase_add_test( tcase, test_CubicBezier_createWithPoints );
460 tcase_add_test( tcase, test_CubicBezier_createWithPoints_NULL );
461 tcase_add_test( tcase, test_CubicBezier_createWithCoordinates );
462 tcase_add_test( tcase, test_CubicBezier_free_NULL );
463 tcase_add_test( tcase, test_CubicBezier_setStart );
464 tcase_add_test( tcase, test_CubicBezier_setStart_NULL );
465 tcase_add_test( tcase, test_CubicBezier_setBasePoint1 );
466 tcase_add_test( tcase, test_CubicBezier_setBasePoint1_NULL );
467 tcase_add_test( tcase, test_CubicBezier_setBasePoint2 );
468 tcase_add_test( tcase, test_CubicBezier_setBasePoint2_NULL );
469 tcase_add_test( tcase, test_CubicBezier_setEnd );
470 tcase_add_test( tcase, test_CubicBezier_setEnd_NULL );
471 tcase_add_test( tcase, test_CubicBezier_createFrom );
472 tcase_add_test( tcase, test_CubicBezier_copyConstructor );
473 tcase_add_test( tcase, test_CubicBezier_assignmentOperator );
474
475 suite_add_tcase(suite, tcase);
476
477 return suite;
478 }
479
480
481 END_C_DECLS
482