renderscript/1.0/vts/functional/VtsScriptTests.cpp

/*
 * Copyright (C) 2017 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "VtsHalRenderscriptV1_0TargetTest.h"

/*
 * Create a Blur intrinsic with scriptIntrinsicCreate, and call
 * scriptSetTimeZone to make sure it is not crashing.
 *
 * Calls: elementCreate, scriptIntrinsicCreate, scriptSetTimeZone
 */
TEST_F(RenderscriptHidlTest, IntrinsicTest) {
    // uint8
    Element element = context->elementCreate(DataType::UNSIGNED_8, DataKind::USER, false, 1);
    Script script = context->scriptIntrinsicCreate(ScriptIntrinsicID::ID_BLUR, element);
    EXPECT_NE(Script(0), script);

    context->scriptSetTimeZone(script, "UTF-8");
}

/*
 * Create a user script “struct_test”, and verified the setters and getters work
 * for the global variables.
 *
 * Calls: scriptCCreate, scriptGetVarV, scriptSetVarI, scriptSetVarJ,
 * scriptSetVarF, scriptSetVarD, elementCreate, typeCreate,
 * allocationCreateTyped, scriptSetVarObj, scriptSetVarV, scriptSetVarVE
 */
TEST_F(RenderscriptHidlTest, ScriptVarTest) {
    hidl_vec<uint8_t> bitcode;
    bitcode.setToExternal((uint8_t*)bitCode, bitCodeLength);
    Script script = context->scriptCCreate("struct_test", "/data/local/tmp/", bitcode);
    EXPECT_NE(Script(0), script);

    // arg tests
    context->scriptSetVarI(script, mExportVarIdx_var_int, 100);
    int resultI = 0;
    context->scriptGetVarV(script, mExportVarIdx_var_int, sizeof(int),
                           [&](const hidl_vec<uint8_t>& _data){ resultI = *((int*)_data.data()); });
    EXPECT_EQ(100, resultI);

    context->scriptSetVarJ(script, mExportVarIdx_var_long, 101l);
    int resultJ = 0;
    context->scriptGetVarV(script, mExportVarIdx_var_long, sizeof(long),
                           [&](const hidl_vec<uint8_t>& _data){
                               resultJ = *((long*)_data.data()); });
    EXPECT_EQ(101l, resultJ);

    context->scriptSetVarF(script, mExportVarIdx_var_float, 102.0f);
    int resultF = 0.0f;
    context->scriptGetVarV(script, mExportVarIdx_var_float, sizeof(float),
                           [&](const hidl_vec<uint8_t>& _data){
                               resultF = *((float*)_data.data()); });
    EXPECT_EQ(102.0f, resultF);

    context->scriptSetVarD(script, mExportVarIdx_var_double, 103.0);
    int resultD = 0.0;
    context->scriptGetVarV(script, mExportVarIdx_var_double, sizeof(double),
                           [&](const hidl_vec<uint8_t>& _data){
                               resultD = *((double*)_data.data()); });
    EXPECT_EQ(103.0, resultD);

    // float1
    Element element = context->elementCreate(DataType::FLOAT_32, DataKind::USER, false, 1);
    // 128 x float1
    Type type = context->typeCreate(element, 128, 0, 0, false, false, YuvFormat::YUV_NONE);
    // 128 x float1
    Allocation allocationIn = context->allocationCreateTyped(type, AllocationMipmapControl::NONE,
                                                             (int)AllocationUsageType::SCRIPT,
                                                             (Ptr)nullptr);
    Allocation allocationOut = Allocation(0);
    context->scriptSetVarObj(script, mExportVarIdx_var_allocation, (ObjectBase)allocationIn);
    context->scriptGetVarV(script, mExportVarIdx_var_allocation, sizeof(ObjectBase),
                           [&](const hidl_vec<uint8_t>& _data){
                               allocationOut = (Allocation) *((ObjectBase*)_data.data()); });
    EXPECT_EQ(allocationOut, allocationIn);

    uint32_t valueV = 104u;
    hidl_vec<uint8_t> _dataV;
    _dataV.setToExternal((uint8_t*)&valueV, sizeof(uint32_t));
    context->scriptSetVarV(script, mExportVarIdx_var_uint32_t, _dataV);
    uint32_t resultV = 0u;
    context->scriptGetVarV(script, mExportVarIdx_var_uint32_t, sizeof(uint32_t),
                           [&](const hidl_vec<uint8_t>& _data){
                               resultV = *((uint32_t*)_data.data()); });
    EXPECT_EQ(104u, resultV);

    std::vector<int> dataVE = {1000, 1001};
    std::vector<uint32_t> dimsVE = {1};
    std::vector<int> outVE(2);
    hidl_vec<uint8_t> _dataVE;
    hidl_vec<uint32_t> _dimsVE;
    _dataVE.setToExternal((uint8_t*)dataVE.data(), dataVE.size()*sizeof(int));
    _dimsVE.setToExternal((uint32_t*)dimsVE.data(), dimsVE.size());
    // intx2 to represent point2 which is {int, int}
    Element elementVE = context->elementCreate(DataType::SIGNED_32, DataKind::USER, false, 2);
    context->scriptSetVarVE(script, mExportVarIdx_var_point2, _dataVE, elementVE, _dimsVE);
    context->scriptGetVarV(script, mExportVarIdx_var_point2, 2*sizeof(int),
                           [&](const hidl_vec<uint8_t>& _data){
                               outVE = std::vector<int>(
                                   (int*)_data.data(), (int*)_data.data() + 2); });
    EXPECT_EQ(1000, outVE[0]);
    EXPECT_EQ(1001, outVE[1]);
}

/*
 * Create a user script “struct_test”, and input and output Allocations.
 * Verified the foreach launch correctly for the invoke kernel.
 *
 * Calls: scriptCCreate, scriptInvoke, scriptGetVarV, scriptInvokeV
 */
TEST_F(RenderscriptHidlTest, ScriptInvokeTest) {
    hidl_vec<uint8_t> bitcode;
    bitcode.setToExternal((uint8_t*)bitCode, bitCodeLength);
    Script script = context->scriptCCreate("struct_test", "/data/local/tmp/", bitcode);
    EXPECT_NE(Script(0), script);

    // invoke test
    int resultI = 0;
    long resultJ = 0l;
    float resultF = 0.0f;
    double resultD = 0.0;
    uint32_t resultV = 0u;
    std::vector<int> resultVE(2);
    context->scriptInvoke(script, mExportFuncIdx_function);
    context->scriptGetVarV(script, mExportVarIdx_var_int, sizeof(int),
                           [&](const hidl_vec<uint8_t>& _data){ resultI = *((int*)_data.data()); });
    context->scriptGetVarV(script, mExportVarIdx_var_long, sizeof(long),
                           [&](const hidl_vec<uint8_t>& _data){
                               resultJ = *((long*)_data.data()); });
    context->scriptGetVarV(script, mExportVarIdx_var_float, sizeof(float),
                           [&](const hidl_vec<uint8_t>& _data){
                               resultF = *((float*)_data.data()); });
    context->scriptGetVarV(script, mExportVarIdx_var_double, sizeof(double),
                           [&](const hidl_vec<uint8_t>& _data){
                               resultD = *((double*)_data.data()); });
    context->scriptGetVarV(script, mExportVarIdx_var_uint32_t, sizeof(uint32_t),
                           [&](const hidl_vec<uint8_t>& _data){
                               resultV = *((uint32_t*)_data.data()); });
    context->scriptGetVarV(script, mExportVarIdx_var_point2, 2*sizeof(int),
                           [&](const hidl_vec<uint8_t>& _data){
                               resultVE = std::vector<int>(
                                   (int*)_data.data(), (int*)_data.data() + 2); });
    EXPECT_EQ(1, resultI);
    EXPECT_EQ(2l, resultJ);
    EXPECT_EQ(3.0f, resultF);
    EXPECT_EQ(4.0, resultD);
    EXPECT_EQ(5u, resultV);
    EXPECT_EQ(6, resultVE[0]);
    EXPECT_EQ(7, resultVE[1]);

    // invokeV test
    int functionV_arg = 5;
    int functionV_res = 0;
    hidl_vec<uint8_t> functionV_data;
    functionV_data.setToExternal((uint8_t*)&functionV_arg, sizeof(int));
    context->scriptInvokeV(script, mExportFuncIdx_functionV, functionV_data);
    context->scriptGetVarV(script, mExportVarIdx_var_int, sizeof(int),
                           [&](const hidl_vec<uint8_t>& _data){
                               functionV_res = *((int*)_data.data()); });
    EXPECT_EQ(5, functionV_res);
}

/*
 * Create a user script “struct_test”, and input and output Allocations.
 * Verified the foreach launch correctly for the foreach kernel.
 *
 * Calls: scriptCCreate, elementCreate, typeCreate, allocationCreateTyped,
 * allocation1DWrite, scriptForEach, allocationRead
 */
TEST_F(RenderscriptHidlTest, ScriptForEachTest) {
    hidl_vec<uint8_t> bitcode;
    bitcode.setToExternal((uint8_t*)bitCode, bitCodeLength);
    Script script = context->scriptCCreate("struct_test", "/data/local/tmp/", bitcode);
    EXPECT_NE(Script(0), script);

    // uint8_t
    Element element = context->elementCreate(DataType::UNSIGNED_8, DataKind::USER, false, 1);
    // 64 x uint8_t
    Type type = context->typeCreate(element, 64, 0, 0, false, false, YuvFormat::YUV_NONE);
    std::vector<uint8_t> dataIn(64), dataOut(64), expected(64);
    std::generate(dataIn.begin(), dataIn.end(), [](){ static uint8_t val = 0; return val++; });
    std::generate(expected.begin(), expected.end(), [](){ static uint8_t val = 1; return val++; });
    hidl_vec<uint8_t> _data;
    _data.setToExternal((uint8_t*)dataIn.data(), dataIn.size());
    // 64 x float1
    Allocation allocation = context->allocationCreateTyped(type, AllocationMipmapControl::NONE,
                                                           (int)AllocationUsageType::SCRIPT,
                                                           (Ptr)nullptr);
    Allocation vout = context->allocationCreateTyped(type, AllocationMipmapControl::NONE,
                                                     (int)AllocationUsageType::SCRIPT,
                                                     (Ptr)nullptr);
    context->allocation1DWrite(allocation, 0, 0, (Size)dataIn.size(), _data);
    hidl_vec<Allocation> vains;
    vains.setToExternal(&allocation, 1);
    hidl_vec<uint8_t> params;
    context->scriptForEach(script, mExportForEachIdx_increment, vains, vout, params, nullptr);
    context->allocationRead(vout, (Ptr)dataOut.data(), (Size)dataOut.size()*sizeof(uint8_t));
    EXPECT_EQ(expected, dataOut);
}

/*
 * Create a user script “struct_test”, and input and output Allocations.
 * Verified the foreach launch correctly for the reduction kernel.
 *
 * Calls: scriptCCreate, elementCreate, typeCreate, allocationCreateTyped,
 * allocation1DWrite, scriptReduce, contextFinish, allocationRead
 */
TEST_F(RenderscriptHidlTest, ScriptReduceTest) {
    hidl_vec<uint8_t> bitcode;
    bitcode.setToExternal((uint8_t*)bitCode, bitCodeLength);
    Script script = context->scriptCCreate("struct_test", "/data/local/tmp/", bitcode);
    EXPECT_NE(Script(0), script);

    // uint8_t
    Element element = context->elementCreate(DataType::SIGNED_32, DataKind::USER, false, 1);
    // 64 x uint8_t
    Type type = context->typeCreate(element, 64, 0, 0, false, false, YuvFormat::YUV_NONE);
    Type type2 = context->typeCreate(element, 1, 0, 0, false, false, YuvFormat::YUV_NONE);
    std::vector<int> dataIn(64), dataOut(1);
    std::generate(dataIn.begin(), dataIn.end(), [](){ static int val = 0; return val++; });
    hidl_vec<uint8_t> _data;
    _data.setToExternal((uint8_t*)dataIn.data(), dataIn.size()*sizeof(int));
    // 64 x float1
    Allocation allocation = context->allocationCreateTyped(type, AllocationMipmapControl::NONE,
                                                           (int)AllocationUsageType::SCRIPT,
                                                           (Ptr)nullptr);
    Allocation vaout = context->allocationCreateTyped(type2, AllocationMipmapControl::NONE,
                                                      (int)AllocationUsageType::SCRIPT,
                                                      (Ptr)nullptr);
    context->allocation1DWrite(allocation, 0, 0, (Size)dataIn.size(), _data);
    hidl_vec<Allocation> vains;
    vains.setToExternal(&allocation, 1);
    context->scriptReduce(script, mExportReduceIdx_summation, vains, vaout, nullptr);
    context->contextFinish();
    context->allocationRead(vaout, (Ptr)dataOut.data(), (Size)dataOut.size()*sizeof(int));
    // sum of 0, 1, 2, ..., 62, 63
    int sum = 63*64/2;
    EXPECT_EQ(sum, dataOut[0]);
}

/*
 * This test creates an allocation and binds it to a data segment in the
 * RenderScript script, represented in the bitcode.
 *
 * Calls: scriptCCreate, elementCreate, typeCreate, allocationCreateTyped,
 * scriptSetVarV, scriptBindAllocation, allocationRead
 */
TEST_F(RenderscriptHidlTest, ScriptBindTest) {
    hidl_vec<uint8_t> bitcode;
    bitcode.setToExternal((uint8_t*)bitCode, bitCodeLength);
    Script script = context->scriptCCreate("struct_test", "/data/local/tmp/", bitcode);
    EXPECT_NE(Script(0), script);

    // in32
    Element element = context->elementCreate(DataType::SIGNED_32, DataKind::USER, false, 1);
    // 64 x int32
    Type type = context->typeCreate(element, 64, 0, 0, false, false, YuvFormat::YUV_NONE);
    // 64 x int32
    Allocation allocation = context->allocationCreateTyped(type, AllocationMipmapControl::NONE,
                                                           (int)AllocationUsageType::SCRIPT,
                                                           (Ptr)nullptr);
    std::vector<int> dataIn(64), dataOut(64), expected(64, 5);
    hidl_vec<uint8_t> _data;
    _data.setToExternal((uint8_t*)dataIn.data(), dataIn.size()*sizeof(int));
    context->allocation1DWrite(allocation, 0, 0, (Size)dataIn.size(), _data);
    context->scriptBindAllocation(script, allocation, mExportVarIdx_var_int_ptr);
    int dim = 64;
    hidl_vec<uint8_t> _dim;
    _dim.setToExternal((uint8_t*)&dim, sizeof(int));
    context->scriptInvokeV(script, mExportFuncIdx_setBuffer, _dim);
    context->allocationRead(allocation, (Ptr)dataOut.data(), (Size)dataOut.size()*sizeof(int));
    EXPECT_EQ(expected, dataOut);
}

/*
 * This test groups together two RenderScript intrinsic kernels to run one after
 * the other asynchronously with respect to the client. The test configures YuvToRGB(A) and Blur,
 * and links them together such that Blur will execute after YuvToRGB(A) and use its result. The
 * test checks the data returned to make sure it was changed after passing through the entire
 * ScriptGroup.
 *
 * Calls: elementCreate, typeCreate, allocationCreateTyped, allocation2DWrite,
 * scriptIntrinsicCreate, scriptKernelIDCreate, scriptFieldIDCreate,
 * scriptGroupCreate, scriptGroupSetOutput, scriptGroupExecute, allocation2DRead
 */
TEST_F(RenderscriptHidlTest, ScriptGroupTest) {
    std::vector<uint8_t> dataIn(256*256*1, 128), dataOut(256*256*4, 0), zeros(256*256*4, 0);
    hidl_vec<uint8_t> _dataIn, _dataOut;
    _dataIn.setToExternal(dataIn.data(), dataIn.size());
    _dataOut.setToExternal(dataOut.data(), dataOut.size());

    // 256 x 256 YUV pixels
    Element element1 = context->elementCreate(DataType::UNSIGNED_8, DataKind::PIXEL_YUV, true, 1);
    Type type1 = context->typeCreate(element1, 256, 256, 0, false, false, YuvFormat::YUV_420_888);
    Allocation allocation1 = context->allocationCreateTyped(type1, AllocationMipmapControl::NONE,
                                                           (int)AllocationUsageType::SCRIPT,
                                                           (Ptr)nullptr);
    context->allocation2DWrite(allocation1, 0, 0, 0, AllocationCubemapFace::POSITIVE_X, 256, 256,
                               _dataIn, 0);

    // 256 x 256 RGBA pixels
    Element element2 = context->elementCreate(DataType::UNSIGNED_8, DataKind::PIXEL_RGBA, true, 4);
    Type type2 = context->typeCreate(element2, 256, 256, 0, false, false, YuvFormat::YUV_NONE);
    Allocation allocation2 = context->allocationCreateTyped(type2, AllocationMipmapControl::NONE,
                                                           (int)AllocationUsageType::SCRIPT,
                                                           (Ptr)nullptr);
    context->allocation2DWrite(allocation2, 0, 0, 0, AllocationCubemapFace::POSITIVE_X, 256, 256,
                               _dataOut, 0);

    // create scripts
    Script yuv2rgb = context->scriptIntrinsicCreate(ScriptIntrinsicID::ID_YUV_TO_RGB, element1);
    EXPECT_NE(Script(0), yuv2rgb);

    ScriptKernelID yuv2rgbKID = context->scriptKernelIDCreate(yuv2rgb, 0, 2);
    EXPECT_NE(ScriptKernelID(0), yuv2rgbKID);

    Script blur = context->scriptIntrinsicCreate(ScriptIntrinsicID::ID_BLUR, element2);
    EXPECT_NE(Script(0), blur);

    ScriptKernelID blurKID = context->scriptKernelIDCreate(blur, 0, 2);
    EXPECT_NE(ScriptKernelID(0), blurKID);
    ScriptFieldID blurFID = context->scriptFieldIDCreate(blur, 1);
    EXPECT_NE(ScriptFieldID(0), blurFID);

    // ScriptGroup
    hidl_vec<ScriptKernelID> kernels = {yuv2rgbKID, blurKID};
    hidl_vec<ScriptKernelID> srcK = {yuv2rgbKID};
    hidl_vec<ScriptKernelID> dstK = {ScriptKernelID(0)};
    hidl_vec<ScriptFieldID> dstF = {blurFID};
    hidl_vec<Type> types = {type2};
    ScriptGroup scriptGroup = context->scriptGroupCreate(kernels, srcK, dstK, dstF, types);
    EXPECT_NE(ScriptGroup(0), scriptGroup);

    context->scriptSetVarObj(yuv2rgb, 0, (ObjectBase)allocation1);
    context->scriptGroupSetOutput(scriptGroup, blurKID, allocation2);
    context->scriptGroupExecute(scriptGroup);
    context->contextFinish();

    // verify contents were changed
    context->allocation2DRead(allocation2, 0, 0, 0, AllocationCubemapFace::POSITIVE_X, 256, 256,
                              (Ptr)dataOut.data(), (Size)dataOut.size(), 0);
    EXPECT_NE(zeros, dataOut);
}

/*
 * Similar to the ScriptGroup test, this test verifies the execution flow of
 * RenderScript kernels and invokables.
 *
 * Calls: scriptFieldIDCreate, closureCreate, scriptInvokeIDCreate,
 * invokeClosureCreate, closureSetGlobal, scriptGroup2Create, scriptGroupExecute
 */
TEST_F(RenderscriptHidlTest, ScriptGroup2Test) {
    hidl_vec<uint8_t> bitcode;
    bitcode.setToExternal((uint8_t*)bitCode, bitCodeLength);
    Script script = context->scriptCCreate("struct_test", "/data/local/tmp/", bitcode);
    EXPECT_NE(Script(0), script);

    std::vector<uint8_t> dataIn(128, 128), dataOut(128, 0), expected(128, 7+1);
    hidl_vec<uint8_t> _dataIn, _dataOut;
    _dataIn.setToExternal(dataIn.data(), dataIn.size());

    // 256 x 256 YUV pixels
    Element element = context->elementCreate(DataType::UNSIGNED_8, DataKind::USER, false, 1);
    Type type = context->typeCreate(element, 128, 0, 0, false, false, YuvFormat::YUV_NONE);
    Allocation allocation = context->allocationCreateTyped(type, AllocationMipmapControl::NONE,
                                                           (int)AllocationUsageType::SCRIPT,
                                                           (Ptr)nullptr);
    context->allocation1DWrite(allocation, 0, 0, (Size)_dataIn.size(), _dataIn);

    ScriptFieldID fieldID = context->scriptFieldIDCreate(script, mExportVarIdx_var_allocation);
    EXPECT_NE(ScriptFieldID(0), fieldID);
    ASSERT_NE(ScriptFieldID(0), fieldID);

    // invoke
    ScriptInvokeID invokeID = context->scriptInvokeIDCreate(script, mExportFuncIdx_setAllocation);
    EXPECT_NE(ScriptInvokeID(0), invokeID);
    ASSERT_NE(ScriptInvokeID(0), invokeID);

    int dim = 128;
    hidl_vec<uint8_t> params;
    params.setToExternal((uint8_t*)&dim, sizeof(dim));
    hidl_vec<ScriptFieldID> fieldIDS1 = {fieldID};
    hidl_vec<int64_t> values1 = {int64_t(0)};
    hidl_vec<int32_t> sizes1 = {int32_t(0)};
    Closure closure1 = context->invokeClosureCreate(invokeID, params, fieldIDS1, values1, sizes1);
    EXPECT_NE(Closure(0), closure1);
    ASSERT_NE(Closure(0), closure1);

    // kernel
    ScriptKernelID kernelID = context->scriptKernelIDCreate(script, mExportForEachIdx_increment, 3);
    EXPECT_NE(ScriptKernelID(0), kernelID);
    ASSERT_NE(ScriptKernelID(0), kernelID);

    hidl_vec<ScriptFieldID> fieldIDS2 = {ScriptFieldID(0)};
    hidl_vec<int64_t> values2 = {(int64_t)(intptr_t)allocation};
    hidl_vec<int32_t> sizes2 = {-1 /* allocation */};
    hidl_vec<Closure> depClosures2 = {closure1};
    hidl_vec<ScriptFieldID> depFieldIDS2 = {fieldID};
    Closure closure2 = context->closureCreate(kernelID, allocation /* returnValue */, fieldIDS2,
                                              values2, sizes2, depClosures2, depFieldIDS2);
    EXPECT_NE(Closure(0), closure2);
    ASSERT_NE(Closure(0), closure2);

    // set argument
    context->closureSetGlobal(closure1, fieldID, (int64_t)(intptr_t)allocation,
                              -1 /* allocation */);

    // execute
    hidl_string name = "script_group_2_test";
    hidl_string cacheDir = "/data/local/tmp";
    hidl_vec<Closure> closures = {closure1, closure2};
    ScriptGroup2 scriptGroup2 = context->scriptGroup2Create(name, cacheDir, closures);
    EXPECT_NE(ScriptGroup2(0), scriptGroup2);
    ASSERT_NE(ScriptGroup2(0), scriptGroup2);

    context->scriptGroupExecute(scriptGroup2);
    context->allocationRead(allocation, (Ptr)dataOut.data(), (Size)dataOut.size()*sizeof(uint8_t));
    EXPECT_EQ(expected, dataOut);
}

/*
 * Similar to the ScriptGroup test, this test verifies a single kernel can be
 * called by ScriptGroup with an unbound allocation specified before launch
 *
 * Calls: scriptFieldIDCreate, closureCreate, scriptInvokeIDCreate,
 * invokeClosureCreate, closureSetArg, scriptGroup2Create, scriptGroupExecute
 */
TEST_F(RenderscriptHidlTest, ScriptGroup2KernelTest) {
    hidl_vec<uint8_t> bitcode;
    bitcode.setToExternal((uint8_t*)bitCode, bitCodeLength);
    Script script = context->scriptCCreate("struct_test", "/data/local/tmp/", bitcode);
    EXPECT_NE(Script(0), script);

    std::vector<uint8_t> dataIn(128, 128), dataOut(128, 0), expected(128, 128 + 1);
    hidl_vec<uint8_t> _dataIn, _dataOut;
    _dataIn.setToExternal(dataIn.data(), dataIn.size());

    // 256 x 256 YUV pixels
    Element element = context->elementCreate(DataType::UNSIGNED_8, DataKind::USER, false, 1);
    Type type = context->typeCreate(element, 128, 0, 0, false, false, YuvFormat::YUV_NONE);
    Allocation allocation = context->allocationCreateTyped(type, AllocationMipmapControl::NONE,
                                                           (int)AllocationUsageType::SCRIPT,
                                                           (Ptr)nullptr);
    context->allocation1DWrite(allocation, 0, 0, (Size)_dataIn.size(), _dataIn);

    // kernel
    ScriptKernelID kernelID = context->scriptKernelIDCreate(script, mExportForEachIdx_increment, 3);
    EXPECT_NE(ScriptKernelID(0), kernelID);
    ASSERT_NE(ScriptKernelID(0), kernelID);

    hidl_vec<ScriptFieldID> fieldIDS = {ScriptFieldID(0)};
    hidl_vec<int64_t> values = {int64_t(0)};
    hidl_vec<int32_t> sizes = {int32_t(0)};
    hidl_vec<Closure> depClosures = {Closure(0)};
    hidl_vec<ScriptFieldID> depFieldIDS = {ScriptFieldID(0)};
    Closure closure = context->closureCreate(kernelID, allocation /* returnValue */, fieldIDS,
                                              values, sizes, depClosures, depFieldIDS);
    EXPECT_NE(Closure(0), closure);
    ASSERT_NE(Closure(0), closure);

    // set argument
    context->closureSetArg(closure, 0 /* first argument */, (Ptr)allocation, -1);

    // execute
    hidl_string name = "script_group_2_test";
    hidl_string cacheDir = "/data/local/tmp";
    hidl_vec<Closure> closures = {closure};
    ScriptGroup2 scriptGroup2 = context->scriptGroup2Create(name, cacheDir, closures);
    EXPECT_NE(ScriptGroup2(0), scriptGroup2);
    ASSERT_NE(ScriptGroup2(0), scriptGroup2);

    context->scriptGroupExecute(scriptGroup2);
    context->allocationRead(allocation, (Ptr)dataOut.data(), (Size)dataOut.size()*sizeof(uint8_t));
    EXPECT_EQ(expected, dataOut);
}