|
150
|
1 //===- EnumsGenTest.cpp - TableGen EnumsGen Tests -------------------------===//
|
|
|
2 //
|
|
|
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
4 // See https://llvm.org/LICENSE.txt for license information.
|
|
|
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
|
6 //
|
|
|
7 //===----------------------------------------------------------------------===//
|
|
|
8
|
|
221
|
9 #include "mlir/IR/BuiltinAttributes.h"
|
|
|
10 #include "mlir/IR/BuiltinTypes.h"
|
|
|
11 #include "mlir/IR/MLIRContext.h"
|
|
|
12 #include "mlir/Support/LLVM.h"
|
|
|
13
|
|
150
|
14 #include "llvm/ADT/DenseMap.h"
|
|
|
15 #include "llvm/ADT/StringExtras.h"
|
|
221
|
16
|
|
150
|
17 #include "gmock/gmock.h"
|
|
221
|
18
|
|
150
|
19 #include <type_traits>
|
|
|
20
|
|
221
|
21 /// Pull in generated enum utility declarations and definitions.
|
|
150
|
22 #include "EnumsGenTest.h.inc"
|
|
221
|
23
|
|
150
|
24 #include "EnumsGenTest.cpp.inc"
|
|
|
25
|
|
221
|
26 /// Test namespaces and enum class/utility names.
|
|
150
|
27 using Outer::Inner::ConvertToEnum;
|
|
|
28 using Outer::Inner::ConvertToString;
|
|
236
|
29 using Outer::Inner::FooEnum;
|
|
150
|
30
|
|
|
31 TEST(EnumsGenTest, GeneratedStrEnumDefinition) {
|
|
236
|
32 EXPECT_EQ(0u, static_cast<uint64_t>(FooEnum::CaseA));
|
|
|
33 EXPECT_EQ(1u, static_cast<uint64_t>(FooEnum::CaseB));
|
|
150
|
34 }
|
|
|
35
|
|
|
36 TEST(EnumsGenTest, GeneratedI32EnumDefinition) {
|
|
|
37 EXPECT_EQ(5u, static_cast<uint64_t>(I32Enum::Case5));
|
|
|
38 EXPECT_EQ(10u, static_cast<uint64_t>(I32Enum::Case10));
|
|
|
39 }
|
|
|
40
|
|
|
41 TEST(EnumsGenTest, GeneratedDenseMapInfo) {
|
|
236
|
42 llvm::DenseMap<FooEnum, std::string> myMap;
|
|
150
|
43
|
|
236
|
44 myMap[FooEnum::CaseA] = "zero";
|
|
|
45 myMap[FooEnum::CaseB] = "one";
|
|
150
|
46
|
|
236
|
47 EXPECT_EQ(myMap[FooEnum::CaseA], "zero");
|
|
|
48 EXPECT_EQ(myMap[FooEnum::CaseB], "one");
|
|
150
|
49 }
|
|
|
50
|
|
|
51 TEST(EnumsGenTest, GeneratedSymbolToStringFn) {
|
|
236
|
52 EXPECT_EQ(ConvertToString(FooEnum::CaseA), "CaseA");
|
|
|
53 EXPECT_EQ(ConvertToString(FooEnum::CaseB), "CaseB");
|
|
150
|
54 }
|
|
|
55
|
|
|
56 TEST(EnumsGenTest, GeneratedStringToSymbolFn) {
|
|
252
|
57 EXPECT_EQ(std::optional<FooEnum>(FooEnum::CaseA), ConvertToEnum("CaseA"));
|
|
|
58 EXPECT_EQ(std::optional<FooEnum>(FooEnum::CaseB), ConvertToEnum("CaseB"));
|
|
|
59 EXPECT_EQ(std::nullopt, ConvertToEnum("X"));
|
|
150
|
60 }
|
|
|
61
|
|
|
62 TEST(EnumsGenTest, GeneratedUnderlyingType) {
|
|
|
63 bool v = std::is_same<uint32_t, std::underlying_type<I32Enum>::type>::value;
|
|
|
64 EXPECT_TRUE(v);
|
|
|
65 }
|
|
|
66
|
|
|
67 TEST(EnumsGenTest, GeneratedBitEnumDefinition) {
|
|
|
68 EXPECT_EQ(0u, static_cast<uint32_t>(BitEnumWithNone::None));
|
|
236
|
69 EXPECT_EQ(1u, static_cast<uint32_t>(BitEnumWithNone::Bit0));
|
|
|
70 EXPECT_EQ(8u, static_cast<uint32_t>(BitEnumWithNone::Bit3));
|
|
|
71
|
|
|
72 EXPECT_EQ(2u, static_cast<uint64_t>(BitEnum64_Test::Bit1));
|
|
|
73 EXPECT_EQ(144115188075855872u, static_cast<uint64_t>(BitEnum64_Test::Bit57));
|
|
150
|
74 }
|
|
|
75
|
|
|
76 TEST(EnumsGenTest, GeneratedSymbolToStringFnForBitEnum) {
|
|
|
77 EXPECT_EQ(stringifyBitEnumWithNone(BitEnumWithNone::None), "None");
|
|
236
|
78 EXPECT_EQ(stringifyBitEnumWithNone(BitEnumWithNone::Bit0), "Bit0");
|
|
150
|
79 EXPECT_EQ(stringifyBitEnumWithNone(BitEnumWithNone::Bit3), "Bit3");
|
|
|
80 EXPECT_EQ(
|
|
236
|
81 stringifyBitEnumWithNone(BitEnumWithNone::Bit0 | BitEnumWithNone::Bit3),
|
|
|
82 "Bit0 | Bit3");
|
|
|
83
|
|
|
84 EXPECT_EQ(stringifyBitEnum64_Test(BitEnum64_Test::Bit1), "Bit1");
|
|
|
85 EXPECT_EQ(
|
|
|
86 stringifyBitEnum64_Test(BitEnum64_Test::Bit1 | BitEnum64_Test::Bit57),
|
|
|
87 "Bit1|Bit57");
|
|
150
|
88 }
|
|
|
89
|
|
|
90 TEST(EnumsGenTest, GeneratedStringToSymbolForBitEnum) {
|
|
|
91 EXPECT_EQ(symbolizeBitEnumWithNone("None"), BitEnumWithNone::None);
|
|
236
|
92 EXPECT_EQ(symbolizeBitEnumWithNone("Bit0"), BitEnumWithNone::Bit0);
|
|
150
|
93 EXPECT_EQ(symbolizeBitEnumWithNone("Bit3"), BitEnumWithNone::Bit3);
|
|
236
|
94 EXPECT_EQ(symbolizeBitEnumWithNone("Bit3|Bit0"),
|
|
|
95 BitEnumWithNone::Bit3 | BitEnumWithNone::Bit0);
|
|
150
|
96
|
|
252
|
97 EXPECT_EQ(symbolizeBitEnumWithNone("Bit2"), std::nullopt);
|
|
|
98 EXPECT_EQ(symbolizeBitEnumWithNone("Bit3 | Bit4"), std::nullopt);
|
|
150
|
99
|
|
252
|
100 EXPECT_EQ(symbolizeBitEnumWithoutNone("None"), std::nullopt);
|
|
150
|
101 }
|
|
|
102
|
|
236
|
103 TEST(EnumsGenTest, GeneratedSymbolToStringFnForGroupedBitEnum) {
|
|
|
104 EXPECT_EQ(stringifyBitEnumWithGroup(BitEnumWithGroup::Bit0), "Bit0");
|
|
|
105 EXPECT_EQ(stringifyBitEnumWithGroup(BitEnumWithGroup::Bit3), "Bit3");
|
|
|
106 EXPECT_EQ(stringifyBitEnumWithGroup(BitEnumWithGroup::Bits0To3),
|
|
|
107 "Bit0|Bit1|Bit2|Bit3|Bits0To3");
|
|
|
108 EXPECT_EQ(stringifyBitEnumWithGroup(BitEnumWithGroup::Bit4), "Bit4");
|
|
|
109 EXPECT_EQ(stringifyBitEnumWithGroup(
|
|
|
110 BitEnumWithGroup::Bit0 | BitEnumWithGroup::Bit1 |
|
|
|
111 BitEnumWithGroup::Bit2 | BitEnumWithGroup::Bit4),
|
|
|
112 "Bit0|Bit1|Bit2|Bit4");
|
|
|
113 }
|
|
|
114
|
|
|
115 TEST(EnumsGenTest, GeneratedStringToSymbolForGroupedBitEnum) {
|
|
|
116 EXPECT_EQ(symbolizeBitEnumWithGroup("Bit0"), BitEnumWithGroup::Bit0);
|
|
|
117 EXPECT_EQ(symbolizeBitEnumWithGroup("Bit3"), BitEnumWithGroup::Bit3);
|
|
252
|
118 EXPECT_EQ(symbolizeBitEnumWithGroup("Bit5"), std::nullopt);
|
|
236
|
119 EXPECT_EQ(symbolizeBitEnumWithGroup("Bit3|Bit0"),
|
|
|
120 BitEnumWithGroup::Bit3 | BitEnumWithGroup::Bit0);
|
|
|
121 }
|
|
|
122
|
|
|
123 TEST(EnumsGenTest, GeneratedSymbolToStringFnForPrimaryGroupBitEnum) {
|
|
|
124 EXPECT_EQ(stringifyBitEnumPrimaryGroup(
|
|
|
125 BitEnumPrimaryGroup::Bit0 | BitEnumPrimaryGroup::Bit1 |
|
|
|
126 BitEnumPrimaryGroup::Bit2 | BitEnumPrimaryGroup::Bit3),
|
|
|
127 "Bits0To3");
|
|
|
128 EXPECT_EQ(stringifyBitEnumPrimaryGroup(BitEnumPrimaryGroup::Bit0 |
|
|
|
129 BitEnumPrimaryGroup::Bit2 |
|
|
|
130 BitEnumPrimaryGroup::Bit3),
|
|
|
131 "Bit0, Bit2, Bit3");
|
|
|
132 EXPECT_EQ(stringifyBitEnumPrimaryGroup(BitEnumPrimaryGroup::Bit0 |
|
|
|
133 BitEnumPrimaryGroup::Bit4 |
|
|
|
134 BitEnumPrimaryGroup::Bit5),
|
|
|
135 "Bits4And5, Bit0");
|
|
|
136 EXPECT_EQ(stringifyBitEnumPrimaryGroup(
|
|
|
137 BitEnumPrimaryGroup::Bit0 | BitEnumPrimaryGroup::Bit1 |
|
|
|
138 BitEnumPrimaryGroup::Bit2 | BitEnumPrimaryGroup::Bit3 |
|
|
|
139 BitEnumPrimaryGroup::Bit4 | BitEnumPrimaryGroup::Bit5),
|
|
|
140 "Bits0To5");
|
|
|
141 }
|
|
|
142
|
|
150
|
143 TEST(EnumsGenTest, GeneratedOperator) {
|
|
236
|
144 EXPECT_TRUE(bitEnumContainsAll(BitEnumWithNone::Bit0 | BitEnumWithNone::Bit3,
|
|
|
145 BitEnumWithNone::Bit0));
|
|
|
146 EXPECT_FALSE(bitEnumContainsAll(BitEnumWithNone::Bit0 & BitEnumWithNone::Bit3,
|
|
|
147 BitEnumWithNone::Bit0));
|
|
150
|
148 }
|
|
|
149
|
|
|
150 TEST(EnumsGenTest, GeneratedSymbolToCustomStringFn) {
|
|
|
151 EXPECT_EQ(stringifyPrettyIntEnum(PrettyIntEnum::Case1), "case_one");
|
|
|
152 EXPECT_EQ(stringifyPrettyIntEnum(PrettyIntEnum::Case2), "case_two");
|
|
|
153 }
|
|
|
154
|
|
|
155 TEST(EnumsGenTest, GeneratedCustomStringToSymbolFn) {
|
|
|
156 auto one = symbolizePrettyIntEnum("case_one");
|
|
|
157 EXPECT_TRUE(one);
|
|
|
158 EXPECT_EQ(*one, PrettyIntEnum::Case1);
|
|
|
159
|
|
|
160 auto two = symbolizePrettyIntEnum("case_two");
|
|
|
161 EXPECT_TRUE(two);
|
|
|
162 EXPECT_EQ(*two, PrettyIntEnum::Case2);
|
|
|
163
|
|
|
164 auto none = symbolizePrettyIntEnum("Case1");
|
|
|
165 EXPECT_FALSE(none);
|
|
|
166 }
|
|
221
|
167
|
|
|
168 TEST(EnumsGenTest, GeneratedIntAttributeClass) {
|
|
|
169 mlir::MLIRContext ctx;
|
|
|
170 I32Enum rawVal = I32Enum::Case5;
|
|
|
171
|
|
|
172 I32EnumAttr enumAttr = I32EnumAttr::get(&ctx, rawVal);
|
|
|
173 EXPECT_NE(enumAttr, nullptr);
|
|
|
174 EXPECT_EQ(enumAttr.getValue(), rawVal);
|
|
|
175
|
|
|
176 mlir::Type intType = mlir::IntegerType::get(&ctx, 32);
|
|
|
177 mlir::Attribute intAttr = mlir::IntegerAttr::get(intType, 5);
|
|
252
|
178 EXPECT_TRUE(llvm::isa<I32EnumAttr>(intAttr));
|
|
221
|
179 EXPECT_EQ(intAttr, enumAttr);
|
|
|
180 }
|
|
|
181
|
|
|
182 TEST(EnumsGenTest, GeneratedBitAttributeClass) {
|
|
|
183 mlir::MLIRContext ctx;
|
|
|
184
|
|
|
185 mlir::Type intType = mlir::IntegerType::get(&ctx, 32);
|
|
|
186 mlir::Attribute intAttr = mlir::IntegerAttr::get(
|
|
|
187 intType,
|
|
236
|
188 static_cast<uint32_t>(BitEnumWithNone::Bit0 | BitEnumWithNone::Bit3));
|
|
252
|
189 EXPECT_TRUE(llvm::isa<BitEnumWithNoneAttr>(intAttr));
|
|
|
190 EXPECT_TRUE(llvm::isa<BitEnumWithoutNoneAttr>(intAttr));
|
|
236
|
191
|
|
|
192 intAttr = mlir::IntegerAttr::get(
|
|
|
193 intType, static_cast<uint32_t>(BitEnumWithGroup::Bits0To3) | (1u << 6));
|
|
252
|
194 EXPECT_FALSE(llvm::isa<BitEnumWithGroupAttr>(intAttr));
|
|
221
|
195 }
|
