import quincy 17.2.0

[ceph.git] / ceph / src / arrow / cpp / src / arrow / util / key_value_metadata_test.cc

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you 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 <algorithm>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>

#include <gtest/gtest.h>

#include "arrow/testing/gtest_util.h"
#include "arrow/util/key_value_metadata.h"

namespace arrow {

TEST(KeyValueMetadataTest, SimpleConstruction) {
  KeyValueMetadata metadata;
  ASSERT_EQ(0, metadata.size());
}

TEST(KeyValueMetadataTest, StringVectorConstruction) {
  std::vector<std::string> keys = {"foo", "bar"};
  std::vector<std::string> values = {"bizz", "buzz"};

  KeyValueMetadata metadata(keys, values);
  ASSERT_EQ("foo", metadata.key(0));
  ASSERT_EQ("bar", metadata.key(1));
  ASSERT_EQ("bizz", metadata.value(0));
  ASSERT_EQ("buzz", metadata.value(1));
  ASSERT_EQ(2, metadata.size());

  std::shared_ptr<KeyValueMetadata> metadata2 =
      key_value_metadata({"foo", "bar"}, {"bizz", "buzz"});
  ASSERT_TRUE(metadata.Equals(*metadata2));
}

TEST(KeyValueMetadataTest, StringMapConstruction) {
  std::unordered_map<std::string, std::string> pairs = {{"foo", "bizz"}, {"bar", "buzz"}};
  std::unordered_map<std::string, std::string> result_map;
  result_map.reserve(pairs.size());

  KeyValueMetadata metadata(pairs);
  metadata.ToUnorderedMap(&result_map);
  ASSERT_EQ(pairs, result_map);
  ASSERT_EQ(2, metadata.size());
}

TEST(KeyValueMetadataTest, StringAppend) {
  std::vector<std::string> keys = {"foo", "bar"};
  std::vector<std::string> values = {"bizz", "buzz"};

  KeyValueMetadata metadata(keys, values);
  ASSERT_EQ("foo", metadata.key(0));
  ASSERT_EQ("bar", metadata.key(1));
  ASSERT_EQ("bizz", metadata.value(0));
  ASSERT_EQ("buzz", metadata.value(1));
  ASSERT_EQ(2, metadata.size());

  metadata.Append("purple", "orange");
  metadata.Append("blue", "red");

  ASSERT_EQ("purple", metadata.key(2));
  ASSERT_EQ("blue", metadata.key(3));

  ASSERT_EQ("orange", metadata.value(2));
  ASSERT_EQ("red", metadata.value(3));
}

TEST(KeyValueMetadataTest, Copy) {
  std::vector<std::string> keys = {"foo", "bar"};
  std::vector<std::string> values = {"bizz", "buzz"};

  KeyValueMetadata metadata(keys, values);
  auto metadata2 = metadata.Copy();
  ASSERT_TRUE(metadata.Equals(*metadata2));
}

TEST(KeyValueMetadataTest, Merge) {
  std::vector<std::string> keys1 = {"foo", "bar"};
  std::vector<std::string> values1 = {"bizz", "buzz"};
  KeyValueMetadata metadata(keys1, values1);

  std::vector<std::string> keys2 = {"bar", "baz"};
  std::vector<std::string> values2 = {"bozz", "bezz"};
  KeyValueMetadata metadata2(keys2, values2);

  std::vector<std::string> keys3 = {"foo", "bar", "baz"};
  std::vector<std::string> values3 = {"bizz", "bozz", "bezz"};
  KeyValueMetadata expected(keys3, values3);

  auto result = metadata.Merge(metadata2);
  ASSERT_TRUE(result->Equals(expected));
}

TEST(KeyValueMetadataTest, FindKey) {
  std::vector<std::string> keys = {"foo", "bar"};
  std::vector<std::string> values = {"bizz", "buzz"};
  KeyValueMetadata metadata(keys, values);

  ASSERT_EQ(0, metadata.FindKey("foo"));
  ASSERT_EQ(1, metadata.FindKey("bar"));
  ASSERT_EQ(-1, metadata.FindKey("baz"));
}

TEST(KeyValueMetadataTest, Equals) {
  std::vector<std::string> keys = {"foo", "bar"};
  std::vector<std::string> values = {"bizz", "buzz"};

  KeyValueMetadata metadata(keys, values);
  KeyValueMetadata metadata2(keys, values);
  KeyValueMetadata metadata3(keys, {"buzz", "bizz"});

  ASSERT_TRUE(metadata.Equals(metadata2));
  ASSERT_FALSE(metadata.Equals(metadata3));

  // Key / value pairs are semantically unordered
  std::reverse(keys.begin(), keys.end());
  KeyValueMetadata metadata4(keys, values);
  std::reverse(values.begin(), values.end());
  KeyValueMetadata metadata5(keys, values);

  ASSERT_FALSE(metadata.Equals(metadata4));
  ASSERT_TRUE(metadata.Equals(metadata5));

  KeyValueMetadata metadata6({"foo"}, {"bizz"});
  ASSERT_FALSE(metadata.Equals(metadata6));
}

TEST(KeyValueMetadataTest, ToString) {
  std::vector<std::string> keys = {"foo", "bar"};
  std::vector<std::string> values = {"bizz", "buzz"};

  KeyValueMetadata metadata(keys, values);

  std::string result = metadata.ToString();
  std::string expected = R"(
-- metadata --
foo: bizz
bar: buzz)";

  ASSERT_EQ(expected, result);
}

TEST(KeyValueMetadataTest, SortedPairs) {
  std::vector<std::string> keys = {"foo", "bar"};
  std::vector<std::string> values = {"bizz", "buzz"};

  KeyValueMetadata metadata1(keys, values);
  std::reverse(keys.begin(), keys.end());
  KeyValueMetadata metadata2(keys, values);
  std::reverse(values.begin(), values.end());
  KeyValueMetadata metadata3(keys, values);

  std::vector<std::pair<std::string, std::string>> expected = {{"bar", "buzz"},
                                                               {"foo", "bizz"}};
  ASSERT_EQ(metadata1.sorted_pairs(), expected);
  ASSERT_EQ(metadata3.sorted_pairs(), expected);
  expected = {{"bar", "bizz"}, {"foo", "buzz"}};
  ASSERT_EQ(metadata2.sorted_pairs(), expected);
}

TEST(KeyValueMetadataTest, Delete) {
  std::vector<std::string> keys = {"aa", "bb", "cc", "dd", "ee", "ff", "gg"};
  std::vector<std::string> values = {"1", "2", "3", "4", "5", "6", "7"};

  {
    KeyValueMetadata metadata(keys, values);
    ASSERT_OK(metadata.Delete("cc"));
    ASSERT_TRUE(metadata.Equals(KeyValueMetadata({"aa", "bb", "dd", "ee", "ff", "gg"},
                                                 {"1", "2", "4", "5", "6", "7"})));

    ASSERT_OK(metadata.Delete(3));
    ASSERT_TRUE(metadata.Equals(
        KeyValueMetadata({"aa", "bb", "dd", "ff", "gg"}, {"1", "2", "4", "6", "7"})));
  }
  {
    KeyValueMetadata metadata(keys, values);
    ASSERT_OK(metadata.DeleteMany({2, 5}));
    ASSERT_TRUE(metadata.Equals(
        KeyValueMetadata({"aa", "bb", "dd", "ee", "gg"}, {"1", "2", "4", "5", "7"})));

    ASSERT_OK(metadata.DeleteMany({}));
    ASSERT_TRUE(metadata.Equals(
        KeyValueMetadata({"aa", "bb", "dd", "ee", "gg"}, {"1", "2", "4", "5", "7"})));
  }
  {
    KeyValueMetadata metadata(keys, values);
    ASSERT_OK(metadata.DeleteMany({0, 6, 5, 2}));
    ASSERT_TRUE(metadata.Equals(KeyValueMetadata({"bb", "dd", "ee"}, {"2", "4", "5"})));

    ASSERT_OK(metadata.DeleteMany({}));
    ASSERT_TRUE(metadata.Equals(KeyValueMetadata({"bb", "dd", "ee"}, {"2", "4", "5"})));
  }
}

}  // namespace arrow