big_endian_unittest.cc 8.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266
  1. // Copyright 2014 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "base/big_endian.h"
  5. #include <stdint.h>
  6. #include <limits>
  7. #include "base/strings/string_piece.h"
  8. #include "testing/gtest/include/gtest/gtest.h"
  9. namespace base {
  10. TEST(ReadBigEndianTest, ReadSignedPositive) {
  11. uint8_t data[] = {0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x1A, 0x2A};
  12. int8_t s8 = 0;
  13. int16_t s16 = 0;
  14. int32_t s32 = 0;
  15. int64_t s64 = 0;
  16. ReadBigEndian(data, &s8);
  17. ReadBigEndian(data, &s16);
  18. ReadBigEndian(data, &s32);
  19. ReadBigEndian(data, &s64);
  20. EXPECT_EQ(0x0A, s8);
  21. EXPECT_EQ(0x0A0B, s16);
  22. EXPECT_EQ(int32_t{0x0A0B0C0D}, s32);
  23. EXPECT_EQ(int64_t{0x0A0B0C0D0E0F1A2All}, s64);
  24. }
  25. TEST(ReadBigEndianTest, ReadSignedNegative) {
  26. uint8_t data[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
  27. int8_t s8 = 0;
  28. int16_t s16 = 0;
  29. int32_t s32 = 0;
  30. int64_t s64 = 0;
  31. ReadBigEndian(data, &s8);
  32. ReadBigEndian(data, &s16);
  33. ReadBigEndian(data, &s32);
  34. ReadBigEndian(data, &s64);
  35. EXPECT_EQ(-1, s8);
  36. EXPECT_EQ(-1, s16);
  37. EXPECT_EQ(-1, s32);
  38. EXPECT_EQ(-1, s64);
  39. }
  40. TEST(ReadBigEndianTest, ReadUnsignedSigned) {
  41. uint8_t data[] = {0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0, 0xA1, 0xA2};
  42. uint8_t u8 = 0;
  43. uint16_t u16 = 0;
  44. uint32_t u32 = 0;
  45. uint64_t u64 = 0;
  46. ReadBigEndian(data, &u8);
  47. ReadBigEndian(data, &u16);
  48. ReadBigEndian(data, &u32);
  49. ReadBigEndian(data, &u64);
  50. EXPECT_EQ(0xA0, u8);
  51. EXPECT_EQ(0xA0B0, u16);
  52. EXPECT_EQ(0xA0B0C0D0, u32);
  53. EXPECT_EQ(0xA0B0C0D0E0F0A1A2ull, u64);
  54. }
  55. TEST(ReadBigEndianTest, TryAll16BitValues) {
  56. using signed_type = int16_t;
  57. uint8_t data[sizeof(signed_type)];
  58. for (int i = std::numeric_limits<signed_type>::min();
  59. i <= std::numeric_limits<signed_type>::max(); i++) {
  60. signed_type expected = i;
  61. signed_type actual = 0;
  62. WriteBigEndian(reinterpret_cast<char*>(data), expected);
  63. ReadBigEndian(data, &actual);
  64. EXPECT_EQ(expected, actual);
  65. }
  66. }
  67. TEST(BigEndianReaderTest, ReadsValues) {
  68. uint8_t data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xA,
  69. 0xB, 0xC, 0xD, 0xE, 0xF, 0x1A, 0x2B, 0x3C, 0x4D, 0x5E};
  70. char buf[2];
  71. uint8_t u8;
  72. uint16_t u16;
  73. uint32_t u32;
  74. uint64_t u64;
  75. base::StringPiece piece;
  76. BigEndianReader reader(data, sizeof(data));
  77. EXPECT_TRUE(reader.Skip(2));
  78. EXPECT_EQ(data + 2, reader.ptr());
  79. EXPECT_EQ(reader.remaining(), sizeof(data) - 2);
  80. EXPECT_TRUE(reader.ReadBytes(buf, sizeof(buf)));
  81. EXPECT_EQ(0x2, buf[0]);
  82. EXPECT_EQ(0x3, buf[1]);
  83. EXPECT_TRUE(reader.ReadU8(&u8));
  84. EXPECT_EQ(0x4, u8);
  85. EXPECT_TRUE(reader.ReadU16(&u16));
  86. EXPECT_EQ(0x0506, u16);
  87. EXPECT_TRUE(reader.ReadU32(&u32));
  88. EXPECT_EQ(0x0708090Au, u32);
  89. EXPECT_TRUE(reader.ReadU64(&u64));
  90. EXPECT_EQ(0x0B0C0D0E0F1A2B3Cllu, u64);
  91. base::StringPiece expected(reinterpret_cast<const char*>(reader.ptr()), 2);
  92. EXPECT_TRUE(reader.ReadPiece(&piece, 2));
  93. EXPECT_EQ(2u, piece.size());
  94. EXPECT_EQ(expected.data(), piece.data());
  95. }
  96. TEST(BigEndianReaderTest, ReadsLengthPrefixedValues) {
  97. {
  98. uint8_t u8_prefixed_data[] = {8, 8, 9, 0xA, 0xB, 0xC, 0xD,
  99. 0xE, 0xF, 0x1A, 0x2B, 0x3C, 0x4D, 0x5E};
  100. BigEndianReader reader(u8_prefixed_data, sizeof(u8_prefixed_data));
  101. base::StringPiece piece;
  102. ASSERT_TRUE(reader.ReadU8LengthPrefixed(&piece));
  103. // |reader| should skip both a u8 and the length-8 length-prefixed field.
  104. EXPECT_EQ(reader.ptr(), u8_prefixed_data + 9);
  105. EXPECT_EQ(piece.size(), 8u);
  106. EXPECT_EQ(reinterpret_cast<const uint8_t*>(piece.data()),
  107. u8_prefixed_data + 1);
  108. }
  109. {
  110. uint8_t u16_prefixed_data[] = {0, 8, 0xD, 0xE, 0xF,
  111. 0x1A, 0x2B, 0x3C, 0x4D, 0x5E};
  112. BigEndianReader reader(u16_prefixed_data, sizeof(u16_prefixed_data));
  113. base::StringPiece piece;
  114. ASSERT_TRUE(reader.ReadU16LengthPrefixed(&piece));
  115. // |reader| should skip both a u16 and the length-8 length-prefixed field.
  116. EXPECT_EQ(reader.ptr(), u16_prefixed_data + 10);
  117. EXPECT_EQ(piece.size(), 8u);
  118. EXPECT_EQ(reinterpret_cast<const uint8_t*>(piece.data()),
  119. u16_prefixed_data + 2);
  120. // With no data left, we shouldn't be able to
  121. // read another u8 length prefix (or a u16 length prefix,
  122. // for that matter).
  123. EXPECT_FALSE(reader.ReadU8LengthPrefixed(&piece));
  124. EXPECT_FALSE(reader.ReadU16LengthPrefixed(&piece));
  125. }
  126. {
  127. // Make sure there's no issue reading a zero-value length prefix.
  128. uint8_t u16_prefixed_data[3] = {};
  129. BigEndianReader reader(u16_prefixed_data, sizeof(u16_prefixed_data));
  130. base::StringPiece piece;
  131. ASSERT_TRUE(reader.ReadU16LengthPrefixed(&piece));
  132. EXPECT_EQ(reader.ptr(), u16_prefixed_data + 2);
  133. EXPECT_EQ(reinterpret_cast<const uint8_t*>(piece.data()),
  134. u16_prefixed_data + 2);
  135. EXPECT_EQ(piece.size(), 0u);
  136. }
  137. }
  138. TEST(BigEndianReaderTest, LengthPrefixedReadsFailGracefully) {
  139. // We can't read 0xF (or, for that matter, 0xF8) bytes after the length
  140. // prefix: there isn't enough data.
  141. uint8_t data[] = {0xF, 8, 9, 0xA, 0xB, 0xC, 0xD,
  142. 0xE, 0xF, 0x1A, 0x2B, 0x3C, 0x4D, 0x5E};
  143. BigEndianReader reader(data, sizeof(data));
  144. base::StringPiece piece;
  145. EXPECT_FALSE(reader.ReadU8LengthPrefixed(&piece));
  146. EXPECT_EQ(data, reader.ptr());
  147. EXPECT_FALSE(reader.ReadU16LengthPrefixed(&piece));
  148. EXPECT_EQ(data, reader.ptr());
  149. }
  150. TEST(BigEndianReaderTest, RespectsLength) {
  151. uint8_t data[8];
  152. char buf[2];
  153. uint8_t u8;
  154. uint16_t u16;
  155. uint32_t u32;
  156. uint64_t u64;
  157. base::StringPiece piece;
  158. BigEndianReader reader(data, sizeof(data));
  159. // 8 left
  160. EXPECT_FALSE(reader.Skip(9));
  161. EXPECT_TRUE(reader.Skip(1));
  162. // 7 left
  163. EXPECT_FALSE(reader.ReadU64(&u64));
  164. EXPECT_TRUE(reader.Skip(4));
  165. // 3 left
  166. EXPECT_FALSE(reader.ReadU32(&u32));
  167. EXPECT_FALSE(reader.ReadPiece(&piece, 4));
  168. EXPECT_TRUE(reader.Skip(2));
  169. // 1 left
  170. EXPECT_FALSE(reader.ReadU16(&u16));
  171. EXPECT_FALSE(reader.ReadBytes(buf, 2));
  172. EXPECT_TRUE(reader.Skip(1));
  173. // 0 left
  174. EXPECT_FALSE(reader.ReadU8(&u8));
  175. EXPECT_EQ(0u, reader.remaining());
  176. }
  177. TEST(BigEndianReaderTest, SafePointerMath) {
  178. uint8_t data[] = "foo";
  179. BigEndianReader reader(data, sizeof(data));
  180. // The test should fail without ever dereferencing the |dummy_buf| pointer.
  181. char* dummy_buf = reinterpret_cast<char*>(0xdeadbeef);
  182. // Craft an extreme length value that would cause |reader.data() + len| to
  183. // overflow.
  184. size_t extreme_length = std::numeric_limits<size_t>::max() - 1;
  185. base::StringPiece piece;
  186. EXPECT_FALSE(reader.Skip(extreme_length));
  187. EXPECT_FALSE(reader.ReadBytes(dummy_buf, extreme_length));
  188. EXPECT_FALSE(reader.ReadPiece(&piece, extreme_length));
  189. }
  190. TEST(BigEndianWriterTest, WritesValues) {
  191. char expected[] = { 0, 0, 2, 3, 4, 5, 6, 7, 8, 9, 0xA, 0xB, 0xC, 0xD, 0xE,
  192. 0xF, 0x1A, 0x2B, 0x3C };
  193. char data[sizeof(expected)];
  194. char buf[] = { 0x2, 0x3 };
  195. memset(data, 0, sizeof(data));
  196. BigEndianWriter writer(data, sizeof(data));
  197. EXPECT_TRUE(writer.Skip(2));
  198. EXPECT_TRUE(writer.WriteBytes(buf, sizeof(buf)));
  199. EXPECT_TRUE(writer.WriteU8(0x4));
  200. EXPECT_TRUE(writer.WriteU16(0x0506));
  201. EXPECT_TRUE(writer.WriteU32(0x0708090A));
  202. EXPECT_TRUE(writer.WriteU64(0x0B0C0D0E0F1A2B3Cllu));
  203. EXPECT_EQ(0, memcmp(expected, data, sizeof(expected)));
  204. }
  205. TEST(BigEndianWriterTest, RespectsLength) {
  206. char data[8];
  207. char buf[2];
  208. uint8_t u8 = 0;
  209. uint16_t u16 = 0;
  210. uint32_t u32 = 0;
  211. uint64_t u64 = 0;
  212. BigEndianWriter writer(data, sizeof(data));
  213. // 8 left
  214. EXPECT_FALSE(writer.Skip(9));
  215. EXPECT_TRUE(writer.Skip(1));
  216. // 7 left
  217. EXPECT_FALSE(writer.WriteU64(u64));
  218. EXPECT_TRUE(writer.Skip(4));
  219. // 3 left
  220. EXPECT_FALSE(writer.WriteU32(u32));
  221. EXPECT_TRUE(writer.Skip(2));
  222. // 1 left
  223. EXPECT_FALSE(writer.WriteU16(u16));
  224. EXPECT_FALSE(writer.WriteBytes(buf, 2));
  225. EXPECT_TRUE(writer.Skip(1));
  226. // 0 left
  227. EXPECT_FALSE(writer.WriteU8(u8));
  228. EXPECT_EQ(0u, writer.remaining());
  229. }
  230. TEST(BigEndianWriterTest, SafePointerMath) {
  231. char data[3];
  232. BigEndianWriter writer(data, sizeof(data));
  233. // The test should fail without ever dereferencing the |dummy_buf| pointer.
  234. const char* dummy_buf = reinterpret_cast<const char*>(0xdeadbeef);
  235. // Craft an extreme length value that would cause |reader.data() + len| to
  236. // overflow.
  237. size_t extreme_length = std::numeric_limits<size_t>::max() - 1;
  238. EXPECT_FALSE(writer.Skip(extreme_length));
  239. EXPECT_FALSE(writer.WriteBytes(dummy_buf, extreme_length));
  240. }
  241. } // namespace base