cpp
/
cppcore
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
13 Commits
1 Branch
99 KiB
 
 
 
Tree: f088bb428d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f088bb428d'
${ noResults }
cppcore/test/cppcore/conversion/convert_cast_tests.cpp

183 lines
10 KiB
Raw Blame History 

  1. #include <gtest/gtest.h>

  2. 

  3. #define CPPCORE_CONVERT_CAST_THROW

  4. #include <cppcore/conversion/convert_cast.h>

  5. 

  6. using namespace ::cppcore;

  7. 

  8. enum class test_enum

  9. {

  10.     test0 = 0,

  11.     test1,

  12.     test2,

  13.     test256 = 256,

  14. };

  15. 

  16. TEST(convert_cast_test, i8)

  17. {

  18.     EXPECT_THROW(convert_cast<int8_t>(static_cast< int16_t>(128)), convert_exception);

  19.     EXPECT_THROW(convert_cast<int8_t>(static_cast< int32_t>(128)), convert_exception);

  20.     EXPECT_THROW(convert_cast<int8_t>(static_cast< int64_t>(128)), convert_exception);

  21. 

  22.     EXPECT_THROW(convert_cast<int8_t>(static_cast< uint8_t>(128)), convert_exception);

  23.     EXPECT_THROW(convert_cast<int8_t>(static_cast<uint16_t>(128)), convert_exception);

  24.     EXPECT_THROW(convert_cast<int8_t>(static_cast<uint32_t>(128)), convert_exception);

  25.     EXPECT_THROW(convert_cast<int8_t>(static_cast<uint64_t>(128)), convert_exception);

  26. 

  27.     EXPECT_EQ   (convert_cast<int8_t>(static_cast<  int8_t>(1)), static_cast<int8_t>(1));

  28.     EXPECT_EQ   (convert_cast<int8_t>(static_cast< int16_t>(2)), static_cast<int8_t>(2));

  29.     EXPECT_EQ   (convert_cast<int8_t>(static_cast< int32_t>(3)), static_cast<int8_t>(3));

  30.     EXPECT_EQ   (convert_cast<int8_t>(static_cast< int64_t>(4)), static_cast<int8_t>(4));

  31. 

  32.     EXPECT_EQ   (convert_cast<int8_t>(static_cast< uint8_t>(4)), static_cast<int8_t>(4));

  33.     EXPECT_EQ   (convert_cast<int8_t>(static_cast<uint16_t>(5)), static_cast<int8_t>(5));

  34.     EXPECT_EQ   (convert_cast<int8_t>(static_cast<uint32_t>(6)), static_cast<int8_t>(6));

  35.     EXPECT_EQ   (convert_cast<int8_t>(static_cast<uint64_t>(7)), static_cast<int8_t>(7));

  36. }

  37. 

  38. TEST(convert_cast_test, u8)

  39. {

  40.     EXPECT_THROW(convert_cast<uint8_t>(static_cast<  int8_t>( -1)), convert_exception);

  41.     EXPECT_THROW(convert_cast<uint8_t>(static_cast< int16_t>(256)), convert_exception);

  42.     EXPECT_THROW(convert_cast<uint8_t>(static_cast< int32_t>( -1)), convert_exception);

  43.     EXPECT_THROW(convert_cast<uint8_t>(static_cast< int64_t>(256)), convert_exception);

  44. 

  45.     EXPECT_THROW(convert_cast<uint8_t>(static_cast<uint16_t>(256)), convert_exception);

  46.     EXPECT_THROW(convert_cast<uint8_t>(static_cast<uint32_t>(256)), convert_exception);

  47.     EXPECT_THROW(convert_cast<uint8_t>(static_cast<uint64_t>(256)), convert_exception);

  48. 

  49.     EXPECT_EQ   (convert_cast<uint8_t>(static_cast<  int8_t>(1)), static_cast<uint8_t>(1));

  50.     EXPECT_EQ   (convert_cast<uint8_t>(static_cast< int16_t>(2)), static_cast<uint8_t>(2));

  51.     EXPECT_EQ   (convert_cast<uint8_t>(static_cast< int32_t>(3)), static_cast<uint8_t>(3));

  52.     EXPECT_EQ   (convert_cast<uint8_t>(static_cast< int64_t>(4)), static_cast<uint8_t>(4));

  53. 

  54.     EXPECT_EQ   (convert_cast<uint8_t>(static_cast< uint8_t>(4)), static_cast<uint8_t>(4));

  55.     EXPECT_EQ   (convert_cast<uint8_t>(static_cast<uint16_t>(5)), static_cast<uint8_t>(5));

  56.     EXPECT_EQ   (convert_cast<uint8_t>(static_cast<uint32_t>(6)), static_cast<uint8_t>(6));

  57.     EXPECT_EQ   (convert_cast<uint8_t>(static_cast<uint64_t>(7)), static_cast<uint8_t>(7));

  58. }

  59. 

  60. TEST(convert_cast_test, i16)

  61. {

  62.     EXPECT_THROW(convert_cast<int16_t>(static_cast< int32_t>(32'768)), convert_exception);

  63.     EXPECT_THROW(convert_cast<int16_t>(static_cast< int64_t>(32'768)), convert_exception);

  64. 

  65.     EXPECT_THROW(convert_cast<int16_t>(static_cast<uint16_t>(32'768)), convert_exception);

  66.     EXPECT_THROW(convert_cast<int16_t>(static_cast<uint32_t>(32'768)), convert_exception);

  67.     EXPECT_THROW(convert_cast<int16_t>(static_cast<uint64_t>(32'768)), convert_exception);

  68. 

  69.     EXPECT_EQ   (convert_cast<int16_t>(static_cast<  int8_t>(1)), static_cast<int16_t>(1));

  70.     EXPECT_EQ   (convert_cast<int16_t>(static_cast< int16_t>(2)), static_cast<int16_t>(2));

  71.     EXPECT_EQ   (convert_cast<int16_t>(static_cast< int32_t>(3)), static_cast<int16_t>(3));

  72.     EXPECT_EQ   (convert_cast<int16_t>(static_cast< int64_t>(4)), static_cast<int16_t>(4));

  73. 

  74.     EXPECT_EQ   (convert_cast<int16_t>(static_cast< uint8_t>(4)), static_cast<int16_t>(4));

  75.     EXPECT_EQ   (convert_cast<int16_t>(static_cast<uint16_t>(5)), static_cast<int16_t>(5));

  76.     EXPECT_EQ   (convert_cast<int16_t>(static_cast<uint32_t>(6)), static_cast<int16_t>(6));

  77.     EXPECT_EQ   (convert_cast<int16_t>(static_cast<uint64_t>(7)), static_cast<int16_t>(7));

  78. }

  79. 

  80. TEST(convert_cast_test, u16)

  81. {

  82.     EXPECT_THROW(convert_cast<uint16_t>(static_cast<  int8_t>(    -1)), convert_exception);

  83.     EXPECT_THROW(convert_cast<uint16_t>(static_cast< int16_t>(    -1)), convert_exception);

  84.     EXPECT_THROW(convert_cast<uint16_t>(static_cast< int32_t>(65'536)), convert_exception);

  85.     EXPECT_THROW(convert_cast<uint16_t>(static_cast< int64_t>(65'536)), convert_exception);

  86. 

  87.     EXPECT_THROW(convert_cast<uint16_t>(static_cast<uint32_t>(65'536)), convert_exception);

  88.     EXPECT_THROW(convert_cast<uint16_t>(static_cast<uint64_t>(65'536)), convert_exception);

  89. 

  90.     EXPECT_EQ   (convert_cast<uint16_t>(static_cast<  int8_t>(1)), static_cast<int16_t>(1));

  91.     EXPECT_EQ   (convert_cast<uint16_t>(static_cast< int16_t>(2)), static_cast<int16_t>(2));

  92.     EXPECT_EQ   (convert_cast<uint16_t>(static_cast< int32_t>(3)), static_cast<int16_t>(3));

  93.     EXPECT_EQ   (convert_cast<uint16_t>(static_cast< int64_t>(4)), static_cast<int16_t>(4));

  94. 

  95.     EXPECT_EQ   (convert_cast<uint16_t>(static_cast< uint8_t>(4)), static_cast<int16_t>(4));

  96.     EXPECT_EQ   (convert_cast<uint16_t>(static_cast<uint16_t>(5)), static_cast<int16_t>(5));

  97.     EXPECT_EQ   (convert_cast<uint16_t>(static_cast<uint32_t>(6)), static_cast<int16_t>(6));

  98.     EXPECT_EQ   (convert_cast<uint16_t>(static_cast<uint64_t>(7)), static_cast<int16_t>(7));

  99. }

  100. 

  101. TEST(convert_cast_test, i32)

  102. {

  103.     EXPECT_THROW(convert_cast<int32_t>(static_cast< int64_t>(2'147'483'648)), convert_exception);

  104. 

  105.     EXPECT_THROW(convert_cast<int32_t>(static_cast<uint32_t>(2'147'483'648)), convert_exception);

  106.     EXPECT_THROW(convert_cast<int32_t>(static_cast<uint64_t>(2'147'483'648)), convert_exception);

  107. 

  108.     EXPECT_EQ   (convert_cast<int32_t>(static_cast<  int8_t>(1)), static_cast<int32_t>(1));

  109.     EXPECT_EQ   (convert_cast<int32_t>(static_cast< int16_t>(2)), static_cast<int32_t>(2));

  110.     EXPECT_EQ   (convert_cast<int32_t>(static_cast< int32_t>(3)), static_cast<int32_t>(3));

  111.     EXPECT_EQ   (convert_cast<int32_t>(static_cast< int64_t>(4)), static_cast<int32_t>(4));

  112. 

  113.     EXPECT_EQ   (convert_cast<int32_t>(static_cast< uint8_t>(4)), static_cast<int32_t>(4));

  114.     EXPECT_EQ   (convert_cast<int32_t>(static_cast<uint16_t>(5)), static_cast<int32_t>(5));

  115.     EXPECT_EQ   (convert_cast<int32_t>(static_cast<uint32_t>(6)), static_cast<int32_t>(6));

  116.     EXPECT_EQ   (convert_cast<int32_t>(static_cast<uint64_t>(7)), static_cast<int32_t>(7));

  117. }

  118. 

  119. TEST(convert_cast_test, u32)

  120. {

  121.     EXPECT_THROW(convert_cast<uint32_t>(static_cast<  int8_t>(           -1)), convert_exception);

  122.     EXPECT_THROW(convert_cast<uint32_t>(static_cast< int16_t>(           -1)), convert_exception);

  123.     EXPECT_THROW(convert_cast<uint32_t>(static_cast< int32_t>(           -1)), convert_exception);

  124.     EXPECT_THROW(convert_cast<uint32_t>(static_cast< int64_t>(4'294'967'296)), convert_exception);

  125. 

  126.     EXPECT_THROW(convert_cast<uint32_t>(static_cast<uint64_t>(4'294'967'296)), convert_exception);

  127. 

  128.     EXPECT_EQ   (convert_cast<uint32_t>(static_cast<  int8_t>(1)), static_cast<int32_t>(1));

  129.     EXPECT_EQ   (convert_cast<uint32_t>(static_cast< int16_t>(2)), static_cast<int32_t>(2));

  130.     EXPECT_EQ   (convert_cast<uint32_t>(static_cast< int32_t>(3)), static_cast<int32_t>(3));

  131.     EXPECT_EQ   (convert_cast<uint32_t>(static_cast< int64_t>(4)), static_cast<int32_t>(4));

  132. 

  133.     EXPECT_EQ   (convert_cast<uint32_t>(static_cast< uint8_t>(4)), static_cast<int32_t>(4));

  134.     EXPECT_EQ   (convert_cast<uint32_t>(static_cast<uint16_t>(5)), static_cast<int32_t>(5));

  135.     EXPECT_EQ   (convert_cast<uint32_t>(static_cast<uint32_t>(6)), static_cast<int32_t>(6));

  136.     EXPECT_EQ   (convert_cast<uint32_t>(static_cast<uint64_t>(7)), static_cast<int32_t>(7));

  137. }

  138. 

  139. TEST(convert_cast_test, i64)

  140. {

  141.     EXPECT_THROW(convert_cast<int64_t>(static_cast<uint64_t>(std::numeric_limits<int64_t>::max()) + 1), convert_exception);

  142. 

  143.     EXPECT_EQ   (convert_cast<int64_t>(static_cast<  int8_t>(1)), static_cast<int64_t>(1));

  144.     EXPECT_EQ   (convert_cast<int64_t>(static_cast< int16_t>(2)), static_cast<int64_t>(2));

  145.     EXPECT_EQ   (convert_cast<int64_t>(static_cast< int32_t>(3)), static_cast<int64_t>(3));

  146.     EXPECT_EQ   (convert_cast<int64_t>(static_cast< int64_t>(4)), static_cast<int64_t>(4));

  147. 

  148.     EXPECT_EQ   (convert_cast<int64_t>(static_cast< uint8_t>(4)), static_cast<int64_t>(4));

  149.     EXPECT_EQ   (convert_cast<int64_t>(static_cast<uint16_t>(5)), static_cast<int64_t>(5));

  150.     EXPECT_EQ   (convert_cast<int64_t>(static_cast<uint32_t>(6)), static_cast<int64_t>(6));

  151.     EXPECT_EQ   (convert_cast<int64_t>(static_cast<uint64_t>(7)), static_cast<int64_t>(7));

  152. }

  153. 

  154. TEST(convert_cast_test, u64)

  155. {

  156.     EXPECT_THROW(convert_cast<uint64_t>(static_cast<  int8_t>(           -1)), convert_exception);

  157.     EXPECT_THROW(convert_cast<uint64_t>(static_cast< int16_t>(           -1)), convert_exception);

  158.     EXPECT_THROW(convert_cast<uint64_t>(static_cast< int32_t>(           -1)), convert_exception);

  159. 

  160.     EXPECT_EQ   (convert_cast<uint64_t>(static_cast<  int8_t>(1)), static_cast<int64_t>(1));

  161.     EXPECT_EQ   (convert_cast<uint64_t>(static_cast< int16_t>(2)), static_cast<int64_t>(2));

  162.     EXPECT_EQ   (convert_cast<uint64_t>(static_cast< int32_t>(3)), static_cast<int64_t>(3));

  163.     EXPECT_EQ   (convert_cast<uint64_t>(static_cast< int64_t>(4)), static_cast<int64_t>(4));

  164. 

  165.     EXPECT_EQ   (convert_cast<uint64_t>(static_cast< uint8_t>(4)), static_cast<int64_t>(4));

  166.     EXPECT_EQ   (convert_cast<uint64_t>(static_cast<uint16_t>(5)), static_cast<int64_t>(5));

  167.     EXPECT_EQ   (convert_cast<uint64_t>(static_cast<uint32_t>(6)), static_cast<int64_t>(6));

  168.     EXPECT_EQ   (convert_cast<uint64_t>(static_cast<uint64_t>(7)), static_cast<int64_t>(7));

  169. }

  170. 

  171. TEST(convert_cast_test, enum)

  172. {

  173.     EXPECT_EQ(convert_cast< int8_t>(  test_enum::test0), static_cast< int8_t>(  0));

  174.     EXPECT_EQ(convert_cast<int16_t>(  test_enum::test1), static_cast<int16_t>(  1));

  175.     EXPECT_EQ(convert_cast<int32_t>(  test_enum::test2), static_cast<int32_t>(  2));

  176.     EXPECT_EQ(convert_cast<int64_t>(test_enum::test256), static_cast<int64_t>(256));

  177. 

  178.     EXPECT_EQ(convert_cast< uint8_t>(  test_enum::test0), static_cast< uint8_t>(  0));

  179.     EXPECT_EQ(convert_cast<uint16_t>(  test_enum::test1), static_cast<uint16_t>(  1));

  180.     EXPECT_EQ(convert_cast<uint32_t>(  test_enum::test2), static_cast<uint32_t>(  2));

  181.     EXPECT_EQ(convert_cast<uint64_t>(test_enum::test256), static_cast<uint64_t>(256));

  182. }