192 lines
3.6 KiB
C++
192 lines
3.6 KiB
C++
// Copyright The OpenTelemetry Authors
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
#include <gtest/gtest.h>
|
|
#include <stddef.h>
|
|
#include <algorithm>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "opentelemetry/nostd/shared_ptr.h"
|
|
|
|
using opentelemetry::nostd::shared_ptr;
|
|
|
|
class A
|
|
{
|
|
public:
|
|
explicit A(bool &destructed) noexcept : destructed_{destructed} { destructed_ = false; }
|
|
|
|
~A() { destructed_ = true; }
|
|
|
|
private:
|
|
bool &destructed_;
|
|
};
|
|
|
|
class B
|
|
{
|
|
public:
|
|
int f() const { return 123; }
|
|
};
|
|
|
|
class C
|
|
{
|
|
public:
|
|
virtual ~C() {}
|
|
};
|
|
|
|
class D : public C
|
|
{
|
|
public:
|
|
~D() override {}
|
|
};
|
|
|
|
TEST(SharedPtrTest, DefaultConstruction)
|
|
{
|
|
shared_ptr<int> ptr1;
|
|
EXPECT_EQ(ptr1.get(), nullptr);
|
|
|
|
shared_ptr<int> ptr2{nullptr};
|
|
EXPECT_EQ(ptr2.get(), nullptr);
|
|
}
|
|
|
|
TEST(SharedPtrTest, ExplicitConstruction)
|
|
{
|
|
auto c = new C();
|
|
shared_ptr<C> ptr1{c};
|
|
EXPECT_EQ(ptr1.get(), c);
|
|
|
|
auto d = new D();
|
|
shared_ptr<C> ptr2{d};
|
|
EXPECT_EQ(ptr2.get(), d);
|
|
}
|
|
|
|
TEST(SharedPtrTest, MoveConstruction)
|
|
{
|
|
auto value = new int{123};
|
|
shared_ptr<int> ptr1{value};
|
|
shared_ptr<int> ptr2{std::move(ptr1)};
|
|
EXPECT_EQ(ptr1.get(), nullptr); // NOLINT
|
|
EXPECT_EQ(ptr2.get(), value);
|
|
}
|
|
|
|
TEST(SharedPtrTest, MoveConstructionFromDifferentType)
|
|
{
|
|
auto value = new int{123};
|
|
shared_ptr<int> ptr1{value};
|
|
shared_ptr<const int> ptr2{std::move(ptr1)};
|
|
EXPECT_EQ(ptr1.get(), nullptr); // NOLINT
|
|
EXPECT_EQ(ptr2.get(), value);
|
|
}
|
|
|
|
TEST(SharedPtrTest, MoveConstructionFromStdSharedPtr)
|
|
{
|
|
auto value = new int{123};
|
|
std::shared_ptr<int> ptr1{value};
|
|
shared_ptr<int> ptr2{std::move(ptr1)};
|
|
EXPECT_EQ(ptr1.get(), nullptr); // NOLINT
|
|
EXPECT_EQ(ptr2.get(), value);
|
|
}
|
|
|
|
TEST(SharedPtrTest, Destruction)
|
|
{
|
|
bool was_destructed;
|
|
shared_ptr<A>{new A{was_destructed}}; // NOLINT
|
|
EXPECT_TRUE(was_destructed);
|
|
}
|
|
|
|
TEST(SharedPtrTest, Assignment)
|
|
{
|
|
auto value = new int{123};
|
|
shared_ptr<int> ptr1;
|
|
|
|
ptr1 = shared_ptr<int>(value);
|
|
EXPECT_EQ(ptr1.get(), value);
|
|
|
|
ptr1 = nullptr;
|
|
EXPECT_EQ(ptr1.get(), nullptr);
|
|
|
|
auto value2 = new int{234};
|
|
const shared_ptr<int> ptr2 = shared_ptr<int>(value2);
|
|
ptr1 = ptr2;
|
|
EXPECT_EQ(ptr1.get(), value2);
|
|
|
|
auto value3 = new int{345};
|
|
std::shared_ptr<int> ptr3(value3);
|
|
ptr1 = ptr3;
|
|
EXPECT_EQ(ptr1.get(), value3);
|
|
}
|
|
|
|
TEST(SharedPtrTest, BoolConversionOpertor)
|
|
{
|
|
auto value = new int{123};
|
|
shared_ptr<int> ptr1{value};
|
|
|
|
EXPECT_TRUE(ptr1);
|
|
EXPECT_FALSE(shared_ptr<int>{});
|
|
}
|
|
|
|
TEST(SharedPtrTest, PointerOperators)
|
|
{
|
|
auto value = new int{123};
|
|
shared_ptr<int> ptr1{value};
|
|
|
|
EXPECT_EQ(&*ptr1, value);
|
|
EXPECT_EQ(shared_ptr<B> { new B } -> f(), 123);
|
|
}
|
|
|
|
TEST(SharedPtrTest, Swap)
|
|
{
|
|
auto value1 = new int{123};
|
|
shared_ptr<int> ptr1{value1};
|
|
|
|
auto value2 = new int{456};
|
|
shared_ptr<int> ptr2{value2};
|
|
ptr1.swap(ptr2);
|
|
|
|
EXPECT_EQ(ptr1.get(), value2);
|
|
EXPECT_EQ(ptr2.get(), value1);
|
|
}
|
|
|
|
TEST(SharedPtrTest, Comparison)
|
|
{
|
|
shared_ptr<int> ptr1{new int{123}};
|
|
shared_ptr<int> ptr2{new int{456}};
|
|
shared_ptr<int> ptr3{};
|
|
|
|
EXPECT_EQ(ptr1, ptr1);
|
|
EXPECT_NE(ptr1, ptr2);
|
|
|
|
EXPECT_NE(ptr1, nullptr);
|
|
EXPECT_NE(nullptr, ptr1);
|
|
|
|
EXPECT_EQ(ptr3, nullptr);
|
|
EXPECT_EQ(nullptr, ptr3);
|
|
}
|
|
|
|
static void SharedPtrTest_Sort(size_t size = 10)
|
|
{
|
|
std::vector<shared_ptr<const int>> nums;
|
|
|
|
for (int i = static_cast<int>(size); i > 0; i--)
|
|
{
|
|
nums.push_back(shared_ptr<int>(new int(i)));
|
|
}
|
|
|
|
auto nums2 = nums;
|
|
|
|
std::sort(nums.begin(), nums.end(),
|
|
[](const shared_ptr<const int> &a, const shared_ptr<const int> &b) { return *a < *b; });
|
|
|
|
EXPECT_NE(nums, nums2);
|
|
|
|
std::reverse(nums2.begin(), nums2.end());
|
|
|
|
EXPECT_EQ(nums, nums2);
|
|
}
|
|
|
|
TEST(SharedPtrTest, Sort)
|
|
{
|
|
SharedPtrTest_Sort();
|
|
}
|