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

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

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

TEST_F(CAPITest, CreateStructOp_build_pass) { CreateStructOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(StructOperationLinkTests, llzk_CreateStructOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_CreateStructOp(testOp)) {
    (void)llzkStruct_CreateStructOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(StructOperationLinkTests, IsA_Struct_MemberDefOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Struct_MemberDefOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberDefOp_GetSymNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberDefOp(testOp)) {
    (void)llzkStruct_MemberDefOpGetSymName(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberDefOp_SetSymNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberDefOp(testOp)) {
    llzkStruct_MemberDefOpSetSymName(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberDefOp_GetTypeAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberDefOp(testOp)) {
    (void)llzkStruct_MemberDefOpGetType(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberDefOp_SetTypeAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberDefOp(testOp)) {
    llzkStruct_MemberDefOpSetType(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberDefOp_GetColumnAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberDefOp(testOp)) {
    (void)llzkStruct_MemberDefOpGetColumn(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberDefOp_SetColumnAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberDefOp(testOp)) {
    llzkStruct_MemberDefOpSetColumn(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberDefOp_GetSignalAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberDefOp(testOp)) {
    (void)llzkStruct_MemberDefOpGetSignal(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberDefOp_SetSignalAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberDefOp(testOp)) {
    llzkStruct_MemberDefOpSetSignal(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(StructOperationLinkTests, llzk_MemberDefOp_SetPublicAttr) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberDefOp(testOperation)) {
    bool newValue = false;
 
    (void)llzkStruct_MemberDefOpSetPublicAttr(testOperation, newValue);
  }
 
  mlirOperationDestroy(testOperation);
}

TEST_F(StructOperationLinkTests, llzk_MemberDefOp_HasPublicAttr) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberDefOp(testOperation)) {
 
    (void)llzkStruct_MemberDefOpHasPublicAttr(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

TEST_F(StructOperationLinkTests, IsA_Struct_MemberReadOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Struct_MemberReadOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberReadOp_GetComponent) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberReadOp(testOp)) {
    (void)llzkStruct_MemberReadOpGetComponent(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberReadOp_SetComponent) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberReadOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkStruct_MemberReadOpSetComponent(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberReadOp_GetMapOperandsCount) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberReadOp(testOp)) {
    (void)llzkStruct_MemberReadOpGetMapOperandsCount(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberReadOp_GetMapOperandsAt) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberReadOp(testOp)) {
    (void)llzkStruct_MemberReadOpGetMapOperandsAt(testOp, 0);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberReadOp_SetMapOperands_Variadic) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberReadOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    MlirValue values[] = {dummyValue};
    llzkStruct_MemberReadOpSetMapOperands(testOp, 1, values);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberReadOp_GetMemberNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberReadOp(testOp)) {
    (void)llzkStruct_MemberReadOpGetMemberName(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberReadOp_SetMemberNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberReadOp(testOp)) {
    llzkStruct_MemberReadOpSetMemberName(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberReadOp_GetTableOffsetAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberReadOp(testOp)) {
    (void)llzkStruct_MemberReadOpGetTableOffset(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberReadOp_SetTableOffsetAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberReadOp(testOp)) {
    llzkStruct_MemberReadOpSetTableOffset(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberReadOp_GetNumDimsPerMapAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberReadOp(testOp)) {
    (void)llzkStruct_MemberReadOpGetNumDimsPerMap(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberReadOp_SetNumDimsPerMapAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberReadOp(testOp)) {
    llzkStruct_MemberReadOpSetNumDimsPerMap(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberReadOp_GetMapOpGroupSizesAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberReadOp(testOp)) {
    (void)llzkStruct_MemberReadOpGetMapOpGroupSizes(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberReadOp_SetMapOpGroupSizesAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberReadOp(testOp)) {
    llzkStruct_MemberReadOpSetMapOpGroupSizes(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberReadOp_GetVal) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberReadOp(testOp)) {
    (void)llzkStruct_MemberReadOpGetVal(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

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

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

TEST_F(CAPITest, MemberWriteOp_build_pass) { MemberWriteOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(StructOperationLinkTests, llzk_MemberWriteOp_GetComponent) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberWriteOp(testOp)) {
    (void)llzkStruct_MemberWriteOpGetComponent(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberWriteOp_SetComponent) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberWriteOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkStruct_MemberWriteOpSetComponent(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberWriteOp_GetVal) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberWriteOp(testOp)) {
    (void)llzkStruct_MemberWriteOpGetVal(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberWriteOp_SetVal) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberWriteOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkStruct_MemberWriteOpSetVal(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberWriteOp_GetMemberNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberWriteOp(testOp)) {
    (void)llzkStruct_MemberWriteOpGetMemberName(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_MemberWriteOp_SetMemberNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_MemberWriteOp(testOp)) {
    llzkStruct_MemberWriteOpSetMemberName(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}

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

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

TEST_F(CAPITest, StructDefOp_build_pass) { StructDefOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(StructOperationLinkTests, llzk_StructDefOp_GetSymNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_StructDefOp(testOp)) {
    (void)llzkStruct_StructDefOpGetSymName(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_StructDefOp_SetSymNameAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_StructDefOp(testOp)) {
    llzkStruct_StructDefOpSetSymName(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(StructOperationLinkTests, llzk_StructDefOp_GetBodyRegionRegion) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Struct_StructDefOp(testOp)) {
    (void)llzkStruct_StructDefOpGetBodyRegion(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(StructOperationLinkTests, llzk_StructDefOp_GetComputeFuncOp) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Struct_StructDefOp(testOperation)) {
 
    (void)llzkStruct_StructDefOpGetComputeFuncOp(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

TEST_F(StructOperationLinkTests, llzk_StructDefOp_GetProductFuncOp) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Struct_StructDefOp(testOperation)) {
 
    (void)llzkStruct_StructDefOpGetProductFuncOp(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

TEST_F(StructOperationLinkTests, llzk_StructDefOp_GetMemberDef) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Struct_StructDefOp(testOperation)) {
    MlirIdentifier memberName = {};
 
    (void)llzkStruct_StructDefOpGetMemberDef(testOperation, memberName);
  }
 
  mlirOperationDestroy(testOperation);
}

TEST_F(StructOperationLinkTests, llzk_StructDefOp_HasColumns) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Struct_StructDefOp(testOperation)) {
 
    (void)llzkStruct_StructDefOpHasColumns(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

TEST_F(StructOperationLinkTests, llzk_StructDefOp_HasComputeConstrain) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Struct_StructDefOp(testOperation)) {
 
    (void)llzkStruct_StructDefOpHasComputeConstrain(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

TEST_F(StructOperationLinkTests, llzk_StructDefOp_GetConstrainFuncOp) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Struct_StructDefOp(testOperation)) {
 
    (void)llzkStruct_StructDefOpGetConstrainFuncOp(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

TEST_F(StructOperationLinkTests, llzk_StructDefOp_HasTemplateSymbolBindings) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Struct_StructDefOp(testOperation)) {
 
    (void)llzkStruct_StructDefOpHasTemplateSymbolBindings(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

TEST_F(StructOperationLinkTests, llzk_StructDefOp_HasSignals) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Struct_StructDefOp(testOperation)) {
 
    (void)llzkStruct_StructDefOpHasSignals(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

TEST_F(StructOperationLinkTests, llzk_StructDefOp_IsMainComponent) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Struct_StructDefOp(testOperation)) {
 
    (void)llzkStruct_StructDefOpIsMainComponent(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

TEST_F(StructOperationLinkTests, llzk_StructDefOp_GetFullyQualifiedName) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Struct_StructDefOp(testOperation)) {
 
    (void)llzkStruct_StructDefOpGetFullyQualifiedName(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}