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

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

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

TEST_F(CAPITest, Bool_ExistsOp_build_pass) { ExistsOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(BoolOperationLinkTests, llzk_ExistsOp_GetSort) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_ExistsOp(testOp)) {
    (void)llzkBool_ExistsOpGetSort(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_ExistsOp_SetSort) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_ExistsOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkBool_ExistsOpSetSort(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_ExistsOp_GetRegionRegion) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_ExistsOp(testOp)) {
    (void)llzkBool_ExistsOpGetRegion(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_ExistsOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_ExistsOp(testOp)) {
    (void)llzkBool_ExistsOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

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

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

TEST_F(CAPITest, Bool_ForAllOp_build_pass) { ForAllOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(BoolOperationLinkTests, llzk_ForAllOp_GetSort) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_ForAllOp(testOp)) {
    (void)llzkBool_ForAllOpGetSort(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_ForAllOp_SetSort) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_ForAllOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkBool_ForAllOpSetSort(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_ForAllOp_GetRegionRegion) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_ForAllOp(testOp)) {
    (void)llzkBool_ForAllOpGetRegion(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_ForAllOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_ForAllOp(testOp)) {
    (void)llzkBool_ForAllOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

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

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

TEST_F(CAPITest, Bool_AndBoolOp_build_pass) { AndBoolOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(BoolOperationLinkTests, llzk_AndBoolOp_GetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_AndBoolOp(testOp)) {
    (void)llzkBool_AndBoolOpGetLhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_AndBoolOp_SetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_AndBoolOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkBool_AndBoolOpSetLhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_AndBoolOp_GetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_AndBoolOp(testOp)) {
    (void)llzkBool_AndBoolOpGetRhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_AndBoolOp_SetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_AndBoolOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkBool_AndBoolOpSetRhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_AndBoolOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_AndBoolOp(testOp)) {
    (void)llzkBool_AndBoolOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

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

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

TEST_F(CAPITest, Bool_AssertOp_build_pass) { AssertOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(BoolOperationLinkTests, llzk_AssertOp_GetCondition) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_AssertOp(testOp)) {
    (void)llzkBool_AssertOpGetCondition(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_AssertOp_SetCondition) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_AssertOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkBool_AssertOpSetCondition(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_AssertOp_GetMsgAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_AssertOp(testOp)) {
    (void)llzkBool_AssertOpGetMsg(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_AssertOp_SetMsgAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_AssertOp(testOp)) {
    llzkBool_AssertOpSetMsg(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}

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

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

TEST_F(CAPITest, Bool_CmpOp_build_pass) { CmpOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(BoolOperationLinkTests, llzk_CmpOp_GetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_CmpOp(testOp)) {
    (void)llzkBool_CmpOpGetLhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_CmpOp_SetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_CmpOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkBool_CmpOpSetLhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_CmpOp_GetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_CmpOp(testOp)) {
    (void)llzkBool_CmpOpGetRhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_CmpOp_SetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_CmpOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkBool_CmpOpSetRhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_CmpOp_GetPredicateAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_CmpOp(testOp)) {
    (void)llzkBool_CmpOpGetPredicate(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_CmpOp_SetPredicateAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_CmpOp(testOp)) {
    llzkBool_CmpOpSetPredicate(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_CmpOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_CmpOp(testOp)) {
    (void)llzkBool_CmpOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

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

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

TEST_F(CAPITest, Bool_NotBoolOp_build_pass) { NotBoolOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(BoolOperationLinkTests, llzk_NotBoolOp_GetOperand) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_NotBoolOp(testOp)) {
    (void)llzkBool_NotBoolOpGetOperand(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_NotBoolOp_SetOperand) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_NotBoolOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkBool_NotBoolOpSetOperand(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_NotBoolOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_NotBoolOp(testOp)) {
    (void)llzkBool_NotBoolOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

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

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

TEST_F(CAPITest, Bool_OrBoolOp_build_pass) { OrBoolOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(BoolOperationLinkTests, llzk_OrBoolOp_GetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_OrBoolOp(testOp)) {
    (void)llzkBool_OrBoolOpGetLhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_OrBoolOp_SetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_OrBoolOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkBool_OrBoolOpSetLhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_OrBoolOp_GetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_OrBoolOp(testOp)) {
    (void)llzkBool_OrBoolOpGetRhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_OrBoolOp_SetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_OrBoolOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkBool_OrBoolOpSetRhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_OrBoolOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_OrBoolOp(testOp)) {
    (void)llzkBool_OrBoolOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

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

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

TEST_F(CAPITest, Bool_XorBoolOp_build_pass) { XorBoolOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(BoolOperationLinkTests, llzk_XorBoolOp_GetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_XorBoolOp(testOp)) {
    (void)llzkBool_XorBoolOpGetLhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_XorBoolOp_SetLhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_XorBoolOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkBool_XorBoolOpSetLhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_XorBoolOp_GetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_XorBoolOp(testOp)) {
    (void)llzkBool_XorBoolOpGetRhs(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_XorBoolOp_SetRhs) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_XorBoolOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkBool_XorBoolOpSetRhs(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_XorBoolOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_XorBoolOp(testOp)) {
    (void)llzkBool_XorBoolOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

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

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

TEST_F(CAPITest, Bool_YieldOp_build_pass) { YieldOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(BoolOperationLinkTests, llzk_YieldOp_GetValue) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_YieldOp(testOp)) {
    (void)llzkBool_YieldOpGetValue(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(BoolOperationLinkTests, llzk_YieldOp_SetValue) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Bool_YieldOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkBool_YieldOpSetValue(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}