| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | |||
| 2 | /*************************************** | ||
| 3 | Auteur : Pierre Aubert | ||
| 4 | Mail : pierre.aubert@lapp.in2p3.fr | ||
| 5 | Licence : CeCILL-C | ||
| 6 | ****************************************/ | ||
| 7 | |||
| 8 | #include <iostream> | ||
| 9 | #include "PAlignedAllocator.h" | ||
| 10 | |||
| 11 | ///Test the PAlignedAllocator | ||
| 12 | /** @return true on success, false otherwise | ||
| 13 | */ | ||
| 14 | 1 | bool testPAlignedAllocator(){ | |
| 15 | 1 | bool b(true); | |
| 16 |
1/1✓ Branch 0 (2→3) taken 1 times.
|
1 | std::vector<int, PAlignedAllocator<int> > vecCustomAllocator(10lu); |
| 17 |
3/3✓ Branch 0 (3→4) taken 1 times.
✓ Branch 2 (5→6) taken 1 times.
✓ Branch 4 (6→7) taken 1 times.
|
1 | std::cout << "testVectorAllocator : vecCustomAllocator ptr = " << vecCustomAllocator.data() << std::endl; |
| 18 | |||
| 19 |
1/1✓ Branch 0 (8→9) taken 1 times.
|
1 | b &= phoenix_checkIsAligned(vecCustomAllocator.data()); |
| 20 |
3/3✓ Branch 0 (9→10) taken 1 times.
✓ Branch 2 (10→11) taken 1 times.
✓ Branch 4 (11→12) taken 1 times.
|
1 | std::cout << "testPAlignedAllocator : b = "<<b<< std::endl; |
| 21 | |||
| 22 | //Check too much allocation | ||
| 23 | try{ | ||
| 24 |
0/1✗ Branch 0 (12→13) not taken.
|
1 | std::vector<int, PAlignedAllocator<int> > vecTooMuchMem(-1lu); |
| 25 |
1/2✗ Branch 0 (28→29) not taken.
✓ Branch 1 (28→30) taken 1 times.
|
1 | }catch(std::length_error&e){ |
| 26 | 1 | b &= true; | |
| 27 | 1 | } | |
| 28 | ///Check bad alloc | ||
| 29 | try{ | ||
| 30 |
1/1✓ Branch 0 (15→16) taken 1 times.
|
1 | std::vector<int, PAlignedAllocator<int> > vecBadAlloc(0lu); |
| 31 |
0/2✗ Branch 0 (34→35) not taken.
✗ Branch 1 (34→36) not taken.
|
1 | }catch(std::bad_alloc&e){ |
| 32 | ✗ | b &= true; | |
| 33 | ✗ | } | |
| 34 |
3/3✓ Branch 0 (18→19) taken 1 times.
✓ Branch 2 (19→20) taken 1 times.
✓ Branch 4 (20→21) taken 1 times.
|
1 | std::cout << "testPAlignedAllocator : b = " << b << std::endl; |
| 35 |
1/1✓ Branch 0 (21→22) taken 1 times.
|
1 | phoenix_freeAlignedVector(NULL); |
| 36 | 1 | return b; | |
| 37 | 1 | } | |
| 38 | |||
| 39 | ///Test the padding | ||
| 40 | /** @return true on success, false otherwise | ||
| 41 | */ | ||
| 42 | 1 | bool testPadding(){ | |
| 43 | 1 | bool b(true); | |
| 44 | 1 | b &= phoenix_getPadding<float>(1lu) != 0lu; | |
| 45 | 1 | b &= phoenix_getPadding<float>(PHOENIX_VECTOR_SIZE_FLOAT) == 0lu; | |
| 46 | 1 | b &= phoenix_getPadding<double>(1lu) != 0lu; | |
| 47 | 1 | b &= phoenix_getPadding<double>(PHOENIX_VECTOR_SIZE_FLOAT) == 0lu; | |
| 48 | |||
| 49 | 1 | b &= phoenix_getPadding<bool>(1lu) != 0lu; | |
| 50 | 1 | b &= phoenix_getPadding<bool>(PHOENIX_VECTOR_SIZE_CHAR) == 0lu; | |
| 51 | 1 | b &= phoenix_getPadding<char>(1lu) != 0lu; | |
| 52 | 1 | b &= phoenix_getPadding<char>(PHOENIX_VECTOR_SIZE_CHAR) == 0lu; | |
| 53 | 1 | b &= phoenix_getPadding<unsigned char>(1lu) != 0lu; | |
| 54 | 1 | b &= phoenix_getPadding<unsigned char>(PHOENIX_VECTOR_SIZE_CHAR) == 0lu; | |
| 55 | |||
| 56 | 1 | b &= phoenix_getPadding<short>(1lu) != 0lu; | |
| 57 | 1 | b &= phoenix_getPadding<short>(PHOENIX_VECTOR_SIZE_SHORT) == 0lu; | |
| 58 | 1 | b &= phoenix_getPadding<unsigned short>(1lu) != 0lu; | |
| 59 | 1 | b &= phoenix_getPadding<unsigned short>(PHOENIX_VECTOR_SIZE_SHORT) == 0lu; | |
| 60 | |||
| 61 | 1 | b &= phoenix_getPadding<int>(1lu) != 0lu; | |
| 62 | 1 | b &= phoenix_getPadding<int>(PHOENIX_VECTOR_SIZE_INT) == 0lu; | |
| 63 | 1 | b &= phoenix_getPadding<unsigned int>(1lu) != 0lu; | |
| 64 | 1 | b &= phoenix_getPadding<unsigned int>(PHOENIX_VECTOR_SIZE_INT) == 0lu; | |
| 65 | |||
| 66 | 1 | b &= phoenix_getPadding<long>(1lu) != 0lu; | |
| 67 | 1 | b &= phoenix_getPadding<long>(PHOENIX_VECTOR_SIZE_LONG_INT) == 0lu; | |
| 68 | 1 | b &= phoenix_getPadding<unsigned long>(1lu) != 0lu; | |
| 69 | 1 | b &= phoenix_getPadding<unsigned long>(PHOENIX_VECTOR_SIZE_LONG_INT) == 0lu; | |
| 70 | |||
| 71 | 1 | std::cout << "testPadding : b = " << b << std::endl; | |
| 72 | 1 | return b; | |
| 73 | } | ||
| 74 | |||
| 75 | ///Test the byte alignement | ||
| 76 | /** @return true on success, false otherwise | ||
| 77 | */ | ||
| 78 | 1 | bool testByteAlignment(){ | |
| 79 | 1 | bool b(true); | |
| 80 | 1 | b &= phoenix_alignement_in_bytes<bool>() == PHOENIX_VECTOR_SIZE_BYTE_INT; | |
| 81 | 1 | b &= phoenix_alignement_in_bytes<char>() == PHOENIX_VECTOR_SIZE_BYTE_INT; | |
| 82 | 1 | b &= phoenix_alignement_in_bytes<unsigned char>() == PHOENIX_VECTOR_SIZE_BYTE_INT; | |
| 83 | 1 | b &= phoenix_alignement_in_bytes<short>() == PHOENIX_VECTOR_SIZE_BYTE_INT; | |
| 84 | 1 | b &= phoenix_alignement_in_bytes<unsigned short>() == PHOENIX_VECTOR_SIZE_BYTE_INT; | |
| 85 | 1 | b &= phoenix_alignement_in_bytes<int>() == PHOENIX_VECTOR_SIZE_BYTE_INT; | |
| 86 | 1 | b &= phoenix_alignement_in_bytes<unsigned int>() == PHOENIX_VECTOR_SIZE_BYTE_INT; | |
| 87 | 1 | b &= phoenix_alignement_in_bytes<long>() == PHOENIX_VECTOR_SIZE_BYTE_INT; | |
| 88 | 1 | b &= phoenix_alignement_in_bytes<unsigned long>() == PHOENIX_VECTOR_SIZE_BYTE_INT; | |
| 89 | |||
| 90 | 1 | b &= phoenix_alignement_in_bytes<float>() == PHOENIX_VECTOR_SIZE_BYTE_FLOAT; | |
| 91 | 1 | b &= phoenix_alignement_in_bytes<double>() == PHOENIX_VECTOR_SIZE_BYTE_FLOAT; | |
| 92 | |||
| 93 | 1 | std::cout << "testByteAlignment : b = " << b << std::endl; | |
| 94 | 1 | return b; | |
| 95 | } | ||
| 96 | |||
| 97 | 1 | int main(int argc, char** argv){ | |
| 98 | 1 | bool b(true); | |
| 99 | 1 | b &= testPAlignedAllocator(); | |
| 100 | 1 | b &= testPadding(); | |
| 101 | 1 | b &= testByteAlignment(); | |
| 102 | 1 | std::cout << "Final : b = " << b << std::endl; | |
| 103 | 1 | return b - 1; | |
| 104 | } | ||
| 105 | |||
| 106 | |||
| 107 |