base/big_endian_unittest.cc

   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
   5 #include "base/big_endian.h"
   6
   7 #include <stdint.h>
   8
   9 #include "base/strings/string_piece.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 namespace base {
  13
  14 TEST(BigEndianReaderTest, ReadsValues) {
  15   char data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF,
  16                   0x1A, 0x2B, 0x3C, 0x4D, 0x5E };
  17   char buf[2];
  18   uint8_t u8;
  19   uint16_t u16;
  20   uint32_t u32;
  21   uint64_t u64;
  22   base::StringPiece piece;
  23   BigEndianReader reader(data, sizeof(data));
  24
  25   EXPECT_TRUE(reader.Skip(2));
  26   EXPECT_EQ(data + 2, reader.ptr());
  27   EXPECT_EQ(reader.remaining(), sizeof(data) - 2);
  28   EXPECT_TRUE(reader.ReadBytes(buf, sizeof(buf)));
  29   EXPECT_EQ(0x2, buf[0]);
  30   EXPECT_EQ(0x3, buf[1]);
  31   EXPECT_TRUE(reader.ReadU8(&u8));
  32   EXPECT_EQ(0x4, u8);
  33   EXPECT_TRUE(reader.ReadU16(&u16));
  34   EXPECT_EQ(0x0506, u16);
  35   EXPECT_TRUE(reader.ReadU32(&u32));
  36   EXPECT_EQ(0x0708090Au, u32);
  37   EXPECT_TRUE(reader.ReadU64(&u64));
  38   EXPECT_EQ(0x0B0C0D0E0F1A2B3Cllu, u64);
  39   base::StringPiece expected(reader.ptr(), 2);
  40   EXPECT_TRUE(reader.ReadPiece(&piece, 2));
  41   EXPECT_EQ(2u, piece.size());
  42   EXPECT_EQ(expected.data(), piece.data());
  43 }
  44
  45 TEST(BigEndianReaderTest, ReadsLengthPrefixedValues) {
  46   {
  47     char u8_prefixed_data[] = {8,   8,   9,    0xA,  0xB,  0xC,  0xD,
  48                                0xE, 0xF, 0x1A, 0x2B, 0x3C, 0x4D, 0x5E};
  49     BigEndianReader reader(u8_prefixed_data, sizeof(u8_prefixed_data));
  50
  51     base::StringPiece piece;
  52     ASSERT_TRUE(reader.ReadU8LengthPrefixed(&piece));
  53     // |reader| should skip both a u8 and the length-8 length-prefixed field.
  54     EXPECT_EQ(reader.ptr(), u8_prefixed_data + 9);
  55     EXPECT_EQ(piece.size(), 8u);
  56     EXPECT_EQ(piece.data(), u8_prefixed_data + 1);
  57   }
  58
  59   {
  60     char u16_prefixed_data[] = {0,    8,    0xD,  0xE,  0xF,
  61                                 0x1A, 0x2B, 0x3C, 0x4D, 0x5E};
  62     BigEndianReader reader(u16_prefixed_data, sizeof(u16_prefixed_data));
  63     base::StringPiece piece;
  64     ASSERT_TRUE(reader.ReadU16LengthPrefixed(&piece));
  65     // |reader| should skip both a u16 and the length-8 length-prefixed field.
  66     EXPECT_EQ(reader.ptr(), u16_prefixed_data + 10);
  67     EXPECT_EQ(piece.size(), 8u);
  68     EXPECT_EQ(piece.data(), u16_prefixed_data + 2);
  69
  70     // With no data left, we shouldn't be able to
  71     // read another u8 length prefix (or a u16 length prefix,
  72     // for that matter).
  73     EXPECT_FALSE(reader.ReadU8LengthPrefixed(&piece));
  74     EXPECT_FALSE(reader.ReadU16LengthPrefixed(&piece));
  75   }
  76
  77   {
  78     // Make sure there's no issue reading a zero-value length prefix.
  79     char u16_prefixed_data[3] = {};
  80     BigEndianReader reader(u16_prefixed_data, sizeof(u16_prefixed_data));
  81     base::StringPiece piece;
  82     ASSERT_TRUE(reader.ReadU16LengthPrefixed(&piece));
  83     EXPECT_EQ(reader.ptr(), u16_prefixed_data + 2);
  84     EXPECT_EQ(piece.data(), u16_prefixed_data + 2);
  85     EXPECT_EQ(piece.size(), 0u);
  86   }
  87 }
  88
  89 TEST(BigEndianReaderTest, LengthPrefixedReadsFailGracefully) {
  90   // We can't read 0xF (or, for that matter, 0xF8) bytes after the length
  91   // prefix: there isn't enough data.
  92   char data[] = {0xF, 8,   9,    0xA,  0xB,  0xC,  0xD,
  93                  0xE, 0xF, 0x1A, 0x2B, 0x3C, 0x4D, 0x5E};
  94   BigEndianReader reader(data, sizeof(data));
  95   base::StringPiece piece;
  96   EXPECT_FALSE(reader.ReadU8LengthPrefixed(&piece));
  97   EXPECT_EQ(data, reader.ptr());
  98
  99   EXPECT_FALSE(reader.ReadU16LengthPrefixed(&piece));
 100   EXPECT_EQ(data, reader.ptr());
 101 }
 102
 103 TEST(BigEndianReaderTest, RespectsLength) {
 104   char data[8];
 105   char buf[2];
 106   uint8_t u8;
 107   uint16_t u16;
 108   uint32_t u32;
 109   uint64_t u64;
 110   base::StringPiece piece;
 111   BigEndianReader reader(data, sizeof(data));
 112   // 8 left
 113   EXPECT_FALSE(reader.Skip(9));
 114   EXPECT_TRUE(reader.Skip(1));
 115   // 7 left
 116   EXPECT_FALSE(reader.ReadU64(&u64));
 117   EXPECT_TRUE(reader.Skip(4));
 118   // 3 left
 119   EXPECT_FALSE(reader.ReadU32(&u32));
 120   EXPECT_FALSE(reader.ReadPiece(&piece, 4));
 121   EXPECT_TRUE(reader.Skip(2));
 122   // 1 left
 123   EXPECT_FALSE(reader.ReadU16(&u16));
 124   EXPECT_FALSE(reader.ReadBytes(buf, 2));
 125   EXPECT_TRUE(reader.Skip(1));
 126   // 0 left
 127   EXPECT_FALSE(reader.ReadU8(&u8));
 128   EXPECT_EQ(0u, reader.remaining());
 129 }
 130
 131 TEST(BigEndianWriterTest, WritesValues) {
 132   char expected[] = { 0, 0, 2, 3, 4, 5, 6, 7, 8, 9, 0xA, 0xB, 0xC, 0xD, 0xE,
 133                       0xF, 0x1A, 0x2B, 0x3C };
 134   char data[sizeof(expected)];
 135   char buf[] = { 0x2, 0x3 };
 136   memset(data, 0, sizeof(data));
 137   BigEndianWriter writer(data, sizeof(data));
 138
 139   EXPECT_TRUE(writer.Skip(2));
 140   EXPECT_TRUE(writer.WriteBytes(buf, sizeof(buf)));
 141   EXPECT_TRUE(writer.WriteU8(0x4));
 142   EXPECT_TRUE(writer.WriteU16(0x0506));
 143   EXPECT_TRUE(writer.WriteU32(0x0708090A));
 144   EXPECT_TRUE(writer.WriteU64(0x0B0C0D0E0F1A2B3Cllu));
 145   EXPECT_EQ(0, memcmp(expected, data, sizeof(expected)));
 146 }
 147
 148 TEST(BigEndianWriterTest, RespectsLength) {
 149   char data[8];
 150   char buf[2];
 151   uint8_t u8 = 0;
 152   uint16_t u16 = 0;
 153   uint32_t u32 = 0;
 154   uint64_t u64 = 0;
 155   BigEndianWriter writer(data, sizeof(data));
 156   // 8 left
 157   EXPECT_FALSE(writer.Skip(9));
 158   EXPECT_TRUE(writer.Skip(1));
 159   // 7 left
 160   EXPECT_FALSE(writer.WriteU64(u64));
 161   EXPECT_TRUE(writer.Skip(4));
 162   // 3 left
 163   EXPECT_FALSE(writer.WriteU32(u32));
 164   EXPECT_TRUE(writer.Skip(2));
 165   // 1 left
 166   EXPECT_FALSE(writer.WriteU16(u16));
 167   EXPECT_FALSE(writer.WriteBytes(buf, 2));
 168   EXPECT_TRUE(writer.Skip(1));
 169   // 0 left
 170   EXPECT_FALSE(writer.WriteU8(u8));
 171   EXPECT_EQ(0u, writer.remaining());
 172 }
 173
 174 }  // namespace base