mlir/unittests/TableGen/EnumsGenTest.cpp

   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
  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
  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) {
  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
  51 TEST(EnumsGenTest, GeneratedSymbolToStringFn) {
  52   EXPECT_EQ(ConvertToString(FooEnum::CaseA), "CaseA");
  53   EXPECT_EQ(ConvertToString(FooEnum::CaseB), "CaseB");
  54 }
  55
  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
  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));
  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
  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
  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
 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);
 118   EXPECT_EQ(symbolizeBitEnumWithGroup("Bit5"), std::nullopt);
 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
 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
 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 }
 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);
 178   EXPECT_TRUE(llvm::isa<I32EnumAttr>(intAttr));
 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,
 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 }