| // Copyright 2021 The Pigweed 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 "pw_sync/inline_borrowable.h" |
| |
| #include <array> |
| #include <chrono> |
| #include <tuple> |
| |
| #include "gtest/gtest.h" |
| #include "pw_sync/interrupt_spin_lock.h" |
| #include "pw_sync/lock_annotations.h" |
| #include "pw_sync/mutex.h" |
| |
| namespace pw::sync { |
| namespace { |
| |
| using namespace std::chrono_literals; |
| |
| // A trivial type that is copyable and movable. |
| struct TrivialType { |
| bool yes() const { return true; } |
| }; |
| |
| // A custom type that is neither copyable nor movable. |
| class CustomType { |
| public: |
| constexpr CustomType(int x, int y) : x_(x), y_(y) {} |
| |
| CustomType(const CustomType&) = delete; |
| CustomType& operator=(const CustomType&) = delete; |
| CustomType(CustomType&&) = delete; |
| CustomType&& operator=(CustomType&&) = delete; |
| |
| std::pair<int, int> data() const { return std::make_pair(x_, y_); } |
| |
| private: |
| int x_, y_; |
| }; |
| |
| // A custom lockable interface. |
| class PW_LOCKABLE("VirtualCustomLocakble") VirtualCustomLockable { |
| public: |
| virtual ~VirtualCustomLockable() {} |
| |
| virtual void lock() PW_EXCLUSIVE_LOCK_FUNCTION() = 0; |
| virtual void unlock() PW_UNLOCK_FUNCTION() = 0; |
| }; |
| |
| // A custom mutex type that requires a constructor parameter. |
| class PW_LOCKABLE("VirtualCustomMutex") VirtualCustomMutex |
| : public VirtualCustomLockable { |
| public: |
| explicit VirtualCustomMutex(int id) : mutex_{}, id_{id} {} |
| |
| void lock() override PW_EXCLUSIVE_LOCK_FUNCTION() { mutex_.lock(); } |
| void unlock() override PW_UNLOCK_FUNCTION() { mutex_.unlock(); } |
| |
| int id() const { return id_; } |
| |
| private: |
| pw::sync::Mutex mutex_; |
| int id_; |
| }; |
| |
| TEST(InlineBorrowableTest, TestTrivialType) { |
| InlineBorrowable<TrivialType> trivial; |
| EXPECT_TRUE(trivial.acquire()->yes()); |
| } |
| |
| TEST(InlineBorrowableTest, TestCustomTypeInPlace) { |
| InlineBorrowable<CustomType> custom(std::in_place, 1, 2); |
| EXPECT_EQ(custom.acquire()->data(), std::make_pair(1, 2)); |
| } |
| |
| TEST(InlineBorrowableTest, TestCustomTypeFromTuple) { |
| InlineBorrowable<CustomType> custom(std::make_tuple(1, 2)); |
| EXPECT_EQ(custom.acquire()->data(), std::make_pair(1, 2)); |
| } |
| |
| TEST(InlineBorrowableTest, TestCustomTypeFromFactory) { |
| InlineBorrowable<CustomType> custom([] { return CustomType(1, 2); }); |
| EXPECT_EQ(custom.acquire()->data(), std::make_pair(1, 2)); |
| } |
| |
| TEST(InlineBorrowableTest, TestTrivialTypeWithInterruptSpinLock) { |
| InlineBorrowable<TrivialType, VirtualInterruptSpinLock> |
| trivial_interrupt_safe; |
| EXPECT_TRUE(trivial_interrupt_safe.acquire()->yes()); |
| } |
| |
| TEST(InlineBorrowableTest, TestCustomTypeWithInterruptSpinLock) { |
| InlineBorrowable<CustomType, VirtualInterruptSpinLock> custom_interrupt_safe( |
| std::in_place, 1, 2); |
| EXPECT_EQ(custom_interrupt_safe.acquire()->data(), std::make_pair(1, 2)); |
| } |
| |
| TEST(InlineBorrowableTest, TestCustomTypeWithCustomMutexFromTuple) { |
| InlineBorrowable<CustomType, VirtualCustomMutex, VirtualCustomLockable> |
| custom_mutex(std::make_tuple(1, 2), std::make_tuple(42)); |
| EXPECT_EQ(custom_mutex.acquire()->data(), std::make_pair(1, 2)); |
| } |
| |
| TEST(InlineBorrowableTest, TestCustomTypeWithCustomMutexFromFactory) { |
| InlineBorrowable<CustomType, VirtualCustomMutex, VirtualCustomLockable> |
| custom_mutex([] { return CustomType(1, 2); }, |
| [] { return VirtualCustomMutex(42); }); |
| EXPECT_EQ(custom_mutex.acquire()->data(), std::make_pair(1, 2)); |
| } |
| |
| TEST(InlineBorrowableTest, TestArrayAggregateInitializationInPlace) { |
| using ArrayAggregate = std::array<int, 2>; |
| InlineBorrowable<ArrayAggregate> aggregate{std::in_place, 1, 2}; |
| EXPECT_EQ((*aggregate.acquire())[0], 1); |
| EXPECT_EQ((*aggregate.acquire())[1], 2); |
| } |
| |
| struct StructAggregate { |
| int a; |
| int b; |
| }; |
| |
| TEST(InlineBorrowableTest, TestStructAggregateInitializationInPlace) { |
| InlineBorrowable<StructAggregate> aggregate{std::in_place, 1, 2}; |
| EXPECT_EQ(aggregate.acquire()->a, 1); |
| EXPECT_EQ(aggregate.acquire()->b, 2); |
| } |
| |
| TEST(InlineBorrowableTest, TestStructAggregateInitializationFromFactory) { |
| InlineBorrowable<StructAggregate> aggregate( |
| []() -> StructAggregate { return {.a = 1, .b = 2}; }); |
| EXPECT_EQ(aggregate.acquire()->a, 1); |
| EXPECT_EQ(aggregate.acquire()->b, 2); |
| } |
| |
| TEST(InlineBorrowableTest, |
| TestStructAggregateInitializationFromMutableFactory) { |
| int i = 0; |
| auto factory = [&i]() mutable -> StructAggregate { |
| i++; |
| return {.a = 1, .b = 2}; |
| }; |
| InlineBorrowable<StructAggregate> aggregate(factory); |
| EXPECT_EQ(aggregate.acquire()->a, 1); |
| EXPECT_EQ(aggregate.acquire()->b, 2); |
| } |
| |
| struct ReferenceTypes { |
| ReferenceTypes(const int& a, int& b, BorrowedPointer<int>&& c) |
| : in(a), out(b), borrowed(std::move(c)) {} |
| const int& in; |
| int& out; |
| BorrowedPointer<int> borrowed; // move-only type |
| }; |
| |
| class InlineBorrowableReferenceTypesTest : public ::testing::Test { |
| protected: |
| int input_ = 1; |
| int output_ = 2; |
| InlineBorrowable<int> borrowable_{std::in_place, 3}; |
| |
| void Validate(BorrowedPointer<ReferenceTypes>&& references) { |
| EXPECT_EQ(references->in, 1); |
| EXPECT_EQ(references->out, 2); |
| EXPECT_EQ(*references->borrowed, 3); |
| |
| references->out = -2; |
| EXPECT_EQ(output_, -2); |
| } |
| }; |
| |
| TEST_F(InlineBorrowableReferenceTypesTest, TestInPlace) { |
| InlineBorrowable<ReferenceTypes> references( |
| std::in_place, input_, output_, borrowable_.acquire()); |
| Validate(references.acquire()); |
| } |
| |
| TEST_F(InlineBorrowableReferenceTypesTest, TestFromTuple) { |
| InlineBorrowable<ReferenceTypes> references( |
| std::forward_as_tuple(input_, output_, borrowable_.acquire())); |
| Validate(references.acquire()); |
| } |
| |
| TEST_F(InlineBorrowableReferenceTypesTest, TestFromFactory) { |
| InlineBorrowable<ReferenceTypes> references( |
| [&] { return ReferenceTypes(input_, output_, borrowable_.acquire()); }); |
| Validate(references.acquire()); |
| } |
| |
| } // namespace |
| } // namespace pw::sync |