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_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, 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_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, 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, 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_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, 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, 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);
}