YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.

//  This source code is licensed under the BSD-style license found in the

//  LICENSE file in the root directory of this source tree. An additional grant

//  of patent rights can be found in the PATENTS file in the same directory.

//

// The following only applies to changes made to this file as part of YugaByte development.

//

// Portions Copyright (c) YugaByte, Inc.

//

// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except

// in compliance with the License.  You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software distributed under the License

// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express

// or implied.  See the License for the specific language governing permissions and limitations

// under the License.

//

// Copyright (c) 2011 The LevelDB Authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file. See the AUTHORS file for names of contributors.

#include "yb/rocksdb/util/coding.h"

#include <string>

#include <gtest/gtest.h>

namespace rocksdb {

class Coding { };

TEST(Coding, Fixed32) {

  std::string s;

  for (uint32_t v = 0; v < 100000; v++) {

    PutFixed32(&s, v);

  }

  const char* p = s.data();

  for (uint32_t v = 0; v < 100000; v++) {

    uint32_t actual = DecodeFixed32(p);

    ASSERT_EQ(v, actual);

    p += sizeof(uint32_t);

  }

}

TEST(Coding, Fixed64) {

  std::string s;

  for (int power = 0; power <= 63; power++) {

    uint64_t v = static_cast<uint64_t>(1) << power;

    PutFixed64(&s, v - 1);

    PutFixed64(&s, v + 0);

    PutFixed64(&s, v + 1);

  }

  const char* p = s.data();

  for (int power = 0; power <= 63; power++) {

    uint64_t v = static_cast<uint64_t>(1) << power;

    uint64_t actual = 0;

    actual = DecodeFixed64(p);

    ASSERT_EQ(v-1, actual);

    p += sizeof(uint64_t);

    actual = DecodeFixed64(p);

    ASSERT_EQ(v+0, actual);

    p += sizeof(uint64_t);

    actual = DecodeFixed64(p);

    ASSERT_EQ(v+1, actual);

    p += sizeof(uint64_t);

  }

}

// Test that encoding routines generate little-endian encodings

TEST(Coding, EncodingOutput) {

  std::string dst;

  PutFixed32(&dst, 0x04030201);

  ASSERT_EQ(4U, dst.size());

  ASSERT_EQ(0x01, static_cast<int>(dst[0]));

  ASSERT_EQ(0x02, static_cast<int>(dst[1]));

  ASSERT_EQ(0x03, static_cast<int>(dst[2]));

  ASSERT_EQ(0x04, static_cast<int>(dst[3]));

  dst.clear();

  PutFixed64(&dst, 0x0807060504030201ull);

  ASSERT_EQ(8U, dst.size());

  ASSERT_EQ(0x01, static_cast<int>(dst[0]));

  ASSERT_EQ(0x02, static_cast<int>(dst[1]));

  ASSERT_EQ(0x03, static_cast<int>(dst[2]));

  ASSERT_EQ(0x04, static_cast<int>(dst[3]));

  ASSERT_EQ(0x05, static_cast<int>(dst[4]));

  ASSERT_EQ(0x06, static_cast<int>(dst[5]));

  ASSERT_EQ(0x07, static_cast<int>(dst[6]));

  ASSERT_EQ(0x08, static_cast<int>(dst[7]));

}

TEST(Coding, Varint32) {

  std::string s;

  for (uint32_t i = 0; i < (32 * 32); i++) {

    uint32_t v = (i / 32) << (i % 32);

    PutVarint32(&s, v);

  }

  const char* p = s.data();

  const char* limit = p + s.size();

  for (uint32_t i = 0; i < (32 * 32); i++) {

    uint32_t expected = (i / 32) << (i % 32);

    uint32_t actual = 0;

    const char* start = p;

    p = GetVarint32Ptr(p, limit, &actual);

    ASSERT_TRUE(p != nullptr);

    ASSERT_EQ(expected, actual);

    ASSERT_EQ(VarintLength(actual), p - start);

  }

  ASSERT_EQ(p, s.data() + s.size());

}

TEST(Coding, Varint64) {

  // Construct the list of values to check

  std::vector<uint64_t> values;

  // Some special values

  values.push_back(0);

  values.push_back(100);

  values.push_back(~static_cast<uint64_t>(0));

  values.push_back(~static_cast<uint64_t>(0) - 1);

  for (uint32_t k = 0; k < 64; k++) {

    // Test values near powers of two

    const uint64_t power = 1ull << k;

    values.push_back(power);

    values.push_back(power-1);

    values.push_back(power+1);

  }

  std::string s;

  for (unsigned int i = 0; i < values.size(); i++) {

    PutVarint64(&s, values[i]);

    FastPutVarint64(&s, values[i]);

  }

  const char* p = s.data();

  const char* limit = p + s.size();

  for (unsigned int i = 0; i < values.size(); i++) {

    // Check decoding of both PutVarint64 and FastPutVarint64.

    for (int j = 0; j < 2; ++j) {

      ASSERT_TRUE(p < limit);

      uint64_t actual = 0;

      const char* start = p;

      p = GetVarint64Ptr(p, limit, &actual);

      ASSERT_TRUE(p != nullptr);

      ASSERT_EQ(values[i], actual);

      ASSERT_EQ(VarintLength(actual), p - start);

    }

  }

  ASSERT_EQ(p, limit);

}

TEST(Coding, Varint32Overflow) {

  uint32_t result;

  std::string input("\x81\x82\x83\x84\x85\x11");

  ASSERT_TRUE(GetVarint32Ptr(input.data(), input.data() + input.size(), &result)

              == nullptr);

}

TEST(Coding, Varint32Truncation) {

  uint32_t large_value = (1u << 31) + 100;

  std::string s;

  PutVarint32(&s, large_value);

  uint32_t result;

  for (unsigned int len = 0; len < s.size() - 1; len++) {

    ASSERT_TRUE(GetVarint32Ptr(s.data(), s.data() + len, &result) == nullptr);

  }

  ASSERT_TRUE(

      GetVarint32Ptr(s.data(), s.data() + s.size(), &result) != nullptr);

  ASSERT_EQ(large_value, result);

}

TEST(Coding, Varint64Overflow) {

  uint64_t result;

  std::string input("\x81\x82\x83\x84\x85\x81\x82\x83\x84\x85\x11");

  ASSERT_TRUE(GetVarint64Ptr(input.data(), input.data() + input.size(), &result)

              == nullptr);

}

TEST(Coding, Varint64Truncation) {

  uint64_t large_value = (1ull << 63) + 100ull;

  std::string s;

  PutVarint64(&s, large_value);

  uint64_t result;

  for (unsigned int len = 0; len < s.size() - 1; len++) {

    ASSERT_TRUE(GetVarint64Ptr(s.data(), s.data() + len, &result) == nullptr);

  }

  ASSERT_TRUE(

      GetVarint64Ptr(s.data(), s.data() + s.size(), &result) != nullptr);

  ASSERT_EQ(large_value, result);

}

TEST(Coding, Strings) {

  std::string s;

  PutLengthPrefixedSlice(&s, Slice(""));

  PutLengthPrefixedSlice(&s, Slice("foo"));

  PutLengthPrefixedSlice(&s, Slice("bar"));

  PutLengthPrefixedSlice(&s, Slice(std::string(200, 'x')));

  Slice input(s);

  Slice v;

  ASSERT_TRUE(GetLengthPrefixedSlice(&input, &v));

  ASSERT_EQ("", v.ToString());

  ASSERT_TRUE(GetLengthPrefixedSlice(&input, &v));

  ASSERT_EQ("foo", v.ToString());

  ASSERT_TRUE(GetLengthPrefixedSlice(&input, &v));

  ASSERT_EQ("bar", v.ToString());

  ASSERT_TRUE(GetLengthPrefixedSlice(&input, &v));

  ASSERT_EQ(std::string(200, 'x'), v.ToString());

  ASSERT_EQ("", input.ToString());

}

}  // namespace rocksdb

int main(int argc, char** argv) {

  ::testing::InitGoogleTest(&argc, argv);

  return RUN_ALL_TESTS();

}