base/big_endian_unittest.cc

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