Nektar++
Classes | Functions
Nektar::SharedArrayUnitTests Namespace Reference

Classes

class  ParameterTestClass
 

Functions

 BOOST_AUTO_TEST_CASE (TestArrayConstructionFromConstantArray)
 
void CheckAddresses (Array< TwoD, double >::reference d, double *expectedAddress)
 
 BOOST_AUTO_TEST_CASE (TestRowPointers)
 
 BOOST_AUTO_TEST_CASE (TestParameterPopulation)
 
 BOOST_AUTO_TEST_CASE (TestEmptyConstructor)
 
 BOOST_AUTO_TEST_CASE (TestUninitializedConstructor)
 
 BOOST_AUTO_TEST_CASE (TestSingleValueInitialization)
 
 BOOST_AUTO_TEST_CASE (TestPopulationFromCArray)
 
 BOOST_AUTO_TEST_CASE (TestCopyConstruction)
 
 BOOST_AUTO_TEST_CASE (Test1DAssignmentOperator)
 
 BOOST_AUTO_TEST_CASE (Test2DAssignmentOperator)
 
 BOOST_AUTO_TEST_CASE (TestOffsetAssignmentOperator)
 
 BOOST_AUTO_TEST_CASE (Test1DAccessOperator)
 
 BOOST_AUTO_TEST_CASE (Test2DAccessOperator)
 
 BOOST_AUTO_TEST_CASE (Test1DEqualOperator)
 
 BOOST_AUTO_TEST_CASE (Test2DEqualOperator)
 

Function Documentation

◆ BOOST_AUTO_TEST_CASE() [1/15]

Nektar::SharedArrayUnitTests::BOOST_AUTO_TEST_CASE ( Test1DAccessOperator  )

Definition at line 596 of file testNekSharedArray.cpp.

597{
598 UnitTests::RedirectCerrIfNeeded();
599 // Normal access.
600 double a[] = {1.0, 2.0, 3.0, 4.0, 5.0};
601 double b[] = {10.0, 20.0, 30.0, 40.0};
602
603 Array<OneD, NekDouble> rhs_a(5, a);
604 Array<OneD, const NekDouble> rhs_b(4, b);
605
606 BOOST_CHECK_EQUAL(rhs_a[0], 1.0);
607 BOOST_CHECK_EQUAL(rhs_a[1], 2.0);
608 BOOST_CHECK_EQUAL(rhs_a[2], 3.0);
609 BOOST_CHECK_EQUAL(rhs_a[3], 4.0);
610 BOOST_CHECK_EQUAL(rhs_a[4], 5.0);
611
612 BOOST_CHECK_EQUAL(rhs_b[0], 10.0);
613 BOOST_CHECK_EQUAL(rhs_b[1], 20.0);
614 BOOST_CHECK_EQUAL(rhs_b[2], 30.0);
615 BOOST_CHECK_EQUAL(rhs_b[3], 40.0);
616#if defined(NEKTAR_DEBUG) || defined(NEKTAR_FULL_DEBUG)
617 BOOST_CHECK_NO_THROW(rhs_a[4]);
618 BOOST_CHECK_THROW(rhs_a[5], ErrorUtil::NekError);
619 BOOST_CHECK_NO_THROW(rhs_b[3]);
620 BOOST_CHECK_THROW(rhs_b[4], ErrorUtil::NekError);
621#endif
622}
NekError
Nektar::ErrorUtil::NekError NekError
Definition: LibUtilities.cpp:55
Nektar::UnitTests::RedirectCerrIfNeeded
void RedirectCerrIfNeeded()
Definition: util.cpp:43

References Nektar::UnitTests::RedirectCerrIfNeeded().

◆ BOOST_AUTO_TEST_CASE() [2/15]

Nektar::SharedArrayUnitTests::BOOST_AUTO_TEST_CASE ( Test1DAssignmentOperator  )

Definition at line 429 of file testNekSharedArray.cpp.

430{
431 {
432 // 1D
433 CountedObject<double> a_array[] = {
434 CountedObject<double>(1), CountedObject<double>(2),
435 CountedObject<double>(3), CountedObject<double>(4)};
436 CountedObject<double> b_array[] = {
437 CountedObject<double>(1), CountedObject<double>(2),
438 CountedObject<double>(3), CountedObject<double>(4),
439 CountedObject<double>(5)};
440 CountedObject<double>::ClearCounters();
441 Array<OneD, const CountedObject<double>> a(4, a_array);
442 Array<OneD, CountedObject<double>> b(5, b_array);
443 CountedObject<double>::Check(0, 0, 0, 9, 0, 0);
444
445 {
446 Array<OneD, const CountedObject<double>> lhs_a;
447 Array<OneD, CountedObject<double>> lhs_b1;
448 Array<OneD, const CountedObject<double>> lhs_b2;
449 CountedObject<double>::Check(0, 0, 0, 9, 0, 0);
450
451 BOOST_CHECK_EQUAL(lhs_a.size(), 0);
452 BOOST_CHECK_EQUAL(lhs_b1.size(), 0);
453 BOOST_CHECK_EQUAL(lhs_b2.size(), 0);
454
455 {
456 lhs_a = a;
457 lhs_b1 = b;
458 lhs_b2 = b;
459 CountedObject<double>::Check(0, 0, 0, 9, 0, 0);
460
461 BOOST_CHECK_EQUAL(lhs_a.size(), a.size());
462 BOOST_CHECK_EQUAL(lhs_b1.size(), b.size());
463 BOOST_CHECK_EQUAL(lhs_b2.size(), b.size());
464 BOOST_CHECK_EQUAL(lhs_a.data(), a.data());
465 BOOST_CHECK_EQUAL(lhs_b1.data(), b.data());
466 BOOST_CHECK_EQUAL(lhs_b2.data(), b.data());
467
468 using size_type = Array<OneD, double>::size_type;
469 for (size_type i = 0; i < a.size(); ++i)
470 {
471 BOOST_CHECK(lhs_a[i] == a[i]);
472 }
473
474 for (size_type i = 0; i < b.size(); ++i)
475 {
476 BOOST_CHECK(lhs_b1[i] == b[i]);
477 BOOST_CHECK(lhs_b2[i] == b[i]);
478 }
479 CountedObject<double>::Check(0, 0, 0, 9, 0, 0);
480 }
481 CountedObject<double>::Check(0, 0, 0, 9, 0, 0);
482 }
483 CountedObject<double>::Check(0, 0, 0, 9, 0, 0);
484 }
485}

References Nektar::CountedObject< DerivedType >::Check(), and Nektar::CountedObject< DerivedType >::ClearCounters().

◆ BOOST_AUTO_TEST_CASE() [3/15]

Nektar::SharedArrayUnitTests::BOOST_AUTO_TEST_CASE ( Test1DEqualOperator  )

Definition at line 684 of file testNekSharedArray.cpp.

685{
686 {
687 // integer types
688 using int_type = int;
689
690 int_type a[] = {1, 2, 3, 4, 5};
691
692 Array<OneD, int_type> nek_a(5, a);
693 Array<OneD, int_type> nek_b(5, a);
694 Array<OneD, const int_type> nek_c(5, a);
695
696 // still equal
697 BOOST_CHECK(nek_a == nek_b);
698 // equal and only one const
699 BOOST_CHECK(nek_a == nek_c);
700
701 // not equal
702 nek_b[3] += 1;
703 BOOST_CHECK(!(nek_a == nek_b));
704 }
705
706 {
707 // float types
708 using float_type = double;
709
710 float_type a[] = {1.0, 2.0, 3.0, 4.0, 5.0};
711
712 Array<OneD, float_type> nek_a(5, a);
713 Array<OneD, float_type> nek_b(5, a);
714 Array<OneD, const float_type> nek_c(5, a);
715
716 // still equal
717 nek_b[3] *= (1.0 + std::numeric_limits<float_type>::epsilon());
718 BOOST_CHECK(nek_a == nek_b);
719 // equal and only one const
720 BOOST_CHECK(nek_a == nek_c);
721
722 // not equal
723 nek_b[4] *= (1.0 + 100 * std::numeric_limits<float_type>::epsilon());
724 BOOST_CHECK(!(nek_a == nek_b));
725 }
726
727 // This should not compile
728 // {
729 // // mixed types should not compare
730 // using float_type = double;
731 // using int_type = int;
732
733 // float_type a[] = {1.0, 2.0, 3.0, 4.0, 5.0};
734 // int_type b[] = {1, 2, 3, 4, 5};
735
736 // Array<OneD, float_type> nek_a(5, a);
737 // Array<OneD, int_type> nek_b(5, b);
738
739 // // still equal
740 // BOOST_CHECK(nek_a == nek_b);
741 // }
742}

◆ BOOST_AUTO_TEST_CASE() [4/15]

Nektar::SharedArrayUnitTests::BOOST_AUTO_TEST_CASE ( Test2DAccessOperator  )

Definition at line 624 of file testNekSharedArray.cpp.

625{
626 {
627 NekDouble a_vals[] = {1.0, 2.0, 3.0, 4.0, 5.0,
628 6.0, 7.0, 8.0, 9.0, 10.0};
629 Array<TwoD, NekDouble> a(5, 2, a_vals);
630
631 BOOST_CHECK_EQUAL(a.GetRows(), 5);
632 BOOST_CHECK_EQUAL(a.GetColumns(), 2);
633
634 using size_type = Array<TwoD, double>::size_type;
635 for (size_type i = 0; i < a.GetRows(); ++i)
636 {
637 for (size_type j = 0; j < a.GetColumns(); ++j)
638 {
639 BOOST_CHECK_EQUAL(a[i][j], a_vals[i * a.GetColumns() + j]);
640 }
641 }
642
643 // Now test assignment.
644 NekDouble rhs_vals[] = {18.0, -76.2, 45.2, 1352.246, -46.346,
645 -2463.346, 26.347, 1.0, 0.0, 23465.3};
646 for (size_type i = 0; i < a.GetRows(); ++i)
647 {
648 for (size_type j = 0; j < a.GetColumns(); ++j)
649 {
650 a[i][j] = rhs_vals[i * a.GetColumns() + j];
651 }
652 }
653
654 for (size_type i = 0; i < a.GetRows(); ++i)
655 {
656 for (size_type j = 0; j < a.GetColumns(); ++j)
657 {
658 BOOST_CHECK_EQUAL(a[i][j], rhs_vals[i * a.GetColumns() + j]);
659 }
660 }
661 }
662
663 {
664 // Test 1 Column.
665 NekDouble a_vals[] = {1.0, 3.0, 5.0, 7.0, 9.0};
666 Array<TwoD, NekDouble> a(5, 1, a_vals);
667 BOOST_CHECK_EQUAL(a.GetRows(), 5);
668 BOOST_CHECK_EQUAL(a.GetColumns(), 1);
669
670 using size_type = Array<TwoD, double>::size_type;
671 for (size_type i = 0; i < a.GetRows(); ++i)
672 {
673 BOOST_CHECK_EQUAL(a[i][0], a_vals[i]);
674 }
675 }
676
677 {
678 Array<TwoD, NekDouble> a(1, 1);
679 a[0][0] = 17.23;
680 BOOST_CHECK_EQUAL(a[0][0], 17.23);
681 }
682}
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43

◆ BOOST_AUTO_TEST_CASE() [5/15]

Nektar::SharedArrayUnitTests::BOOST_AUTO_TEST_CASE ( Test2DAssignmentOperator  )

Definition at line 487 of file testNekSharedArray.cpp.

488{
489 {
490 // 2D
491 CountedObject<double> initValue(98);
492 CountedObject<double>::ClearCounters();
493
494 Array<TwoD, const CountedObject<double>> a(5, 10, initValue);
495 Array<TwoD, CountedObject<double>> b(10, 10, initValue);
496 CountedObject<double>::Check(0, 0, 0, 150, 0, 0);
497
498 BOOST_CHECK(a.begin() != a.end());
499 BOOST_CHECK(b.begin() != b.end());
500
501 BOOST_CHECK_EQUAL(a.size(), 50);
502 BOOST_CHECK_EQUAL(b.size(), 100);
503 BOOST_CHECK_EQUAL(a.shape()[0], 5);
504 BOOST_CHECK_EQUAL(a.shape()[1], 10);
505 BOOST_CHECK_EQUAL(b.shape()[0], 10);
506 BOOST_CHECK_EQUAL(b.shape()[1], 10);
507
508 BOOST_CHECK_EQUAL(a.num_dimensions(), 2);
509 BOOST_CHECK_EQUAL(b.num_dimensions(), 2);
510
511 {
512 Array<TwoD, const CountedObject<double>> lhs_a;
513 Array<TwoD, const CountedObject<double>> lhs_b1;
514 Array<TwoD, CountedObject<double>> lhs_b2;
515
516 BOOST_CHECK_EQUAL(lhs_a.size(), 0);
517 BOOST_CHECK_EQUAL(lhs_b1.size(), 0);
518 BOOST_CHECK_EQUAL(lhs_b2.size(), 0);
519
520 lhs_a = a;
521 lhs_b1 = b;
522 lhs_b2 = b;
523 CountedObject<double>::Check(0, 0, 0, 150, 0, 0);
524
525 BOOST_CHECK_EQUAL(lhs_a.size(), a.size());
526 BOOST_CHECK_EQUAL(lhs_b1.size(), b.size());
527 BOOST_CHECK_EQUAL(lhs_b2.size(), b.size());
528 BOOST_CHECK_EQUAL(lhs_a.shape()[0], a.shape()[0]);
529 BOOST_CHECK_EQUAL(lhs_a.shape()[1], a.shape()[1]);
530
531 BOOST_CHECK_EQUAL(lhs_b1.shape()[0], b.shape()[0]);
532 BOOST_CHECK_EQUAL(lhs_b1.shape()[1], b.shape()[1]);
533
534 BOOST_CHECK_EQUAL(lhs_b2.shape()[0], b.shape()[0]);
535 BOOST_CHECK_EQUAL(lhs_b2.shape()[1], b.shape()[1]);
536
537 using size_type = Array<TwoD, double>::size_type;
538 for (size_type i = 0; i < a.shape()[0]; ++i)
539 {
540 for (size_type j = 0; j < a.shape()[1]; ++j)
541 {
542 BOOST_CHECK(a[i][j] == initValue);
543 BOOST_CHECK(lhs_a[i][j] == a[i][j]);
544 }
545 }
546
547 for (size_type i = 0; i < b.shape()[0]; ++i)
548 {
549 for (size_type j = 0; j < b.shape()[1]; ++j)
550 {
551 BOOST_CHECK(b[i][j] == initValue);
552 BOOST_CHECK(lhs_b1[i][j] == b[i][j]);
553 BOOST_CHECK(lhs_b2[i][j] == b[i][j]);
554 }
555 }
556 }
557 CountedObject<double>::Check(0, 0, 0, 150, 0, 0);
558 }
559
560 CountedObject<double>::Check(0, 0, 151, 150, 0, 0);
561}

References Nektar::CountedObject< DerivedType >::Check(), and Nektar::CountedObject< DerivedType >::ClearCounters().

◆ BOOST_AUTO_TEST_CASE() [6/15]

Nektar::SharedArrayUnitTests::BOOST_AUTO_TEST_CASE ( Test2DEqualOperator  )

Definition at line 744 of file testNekSharedArray.cpp.

745{
746 {
747 // integer types
748 using int_type = int;
749
750 int_type a[] = {1, 2, 3, 4, 5};
751 Array<TwoD, int_type> nek_a(5, 1, a);
752 Array<TwoD, int_type> nek_b(5, 1, a);
753 Array<TwoD, const int_type> nek_c(5, 1, a);
754
755 // still equal
756 BOOST_CHECK(nek_a == nek_b);
757 // equal and only one const
758 BOOST_CHECK(nek_a == nek_c);
759
760 // not equal
761 nek_b[3][0] += 1;
762 BOOST_CHECK(!(nek_a == nek_b));
763 }
764
765 {
766 // floating types
767 using float_type = double;
768
769 float_type a[] = {1., 2., 3., 4., 5.};
770 Array<TwoD, float_type> nek_a(5, 1, a);
771 Array<TwoD, float_type> nek_b(5, 1, a);
772 Array<TwoD, const float_type> nek_c(5, 1, a);
773
774 // still equal
775 nek_b[3][0] *= (1.0 + std::numeric_limits<float_type>::epsilon());
776 BOOST_CHECK(nek_a == nek_b);
777 // equal and only one const
778 BOOST_CHECK(nek_a == nek_c);
779
780 // not equal
781 nek_b[4][0] *= (1.0 + 100 * std::numeric_limits<float_type>::epsilon());
782 BOOST_CHECK(!(nek_a == nek_b));
783 }
784}

◆ BOOST_AUTO_TEST_CASE() [7/15]

Nektar::SharedArrayUnitTests::BOOST_AUTO_TEST_CASE ( TestArrayConstructionFromConstantArray  )

Definition at line 45 of file TestSharedArray.cpp.

46{
47 Array<OneD, const double> const_array_1(10, 7.0);
48 Array<OneD, const double> const_array_2(10, 3.0);
49
50 Array<OneD, double> array_1(const_array_1);
51 Array<OneD, double> array_2(5, const_array_2);
52
53 BOOST_CHECK_EQUAL(array_1.size(), const_array_1.size());
54 BOOST_CHECK_EQUAL(array_2.size(), 5);
55
56 array_1[2] = -1.0;
57 array_2[2] = -1.0;
58
59 BOOST_CHECK_EQUAL(array_1[2], -1.0);
60 BOOST_CHECK_EQUAL(array_2[2], -1.0);
61
62 BOOST_CHECK_EQUAL(const_array_1[2], 7.0);
63 BOOST_CHECK_EQUAL(const_array_2[2], 3.0);
64}

◆ BOOST_AUTO_TEST_CASE() [8/15]

Nektar::SharedArrayUnitTests::BOOST_AUTO_TEST_CASE ( TestCopyConstruction  )

Definition at line 360 of file testNekSharedArray.cpp.

361{
362 {
363 CountedObject<double> a_array[] = {
364 CountedObject<double>(1), CountedObject<double>(2),
365 CountedObject<double>(3), CountedObject<double>(4)};
366 CountedObject<double> b_array[] = {
367 CountedObject<double>(1), CountedObject<double>(2),
368 CountedObject<double>(3), CountedObject<double>(4),
369 CountedObject<double>(5)};
370 CountedObject<double>::ClearCounters();
371
372 Array<OneD, const CountedObject<double>> a(4, a_array);
373 Array<OneD, CountedObject<double>> b(5, b_array);
374 CountedObject<double>::Check(0, 0, 0, 9, 0, 0);
375
376 {
377 Array<OneD, const CountedObject<double>> c(a);
378 Array<OneD, CountedObject<double>> d(b);
379 Array<OneD, const CountedObject<double>> e(a);
380
381 BOOST_CHECK_EQUAL(c.size(), a.size());
382 BOOST_CHECK_EQUAL(e.size(), a.size());
383 BOOST_CHECK_EQUAL(d.size(), b.size());
384 BOOST_CHECK(c.data() == a.data());
385 BOOST_CHECK(e.data() == a.data());
386 BOOST_CHECK(d.data() == b.data());
387
388 CountedObject<double>::Check(0, 0, 0, 9, 0, 0);
389 }
390 CountedObject<double>::Check(0, 0, 0, 9, 0, 0);
391 }
392 CountedObject<double>::Check(0, 0, 18, 9, 0, 0);
393
394 {
395 // Test offset copy constructor.
396 CountedObject<double> a_array[] = {
397 CountedObject<double>(1), CountedObject<double>(2),
398 CountedObject<double>(3), CountedObject<double>(4)};
399 CountedObject<double> b_array[] = {
400 CountedObject<double>(1), CountedObject<double>(2),
401 CountedObject<double>(3), CountedObject<double>(4),
402 CountedObject<double>(5)};
403 CountedObject<double>::ClearCounters();
404 Array<OneD, const CountedObject<double>> a(4, a_array);
405 Array<OneD, CountedObject<double>> b(5, b_array);
406 CountedObject<double>::Check(0, 0, 0, 9, 0, 0);
407
408 Array<OneD, const CountedObject<double>> a_off = a + 1;
409 Array<OneD, const CountedObject<double>> bb_off = b + 2;
410 Array<OneD, CountedObject<double>> b_off = b + 2;
411
412 BOOST_CHECK_EQUAL(a_off[0].value, a[1].value);
413 BOOST_CHECK_EQUAL(a_off[1].value, a[2].value);
414 BOOST_CHECK_EQUAL(a_off[2].value, a[3].value);
415 BOOST_CHECK_EQUAL(a_off.size(), 3);
416
417 BOOST_CHECK_EQUAL(b_off[0].value, b[2].value);
418 BOOST_CHECK_EQUAL(b_off[1].value, b[3].value);
419 BOOST_CHECK_EQUAL(b_off[2].value, b[4].value);
420 BOOST_CHECK_EQUAL(b_off.size(), 3);
421
422 BOOST_CHECK_EQUAL(bb_off[0].value, b[2].value);
423 BOOST_CHECK_EQUAL(bb_off[1].value, b[3].value);
424 BOOST_CHECK_EQUAL(bb_off[2].value, b[4].value);
425 BOOST_CHECK_EQUAL(bb_off.size(), 3);
426 }
427}
Nektar::UnitTests::d
std::vector< double > d(NPUPPER *NPUPPER)

References Nektar::CountedObject< DerivedType >::Check(), Nektar::CountedObject< DerivedType >::ClearCounters(), and Nektar::UnitTests::d().

◆ BOOST_AUTO_TEST_CASE() [9/15]

Nektar::SharedArrayUnitTests::BOOST_AUTO_TEST_CASE ( TestEmptyConstructor  )

Definition at line 143 of file testNekSharedArray.cpp.

144{
145 {
146 CountedObject<double>::ClearCounters();
147 Array<OneD, const CountedObject<double>> a;
148 Array<OneD, CountedObject<double>> b;
149 CountedObject<double>::Check(0, 0, 0, 0, 0, 0);
150
151 BOOST_CHECK(a.begin() == a.end());
152 BOOST_CHECK(b.begin() == b.end());
153
154 BOOST_CHECK_EQUAL(a.size(), 0);
155 BOOST_CHECK_EQUAL(b.size(), 0);
156
157 BOOST_CHECK_EQUAL(a.num_dimensions(), 1);
158 BOOST_CHECK_EQUAL(b.num_dimensions(), 1);
159 }
160 CountedObject<double>::Check(0, 0, 0, 0, 0, 0);
161
162 {
163 CountedObject<double>::ClearCounters();
164 Array<TwoD, const CountedObject<double>> a;
165 Array<TwoD, CountedObject<double>> b;
166 CountedObject<double>::Check(0, 0, 0, 0, 0, 0);
167
168 BOOST_CHECK(a.begin() == a.end());
169 BOOST_CHECK(b.begin() == b.end());
170
171 BOOST_CHECK_EQUAL(a.size(), 0);
172 BOOST_CHECK_EQUAL(b.size(), 0);
173
174 BOOST_CHECK_EQUAL(a.num_dimensions(), 2);
175 BOOST_CHECK_EQUAL(b.num_dimensions(), 2);
176 }
177 CountedObject<double>::Check(0, 0, 0, 0, 0, 0);
178}

References Nektar::CountedObject< DerivedType >::Check(), and Nektar::CountedObject< DerivedType >::ClearCounters().

◆ BOOST_AUTO_TEST_CASE() [10/15]

Nektar::SharedArrayUnitTests::BOOST_AUTO_TEST_CASE ( TestOffsetAssignmentOperator  )

Definition at line 563 of file testNekSharedArray.cpp.

564{
565 double a[] = {1.0, 2.0, 3.0, 4.0, 5.0};
566 double b[] = {10.0, 20.0, 30.0, 40.0};
567
568 Array<OneD, NekDouble> rhs_a(5, a);
569 Array<OneD, const NekDouble> rhs_b(4, b);
570
571 Array<OneD, NekDouble> offset_a = rhs_a + 2;
572 ;
573 Array<OneD, const NekDouble> offset_b = rhs_a + 2;
574
575 Array<OneD, NekDouble> lhs_a;
576 Array<OneD, const NekDouble> lhs_b;
577
578 lhs_a = offset_a;
579 lhs_b = offset_b;
580
581 BOOST_CHECK_EQUAL(lhs_a.size(), offset_a.size());
582 BOOST_CHECK_EQUAL(lhs_b.size(), offset_b.size());
583
584 using size_type = Array<TwoD, double>::size_type;
585 for (size_type i = 0; i < lhs_a.size(); ++i)
586 {
587 BOOST_CHECK(lhs_a[i] == offset_a[i]);
588 }
589
590 for (size_type i = 0; i < lhs_b.size(); ++i)
591 {
592 BOOST_CHECK(lhs_b[i] == offset_b[i]);
593 }
594}

◆ BOOST_AUTO_TEST_CASE() [11/15]

Nektar::SharedArrayUnitTests::BOOST_AUTO_TEST_CASE ( TestParameterPopulation  )

Definition at line 110 of file testNekSharedArray.cpp.

111{
112 ParameterTestClass obj;
113
114 Array<OneD, NekDouble> zero(5, 0.0);
115 Array<OneD, NekDouble> temp(zero);
116 Array<OneD, const NekDouble> const_zero(5, 0.0);
117 Array<OneD, const NekDouble> const_temp(const_zero);
118
119 obj.getNonConstByReference(temp);
120 BOOST_CHECK(temp == obj.a);
121
122 temp = zero;
123 obj.getNonConstByValue(temp);
124 BOOST_CHECK(temp == zero);
125 BOOST_CHECK(temp != obj.a);
126
127 // should not compile.
128 // obj.getNonConstByReference(const_temp);
129 // obj.getNonConstByValue(const_temp);
130
131 // Now the ConstArray versions.
132 obj.getConstByReference(const_temp);
133 BOOST_CHECK(const_temp == obj.a);
134 BOOST_CHECK(const_temp != const_zero);
135 const_temp = const_zero;
136 BOOST_CHECK(const_temp == const_zero);
137
138 obj.getConstByValue(const_temp);
139 BOOST_CHECK(const_temp == const_zero);
140 BOOST_CHECK(const_temp != obj.a);
141}
Nektar::SharedArrayUnitTests::ParameterTestClass::getConstByReference
void getConstByReference(Array< OneD, const NekDouble > &out)
Definition: testNekSharedArray.cpp:94
Nektar::SharedArrayUnitTests::ParameterTestClass::getNonConstByValue
void getNonConstByValue(Array< OneD, NekDouble > out)
Definition: testNekSharedArray.cpp:73
Nektar::SharedArrayUnitTests::ParameterTestClass::getConstByValue
void getConstByValue(Array< OneD, const NekDouble > out)
Definition: testNekSharedArray.cpp:101
Nektar::SharedArrayUnitTests::ParameterTestClass::getNonConstByReference
void getNonConstByReference(Array< OneD, NekDouble > &out)
Definition: testNekSharedArray.cpp:66

References Nektar::SharedArrayUnitTests::ParameterTestClass::a, Nektar::SharedArrayUnitTests::ParameterTestClass::getConstByReference(), Nektar::SharedArrayUnitTests::ParameterTestClass::getConstByValue(), Nektar::SharedArrayUnitTests::ParameterTestClass::getNonConstByReference(), and Nektar::SharedArrayUnitTests::ParameterTestClass::getNonConstByValue().

◆ BOOST_AUTO_TEST_CASE() [12/15]

Nektar::SharedArrayUnitTests::BOOST_AUTO_TEST_CASE ( TestPopulationFromCArray  )

Definition at line 300 of file testNekSharedArray.cpp.

301{
302 {
303 CountedObject<double> a_array[] = {
304 CountedObject<double>(1), CountedObject<double>(2),
305 CountedObject<double>(3), CountedObject<double>(4)};
306 CountedObject<double> b_array[] = {
307 CountedObject<double>(1), CountedObject<double>(2),
308 CountedObject<double>(3), CountedObject<double>(4),
309 CountedObject<double>(5)};
310 CountedObject<double>::ClearCounters();
311
312 Array<OneD, const CountedObject<double>> a(4, a_array);
313 Array<OneD, CountedObject<double>> b(5, b_array);
314 CountedObject<double>::Check(0, 0, 0, 9, 0, 0);
315
316 BOOST_CHECK(a.begin() != a.end());
317 BOOST_CHECK(b.begin() != b.end());
318
319 BOOST_CHECK_EQUAL(a.size(), 4);
320 BOOST_CHECK_EQUAL(b.size(), 5);
321
322 BOOST_CHECK_EQUAL(a.num_dimensions(), 1);
323 BOOST_CHECK_EQUAL(b.num_dimensions(), 1);
324
325 using size_type = Array<OneD, double>::size_type;
326 for (size_type i = 0; i < a.size(); ++i)
327 {
328 BOOST_CHECK(a[i] == a_array[i]);
329 }
330
331 for (size_type i = 0; i < b.size(); ++i)
332 {
333 BOOST_CHECK(b[i] == b_array[i]);
334 }
335 }
336 CountedObject<double>::Check(0, 0, 18, 9, 0, 0);
337
338 {
339 double a_array[] = {1.0, 2.0, 3.0, 4.0};
340 double b_array[] = {5.0, 6.0, 7.0, 8.0, 9.0};
341 Array<OneD, double> a(4, a_array);
342 Array<OneD, double> b(5, b_array);
343
344 BOOST_CHECK(a.size() == 4);
345 BOOST_CHECK(b.size() == 5);
346
347 using size_type = Array<OneD, double>::size_type;
348 for (size_type i = 0; i < a.size(); ++i)
349 {
350 BOOST_CHECK(a[i] == a_array[i]);
351 }
352
353 for (size_type i = 0; i < b.size(); ++i)
354 {
355 BOOST_CHECK(b[i] == b_array[i]);
356 }
357 }
358}

References Nektar::CountedObject< DerivedType >::Check(), and Nektar::CountedObject< DerivedType >::ClearCounters().

◆ BOOST_AUTO_TEST_CASE() [13/15]

Nektar::SharedArrayUnitTests::BOOST_AUTO_TEST_CASE ( TestRowPointers  )

Definition at line 72 of file TestSharedArray.cpp.

73{
74 Array<TwoD, double> array_1(10, 7, 0.0);
75 CheckAddresses(array_1[0], array_1.data());
76 CheckAddresses(array_1[1], array_1.data() + 7);
77}
Nektar::SharedArrayUnitTests::CheckAddresses
void CheckAddresses(Array< TwoD, double >::reference d, double *expectedAddress)
Definition: TestSharedArray.cpp:66

References CheckAddresses().

◆ BOOST_AUTO_TEST_CASE() [14/15]

Nektar::SharedArrayUnitTests::BOOST_AUTO_TEST_CASE ( TestSingleValueInitialization  )

Definition at line 224 of file testNekSharedArray.cpp.

225{
226 {
227 CountedObject<double> initValue(98);
228 CountedObject<double>::ClearCounters();
229
230 Array<OneD, const CountedObject<double>> a(5, initValue);
231 Array<OneD, CountedObject<double>> b(10, initValue);
232 CountedObject<double>::Check(0, 0, 0, 15, 0, 0);
233
234 BOOST_CHECK(a.begin() != a.end());
235 BOOST_CHECK(b.begin() != b.end());
236
237 BOOST_CHECK_EQUAL(a.size(), 5);
238 BOOST_CHECK_EQUAL(b.size(), 10);
239
240 BOOST_CHECK_EQUAL(a.num_dimensions(), 1);
241 BOOST_CHECK_EQUAL(b.num_dimensions(), 1);
242
243 for (Array<OneD, const CountedObject<double>>::const_iterator iter =
244 a.begin();
245 iter != a.end(); ++iter)
246 {
247 BOOST_CHECK(*iter == initValue);
248 }
249
250 for (Array<OneD, CountedObject<double>>::iterator iter = b.begin();
251 iter != b.end(); ++iter)
252 {
253 BOOST_CHECK(*iter == initValue);
254 }
255 }
256 CountedObject<double>::Check(0, 0, 16, 15, 0, 0);
257
258 {
259 CountedObject<double> initValue(98);
260 CountedObject<double>::ClearCounters();
261
262 Array<TwoD, const CountedObject<double>> a(5, 10, initValue);
263 Array<TwoD, CountedObject<double>> b(10, 10, initValue);
264 CountedObject<double>::Check(0, 0, 0, 150, 0, 0);
265
266 BOOST_CHECK(a.begin() != a.end());
267 BOOST_CHECK(b.begin() != b.end());
268
269 BOOST_CHECK_EQUAL(a.size(), 50);
270 BOOST_CHECK_EQUAL(b.size(), 100);
271
272 BOOST_CHECK_EQUAL(a.shape()[0], 5);
273 BOOST_CHECK_EQUAL(a.shape()[1], 10);
274 BOOST_CHECK_EQUAL(b.shape()[0], 10);
275 BOOST_CHECK_EQUAL(b.shape()[1], 10);
276
277 BOOST_CHECK_EQUAL(a.num_dimensions(), 2);
278 BOOST_CHECK_EQUAL(b.num_dimensions(), 2);
279
280 using size_type = Array<TwoD, double>::size_type;
281 for (size_type i = 0; i < a.shape()[0]; ++i)
282 {
283 for (size_type j = 0; j < a.shape()[1]; ++j)
284 {
285 BOOST_CHECK(a[i][j] == initValue);
286 }
287 }
288
289 for (size_type i = 0; i < b.shape()[0]; ++i)
290 {
291 for (size_type j = 0; j < b.shape()[1]; ++j)
292 {
293 BOOST_CHECK(b[i][j] == initValue);
294 }
295 }
296 }
297 CountedObject<double>::Check(0, 0, 151, 150, 0, 0);
298}

References Nektar::CountedObject< DerivedType >::Check(), and Nektar::CountedObject< DerivedType >::ClearCounters().

◆ BOOST_AUTO_TEST_CASE() [15/15]

Nektar::SharedArrayUnitTests::BOOST_AUTO_TEST_CASE ( TestUninitializedConstructor  )

Definition at line 180 of file testNekSharedArray.cpp.

181{
182 {
183 CountedObject<double>::ClearCounters();
184
185 Array<OneD, const CountedObject<double>> a(5);
186 Array<OneD, CountedObject<double>> b(10);
187 CountedObject<double>::Check(15, 0, 0, 0, 0, 0);
188
189 BOOST_CHECK(a.begin() != a.end());
190 BOOST_CHECK(b.begin() != b.end());
191
192 BOOST_CHECK_EQUAL(a.size(), 5);
193 BOOST_CHECK_EQUAL(b.size(), 10);
194
195 BOOST_CHECK_EQUAL(a.num_dimensions(), 1);
196 BOOST_CHECK_EQUAL(b.num_dimensions(), 1);
197 }
198 CountedObject<double>::Check(15, 0, 15, 0, 0, 0);
199
200 {
201 CountedObject<double>::ClearCounters();
202
203 Array<TwoD, const CountedObject<double>> a(5, 10);
204 Array<TwoD, CountedObject<double>> b(10, 10);
205 CountedObject<double>::Check(150, 0, 0, 0, 0, 0);
206
207 BOOST_CHECK(a.begin() != a.end());
208 BOOST_CHECK(b.begin() != b.end());
209
210 BOOST_CHECK_EQUAL(a.size(), 50);
211 BOOST_CHECK_EQUAL(b.size(), 100);
212
213 BOOST_CHECK_EQUAL(a.shape()[0], 5);
214 BOOST_CHECK_EQUAL(a.shape()[1], 10);
215 BOOST_CHECK_EQUAL(b.shape()[0], 10);
216 BOOST_CHECK_EQUAL(b.shape()[1], 10);
217
218 BOOST_CHECK_EQUAL(a.num_dimensions(), 2);
219 BOOST_CHECK_EQUAL(b.num_dimensions(), 2);
220 }
221 CountedObject<double>::Check(150, 0, 150, 0, 0, 0);
222}

References Nektar::CountedObject< DerivedType >::Check(), and Nektar::CountedObject< DerivedType >::ClearCounters().

◆ CheckAddresses()

void Nektar::SharedArrayUnitTests::CheckAddresses ( Array< TwoD, double >::reference  d,
double *  expectedAddress 
)

Definition at line 66 of file TestSharedArray.cpp.

67{
68 BOOST_CHECK_EQUAL(d.size(), 7);
69 BOOST_CHECK_EQUAL(d.origin(), expectedAddress);
70}

References Nektar::UnitTests::d().

Referenced by BOOST_AUTO_TEST_CASE().

Generated on Wed Jan 31 2024 08:26:58 for Nektar++ by doxygen 1.9.4