aboutsummaryrefslogtreecommitdiffstats
path: root/library/cpp/yt/misc/unittests/non_null_ptr_ut.cpp
blob: 8396e403abc403c6c174f20e225f0a8ca3cc6c78 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
#include <library/cpp/testing/gtest/gtest.h>

#include <library/cpp/yt/misc/non_null_ptr.h>

namespace NYT {
namespace {

////////////////////////////////////////////////////////////////////////////////

enum class EFuncResult
{
    Base,
    ConstBase,
    Derived,
    ConstDerived,
};

enum class EBinaryFuncResult
{
    OK,
    NotOK,
};

struct TBase
{ };

struct TDerived
    : public TBase
{ };

EFuncResult Foo(TNonNullPtr<TBase> /*base*/)
{
    return EFuncResult::Base;
}

EFuncResult Foo(TNonNullPtr<const TBase> /*base*/)
{
    return EFuncResult::ConstBase;
}

EFuncResult Foo(TNonNullPtr<TDerived> /*derived*/)
{
    return EFuncResult::Derived;
}

EFuncResult Foo(TNonNullPtr<const TDerived> /*derived*/)
{
    return EFuncResult::ConstDerived;
}

[[maybe_unused]] EBinaryFuncResult Foo(int* /*derived*/)
{
    return EBinaryFuncResult::NotOK;
}

EBinaryFuncResult Foo(TNonNullPtr<int> /*derived*/)
{
    return EBinaryFuncResult::OK;
}

EBinaryFuncResult Bar(TNonNullPtr<const int> /*arg*/)
{
    return EBinaryFuncResult::OK;
}

EBinaryFuncResult Baz(TNonNullPtr<int> /*arg*/)
{
    return EBinaryFuncResult::OK;
}

TEST(TNonNullPtrTest, Simple)
{
    TDerived derived{};
    const auto& constDerived = derived;
    EXPECT_EQ(EFuncResult::Derived, Foo(GetPtr(derived)));
    EXPECT_EQ(EFuncResult::ConstDerived, Foo(GetPtr(constDerived)));

    TBase base{};
    const auto& constBase = base;
    EXPECT_EQ(EFuncResult::Base, Foo(GetPtr(base)));
    EXPECT_EQ(EFuncResult::ConstBase, Foo(GetPtr(constBase)));

    int i{};
    EXPECT_EQ(EBinaryFuncResult::OK, Foo(GetPtr(i)));
}

TEST(TNonNullPtrTest, CastToConst)
{
    int i{};

    EXPECT_EQ(EBinaryFuncResult::OK, Bar(GetPtr(i)));
}

TEST(TNonNullPtrTest, ConstructionFromRawPointer)
{
    int i{};

    EXPECT_EQ(EBinaryFuncResult::OK, Baz(&i));
}

////////////////////////////////////////////////////////////////////////////////

} // namespace
} // namespace NYT