ClickHouse

1
#include <gtest/gtest.h>
2

3
#include <base/types.h>
4
#include <type_traits>
5
#include <Core/MultiEnum.h>
6

7
namespace
8
{
9

10
enum class TestEnum : UInt8
11
{
12
    // name represents which bit is going to be set
13
    ZERO,
14
    ONE,
15
    TWO,
16
    THREE,
17
    FOUR,
18
    FIVE
19
};
20
}
21

22
GTEST_TEST(MultiEnum, WithDefault)
23
{
24
    MultiEnum<TestEnum, UInt8> multi_enum;
25
    ASSERT_EQ(0, multi_enum.getValue());
26
    ASSERT_EQ(0, multi_enum);
27

28
    ASSERT_FALSE(multi_enum.isSet(TestEnum::ZERO));
29
    ASSERT_FALSE(multi_enum.isSet(TestEnum::ONE));
30
    ASSERT_FALSE(multi_enum.isSet(TestEnum::TWO));
31
    ASSERT_FALSE(multi_enum.isSet(TestEnum::THREE));
32
    ASSERT_FALSE(multi_enum.isSet(TestEnum::FOUR));
33
    ASSERT_FALSE(multi_enum.isSet(TestEnum::FIVE));
34
}
35

36
GTEST_TEST(MultiEnum, WitheEnum)
37
{
38
    MultiEnum<TestEnum, UInt8> multi_enum(TestEnum::FOUR);
39
    ASSERT_EQ(16, multi_enum.getValue());
40
    ASSERT_EQ(16, multi_enum);
41

42
    ASSERT_FALSE(multi_enum.isSet(TestEnum::ZERO));
43
    ASSERT_FALSE(multi_enum.isSet(TestEnum::ONE));
44
    ASSERT_FALSE(multi_enum.isSet(TestEnum::TWO));
45
    ASSERT_FALSE(multi_enum.isSet(TestEnum::THREE));
46
    ASSERT_TRUE(multi_enum.isSet(TestEnum::FOUR));
47
    ASSERT_FALSE(multi_enum.isSet(TestEnum::FIVE));
48
}
49

50
GTEST_TEST(MultiEnum, WithValue)
51
{
52
    const MultiEnum<TestEnum> multi_enum(13u); // (1 | (1 << 2 | 1 << 3)
53

54
    ASSERT_TRUE(multi_enum.isSet(TestEnum::ZERO));
55
    ASSERT_FALSE(multi_enum.isSet(TestEnum::ONE));
56
    ASSERT_TRUE(multi_enum.isSet(TestEnum::TWO));
57
    ASSERT_TRUE(multi_enum.isSet(TestEnum::THREE));
58
    ASSERT_FALSE(multi_enum.isSet(TestEnum::FOUR));
59
    ASSERT_FALSE(multi_enum.isSet(TestEnum::FIVE));
60
}
61

62
GTEST_TEST(MultiEnum, WithMany)
63
{
64
    MultiEnum<TestEnum> multi_enum{TestEnum::ONE, TestEnum::FIVE};
65
    ASSERT_EQ(1 << 1 | 1 << 5, multi_enum.getValue());
66
    ASSERT_EQ(1 << 1 | 1 << 5, multi_enum);
67

68
    ASSERT_FALSE(multi_enum.isSet(TestEnum::ZERO));
69
    ASSERT_TRUE(multi_enum.isSet(TestEnum::ONE));
70
    ASSERT_FALSE(multi_enum.isSet(TestEnum::TWO));
71
    ASSERT_FALSE(multi_enum.isSet(TestEnum::THREE));
72
    ASSERT_FALSE(multi_enum.isSet(TestEnum::FOUR));
73
    ASSERT_TRUE(multi_enum.isSet(TestEnum::FIVE));
74
}
75

76
GTEST_TEST(MultiEnum, WithCopyConstructor)
77
{
78
    const MultiEnum<TestEnum> multi_enum_source{TestEnum::ONE, TestEnum::FIVE};
79
    MultiEnum<TestEnum> multi_enum{multi_enum_source};
80

81
    ASSERT_EQ(1 << 1 | 1 << 5, multi_enum.getValue());
82
}
83

84
GTEST_TEST(MultiEnum, SetAndUnSet)
85
{
86
    MultiEnum<TestEnum> multi_enum;
87
    multi_enum.set(TestEnum::ONE);
88
    ASSERT_EQ(1 << 1, multi_enum);
89

90
    multi_enum.set(TestEnum::TWO);
91
    ASSERT_EQ(1 << 1| (1 << 2), multi_enum);
92

93
    multi_enum.unSet(TestEnum::ONE);
94
    ASSERT_EQ(1 << 2, multi_enum);
95
}
96

97
GTEST_TEST(MultiEnum, SetValueOnDifferentTypes)
98
{
99
    MultiEnum<TestEnum> multi_enum;
100

101
    multi_enum.setValue(static_cast<UInt8>(1));
102
    ASSERT_EQ(1, multi_enum);
103

104
    multi_enum.setValue(static_cast<UInt16>(2));
105
    ASSERT_EQ(2, multi_enum);
106

107
    multi_enum.setValue(static_cast<UInt32>(3));
108
    ASSERT_EQ(3, multi_enum);
109

110
    multi_enum.setValue(static_cast<UInt64>(4));
111
    ASSERT_EQ(4, multi_enum);
112
}
113

114
// shouldn't compile
115
//GTEST_TEST(MultiEnum, WithOtherEnumType)
116
//{
117
//    MultiEnum<TestEnum> multi_enum;
118

119
//    enum FOO {BAR, FOOBAR};
120
//    MultiEnum<TestEnum> multi_enum2(BAR);
121
//    MultiEnum<TestEnum> multi_enum3(BAR, FOOBAR);
122
//    multi_enum.setValue(FOO::BAR);
123
//    multi_enum == FOO::BAR;
124
//    FOO::BAR == multi_enum;
125
//}
126

127
GTEST_TEST(MultiEnum, SetSameValueMultipleTimes)
128
{
129
    // Setting same value is idempotent.
130
    MultiEnum<TestEnum> multi_enum;
131
    multi_enum.set(TestEnum::ONE);
132
    ASSERT_EQ(1 << 1, multi_enum);
133

134
    multi_enum.set(TestEnum::ONE);
135
    ASSERT_EQ(1 << 1, multi_enum);
136
}
137

138
GTEST_TEST(MultiEnum, UnSetValuesThatWerentSet)
139
{
140
    // Unsetting values that weren't set shouldn't change other flags nor aggregate value.
141
    MultiEnum<TestEnum> multi_enum{TestEnum::ONE, TestEnum::THREE};
142
    multi_enum.unSet(TestEnum::TWO);
143
    ASSERT_EQ(1 << 1 | 1 << 3, multi_enum);
144

145
    multi_enum.unSet(TestEnum::FOUR);
146
    ASSERT_EQ(1 << 1 | 1 << 3, multi_enum);
147

148
    multi_enum.unSet(TestEnum::FIVE);
149
    ASSERT_EQ(1 << 1 | 1 << 3, multi_enum);
150
}
151

152
GTEST_TEST(MultiEnum, Reset)
153
{
154
    MultiEnum<TestEnum> multi_enum{TestEnum::ONE, TestEnum::THREE};
155
    multi_enum.reset();
156
    ASSERT_EQ(0, multi_enum);
157
}
158