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
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
14 #include "llvm/ADT/DenseMap.h"
15 #include "llvm/ADT/StringExtras.h"
16
17 #include "gmock/gmock.h"
18
19 #include <type_traits>
20
21 /// Pull in generated enum utility declarations and definitions.
22 #include "EnumsGenTest.h.inc"
23
24 #include "EnumsGenTest.cpp.inc"
25
26 /// Test namespaces and enum class/utility names.
27 using Outer::Inner::ConvertToEnum;
28 using Outer::Inner::ConvertToString;
29 using Outer::Inner::FooEnum;
30
TEST(EnumsGenTest,GeneratedStrEnumDefinition)31 TEST(EnumsGenTest, GeneratedStrEnumDefinition) {
32 EXPECT_EQ(0u, static_cast<uint64_t>(FooEnum::CaseA));
33 EXPECT_EQ(1u, static_cast<uint64_t>(FooEnum::CaseB));
34 }
35
TEST(EnumsGenTest,GeneratedI32EnumDefinition)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
TEST(EnumsGenTest,GeneratedDenseMapInfo)41 TEST(EnumsGenTest, GeneratedDenseMapInfo) {
42 llvm::DenseMap<FooEnum, std::string> myMap;
43
44 myMap[FooEnum::CaseA] = "zero";
45 myMap[FooEnum::CaseB] = "one";
46
47 EXPECT_EQ(myMap[FooEnum::CaseA], "zero");
48 EXPECT_EQ(myMap[FooEnum::CaseB], "one");
49 }
50
TEST(EnumsGenTest,GeneratedSymbolToStringFn)51 TEST(EnumsGenTest, GeneratedSymbolToStringFn) {
52 EXPECT_EQ(ConvertToString(FooEnum::CaseA), "CaseA");
53 EXPECT_EQ(ConvertToString(FooEnum::CaseB), "CaseB");
54 }
55
TEST(EnumsGenTest,GeneratedStringToSymbolFn)56 TEST(EnumsGenTest, GeneratedStringToSymbolFn) {
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"));
60 }
61
TEST(EnumsGenTest,GeneratedUnderlyingType)62 TEST(EnumsGenTest, GeneratedUnderlyingType) {
63 bool v = std::is_same<uint32_t, std::underlying_type<I32Enum>::type>::value;
64 EXPECT_TRUE(v);
65 }
66
TEST(EnumsGenTest,GeneratedBitEnumDefinition)67 TEST(EnumsGenTest, GeneratedBitEnumDefinition) {
68 EXPECT_EQ(0u, static_cast<uint32_t>(BitEnumWithNone::None));
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));
74 }
75
TEST(EnumsGenTest,GeneratedSymbolToStringFnForBitEnum)76 TEST(EnumsGenTest, GeneratedSymbolToStringFnForBitEnum) {
77 EXPECT_EQ(stringifyBitEnumWithNone(BitEnumWithNone::None), "None");
78 EXPECT_EQ(stringifyBitEnumWithNone(BitEnumWithNone::Bit0), "Bit0");
79 EXPECT_EQ(stringifyBitEnumWithNone(BitEnumWithNone::Bit3), "Bit3");
80 EXPECT_EQ(
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");
88 }
89
TEST(EnumsGenTest,GeneratedStringToSymbolForBitEnum)90 TEST(EnumsGenTest, GeneratedStringToSymbolForBitEnum) {
91 EXPECT_EQ(symbolizeBitEnumWithNone("None"), BitEnumWithNone::None);
92 EXPECT_EQ(symbolizeBitEnumWithNone("Bit0"), BitEnumWithNone::Bit0);
93 EXPECT_EQ(symbolizeBitEnumWithNone("Bit3"), BitEnumWithNone::Bit3);
94 EXPECT_EQ(symbolizeBitEnumWithNone("Bit3|Bit0"),
95 BitEnumWithNone::Bit3 | BitEnumWithNone::Bit0);
96
97 EXPECT_EQ(symbolizeBitEnumWithNone("Bit2"), std::nullopt);
98 EXPECT_EQ(symbolizeBitEnumWithNone("Bit3 | Bit4"), std::nullopt);
99
100 EXPECT_EQ(symbolizeBitEnumWithoutNone("None"), std::nullopt);
101 }
102
TEST(EnumsGenTest,GeneratedSymbolToStringFnForGroupedBitEnum)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
TEST(EnumsGenTest,GeneratedStringToSymbolForGroupedBitEnum)115 TEST(EnumsGenTest, GeneratedStringToSymbolForGroupedBitEnum) {
116 EXPECT_EQ(symbolizeBitEnumWithGroup("Bit0"), BitEnumWithGroup::Bit0);
117 EXPECT_EQ(symbolizeBitEnumWithGroup("Bit3"), BitEnumWithGroup::Bit3);
118 EXPECT_EQ(symbolizeBitEnumWithGroup("Bit5"), std::nullopt);
119 EXPECT_EQ(symbolizeBitEnumWithGroup("Bit3|Bit0"),
120 BitEnumWithGroup::Bit3 | BitEnumWithGroup::Bit0);
121 }
122
TEST(EnumsGenTest,GeneratedSymbolToStringFnForPrimaryGroupBitEnum)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
TEST(EnumsGenTest,GeneratedOperator)143 TEST(EnumsGenTest, GeneratedOperator) {
144 EXPECT_TRUE(bitEnumContainsAll(BitEnumWithNone::Bit0 | BitEnumWithNone::Bit3,
145 BitEnumWithNone::Bit0));
146 EXPECT_FALSE(bitEnumContainsAll(BitEnumWithNone::Bit0 & BitEnumWithNone::Bit3,
147 BitEnumWithNone::Bit0));
148 }
149
TEST(EnumsGenTest,GeneratedSymbolToCustomStringFn)150 TEST(EnumsGenTest, GeneratedSymbolToCustomStringFn) {
151 EXPECT_EQ(stringifyPrettyIntEnum(PrettyIntEnum::Case1), "case_one");
152 EXPECT_EQ(stringifyPrettyIntEnum(PrettyIntEnum::Case2), "case_two");
153 }
154
TEST(EnumsGenTest,GeneratedCustomStringToSymbolFn)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 }
167
TEST(EnumsGenTest,GeneratedIntAttributeClass)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);
178 EXPECT_TRUE(llvm::isa<I32EnumAttr>(intAttr));
179 EXPECT_EQ(intAttr, enumAttr);
180 }
181
TEST(EnumsGenTest,GeneratedBitAttributeClass)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,
188 static_cast<uint32_t>(BitEnumWithNone::Bit0 | BitEnumWithNone::Bit3));
189 EXPECT_TRUE(llvm::isa<BitEnumWithNoneAttr>(intAttr));
190 EXPECT_TRUE(llvm::isa<BitEnumWithoutNoneAttr>(intAttr));
191
192 intAttr = mlir::IntegerAttr::get(
193 intType, static_cast<uint32_t>(BitEnumWithGroup::Bits0To3) | (1u << 6));
194 EXPECT_FALSE(llvm::isa<BitEnumWithGroupAttr>(intAttr));
195 }
196