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 #include "llvm/ADT/StringSwitch.h" 17 18 #include "gmock/gmock.h" 19 20 #include <type_traits> 21 22 /// Pull in generated enum utility declarations and definitions. 23 #include "EnumsGenTest.h.inc" 24 25 #include "EnumsGenTest.cpp.inc" 26 27 /// Test namespaces and enum class/utility names. 28 using Outer::Inner::ConvertToEnum; 29 using Outer::Inner::ConvertToString; 30 using Outer::Inner::StrEnum; 31 using Outer::Inner::StrEnumAttr; 32 33 TEST(EnumsGenTest, GeneratedStrEnumDefinition) { 34 EXPECT_EQ(0u, static_cast<uint64_t>(StrEnum::CaseA)); 35 EXPECT_EQ(10u, static_cast<uint64_t>(StrEnum::CaseB)); 36 } 37 38 TEST(EnumsGenTest, GeneratedI32EnumDefinition) { 39 EXPECT_EQ(5u, static_cast<uint64_t>(I32Enum::Case5)); 40 EXPECT_EQ(10u, static_cast<uint64_t>(I32Enum::Case10)); 41 } 42 43 TEST(EnumsGenTest, GeneratedDenseMapInfo) { 44 llvm::DenseMap<StrEnum, std::string> myMap; 45 46 myMap[StrEnum::CaseA] = "zero"; 47 myMap[StrEnum::CaseB] = "one"; 48 49 EXPECT_EQ(myMap[StrEnum::CaseA], "zero"); 50 EXPECT_EQ(myMap[StrEnum::CaseB], "one"); 51 } 52 53 TEST(EnumsGenTest, GeneratedSymbolToStringFn) { 54 EXPECT_EQ(ConvertToString(StrEnum::CaseA), "CaseA"); 55 EXPECT_EQ(ConvertToString(StrEnum::CaseB), "CaseB"); 56 } 57 58 TEST(EnumsGenTest, GeneratedStringToSymbolFn) { 59 EXPECT_EQ(llvm::Optional<StrEnum>(StrEnum::CaseA), ConvertToEnum("CaseA")); 60 EXPECT_EQ(llvm::Optional<StrEnum>(StrEnum::CaseB), ConvertToEnum("CaseB")); 61 EXPECT_EQ(llvm::None, ConvertToEnum("X")); 62 } 63 64 TEST(EnumsGenTest, GeneratedUnderlyingType) { 65 bool v = std::is_same<uint32_t, std::underlying_type<I32Enum>::type>::value; 66 EXPECT_TRUE(v); 67 } 68 69 TEST(EnumsGenTest, GeneratedBitEnumDefinition) { 70 EXPECT_EQ(0u, static_cast<uint32_t>(BitEnumWithNone::None)); 71 EXPECT_EQ(1u, static_cast<uint32_t>(BitEnumWithNone::Bit0)); 72 EXPECT_EQ(8u, static_cast<uint32_t>(BitEnumWithNone::Bit3)); 73 } 74 75 TEST(EnumsGenTest, GeneratedSymbolToStringFnForBitEnum) { 76 EXPECT_EQ(stringifyBitEnumWithNone(BitEnumWithNone::None), "None"); 77 EXPECT_EQ(stringifyBitEnumWithNone(BitEnumWithNone::Bit0), "Bit0"); 78 EXPECT_EQ(stringifyBitEnumWithNone(BitEnumWithNone::Bit3), "Bit3"); 79 EXPECT_EQ( 80 stringifyBitEnumWithNone(BitEnumWithNone::Bit0 | BitEnumWithNone::Bit3), 81 "Bit0|Bit3"); 82 } 83 84 TEST(EnumsGenTest, GeneratedStringToSymbolForBitEnum) { 85 EXPECT_EQ(symbolizeBitEnumWithNone("None"), BitEnumWithNone::None); 86 EXPECT_EQ(symbolizeBitEnumWithNone("Bit0"), BitEnumWithNone::Bit0); 87 EXPECT_EQ(symbolizeBitEnumWithNone("Bit3"), BitEnumWithNone::Bit3); 88 EXPECT_EQ(symbolizeBitEnumWithNone("Bit3|Bit0"), 89 BitEnumWithNone::Bit3 | BitEnumWithNone::Bit0); 90 91 EXPECT_EQ(symbolizeBitEnumWithNone("Bit2"), llvm::None); 92 EXPECT_EQ(symbolizeBitEnumWithNone("Bit3|Bit4"), llvm::None); 93 94 EXPECT_EQ(symbolizeBitEnumWithoutNone("None"), llvm::None); 95 } 96 97 TEST(EnumsGenTest, GeneratedSymbolToStringFnForGroupedBitEnum) { 98 EXPECT_EQ(stringifyBitEnumWithGroup(BitEnumWithGroup::Bit0), "Bit0"); 99 EXPECT_EQ(stringifyBitEnumWithGroup(BitEnumWithGroup::Bit3), "Bit3"); 100 EXPECT_EQ(stringifyBitEnumWithGroup(BitEnumWithGroup::Bits0To3), 101 "Bit0|Bit1|Bit2|Bit3|Bits0To3"); 102 EXPECT_EQ(stringifyBitEnumWithGroup(BitEnumWithGroup::Bit4), "Bit4"); 103 EXPECT_EQ(stringifyBitEnumWithGroup( 104 BitEnumWithGroup::Bit0 | BitEnumWithGroup::Bit1 | 105 BitEnumWithGroup::Bit2 | BitEnumWithGroup::Bit4), 106 "Bit0|Bit1|Bit2|Bit4"); 107 } 108 109 TEST(EnumsGenTest, GeneratedStringToSymbolForGroupedBitEnum) { 110 EXPECT_EQ(symbolizeBitEnumWithGroup("Bit0"), BitEnumWithGroup::Bit0); 111 EXPECT_EQ(symbolizeBitEnumWithGroup("Bit3"), BitEnumWithGroup::Bit3); 112 EXPECT_EQ(symbolizeBitEnumWithGroup("Bit5"), llvm::None); 113 EXPECT_EQ(symbolizeBitEnumWithGroup("Bit3|Bit0"), 114 BitEnumWithGroup::Bit3 | BitEnumWithGroup::Bit0); 115 } 116 117 TEST(EnumsGenTest, GeneratedOperator) { 118 EXPECT_TRUE(bitEnumContains(BitEnumWithNone::Bit0 | BitEnumWithNone::Bit3, 119 BitEnumWithNone::Bit0)); 120 EXPECT_FALSE(bitEnumContains(BitEnumWithNone::Bit0 & BitEnumWithNone::Bit3, 121 BitEnumWithNone::Bit0)); 122 } 123 124 TEST(EnumsGenTest, GeneratedSymbolToCustomStringFn) { 125 EXPECT_EQ(stringifyPrettyIntEnum(PrettyIntEnum::Case1), "case_one"); 126 EXPECT_EQ(stringifyPrettyIntEnum(PrettyIntEnum::Case2), "case_two"); 127 } 128 129 TEST(EnumsGenTest, GeneratedCustomStringToSymbolFn) { 130 auto one = symbolizePrettyIntEnum("case_one"); 131 EXPECT_TRUE(one); 132 EXPECT_EQ(*one, PrettyIntEnum::Case1); 133 134 auto two = symbolizePrettyIntEnum("case_two"); 135 EXPECT_TRUE(two); 136 EXPECT_EQ(*two, PrettyIntEnum::Case2); 137 138 auto none = symbolizePrettyIntEnum("Case1"); 139 EXPECT_FALSE(none); 140 } 141 142 TEST(EnumsGenTest, GeneratedIntAttributeClass) { 143 mlir::MLIRContext ctx; 144 I32Enum rawVal = I32Enum::Case5; 145 146 I32EnumAttr enumAttr = I32EnumAttr::get(&ctx, rawVal); 147 EXPECT_NE(enumAttr, nullptr); 148 EXPECT_EQ(enumAttr.getValue(), rawVal); 149 150 mlir::Type intType = mlir::IntegerType::get(&ctx, 32); 151 mlir::Attribute intAttr = mlir::IntegerAttr::get(intType, 5); 152 EXPECT_TRUE(intAttr.isa<I32EnumAttr>()); 153 EXPECT_EQ(intAttr, enumAttr); 154 } 155 156 TEST(EnumsGenTest, GeneratedStringAttributeClass) { 157 mlir::MLIRContext ctx; 158 StrEnum rawVal = StrEnum::CaseA; 159 160 StrEnumAttr enumAttr = StrEnumAttr::get(&ctx, rawVal); 161 EXPECT_NE(enumAttr, nullptr); 162 EXPECT_EQ(enumAttr.getValue(), rawVal); 163 164 mlir::Attribute strAttr = mlir::StringAttr::get(&ctx, "CaseA"); 165 EXPECT_TRUE(strAttr.isa<StrEnumAttr>()); 166 EXPECT_EQ(strAttr, enumAttr); 167 } 168 169 TEST(EnumsGenTest, GeneratedBitAttributeClass) { 170 mlir::MLIRContext ctx; 171 172 mlir::Type intType = mlir::IntegerType::get(&ctx, 32); 173 mlir::Attribute intAttr = mlir::IntegerAttr::get( 174 intType, 175 static_cast<uint32_t>(BitEnumWithNone::Bit0 | BitEnumWithNone::Bit3)); 176 EXPECT_TRUE(intAttr.isa<BitEnumWithNoneAttr>()); 177 EXPECT_TRUE(intAttr.isa<BitEnumWithoutNoneAttr>()); 178 179 intAttr = mlir::IntegerAttr::get( 180 intType, static_cast<uint32_t>(BitEnumWithGroup::Bits0To3) | (1u << 6)); 181 EXPECT_FALSE(intAttr.isa<BitEnumWithGroupAttr>()); 182 } 183