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

TEST_F(PolyOperationLinkTests, IsA_Poly_ApplyMapOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Poly_ApplyMapOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}
 
TEST_F(PolyOperationLinkTests, llzk_ApplyMapOp_GetMapOperandsCount) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_ApplyMapOp(testOp)) {
    (void)llzkPoly_ApplyMapOpGetMapOperandsCount(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(PolyOperationLinkTests, llzk_ApplyMapOp_GetMapOperandsAt) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_ApplyMapOp(testOp)) {
    (void)llzkPoly_ApplyMapOpGetMapOperandsAt(testOp, 0);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(PolyOperationLinkTests, llzk_ApplyMapOp_SetMapOperands_Variadic) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_ApplyMapOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    MlirValue values[] = {dummyValue};
    llzkPoly_ApplyMapOpSetMapOperands(testOp, 1, values);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(PolyOperationLinkTests, llzk_ApplyMapOp_GetMapAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_ApplyMapOp(testOp)) {
    (void)llzkPoly_ApplyMapOpGetMap(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(PolyOperationLinkTests, llzk_ApplyMapOp_SetMapAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_ApplyMapOp(testOp)) {
    llzkPoly_ApplyMapOpSetMap(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(PolyOperationLinkTests, llzk_ApplyMapOp_GetNumDimsAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_ApplyMapOp(testOp)) {
    (void)llzkPoly_ApplyMapOpGetNumDims(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(PolyOperationLinkTests, llzk_ApplyMapOp_SetNumDimsAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_ApplyMapOp(testOp)) {
    llzkPoly_ApplyMapOpSetNumDims(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(PolyOperationLinkTests, llzk_ApplyMapOp_GetResult0) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_ApplyMapOp(testOp)) {
    (void)llzkPoly_ApplyMapOpGetResult0(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(PolyOperationLinkTests, llzk_ApplyMapOp_GetAffineMap) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Poly_ApplyMapOp(testOperation)) {
 
    (void)llzkPoly_ApplyMapOpGetAffineMap(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

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

TEST_F(PolyOperationLinkTests, llzk_ConstReadOp_Build) {
  // Returns an `arith.constant` op, which will never match the ConstReadOp 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_Poly_ConstReadOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto valType = createIndexType();
    auto const_nameAttr = createIndexAttribute();
 
    (void)llzkPoly_ConstReadOpBuild(builder, location, valType, const_nameAttr);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct ConstReadOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Poly_ConstReadOp(op); }
  static std::unique_ptr<ConstReadOpBuildFuncHelper> get();
 
protected:
  ConstReadOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, ConstReadOp_build_pass) { ConstReadOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(PolyOperationLinkTests, llzk_ConstReadOp_GetConstNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_ConstReadOp(testOp)) {
    (void)llzkPoly_ConstReadOpGetConstName(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(PolyOperationLinkTests, llzk_ConstReadOp_SetConstNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_ConstReadOp(testOp)) {
    llzkPoly_ConstReadOpSetConstName(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(PolyOperationLinkTests, llzk_ConstReadOp_GetVal) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_ConstReadOp(testOp)) {
    (void)llzkPoly_ConstReadOpGetVal(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

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

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

TEST_F(CAPITest, TemplateExprOp_build_pass) { TemplateExprOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(PolyOperationLinkTests, llzk_TemplateExprOp_GetSymNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_TemplateExprOp(testOp)) {
    (void)llzkPoly_TemplateExprOpGetSymName(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(PolyOperationLinkTests, llzk_TemplateExprOp_SetSymNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_TemplateExprOp(testOp)) {
    llzkPoly_TemplateExprOpSetSymName(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(PolyOperationLinkTests, llzk_TemplateExprOp_GetInitializerRegionRegion) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_TemplateExprOp(testOp)) {
    (void)llzkPoly_TemplateExprOpGetInitializerRegion(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(PolyOperationLinkTests, llzk_TemplateExprOp_GetType) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Poly_TemplateExprOp(testOperation)) {
 
    (void)llzkPoly_TemplateExprOpGetType(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

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

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

TEST_F(CAPITest, TemplateOp_build_pass) { TemplateOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(PolyOperationLinkTests, llzk_TemplateOp_GetSymNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_TemplateOp(testOp)) {
    (void)llzkPoly_TemplateOpGetSymName(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(PolyOperationLinkTests, llzk_TemplateOp_SetSymNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_TemplateOp(testOp)) {
    llzkPoly_TemplateOpSetSymName(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(PolyOperationLinkTests, llzk_TemplateOp_GetBodyRegionRegion) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_TemplateOp(testOp)) {
    (void)llzkPoly_TemplateOpGetBodyRegion(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

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

TEST_F(PolyOperationLinkTests, llzk_TemplateParamOp_Build) {
  // Returns an `arith.constant` op, which will never match the TemplateParamOp 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_Poly_TemplateParamOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto sym_nameAttr = mlirOperationGetName(testOp);
    auto type_optAttr = createIndexAttribute();
 
    (void)llzkPoly_TemplateParamOpBuild(builder, location, sym_nameAttr, type_optAttr);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct TemplateParamOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Poly_TemplateParamOp(op); }
  static std::unique_ptr<TemplateParamOpBuildFuncHelper> get();
 
protected:
  TemplateParamOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, TemplateParamOp_build_pass) { TemplateParamOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(PolyOperationLinkTests, llzk_TemplateParamOp_GetSymNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_TemplateParamOp(testOp)) {
    (void)llzkPoly_TemplateParamOpGetSymName(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(PolyOperationLinkTests, llzk_TemplateParamOp_SetSymNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_TemplateParamOp(testOp)) {
    llzkPoly_TemplateParamOpSetSymName(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(PolyOperationLinkTests, llzk_TemplateParamOp_GetTypeOptAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_TemplateParamOp(testOp)) {
    (void)llzkPoly_TemplateParamOpGetTypeOpt(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(PolyOperationLinkTests, llzk_TemplateParamOp_SetTypeOptAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_TemplateParamOp(testOp)) {
    llzkPoly_TemplateParamOpSetTypeOpt(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}

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

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

TEST_F(CAPITest, UnifiableCastOp_build_pass) { UnifiableCastOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(PolyOperationLinkTests, llzk_UnifiableCastOp_GetInput) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_UnifiableCastOp(testOp)) {
    (void)llzkPoly_UnifiableCastOpGetInput(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(PolyOperationLinkTests, llzk_UnifiableCastOp_SetInput) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_UnifiableCastOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkPoly_UnifiableCastOpSetInput(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(PolyOperationLinkTests, llzk_UnifiableCastOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_UnifiableCastOp(testOp)) {
    (void)llzkPoly_UnifiableCastOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

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

TEST_F(PolyOperationLinkTests, 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_Poly_YieldOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
 
    (void)llzkPoly_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_Poly_YieldOp(op); }
  static std::unique_ptr<YieldOpBuildFuncHelper> get();
 
protected:
  YieldOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, YieldOp_build_pass) { YieldOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(PolyOperationLinkTests, llzk_YieldOp_GetVal) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_YieldOp(testOp)) {
    (void)llzkPoly_YieldOpGetVal(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(PolyOperationLinkTests, llzk_YieldOp_SetVal) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Poly_YieldOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkPoly_YieldOpSetVal(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}