001 package jigcell.compare.tests;
002
003 import jigcell.compare.IDataElement;
004 import jigcell.compare.data.PackedTreeDataElement;
005 import jigcell.compare.data.PackedTreeDataElement2;
006 import jigcell.compare.data.SparseTreeDataElement;
007 import jigcell.compare.data.SparseTreeDataElement2;
008 import junit.framework.Test;
009 import junit.framework.TestCase;
010 import junit.framework.TestSuite;
011 import junit.textui.TestRunner;
012
013 /**
014 * A collection of tests to exercise the included data element types.
015 *
016 * <p>
017 * This code is licensed under the DARPA BioCOMP Open Source License. See LICENSE for more details.
018 * </p>
019 *
020 * @author Nicholas Allen
021 */
022
023 public class ElementTests extends TestCase {
024
025 /**
026 * Starts a new test suite run.
027 *
028 * @param args Program arguments
029 */
030
031 public static void main (String args []) {
032 TestRunner.run (suite ());
033 }
034
035 /**
036 * All of the tests in this test.
037 */
038
039 public static Test suite () {
040 return new TestSuite (ElementTests.class);
041 }
042
043 /**
044 * Creates a new element test.
045 *
046 * @param name Test name
047 */
048
049 public ElementTests (String name) {
050 super (name);
051 }
052
053 /**
054 * Test for true element.
055 */
056
057 public void testPackedTreeDataElementBoolean () throws Exception {
058 IDataElement element = PackedTreeDataElement.createElement ("true");
059 assertTrue (element.isScalar ());
060 assertTrue (element.getType () == IDataElement.Type.BOOLEAN);
061 assertTrue (element.getBooleanValue ());
062 }
063
064 /**
065 * Test for false element.
066 */
067
068 public void testPackedTreeDataElementBoolean2 () throws Exception {
069 IDataElement element = PackedTreeDataElement.createElement ("false");
070 assertTrue (element.isScalar ());
071 assertTrue (element.getType () == IDataElement.Type.BOOLEAN);
072 assertFalse (element.getBooleanValue ());
073 }
074
075 /**
076 * Test for empty element.
077 */
078
079 public void testPackedTreeDataElementEmpty () throws Exception {
080 IDataElement element = PackedTreeDataElement.createElement ("");
081 assertTrue (element.isScalar ());
082 assertTrue (element.getType () == IDataElement.Type.NONE);
083 }
084
085 /**
086 * Test for positive integer element.
087 */
088
089 public void testPackedTreeDataElementIntegral () throws Exception {
090 IDataElement element = PackedTreeDataElement.createElement ("1");
091 assertTrue (element.isScalar ());
092 assertTrue (element.getType () == IDataElement.Type.INTEGRAL);
093 assertTrue (element.getIntegralValue () == 1);
094 }
095
096 /**
097 * Test for zero integer element.
098 */
099
100 public void testPackedTreeDataElementIntegral2 () throws Exception {
101 IDataElement element = PackedTreeDataElement.createElement ("0");
102 assertTrue (element.isScalar ());
103 assertTrue (element.getType () == IDataElement.Type.INTEGRAL);
104 assertTrue (element.getIntegralValue () == 0);
105 }
106
107 /**
108 * Test for negative integer element.
109 */
110
111 public void testPackedTreeDataElementIntegral3 () throws Exception {
112 IDataElement element = PackedTreeDataElement.createElement ("-1");
113 assertTrue (element.isScalar ());
114 assertTrue (element.getType () == IDataElement.Type.INTEGRAL);
115 assertTrue (element.getIntegralValue () == -1);
116 }
117
118 /**
119 * Test for maximum integer element.
120 */
121
122 public void testPackedTreeDataElementIntegral4 () throws Exception {
123 IDataElement element = PackedTreeDataElement.createElement (String.valueOf (Long.MAX_VALUE));
124 assertTrue (element.isScalar ());
125 assertTrue (element.getType () == IDataElement.Type.INTEGRAL);
126 assertTrue (element.getIntegralValue () == Long.MAX_VALUE);
127 }
128
129 /**
130 * Test for minimum integer element.
131 */
132
133 public void testPackedTreeDataElementIntegral5 () throws Exception {
134 IDataElement element = PackedTreeDataElement.createElement (String.valueOf (Long.MIN_VALUE));
135 assertTrue (element.isScalar ());
136 assertTrue (element.getType () == IDataElement.Type.INTEGRAL);
137 assertTrue (element.getIntegralValue () == Long.MIN_VALUE);
138 }
139
140 /**
141 * Test for empty list element.
142 */
143
144 public void testPackedTreeDataElementList () throws Exception {
145 IDataElement element = PackedTreeDataElement.createElement ("()");
146 assertFalse (element.isScalar ());
147 assertTrue (element.getType () == IDataElement.Type.MULTIPLE);
148 assertTrue (element.getType (1) == IDataElement.Type.NONE);
149 }
150
151 /**
152 * Test for mixed type list element.
153 */
154
155 public void testPackedTreeDataElementList2 () throws Exception {
156 IDataElement element = PackedTreeDataElement.createElement ("(1,1.0,true,,\"\",())");
157 assertFalse (element.isScalar ());
158 assertTrue (element.getType () == IDataElement.Type.MULTIPLE);
159 assertTrue (element.getType (1) == IDataElement.Type.INTEGRAL);
160 assertTrue (element.getType (2) == IDataElement.Type.REAL);
161 assertTrue (element.getType (3) == IDataElement.Type.BOOLEAN);
162 assertTrue (element.getType (4) == IDataElement.Type.NONE);
163 assertTrue (element.getType (5) == IDataElement.Type.LITERAL);
164 assertTrue (element.getType (6) == IDataElement.Type.MULTIPLE);
165 }
166
167 /**
168 * Assorted tests for PackedTreeDataElement used in benchmarks.
169 */
170
171 public void testPackedTreeDataElementMixed () throws Exception {
172 ElementBenchmark.test (PackedTreeDataElement.class);
173 }
174
175 /**
176 * Test for positive real element.
177 */
178
179 public void testPackedTreeDataElementReal () throws Exception {
180 IDataElement element = PackedTreeDataElement.createElement ("1.0");
181 assertTrue (element.isScalar ());
182 assertTrue (element.getType () == IDataElement.Type.REAL);
183 assertTrue (element.getRealValue () == 1.0);
184 }
185
186 /**
187 * Test for negative infinite element.
188 */
189
190 public void testPackedTreeDataElementReal2 () throws Exception {
191 IDataElement element = PackedTreeDataElement.createElement ("-infinity");
192 assertTrue (element.isScalar ());
193 assertTrue (element.getType () == IDataElement.Type.REAL);
194 assertTrue (element.getRealValue () == Double.NEGATIVE_INFINITY);
195 }
196
197 /**
198 * Test for positive infinite element.
199 */
200
201 public void testPackedTreeDataElementReal3 () throws Exception {
202 IDataElement element = PackedTreeDataElement.createElement ("infinity");
203 assertTrue (element.isScalar ());
204 assertTrue (element.getType () == IDataElement.Type.REAL);
205 assertTrue (element.getRealValue () == Double.POSITIVE_INFINITY);
206 }
207
208 /**
209 * Test for maximum real element.
210 */
211
212 public void testPackedTreeDataElementReal4 () throws Exception {
213 IDataElement element = PackedTreeDataElement.createElement (String.valueOf (Double.MAX_VALUE));
214 assertTrue (element.isScalar ());
215 assertTrue (element.getType () == IDataElement.Type.REAL);
216 assertTrue (element.getRealValue () == Double.MAX_VALUE);
217 }
218
219 /**
220 * Test for minimum real element.
221 */
222
223 public void testPackedTreeDataElementReal5 () throws Exception {
224 IDataElement element = PackedTreeDataElement.createElement (String.valueOf (Double.MIN_VALUE));
225 assertTrue (element.isScalar ());
226 assertTrue (element.getType () == IDataElement.Type.REAL);
227 assertTrue (element.getRealValue () == Double.MIN_VALUE);
228 }
229
230 /**
231 * Test for undefined real element.
232 */
233
234 public void testPackedTreeDataElementReal6 () throws Exception {
235 IDataElement element = PackedTreeDataElement.createElement ("NaN");
236 assertTrue (element.isScalar ());
237 assertTrue (element.getType () == IDataElement.Type.REAL);
238 assertTrue (Double.isNaN (element.getRealValue ()));
239 }
240
241 /**
242 * Test for negative real element.
243 */
244
245 public void testPackedTreeDataElementReal7 () throws Exception {
246 IDataElement element = PackedTreeDataElement.createElement ("-1.0");
247 assertTrue (element.isScalar ());
248 assertTrue (element.getType () == IDataElement.Type.REAL);
249 assertTrue (element.getRealValue () == -1.0);
250 }
251
252 /**
253 * Test for zero real element.
254 */
255
256 public void testPackedTreeDataElementReal8 () throws Exception {
257 IDataElement element = PackedTreeDataElement.createElement ("0.0");
258 assertTrue (element.isScalar ());
259 assertTrue (element.getType () == IDataElement.Type.REAL);
260 assertTrue (element.getRealValue () == 0.0);
261 }
262
263 /**
264 * Test for string of an integer element.
265 */
266
267 public void testPackedTreeDataElementString () throws Exception {
268 IDataElement element = PackedTreeDataElement.createElement ("\"1\"");
269 assertTrue (element.isScalar ());
270 assertTrue (element.getType () == IDataElement.Type.LITERAL);
271 assertTrue (element.getLiteralValue ().equals ("1"));
272 }
273
274 /**
275 * Test for string of a real element.
276 */
277
278 public void testPackedTreeDataElementString2 () throws Exception {
279 IDataElement element = PackedTreeDataElement.createElement ("\"1.0\"");
280 assertTrue (element.isScalar ());
281 assertTrue (element.getType () == IDataElement.Type.LITERAL);
282 assertTrue (element.getLiteralValue ().equals ("1.0"));
283 }
284
285 /**
286 * Test for string of a boolean element.
287 */
288
289 public void testPackedTreeDataElementString3 () throws Exception {
290 IDataElement element = PackedTreeDataElement.createElement ("\"true\"");
291 assertTrue (element.isScalar ());
292 assertTrue (element.getType () == IDataElement.Type.LITERAL);
293 assertTrue (element.getLiteralValue ().equals ("true"));
294 }
295
296 /**
297 * Test for string of a list element.
298 */
299
300 public void testPackedTreeDataElementString4 () throws Exception {
301 IDataElement element = PackedTreeDataElement.createElement ("\"()\"");
302 assertTrue (element.isScalar ());
303 assertTrue (element.getType () == IDataElement.Type.LITERAL);
304 assertTrue (element.getLiteralValue ().equals ("()"));
305 }
306
307 /**
308 * Test for string of a string element.
309 */
310
311 public void testPackedTreeDataElementString5 () throws Exception {
312 IDataElement element = PackedTreeDataElement.createElement ("\"\"");
313 assertTrue (element.isScalar ());
314 assertTrue (element.getType () == IDataElement.Type.LITERAL);
315 assertTrue (element.getLiteralValue ().equals (""));
316 }
317
318 /**
319 * Test for true element.
320 */
321
322 public void testPackedTreeDataElement2Boolean () throws Exception {
323 IDataElement element = PackedTreeDataElement2.createElement ("true");
324 assertTrue (element.isScalar ());
325 assertTrue (element.getType () == IDataElement.Type.BOOLEAN);
326 assertTrue (element.getBooleanValue ());
327 }
328
329 /**
330 * Test for false element.
331 */
332
333 public void testPackedTreeDataElement2Boolean2 () throws Exception {
334 IDataElement element = PackedTreeDataElement2.createElement ("false");
335 assertTrue (element.isScalar ());
336 assertTrue (element.getType () == IDataElement.Type.BOOLEAN);
337 assertFalse (element.getBooleanValue ());
338 }
339
340 /**
341 * Test for empty element.
342 */
343
344 public void testPackedTreeDataElement2Empty () throws Exception {
345 IDataElement element = PackedTreeDataElement2.createElement ("");
346 assertTrue (element.isScalar ());
347 assertTrue (element.getType () == IDataElement.Type.NONE);
348 }
349
350 /**
351 * Test for positive integer element.
352 */
353
354 public void testPackedTreeDataElement2Integral () throws Exception {
355 IDataElement element = PackedTreeDataElement2.createElement ("1");
356 assertTrue (element.isScalar ());
357 assertTrue (element.getType () == IDataElement.Type.INTEGRAL);
358 assertTrue (element.getIntegralValue () == 1);
359 }
360
361 /**
362 * Test for zero integer element.
363 */
364
365 public void testPackedTreeDataElement2Integral2 () throws Exception {
366 IDataElement element = PackedTreeDataElement2.createElement ("0");
367 assertTrue (element.isScalar ());
368 assertTrue (element.getType () == IDataElement.Type.INTEGRAL);
369 assertTrue (element.getIntegralValue () == 0);
370 }
371
372 /**
373 * Test for negative integer element.
374 */
375
376 public void testPackedTreeDataElement2Integral3 () throws Exception {
377 IDataElement element = PackedTreeDataElement2.createElement ("-1");
378 assertTrue (element.isScalar ());
379 assertTrue (element.getType () == IDataElement.Type.INTEGRAL);
380 assertTrue (element.getIntegralValue () == -1);
381 }
382
383 /**
384 * Test for maximum integer element.
385 */
386
387 public void testPackedTreeDataElement2Integral4 () throws Exception {
388 IDataElement element = PackedTreeDataElement2.createElement (String.valueOf (Long.MAX_VALUE));
389 assertTrue (element.isScalar ());
390 assertTrue (element.getType () == IDataElement.Type.INTEGRAL);
391 assertTrue (element.getIntegralValue () == Long.MAX_VALUE);
392 }
393
394 /**
395 * Test for minimum integer element.
396 */
397
398 public void testPackedTreeDataElement2Integral5 () throws Exception {
399 IDataElement element = PackedTreeDataElement2.createElement (String.valueOf (Long.MIN_VALUE));
400 assertTrue (element.isScalar ());
401 assertTrue (element.getType () == IDataElement.Type.INTEGRAL);
402 assertTrue (element.getIntegralValue () == Long.MIN_VALUE);
403 }
404
405 /**
406 * Test for empty list element.
407 */
408
409 public void testPackedTreeDataElement2List () throws Exception {
410 IDataElement element = PackedTreeDataElement2.createElement ("()");
411 assertFalse (element.isScalar ());
412 assertTrue (element.getType () == IDataElement.Type.MULTIPLE);
413 assertTrue (element.getType (1) == IDataElement.Type.NONE);
414 }
415
416 /**
417 * Test for mixed type list element.
418 */
419
420 public void testPackedTreeDataElement2List2 () throws Exception {
421 IDataElement element = PackedTreeDataElement2.createElement ("(1,1.0,true,,\"\",())");
422 assertFalse (element.isScalar ());
423 assertTrue (element.getType () == IDataElement.Type.MULTIPLE);
424 assertTrue (element.getType (1) == IDataElement.Type.INTEGRAL);
425 assertTrue (element.getType (2) == IDataElement.Type.REAL);
426 assertTrue (element.getType (3) == IDataElement.Type.BOOLEAN);
427 assertTrue (element.getType (4) == IDataElement.Type.NONE);
428 assertTrue (element.getType (5) == IDataElement.Type.LITERAL);
429 assertTrue (element.getType (6) == IDataElement.Type.MULTIPLE);
430 }
431
432 /**
433 * Assorted tests for PackedTreeDataElement2 used in benchmarks.
434 */
435
436 public void testPackedTreeDataElement2Mixed () throws Exception {
437 ElementBenchmark.test (PackedTreeDataElement2.class);
438 }
439
440 /**
441 * Test for positive real element.
442 */
443
444 public void testPackedTreeDataElement2Real () throws Exception {
445 IDataElement element = PackedTreeDataElement2.createElement ("1.0");
446 assertTrue (element.isScalar ());
447 assertTrue (element.getType () == IDataElement.Type.REAL);
448 assertTrue (element.getRealValue () == 1.0);
449 }
450
451 /**
452 * Test for negative infinite element.
453 */
454
455 public void testPackedTreeDataElement2Real2 () throws Exception {
456 IDataElement element = PackedTreeDataElement2.createElement ("-infinity");
457 assertTrue (element.isScalar ());
458 assertTrue (element.getType () == IDataElement.Type.REAL);
459 assertTrue (element.getRealValue () == Double.NEGATIVE_INFINITY);
460 }
461
462 /**
463 * Test for positive infinite element.
464 */
465
466 public void testPackedTreeDataElement2Real3 () throws Exception {
467 IDataElement element = PackedTreeDataElement2.createElement ("infinity");
468 assertTrue (element.isScalar ());
469 assertTrue (element.getType () == IDataElement.Type.REAL);
470 assertTrue (element.getRealValue () == Double.POSITIVE_INFINITY);
471 }
472
473 /**
474 * Test for maximum real element.
475 */
476
477 public void testPackedTreeDataElement2Real4 () throws Exception {
478 IDataElement element = PackedTreeDataElement2.createElement (String.valueOf (Double.MAX_VALUE));
479 assertTrue (element.isScalar ());
480 assertTrue (element.getType () == IDataElement.Type.REAL);
481 assertTrue (element.getRealValue () == Double.MAX_VALUE);
482 }
483
484 /**
485 * Test for minimum real element.
486 */
487
488 public void testPackedTreeDataElement2Real5 () throws Exception {
489 IDataElement element = PackedTreeDataElement2.createElement (String.valueOf (Double.MIN_VALUE));
490 assertTrue (element.isScalar ());
491 assertTrue (element.getType () == IDataElement.Type.REAL);
492 assertTrue (element.getRealValue () == Double.MIN_VALUE);
493 }
494
495 /**
496 * Test for undefined real element.
497 */
498
499 public void testPackedTreeDataElement2Real6 () throws Exception {
500 IDataElement element = PackedTreeDataElement2.createElement ("NaN");
501 assertTrue (element.isScalar ());
502 assertTrue (element.getType () == IDataElement.Type.REAL);
503 assertTrue (Double.isNaN (element.getRealValue ()));
504 }
505
506 /**
507 * Test for negative real element.
508 */
509
510 public void testPackedTreeDataElement2Real7 () throws Exception {
511 IDataElement element = PackedTreeDataElement2.createElement ("-1.0");
512 assertTrue (element.isScalar ());
513 assertTrue (element.getType () == IDataElement.Type.REAL);
514 assertTrue (element.getRealValue () == -1.0);
515 }
516
517 /**
518 * Test for zero real element.
519 */
520
521 public void testPackedTreeDataElement2Real8 () throws Exception {
522 IDataElement element = PackedTreeDataElement2.createElement ("0.0");
523 assertTrue (element.isScalar ());
524 assertTrue (element.getType () == IDataElement.Type.REAL);
525 assertTrue (element.getRealValue () == 0.0);
526 }
527
528 /**
529 * Test for string of an integer element.
530 */
531
532 public void testPackedTreeDataElement2String () throws Exception {
533 IDataElement element = PackedTreeDataElement2.createElement ("\"1\"");
534 assertTrue (element.isScalar ());
535 assertTrue (element.getType () == IDataElement.Type.LITERAL);
536 assertTrue (element.getLiteralValue ().equals ("1"));
537 }
538
539 /**
540 * Test for string of a real element.
541 */
542
543 public void testPackedTreeDataElement2String2 () throws Exception {
544 IDataElement element = PackedTreeDataElement2.createElement ("\"1.0\"");
545 assertTrue (element.isScalar ());
546 assertTrue (element.getType () == IDataElement.Type.LITERAL);
547 assertTrue (element.getLiteralValue ().equals ("1.0"));
548 }
549
550 /**
551 * Test for string of a boolean element.
552 */
553
554 public void testPackedTreeDataElement2String3 () throws Exception {
555 IDataElement element = PackedTreeDataElement2.createElement ("\"true\"");
556 assertTrue (element.isScalar ());
557 assertTrue (element.getType () == IDataElement.Type.LITERAL);
558 assertTrue (element.getLiteralValue ().equals ("true"));
559 }
560
561 /**
562 * Test for string of a list element.
563 */
564
565 public void testPackedTreeDataElement2String4 () throws Exception {
566 IDataElement element = PackedTreeDataElement2.createElement ("\"()\"");
567 assertTrue (element.isScalar ());
568 assertTrue (element.getType () == IDataElement.Type.LITERAL);
569 assertTrue (element.getLiteralValue ().equals ("()"));
570 }
571
572 /**
573 * Test for string of a string element.
574 */
575
576 public void testPackedTreeDataElement2String5 () throws Exception {
577 IDataElement element = PackedTreeDataElement2.createElement ("\"\"");
578 assertTrue (element.isScalar ());
579 assertTrue (element.getType () == IDataElement.Type.LITERAL);
580 assertTrue (element.getLiteralValue ().equals (""));
581 }
582
583 /**
584 * Test for true element.
585 */
586
587 public void testSparseTreeDataElementBoolean () throws Exception {
588 IDataElement element = SparseTreeDataElement.createElement ("true");
589 assertTrue (element.isScalar ());
590 assertTrue (element.getType () == IDataElement.Type.BOOLEAN);
591 assertTrue (element.getBooleanValue ());
592 }
593
594 /**
595 * Test for false element.
596 */
597
598 public void testSparseTreeDataElementBoolean2 () throws Exception {
599 IDataElement element = SparseTreeDataElement.createElement ("false");
600 assertTrue (element.isScalar ());
601 assertTrue (element.getType () == IDataElement.Type.BOOLEAN);
602 assertFalse (element.getBooleanValue ());
603 }
604
605 /**
606 * Test for empty element.
607 */
608
609 public void testSparseTreeDataElementEmpty () throws Exception {
610 IDataElement element = SparseTreeDataElement.createElement ("");
611 assertTrue (element.isScalar ());
612 assertTrue (element.getType () == IDataElement.Type.NONE);
613 }
614
615 /**
616 * Test for positive integer element.
617 */
618
619 public void testSparseTreeDataElementIntegral () throws Exception {
620 IDataElement element = SparseTreeDataElement.createElement ("1");
621 assertTrue (element.isScalar ());
622 assertTrue (element.getType () == IDataElement.Type.INTEGRAL);
623 assertTrue (element.getIntegralValue () == 1);
624 }
625
626 /**
627 * Test for zero integer element.
628 */
629
630 public void testSparseTreeDataElementIntegral2 () throws Exception {
631 IDataElement element = SparseTreeDataElement.createElement ("0");
632 assertTrue (element.isScalar ());
633 assertTrue (element.getType () == IDataElement.Type.INTEGRAL);
634 assertTrue (element.getIntegralValue () == 0);
635 }
636
637 /**
638 * Test for negative integer element.
639 */
640
641 public void testSparseTreeDataElementIntegral3 () throws Exception {
642 IDataElement element = SparseTreeDataElement.createElement ("-1");
643 assertTrue (element.isScalar ());
644 assertTrue (element.getType () == IDataElement.Type.INTEGRAL);
645 assertTrue (element.getIntegralValue () == -1);
646 }
647
648 /**
649 * Test for maximum integer element.
650 */
651
652 public void testSparseTreeDataElementIntegral4 () throws Exception {
653 IDataElement element = SparseTreeDataElement.createElement (String.valueOf (Long.MAX_VALUE));
654 assertTrue (element.isScalar ());
655 assertTrue (element.getType () == IDataElement.Type.INTEGRAL);
656 assertTrue (element.getIntegralValue () == Long.MAX_VALUE);
657 }
658
659 /**
660 * Test for minimum integer element.
661 */
662
663 public void testSparseTreeDataElementIntegral5 () throws Exception {
664 IDataElement element = SparseTreeDataElement.createElement (String.valueOf (Long.MIN_VALUE));
665 assertTrue (element.isScalar ());
666 assertTrue (element.getType () == IDataElement.Type.INTEGRAL);
667 assertTrue (element.getIntegralValue () == Long.MIN_VALUE);
668 }
669
670 /**
671 * Test for empty list element.
672 */
673
674 public void testSparseTreeDataElementList () throws Exception {
675 IDataElement element = SparseTreeDataElement.createElement ("()");
676 assertFalse (element.isScalar ());
677 assertTrue (element.getType () == IDataElement.Type.MULTIPLE);
678 assertTrue (element.getType (1) == IDataElement.Type.NONE);
679 }
680
681 /**
682 * Test for mixed type list element.
683 */
684
685 public void testSparseTreeDataElementList2 () throws Exception {
686 IDataElement element = SparseTreeDataElement.createElement ("(1,1.0,true,,\"\",())");
687 assertFalse (element.isScalar ());
688 assertTrue (element.getType () == IDataElement.Type.MULTIPLE);
689 assertTrue (element.getType (1) == IDataElement.Type.INTEGRAL);
690 assertTrue (element.getType (2) == IDataElement.Type.REAL);
691 assertTrue (element.getType (3) == IDataElement.Type.BOOLEAN);
692 assertTrue (element.getType (4) == IDataElement.Type.NONE);
693 assertTrue (element.getType (5) == IDataElement.Type.LITERAL);
694 assertTrue (element.getType (6) == IDataElement.Type.MULTIPLE);
695 }
696
697 /**
698 * Assorted tests for SparseTreeDataElement used in benchmarks.
699 */
700
701 public void testSparseTreeDataElementMixed () throws Exception {
702 ElementBenchmark.test (SparseTreeDataElement.class);
703 }
704
705 /**
706 * Test for positive real element.
707 */
708
709 public void testSparseTreeDataElementReal () throws Exception {
710 IDataElement element = SparseTreeDataElement.createElement ("1.0");
711 assertTrue (element.isScalar ());
712 assertTrue (element.getType () == IDataElement.Type.REAL);
713 assertTrue (element.getRealValue () == 1.0);
714 }
715
716 /**
717 * Test for negative infinite element.
718 */
719
720 public void testSparseTreeDataElementReal2 () throws Exception {
721 IDataElement element = SparseTreeDataElement.createElement ("-infinity");
722 assertTrue (element.isScalar ());
723 assertTrue (element.getType () == IDataElement.Type.REAL);
724 assertTrue (element.getRealValue () == Double.NEGATIVE_INFINITY);
725 }
726
727 /**
728 * Test for positive infinite element.
729 */
730
731 public void testSparseTreeDataElementReal3 () throws Exception {
732 IDataElement element = SparseTreeDataElement.createElement ("infinity");
733 assertTrue (element.isScalar ());
734 assertTrue (element.getType () == IDataElement.Type.REAL);
735 assertTrue (element.getRealValue () == Double.POSITIVE_INFINITY);
736 }
737
738 /**
739 * Test for maximum real element.
740 */
741
742 public void testSparseTreeDataElementReal4 () throws Exception {
743 IDataElement element = SparseTreeDataElement.createElement (String.valueOf (Double.MAX_VALUE));
744 assertTrue (element.isScalar ());
745 assertTrue (element.getType () == IDataElement.Type.REAL);
746 assertTrue (element.getRealValue () == Double.MAX_VALUE);
747 }
748
749 /**
750 * Test for minimum real element.
751 */
752
753 public void testSparseTreeDataElementReal5 () throws Exception {
754 IDataElement element = SparseTreeDataElement.createElement (String.valueOf (Double.MIN_VALUE));
755 assertTrue (element.isScalar ());
756 assertTrue (element.getType () == IDataElement.Type.REAL);
757 assertTrue (element.getRealValue () == Double.MIN_VALUE);
758 }
759
760 /**
761 * Test for undefined real element.
762 */
763
764 public void testSparseTreeDataElementReal6 () throws Exception {
765 IDataElement element = SparseTreeDataElement.createElement ("NaN");
766 assertTrue (element.isScalar ());
767 assertTrue (element.getType () == IDataElement.Type.REAL);
768 assertTrue (Double.isNaN (element.getRealValue ()));
769 }
770
771 /**
772 * Test for negative real element.
773 */
774
775 public void testSparseTreeDataElementReal7 () throws Exception {
776 IDataElement element = SparseTreeDataElement.createElement ("-1.0");
777 assertTrue (element.isScalar ());
778 assertTrue (element.getType () == IDataElement.Type.REAL);
779 assertTrue (element.getRealValue () == -1.0);
780 }
781
782 /**
783 * Test for zero real element.
784 */
785
786 public void testSparseTreeDataElementReal8 () throws Exception {
787 IDataElement element = SparseTreeDataElement.createElement ("0.0");
788 assertTrue (element.isScalar ());
789 assertTrue (element.getType () == IDataElement.Type.REAL);
790 assertTrue (element.getRealValue () == 0.0);
791 }
792
793 /**
794 * Test for string of an integer element.
795 */
796
797 public void testSparseTreeDataElementString () throws Exception {
798 IDataElement element = SparseTreeDataElement.createElement ("\"1\"");
799 assertTrue (element.isScalar ());
800 assertTrue (element.getType () == IDataElement.Type.LITERAL);
801 assertTrue (element.getLiteralValue ().equals ("1"));
802 }
803
804 /**
805 * Test for string of a real element.
806 */
807
808 public void testSparseTreeDataElementString2 () throws Exception {
809 IDataElement element = SparseTreeDataElement.createElement ("\"1.0\"");
810 assertTrue (element.isScalar ());
811 assertTrue (element.getType () == IDataElement.Type.LITERAL);
812 assertTrue (element.getLiteralValue ().equals ("1.0"));
813 }
814
815 /**
816 * Test for string of a boolean element.
817 */
818
819 public void testSparseTreeDataElementString3 () throws Exception {
820 IDataElement element = SparseTreeDataElement.createElement ("\"true\"");
821 assertTrue (element.isScalar ());
822 assertTrue (element.getType () == IDataElement.Type.LITERAL);
823 assertTrue (element.getLiteralValue ().equals ("true"));
824 }
825
826 /**
827 * Test for string of a list element.
828 */
829
830 public void testSparseTreeDataElementString4 () throws Exception {
831 IDataElement element = SparseTreeDataElement.createElement ("\"()\"");
832 assertTrue (element.isScalar ());
833 assertTrue (element.getType () == IDataElement.Type.LITERAL);
834 assertTrue (element.getLiteralValue ().equals ("()"));
835 }
836
837 /**
838 * Test for string of a string element.
839 */
840
841 public void testSparseTreeDataElementString5 () throws Exception {
842 IDataElement element = SparseTreeDataElement.createElement ("\"\"");
843 assertTrue (element.isScalar ());
844 assertTrue (element.getType () == IDataElement.Type.LITERAL);
845 assertTrue (element.getLiteralValue ().equals (""));
846 }
847
848 /**
849 * Test for true element.
850 */
851
852 public void testSparseTreeDataElement2Boolean () throws Exception {
853 IDataElement element = SparseTreeDataElement2.createElement ("true");
854 assertTrue (element.isScalar ());
855 assertTrue (element.getType () == IDataElement.Type.BOOLEAN);
856 assertTrue (element.getBooleanValue ());
857 }
858
859 /**
860 * Test for false element.
861 */
862
863 public void testSparseTreeDataElement2Boolean2 () throws Exception {
864 IDataElement element = SparseTreeDataElement2.createElement ("false");
865 assertTrue (element.isScalar ());
866 assertTrue (element.getType () == IDataElement.Type.BOOLEAN);
867 assertFalse (element.getBooleanValue ());
868 }
869
870 /**
871 * Test for empty element.
872 */
873
874 public void testSparseTreeDataElement2Empty () throws Exception {
875 IDataElement element = SparseTreeDataElement2.createElement ("");
876 assertTrue (element.isScalar ());
877 assertTrue (element.getType () == IDataElement.Type.NONE);
878 }
879
880 /**
881 * Test for positive integer element.
882 */
883
884 public void testSparseTreeDataElement2Integral () throws Exception {
885 IDataElement element = SparseTreeDataElement2.createElement ("1");
886 assertTrue (element.isScalar ());
887 assertTrue (element.getType () == IDataElement.Type.INTEGRAL);
888 assertTrue (element.getIntegralValue () == 1);
889 }
890
891 /**
892 * Test for zero integer element.
893 */
894
895 public void testSparseTreeDataElement2Integral2 () throws Exception {
896 IDataElement element = SparseTreeDataElement2.createElement ("0");
897 assertTrue (element.isScalar ());
898 assertTrue (element.getType () == IDataElement.Type.INTEGRAL);
899 assertTrue (element.getIntegralValue () == 0);
900 }
901
902 /**
903 * Test for negative integer element.
904 */
905
906 public void testSparseTreeDataElement2Integral3 () throws Exception {
907 IDataElement element = SparseTreeDataElement2.createElement ("-1");
908 assertTrue (element.isScalar ());
909 assertTrue (element.getType () == IDataElement.Type.INTEGRAL);
910 assertTrue (element.getIntegralValue () == -1);
911 }
912
913 /**
914 * Test for maximum integer element.
915 */
916
917 public void testSparseTreeDataElement2Integral4 () throws Exception {
918 IDataElement element = SparseTreeDataElement2.createElement (String.valueOf (Long.MAX_VALUE));
919 assertTrue (element.isScalar ());
920 assertTrue (element.getType () == IDataElement.Type.INTEGRAL);
921 assertTrue (element.getIntegralValue () == Long.MAX_VALUE);
922 }
923
924 /**
925 * Test for minimum integer element.
926 */
927
928 public void testSparseTreeDataElement2Integral5 () throws Exception {
929 IDataElement element = SparseTreeDataElement2.createElement (String.valueOf (Long.MIN_VALUE));
930 assertTrue (element.isScalar ());
931 assertTrue (element.getType () == IDataElement.Type.INTEGRAL);
932 assertTrue (element.getIntegralValue () == Long.MIN_VALUE);
933 }
934
935 /**
936 * Test for empty list element.
937 */
938
939 public void testSparseTreeDataElement2List () throws Exception {
940 IDataElement element = SparseTreeDataElement2.createElement ("()");
941 assertFalse (element.isScalar ());
942 assertTrue (element.getType () == IDataElement.Type.MULTIPLE);
943 assertTrue (element.getType (1) == IDataElement.Type.NONE);
944 }
945
946 /**
947 * Test for mixed type list element.
948 */
949
950 public void testSparseTreeDataElement2List2 () throws Exception {
951 IDataElement element = SparseTreeDataElement2.createElement ("(1,1.0,true,,\"\",())");
952 assertFalse (element.isScalar ());
953 assertTrue (element.getType () == IDataElement.Type.MULTIPLE);
954 assertTrue (element.getType (1) == IDataElement.Type.INTEGRAL);
955 assertTrue (element.getType (2) == IDataElement.Type.REAL);
956 assertTrue (element.getType (3) == IDataElement.Type.BOOLEAN);
957 assertTrue (element.getType (4) == IDataElement.Type.NONE);
958 assertTrue (element.getType (5) == IDataElement.Type.LITERAL);
959 assertTrue (element.getType (6) == IDataElement.Type.MULTIPLE);
960 }
961
962 /**
963 * Assorted tests for SparseTreeDataElement2 used in benchmarks.
964 */
965
966 public void testSparseTreeDataElement2Mixed () throws Exception {
967 ElementBenchmark.test (SparseTreeDataElement2.class);
968 }
969
970 /**
971 * Test for positive real element.
972 */
973
974 public void testSparseTreeDataElement2Real () throws Exception {
975 IDataElement element = SparseTreeDataElement2.createElement ("1.0");
976 assertTrue (element.isScalar ());
977 assertTrue (element.getType () == IDataElement.Type.REAL);
978 assertTrue (element.getRealValue () == 1.0);
979 }
980
981 /**
982 * Test for negative infinite element.
983 */
984
985 public void testSparseTreeDataElement2Real2 () throws Exception {
986 IDataElement element = SparseTreeDataElement2.createElement ("-infinity");
987 assertTrue (element.isScalar ());
988 assertTrue (element.getType () == IDataElement.Type.REAL);
989 assertTrue (element.getRealValue () == Double.NEGATIVE_INFINITY);
990 }
991
992 /**
993 * Test for positive infinite element.
994 */
995
996 public void testSparseTreeDataElement2Real3 () throws Exception {
997 IDataElement element = SparseTreeDataElement2.createElement ("infinity");
998 assertTrue (element.isScalar ());
999 assertTrue (element.getType () == IDataElement.Type.REAL);
1000 assertTrue (element.getRealValue () == Double.POSITIVE_INFINITY);
1001 }
1002
1003 /**
1004 * Test for maximum real element.
1005 */
1006
1007 public void testSparseTreeDataElement2Real4 () throws Exception {
1008 IDataElement element = SparseTreeDataElement2.createElement (String.valueOf (Double.MAX_VALUE));
1009 assertTrue (element.isScalar ());
1010 assertTrue (element.getType () == IDataElement.Type.REAL);
1011 assertTrue (element.getRealValue () == Double.MAX_VALUE);
1012 }
1013
1014 /**
1015 * Test for minimum real element.
1016 */
1017
1018 public void testSparseTreeDataElement2Real5 () throws Exception {
1019 IDataElement element = SparseTreeDataElement2.createElement (String.valueOf (Double.MIN_VALUE));
1020 assertTrue (element.isScalar ());
1021 assertTrue (element.getType () == IDataElement.Type.REAL);
1022 assertTrue (element.getRealValue () == Double.MIN_VALUE);
1023 }
1024
1025 /**
1026 * Test for undefined real element.
1027 */
1028
1029 public void testSparseTreeDataElement2Real6 () throws Exception {
1030 IDataElement element = SparseTreeDataElement2.createElement ("NaN");
1031 assertTrue (element.isScalar ());
1032 assertTrue (element.getType () == IDataElement.Type.REAL);
1033 assertTrue (Double.isNaN (element.getRealValue ()));
1034 }
1035
1036 /**
1037 * Test for negative real element.
1038 */
1039
1040 public void testSparseTreeDataElement2Real7 () throws Exception {
1041 IDataElement element = SparseTreeDataElement2.createElement ("-1.0");
1042 assertTrue (element.isScalar ());
1043 assertTrue (element.getType () == IDataElement.Type.REAL);
1044 assertTrue (element.getRealValue () == -1.0);
1045 }
1046
1047 /**
1048 * Test for zero real element.
1049 */
1050
1051 public void testSparseTreeDataElement2Real8 () throws Exception {
1052 IDataElement element = SparseTreeDataElement2.createElement ("0.0");
1053 assertTrue (element.isScalar ());
1054 assertTrue (element.getType () == IDataElement.Type.REAL);
1055 assertTrue (element.getRealValue () == 0.0);
1056 }
1057
1058 /**
1059 * Test for string of an integer element.
1060 */
1061
1062 public void testSparseTreeDataElement2String () throws Exception {
1063 IDataElement element = SparseTreeDataElement2.createElement ("\"1\"");
1064 assertTrue (element.isScalar ());
1065 assertTrue (element.getType () == IDataElement.Type.LITERAL);
1066 assertTrue (element.getLiteralValue ().equals ("1"));
1067 }
1068
1069 /**
1070 * Test for string of a real element.
1071 */
1072
1073 public void testSparseTreeDataElement2String2 () throws Exception {
1074 IDataElement element = SparseTreeDataElement2.createElement ("\"1.0\"");
1075 assertTrue (element.isScalar ());
1076 assertTrue (element.getType () == IDataElement.Type.LITERAL);
1077 assertTrue (element.getLiteralValue ().equals ("1.0"));
1078 }
1079
1080 /**
1081 * Test for string of a boolean element.
1082 */
1083
1084 public void testSparseTreeDataElement2String3 () throws Exception {
1085 IDataElement element = SparseTreeDataElement2.createElement ("\"true\"");
1086 assertTrue (element.isScalar ());
1087 assertTrue (element.getType () == IDataElement.Type.LITERAL);
1088 assertTrue (element.getLiteralValue ().equals ("true"));
1089 }
1090
1091 /**
1092 * Test for string of a list element.
1093 */
1094
1095 public void testSparseTreeDataElement2String4 () throws Exception {
1096 IDataElement element = SparseTreeDataElement2.createElement ("\"()\"");
1097 assertTrue (element.isScalar ());
1098 assertTrue (element.getType () == IDataElement.Type.LITERAL);
1099 assertTrue (element.getLiteralValue ().equals ("()"));
1100 }
1101
1102 /**
1103 * Test for string of a string element.
1104 */
1105
1106 public void testSparseTreeDataElement2String5 () throws Exception {
1107 IDataElement element = SparseTreeDataElement2.createElement ("\"\"");
1108 assertTrue (element.isScalar ());
1109 assertTrue (element.getType () == IDataElement.Type.LITERAL);
1110 assertTrue (element.getLiteralValue ().equals (""));
1111 }
1112 }