Ops.capi.test.cpp.inc

Go to the documentation of this file.

/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Op C API Tests                                                             *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|* From: Ops.td                                                               *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/
 
class FeltOperationLinkTests : public CAPITest {};

TEST_F(FeltOperationLinkTests, IsA_Felt_AddFeltOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Felt_AddFeltOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}

TEST_F(FeltOperationLinkTests, llzk_AddFeltOp_Build) {
  // Returns an `arith.constant` op, which will never match the AddFeltOp dialect check.
  auto testOp = createIndexOperation();
 
  // This condition is always false, so the function is never actually called.
  // We only verify it compiles and links correctly.
  if (llzkOperationIsA_Felt_AddFeltOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto resultType = createIndexType();
 
    (void)llzkFelt_AddFeltOpBuild(builder, location, resultType, dummyValue, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct AddFeltOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Felt_AddFeltOp(op); }
  static std::unique_ptr<AddFeltOpBuildFuncHelper> get();
 
protected:
  AddFeltOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, AddFeltOp_build_pass) { AddFeltOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(FeltOperationLinkTests, llzk_AddFeltOp_GetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_AddFeltOp(testOp)) {
    (void)llzkFelt_AddFeltOpGetLhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_AddFeltOp_SetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_AddFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_AddFeltOpSetLhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_AddFeltOp_GetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_AddFeltOp(testOp)) {
    (void)llzkFelt_AddFeltOpGetRhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_AddFeltOp_SetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_AddFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_AddFeltOpSetRhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_AddFeltOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_AddFeltOp(testOp)) {
    (void)llzkFelt_AddFeltOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(FeltOperationLinkTests, IsA_Felt_AndFeltOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Felt_AndFeltOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}

TEST_F(FeltOperationLinkTests, llzk_AndFeltOp_Build) {
  // Returns an `arith.constant` op, which will never match the AndFeltOp dialect check.
  auto testOp = createIndexOperation();
 
  // This condition is always false, so the function is never actually called.
  // We only verify it compiles and links correctly.
  if (llzkOperationIsA_Felt_AndFeltOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto resultType = createIndexType();
 
    (void)llzkFelt_AndFeltOpBuild(builder, location, resultType, dummyValue, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct AndFeltOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Felt_AndFeltOp(op); }
  static std::unique_ptr<AndFeltOpBuildFuncHelper> get();
 
protected:
  AndFeltOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, AndFeltOp_build_pass) { AndFeltOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(FeltOperationLinkTests, llzk_AndFeltOp_GetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_AndFeltOp(testOp)) {
    (void)llzkFelt_AndFeltOpGetLhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_AndFeltOp_SetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_AndFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_AndFeltOpSetLhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_AndFeltOp_GetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_AndFeltOp(testOp)) {
    (void)llzkFelt_AndFeltOpGetRhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_AndFeltOp_SetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_AndFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_AndFeltOpSetRhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_AndFeltOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_AndFeltOp(testOp)) {
    (void)llzkFelt_AndFeltOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(FeltOperationLinkTests, IsA_Felt_DivFeltOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Felt_DivFeltOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}

TEST_F(FeltOperationLinkTests, llzk_DivFeltOp_Build) {
  // Returns an `arith.constant` op, which will never match the DivFeltOp dialect check.
  auto testOp = createIndexOperation();
 
  // This condition is always false, so the function is never actually called.
  // We only verify it compiles and links correctly.
  if (llzkOperationIsA_Felt_DivFeltOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto resultType = createIndexType();
 
    (void)llzkFelt_DivFeltOpBuild(builder, location, resultType, dummyValue, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct DivFeltOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Felt_DivFeltOp(op); }
  static std::unique_ptr<DivFeltOpBuildFuncHelper> get();
 
protected:
  DivFeltOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, DivFeltOp_build_pass) { DivFeltOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(FeltOperationLinkTests, llzk_DivFeltOp_GetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_DivFeltOp(testOp)) {
    (void)llzkFelt_DivFeltOpGetLhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_DivFeltOp_SetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_DivFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_DivFeltOpSetLhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_DivFeltOp_GetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_DivFeltOp(testOp)) {
    (void)llzkFelt_DivFeltOpGetRhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_DivFeltOp_SetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_DivFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_DivFeltOpSetRhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_DivFeltOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_DivFeltOp(testOp)) {
    (void)llzkFelt_DivFeltOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(FeltOperationLinkTests, IsA_Felt_FeltConstantOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Felt_FeltConstantOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}

TEST_F(FeltOperationLinkTests, llzk_FeltConstantOp_Build) {
  // Returns an `arith.constant` op, which will never match the FeltConstantOp dialect check.
  auto testOp = createIndexOperation();
 
  // This condition is always false, so the function is never actually called.
  // We only verify it compiles and links correctly.
  if (llzkOperationIsA_Felt_FeltConstantOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto resultType = createIndexType();
    auto valueAttr = createIndexAttribute();
 
    (void)llzkFelt_FeltConstantOpBuild(builder, location, resultType, valueAttr);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct FeltConstantOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Felt_FeltConstantOp(op); }
  static std::unique_ptr<FeltConstantOpBuildFuncHelper> get();
 
protected:
  FeltConstantOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, FeltConstantOp_build_pass) { FeltConstantOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(FeltOperationLinkTests, llzk_FeltConstantOp_GetValueAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_FeltConstantOp(testOp)) {
    (void)llzkFelt_FeltConstantOpGetValue(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_FeltConstantOp_SetValueAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_FeltConstantOp(testOp)) {
    llzkFelt_FeltConstantOpSetValue(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_FeltConstantOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_FeltConstantOp(testOp)) {
    (void)llzkFelt_FeltConstantOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(FeltOperationLinkTests, IsA_Felt_InvFeltOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Felt_InvFeltOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}

TEST_F(FeltOperationLinkTests, llzk_InvFeltOp_Build) {
  // Returns an `arith.constant` op, which will never match the InvFeltOp dialect check.
  auto testOp = createIndexOperation();
 
  // This condition is always false, so the function is never actually called.
  // We only verify it compiles and links correctly.
  if (llzkOperationIsA_Felt_InvFeltOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto resultType = createIndexType();
 
    (void)llzkFelt_InvFeltOpBuild(builder, location, resultType, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct InvFeltOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Felt_InvFeltOp(op); }
  static std::unique_ptr<InvFeltOpBuildFuncHelper> get();
 
protected:
  InvFeltOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, InvFeltOp_build_pass) { InvFeltOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(FeltOperationLinkTests, llzk_InvFeltOp_GetOperand) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_InvFeltOp(testOp)) {
    (void)llzkFelt_InvFeltOpGetOperand(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_InvFeltOp_SetOperand) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_InvFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_InvFeltOpSetOperand(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_InvFeltOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_InvFeltOp(testOp)) {
    (void)llzkFelt_InvFeltOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(FeltOperationLinkTests, IsA_Felt_MulFeltOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Felt_MulFeltOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}

TEST_F(FeltOperationLinkTests, llzk_MulFeltOp_Build) {
  // Returns an `arith.constant` op, which will never match the MulFeltOp dialect check.
  auto testOp = createIndexOperation();
 
  // This condition is always false, so the function is never actually called.
  // We only verify it compiles and links correctly.
  if (llzkOperationIsA_Felt_MulFeltOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto resultType = createIndexType();
 
    (void)llzkFelt_MulFeltOpBuild(builder, location, resultType, dummyValue, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct MulFeltOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Felt_MulFeltOp(op); }
  static std::unique_ptr<MulFeltOpBuildFuncHelper> get();
 
protected:
  MulFeltOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, MulFeltOp_build_pass) { MulFeltOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(FeltOperationLinkTests, llzk_MulFeltOp_GetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_MulFeltOp(testOp)) {
    (void)llzkFelt_MulFeltOpGetLhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_MulFeltOp_SetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_MulFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_MulFeltOpSetLhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_MulFeltOp_GetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_MulFeltOp(testOp)) {
    (void)llzkFelt_MulFeltOpGetRhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_MulFeltOp_SetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_MulFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_MulFeltOpSetRhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_MulFeltOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_MulFeltOp(testOp)) {
    (void)llzkFelt_MulFeltOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(FeltOperationLinkTests, IsA_Felt_NegFeltOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Felt_NegFeltOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}

TEST_F(FeltOperationLinkTests, llzk_NegFeltOp_Build) {
  // Returns an `arith.constant` op, which will never match the NegFeltOp dialect check.
  auto testOp = createIndexOperation();
 
  // This condition is always false, so the function is never actually called.
  // We only verify it compiles and links correctly.
  if (llzkOperationIsA_Felt_NegFeltOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto resultType = createIndexType();
 
    (void)llzkFelt_NegFeltOpBuild(builder, location, resultType, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct NegFeltOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Felt_NegFeltOp(op); }
  static std::unique_ptr<NegFeltOpBuildFuncHelper> get();
 
protected:
  NegFeltOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, NegFeltOp_build_pass) { NegFeltOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(FeltOperationLinkTests, llzk_NegFeltOp_GetOperand) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_NegFeltOp(testOp)) {
    (void)llzkFelt_NegFeltOpGetOperand(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_NegFeltOp_SetOperand) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_NegFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_NegFeltOpSetOperand(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_NegFeltOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_NegFeltOp(testOp)) {
    (void)llzkFelt_NegFeltOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(FeltOperationLinkTests, IsA_Felt_NotFeltOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Felt_NotFeltOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}

TEST_F(FeltOperationLinkTests, llzk_NotFeltOp_Build) {
  // Returns an `arith.constant` op, which will never match the NotFeltOp dialect check.
  auto testOp = createIndexOperation();
 
  // This condition is always false, so the function is never actually called.
  // We only verify it compiles and links correctly.
  if (llzkOperationIsA_Felt_NotFeltOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto resultType = createIndexType();
 
    (void)llzkFelt_NotFeltOpBuild(builder, location, resultType, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct NotFeltOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Felt_NotFeltOp(op); }
  static std::unique_ptr<NotFeltOpBuildFuncHelper> get();
 
protected:
  NotFeltOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, NotFeltOp_build_pass) { NotFeltOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(FeltOperationLinkTests, llzk_NotFeltOp_GetOperand) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_NotFeltOp(testOp)) {
    (void)llzkFelt_NotFeltOpGetOperand(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_NotFeltOp_SetOperand) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_NotFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_NotFeltOpSetOperand(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_NotFeltOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_NotFeltOp(testOp)) {
    (void)llzkFelt_NotFeltOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(FeltOperationLinkTests, IsA_Felt_OrFeltOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Felt_OrFeltOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}

TEST_F(FeltOperationLinkTests, llzk_OrFeltOp_Build) {
  // Returns an `arith.constant` op, which will never match the OrFeltOp dialect check.
  auto testOp = createIndexOperation();
 
  // This condition is always false, so the function is never actually called.
  // We only verify it compiles and links correctly.
  if (llzkOperationIsA_Felt_OrFeltOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto resultType = createIndexType();
 
    (void)llzkFelt_OrFeltOpBuild(builder, location, resultType, dummyValue, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct OrFeltOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Felt_OrFeltOp(op); }
  static std::unique_ptr<OrFeltOpBuildFuncHelper> get();
 
protected:
  OrFeltOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, OrFeltOp_build_pass) { OrFeltOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(FeltOperationLinkTests, llzk_OrFeltOp_GetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_OrFeltOp(testOp)) {
    (void)llzkFelt_OrFeltOpGetLhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_OrFeltOp_SetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_OrFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_OrFeltOpSetLhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_OrFeltOp_GetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_OrFeltOp(testOp)) {
    (void)llzkFelt_OrFeltOpGetRhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_OrFeltOp_SetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_OrFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_OrFeltOpSetRhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_OrFeltOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_OrFeltOp(testOp)) {
    (void)llzkFelt_OrFeltOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(FeltOperationLinkTests, IsA_Felt_PowFeltOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Felt_PowFeltOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}

TEST_F(FeltOperationLinkTests, llzk_PowFeltOp_Build) {
  // Returns an `arith.constant` op, which will never match the PowFeltOp dialect check.
  auto testOp = createIndexOperation();
 
  // This condition is always false, so the function is never actually called.
  // We only verify it compiles and links correctly.
  if (llzkOperationIsA_Felt_PowFeltOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto resultType = createIndexType();
 
    (void)llzkFelt_PowFeltOpBuild(builder, location, resultType, dummyValue, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct PowFeltOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Felt_PowFeltOp(op); }
  static std::unique_ptr<PowFeltOpBuildFuncHelper> get();
 
protected:
  PowFeltOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, PowFeltOp_build_pass) { PowFeltOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(FeltOperationLinkTests, llzk_PowFeltOp_GetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_PowFeltOp(testOp)) {
    (void)llzkFelt_PowFeltOpGetLhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_PowFeltOp_SetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_PowFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_PowFeltOpSetLhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_PowFeltOp_GetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_PowFeltOp(testOp)) {
    (void)llzkFelt_PowFeltOpGetRhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_PowFeltOp_SetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_PowFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_PowFeltOpSetRhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_PowFeltOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_PowFeltOp(testOp)) {
    (void)llzkFelt_PowFeltOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(FeltOperationLinkTests, IsA_Felt_ShlFeltOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Felt_ShlFeltOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}

TEST_F(FeltOperationLinkTests, llzk_ShlFeltOp_Build) {
  // Returns an `arith.constant` op, which will never match the ShlFeltOp dialect check.
  auto testOp = createIndexOperation();
 
  // This condition is always false, so the function is never actually called.
  // We only verify it compiles and links correctly.
  if (llzkOperationIsA_Felt_ShlFeltOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto resultType = createIndexType();
 
    (void)llzkFelt_ShlFeltOpBuild(builder, location, resultType, dummyValue, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct ShlFeltOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Felt_ShlFeltOp(op); }
  static std::unique_ptr<ShlFeltOpBuildFuncHelper> get();
 
protected:
  ShlFeltOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, ShlFeltOp_build_pass) { ShlFeltOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(FeltOperationLinkTests, llzk_ShlFeltOp_GetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_ShlFeltOp(testOp)) {
    (void)llzkFelt_ShlFeltOpGetLhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_ShlFeltOp_SetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_ShlFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_ShlFeltOpSetLhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_ShlFeltOp_GetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_ShlFeltOp(testOp)) {
    (void)llzkFelt_ShlFeltOpGetRhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_ShlFeltOp_SetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_ShlFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_ShlFeltOpSetRhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_ShlFeltOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_ShlFeltOp(testOp)) {
    (void)llzkFelt_ShlFeltOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(FeltOperationLinkTests, IsA_Felt_ShrFeltOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Felt_ShrFeltOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}

TEST_F(FeltOperationLinkTests, llzk_ShrFeltOp_Build) {
  // Returns an `arith.constant` op, which will never match the ShrFeltOp dialect check.
  auto testOp = createIndexOperation();
 
  // This condition is always false, so the function is never actually called.
  // We only verify it compiles and links correctly.
  if (llzkOperationIsA_Felt_ShrFeltOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto resultType = createIndexType();
 
    (void)llzkFelt_ShrFeltOpBuild(builder, location, resultType, dummyValue, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct ShrFeltOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Felt_ShrFeltOp(op); }
  static std::unique_ptr<ShrFeltOpBuildFuncHelper> get();
 
protected:
  ShrFeltOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, ShrFeltOp_build_pass) { ShrFeltOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(FeltOperationLinkTests, llzk_ShrFeltOp_GetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_ShrFeltOp(testOp)) {
    (void)llzkFelt_ShrFeltOpGetLhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_ShrFeltOp_SetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_ShrFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_ShrFeltOpSetLhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_ShrFeltOp_GetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_ShrFeltOp(testOp)) {
    (void)llzkFelt_ShrFeltOpGetRhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_ShrFeltOp_SetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_ShrFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_ShrFeltOpSetRhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_ShrFeltOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_ShrFeltOp(testOp)) {
    (void)llzkFelt_ShrFeltOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(FeltOperationLinkTests, IsA_Felt_SignedIntDivFeltOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Felt_SignedIntDivFeltOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}

TEST_F(FeltOperationLinkTests, llzk_SignedIntDivFeltOp_Build) {
  // Returns an `arith.constant` op, which will never match the SignedIntDivFeltOp dialect check.
  auto testOp = createIndexOperation();
 
  // This condition is always false, so the function is never actually called.
  // We only verify it compiles and links correctly.
  if (llzkOperationIsA_Felt_SignedIntDivFeltOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto resultType = createIndexType();
 
    (void)llzkFelt_SignedIntDivFeltOpBuild(builder, location, resultType, dummyValue, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct SignedIntDivFeltOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Felt_SignedIntDivFeltOp(op); }
  static std::unique_ptr<SignedIntDivFeltOpBuildFuncHelper> get();
 
protected:
  SignedIntDivFeltOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, SignedIntDivFeltOp_build_pass) { SignedIntDivFeltOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(FeltOperationLinkTests, llzk_SignedIntDivFeltOp_GetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_SignedIntDivFeltOp(testOp)) {
    (void)llzkFelt_SignedIntDivFeltOpGetLhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_SignedIntDivFeltOp_SetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_SignedIntDivFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_SignedIntDivFeltOpSetLhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_SignedIntDivFeltOp_GetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_SignedIntDivFeltOp(testOp)) {
    (void)llzkFelt_SignedIntDivFeltOpGetRhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_SignedIntDivFeltOp_SetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_SignedIntDivFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_SignedIntDivFeltOpSetRhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_SignedIntDivFeltOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_SignedIntDivFeltOp(testOp)) {
    (void)llzkFelt_SignedIntDivFeltOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(FeltOperationLinkTests, IsA_Felt_SignedModFeltOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Felt_SignedModFeltOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}

TEST_F(FeltOperationLinkTests, llzk_SignedModFeltOp_Build) {
  // Returns an `arith.constant` op, which will never match the SignedModFeltOp dialect check.
  auto testOp = createIndexOperation();
 
  // This condition is always false, so the function is never actually called.
  // We only verify it compiles and links correctly.
  if (llzkOperationIsA_Felt_SignedModFeltOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto resultType = createIndexType();
 
    (void)llzkFelt_SignedModFeltOpBuild(builder, location, resultType, dummyValue, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct SignedModFeltOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Felt_SignedModFeltOp(op); }
  static std::unique_ptr<SignedModFeltOpBuildFuncHelper> get();
 
protected:
  SignedModFeltOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, SignedModFeltOp_build_pass) { SignedModFeltOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(FeltOperationLinkTests, llzk_SignedModFeltOp_GetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_SignedModFeltOp(testOp)) {
    (void)llzkFelt_SignedModFeltOpGetLhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_SignedModFeltOp_SetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_SignedModFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_SignedModFeltOpSetLhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_SignedModFeltOp_GetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_SignedModFeltOp(testOp)) {
    (void)llzkFelt_SignedModFeltOpGetRhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_SignedModFeltOp_SetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_SignedModFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_SignedModFeltOpSetRhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_SignedModFeltOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_SignedModFeltOp(testOp)) {
    (void)llzkFelt_SignedModFeltOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(FeltOperationLinkTests, IsA_Felt_SubFeltOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Felt_SubFeltOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}

TEST_F(FeltOperationLinkTests, llzk_SubFeltOp_Build) {
  // Returns an `arith.constant` op, which will never match the SubFeltOp dialect check.
  auto testOp = createIndexOperation();
 
  // This condition is always false, so the function is never actually called.
  // We only verify it compiles and links correctly.
  if (llzkOperationIsA_Felt_SubFeltOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto resultType = createIndexType();
 
    (void)llzkFelt_SubFeltOpBuild(builder, location, resultType, dummyValue, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct SubFeltOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Felt_SubFeltOp(op); }
  static std::unique_ptr<SubFeltOpBuildFuncHelper> get();
 
protected:
  SubFeltOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, SubFeltOp_build_pass) { SubFeltOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(FeltOperationLinkTests, llzk_SubFeltOp_GetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_SubFeltOp(testOp)) {
    (void)llzkFelt_SubFeltOpGetLhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_SubFeltOp_SetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_SubFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_SubFeltOpSetLhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_SubFeltOp_GetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_SubFeltOp(testOp)) {
    (void)llzkFelt_SubFeltOpGetRhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_SubFeltOp_SetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_SubFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_SubFeltOpSetRhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_SubFeltOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_SubFeltOp(testOp)) {
    (void)llzkFelt_SubFeltOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(FeltOperationLinkTests, IsA_Felt_UnsignedIntDivFeltOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Felt_UnsignedIntDivFeltOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}

TEST_F(FeltOperationLinkTests, llzk_UnsignedIntDivFeltOp_Build) {
  // Returns an `arith.constant` op, which will never match the UnsignedIntDivFeltOp dialect check.
  auto testOp = createIndexOperation();
 
  // This condition is always false, so the function is never actually called.
  // We only verify it compiles and links correctly.
  if (llzkOperationIsA_Felt_UnsignedIntDivFeltOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto resultType = createIndexType();
 
    (void)llzkFelt_UnsignedIntDivFeltOpBuild(builder, location, resultType, dummyValue, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct UnsignedIntDivFeltOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Felt_UnsignedIntDivFeltOp(op); }
  static std::unique_ptr<UnsignedIntDivFeltOpBuildFuncHelper> get();
 
protected:
  UnsignedIntDivFeltOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, UnsignedIntDivFeltOp_build_pass) { UnsignedIntDivFeltOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(FeltOperationLinkTests, llzk_UnsignedIntDivFeltOp_GetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_UnsignedIntDivFeltOp(testOp)) {
    (void)llzkFelt_UnsignedIntDivFeltOpGetLhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_UnsignedIntDivFeltOp_SetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_UnsignedIntDivFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_UnsignedIntDivFeltOpSetLhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_UnsignedIntDivFeltOp_GetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_UnsignedIntDivFeltOp(testOp)) {
    (void)llzkFelt_UnsignedIntDivFeltOpGetRhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_UnsignedIntDivFeltOp_SetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_UnsignedIntDivFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_UnsignedIntDivFeltOpSetRhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_UnsignedIntDivFeltOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_UnsignedIntDivFeltOp(testOp)) {
    (void)llzkFelt_UnsignedIntDivFeltOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(FeltOperationLinkTests, IsA_Felt_UnsignedModFeltOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Felt_UnsignedModFeltOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}

TEST_F(FeltOperationLinkTests, llzk_UnsignedModFeltOp_Build) {
  // Returns an `arith.constant` op, which will never match the UnsignedModFeltOp dialect check.
  auto testOp = createIndexOperation();
 
  // This condition is always false, so the function is never actually called.
  // We only verify it compiles and links correctly.
  if (llzkOperationIsA_Felt_UnsignedModFeltOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto resultType = createIndexType();
 
    (void)llzkFelt_UnsignedModFeltOpBuild(builder, location, resultType, dummyValue, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct UnsignedModFeltOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Felt_UnsignedModFeltOp(op); }
  static std::unique_ptr<UnsignedModFeltOpBuildFuncHelper> get();
 
protected:
  UnsignedModFeltOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, UnsignedModFeltOp_build_pass) { UnsignedModFeltOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(FeltOperationLinkTests, llzk_UnsignedModFeltOp_GetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_UnsignedModFeltOp(testOp)) {
    (void)llzkFelt_UnsignedModFeltOpGetLhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_UnsignedModFeltOp_SetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_UnsignedModFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_UnsignedModFeltOpSetLhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_UnsignedModFeltOp_GetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_UnsignedModFeltOp(testOp)) {
    (void)llzkFelt_UnsignedModFeltOpGetRhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_UnsignedModFeltOp_SetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_UnsignedModFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_UnsignedModFeltOpSetRhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_UnsignedModFeltOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_UnsignedModFeltOp(testOp)) {
    (void)llzkFelt_UnsignedModFeltOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(FeltOperationLinkTests, IsA_Felt_XorFeltOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Felt_XorFeltOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}

TEST_F(FeltOperationLinkTests, llzk_XorFeltOp_Build) {
  // Returns an `arith.constant` op, which will never match the XorFeltOp dialect check.
  auto testOp = createIndexOperation();
 
  // This condition is always false, so the function is never actually called.
  // We only verify it compiles and links correctly.
  if (llzkOperationIsA_Felt_XorFeltOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto resultType = createIndexType();
 
    (void)llzkFelt_XorFeltOpBuild(builder, location, resultType, dummyValue, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct XorFeltOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Felt_XorFeltOp(op); }
  static std::unique_ptr<XorFeltOpBuildFuncHelper> get();
 
protected:
  XorFeltOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, XorFeltOp_build_pass) { XorFeltOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(FeltOperationLinkTests, llzk_XorFeltOp_GetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_XorFeltOp(testOp)) {
    (void)llzkFelt_XorFeltOpGetLhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_XorFeltOp_SetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_XorFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_XorFeltOpSetLhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_XorFeltOp_GetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_XorFeltOp(testOp)) {
    (void)llzkFelt_XorFeltOpGetRhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_XorFeltOp_SetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_XorFeltOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkFelt_XorFeltOpSetRhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(FeltOperationLinkTests, llzk_XorFeltOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Felt_XorFeltOp(testOp)) {
    (void)llzkFelt_XorFeltOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}