EnumCAPITestGen.cpp

Go to the documentation of this file.

//===- EnumCAPITestGen.cpp - C API test generator for enums ---------------===//
//
// Part of the LLZK Project, under the Apache License v2.0.
// See LICENSE.txt for license information.
// Copyright 2025 Veridise Inc.
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
//
// EnumCAPITestGen generates unit tests for the C API enums generated by
// EnumCAPIGen. These are link-time tests that ensure all generated enum
// declarations and wrap/unwrap functions compile and link properly.
//
// Test Strategy:
// - Tests verify enum values can be assigned and compared
// - Tests verify wrap/unwrap functions compile and link (though the C++ type
//   doesn't exist in test context, the functions still need to link)
// - This ensures all enum cases are properly declared and wrap/unwrap functions
//   have correct signatures
//
//===----------------------------------------------------------------------===//
 
#include "CAPIGenRegistration.h"
#include "CommonCAPIGen.h"
 
#include <mlir/TableGen/EnumInfo.h>
#include <mlir/TableGen/GenInfo.h>
 
#include <llvm/ADT/StringExtras.h>
#include <llvm/Support/CommandLine.h>
#include <llvm/Support/FormatVariadic.h>
#include <llvm/TableGen/Record.h>
#include <llvm/TableGen/TableGenBackend.h>
 
using namespace mlir;
using namespace mlir::tblgen;
 
namespace {

struct EnumTestGenerator : public TestGenerator {
  EnumTestGenerator(llvm::raw_ostream &outputStream) : TestGenerator("Enum", outputStream) {}
 
  void genExtraMethod(const ExtraMethod & /*method*/) const override {
    llvm_unreachable("Enums cannot have extra methods");
  }

  void genEnumUsageTest(StringRef cEnumName, StringRef firstCaseValue) const {
    static constexpr char fmt[] = R"(
TEST_F({0}EnumLinkTests, Enum_{1}_Usage) {{
  // We create a variable and check that enum values can be assigned.
  {1} enumValue = {2};
  (void)enumValue;
 
  // Verify we can compare enum values
  EXPECT_EQ(enumValue, {2});
}
)";
    os << llvm::formatv(fmt, dialectNameCapitalized, cEnumName, firstCaseValue);
  }

  void genWrapUnwrapTest(StringRef cEnumName, StringRef firstCaseValue) const {
    static constexpr char fmt[] = R"(
TEST_F({0}EnumLinkTests, Enum_{1}_WrapUnwrap) {{
  // We use the first enum case value for testing.
  {1} cValue = {2};
 
  // Test that wrap and unwrap are inverses (at compile/link time)
  // The actual C++ type doesn't exist in test context, so we just
  // verify the functions exist and link.
  {1} roundTrip = wrap(unwrap(cValue));
  EXPECT_EQ(cValue, roundTrip);
}
)";
    os << llvm::formatv(fmt, dialectNameCapitalized, cEnumName, firstCaseValue);
  }

  void genCompleteRecord(const EnumInfo &enumInfo) {
    // EnumInfo does not contain a Dialect reference, so filter by C++ namespace instead.
    if (!getDialectName().empty() &&
        !enumInfo.getCppNamespace().contains_insensitive(getDialectName())) {
      return;
    }
 
    std::vector<EnumCase> enumCases = enumInfo.getAllCases();
    if (enumCases.empty()) {
      return;
    }
 
    // Get enum name
    std::string cEnumName = toPascalCase(getFunctionPrefix()) + toPascalCase(getDialectName()) +
                            toPascalCase(enumInfo.getEnumClassName());
 
    // Get first enum case for testing
    std::string firstCaseValue =
        llvm::formatv("{0}_{1}", cEnumName, enumCases[0].getSymbol()).str();
 
    // Generate enum usage test
    this->genEnumUsageTest(cEnumName, firstCaseValue);
 
    // Generate wrap/unwrap test
    this->genWrapUnwrapTest(cEnumName, firstCaseValue);
  }
};
 
} // namespace

static bool emitEnumCAPITests(const llvm::RecordKeeper &records, raw_ostream &os) {
  // Generate file header
  emitSourceFileHeader("Enum C API Tests", os, records);
 
  // Create generator
  EnumTestGenerator generator(os);
 
  // Generate test class prologue
  generator.genTestClassPrologue();
 
  // Generate tests for each enum
  for (const auto *def : records.getAllDerivedDefinitionsIfDefined("EnumAttrInfo")) {
    EnumInfo enumInfo(def);
    generator.genCompleteRecord(enumInfo);
  }
 
  return false;
}
 
void llzk::registerEnumCAPITestGenerator() {
  static mlir::GenRegistration genEnumCAPITests(
      "gen-enum-capi-tests", "Generate enum C API unit tests", &emitEnumCAPITests
  );
}