mirror of https://github.com/grpc/grpc.git
Merge pull request #18052 from mhaidrygoog/xds_work
Support for LocalityMap for XDS LB policypull/18588/head
Moiz Haidry
6 years ago
committed by
GitHub
commit
5e26c4339d
19 changed files with 1403 additions and 198 deletions
@ -0,0 +1,419 @@ |
|||||||
|
/*
|
||||||
|
* |
||||||
|
* Copyright 2017 gRPC authors. |
||||||
|
* |
||||||
|
* 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. |
||||||
|
* |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef GRPC_CORE_LIB_GPRPP_MAP_H |
||||||
|
#define GRPC_CORE_LIB_GPRPP_MAP_H |
||||||
|
|
||||||
|
#include <grpc/support/port_platform.h> |
||||||
|
|
||||||
|
#include <string.h> |
||||||
|
#include <functional> |
||||||
|
#include <iterator> |
||||||
|
#include "src/core/lib/gpr/useful.h" |
||||||
|
#include "src/core/lib/gprpp/memory.h" |
||||||
|
#include "src/core/lib/gprpp/pair.h" |
||||||
|
|
||||||
|
namespace grpc_core { |
||||||
|
struct StringLess { |
||||||
|
bool operator()(const char* a, const char* b) const { |
||||||
|
return strcmp(a, b) < 0; |
||||||
|
} |
||||||
|
bool operator()(const UniquePtr<char>& k1, const UniquePtr<char>& k2) { |
||||||
|
return strcmp(k1.get(), k2.get()) < 0; |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
namespace testing { |
||||||
|
class MapTest; |
||||||
|
} |
||||||
|
|
||||||
|
// Alternative map implementation for grpc_core
|
||||||
|
template <class Key, class T, class Compare = std::less<Key>> |
||||||
|
class Map { |
||||||
|
public: |
||||||
|
typedef Key key_type; |
||||||
|
typedef T mapped_type; |
||||||
|
typedef Pair<key_type, mapped_type> value_type; |
||||||
|
typedef Compare key_compare; |
||||||
|
class iterator; |
||||||
|
|
||||||
|
~Map() { clear(); } |
||||||
|
|
||||||
|
T& operator[](key_type&& key); |
||||||
|
T& operator[](const key_type& key); |
||||||
|
iterator find(const key_type& k); |
||||||
|
size_t erase(const key_type& key); |
||||||
|
// Removes the current entry and points to the next one
|
||||||
|
iterator erase(iterator iter); |
||||||
|
|
||||||
|
size_t size() { return size_; } |
||||||
|
|
||||||
|
template <class... Args> |
||||||
|
Pair<iterator, bool> emplace(Args&&... args); |
||||||
|
|
||||||
|
Pair<iterator, bool> insert(value_type&& pair) { |
||||||
|
return emplace(std::move(pair)); |
||||||
|
} |
||||||
|
|
||||||
|
Pair<iterator, bool> insert(const value_type& pair) { return emplace(pair); } |
||||||
|
|
||||||
|
bool empty() const { return root_ == nullptr; } |
||||||
|
|
||||||
|
void clear() { |
||||||
|
auto iter = begin(); |
||||||
|
while (!empty()) { |
||||||
|
iter = erase(iter); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
iterator begin() { |
||||||
|
Entry* curr = GetMinEntry(root_); |
||||||
|
return iterator(this, curr); |
||||||
|
} |
||||||
|
|
||||||
|
iterator end() { return iterator(this, nullptr); } |
||||||
|
|
||||||
|
private: |
||||||
|
friend class testing::MapTest; |
||||||
|
struct Entry { |
||||||
|
explicit Entry(value_type&& pair) : pair(std::move(pair)) {} |
||||||
|
value_type pair; |
||||||
|
Entry* left = nullptr; |
||||||
|
Entry* right = nullptr; |
||||||
|
int32_t height = 1; |
||||||
|
}; |
||||||
|
|
||||||
|
static int32_t EntryHeight(const Entry* e) { |
||||||
|
return e == nullptr ? 0 : e->height; |
||||||
|
} |
||||||
|
|
||||||
|
static Entry* GetMinEntry(Entry* e); |
||||||
|
Entry* InOrderSuccessor(const Entry* e) const; |
||||||
|
static Entry* RotateLeft(Entry* e); |
||||||
|
static Entry* RotateRight(Entry* e); |
||||||
|
static Entry* RebalanceTreeAfterInsertion(Entry* root, const key_type& k); |
||||||
|
static Entry* RebalanceTreeAfterDeletion(Entry* root); |
||||||
|
// Returns a pair with the first value being an iterator pointing to the
|
||||||
|
// inserted entry and the second value being the new root of the subtree
|
||||||
|
// after a rebalance
|
||||||
|
Pair<iterator, Entry*> InsertRecursive(Entry* root, value_type&& p); |
||||||
|
static Entry* RemoveRecursive(Entry* root, const key_type& k); |
||||||
|
// Return 0 if lhs = rhs
|
||||||
|
// 1 if lhs > rhs
|
||||||
|
// -1 if lhs < rhs
|
||||||
|
static int CompareKeys(const Key& lhs, const Key& rhs); |
||||||
|
|
||||||
|
Entry* root_ = nullptr; |
||||||
|
size_t size_ = 0; |
||||||
|
}; |
||||||
|
|
||||||
|
template <class Key, class T, class Compare> |
||||||
|
class Map<Key, T, Compare>::iterator |
||||||
|
: public std::iterator<std::input_iterator_tag, Pair<Key, T>, int32_t, |
||||||
|
Pair<Key, T>*, Pair<Key, T>&> { |
||||||
|
public: |
||||||
|
iterator(const iterator& iter) : curr_(iter.curr_), map_(iter.map_) {} |
||||||
|
bool operator==(const iterator& rhs) const { return (curr_ == rhs.curr_); } |
||||||
|
bool operator!=(const iterator& rhs) const { return (curr_ != rhs.curr_); } |
||||||
|
|
||||||
|
iterator& operator++() { |
||||||
|
curr_ = map_->InOrderSuccessor(curr_); |
||||||
|
return *this; |
||||||
|
} |
||||||
|
|
||||||
|
iterator operator++(int) { |
||||||
|
Entry* prev = curr_; |
||||||
|
curr_ = map_->InOrderSuccessor(curr_); |
||||||
|
return iterator(map_, prev); |
||||||
|
} |
||||||
|
|
||||||
|
iterator& operator=(const iterator& other) { |
||||||
|
if (this != &other) { |
||||||
|
this->curr_ = other.curr_; |
||||||
|
this->map_ = other.map_; |
||||||
|
} |
||||||
|
return *this; |
||||||
|
} |
||||||
|
|
||||||
|
// operator*()
|
||||||
|
value_type& operator*() { return curr_->pair; } |
||||||
|
const value_type& operator*() const { return curr_->pair; } |
||||||
|
|
||||||
|
// operator->()
|
||||||
|
value_type* operator->() { return &curr_->pair; } |
||||||
|
value_type const* operator->() const { return &curr_->pair; } |
||||||
|
|
||||||
|
private: |
||||||
|
friend class Map<key_type, mapped_type, key_compare>; |
||||||
|
using GrpcMap = typename ::grpc_core::Map<Key, T, Compare>; |
||||||
|
iterator(GrpcMap* map, Entry* curr) : curr_(curr), map_(map) {} |
||||||
|
Entry* curr_; |
||||||
|
GrpcMap* map_; |
||||||
|
}; |
||||||
|
|
||||||
|
template <class Key, class T, class Compare> |
||||||
|
T& Map<Key, T, Compare>::operator[](key_type&& key) { |
||||||
|
auto iter = find(key); |
||||||
|
if (iter == end()) { |
||||||
|
return emplace(std::move(key), T()).first->second; |
||||||
|
} |
||||||
|
return iter->second; |
||||||
|
} |
||||||
|
|
||||||
|
template <class Key, class T, class Compare> |
||||||
|
T& Map<Key, T, Compare>::operator[](const key_type& key) { |
||||||
|
auto iter = find(key); |
||||||
|
if (iter == end()) { |
||||||
|
return emplace(key, T()).first->second; |
||||||
|
} |
||||||
|
return iter->second; |
||||||
|
} |
||||||
|
|
||||||
|
template <class Key, class T, class Compare> |
||||||
|
typename Map<Key, T, Compare>::iterator Map<Key, T, Compare>::find( |
||||||
|
const key_type& k) { |
||||||
|
Entry* iter = root_; |
||||||
|
while (iter != nullptr) { |
||||||
|
int comp = CompareKeys(iter->pair.first, k); |
||||||
|
if (comp == 0) { |
||||||
|
return iterator(this, iter); |
||||||
|
} else if (comp < 0) { |
||||||
|
iter = iter->right; |
||||||
|
} else { |
||||||
|
iter = iter->left; |
||||||
|
} |
||||||
|
} |
||||||
|
return end(); |
||||||
|
} |
||||||
|
|
||||||
|
template <class Key, class T, class Compare> |
||||||
|
template <class... Args> |
||||||
|
typename ::grpc_core::Pair<typename Map<Key, T, Compare>::iterator, bool> |
||||||
|
Map<Key, T, Compare>::emplace(Args&&... args) { |
||||||
|
Pair<key_type, mapped_type> pair(std::forward<Args>(args)...); |
||||||
|
iterator ret = find(pair.first); |
||||||
|
bool insertion = false; |
||||||
|
if (ret == end()) { |
||||||
|
Pair<iterator, Entry*> p = InsertRecursive(root_, std::move(pair)); |
||||||
|
root_ = p.second; |
||||||
|
ret = p.first; |
||||||
|
insertion = true; |
||||||
|
size_++; |
||||||
|
} |
||||||
|
return MakePair(ret, insertion); |
||||||
|
} |
||||||
|
|
||||||
|
template <class Key, class T, class Compare> |
||||||
|
size_t Map<Key, T, Compare>::erase(const key_type& key) { |
||||||
|
iterator it = find(key); |
||||||
|
if (it == end()) return 0; |
||||||
|
erase(it); |
||||||
|
return 1; |
||||||
|
} |
||||||
|
|
||||||
|
// TODO(mhaidry): Modify erase to use the iterator location
|
||||||
|
// to create an efficient erase method
|
||||||
|
template <class Key, class T, class Compare> |
||||||
|
typename Map<Key, T, Compare>::iterator Map<Key, T, Compare>::erase( |
||||||
|
iterator iter) { |
||||||
|
if (iter == end()) return iter; |
||||||
|
key_type& del_key = iter->first; |
||||||
|
iter++; |
||||||
|
root_ = RemoveRecursive(root_, del_key); |
||||||
|
size_--; |
||||||
|
return iter; |
||||||
|
} |
||||||
|
|
||||||
|
template <class Key, class T, class Compare> |
||||||
|
typename Map<Key, T, Compare>::Entry* Map<Key, T, Compare>::InOrderSuccessor( |
||||||
|
const Entry* e) const { |
||||||
|
if (e->right != nullptr) { |
||||||
|
return GetMinEntry(e->right); |
||||||
|
} |
||||||
|
Entry* successor = nullptr; |
||||||
|
Entry* iter = root_; |
||||||
|
while (iter != nullptr) { |
||||||
|
int comp = CompareKeys(iter->pair.first, e->pair.first); |
||||||
|
if (comp > 0) { |
||||||
|
successor = iter; |
||||||
|
iter = iter->left; |
||||||
|
} else if (comp < 0) { |
||||||
|
iter = iter->right; |
||||||
|
} else |
||||||
|
break; |
||||||
|
} |
||||||
|
return successor; |
||||||
|
} |
||||||
|
|
||||||
|
// Returns a pair with the first value being an iterator pointing to the
|
||||||
|
// inserted entry and the second value being the new root of the subtree
|
||||||
|
// after a rebalance
|
||||||
|
template <class Key, class T, class Compare> |
||||||
|
typename ::grpc_core::Pair<typename Map<Key, T, Compare>::iterator, |
||||||
|
typename Map<Key, T, Compare>::Entry*> |
||||||
|
Map<Key, T, Compare>::InsertRecursive(Entry* root, value_type&& p) { |
||||||
|
if (root == nullptr) { |
||||||
|
Entry* e = New<Entry>(std::move(p)); |
||||||
|
return MakePair(iterator(this, e), e); |
||||||
|
} |
||||||
|
int comp = CompareKeys(root->pair.first, p.first); |
||||||
|
if (comp > 0) { |
||||||
|
Pair<iterator, Entry*> ret = InsertRecursive(root->left, std::move(p)); |
||||||
|
root->left = ret.second; |
||||||
|
ret.second = RebalanceTreeAfterInsertion(root, ret.first->first); |
||||||
|
return ret; |
||||||
|
} else if (comp < 0) { |
||||||
|
Pair<iterator, Entry*> ret = InsertRecursive(root->right, std::move(p)); |
||||||
|
root->right = ret.second; |
||||||
|
ret.second = RebalanceTreeAfterInsertion(root, ret.first->first); |
||||||
|
return ret; |
||||||
|
} else { |
||||||
|
root->pair = std::move(p); |
||||||
|
return MakePair(iterator(this, root), root); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
template <class Key, class T, class Compare> |
||||||
|
typename Map<Key, T, Compare>::Entry* Map<Key, T, Compare>::GetMinEntry( |
||||||
|
Entry* e) { |
||||||
|
if (e != nullptr) { |
||||||
|
while (e->left != nullptr) { |
||||||
|
e = e->left; |
||||||
|
} |
||||||
|
} |
||||||
|
return e; |
||||||
|
} |
||||||
|
|
||||||
|
template <class Key, class T, class Compare> |
||||||
|
typename Map<Key, T, Compare>::Entry* Map<Key, T, Compare>::RotateLeft( |
||||||
|
Entry* e) { |
||||||
|
Entry* rightChild = e->right; |
||||||
|
Entry* rightLeftChild = rightChild->left; |
||||||
|
rightChild->left = e; |
||||||
|
e->right = rightLeftChild; |
||||||
|
e->height = 1 + GPR_MAX(EntryHeight(e->left), EntryHeight(e->right)); |
||||||
|
rightChild->height = 1 + GPR_MAX(EntryHeight(rightChild->left), |
||||||
|
EntryHeight(rightChild->right)); |
||||||
|
return rightChild; |
||||||
|
} |
||||||
|
|
||||||
|
template <class Key, class T, class Compare> |
||||||
|
typename Map<Key, T, Compare>::Entry* Map<Key, T, Compare>::RotateRight( |
||||||
|
Entry* e) { |
||||||
|
Entry* leftChild = e->left; |
||||||
|
Entry* leftRightChild = leftChild->right; |
||||||
|
leftChild->right = e; |
||||||
|
e->left = leftRightChild; |
||||||
|
e->height = 1 + GPR_MAX(EntryHeight(e->left), EntryHeight(e->right)); |
||||||
|
leftChild->height = |
||||||
|
1 + GPR_MAX(EntryHeight(leftChild->left), EntryHeight(leftChild->right)); |
||||||
|
return leftChild; |
||||||
|
} |
||||||
|
|
||||||
|
template <class Key, class T, class Compare> |
||||||
|
typename Map<Key, T, Compare>::Entry* |
||||||
|
Map<Key, T, Compare>::RebalanceTreeAfterInsertion(Entry* root, |
||||||
|
const key_type& k) { |
||||||
|
root->height = 1 + GPR_MAX(EntryHeight(root->left), EntryHeight(root->right)); |
||||||
|
int32_t heightDifference = EntryHeight(root->left) - EntryHeight(root->right); |
||||||
|
if (heightDifference > 1 && CompareKeys(root->left->pair.first, k) > 0) { |
||||||
|
return RotateRight(root); |
||||||
|
} |
||||||
|
if (heightDifference < -1 && CompareKeys(root->right->pair.first, k) < 0) { |
||||||
|
return RotateLeft(root); |
||||||
|
} |
||||||
|
if (heightDifference > 1 && CompareKeys(root->left->pair.first, k) < 0) { |
||||||
|
root->left = RotateLeft(root->left); |
||||||
|
return RotateRight(root); |
||||||
|
} |
||||||
|
if (heightDifference < -1 && CompareKeys(root->right->pair.first, k) > 0) { |
||||||
|
root->right = RotateRight(root->right); |
||||||
|
return RotateLeft(root); |
||||||
|
} |
||||||
|
return root; |
||||||
|
} |
||||||
|
|
||||||
|
template <class Key, class T, class Compare> |
||||||
|
typename Map<Key, T, Compare>::Entry* |
||||||
|
Map<Key, T, Compare>::RebalanceTreeAfterDeletion(Entry* root) { |
||||||
|
root->height = 1 + GPR_MAX(EntryHeight(root->left), EntryHeight(root->right)); |
||||||
|
int32_t heightDifference = EntryHeight(root->left) - EntryHeight(root->right); |
||||||
|
if (heightDifference > 1) { |
||||||
|
int leftHeightDifference = |
||||||
|
EntryHeight(root->left->left) - EntryHeight(root->left->right); |
||||||
|
if (leftHeightDifference < 0) { |
||||||
|
root->left = RotateLeft(root->left); |
||||||
|
} |
||||||
|
return RotateRight(root); |
||||||
|
} |
||||||
|
if (heightDifference < -1) { |
||||||
|
int rightHeightDifference = |
||||||
|
EntryHeight(root->right->left) - EntryHeight(root->right->right); |
||||||
|
if (rightHeightDifference > 0) { |
||||||
|
root->right = RotateRight(root->right); |
||||||
|
} |
||||||
|
return RotateLeft(root); |
||||||
|
} |
||||||
|
return root; |
||||||
|
} |
||||||
|
|
||||||
|
template <class Key, class T, class Compare> |
||||||
|
typename Map<Key, T, Compare>::Entry* Map<Key, T, Compare>::RemoveRecursive( |
||||||
|
Entry* root, const key_type& k) { |
||||||
|
if (root == nullptr) return root; |
||||||
|
int comp = CompareKeys(root->pair.first, k); |
||||||
|
if (comp > 0) { |
||||||
|
root->left = RemoveRecursive(root->left, k); |
||||||
|
} else if (comp < 0) { |
||||||
|
root->right = RemoveRecursive(root->right, k); |
||||||
|
} else { |
||||||
|
Entry* ret; |
||||||
|
if (root->left == nullptr) { |
||||||
|
ret = root->right; |
||||||
|
Delete(root); |
||||||
|
return ret; |
||||||
|
} else if (root->right == nullptr) { |
||||||
|
ret = root->left; |
||||||
|
Delete(root); |
||||||
|
return ret; |
||||||
|
} else { |
||||||
|
ret = root->right; |
||||||
|
while (ret->left != nullptr) { |
||||||
|
ret = ret->left; |
||||||
|
} |
||||||
|
root->pair.swap(ret->pair); |
||||||
|
root->right = RemoveRecursive(root->right, ret->pair.first); |
||||||
|
} |
||||||
|
} |
||||||
|
return RebalanceTreeAfterDeletion(root); |
||||||
|
} |
||||||
|
|
||||||
|
template <class Key, class T, class Compare> |
||||||
|
int Map<Key, T, Compare>::CompareKeys(const key_type& lhs, |
||||||
|
const key_type& rhs) { |
||||||
|
key_compare compare; |
||||||
|
bool left_comparison = compare(lhs, rhs); |
||||||
|
bool right_comparison = compare(rhs, lhs); |
||||||
|
// Both values are equal
|
||||||
|
if (!left_comparison && !right_comparison) { |
||||||
|
return 0; |
||||||
|
} |
||||||
|
return left_comparison ? -1 : 1; |
||||||
|
} |
||||||
|
} // namespace grpc_core
|
||||||
|
#endif /* GRPC_CORE_LIB_GPRPP_MAP_H */ |
||||||
@ -0,0 +1,38 @@ |
|||||||
|
/*
|
||||||
|
* |
||||||
|
* Copyright 2017 gRPC authors. |
||||||
|
* |
||||||
|
* 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. |
||||||
|
* |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef GRPC_CORE_LIB_GPRPP_PAIR_H |
||||||
|
#define GRPC_CORE_LIB_GPRPP_PAIR_H |
||||||
|
|
||||||
|
#include <grpc/support/port_platform.h> |
||||||
|
|
||||||
|
#include <utility> |
||||||
|
|
||||||
|
namespace grpc_core { |
||||||
|
template <class T1, class T2> |
||||||
|
using Pair = std::pair<T1, T2>; |
||||||
|
|
||||||
|
template <class T1, class T2> |
||||||
|
inline Pair<typename std::decay<T1>::type, typename std::decay<T2>::type> |
||||||
|
MakePair(T1&& u, T2&& v) { |
||||||
|
typedef typename std::decay<T1>::type V1; |
||||||
|
typedef typename std::decay<T2>::type V2; |
||||||
|
return Pair<V1, V2>(std::forward<T1>(u), std::forward<T2>(v)); |
||||||
|
} |
||||||
|
} // namespace grpc_core
|
||||||
|
#endif /* GRPC_CORE_LIB_GPRPP_PAIR_H */ |
||||||
@ -0,0 +1,409 @@ |
|||||||
|
/*
|
||||||
|
* |
||||||
|
* Copyright 2017 gRPC authors. |
||||||
|
* |
||||||
|
* 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 "src/core/lib/gprpp/map.h" |
||||||
|
#include <gtest/gtest.h> |
||||||
|
#include "include/grpc/support/string_util.h" |
||||||
|
#include "src/core/lib/gprpp/inlined_vector.h" |
||||||
|
#include "src/core/lib/gprpp/memory.h" |
||||||
|
#include "src/core/lib/gprpp/orphanable.h" |
||||||
|
#include "src/core/lib/gprpp/ref_counted_ptr.h" |
||||||
|
#include "test/core/util/test_config.h" |
||||||
|
|
||||||
|
namespace grpc_core { |
||||||
|
namespace testing { |
||||||
|
class Payload { |
||||||
|
public: |
||||||
|
Payload() : data_(-1) {} |
||||||
|
explicit Payload(int data) : data_(data) {} |
||||||
|
Payload(const Payload& other) : data_(other.data_) {} |
||||||
|
Payload& operator=(const Payload& other) { |
||||||
|
if (this != &other) { |
||||||
|
data_ = other.data_; |
||||||
|
} |
||||||
|
return *this; |
||||||
|
} |
||||||
|
int data() { return data_; } |
||||||
|
|
||||||
|
private: |
||||||
|
int data_; |
||||||
|
}; |
||||||
|
|
||||||
|
inline UniquePtr<char> CopyString(const char* string) { |
||||||
|
return UniquePtr<char>(gpr_strdup(string)); |
||||||
|
} |
||||||
|
|
||||||
|
static constexpr char kKeys[][4] = {"abc", "efg", "hij", "klm", "xyz"}; |
||||||
|
|
||||||
|
class MapTest : public ::testing::Test { |
||||||
|
public: |
||||||
|
template <class Key, class T, class Compare> |
||||||
|
typename ::grpc_core::Map<Key, T, Compare>::Entry* Root( |
||||||
|
typename ::grpc_core::Map<Key, T, Compare>* map) { |
||||||
|
return map->root_; |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
// Test insertion of Payload
|
||||||
|
TEST_F(MapTest, EmplaceAndFind) { |
||||||
|
Map<const char*, Payload, StringLess> test_map; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map.emplace(kKeys[i], Payload(i)); |
||||||
|
} |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
EXPECT_EQ(i, test_map.find(kKeys[i])->second.data()); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Test insertion of Payload Unique Ptrs
|
||||||
|
TEST_F(MapTest, EmplaceAndFindWithUniquePtrValue) { |
||||||
|
Map<const char*, UniquePtr<Payload>, StringLess> test_map; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map.emplace(kKeys[i], MakeUnique<Payload>(i)); |
||||||
|
} |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
EXPECT_EQ(i, test_map.find(kKeys[i])->second->data()); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Test insertion of Unique Ptr kKeys and Payload
|
||||||
|
TEST_F(MapTest, EmplaceAndFindWithUniquePtrKey) { |
||||||
|
Map<UniquePtr<char>, Payload, StringLess> test_map; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map.emplace(CopyString(kKeys[i]), Payload(i)); |
||||||
|
} |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
EXPECT_EQ(i, test_map.find(CopyString(kKeys[i]))->second.data()); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Test insertion of Payload
|
||||||
|
TEST_F(MapTest, InsertAndFind) { |
||||||
|
Map<const char*, Payload, StringLess> test_map; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map.insert(MakePair(kKeys[i], Payload(i))); |
||||||
|
} |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
EXPECT_EQ(i, test_map.find(kKeys[i])->second.data()); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Test insertion of Payload Unique Ptrs
|
||||||
|
TEST_F(MapTest, InsertAndFindWithUniquePtrValue) { |
||||||
|
Map<const char*, UniquePtr<Payload>, StringLess> test_map; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map.insert(MakePair(kKeys[i], MakeUnique<Payload>(i))); |
||||||
|
} |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
EXPECT_EQ(i, test_map.find(kKeys[i])->second->data()); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Test insertion of Unique Ptr kKeys and Payload
|
||||||
|
TEST_F(MapTest, InsertAndFindWithUniquePtrKey) { |
||||||
|
Map<UniquePtr<char>, Payload, StringLess> test_map; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map.insert(MakePair(CopyString(kKeys[i]), Payload(i))); |
||||||
|
} |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
EXPECT_EQ(i, test_map.find(CopyString(kKeys[i]))->second.data()); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Test bracket operators
|
||||||
|
TEST_F(MapTest, BracketOperator) { |
||||||
|
Map<const char*, Payload, StringLess> test_map; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map[kKeys[i]] = Payload(i); |
||||||
|
} |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
EXPECT_EQ(i, test_map[kKeys[i]].data()); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Test bracket operators with unique pointer to payload
|
||||||
|
TEST_F(MapTest, BracketOperatorWithUniquePtrValue) { |
||||||
|
Map<const char*, UniquePtr<Payload>, StringLess> test_map; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map[kKeys[i]] = MakeUnique<Payload>(i); |
||||||
|
} |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
EXPECT_EQ(i, test_map[kKeys[i]]->data()); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Test bracket operators with unique pointer to payload
|
||||||
|
TEST_F(MapTest, BracketOperatorWithUniquePtrKey) { |
||||||
|
Map<UniquePtr<char>, Payload, StringLess> test_map; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map[CopyString(kKeys[i])] = Payload(i); |
||||||
|
} |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
EXPECT_EQ(i, test_map[CopyString(kKeys[i])].data()); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Test removal of a single value
|
||||||
|
TEST_F(MapTest, Erase) { |
||||||
|
Map<const char*, Payload, StringLess> test_map; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map.emplace(kKeys[i], Payload(i)); |
||||||
|
} |
||||||
|
EXPECT_EQ(test_map.size(), 5UL); |
||||||
|
EXPECT_EQ(test_map.erase(kKeys[3]), 1UL); // Remove "hij"
|
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
if (i == 3) { // "hij" should not be present
|
||||||
|
EXPECT_TRUE(test_map.find(kKeys[i]) == test_map.end()); |
||||||
|
} else { |
||||||
|
EXPECT_EQ(i, test_map.find(kKeys[i])->second.data()); |
||||||
|
} |
||||||
|
} |
||||||
|
EXPECT_EQ(test_map.size(), 4UL); |
||||||
|
} |
||||||
|
|
||||||
|
// Test removal of a single value with unique ptr to payload
|
||||||
|
TEST_F(MapTest, EraseWithUniquePtrValue) { |
||||||
|
Map<const char*, UniquePtr<Payload>, StringLess> test_map; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map.emplace(kKeys[i], MakeUnique<Payload>(i)); |
||||||
|
} |
||||||
|
EXPECT_EQ(test_map.size(), 5UL); |
||||||
|
test_map.erase(kKeys[3]); // Remove "hij"
|
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
if (i == 3) { // "hij" should not be present
|
||||||
|
EXPECT_TRUE(test_map.find(kKeys[i]) == test_map.end()); |
||||||
|
} else { |
||||||
|
EXPECT_EQ(i, test_map.find(kKeys[i])->second->data()); |
||||||
|
} |
||||||
|
} |
||||||
|
EXPECT_EQ(test_map.size(), 4UL); |
||||||
|
} |
||||||
|
|
||||||
|
// Test removal of a single value
|
||||||
|
TEST_F(MapTest, EraseWithUniquePtrKey) { |
||||||
|
Map<UniquePtr<char>, Payload, StringLess> test_map; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map.emplace(CopyString(kKeys[i]), Payload(i)); |
||||||
|
} |
||||||
|
EXPECT_EQ(test_map.size(), 5UL); |
||||||
|
test_map.erase(CopyString(kKeys[3])); // Remove "hij"
|
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
if (i == 3) { // "hij" should not be present
|
||||||
|
EXPECT_TRUE(test_map.find(CopyString(kKeys[i])) == test_map.end()); |
||||||
|
} else { |
||||||
|
EXPECT_EQ(i, test_map.find(CopyString(kKeys[i]))->second.data()); |
||||||
|
} |
||||||
|
} |
||||||
|
EXPECT_EQ(test_map.size(), 4UL); |
||||||
|
} |
||||||
|
|
||||||
|
// Test clear
|
||||||
|
TEST_F(MapTest, SizeAndClear) { |
||||||
|
Map<const char*, Payload, StringLess> test_map; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map.emplace(kKeys[i], Payload(i)); |
||||||
|
} |
||||||
|
EXPECT_EQ(test_map.size(), 5UL); |
||||||
|
EXPECT_FALSE(test_map.empty()); |
||||||
|
test_map.clear(); |
||||||
|
EXPECT_EQ(test_map.size(), 0UL); |
||||||
|
EXPECT_TRUE(test_map.empty()); |
||||||
|
} |
||||||
|
|
||||||
|
// Test clear with unique ptr payload
|
||||||
|
TEST_F(MapTest, SizeAndClearWithUniquePtrValue) { |
||||||
|
Map<const char*, UniquePtr<Payload>, StringLess> test_map; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map.emplace(kKeys[i], MakeUnique<Payload>(i)); |
||||||
|
} |
||||||
|
EXPECT_EQ(test_map.size(), 5UL); |
||||||
|
EXPECT_FALSE(test_map.empty()); |
||||||
|
test_map.clear(); |
||||||
|
EXPECT_EQ(test_map.size(), 0UL); |
||||||
|
EXPECT_TRUE(test_map.empty()); |
||||||
|
} |
||||||
|
|
||||||
|
// Test clear with unique ptr char key
|
||||||
|
TEST_F(MapTest, SizeAndClearWithUniquePtrKey) { |
||||||
|
Map<UniquePtr<char>, Payload, StringLess> test_map; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map.emplace(CopyString(kKeys[i]), Payload(i)); |
||||||
|
} |
||||||
|
EXPECT_EQ(test_map.size(), 5UL); |
||||||
|
EXPECT_FALSE(test_map.empty()); |
||||||
|
test_map.clear(); |
||||||
|
EXPECT_EQ(test_map.size(), 0UL); |
||||||
|
EXPECT_TRUE(test_map.empty()); |
||||||
|
} |
||||||
|
|
||||||
|
// Test correction of Left-Left Tree imbalance
|
||||||
|
TEST_F(MapTest, MapLL) { |
||||||
|
Map<const char*, Payload, StringLess> test_map; |
||||||
|
for (int i = 2; i >= 0; i--) { |
||||||
|
test_map.emplace(kKeys[i], Payload(i)); |
||||||
|
} |
||||||
|
EXPECT_EQ(strcmp(Root(&test_map)->pair.first, kKeys[1]), 0); |
||||||
|
EXPECT_EQ(strcmp(Root(&test_map)->left->pair.first, kKeys[0]), 0); |
||||||
|
EXPECT_EQ(strcmp(Root(&test_map)->right->pair.first, kKeys[2]), 0); |
||||||
|
} |
||||||
|
|
||||||
|
// Test correction of Left-Right tree imbalance
|
||||||
|
TEST_F(MapTest, MapLR) { |
||||||
|
Map<const char*, Payload, StringLess> test_map; |
||||||
|
int insertion_key_index[] = {2, 0, 1}; |
||||||
|
for (int i = 0; i < 3; i++) { |
||||||
|
int key_index = insertion_key_index[i]; |
||||||
|
test_map.emplace(kKeys[key_index], Payload(key_index)); |
||||||
|
} |
||||||
|
EXPECT_EQ(strcmp(Root(&test_map)->pair.first, kKeys[1]), 0); |
||||||
|
EXPECT_EQ(strcmp(Root(&test_map)->left->pair.first, kKeys[0]), 0); |
||||||
|
EXPECT_EQ(strcmp(Root(&test_map)->right->pair.first, kKeys[2]), 0); |
||||||
|
} |
||||||
|
|
||||||
|
// Test correction of Right-Left tree imbalance
|
||||||
|
TEST_F(MapTest, MapRL) { |
||||||
|
Map<const char*, Payload, StringLess> test_map; |
||||||
|
int insertion_key_index[] = {0, 2, 1}; |
||||||
|
for (int i = 0; i < 3; i++) { |
||||||
|
int key_index = insertion_key_index[i]; |
||||||
|
test_map.emplace(kKeys[key_index], Payload(key_index)); |
||||||
|
} |
||||||
|
EXPECT_EQ(strcmp(Root(&test_map)->pair.first, kKeys[1]), 0); |
||||||
|
EXPECT_EQ(strcmp(Root(&test_map)->left->pair.first, kKeys[0]), 0); |
||||||
|
EXPECT_EQ(strcmp(Root(&test_map)->right->pair.first, kKeys[2]), 0); |
||||||
|
} |
||||||
|
|
||||||
|
// Test correction of Right-Right tree imbalance
|
||||||
|
TEST_F(MapTest, MapRR) { |
||||||
|
Map<const char*, Payload, StringLess> test_map; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map.emplace(kKeys[i], Payload(i)); |
||||||
|
} |
||||||
|
EXPECT_EQ(strcmp(Root(&test_map)->pair.first, kKeys[1]), 0); |
||||||
|
EXPECT_EQ(strcmp(Root(&test_map)->left->pair.first, kKeys[0]), 0); |
||||||
|
EXPECT_EQ(strcmp(Root(&test_map)->right->pair.first, kKeys[3]), 0); |
||||||
|
EXPECT_EQ(strcmp(Root(&test_map)->right->left->pair.first, kKeys[2]), 0); |
||||||
|
EXPECT_EQ(strcmp(Root(&test_map)->right->right->pair.first, kKeys[4]), 0); |
||||||
|
} |
||||||
|
|
||||||
|
// Test correction after random insertion
|
||||||
|
TEST_F(MapTest, MapRandomInsertions) { |
||||||
|
Map<const char*, Payload, StringLess> test_map; |
||||||
|
int insertion_key_index[] = {1, 4, 3, 0, 2}; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
int key_index = insertion_key_index[i]; |
||||||
|
test_map.emplace(kKeys[key_index], Payload(key_index)); |
||||||
|
} |
||||||
|
EXPECT_EQ(strcmp(Root(&test_map)->pair.first, kKeys[3]), 0); |
||||||
|
EXPECT_EQ(strcmp(Root(&test_map)->left->pair.first, kKeys[1]), 0); |
||||||
|
EXPECT_EQ(strcmp(Root(&test_map)->right->pair.first, kKeys[4]), 0); |
||||||
|
EXPECT_EQ(strcmp(Root(&test_map)->left->right->pair.first, kKeys[2]), 0); |
||||||
|
EXPECT_EQ(strcmp(Root(&test_map)->left->left->pair.first, kKeys[0]), 0); |
||||||
|
} |
||||||
|
|
||||||
|
// Test Map iterator
|
||||||
|
TEST_F(MapTest, Iteration) { |
||||||
|
Map<const char*, Payload, StringLess> test_map; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map.emplace(kKeys[i], Payload(i)); |
||||||
|
} |
||||||
|
int count = 0; |
||||||
|
for (auto iter = test_map.begin(); iter != test_map.end(); iter++) { |
||||||
|
EXPECT_EQ(iter->second.data(), count); |
||||||
|
count++; |
||||||
|
} |
||||||
|
EXPECT_EQ(count, 5); |
||||||
|
} |
||||||
|
|
||||||
|
// Test Map iterator with unique ptr payload
|
||||||
|
TEST_F(MapTest, IterationWithUniquePtrValue) { |
||||||
|
Map<const char*, UniquePtr<Payload>, StringLess> test_map; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map.emplace(kKeys[i], MakeUnique<Payload>(i)); |
||||||
|
} |
||||||
|
int count = 0; |
||||||
|
for (auto iter = test_map.begin(); iter != test_map.end(); iter++) { |
||||||
|
EXPECT_EQ(iter->second->data(), count); |
||||||
|
count++; |
||||||
|
} |
||||||
|
EXPECT_EQ(count, 5); |
||||||
|
} |
||||||
|
|
||||||
|
// Test Map iterator with unique ptr to char key
|
||||||
|
TEST_F(MapTest, IterationWithUniquePtrKey) { |
||||||
|
Map<UniquePtr<char>, Payload, StringLess> test_map; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map.emplace(CopyString(kKeys[i]), Payload(i)); |
||||||
|
} |
||||||
|
int count = 0; |
||||||
|
for (auto iter = test_map.begin(); iter != test_map.end(); iter++) { |
||||||
|
EXPECT_EQ(iter->second.data(), count); |
||||||
|
count++; |
||||||
|
} |
||||||
|
EXPECT_EQ(count, 5); |
||||||
|
} |
||||||
|
|
||||||
|
// Test removing entries while iterating the map
|
||||||
|
TEST_F(MapTest, EraseUsingIterator) { |
||||||
|
Map<const char*, Payload, StringLess> test_map; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map.emplace(kKeys[i], Payload(i)); |
||||||
|
} |
||||||
|
int count = 0; |
||||||
|
for (auto iter = test_map.begin(); iter != test_map.end();) { |
||||||
|
EXPECT_EQ(iter->second.data(), count); |
||||||
|
iter = test_map.erase(iter); |
||||||
|
count++; |
||||||
|
} |
||||||
|
EXPECT_EQ(count, 5); |
||||||
|
EXPECT_TRUE(test_map.empty()); |
||||||
|
} |
||||||
|
|
||||||
|
// Random ops on a Map with Integer key of Payload value,
|
||||||
|
// tests default comparator
|
||||||
|
TEST_F(MapTest, RandomOpsWithIntKey) { |
||||||
|
Map<int, Payload> test_map; |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map.emplace(i, Payload(i)); |
||||||
|
} |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
EXPECT_EQ(i, test_map.find(i)->second.data()); |
||||||
|
} |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
test_map[i] = Payload(i + 10); |
||||||
|
} |
||||||
|
for (int i = 0; i < 5; i++) { |
||||||
|
EXPECT_EQ(i + 10, test_map[i].data()); |
||||||
|
} |
||||||
|
EXPECT_EQ(test_map.erase(3), 1UL); |
||||||
|
EXPECT_TRUE(test_map.find(3) == test_map.end()); |
||||||
|
EXPECT_FALSE(test_map.empty()); |
||||||
|
EXPECT_EQ(test_map.size(), 4UL); |
||||||
|
test_map.clear(); |
||||||
|
EXPECT_EQ(test_map.size(), 0UL); |
||||||
|
EXPECT_TRUE(test_map.empty()); |
||||||
|
} |
||||||
|
|
||||||
|
} // namespace testing
|
||||||
|
} // namespace grpc_core
|
||||||
|
|
||||||
|
int main(int argc, char** argv) { |
||||||
|
grpc::testing::TestEnvironment env(argc, argv); |
||||||
|
::testing::InitGoogleTest(&argc, argv); |
||||||
|
return RUN_ALL_TESTS(); |
||||||
|
} |
||||||
Loading…
Reference in new issue