@@ -1 +0,0 @@ | |||||
# This file is generated by cmake for dependency checking of the CMakeCache.txt file |
@@ -0,0 +1,4 @@ | |||||
#pragma once | |||||
#cmakedefine CPPCORE_CONVERT_CAST_ABORT | |||||
#cmakedefine CPPCORE_CONVERT_CAST_THROW |
@@ -9,3 +9,9 @@ Option ( CPPCORE_INSTALL_PACKAGE | |||||
Option ( CPPCORE_USE_GIT_VERSION | Option ( CPPCORE_USE_GIT_VERSION | ||||
"Read the git tags to get the version of cppcore" | "Read the git tags to get the version of cppcore" | ||||
ON ) | ON ) | ||||
If ( NOT CPPCORE_CONVERT_CAST ) | |||||
Set ( CPPCORE_CONVERT_CAST throw | |||||
CACHE STRING "Specify how the convert_cast should handle invalid values." ) | |||||
Set_Property ( CACHE CPPCORE_CONVERT_CAST | |||||
PROPERTY STRINGS throw abort ) | |||||
EndIf ( ) |
@@ -0,0 +1,25 @@ | |||||
#pragma once | |||||
namespace cppcore | |||||
{ | |||||
/** | |||||
* @brief Convert one type to another type. | |||||
* | |||||
* This method will try to convert the given value to the given type. | |||||
* If a convertion between the two types is unknown, a compiler error is raised. | |||||
* If the value to convert does not fullfill the conversion requirements (like range checks) | |||||
* the program will panic (call to std::abort) or throw an convert_exception (if configured). | |||||
* | |||||
* @tparam T_to Type to convert to. | |||||
* @tparam T_from Type to convert from. | |||||
* | |||||
* @param[in] p_value Value to convert. | |||||
* @return Converted value. | |||||
*/ | |||||
template<typename T_to, typename T_from> | |||||
constexpr T_to convert_cast(T_from p_value); | |||||
} | |||||
#include "convert_cast.inl" |
@@ -0,0 +1,178 @@ | |||||
#pragma once | |||||
#ifdef CPPCORE_CONVERT_CAST_ABORT | |||||
# include <iostream> | |||||
#endif | |||||
#include <limits> | |||||
#include <type_traits> | |||||
#include <cppcore/config.h> | |||||
#include <cppcore/misc/exception.h> | |||||
#include <cppcore/misc/type_helper.h> | |||||
#include "convert_cast.h" | |||||
namespace cppcore | |||||
{ | |||||
namespace __impl | |||||
{ | |||||
template<typename T_to, typename T_from> | |||||
void convert_cast_raise(T_from p_value) | |||||
{ | |||||
#if defined(CPPCORE_CONVERT_CAST_THROW) | |||||
using namespace std; | |||||
throw convert_exception("Unable to convert "s | |||||
+ type_helper<T_from>::name() | |||||
+ "(" + std::to_string(p_value) + ") to " | |||||
+ type_helper<T_to>::name()); | |||||
#elif defined(CPPCORE_CONVERT_CAST_ABORT) | |||||
std::cerr | |||||
<< "Unable to convert " | |||||
<< type_helper<T_from>::name() | |||||
<< "(" << p_value << ") to " | |||||
<< type_helper<T_to>::name() | |||||
<< std::endl; | |||||
std::abort(); | |||||
#endif | |||||
} | |||||
template<typename T_from, typename T_to, typename T_enable = void> | |||||
struct convert_cast_impl | |||||
{ | |||||
constexpr T_to operator()(T_from p_value) const | |||||
{ static_assert(sizeof(T_from) < 0, "convert_cast is not available for the passed types!"); } | |||||
}; | |||||
/** | |||||
* types are equal => simple static cast | |||||
*/ | |||||
template<typename T> | |||||
struct convert_cast_impl<T, T, void> | |||||
{ | |||||
constexpr T operator()(T p_value) const | |||||
{ return p_value; } | |||||
}; | |||||
/** | |||||
* T_from does fit into T_to => simple static cast | |||||
*/ | |||||
template<typename T_from, typename T_to> | |||||
struct convert_cast_impl< | |||||
T_from, | |||||
T_to, | |||||
std::enable_if_t< | |||||
(sizeof(T_from) < sizeof(T_to)) | |||||
&& std::disjunction_v< | |||||
std::conjunction< | |||||
std::is_unsigned<std::decay_t<T_from>>, | |||||
std::is_integral<std::decay_t<T_to>> | |||||
>, | |||||
std::conjunction< | |||||
std::is_signed<std::decay_t<T_from>>, | |||||
std::is_signed<std::decay_t<T_to>> | |||||
> | |||||
> | |||||
> | |||||
> | |||||
{ | |||||
constexpr T_to operator()(T_from p_value) const | |||||
{ return static_cast<T_to>(p_value); } | |||||
}; | |||||
/** | |||||
* T_from does fit into T_to => check range and cast | |||||
*/ | |||||
template<typename T_from, typename T_to> | |||||
struct convert_cast_impl< | |||||
T_from, | |||||
T_to, | |||||
std::enable_if_t< | |||||
(sizeof(T_from) > sizeof(T_to)) | |||||
&& std::is_signed_v<std::decay_t<T_from>> | |||||
&& std::is_signed_v<std::decay_t<T_to>> | |||||
> | |||||
> | |||||
{ | |||||
constexpr T_to operator()(T_from p_value) const | |||||
{ | |||||
if (p_value < std::numeric_limits<T_to>::min()) | |||||
convert_cast_raise<T_to>(p_value); | |||||
if (p_value > std::numeric_limits<T_to>::max()) | |||||
convert_cast_raise<T_to>(p_value); | |||||
return static_cast<T_to>(p_value); | |||||
} | |||||
}; | |||||
/** | |||||
* T_from does fit into T_to => check range and cast | |||||
*/ | |||||
template<typename T_from, typename T_to> | |||||
struct convert_cast_impl< | |||||
T_from, | |||||
T_to, | |||||
std::enable_if_t< | |||||
( (sizeof(T_from) >= sizeof(T_to)) | |||||
&& std::is_unsigned_v<std::decay_t<T_from>> | |||||
&& std::is_signed_v<std::decay_t<T_to>>) | |||||
|| ( (sizeof(T_from) > sizeof(T_to)) | |||||
&& std::is_unsigned_v<std::decay_t<T_from>> | |||||
&& std::is_unsigned_v<std::decay_t<T_to>>) | |||||
> | |||||
> | |||||
{ | |||||
constexpr T_to operator()(T_from p_value) const | |||||
{ | |||||
if (p_value > std::numeric_limits<T_to>::max()) | |||||
convert_cast_raise<T_to>(p_value); | |||||
return static_cast<T_to>(p_value); | |||||
} | |||||
}; | |||||
/** | |||||
* signed to unsigned cast => check lower range and cast | |||||
*/ | |||||
template<typename T_from, typename T_to> | |||||
struct convert_cast_impl< | |||||
T_from, | |||||
T_to, | |||||
std::enable_if_t< | |||||
std::is_signed_v <std::decay_t<T_from>> | |||||
&& std::is_unsigned_v<std::decay_t<T_to >>>> | |||||
{ | |||||
constexpr T_to operator()(T_from p_value) const | |||||
{ | |||||
using unsigned_type = std::make_unsigned_t<T_from>; | |||||
if (p_value < 0) | |||||
convert_cast_raise<T_to>(p_value); | |||||
return convert_cast<T_to>(static_cast<unsigned_type>(p_value)); | |||||
} | |||||
}; | |||||
/** | |||||
* enum to integral cast => static cast | |||||
*/ | |||||
template<typename T_from, typename T_to> | |||||
struct convert_cast_impl< | |||||
T_from, | |||||
T_to, | |||||
std::enable_if_t< | |||||
std::is_enum_v <std::decay_t<T_from>> | |||||
&& std::is_integral_v<std::decay_t<T_to >> | |||||
>> | |||||
{ | |||||
constexpr T_to operator()(T_from p_value) const | |||||
{ | |||||
using underlying_type = std::underlying_type_t<T_from>; | |||||
return convert_cast<T_to>(static_cast<underlying_type>(p_value)); | |||||
} | |||||
}; | |||||
} | |||||
template<typename T_to, typename T_from> | |||||
constexpr T_to convert_cast(T_from p_value) | |||||
{ return __impl::convert_cast_impl<T_from, T_to>()(p_value); } | |||||
} |
@@ -1,10 +1,13 @@ | |||||
#pragma once | #pragma once | ||||
#include <limits> | |||||
#include <cppcore/misc/exception.h> | #include <cppcore/misc/exception.h> | ||||
#include <cppcore/misc/type_helper.h> | #include <cppcore/misc/type_helper.h> | ||||
#include "enum.h" | #include "enum.h" | ||||
#include "string.h" | #include "string.h" | ||||
#include "convert_cast.h" | |||||
#ifdef _GLIBCXX_VECTOR | #ifdef _GLIBCXX_VECTOR | ||||
#define CPPCORE_HAS_VECTOR | #define CPPCORE_HAS_VECTOR | ||||
@@ -51,7 +54,7 @@ namespace cppcore | |||||
&& ( *i == seperator | && ( *i == seperator | ||||
|| *i == '\0')) | || *i == '\0')) | ||||
{ | { | ||||
std::string tmp(s, static_cast<size_t>(i - s)); | |||||
std::string tmp(s, convert_cast<size_t>(i - s)); | |||||
if (!predicate(tmp)) | if (!predicate(tmp)) | ||||
return false; | return false; | ||||
s = i + 1; | s = i + 1; | ||||
@@ -362,13 +365,32 @@ namespace cppcore | |||||
}; | }; | ||||
template<typename T> | template<typename T> | ||||
struct op_from_string<T, typename std::enable_if_t<std::is_integral_v<T>>> | |||||
struct op_from_string<T, typename std::enable_if_t<std::is_unsigned_v<T> && std::is_integral_v<T>>> | |||||
{ | { | ||||
inline bool operator()(const std::string& s, T& v) const | |||||
inline bool operator()(const std::string& s, T& value) const | |||||
{ | |||||
char *e = nullptr; | |||||
const char *c = s.c_str(); | |||||
auto tmp = std::strtoull(c, &e, 0); | |||||
if (tmp > std::numeric_limits<T>::max()) | |||||
return false; | |||||
value = static_cast<T>(tmp); | |||||
return (c != e); | |||||
} | |||||
}; | |||||
template<typename T> | |||||
struct op_from_string<T, typename std::enable_if_t<std::is_signed_v<T> && std::is_integral_v<T>>> | |||||
{ | |||||
inline bool operator()(const std::string& s, T& value) const | |||||
{ | { | ||||
char *e = nullptr; | char *e = nullptr; | ||||
const char *c = s.c_str(); | const char *c = s.c_str(); | ||||
v = static_cast<T>(std::strtoull(c, &e, 0)); | |||||
auto tmp = std::strtoll(c, &e, 0); | |||||
if ( tmp > std::numeric_limits<T>::max() | |||||
|| tmp < std::numeric_limits<T>::min()) | |||||
return false; | |||||
value = static_cast<T>(tmp); | |||||
return (c != e); | return (c != e); | ||||
} | } | ||||
}; | }; | ||||
@@ -380,7 +402,11 @@ namespace cppcore | |||||
{ | { | ||||
char *e = nullptr; | char *e = nullptr; | ||||
const char *c = s.c_str(); | const char *c = s.c_str(); | ||||
value = static_cast<T>(std::strtold(c, &e)); | |||||
auto tmp = std::strtold(c, &e); | |||||
if ( tmp > static_cast<long double>(std::numeric_limits<T>::max()) | |||||
|| tmp < static_cast<long double>(std::numeric_limits<T>::min())) | |||||
return false; | |||||
value = static_cast<T>(tmp); | |||||
return (c != e); | return (c != e); | ||||
} | } | ||||
}; | }; | ||||
@@ -1,5 +1,7 @@ | |||||
#pragma once | #pragma once | ||||
#include <cppcore/conversion/convert_cast.h> | |||||
#include "stream.h" | #include "stream.h" | ||||
namespace cppcore | namespace cppcore | ||||
@@ -123,7 +125,7 @@ namespace cppcore | |||||
{ | { | ||||
auto pos = is.tellg(); | auto pos = is.tellg(); | ||||
t.deserialize(is); | t.deserialize(is); | ||||
return static_cast<size_t>(is.tellg() - pos); | |||||
return convert_cast<size_t>(is.tellg() - pos); | |||||
} | } | ||||
}; | }; | ||||
@@ -150,10 +152,10 @@ namespace cppcore | |||||
{ | { | ||||
if (t.size() > std::numeric_limits<uint32_t>::max()) | if (t.size() > std::numeric_limits<uint32_t>::max()) | ||||
throw exception("unable to write data to stream: string is to large"); | throw exception("unable to write data to stream: string is to large"); | ||||
op_stream_write<uint32_t, void>()(os, static_cast<uint32_t>(t.size())); | |||||
op_stream_write<uint32_t, void>()(os, convert_cast<uint32_t>(t.size())); | |||||
if (!os) | if (!os) | ||||
throw exception("unable to write data to stream: invalid stream"); | throw exception("unable to write data to stream: invalid stream"); | ||||
os.write(t.data(), static_cast<std::streamsize>(t.size())); | |||||
os.write(t.data(), convert_cast<std::streamsize>(t.size())); | |||||
if (!os) | if (!os) | ||||
throw exception("unable to write data to stream: stream error"); | throw exception("unable to write data to stream: stream error"); | ||||
return sizeof(uint32_t) + t.size(); | return sizeof(uint32_t) + t.size(); | ||||
@@ -167,7 +169,7 @@ namespace cppcore | |||||
{ | { | ||||
auto pos = os.tellp(); | auto pos = os.tellp(); | ||||
t.serialize(os); | t.serialize(os); | ||||
return static_cast<size_t>(os.tellp() - pos); | |||||
return convert_cast<size_t>(os.tellp() - pos); | |||||
} | } | ||||
}; | }; | ||||
@@ -1,5 +1,7 @@ | |||||
#pragma once | #pragma once | ||||
#include <cppcore/conversion/convert_cast.h> | |||||
#include "vector_streambuf.h" | #include "vector_streambuf.h" | ||||
namespace cppcore | namespace cppcore | ||||
@@ -18,7 +20,7 @@ namespace cppcore | |||||
::get() const | ::get() const | ||||
{ | { | ||||
auto vec = _buffer; | auto vec = _buffer; | ||||
vec.resize(static_cast<size_t>(this->pptr() - this->pbase())); | |||||
vec.resize(convert_cast<size_t>(this->pptr() - this->pbase())); | |||||
return vec; | return vec; | ||||
} | } | ||||
@@ -40,7 +42,7 @@ namespace cppcore | |||||
basic_vector_streambuf<T_data, T_char> | basic_vector_streambuf<T_data, T_char> | ||||
::extract() | ::extract() | ||||
{ | { | ||||
_buffer.resize(static_cast<size_t>(this->pptr() - this->pbase())); | |||||
_buffer.resize(convert_cast<size_t>(this->pptr() - this->pbase())); | |||||
auto ret = std::move(_buffer); | auto ret = std::move(_buffer); | ||||
this->setp(nullptr, nullptr); | this->setp(nullptr, nullptr); | ||||
this->setg(nullptr, nullptr, nullptr); | this->setg(nullptr, nullptr, nullptr); | ||||
@@ -52,11 +54,11 @@ namespace cppcore | |||||
basic_vector_streambuf<T_data, T_char> | basic_vector_streambuf<T_data, T_char> | ||||
::underflow() | ::underflow() | ||||
{ | { | ||||
auto gpos = static_cast<size_t>(this->gptr() - this->eback()); | |||||
auto gpos = convert_cast<size_t>(this->gptr() - this->eback()); | |||||
this->setg(this->eback(), this->eback() + gpos, this->pptr()); | this->setg(this->eback(), this->eback() + gpos, this->pptr()); | ||||
if (this->gptr() == this->egptr()) | if (this->gptr() == this->egptr()) | ||||
return traits_type::eof(); | return traits_type::eof(); | ||||
auto ret = static_cast<int_type>(*this->gptr()); | |||||
auto ret = convert_cast<int_type>(*this->gptr()); | |||||
return ret; | return ret; | ||||
} | } | ||||
@@ -80,15 +82,15 @@ namespace cppcore | |||||
auto beg = reinterpret_cast<char_type*>(&_buffer.front()); | auto beg = reinterpret_cast<char_type*>(&_buffer.front()); | ||||
auto end = beg + _buffer.size(); | auto end = beg + _buffer.size(); | ||||
auto ppos = static_cast<int>(this->pptr() - this->pbase()); | |||||
auto gpos = static_cast<size_t>(this->gptr() - this->eback()); | |||||
auto ppos = convert_cast<int>(this->pptr() - this->pbase()); | |||||
auto gpos = convert_cast<size_t>(this->gptr() - this->eback()); | |||||
this->setp(beg, end); | this->setp(beg, end); | ||||
this->setg(beg, beg + gpos, beg + ppos); | this->setg(beg, beg + gpos, beg + ppos); | ||||
this->pbump(ppos); | this->pbump(ppos); | ||||
auto p = this->pptr(); | auto p = this->pptr(); | ||||
assert(this->pbase() <= p && p < this->epptr()); | assert(this->pbase() <= p && p < this->epptr()); | ||||
*p = static_cast<char_type>(ch); | |||||
*p = convert_cast<char_type>(ch); | |||||
this->pbump(1); | this->pbump(1); | ||||
} | } | ||||
return ch; | return ch; | ||||
@@ -6,11 +6,21 @@ Include ( strip_symbols OPTIONAL RESULT_VARIABLE HAS_STRIP_S | |||||
# Interface Library ############################################################################### | # Interface Library ############################################################################### | ||||
If ( "${CPPCORE_CONVERT_CAST}" STREQUAL "abort" ) | |||||
Set ( CPPCORE_CONVERT_CAST_ABORT 1 ) | |||||
ElseIf ( "${CPPCORE_CONVERT_CAST}" STREQUAL "throw" ) | |||||
Set ( CPPCORE_CONVERT_CAST_THROW 1 ) | |||||
EndIf ( ) | |||||
Set ( CPPCORE_GENERATED_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/generated ) | |||||
Configure_File ( ${CMAKE_CURRENT_SOURCE_DIR}/../cmake/config.h.in | |||||
${CPPCORE_GENERATED_INCLUDE_DIR}/cppcore/config.h ) | |||||
Set ( CPPCORE_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../include ) | Set ( CPPCORE_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../include ) | ||||
Add_Library ( cppcore INTERFACE ) | Add_Library ( cppcore INTERFACE ) | ||||
Target_Include_Directories ( cppcore | Target_Include_Directories ( cppcore | ||||
INTERFACE | INTERFACE | ||||
$<BUILD_INTERFACE:${CPPCORE_INCLUDE_DIR}> | $<BUILD_INTERFACE:${CPPCORE_INCLUDE_DIR}> | ||||
$<BUILD_INTERFACE:${CPPCORE_GENERATED_INCLUDE_DIR}> | |||||
$<INSTALL_INTERFACE:${CPPCORE_INSTALL_DIR_INCLUDE}> ) | $<INSTALL_INTERFACE:${CPPCORE_INSTALL_DIR_INCLUDE}> ) | ||||
# Install ######################################################################################### | # Install ######################################################################################### | ||||
@@ -24,6 +34,8 @@ If ( CPPCORE_INSTALL_HEADER ) | |||||
DESTINATION ${CPPCORE_INSTALL_DIR_INCLUDE} ) | DESTINATION ${CPPCORE_INSTALL_DIR_INCLUDE} ) | ||||
Install ( DIRECTORY ${CPPCORE_INCLUDE_DIR}/cppcore | Install ( DIRECTORY ${CPPCORE_INCLUDE_DIR}/cppcore | ||||
DESTINATION ${CPPCORE_INSTALL_DIR_INCLUDE} ) | DESTINATION ${CPPCORE_INSTALL_DIR_INCLUDE} ) | ||||
Install ( DIRECTORY ${CPPCORE_GENERATED_INCLUDE_DIR}/cppcore | |||||
DESTINATION ${CPPCORE_INSTALL_DIR_INCLUDE} ) | |||||
Install ( TARGETS cppcore | Install ( TARGETS cppcore | ||||
EXPORT cppcore | EXPORT cppcore | ||||
DESTINATION ${CPPCORE_INSTALL_DIR_INCLUDE} ) | DESTINATION ${CPPCORE_INSTALL_DIR_INCLUDE} ) | ||||
@@ -0,0 +1,182 @@ | |||||
#include <gtest/gtest.h> | |||||
#define CPPCORE_CONVERT_CAST_THROW | |||||
#include <cppcore/conversion/convert_cast.h> | |||||
using namespace ::cppcore; | |||||
enum class test_enum | |||||
{ | |||||
test0 = 0, | |||||
test1, | |||||
test2, | |||||
test256 = 256, | |||||
}; | |||||
TEST(convert_cast_test, i8) | |||||
{ | |||||
EXPECT_THROW(convert_cast<int8_t>(static_cast< int16_t>(128)), convert_exception); | |||||
EXPECT_THROW(convert_cast<int8_t>(static_cast< int32_t>(128)), convert_exception); | |||||
EXPECT_THROW(convert_cast<int8_t>(static_cast< int64_t>(128)), convert_exception); | |||||
EXPECT_THROW(convert_cast<int8_t>(static_cast< uint8_t>(128)), convert_exception); | |||||
EXPECT_THROW(convert_cast<int8_t>(static_cast<uint16_t>(128)), convert_exception); | |||||
EXPECT_THROW(convert_cast<int8_t>(static_cast<uint32_t>(128)), convert_exception); | |||||
EXPECT_THROW(convert_cast<int8_t>(static_cast<uint64_t>(128)), convert_exception); | |||||
EXPECT_EQ (convert_cast<int8_t>(static_cast< int8_t>(1)), static_cast<int8_t>(1)); | |||||
EXPECT_EQ (convert_cast<int8_t>(static_cast< int16_t>(2)), static_cast<int8_t>(2)); | |||||
EXPECT_EQ (convert_cast<int8_t>(static_cast< int32_t>(3)), static_cast<int8_t>(3)); | |||||
EXPECT_EQ (convert_cast<int8_t>(static_cast< int64_t>(4)), static_cast<int8_t>(4)); | |||||
EXPECT_EQ (convert_cast<int8_t>(static_cast< uint8_t>(4)), static_cast<int8_t>(4)); | |||||
EXPECT_EQ (convert_cast<int8_t>(static_cast<uint16_t>(5)), static_cast<int8_t>(5)); | |||||
EXPECT_EQ (convert_cast<int8_t>(static_cast<uint32_t>(6)), static_cast<int8_t>(6)); | |||||
EXPECT_EQ (convert_cast<int8_t>(static_cast<uint64_t>(7)), static_cast<int8_t>(7)); | |||||
} | |||||
TEST(convert_cast_test, u8) | |||||
{ | |||||
EXPECT_THROW(convert_cast<uint8_t>(static_cast< int8_t>( -1)), convert_exception); | |||||
EXPECT_THROW(convert_cast<uint8_t>(static_cast< int16_t>(256)), convert_exception); | |||||
EXPECT_THROW(convert_cast<uint8_t>(static_cast< int32_t>( -1)), convert_exception); | |||||
EXPECT_THROW(convert_cast<uint8_t>(static_cast< int64_t>(256)), convert_exception); | |||||
EXPECT_THROW(convert_cast<uint8_t>(static_cast<uint16_t>(256)), convert_exception); | |||||
EXPECT_THROW(convert_cast<uint8_t>(static_cast<uint32_t>(256)), convert_exception); | |||||
EXPECT_THROW(convert_cast<uint8_t>(static_cast<uint64_t>(256)), convert_exception); | |||||
EXPECT_EQ (convert_cast<uint8_t>(static_cast< int8_t>(1)), static_cast<uint8_t>(1)); | |||||
EXPECT_EQ (convert_cast<uint8_t>(static_cast< int16_t>(2)), static_cast<uint8_t>(2)); | |||||
EXPECT_EQ (convert_cast<uint8_t>(static_cast< int32_t>(3)), static_cast<uint8_t>(3)); | |||||
EXPECT_EQ (convert_cast<uint8_t>(static_cast< int64_t>(4)), static_cast<uint8_t>(4)); | |||||
EXPECT_EQ (convert_cast<uint8_t>(static_cast< uint8_t>(4)), static_cast<uint8_t>(4)); | |||||
EXPECT_EQ (convert_cast<uint8_t>(static_cast<uint16_t>(5)), static_cast<uint8_t>(5)); | |||||
EXPECT_EQ (convert_cast<uint8_t>(static_cast<uint32_t>(6)), static_cast<uint8_t>(6)); | |||||
EXPECT_EQ (convert_cast<uint8_t>(static_cast<uint64_t>(7)), static_cast<uint8_t>(7)); | |||||
} | |||||
TEST(convert_cast_test, i16) | |||||
{ | |||||
EXPECT_THROW(convert_cast<int16_t>(static_cast< int32_t>(32'768)), convert_exception); | |||||
EXPECT_THROW(convert_cast<int16_t>(static_cast< int64_t>(32'768)), convert_exception); | |||||
EXPECT_THROW(convert_cast<int16_t>(static_cast<uint16_t>(32'768)), convert_exception); | |||||
EXPECT_THROW(convert_cast<int16_t>(static_cast<uint32_t>(32'768)), convert_exception); | |||||
EXPECT_THROW(convert_cast<int16_t>(static_cast<uint64_t>(32'768)), convert_exception); | |||||
EXPECT_EQ (convert_cast<int16_t>(static_cast< int8_t>(1)), static_cast<int16_t>(1)); | |||||
EXPECT_EQ (convert_cast<int16_t>(static_cast< int16_t>(2)), static_cast<int16_t>(2)); | |||||
EXPECT_EQ (convert_cast<int16_t>(static_cast< int32_t>(3)), static_cast<int16_t>(3)); | |||||
EXPECT_EQ (convert_cast<int16_t>(static_cast< int64_t>(4)), static_cast<int16_t>(4)); | |||||
EXPECT_EQ (convert_cast<int16_t>(static_cast< uint8_t>(4)), static_cast<int16_t>(4)); | |||||
EXPECT_EQ (convert_cast<int16_t>(static_cast<uint16_t>(5)), static_cast<int16_t>(5)); | |||||
EXPECT_EQ (convert_cast<int16_t>(static_cast<uint32_t>(6)), static_cast<int16_t>(6)); | |||||
EXPECT_EQ (convert_cast<int16_t>(static_cast<uint64_t>(7)), static_cast<int16_t>(7)); | |||||
} | |||||
TEST(convert_cast_test, u16) | |||||
{ | |||||
EXPECT_THROW(convert_cast<uint16_t>(static_cast< int8_t>( -1)), convert_exception); | |||||
EXPECT_THROW(convert_cast<uint16_t>(static_cast< int16_t>( -1)), convert_exception); | |||||
EXPECT_THROW(convert_cast<uint16_t>(static_cast< int32_t>(65'536)), convert_exception); | |||||
EXPECT_THROW(convert_cast<uint16_t>(static_cast< int64_t>(65'536)), convert_exception); | |||||
EXPECT_THROW(convert_cast<uint16_t>(static_cast<uint32_t>(65'536)), convert_exception); | |||||
EXPECT_THROW(convert_cast<uint16_t>(static_cast<uint64_t>(65'536)), convert_exception); | |||||
EXPECT_EQ (convert_cast<uint16_t>(static_cast< int8_t>(1)), static_cast<int16_t>(1)); | |||||
EXPECT_EQ (convert_cast<uint16_t>(static_cast< int16_t>(2)), static_cast<int16_t>(2)); | |||||
EXPECT_EQ (convert_cast<uint16_t>(static_cast< int32_t>(3)), static_cast<int16_t>(3)); | |||||
EXPECT_EQ (convert_cast<uint16_t>(static_cast< int64_t>(4)), static_cast<int16_t>(4)); | |||||
EXPECT_EQ (convert_cast<uint16_t>(static_cast< uint8_t>(4)), static_cast<int16_t>(4)); | |||||
EXPECT_EQ (convert_cast<uint16_t>(static_cast<uint16_t>(5)), static_cast<int16_t>(5)); | |||||
EXPECT_EQ (convert_cast<uint16_t>(static_cast<uint32_t>(6)), static_cast<int16_t>(6)); | |||||
EXPECT_EQ (convert_cast<uint16_t>(static_cast<uint64_t>(7)), static_cast<int16_t>(7)); | |||||
} | |||||
TEST(convert_cast_test, i32) | |||||
{ | |||||
EXPECT_THROW(convert_cast<int32_t>(static_cast< int64_t>(2'147'483'648)), convert_exception); | |||||
EXPECT_THROW(convert_cast<int32_t>(static_cast<uint32_t>(2'147'483'648)), convert_exception); | |||||
EXPECT_THROW(convert_cast<int32_t>(static_cast<uint64_t>(2'147'483'648)), convert_exception); | |||||
EXPECT_EQ (convert_cast<int32_t>(static_cast< int8_t>(1)), static_cast<int32_t>(1)); | |||||
EXPECT_EQ (convert_cast<int32_t>(static_cast< int16_t>(2)), static_cast<int32_t>(2)); | |||||
EXPECT_EQ (convert_cast<int32_t>(static_cast< int32_t>(3)), static_cast<int32_t>(3)); | |||||
EXPECT_EQ (convert_cast<int32_t>(static_cast< int64_t>(4)), static_cast<int32_t>(4)); | |||||
EXPECT_EQ (convert_cast<int32_t>(static_cast< uint8_t>(4)), static_cast<int32_t>(4)); | |||||
EXPECT_EQ (convert_cast<int32_t>(static_cast<uint16_t>(5)), static_cast<int32_t>(5)); | |||||
EXPECT_EQ (convert_cast<int32_t>(static_cast<uint32_t>(6)), static_cast<int32_t>(6)); | |||||
EXPECT_EQ (convert_cast<int32_t>(static_cast<uint64_t>(7)), static_cast<int32_t>(7)); | |||||
} | |||||
TEST(convert_cast_test, u32) | |||||
{ | |||||
EXPECT_THROW(convert_cast<uint32_t>(static_cast< int8_t>( -1)), convert_exception); | |||||
EXPECT_THROW(convert_cast<uint32_t>(static_cast< int16_t>( -1)), convert_exception); | |||||
EXPECT_THROW(convert_cast<uint32_t>(static_cast< int32_t>( -1)), convert_exception); | |||||
EXPECT_THROW(convert_cast<uint32_t>(static_cast< int64_t>(4'294'967'296)), convert_exception); | |||||
EXPECT_THROW(convert_cast<uint32_t>(static_cast<uint64_t>(4'294'967'296)), convert_exception); | |||||
EXPECT_EQ (convert_cast<uint32_t>(static_cast< int8_t>(1)), static_cast<int32_t>(1)); | |||||
EXPECT_EQ (convert_cast<uint32_t>(static_cast< int16_t>(2)), static_cast<int32_t>(2)); | |||||
EXPECT_EQ (convert_cast<uint32_t>(static_cast< int32_t>(3)), static_cast<int32_t>(3)); | |||||
EXPECT_EQ (convert_cast<uint32_t>(static_cast< int64_t>(4)), static_cast<int32_t>(4)); | |||||
EXPECT_EQ (convert_cast<uint32_t>(static_cast< uint8_t>(4)), static_cast<int32_t>(4)); | |||||
EXPECT_EQ (convert_cast<uint32_t>(static_cast<uint16_t>(5)), static_cast<int32_t>(5)); | |||||
EXPECT_EQ (convert_cast<uint32_t>(static_cast<uint32_t>(6)), static_cast<int32_t>(6)); | |||||
EXPECT_EQ (convert_cast<uint32_t>(static_cast<uint64_t>(7)), static_cast<int32_t>(7)); | |||||
} | |||||
TEST(convert_cast_test, i64) | |||||
{ | |||||
EXPECT_THROW(convert_cast<int64_t>(static_cast<uint64_t>(std::numeric_limits<int64_t>::max()) + 1), convert_exception); | |||||
EXPECT_EQ (convert_cast<int64_t>(static_cast< int8_t>(1)), static_cast<int64_t>(1)); | |||||
EXPECT_EQ (convert_cast<int64_t>(static_cast< int16_t>(2)), static_cast<int64_t>(2)); | |||||
EXPECT_EQ (convert_cast<int64_t>(static_cast< int32_t>(3)), static_cast<int64_t>(3)); | |||||
EXPECT_EQ (convert_cast<int64_t>(static_cast< int64_t>(4)), static_cast<int64_t>(4)); | |||||
EXPECT_EQ (convert_cast<int64_t>(static_cast< uint8_t>(4)), static_cast<int64_t>(4)); | |||||
EXPECT_EQ (convert_cast<int64_t>(static_cast<uint16_t>(5)), static_cast<int64_t>(5)); | |||||
EXPECT_EQ (convert_cast<int64_t>(static_cast<uint32_t>(6)), static_cast<int64_t>(6)); | |||||
EXPECT_EQ (convert_cast<int64_t>(static_cast<uint64_t>(7)), static_cast<int64_t>(7)); | |||||
} | |||||
TEST(convert_cast_test, u64) | |||||
{ | |||||
EXPECT_THROW(convert_cast<uint64_t>(static_cast< int8_t>( -1)), convert_exception); | |||||
EXPECT_THROW(convert_cast<uint64_t>(static_cast< int16_t>( -1)), convert_exception); | |||||
EXPECT_THROW(convert_cast<uint64_t>(static_cast< int32_t>( -1)), convert_exception); | |||||
EXPECT_EQ (convert_cast<uint64_t>(static_cast< int8_t>(1)), static_cast<int64_t>(1)); | |||||
EXPECT_EQ (convert_cast<uint64_t>(static_cast< int16_t>(2)), static_cast<int64_t>(2)); | |||||
EXPECT_EQ (convert_cast<uint64_t>(static_cast< int32_t>(3)), static_cast<int64_t>(3)); | |||||
EXPECT_EQ (convert_cast<uint64_t>(static_cast< int64_t>(4)), static_cast<int64_t>(4)); | |||||
EXPECT_EQ (convert_cast<uint64_t>(static_cast< uint8_t>(4)), static_cast<int64_t>(4)); | |||||
EXPECT_EQ (convert_cast<uint64_t>(static_cast<uint16_t>(5)), static_cast<int64_t>(5)); | |||||
EXPECT_EQ (convert_cast<uint64_t>(static_cast<uint32_t>(6)), static_cast<int64_t>(6)); | |||||
EXPECT_EQ (convert_cast<uint64_t>(static_cast<uint64_t>(7)), static_cast<int64_t>(7)); | |||||
} | |||||
TEST(convert_cast_test, enum) | |||||
{ | |||||
EXPECT_EQ(convert_cast< int8_t>( test_enum::test0), static_cast< int8_t>( 0)); | |||||
EXPECT_EQ(convert_cast<int16_t>( test_enum::test1), static_cast<int16_t>( 1)); | |||||
EXPECT_EQ(convert_cast<int32_t>( test_enum::test2), static_cast<int32_t>( 2)); | |||||
EXPECT_EQ(convert_cast<int64_t>(test_enum::test256), static_cast<int64_t>(256)); | |||||
EXPECT_EQ(convert_cast< uint8_t>( test_enum::test0), static_cast< uint8_t>( 0)); | |||||
EXPECT_EQ(convert_cast<uint16_t>( test_enum::test1), static_cast<uint16_t>( 1)); | |||||
EXPECT_EQ(convert_cast<uint32_t>( test_enum::test2), static_cast<uint32_t>( 2)); | |||||
EXPECT_EQ(convert_cast<uint64_t>(test_enum::test256), static_cast<uint64_t>(256)); | |||||
} |