tests/byte_tests.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //
   3 // Copyright (c) 2015 Microsoft Corporation. All rights reserved.
   4 //
   5 // This code is licensed under the MIT License (MIT).
   6 //
   7 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   8 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   9 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  10 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  11 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  12 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  13 // THE SOFTWARE.
  14 //
  15 ///////////////////////////////////////////////////////////////////////////////
  16
  17 #include <gtest/gtest.h>
  18
  19 #define GSL_USE_STD_BYTE 0
  20 #include <gsl/byte> // for to_byte, to_integer, byte, operator&, ope...
  21
  22 #include <type_traits>
  23 #include <utility>
  24
  25 using namespace std;
  26 using namespace gsl;
  27
  28 namespace
  29 {
  30 int modify_both(gsl::byte& b, int& i)
  31 {
  32     i = 10;
  33     b = to_byte<5>();
  34     return i;
  35 }
  36
  37 TEST(byte_tests, construction)
  38 {
  39     {
  40         const gsl::byte b = static_cast<gsl::byte>(4);
  41         EXPECT_TRUE(static_cast<unsigned char>(b) == 4);
  42     }
  43
  44     {
  45         const gsl::byte b = gsl::byte(12);
  46         EXPECT_TRUE(static_cast<unsigned char>(b) == 12);
  47     }
  48
  49     {
  50         const gsl::byte b = to_byte<12>();
  51         EXPECT_TRUE(static_cast<unsigned char>(b) == 12);
  52     }
  53     {
  54         const unsigned char uc = 12;
  55         const gsl::byte b = to_byte(uc);
  56         EXPECT_TRUE(static_cast<unsigned char>(b) == 12);
  57     }
  58
  59 #if defined(__cplusplus) && (__cplusplus >= 201703L)
  60     {
  61         const gsl::byte b{14};
  62         EXPECT_TRUE(static_cast<unsigned char>(b) == 14);
  63     }
  64 #endif
  65
  66 #ifdef CONFIRM_COMPILATION_ERRORS
  67     to_byte(char{});
  68     to_byte(3);
  69     to_byte(3u);
  70     to_byte<-1>();
  71     to_byte<256u>();
  72 #endif
  73 }
  74
  75 TEST(byte_tests, bitwise_operations)
  76 {
  77     const gsl::byte b = to_byte<0xFF>();
  78
  79     gsl::byte a = to_byte<0x00>();
  80     EXPECT_TRUE((b | a) == to_byte<0xFF>());
  81     EXPECT_TRUE(a == to_byte<0x00>());
  82
  83     a |= b;
  84     EXPECT_TRUE(a == to_byte<0xFF>());
  85
  86     a = to_byte<0x01>();
  87     EXPECT_TRUE((b & a) == to_byte<0x01>());
  88
  89     a &= b;
  90     EXPECT_TRUE(a == to_byte<0x01>());
  91
  92     EXPECT_TRUE((b ^ a) == to_byte<0xFE>());
  93
  94     EXPECT_TRUE(a == to_byte<0x01>());
  95     a ^= b;
  96     EXPECT_TRUE(a == to_byte<0xFE>());
  97
  98     a = to_byte<0x01>();
  99     EXPECT_TRUE(~a == to_byte<0xFE>());
 100
 101     a = to_byte<0xFF>();
 102     EXPECT_TRUE((a << 4) == to_byte<0xF0>());
 103     EXPECT_TRUE((a >> 4) == to_byte<0x0F>());
 104
 105     a <<= 4;
 106     EXPECT_TRUE(a == to_byte<0xF0>());
 107     a >>= 4;
 108     EXPECT_TRUE(a == to_byte<0x0F>());
 109 }
 110
 111 TEST(byte_tests, to_integer)
 112 {
 113     const gsl::byte b = to_byte<0x12>();
 114
 115     EXPECT_TRUE(0x12 == gsl::to_integer<char>(b));
 116     EXPECT_TRUE(0x12 == gsl::to_integer<short>(b));
 117     EXPECT_TRUE(0x12 == gsl::to_integer<long>(b));
 118     EXPECT_TRUE(0x12 == gsl::to_integer<long long>(b));
 119
 120     EXPECT_TRUE(0x12 == gsl::to_integer<unsigned char>(b));
 121     EXPECT_TRUE(0x12 == gsl::to_integer<unsigned short>(b));
 122     EXPECT_TRUE(0x12 == gsl::to_integer<unsigned long>(b));
 123     EXPECT_TRUE(0x12 == gsl::to_integer<unsigned long long>(b));
 124
 125     //      EXPECT_TRUE(0x12 == gsl::to_integer<float>(b));   // expect compile-time error
 126     //      EXPECT_TRUE(0x12 == gsl::to_integer<double>(b));  // expect compile-time error
 127 }
 128
 129 TEST(byte_tests, aliasing)
 130 {
 131     int i{0};
 132     const int res = modify_both(reinterpret_cast<gsl::byte&>(i), i);
 133     EXPECT_TRUE(res == i);
 134 }
 135
 136 #if __cplusplus >= 201703l
 137 using std::void_t;
 138 #else  // __cplusplus >= 201703l
 139 template <class...>
 140 using void_t = void;
 141 #endif // __cplusplus < 201703l
 142
 143 template <typename U, typename = void>
 144 static constexpr bool LShiftCompilesFor = false;
 145 template <typename U>
 146 static constexpr bool LShiftCompilesFor<
 147     U, void_t<decltype(gsl::operator<< <float>(declval<gsl::byte>(), declval<U>()))>> = true;
 148 static_assert(!LShiftCompilesFor<float>, "!LShiftCompilesFor<float>");
 149
 150 template <typename U, typename = void>
 151 static constexpr bool RShiftCompilesFor = false;
 152 template <typename U>
 153 static constexpr bool RShiftCompilesFor<
 154     U, void_t<decltype(gsl::operator>> <U>(declval<gsl::byte>(), declval<U>()))>> = true;
 155 static_assert(!RShiftCompilesFor<float>, "!RShiftCompilesFor<float>");
 156
 157 template <typename U, typename = void>
 158 static constexpr bool LShiftAssignCompilesFor = false;
 159 template <typename U>
 160 static constexpr bool LShiftAssignCompilesFor<
 161     U, void_t<decltype(gsl::operator<<= <U>(declval<gsl::byte&>(), declval<U>()))>> = true;
 162 static_assert(!LShiftAssignCompilesFor<float>, "!LShiftAssignCompilesFor<float>");
 163
 164 template <typename U, typename = void>
 165 static constexpr bool RShiftAssignCompilesFor = false;
 166 template <typename U>
 167 static constexpr bool RShiftAssignCompilesFor<
 168     U, void_t<decltype(gsl::operator>>= <U>(declval<gsl::byte&>(), declval<U>()))>> = true;
 169 static_assert(!RShiftAssignCompilesFor<float>, "!RShiftAssignCompilesFor<float>");
 170
 171 template <typename U, typename = void>
 172 static constexpr bool ToIntegerCompilesFor = false;
 173 template <typename U>
 174 static constexpr bool
 175     ToIntegerCompilesFor<U, void_t<decltype(gsl::to_integer<U>(gsl::byte{}))>> = true;
 176 static_assert(!ToIntegerCompilesFor<float>, "!ToIntegerCompilesFor<float>");
 177
 178 } // namespace