/*
* 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);
EXPECT_NE(Element(0), element);
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);
ASSERT_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);
ASSERT_NE(Element(0), element);
// 128 x float1
Type type = context->typeCreate(element, 128, 0, 0, false, false, YuvFormat::YUV_NONE);
ASSERT_NE(Type(0), type);
// 128 x float1
Allocation allocationIn = context->allocationCreateTyped(type, AllocationMipmapControl::NONE,
(int)AllocationUsageType::SCRIPT,
(Ptr)nullptr);
ASSERT_NE(Allocation(0), allocationIn);
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);
ASSERT_NE(Element(0), elementVE);
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);
ASSERT_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);
ASSERT_NE(Script(0), script);
// uint8_t
Element element = context->elementCreate(DataType::UNSIGNED_8, DataKind::USER, false, 1);
ASSERT_NE(Element(0), element);
// 64 x uint8_t
Type type = context->typeCreate(element, 64, 0, 0, false, false, YuvFormat::YUV_NONE);
ASSERT_NE(Type(0), type);
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);
ASSERT_NE(Allocation(0), allocation);
Allocation vout = context->allocationCreateTyped(type, AllocationMipmapControl::NONE,
(int)AllocationUsageType::SCRIPT,
(Ptr)nullptr);
ASSERT_NE(Allocation(0), vout);
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);
ASSERT_NE(Script(0), script);
// uint8_t
Element element = context->elementCreate(DataType::SIGNED_32, DataKind::USER, false, 1);
ASSERT_NE(Element(0), element);
// 64 x uint8_t
Type type = context->typeCreate(element, 64, 0, 0, false, false, YuvFormat::YUV_NONE);
ASSERT_NE(Type(0), type);
Type type2 = context->typeCreate(element, 1, 0, 0, false, false, YuvFormat::YUV_NONE);
ASSERT_NE(Type(0), type2);
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);
ASSERT_NE(Allocation(0), allocation);
Allocation vaout = context->allocationCreateTyped(type2, AllocationMipmapControl::NONE,
(int)AllocationUsageType::SCRIPT,
(Ptr)nullptr);
ASSERT_NE(Allocation(0), vaout);
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,
* allocation1DWrite, scriptBindAllocation, scriptSetVarV, scriptBindAllocation,
* allocationRead, scriptInvokeV, 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);
ASSERT_NE(Script(0), script);
// in32
Element element = context->elementCreate(DataType::SIGNED_32, DataKind::USER, false, 1);
ASSERT_NE(Element(0), element);
// 64 x int32
Type type = context->typeCreate(element, 64, 0, 0, false, false, YuvFormat::YUV_NONE);
ASSERT_NE(Type(0), type);
// 64 x int32
Allocation allocation = context->allocationCreateTyped(type, AllocationMipmapControl::NONE,
(int)AllocationUsageType::SCRIPT,
(Ptr)nullptr);
ASSERT_NE(Allocation(0), allocation);
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
* Blend and Blur, and links them together such that Blur will execute after
* Blend 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, scriptGroupSetInput, scriptGroupSetOutput,
* scriptGroupExecute, contextFinish, allocation2DRead
*/
TEST_F(RenderscriptHidlTest, ScriptGroupTest) {
std::vector<uint8_t> dataIn(256 * 256 * 4, 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_RGBA, true, 4);
ASSERT_NE(Element(0), element1);
Type type1 = context->typeCreate(element1, 256, 256, 0, false, false,
YuvFormat::YUV_NONE);
ASSERT_NE(Type(0), type1);
Allocation allocation1 = context->allocationCreateTyped(type1, AllocationMipmapControl::NONE,
(int)AllocationUsageType::SCRIPT,
(Ptr)nullptr);
ASSERT_NE(Allocation(0), allocation1);
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);
ASSERT_NE(Element(0), element2);
Type type2 = context->typeCreate(element2, 256, 256, 0, false, false, YuvFormat::YUV_NONE);
ASSERT_NE(Type(0), type2);
Allocation allocation2 = context->allocationCreateTyped(type2, AllocationMipmapControl::NONE,
(int)AllocationUsageType::SCRIPT,
(Ptr)nullptr);
ASSERT_NE(Allocation(0), allocation2);
context->allocation2DWrite(allocation2, 0, 0, 0, AllocationCubemapFace::POSITIVE_X, 256, 256,
_dataOut, 0);
// create scripts
Script blend =
context->scriptIntrinsicCreate(ScriptIntrinsicID::ID_BLEND, element1);
ASSERT_NE(Script(0), blend);
ScriptKernelID blendKID = context->scriptKernelIDCreate(blend, 1, 3);
ASSERT_NE(ScriptKernelID(0), blendKID);
Script blur = context->scriptIntrinsicCreate(ScriptIntrinsicID::ID_BLUR, element2);
ASSERT_NE(Script(0), blur);
ScriptKernelID blurKID = context->scriptKernelIDCreate(blur, 0, 2);
ASSERT_NE(ScriptKernelID(0), blurKID);
ScriptFieldID blurFID = context->scriptFieldIDCreate(blur, 1);
ASSERT_NE(ScriptFieldID(0), blurFID);
// ScriptGroup
hidl_vec<ScriptKernelID> kernels = {blendKID, blurKID};
hidl_vec<ScriptKernelID> srcK = {blendKID};
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);
ASSERT_NE(ScriptGroup(0), scriptGroup);
context->scriptGroupSetInput(scriptGroup, blendKID, 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: scriptCCreate, elementCreate, typeCreate, allocationCreateTyped,
* allocation1DWrite, scriptFieldIDCreate, scriptInvokeIDCreate,
* invokeClosureCreate, closureCreate, closureSetGlobal, scriptGroup2Create,
* scriptGroupExecute, allocationRead
*/
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);
ASSERT_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);
ASSERT_NE(Element(0), element);
Type type = context->typeCreate(element, 128, 0, 0, false, false, YuvFormat::YUV_NONE);
ASSERT_NE(Type(0), type);
Allocation allocation = context->allocationCreateTyped(type, AllocationMipmapControl::NONE,
(int)AllocationUsageType::SCRIPT,
(Ptr)nullptr);
ASSERT_NE(Allocation(0), allocation);
context->allocation1DWrite(allocation, 0, 0, (Size)_dataIn.size(), _dataIn);
ScriptFieldID fieldID = context->scriptFieldIDCreate(script, mExportVarIdx_var_allocation);
ASSERT_NE(ScriptFieldID(0), fieldID);
// invoke
ScriptInvokeID invokeID = context->scriptInvokeIDCreate(script, mExportFuncIdx_setAllocation);
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);
ASSERT_NE(Closure(0), closure1);
// kernel
ScriptKernelID kernelID = context->scriptKernelIDCreate(script, mExportForEachIdx_increment, 3);
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);
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);
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: scriptCCreate, elementCreate, typeCreate, allocationCreateTyped,
* allocation1DWrite, scriptKernelIDCreate, closureCreate, closureSetArg,
* scriptGroup2Create, scriptGroupExecute, allocationRead
*/
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);
ASSERT_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);
ASSERT_NE(Element(0), element);
Type type = context->typeCreate(element, 128, 0, 0, false, false, YuvFormat::YUV_NONE);
ASSERT_NE(Type(0), type);
Allocation allocation = context->allocationCreateTyped(type, AllocationMipmapControl::NONE,
(int)AllocationUsageType::SCRIPT,
(Ptr)nullptr);
ASSERT_NE(Allocation(0), allocation);
context->allocation1DWrite(allocation, 0, 0, (Size)_dataIn.size(), _dataIn);
// kernel
ScriptKernelID kernelID = context->scriptKernelIDCreate(script, mExportForEachIdx_increment, 3);
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);
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);
ASSERT_NE(ScriptGroup2(0), scriptGroup2);
context->scriptGroupExecute(scriptGroup2);
context->allocationRead(allocation, (Ptr)dataOut.data(), (Size)dataOut.size()*sizeof(uint8_t));
EXPECT_EQ(expected, dataOut);
}