ceph/src/rocksdb/util/coding_test.cc

   1 //  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
   2 //  This source code is licensed under the BSD-style license found in the
   3 //  LICENSE file in the root directory of this source tree. An additional grant
   4 //  of patent rights can be found in the PATENTS file in the same directory.
   5 //
   6 // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
   7 // Use of this source code is governed by a BSD-style license that can be
   8 // found in the LICENSE file. See the AUTHORS file for names of contributors.
   9
  10 #include "util/coding.h"
  11
  12 #include "util/testharness.h"
  13
  14 namespace rocksdb {
  15
  16 class Coding { };
  17
  18 TEST(Coding, Fixed32) {
  19   std::string s;
  20   for (uint32_t v = 0; v < 100000; v++) {
  21     PutFixed32(&s, v);
  22   }
  23
  24   const char* p = s.data();
  25   for (uint32_t v = 0; v < 100000; v++) {
  26     uint32_t actual = DecodeFixed32(p);
  27     ASSERT_EQ(v, actual);
  28     p += sizeof(uint32_t);
  29   }
  30 }
  31
  32 TEST(Coding, Fixed64) {
  33   std::string s;
  34   for (int power = 0; power <= 63; power++) {
  35     uint64_t v = static_cast<uint64_t>(1) << power;
  36     PutFixed64(&s, v - 1);
  37     PutFixed64(&s, v + 0);
  38     PutFixed64(&s, v + 1);
  39   }
  40
  41   const char* p = s.data();
  42   for (int power = 0; power <= 63; power++) {
  43     uint64_t v = static_cast<uint64_t>(1) << power;
  44     uint64_t actual = 0;
  45     actual = DecodeFixed64(p);
  46     ASSERT_EQ(v-1, actual);
  47     p += sizeof(uint64_t);
  48
  49     actual = DecodeFixed64(p);
  50     ASSERT_EQ(v+0, actual);
  51     p += sizeof(uint64_t);
  52
  53     actual = DecodeFixed64(p);
  54     ASSERT_EQ(v+1, actual);
  55     p += sizeof(uint64_t);
  56   }
  57 }
  58
  59 // Test that encoding routines generate little-endian encodings
  60 TEST(Coding, EncodingOutput) {
  61   std::string dst;
  62   PutFixed32(&dst, 0x04030201);
  63   ASSERT_EQ(4U, dst.size());
  64   ASSERT_EQ(0x01, static_cast<int>(dst[0]));
  65   ASSERT_EQ(0x02, static_cast<int>(dst[1]));
  66   ASSERT_EQ(0x03, static_cast<int>(dst[2]));
  67   ASSERT_EQ(0x04, static_cast<int>(dst[3]));
  68
  69   dst.clear();
  70   PutFixed64(&dst, 0x0807060504030201ull);
  71   ASSERT_EQ(8U, dst.size());
  72   ASSERT_EQ(0x01, static_cast<int>(dst[0]));
  73   ASSERT_EQ(0x02, static_cast<int>(dst[1]));
  74   ASSERT_EQ(0x03, static_cast<int>(dst[2]));
  75   ASSERT_EQ(0x04, static_cast<int>(dst[3]));
  76   ASSERT_EQ(0x05, static_cast<int>(dst[4]));
  77   ASSERT_EQ(0x06, static_cast<int>(dst[5]));
  78   ASSERT_EQ(0x07, static_cast<int>(dst[6]));
  79   ASSERT_EQ(0x08, static_cast<int>(dst[7]));
  80 }
  81
  82 TEST(Coding, Varint32) {
  83   std::string s;
  84   for (uint32_t i = 0; i < (32 * 32); i++) {
  85     uint32_t v = (i / 32) << (i % 32);
  86     PutVarint32(&s, v);
  87   }
  88
  89   const char* p = s.data();
  90   const char* limit = p + s.size();
  91   for (uint32_t i = 0; i < (32 * 32); i++) {
  92     uint32_t expected = (i / 32) << (i % 32);
  93     uint32_t actual = 0;
  94     const char* start = p;
  95     p = GetVarint32Ptr(p, limit, &actual);
  96     ASSERT_TRUE(p != nullptr);
  97     ASSERT_EQ(expected, actual);
  98     ASSERT_EQ(VarintLength(actual), p - start);
  99   }
 100   ASSERT_EQ(p, s.data() + s.size());
 101 }
 102
 103 TEST(Coding, Varint64) {
 104   // Construct the list of values to check
 105   std::vector<uint64_t> values;
 106   // Some special values
 107   values.push_back(0);
 108   values.push_back(100);
 109   values.push_back(~static_cast<uint64_t>(0));
 110   values.push_back(~static_cast<uint64_t>(0) - 1);
 111   for (uint32_t k = 0; k < 64; k++) {
 112     // Test values near powers of two
 113     const uint64_t power = 1ull << k;
 114     values.push_back(power);
 115     values.push_back(power-1);
 116     values.push_back(power+1);
 117   };
 118
 119   std::string s;
 120   for (unsigned int i = 0; i < values.size(); i++) {
 121     PutVarint64(&s, values[i]);
 122   }
 123
 124   const char* p = s.data();
 125   const char* limit = p + s.size();
 126   for (unsigned int i = 0; i < values.size(); i++) {
 127     ASSERT_TRUE(p < limit);
 128     uint64_t actual = 0;
 129     const char* start = p;
 130     p = GetVarint64Ptr(p, limit, &actual);
 131     ASSERT_TRUE(p != nullptr);
 132     ASSERT_EQ(values[i], actual);
 133     ASSERT_EQ(VarintLength(actual), p - start);
 134   }
 135   ASSERT_EQ(p, limit);
 136
 137 }
 138
 139 TEST(Coding, Varint32Overflow) {
 140   uint32_t result;
 141   std::string input("\x81\x82\x83\x84\x85\x11");
 142   ASSERT_TRUE(GetVarint32Ptr(input.data(), input.data() + input.size(), &result)
 143               == nullptr);
 144 }
 145
 146 TEST(Coding, Varint32Truncation) {
 147   uint32_t large_value = (1u << 31) + 100;
 148   std::string s;
 149   PutVarint32(&s, large_value);
 150   uint32_t result;
 151   for (unsigned int len = 0; len < s.size() - 1; len++) {
 152     ASSERT_TRUE(GetVarint32Ptr(s.data(), s.data() + len, &result) == nullptr);
 153   }
 154   ASSERT_TRUE(
 155       GetVarint32Ptr(s.data(), s.data() + s.size(), &result) != nullptr);
 156   ASSERT_EQ(large_value, result);
 157 }
 158
 159 TEST(Coding, Varint64Overflow) {
 160   uint64_t result;
 161   std::string input("\x81\x82\x83\x84\x85\x81\x82\x83\x84\x85\x11");
 162   ASSERT_TRUE(GetVarint64Ptr(input.data(), input.data() + input.size(), &result)
 163               == nullptr);
 164 }
 165
 166 TEST(Coding, Varint64Truncation) {
 167   uint64_t large_value = (1ull << 63) + 100ull;
 168   std::string s;
 169   PutVarint64(&s, large_value);
 170   uint64_t result;
 171   for (unsigned int len = 0; len < s.size() - 1; len++) {
 172     ASSERT_TRUE(GetVarint64Ptr(s.data(), s.data() + len, &result) == nullptr);
 173   }
 174   ASSERT_TRUE(
 175       GetVarint64Ptr(s.data(), s.data() + s.size(), &result) != nullptr);
 176   ASSERT_EQ(large_value, result);
 177 }
 178
 179 TEST(Coding, Strings) {
 180   std::string s;
 181   PutLengthPrefixedSlice(&s, Slice(""));
 182   PutLengthPrefixedSlice(&s, Slice("foo"));
 183   PutLengthPrefixedSlice(&s, Slice("bar"));
 184   PutLengthPrefixedSlice(&s, Slice(std::string(200, 'x')));
 185
 186   Slice input(s);
 187   Slice v;
 188   ASSERT_TRUE(GetLengthPrefixedSlice(&input, &v));
 189   ASSERT_EQ("", v.ToString());
 190   ASSERT_TRUE(GetLengthPrefixedSlice(&input, &v));
 191   ASSERT_EQ("foo", v.ToString());
 192   ASSERT_TRUE(GetLengthPrefixedSlice(&input, &v));
 193   ASSERT_EQ("bar", v.ToString());
 194   ASSERT_TRUE(GetLengthPrefixedSlice(&input, &v));
 195   ASSERT_EQ(std::string(200, 'x'), v.ToString());
 196   ASSERT_EQ("", input.ToString());
 197 }
 198
 199 }  // namespace rocksdb
 200
 201 int main(int argc, char** argv) {
 202   ::testing::InitGoogleTest(&argc, argv);
 203   return RUN_ALL_TESTS();
 204 }