YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

// 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.

//

#include <string>

#include <unordered_map>

#include <gtest/gtest.h>

#include "yb/util/byte_buffer.h"

#include "yb/util/random_util.h"

using namespace std::literals;

namespace yb {

using Buffer = ByteBuffer<8>;

TEST(ByteBufferTest, Assign) {

  std::string str = "source_string"s;

  Buffer buffer(str);

  Buffer copy(buffer);

  ASSERT_EQ(buffer, copy);

  copy = buffer;

  Buffer moved(std::move(buffer));

  ASSERT_TRUE(buffer.empty());

  ASSERT_EQ(moved, copy);

  moved = std::move(copy);

  ASSERT_TRUE(copy.empty());

  buffer.Assign(str);

  ASSERT_EQ(buffer, moved);

}

TEST(ByteBufferTest, Append) {

  constexpr int kStringLen = 128;

  constexpr int kIterations = 1000;

  std::string str = RandomHumanReadableString(kStringLen);

  for (int i = kIterations; i-- > 0;) {

    Buffer buffer;

    while (buffer.size() < str.size()) {

      size_t len = RandomUniformInt<size_t>(0, str.size() - buffer.size());

      buffer.append(Slice(str.c_str() + buffer.size(), len));

      ASSERT_EQ(buffer.AsSlice(), Slice(str).Prefix(buffer.size()));

      if (len == 0) {

        buffer.PushBack(str[buffer.size()]);

        ASSERT_EQ(buffer.AsSlice(), Slice(str).Prefix(buffer.size()));

      }

    }

  }

}

template <class Map>

void TestMap() {

  std::vector<std::pair<std::string, int>> entries = {

      { "one"s, 1 },

      { "two"s, 2 },

      { "three"s, 3 },

  };

  Map m;

  for (const auto& p : entries) {

    ASSERT_TRUE(m.emplace(Buffer(p.first), p.second).second);

  }

  for (const auto& p : entries) {

    ASSERT_EQ(m[Buffer(p.first)], p.second);

  }

}

_ZN2yb7TestMapINSt3__13mapINS_10ByteBufferILm8EEEiNS1_4lessIS4_EENS1_9allocatorINS1_4pairIKS4_iEEEEEEEEvv

Line

Count

Source

61

1

void TestMap() {

62

1

  std::vector<std::pair<std::string, int>> entries = {

63

1

      { "one"s, 1 },

64

1

      { "two"s, 2 },

65

1

      { "three"s, 3 },

66

1

  };

67

68

1

  Map m;

69

3

  for (const auto& p : entries) {

70

3

    ASSERT_TRUE(m.emplace(Buffer(p.first), p.second).second);

71

3

  }

72

73

3

  for (const auto& p : entries) {

74

3

    ASSERT_EQ(m[Buffer(p.first)], p.second);

75

3

  }

76

1

}

_ZN2yb7TestMapINSt3__113unordered_mapINS_10ByteBufferILm8EEEiNS_14ByteBufferHashENS1_8equal_toIS4_EENS1_9allocatorINS1_4pairIKS4_iEEEEEEEEvv

Line

Count

Source

61

1

void TestMap() {

62

1

  std::vector<std::pair<std::string, int>> entries = {

63

1

      { "one"s, 1 },

64

1

      { "two"s, 2 },

65

1

      { "three"s, 3 },

66

1

  };

67

68

1

  Map m;

69

3

  for (const auto& p : entries) {

70

3

    ASSERT_TRUE(m.emplace(Buffer(p.first), p.second).second);

71

3

  }

72

73

3

  for (const auto& p : entries) {

74

3

    ASSERT_EQ(m[Buffer(p.first)], p.second);

75

3

  }

76

1

}

TEST(ByteBufferTest, Map) {

  TestMap<std::map<Buffer, int>>();

  TestMap<std::unordered_map<Buffer, int, ByteBufferHash>>();

}

} // namespace yb