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