// Copyright 2022 The Abseil 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 // // https://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 "absl/container/internal/common_policy_traits.h" #include #include #include #include "gmock/gmock.h" #include "gtest/gtest.h" namespace absl { ABSL_NAMESPACE_BEGIN namespace container_internal { namespace { using ::testing::MockFunction; using ::testing::AnyNumber; using ::testing::ReturnRef; using Slot = int; struct PolicyWithoutOptionalOps { using slot_type = Slot; using key_type = Slot; using init_type = Slot; static std::function construct; static std::function destroy; static std::function element; }; std::function PolicyWithoutOptionalOps::construct; std::function PolicyWithoutOptionalOps::destroy; std::function PolicyWithoutOptionalOps::element; struct PolicyWithOptionalOps : PolicyWithoutOptionalOps { static std::function transfer; }; std::function PolicyWithOptionalOps::transfer; struct Test : ::testing::Test { Test() { PolicyWithoutOptionalOps::construct = [&](void* a1, Slot* a2, Slot a3) { construct.Call(a1, a2, std::move(a3)); }; PolicyWithoutOptionalOps::destroy = [&](void* a1, Slot* a2) { destroy.Call(a1, a2); }; PolicyWithoutOptionalOps::element = [&](Slot* a1) -> Slot& { return element.Call(a1); }; PolicyWithOptionalOps::transfer = [&](void* a1, Slot* a2, Slot* a3) { return transfer.Call(a1, a2, a3); }; } std::allocator alloc; int a = 53; MockFunction construct; MockFunction destroy; MockFunction element; MockFunction transfer; }; TEST_F(Test, construct) { EXPECT_CALL(construct, Call(&alloc, &a, 53)); common_policy_traits::construct(&alloc, &a, 53); } TEST_F(Test, destroy) { EXPECT_CALL(destroy, Call(&alloc, &a)); common_policy_traits::destroy(&alloc, &a); } TEST_F(Test, element) { int b = 0; EXPECT_CALL(element, Call(&a)).WillOnce(ReturnRef(b)); EXPECT_EQ(&b, &common_policy_traits::element(&a)); } TEST_F(Test, without_transfer) { int b = 42; EXPECT_CALL(element, Call(&a)).Times(AnyNumber()).WillOnce(ReturnRef(a)); EXPECT_CALL(element, Call(&b)).WillOnce(ReturnRef(b)); EXPECT_CALL(construct, Call(&alloc, &a, b)).Times(AnyNumber()); EXPECT_CALL(destroy, Call(&alloc, &b)).Times(AnyNumber()); common_policy_traits::transfer(&alloc, &a, &b); } TEST_F(Test, with_transfer) { int b = 42; EXPECT_CALL(transfer, Call(&alloc, &a, &b)); common_policy_traits::transfer(&alloc, &a, &b); } } // namespace } // namespace container_internal ABSL_NAMESPACE_END } // namespace absl