ArmNN
 21.02
Macros | Functions
UtilityTests.cpp File Reference
#include <boost/test/unit_test.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
#include <armnn/utility/PolymorphicDowncast.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <armnn/Exceptions.hpp>
#include <limits>

Go to the source code of this file.

Macros

#define ARMNN_POLYMORPHIC_CAST_TESTABLE
 
#define ARMNN_NUMERIC_CAST_TESTABLE
 

Functions

 BOOST_AUTO_TEST_CASE (PolymorphicDowncast)
 
 BOOST_AUTO_TEST_CASE (PolymorphicPointerDowncast_SharedPointer)
 
 BOOST_AUTO_TEST_CASE (PolymorphicPointerDowncast_BuildInPointer)
 
 BOOST_AUTO_TEST_CASE (NumericCast)
 

Macro Definition Documentation

◆ ARMNN_NUMERIC_CAST_TESTABLE

#define ARMNN_NUMERIC_CAST_TESTABLE

Definition at line 9 of file UtilityTests.cpp.

◆ ARMNN_POLYMORPHIC_CAST_TESTABLE

#define ARMNN_POLYMORPHIC_CAST_TESTABLE

Definition at line 8 of file UtilityTests.cpp.

Function Documentation

◆ BOOST_AUTO_TEST_CASE() [1/4]

BOOST_AUTO_TEST_CASE ( PolymorphicDowncast  )

Definition at line 22 of file UtilityTests.cpp.

References armnn::IgnoreUnused().

23 {
24  using namespace armnn;
25  class Base
26  {
27  public:
28  virtual ~Base(){}
29  float v;
30  };
31 
32  class Child1 : public Base
33  {
34  public:
35  int j;
36  };
37 
38  class Child2 : public Base
39  {
40  public:
41  char b;
42  };
43 
44  Child1 child1;
45  Base* base1 = &child1;
46  auto ptr1 = dynamic_cast<Child1*>(base1);
47  BOOST_CHECK(ptr1 != nullptr);
48  BOOST_CHECK_NO_THROW(armnn::PolymorphicDowncast<Child1*>(base1));
49  BOOST_CHECK(armnn::PolymorphicDowncast<Child1*>(base1) == ptr1);
50 
51  auto ptr2 = dynamic_cast<Child2*>(base1);
52  BOOST_CHECK(ptr2 == nullptr);
53  BOOST_CHECK_THROW(armnn::PolymorphicDowncast<Child2*>(base1), std::bad_cast);
54 
55  armnn::IgnoreUnused(ptr1, ptr2);
56 }
armnn
Copyright (c) 2021 ARM Limited and Contributors.
Definition: 01_00_software_tools.dox:6
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14

◆ BOOST_AUTO_TEST_CASE() [2/4]

BOOST_AUTO_TEST_CASE ( PolymorphicPointerDowncast_SharedPointer  )

Definition at line 59 of file UtilityTests.cpp.

References armnn::IgnoreUnused().

60 {
61  using namespace armnn;
62  class Base
63  {
64  public:
65  virtual ~Base(){}
66  float v;
67  };
68 
69  class Child1 : public Base
70  {
71  public:
72  int j;
73  };
74 
75  class Child2 : public Base
76  {
77  public:
78  char b;
79  };
80 
81  std::shared_ptr<Base> base1 = std::make_shared<Child1>();
82 
83  std::shared_ptr<Child1> ptr1 = std::static_pointer_cast<Child1>(base1);
84  BOOST_CHECK(ptr1);
85  BOOST_CHECK_NO_THROW(armnn::PolymorphicPointerDowncast<Child1>(base1));
86  BOOST_CHECK(armnn::PolymorphicPointerDowncast<Child1>(base1) == ptr1);
87 
88  auto ptr2 = std::dynamic_pointer_cast<Child2>(base1);
89  BOOST_CHECK(!ptr2);
90  BOOST_CHECK_THROW(armnn::PolymorphicPointerDowncast<Child2>(base1), std::bad_cast);
91 
92  armnn::IgnoreUnused(ptr1, ptr2);
93 }
armnn
Copyright (c) 2021 ARM Limited and Contributors.
Definition: 01_00_software_tools.dox:6
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14

◆ BOOST_AUTO_TEST_CASE() [3/4]

BOOST_AUTO_TEST_CASE ( PolymorphicPointerDowncast_BuildInPointer  )

Definition at line 96 of file UtilityTests.cpp.

References armnn::IgnoreUnused().

97 {
98  using namespace armnn;
99  class Base
100  {
101  public:
102  virtual ~Base(){}
103  float v;
104  };
105 
106  class Child1 : public Base
107  {
108  public:
109  int j;
110  };
111 
112  class Child2 : public Base
113  {
114  public:
115  char b;
116  };
117 
118  Child1 child1;
119  Base* base1 = &child1;
120  auto ptr1 = dynamic_cast<Child1*>(base1);
121  BOOST_CHECK(ptr1 != nullptr);
122  BOOST_CHECK_NO_THROW(armnn::PolymorphicPointerDowncast<Child1>(base1));
123  BOOST_CHECK(armnn::PolymorphicPointerDowncast<Child1>(base1) == ptr1);
124 
125  auto ptr2 = dynamic_cast<Child2*>(base1);
126  BOOST_CHECK(ptr2 == nullptr);
127  BOOST_CHECK_THROW(armnn::PolymorphicPointerDowncast<Child2>(base1), std::bad_cast);
128 
129  armnn::IgnoreUnused(ptr1, ptr2);
130 }
armnn
Copyright (c) 2021 ARM Limited and Contributors.
Definition: 01_00_software_tools.dox:6
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14

◆ BOOST_AUTO_TEST_CASE() [4/4]

BOOST_AUTO_TEST_CASE ( NumericCast  )

Definition at line 133 of file UtilityTests.cpp.

References BOOST_AUTO_TEST_SUITE_END().

134 {
135  using namespace armnn;
136 
137  // To 8 bit
138  BOOST_CHECK_THROW(numeric_cast<unsigned char>(-1), std::bad_cast);
139  BOOST_CHECK_THROW(numeric_cast<unsigned char>(1 << 8), std::bad_cast);
140  BOOST_CHECK_THROW(numeric_cast<unsigned char>(1L << 16), std::bad_cast);
141  BOOST_CHECK_THROW(numeric_cast<unsigned char>(1LL << 32), std::bad_cast);
142 
143  BOOST_CHECK_THROW(numeric_cast<signed char>((1L << 8)*-1), std::bad_cast);
144  BOOST_CHECK_THROW(numeric_cast<signed char>((1L << 15)*-1), std::bad_cast);
145  BOOST_CHECK_THROW(numeric_cast<signed char>((1LL << 31)*-1), std::bad_cast);
146 
147  BOOST_CHECK_NO_THROW(numeric_cast<unsigned char>(1U));
148  BOOST_CHECK_NO_THROW(numeric_cast<unsigned char>(1L));
149  BOOST_CHECK_NO_THROW(numeric_cast<signed char>(-1));
150  BOOST_CHECK_NO_THROW(numeric_cast<signed char>(-1L));
151  BOOST_CHECK_NO_THROW(numeric_cast<signed char>((1 << 7)*-1));
152 
153  // To 16 bit
154  BOOST_CHECK_THROW(numeric_cast<uint16_t>(-1), std::bad_cast);
155  BOOST_CHECK_THROW(numeric_cast<uint16_t>(1L << 16), std::bad_cast);
156  BOOST_CHECK_THROW(numeric_cast<uint16_t>(1LL << 32), std::bad_cast);
157 
158  BOOST_CHECK_THROW(numeric_cast<int16_t>(1L << 15), std::bad_cast);
159  BOOST_CHECK_THROW(numeric_cast<int16_t>(1LL << 31), std::bad_cast);
160 
161  BOOST_CHECK_NO_THROW(numeric_cast<uint16_t>(1L << 8));
162  BOOST_CHECK_NO_THROW(numeric_cast<int16_t>(1L << 7));
163  BOOST_CHECK_NO_THROW(numeric_cast<int16_t>((1L << 15)*-1));
164 
165  BOOST_CHECK_NO_THROW(numeric_cast<int16_t>(1U << 8));
166  BOOST_CHECK_NO_THROW(numeric_cast<int16_t>(1U << 14));
167 
168  // To 32 bit
169  BOOST_CHECK_NO_THROW(numeric_cast<uint32_t>(1));
170  BOOST_CHECK_NO_THROW(numeric_cast<uint32_t>(1 << 8));
171  BOOST_CHECK_NO_THROW(numeric_cast<uint32_t>(1L << 16));
172  BOOST_CHECK_NO_THROW(numeric_cast<uint32_t>(1LL << 31));
173 
174  BOOST_CHECK_NO_THROW(numeric_cast<int32_t>(-1));
175  BOOST_CHECK_NO_THROW(numeric_cast<int32_t>((1L << 8)*-1));
176  BOOST_CHECK_NO_THROW(numeric_cast<int32_t>((1L << 16)*-1));
177  BOOST_CHECK_NO_THROW(numeric_cast<int32_t>((1LL << 31)*-1));
178 
179  BOOST_CHECK_NO_THROW(numeric_cast<int32_t>(1U));
180  BOOST_CHECK_NO_THROW(numeric_cast<int32_t>(1U << 8));
181  BOOST_CHECK_NO_THROW(numeric_cast<int32_t>(1U << 16));
182  BOOST_CHECK_NO_THROW(numeric_cast<int32_t>(1U << 30));
183 
184  float float_max = std::numeric_limits<float>::max();
185  float float_min = std::numeric_limits<float>::lowest();
186  auto int8_max = std::numeric_limits<int8_t>::max();
187  auto int16_max = std::numeric_limits<int16_t>::max();
188  auto int32_max = std::numeric_limits<int32_t>::max();
189  auto int8_min = std::numeric_limits<int8_t>::lowest();
190  auto int16_min = std::numeric_limits<int16_t>::lowest();
191  auto int32_min = std::numeric_limits<int32_t>::lowest();
192  auto uint8_max = std::numeric_limits<uint8_t>::max();
193  auto uint16_max = std::numeric_limits<uint16_t>::max();
194  auto uint32_max = std::numeric_limits<uint32_t>::max();
195  auto double_max = std::numeric_limits<double>::max();
196 
197  // Float to signed integer
198  BOOST_CHECK_NO_THROW(numeric_cast<int32_t>(1.324f));
199  BOOST_CHECK(1 == numeric_cast<int32_t>(1.324f));
200  BOOST_CHECK_NO_THROW(numeric_cast<int32_t>(-1.0f));
201  BOOST_CHECK(-1 == numeric_cast<int32_t>(-1.0f));
202 
203  BOOST_CHECK_NO_THROW(numeric_cast<int8_t>(static_cast<float>(int8_max)));
204  BOOST_CHECK_NO_THROW(numeric_cast<int16_t>(static_cast<float>(int16_max)));
205  BOOST_CHECK_NO_THROW(numeric_cast<int32_t>(static_cast<float>(int32_max)));
206 
207  BOOST_CHECK_THROW(numeric_cast<int8_t>(float_max), std::bad_cast);
208  BOOST_CHECK_THROW(numeric_cast<int16_t>(float_max), std::bad_cast);
209  BOOST_CHECK_THROW(numeric_cast<int32_t>(float_max), std::bad_cast);
210 
211  BOOST_CHECK_THROW(numeric_cast<int8_t>(float_min), std::bad_cast);
212  BOOST_CHECK_THROW(numeric_cast<int16_t>(float_min), std::bad_cast);
213  BOOST_CHECK_THROW(numeric_cast<int32_t>(float_min), std::bad_cast);
214 
215  // Signed integer to float
216  BOOST_CHECK_NO_THROW(numeric_cast<float>(1));
217  BOOST_CHECK(1.0 == numeric_cast<float>(1));
218  BOOST_CHECK_NO_THROW(numeric_cast<float>(-1));
219  BOOST_CHECK(-1.0 == numeric_cast<float>(-1));
220 
221  BOOST_CHECK_NO_THROW(numeric_cast<float>(int8_max));
222  BOOST_CHECK_NO_THROW(numeric_cast<float>(int16_max));
223  BOOST_CHECK_NO_THROW(numeric_cast<float>(int32_max));
224 
225  BOOST_CHECK_NO_THROW(numeric_cast<float>(int8_min));
226  BOOST_CHECK_NO_THROW(numeric_cast<float>(int16_min));
227  BOOST_CHECK_NO_THROW(numeric_cast<float>(int32_min));
228 
229  // Unsigned integer to float
230  BOOST_CHECK_NO_THROW(numeric_cast<float>(1U));
231  BOOST_CHECK(1.0 == numeric_cast<float>(1U));
232 
233  BOOST_CHECK_NO_THROW(numeric_cast<float>(uint8_max));
234  BOOST_CHECK_NO_THROW(numeric_cast<float>(uint16_max));
235  BOOST_CHECK_NO_THROW(numeric_cast<float>(uint32_max));
236 
237  // Float to unsigned integer
238  BOOST_CHECK_NO_THROW(numeric_cast<uint32_t>(1.43243f));
239  BOOST_CHECK(1 == numeric_cast<uint32_t>(1.43243f));
240 
241  BOOST_CHECK_THROW(numeric_cast<uint32_t>(-1.1f), std::bad_cast);
242  BOOST_CHECK_THROW(numeric_cast<uint32_t>(float_max), std::bad_cast);
243 
244  // Double checks
245  BOOST_CHECK_THROW(numeric_cast<int32_t>(double_max), std::bad_cast);
246  BOOST_CHECK_THROW(numeric_cast<int32_t>(double_max), std::bad_cast);
247  BOOST_CHECK_THROW(numeric_cast<float>(double_max), std::bad_cast);
248  BOOST_CHECK_NO_THROW(numeric_cast<double>(int32_max));
249  BOOST_CHECK_NO_THROW(numeric_cast<long double>(int32_max));
250 
251  }
armnn
Copyright (c) 2021 ARM Limited and Contributors.
Definition: 01_00_software_tools.dox:6