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

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

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

TEST_F(CAPITest, ArrayLengthOp_build_pass) { ArrayLengthOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(ArrayOperationLinkTests, llzk_ArrayLengthOp_GetArrRef) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_ArrayLengthOp(testOp)) {
    (void)llzkArray_ArrayLengthOpGetArrRef(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_ArrayLengthOp_SetArrRef) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_ArrayLengthOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkArray_ArrayLengthOpSetArrRef(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_ArrayLengthOp_GetDim) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_ArrayLengthOp(testOp)) {
    (void)llzkArray_ArrayLengthOpGetDim(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_ArrayLengthOp_SetDim) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_ArrayLengthOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkArray_ArrayLengthOpSetDim(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_ArrayLengthOp_GetLength) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_ArrayLengthOp(testOp)) {
    (void)llzkArray_ArrayLengthOpGetLength(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(ArrayOperationLinkTests, llzk_ArrayLengthOp_GetArrRefType) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Array_ArrayLengthOp(testOperation)) {
 
    (void)llzkArray_ArrayLengthOpGetArrRefType(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

TEST_F(ArrayOperationLinkTests, IsA_Array_CreateArrayOp) {
  auto testOperation = createIndexOperation();
 
  // This will always return false since `createIndex*` returns an MLIR builtin
  EXPECT_FALSE(llzkOperationIsA_Array_CreateArrayOp(testOperation));
 
  mlirOperationDestroy(testOperation);
}
 
TEST_F(ArrayOperationLinkTests, llzk_CreateArrayOp_GetElementsCount) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_CreateArrayOp(testOp)) {
    (void)llzkArray_CreateArrayOpGetElementsCount(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_CreateArrayOp_GetElementsAt) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_CreateArrayOp(testOp)) {
    (void)llzkArray_CreateArrayOpGetElementsAt(testOp, 0);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_CreateArrayOp_SetElements_Variadic) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_CreateArrayOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    MlirValue values[] = {dummyValue};
    llzkArray_CreateArrayOpSetElements(testOp, 1, values);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_CreateArrayOp_GetMapOperandsCount) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_CreateArrayOp(testOp)) {
    (void)llzkArray_CreateArrayOpGetMapOperandsCount(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_CreateArrayOp_GetMapOperandsAt) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_CreateArrayOp(testOp)) {
    (void)llzkArray_CreateArrayOpGetMapOperandsAt(testOp, 0);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_CreateArrayOp_SetMapOperands_Variadic) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_CreateArrayOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    MlirValue values[] = {dummyValue};
    llzkArray_CreateArrayOpSetMapOperands(testOp, 1, values);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_CreateArrayOp_GetNumDimsPerMapAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_CreateArrayOp(testOp)) {
    (void)llzkArray_CreateArrayOpGetNumDimsPerMap(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_CreateArrayOp_SetNumDimsPerMapAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_CreateArrayOp(testOp)) {
    llzkArray_CreateArrayOpSetNumDimsPerMap(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_CreateArrayOp_GetMapOpGroupSizesAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_CreateArrayOp(testOp)) {
    (void)llzkArray_CreateArrayOpGetMapOpGroupSizes(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_CreateArrayOp_SetMapOpGroupSizesAttr) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_CreateArrayOp(testOp)) {
    llzkArray_CreateArrayOpSetMapOpGroupSizes(testOp, createIndexAttribute());
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_CreateArrayOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_CreateArrayOp(testOp)) {
    (void)llzkArray_CreateArrayOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

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

TEST_F(ArrayOperationLinkTests, llzk_ExtractArrayOp_Build) {
  // Returns an `arith.constant` op, which will never match the ExtractArrayOp 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_Array_ExtractArrayOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto resultType = createIndexType();
    MlirValue indicesValues[] = {dummyValue};
    intptr_t indicesSize = 0;
 
    (void)llzkArray_ExtractArrayOpBuild(builder, location, resultType, dummyValue, indicesSize, indicesValues);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct ExtractArrayOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Array_ExtractArrayOp(op); }
  static std::unique_ptr<ExtractArrayOpBuildFuncHelper> get();
 
protected:
  ExtractArrayOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, ExtractArrayOp_build_pass) { ExtractArrayOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(ArrayOperationLinkTests, llzk_ExtractArrayOp_GetArrRef) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_ExtractArrayOp(testOp)) {
    (void)llzkArray_ExtractArrayOpGetArrRef(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_ExtractArrayOp_SetArrRef) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_ExtractArrayOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkArray_ExtractArrayOpSetArrRef(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_ExtractArrayOp_GetIndicesCount) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_ExtractArrayOp(testOp)) {
    (void)llzkArray_ExtractArrayOpGetIndicesCount(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_ExtractArrayOp_GetIndicesAt) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_ExtractArrayOp(testOp)) {
    (void)llzkArray_ExtractArrayOpGetIndicesAt(testOp, 0);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_ExtractArrayOp_SetIndices_Variadic) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_ExtractArrayOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    MlirValue values[] = {dummyValue};
    llzkArray_ExtractArrayOpSetIndices(testOp, 1, values);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_ExtractArrayOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_ExtractArrayOp(testOp)) {
    (void)llzkArray_ExtractArrayOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(ArrayOperationLinkTests, llzk_ExtractArrayOp_GetArrRefType) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Array_ExtractArrayOp(testOperation)) {
 
    (void)llzkArray_ExtractArrayOpGetArrRefType(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

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

TEST_F(ArrayOperationLinkTests, llzk_InsertArrayOp_Build) {
  // Returns an `arith.constant` op, which will never match the InsertArrayOp 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_Array_InsertArrayOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    MlirValue indicesValues[] = {dummyValue};
    intptr_t indicesSize = 0;
 
    (void)llzkArray_InsertArrayOpBuild(builder, location, dummyValue, indicesSize, indicesValues, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct InsertArrayOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Array_InsertArrayOp(op); }
  static std::unique_ptr<InsertArrayOpBuildFuncHelper> get();
 
protected:
  InsertArrayOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, InsertArrayOp_build_pass) { InsertArrayOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(ArrayOperationLinkTests, llzk_InsertArrayOp_GetArrRef) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_InsertArrayOp(testOp)) {
    (void)llzkArray_InsertArrayOpGetArrRef(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_InsertArrayOp_SetArrRef) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_InsertArrayOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkArray_InsertArrayOpSetArrRef(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_InsertArrayOp_GetIndicesCount) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_InsertArrayOp(testOp)) {
    (void)llzkArray_InsertArrayOpGetIndicesCount(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_InsertArrayOp_GetIndicesAt) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_InsertArrayOp(testOp)) {
    (void)llzkArray_InsertArrayOpGetIndicesAt(testOp, 0);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_InsertArrayOp_SetIndices_Variadic) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_InsertArrayOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    MlirValue values[] = {dummyValue};
    llzkArray_InsertArrayOpSetIndices(testOp, 1, values);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_InsertArrayOp_GetRvalue) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_InsertArrayOp(testOp)) {
    (void)llzkArray_InsertArrayOpGetRvalue(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_InsertArrayOp_SetRvalue) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_InsertArrayOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkArray_InsertArrayOpSetRvalue(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(ArrayOperationLinkTests, llzk_InsertArrayOp_GetArrRefType) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Array_InsertArrayOp(testOperation)) {
 
    (void)llzkArray_InsertArrayOpGetArrRefType(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

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

TEST_F(ArrayOperationLinkTests, llzk_ReadArrayOp_Build) {
  // Returns an `arith.constant` op, which will never match the ReadArrayOp 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_Array_ReadArrayOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    auto resultType = createIndexType();
    MlirValue indicesValues[] = {dummyValue};
    intptr_t indicesSize = 0;
 
    (void)llzkArray_ReadArrayOpBuild(builder, location, resultType, dummyValue, indicesSize, indicesValues);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct ReadArrayOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Array_ReadArrayOp(op); }
  static std::unique_ptr<ReadArrayOpBuildFuncHelper> get();
 
protected:
  ReadArrayOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, ReadArrayOp_build_pass) { ReadArrayOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(ArrayOperationLinkTests, llzk_ReadArrayOp_GetArrRef) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_ReadArrayOp(testOp)) {
    (void)llzkArray_ReadArrayOpGetArrRef(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_ReadArrayOp_SetArrRef) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_ReadArrayOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkArray_ReadArrayOpSetArrRef(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_ReadArrayOp_GetIndicesCount) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_ReadArrayOp(testOp)) {
    (void)llzkArray_ReadArrayOpGetIndicesCount(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_ReadArrayOp_GetIndicesAt) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_ReadArrayOp(testOp)) {
    (void)llzkArray_ReadArrayOpGetIndicesAt(testOp, 0);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_ReadArrayOp_SetIndices_Variadic) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_ReadArrayOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    MlirValue values[] = {dummyValue};
    llzkArray_ReadArrayOpSetIndices(testOp, 1, values);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_ReadArrayOp_GetResult) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_ReadArrayOp(testOp)) {
    (void)llzkArray_ReadArrayOpGetResult(testOp);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(ArrayOperationLinkTests, llzk_ReadArrayOp_GetArrRefType) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Array_ReadArrayOp(testOperation)) {
 
    (void)llzkArray_ReadArrayOpGetArrRefType(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}

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

TEST_F(ArrayOperationLinkTests, llzk_WriteArrayOp_Build) {
  // Returns an `arith.constant` op, which will never match the WriteArrayOp 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_Array_WriteArrayOp(testOp)) {
    MlirOpBuilder builder = mlirOpBuilderCreate(context);
    MlirLocation location = mlirLocationUnknownGet(context);
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    MlirValue indicesValues[] = {dummyValue};
    intptr_t indicesSize = 0;
 
    (void)llzkArray_WriteArrayOpBuild(builder, location, dummyValue, indicesSize, indicesValues, dummyValue);
    // No need to destroy builder or op since this code never runs.
  }
 
  mlirOperationDestroy(testOp);
}
 
struct WriteArrayOpBuildFuncHelper : public TestAnyBuildFuncHelper<CAPITest> {
  virtual bool callIsA(MlirOperation op) override { return llzkOperationIsA_Array_WriteArrayOp(op); }
  static std::unique_ptr<WriteArrayOpBuildFuncHelper> get();
 
protected:
  WriteArrayOpBuildFuncHelper() = default;
};

TEST_F(CAPITest, WriteArrayOp_build_pass) { WriteArrayOpBuildFuncHelper::get()->run(*this); }
 
TEST_F(ArrayOperationLinkTests, llzk_WriteArrayOp_GetArrRef) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_WriteArrayOp(testOp)) {
    (void)llzkArray_WriteArrayOpGetArrRef(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_WriteArrayOp_SetArrRef) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_WriteArrayOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkArray_WriteArrayOpSetArrRef(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_WriteArrayOp_GetIndicesCount) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_WriteArrayOp(testOp)) {
    (void)llzkArray_WriteArrayOpGetIndicesCount(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_WriteArrayOp_GetIndicesAt) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_WriteArrayOp(testOp)) {
    (void)llzkArray_WriteArrayOpGetIndicesAt(testOp, 0);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_WriteArrayOp_SetIndices_Variadic) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_WriteArrayOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    MlirValue values[] = {dummyValue};
    llzkArray_WriteArrayOpSetIndices(testOp, 1, values);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_WriteArrayOp_GetRvalue) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_WriteArrayOp(testOp)) {
    (void)llzkArray_WriteArrayOpGetRvalue(testOp);
  }
 
  mlirOperationDestroy(testOp);
}
 
TEST_F(ArrayOperationLinkTests, llzk_WriteArrayOp_SetRvalue) {
  auto testOp = createIndexOperation();
 
  if (llzkOperationIsA_Array_WriteArrayOp(testOp)) {
    auto dummyValue = mlirOperationGetResult(testOp, 0);
    llzkArray_WriteArrayOpSetRvalue(testOp, dummyValue);
  }
 
  mlirOperationDestroy(testOp);
}

TEST_F(ArrayOperationLinkTests, llzk_WriteArrayOp_GetArrRefType) {
  auto testOperation = createIndexOperation();
 
  if (llzkOperationIsA_Array_WriteArrayOp(testOperation)) {
 
    (void)llzkArray_WriteArrayOpGetArrRefType(testOperation);
  }
 
  mlirOperationDestroy(testOperation);
}