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 VerifOperationLinkTests : public CAPITest {};

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

TEST_F(VerifOperationLinkTests, llzk_AssumeDetOp_Build) {
  // Returns an `arith.constant` op, which will never match the AssumeDetOp 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_Verif_AssumeDetOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
 
    (void)llzkVerif_AssumeDetOpBuild(builder, location, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct AssumeDetOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Verif_AssumeDetOp(op); }
  static std::unique_ptr<AssumeDetOpBuildFuncHelper> get();
 
protected:
  AssumeDetOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, Verif_AssumeDetOp_build_pass) { AssumeDetOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(VerifOperationLinkTests, llzk_AssumeDetOp_GetHint) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_AssumeDetOp(testOp)) {
    (void)llzkVerif_AssumeDetOpGetHint(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_AssumeDetOp_SetHint) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_AssumeDetOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkVerif_AssumeDetOpSetHint(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}

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

TEST_F(VerifOperationLinkTests, llzk_ContractEndOp_Build) {
  // Returns an `arith.constant` op, which will never match the ContractEndOp 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_Verif_ContractEndOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
 
    (void)llzkVerif_ContractEndOpBuild(builder, location);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct ContractEndOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Verif_ContractEndOp(op); }
  static std::unique_ptr<ContractEndOpBuildFuncHelper> get();
 
protected:
  ContractEndOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, Verif_ContractEndOp_build_pass) { ContractEndOpBuildFuncHelper::get()->run(*this); }

TEST_F(VerifOperationLinkTests, IsA_Verif_ContractOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Verif_ContractOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}
 
TEST_F(VerifOperationLinkTests, llzk_ContractOp_GetSymNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_ContractOp(testOp)) {
    (void)llzkVerif_ContractOpGetSymName(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_ContractOp_SetSymNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_ContractOp(testOp)) {
    llzkVerif_ContractOpSetSymName(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_ContractOp_GetTargetAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_ContractOp(testOp)) {
    (void)llzkVerif_ContractOpGetTarget(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_ContractOp_SetTargetAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_ContractOp(testOp)) {
    llzkVerif_ContractOpSetTarget(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_ContractOp_GetFunctionTypeAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_ContractOp(testOp)) {
    (void)llzkVerif_ContractOpGetFunctionType(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_ContractOp_SetFunctionTypeAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_ContractOp(testOp)) {
    llzkVerif_ContractOpSetFunctionType(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_ContractOp_GetArgAttrsAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_ContractOp(testOp)) {
    (void)llzkVerif_ContractOpGetArgAttrs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_ContractOp_SetArgAttrsAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_ContractOp(testOp)) {
    llzkVerif_ContractOpSetArgAttrs(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_ContractOp_GetBodyRegion) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_ContractOp(testOp)) {
    (void)llzkVerif_ContractOpGetBody(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(VerifOperationLinkTests, llzk_ContractOp_IsDeclaration) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Verif_ContractOp(testOperation)) {
 
    (void)llzkVerif_ContractOpIsDeclaration(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

TEST_F(VerifOperationLinkTests, llzk_ContractOp_HasArgPublicAttr) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Verif_ContractOp(testOperation)) {
    unsigned index = 0;
 
    (void)llzkVerif_ContractOpHasArgPublicAttr(testOperation, index);
  }
 
  mlirOperationDestroy(testOperation);
}

TEST_F(VerifOperationLinkTests, llzk_ContractOp_HasFuncTarget) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Verif_ContractOp(testOperation)) {
 
    (void)llzkVerif_ContractOpHasFuncTarget(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

TEST_F(VerifOperationLinkTests, llzk_ContractOp_HasStructTarget) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Verif_ContractOp(testOperation)) {
 
    (void)llzkVerif_ContractOpHasStructTarget(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

TEST_F(VerifOperationLinkTests, llzk_ContractOp_GetCallableRegion) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Verif_ContractOp(testOperation)) {
 
    (void)llzkVerif_ContractOpGetCallableRegion(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

TEST_F(VerifOperationLinkTests, llzk_ContractOp_HasArgName) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Verif_ContractOp(testOperation)) {
    unsigned index = 0;
 
    (void)llzkVerif_ContractOpHasArgName(testOperation, index);
  }
 
  mlirOperationDestroy(testOperation);
}

TEST_F(VerifOperationLinkTests, llzk_ContractOp_GetFullyQualifiedName) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Verif_ContractOp(testOperation)) {
    bool requireParent = false;
 
    (void)llzkVerif_ContractOpGetFullyQualifiedName(testOperation, requireParent);
  }
 
  mlirOperationDestroy(testOperation);
}

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

TEST_F(VerifOperationLinkTests, llzk_DecreasesOp_Build) {
  // Returns an `arith.constant` op, which will never match the DecreasesOp 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_Verif_DecreasesOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
 
    (void)llzkVerif_DecreasesOpBuild(builder, location, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct DecreasesOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Verif_DecreasesOp(op); }
  static std::unique_ptr<DecreasesOpBuildFuncHelper> get();
 
protected:
  DecreasesOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, Verif_DecreasesOp_build_pass) { DecreasesOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(VerifOperationLinkTests, llzk_DecreasesOp_GetValue) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_DecreasesOp(testOp)) {
    (void)llzkVerif_DecreasesOpGetValue(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_DecreasesOp_SetValue) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_DecreasesOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkVerif_DecreasesOpSetValue(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}

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

TEST_F(VerifOperationLinkTests, llzk_EnsureComputeOp_Build) {
  // Returns an `arith.constant` op, which will never match the EnsureComputeOp 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_Verif_EnsureComputeOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
 
    (void)llzkVerif_EnsureComputeOpBuild(builder, location, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct EnsureComputeOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Verif_EnsureComputeOp(op); }
  static std::unique_ptr<EnsureComputeOpBuildFuncHelper> get();
 
protected:
  EnsureComputeOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, Verif_EnsureComputeOp_build_pass) { EnsureComputeOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(VerifOperationLinkTests, llzk_EnsureComputeOp_GetCondition) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_EnsureComputeOp(testOp)) {
    (void)llzkVerif_EnsureComputeOpGetCondition(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_EnsureComputeOp_SetCondition) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_EnsureComputeOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkVerif_EnsureComputeOpSetCondition(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}

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

TEST_F(VerifOperationLinkTests, llzk_EnsureConstrainOp_Build) {
  // Returns an `arith.constant` op, which will never match the EnsureConstrainOp 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_Verif_EnsureConstrainOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
 
    (void)llzkVerif_EnsureConstrainOpBuild(builder, location, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct EnsureConstrainOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Verif_EnsureConstrainOp(op); }
  static std::unique_ptr<EnsureConstrainOpBuildFuncHelper> get();
 
protected:
  EnsureConstrainOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, Verif_EnsureConstrainOp_build_pass) { EnsureConstrainOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(VerifOperationLinkTests, llzk_EnsureConstrainOp_GetCondition) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_EnsureConstrainOp(testOp)) {
    (void)llzkVerif_EnsureConstrainOpGetCondition(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_EnsureConstrainOp_SetCondition) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_EnsureConstrainOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkVerif_EnsureConstrainOpSetCondition(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(VerifOperationLinkTests, IsA_Verif_IncludeOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Verif_IncludeOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}
 
TEST_F(VerifOperationLinkTests, llzk_IncludeOp_GetArgOperandsCount) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_IncludeOp(testOp)) {
    (void)llzkVerif_IncludeOpGetArgOperandsCount(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_IncludeOp_GetArgOperandsAt) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_IncludeOp(testOp)) {
    (void)llzkVerif_IncludeOpGetArgOperandsAt(testOp, 0);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_IncludeOp_SetArgOperands_Variadic) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_IncludeOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    MlirValue values[] = {dummyValue};
    llzkVerif_IncludeOpSetArgOperands(testOp, 1, values);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_IncludeOp_GetMapOperandsCount) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_IncludeOp(testOp)) {
    (void)llzkVerif_IncludeOpGetMapOperandsCount(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_IncludeOp_GetMapOperandsAt) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_IncludeOp(testOp)) {
    (void)llzkVerif_IncludeOpGetMapOperandsAt(testOp, 0);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_IncludeOp_SetMapOperands_VariadicOfVariadic) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_IncludeOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    MlirValueRange groups[1];
    groups[0].values = &dummyValue;
    groups[0].size = 1;
    llzkVerif_IncludeOpSetMapOperands(testOp, 1, groups);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_IncludeOp_GetCalleeAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_IncludeOp(testOp)) {
    (void)llzkVerif_IncludeOpGetCallee(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_IncludeOp_SetCalleeAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_IncludeOp(testOp)) {
    llzkVerif_IncludeOpSetCallee(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_IncludeOp_GetTemplateParamsAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_IncludeOp(testOp)) {
    (void)llzkVerif_IncludeOpGetTemplateParams(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_IncludeOp_SetTemplateParamsAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_IncludeOp(testOp)) {
    llzkVerif_IncludeOpSetTemplateParams(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_IncludeOp_GetNumDimsPerMapAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_IncludeOp(testOp)) {
    (void)llzkVerif_IncludeOpGetNumDimsPerMap(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_IncludeOp_SetNumDimsPerMapAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_IncludeOp(testOp)) {
    llzkVerif_IncludeOpSetNumDimsPerMap(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_IncludeOp_GetMapOpGroupSizesAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_IncludeOp(testOp)) {
    (void)llzkVerif_IncludeOpGetMapOpGroupSizes(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_IncludeOp_SetMapOpGroupSizesAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_IncludeOp(testOp)) {
    llzkVerif_IncludeOpSetMapOpGroupSizes(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(VerifOperationLinkTests, llzk_IncludeOp_ContractTargetsStruct) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Verif_IncludeOp(testOperation)) {
 
    (void)llzkVerif_IncludeOpContractTargetsStruct(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

TEST_F(VerifOperationLinkTests, llzk_IncludeOp_GetSelfValue) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Verif_IncludeOp(testOperation)) {
 
    (void)llzkVerif_IncludeOpGetSelfValue(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

TEST_F(VerifOperationLinkTests, llzk_IncludeOp_GetTypeSignature) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Verif_IncludeOp(testOperation)) {
 
    (void)llzkVerif_IncludeOpGetTypeSignature(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

TEST_F(VerifOperationLinkTests, llzk_IncludeOp_ResolveCallable) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Verif_IncludeOp(testOperation)) {
 
    (void)llzkVerif_IncludeOpResolveCallable(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

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

TEST_F(VerifOperationLinkTests, llzk_IncreasesOp_Build) {
  // Returns an `arith.constant` op, which will never match the IncreasesOp 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_Verif_IncreasesOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
 
    (void)llzkVerif_IncreasesOpBuild(builder, location, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct IncreasesOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Verif_IncreasesOp(op); }
  static std::unique_ptr<IncreasesOpBuildFuncHelper> get();
 
protected:
  IncreasesOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, Verif_IncreasesOp_build_pass) { IncreasesOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(VerifOperationLinkTests, llzk_IncreasesOp_GetValue) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_IncreasesOp(testOp)) {
    (void)llzkVerif_IncreasesOpGetValue(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_IncreasesOp_SetValue) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_IncreasesOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkVerif_IncreasesOpSetValue(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(VerifOperationLinkTests, IsA_Verif_InvariantOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Verif_InvariantOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}
 
TEST_F(VerifOperationLinkTests, llzk_InvariantOp_GetLoopNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_InvariantOp(testOp)) {
    (void)llzkVerif_InvariantOpGetLoopName(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_InvariantOp_SetLoopNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_InvariantOp(testOp)) {
    llzkVerif_InvariantOpSetLoopName(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_InvariantOp_GetLoopArgTypesAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_InvariantOp(testOp)) {
    (void)llzkVerif_InvariantOpGetLoopArgTypes(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_InvariantOp_SetLoopArgTypesAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_InvariantOp(testOp)) {
    llzkVerif_InvariantOpSetLoopArgTypes(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_InvariantOp_GetRegionRegion) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_InvariantOp(testOp)) {
    (void)llzkVerif_InvariantOpGetRegion(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(VerifOperationLinkTests, llzk_InvariantOp_GetParentContract) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Verif_InvariantOp(testOperation)) {
 
    (void)llzkVerif_InvariantOpGetParentContract(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

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

TEST_F(VerifOperationLinkTests, llzk_OldOp_Build) {
  // Returns an `arith.constant` op, which will never match the OldOp 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_Verif_OldOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
 
    (void)llzkVerif_OldOpBuild(builder, location, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct OldOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Verif_OldOp(op); }
  static std::unique_ptr<OldOpBuildFuncHelper> get();
 
protected:
  OldOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, Verif_OldOp_build_pass) { OldOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(VerifOperationLinkTests, llzk_OldOp_GetValue) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_OldOp(testOp)) {
    (void)llzkVerif_OldOpGetValue(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_OldOp_SetValue) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_OldOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkVerif_OldOpSetValue(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_OldOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_OldOp(testOp)) {
    (void)llzkVerif_OldOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

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

TEST_F(VerifOperationLinkTests, llzk_ProveDetOp_Build) {
  // Returns an `arith.constant` op, which will never match the ProveDetOp 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_Verif_ProveDetOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
 
    (void)llzkVerif_ProveDetOpBuild(builder, location, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct ProveDetOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Verif_ProveDetOp(op); }
  static std::unique_ptr<ProveDetOpBuildFuncHelper> get();
 
protected:
  ProveDetOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, Verif_ProveDetOp_build_pass) { ProveDetOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(VerifOperationLinkTests, llzk_ProveDetOp_GetCondition) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_ProveDetOp(testOp)) {
    (void)llzkVerif_ProveDetOpGetCondition(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_ProveDetOp_SetCondition) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_ProveDetOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkVerif_ProveDetOpSetCondition(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_ProveDetOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_ProveDetOp(testOp)) {
    (void)llzkVerif_ProveDetOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

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

TEST_F(VerifOperationLinkTests, llzk_RequireComputeOp_Build) {
  // Returns an `arith.constant` op, which will never match the RequireComputeOp 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_Verif_RequireComputeOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
 
    (void)llzkVerif_RequireComputeOpBuild(builder, location, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct RequireComputeOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Verif_RequireComputeOp(op); }
  static std::unique_ptr<RequireComputeOpBuildFuncHelper> get();
 
protected:
  RequireComputeOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, Verif_RequireComputeOp_build_pass) { RequireComputeOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(VerifOperationLinkTests, llzk_RequireComputeOp_GetCondition) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_RequireComputeOp(testOp)) {
    (void)llzkVerif_RequireComputeOpGetCondition(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_RequireComputeOp_SetCondition) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_RequireComputeOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkVerif_RequireComputeOpSetCondition(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}

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

TEST_F(VerifOperationLinkTests, llzk_RequireConstrainOp_Build) {
  // Returns an `arith.constant` op, which will never match the RequireConstrainOp 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_Verif_RequireConstrainOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
 
    (void)llzkVerif_RequireConstrainOpBuild(builder, location, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct RequireConstrainOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Verif_RequireConstrainOp(op); }
  static std::unique_ptr<RequireConstrainOpBuildFuncHelper> get();
 
protected:
  RequireConstrainOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, Verif_RequireConstrainOp_build_pass) { RequireConstrainOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(VerifOperationLinkTests, llzk_RequireConstrainOp_GetCondition) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_RequireConstrainOp(testOp)) {
    (void)llzkVerif_RequireConstrainOpGetCondition(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_RequireConstrainOp_SetCondition) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_RequireConstrainOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkVerif_RequireConstrainOpSetCondition(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}

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

TEST_F(VerifOperationLinkTests, llzk_StepOp_Build) {
  // Returns an `arith.constant` op, which will never match the StepOp 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_Verif_StepOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
 
    (void)llzkVerif_StepOpBuild(builder, location);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct StepOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Verif_StepOp(op); }
  static std::unique_ptr<StepOpBuildFuncHelper> get();
 
protected:
  StepOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, Verif_StepOp_build_pass) { StepOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(VerifOperationLinkTests, llzk_StepOp_GetRegionRegion) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_StepOp(testOp)) {
    (void)llzkVerif_StepOpGetRegion(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

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

TEST_F(VerifOperationLinkTests, llzk_StepYieldOp_Build) {
  // Returns an `arith.constant` op, which will never match the StepYieldOp 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_Verif_StepYieldOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
 
    (void)llzkVerif_StepYieldOpBuild(builder, location, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct StepYieldOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Verif_StepYieldOp(op); }
  static std::unique_ptr<StepYieldOpBuildFuncHelper> get();
 
protected:
  StepYieldOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, Verif_StepYieldOp_build_pass) { StepYieldOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(VerifOperationLinkTests, llzk_StepYieldOp_GetValue) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_StepYieldOp(testOp)) {
    (void)llzkVerif_StepYieldOpGetValue(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_StepYieldOp_SetValue) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_StepYieldOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkVerif_StepYieldOpSetValue(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}

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

TEST_F(VerifOperationLinkTests, llzk_VerifAssertOp_Build) {
  // Returns an `arith.constant` op, which will never match the VerifAssertOp 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_Verif_VerifAssertOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
 
    (void)llzkVerif_VerifAssertOpBuild(builder, location, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct VerifAssertOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Verif_VerifAssertOp(op); }
  static std::unique_ptr<VerifAssertOpBuildFuncHelper> get();
 
protected:
  VerifAssertOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, Verif_VerifAssertOp_build_pass) { VerifAssertOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(VerifOperationLinkTests, llzk_VerifAssertOp_GetCondition) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_VerifAssertOp(testOp)) {
    (void)llzkVerif_VerifAssertOpGetCondition(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_VerifAssertOp_SetCondition) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_VerifAssertOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkVerif_VerifAssertOpSetCondition(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}

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

TEST_F(VerifOperationLinkTests, llzk_VerifProveOp_Build) {
  // Returns an `arith.constant` op, which will never match the VerifProveOp 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_Verif_VerifProveOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
 
    (void)llzkVerif_VerifProveOpBuild(builder, location, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct VerifProveOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Verif_VerifProveOp(op); }
  static std::unique_ptr<VerifProveOpBuildFuncHelper> get();
 
protected:
  VerifProveOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, Verif_VerifProveOp_build_pass) { VerifProveOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(VerifOperationLinkTests, llzk_VerifProveOp_GetCondition) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_VerifProveOp(testOp)) {
    (void)llzkVerif_VerifProveOpGetCondition(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_VerifProveOp_SetCondition) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_VerifProveOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkVerif_VerifProveOpSetCondition(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}

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

TEST_F(VerifOperationLinkTests, llzk_VerifSMTProveOp_Build) {
  // Returns an `arith.constant` op, which will never match the VerifSMTProveOp 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_Verif_VerifSMTProveOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
 
    (void)llzkVerif_VerifSMTProveOpBuild(builder, location, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct VerifSMTProveOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Verif_VerifSMTProveOp(op); }
  static std::unique_ptr<VerifSMTProveOpBuildFuncHelper> get();
 
protected:
  VerifSMTProveOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, Verif_VerifSMTProveOp_build_pass) { VerifSMTProveOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(VerifOperationLinkTests, llzk_VerifSMTProveOp_GetCondition) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_VerifSMTProveOp(testOp)) {
    (void)llzkVerif_VerifSMTProveOpGetCondition(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(VerifOperationLinkTests, llzk_VerifSMTProveOp_SetCondition) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Verif_VerifSMTProveOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkVerif_VerifSMTProveOpSetCondition(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}