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.
27using Outer::Inner::ConvertToEnum;
28using Outer::Inner::ConvertToString;
29using Outer::Inner::FooEnum;
30
31TEST(EnumsGenTest, GeneratedStrEnumDefinition) {
32 EXPECT_EQ(0u, static_cast<uint64_t>(FooEnum::CaseA));
33 EXPECT_EQ(1u, static_cast<uint64_t>(FooEnum::CaseB));
34}
35
36TEST(EnumsGenTest, GeneratedI32EnumDefinition) {
37 EXPECT_EQ(5u, static_cast<uint64_t>(I32Enum::Case5));
38 EXPECT_EQ(10u, static_cast<uint64_t>(I32Enum::Case10));
39}
40
41TEST(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
51TEST(EnumsGenTest, GeneratedSymbolToStringFn) {
52 EXPECT_EQ(ConvertToString(FooEnum::CaseA), "CaseA");
53 EXPECT_EQ(ConvertToString(FooEnum::CaseB), "CaseB");
54}
55
56TEST(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
62TEST(EnumsGenTest, GeneratedUnderlyingType) {
63 bool v = std::is_same<uint32_t, std::underlying_type<I32Enum>::type>::value;
64 EXPECT_TRUE(v);
65}
66
67TEST(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
76TEST(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
90TEST(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
103TEST(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
115TEST(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
123TEST(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
143TEST(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
150TEST(EnumsGenTest, GeneratedSymbolToCustomStringFn) {
151 EXPECT_EQ(stringifyPrettyIntEnum(PrettyIntEnum::Case1), "case_one");
152 EXPECT_EQ(stringifyPrettyIntEnum(PrettyIntEnum::Case2), "case_two");
153}
154
155TEST(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
168TEST(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
182TEST(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

source code of mlir/unittests/TableGen/EnumsGenTest.cpp