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

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

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

TEST_F(CAPITest, GlobalDefOp_build_pass) { GlobalDefOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(GlobalOperationLinkTests, llzk_GlobalDefOp_GetSymNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Global_GlobalDefOp(testOp)) {
    (void)llzkGlobal_GlobalDefOpGetSymName(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(GlobalOperationLinkTests, llzk_GlobalDefOp_SetSymNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Global_GlobalDefOp(testOp)) {
    llzkGlobal_GlobalDefOpSetSymName(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(GlobalOperationLinkTests, llzk_GlobalDefOp_GetConstantAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Global_GlobalDefOp(testOp)) {
    (void)llzkGlobal_GlobalDefOpGetConstant(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(GlobalOperationLinkTests, llzk_GlobalDefOp_SetConstantAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Global_GlobalDefOp(testOp)) {
    llzkGlobal_GlobalDefOpSetConstant(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(GlobalOperationLinkTests, llzk_GlobalDefOp_GetTypeAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Global_GlobalDefOp(testOp)) {
    (void)llzkGlobal_GlobalDefOpGetType(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(GlobalOperationLinkTests, llzk_GlobalDefOp_SetTypeAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Global_GlobalDefOp(testOp)) {
    llzkGlobal_GlobalDefOpSetType(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(GlobalOperationLinkTests, llzk_GlobalDefOp_GetInitialValueAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Global_GlobalDefOp(testOp)) {
    (void)llzkGlobal_GlobalDefOpGetInitialValue(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(GlobalOperationLinkTests, llzk_GlobalDefOp_SetInitialValueAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Global_GlobalDefOp(testOp)) {
    llzkGlobal_GlobalDefOpSetInitialValue(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(GlobalOperationLinkTests, llzk_GlobalDefOp_IsConstant) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Global_GlobalDefOp(testOperation)) {
 
    (void)llzkGlobal_GlobalDefOpIsConstant(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

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

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

TEST_F(CAPITest, GlobalReadOp_build_pass) { GlobalReadOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(GlobalOperationLinkTests, llzk_GlobalReadOp_GetNameRefAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Global_GlobalReadOp(testOp)) {
    (void)llzkGlobal_GlobalReadOpGetNameRef(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(GlobalOperationLinkTests, llzk_GlobalReadOp_SetNameRefAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Global_GlobalReadOp(testOp)) {
    llzkGlobal_GlobalReadOpSetNameRef(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(GlobalOperationLinkTests, llzk_GlobalReadOp_GetVal) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Global_GlobalReadOp(testOp)) {
    (void)llzkGlobal_GlobalReadOpGetVal(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

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

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

TEST_F(CAPITest, GlobalWriteOp_build_pass) { GlobalWriteOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(GlobalOperationLinkTests, llzk_GlobalWriteOp_GetVal) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Global_GlobalWriteOp(testOp)) {
    (void)llzkGlobal_GlobalWriteOpGetVal(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(GlobalOperationLinkTests, llzk_GlobalWriteOp_SetVal) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Global_GlobalWriteOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkGlobal_GlobalWriteOpSetVal(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(GlobalOperationLinkTests, llzk_GlobalWriteOp_GetNameRefAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Global_GlobalWriteOp(testOp)) {
    (void)llzkGlobal_GlobalWriteOpGetNameRef(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(GlobalOperationLinkTests, llzk_GlobalWriteOp_SetNameRefAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Global_GlobalWriteOp(testOp)) {
    llzkGlobal_GlobalWriteOpSetNameRef(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}