| /* |
| * 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" |
| #include <system/window.h> |
| |
| /* |
| * ContextCreateAndDestroy: |
| * Creates a RenderScript context and immediately destroys the context. |
| * Since create and destroy calls are a part of SetUp() and TearDown(), |
| * the test definition is intentionally kept empty |
| * |
| * Calls: getService<IDevice>, contextCreate, contextDestroy |
| */ |
| TEST_F(RenderscriptHidlTest, ContextCreateAndDestroy) {} |
| |
| /* |
| * Create an Element and verify the return value is valid. |
| * |
| * Calls: elementCreate |
| */ |
| TEST_F(RenderscriptHidlTest, ElementCreate) { |
| Element element = context->elementCreate(DataType::FLOAT_32, DataKind::USER, false, 1); |
| EXPECT_NE(Element(0), element); |
| } |
| |
| /* |
| * Create an Element, a Type and an Allocation of that type, and verify the |
| * return values are valid. |
| * |
| * Calls: elementCreate, typeCreate, allocationCreateTyped, allocationGetType |
| */ |
| TEST_F(RenderscriptHidlTest, ElementTypeAllocationCreate) { |
| // Element create test |
| Element element = context->elementCreate(DataType::FLOAT_32, DataKind::USER, false, 1); |
| ASSERT_NE(Element(0), element); |
| |
| // Type create test |
| Type type = context->typeCreate(element, 1, 0, 0, false, false, YuvFormat::YUV_NONE); |
| ASSERT_NE(Type(0), type); |
| |
| // Allocation create test |
| Allocation allocation = context->allocationCreateTyped(type, AllocationMipmapControl::NONE, |
| (int)((uint32_t)AllocationUsageType::ALL |
| & ~(uint32_t)AllocationUsageType::OEM), |
| (Ptr)nullptr); |
| ASSERT_NE(Allocation(0), allocation); |
| |
| // Allocation type test |
| Type type2 = context->allocationGetType(allocation); |
| EXPECT_EQ(type, type2); |
| } |
| |
| /* |
| * Create an Element, a Type of the Element, and verify the native metadata can |
| * be retrieved correctly. |
| * |
| * Calls: elementCreate, typeCreate, elementGetNativeMetadata, |
| * typeGetNativeMetadata |
| */ |
| TEST_F(RenderscriptHidlTest, MetadataTest) { |
| // 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); |
| |
| std::vector<uint32_t> elementMetadata(5); |
| context->elementGetNativeMetadata(element, [&](const hidl_vec<uint32_t>& _metadata){ |
| elementMetadata = _metadata; }); |
| EXPECT_EQ(DataType::FLOAT_32, (DataType)elementMetadata[0]); |
| EXPECT_EQ(DataKind::USER, (DataKind)elementMetadata[1]); |
| EXPECT_EQ(false, elementMetadata[2]); |
| EXPECT_EQ(1u, (uint32_t)elementMetadata[3]); |
| EXPECT_EQ(0u, (uint32_t)elementMetadata[4]); |
| |
| std::vector<OpaqueHandle> typeMetadata(6); |
| context->typeGetNativeMetadata(type, [&typeMetadata](const hidl_vec<OpaqueHandle>& _metadata){ |
| typeMetadata = _metadata; }); |
| EXPECT_EQ(128u, (uint32_t)typeMetadata[0]); |
| EXPECT_EQ(0u, (uint32_t)typeMetadata[1]); |
| EXPECT_EQ(0u, (uint32_t)typeMetadata[2]); |
| EXPECT_NE(true, typeMetadata[3]); |
| EXPECT_NE(true, typeMetadata[4]); |
| EXPECT_EQ(element, (Element)typeMetadata[5]); |
| } |
| |
| /* |
| * Create a Allocation, and verified allocationGetPointer and allocationResize1D |
| * return valid values. |
| * |
| * Calls: elementCreate, typeCreate, allocationCreateTyped, |
| * allocationGetPointer, allocationResize1D |
| */ |
| TEST_F(RenderscriptHidlTest, ResizeTest) { |
| // 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 allocation = context->allocationCreateTyped(type, AllocationMipmapControl::NONE, |
| (int)AllocationUsageType::SCRIPT, |
| (Ptr)nullptr); |
| ASSERT_NE(Allocation(0), allocation); |
| |
| Ptr dataPtr1, dataPtr2; |
| Size stride; |
| context->allocationGetPointer(allocation, 0, AllocationCubemapFace::POSITIVE_X, 0, |
| [&](Ptr _dataPtr, Size _stride){ |
| dataPtr1 = _dataPtr; stride = _stride; }); |
| EXPECT_EQ(Size(0), stride); |
| |
| context->allocationResize1D(allocation, 1024*1024); |
| context->allocationGetPointer(allocation, 0, AllocationCubemapFace::POSITIVE_X, 0, |
| [&](Ptr _dataPtr, Size _stride){ |
| dataPtr2 = _dataPtr; stride = _stride; }); |
| EXPECT_EQ(Size(0), stride); |
| EXPECT_NE(dataPtr1, dataPtr2); |
| } |
| |
| /* |
| * Test creates two allocations, one with IO_INPUT and one with IO_OUTPUT. The |
| * NativeWindow (Surface) is retrieved from one allocation and set to the other. |
| * |
| * Calls: elementCreate, typeCreate, allocationCreateTyped, allocation2DWrite, |
| * allocationGetNativeWindow, allocationSetNativeWindow, allocationIoSend, |
| * allocationIoReceive, allocation2DRead |
| */ |
| TEST_F(RenderscriptHidlTest, NativeWindowIoTest) { |
| // uint8x4 |
| Element element = context->elementCreate(DataType::UNSIGNED_8, DataKind::USER, false, 4); |
| ASSERT_NE(Element(0), element); |
| |
| // 512 x 512 x uint8x4 |
| Type type = context->typeCreate(element, 512, 512, 0, false, false, YuvFormat::YUV_NONE); |
| ASSERT_NE(Type(0), type); |
| |
| std::vector<uint32_t> dataIn(512*512), dataOut(512*512); |
| std::generate(dataIn.begin(), dataIn.end(), [](){ static uint32_t val = 0; return val++; }); |
| hidl_vec<uint8_t> _data; |
| _data.setToExternal((uint8_t*)dataIn.data(), dataIn.size()*sizeof(uint32_t)); |
| // 512 x 512 x uint8x4 |
| Allocation allocationRecv = context->allocationCreateTyped(type, AllocationMipmapControl::NONE, |
| (int)(AllocationUsageType::SCRIPT |
| | AllocationUsageType::IO_INPUT), |
| (Ptr)nullptr); |
| ASSERT_NE(Allocation(0), allocationRecv); |
| |
| Allocation allocationSend = context->allocationCreateTyped(type, AllocationMipmapControl::NONE, |
| (int)(AllocationUsageType::SCRIPT |
| | AllocationUsageType::IO_OUTPUT), |
| (Ptr)nullptr); |
| ASSERT_NE(Allocation(0), allocationSend); |
| |
| NativeWindow nativeWindow = context->allocationGetNativeWindow(allocationRecv); |
| ASSERT_NE(NativeWindow(0), nativeWindow); |
| |
| ((ANativeWindow *)nativeWindow)->incStrong(nullptr); |
| native_window_api_connect((ANativeWindow*)nativeWindow, |
| NATIVE_WINDOW_API_CPU); |
| |
| context->allocationSetNativeWindow(allocationSend, nativeWindow); |
| context->allocation2DWrite(allocationSend, 0, 0, 0, AllocationCubemapFace::POSITIVE_X, 512, 512, |
| _data, 0); |
| context->allocationIoSend(allocationSend); |
| context->allocationIoReceive(allocationRecv); |
| context->allocation2DRead(allocationRecv, 0, 0, 0, AllocationCubemapFace::POSITIVE_X, 512, 512, |
| (Ptr)dataOut.data(), (Size)dataOut.size()*sizeof(uint32_t), 0); |
| EXPECT_EQ(dataIn, dataOut); |
| } |
| |
| /* |
| * Three allocations are created, two with IO_INPUT and one with IO_OUTPUT. The |
| * two allocations with IO_INPUT are made to share the same BufferQueue. |
| * |
| * Calls: elementCreate, typeCreate, allocationCreateTyped, |
| * allocationSetupBufferQueue, allocationShareBufferQueue, |
| * allocationGetNativeWindow, allocationSetNativeWindow, |
| * allocation2DWrite, allocation2DRead, allocationIoSend, |
| * allocationIoReceive |
| */ |
| TEST_F(RenderscriptHidlTest, BufferQueueTest) { |
| // uint8x4 |
| Element element = context->elementCreate(DataType::UNSIGNED_8, DataKind::USER, false, 4); |
| ASSERT_NE(Element(0), element); |
| |
| // 512 x 512 x uint8x4 |
| Type type = context->typeCreate(element, 512, 512, 0, false, false, YuvFormat::YUV_NONE); |
| ASSERT_NE(Type(0), type); |
| |
| std::vector<uint32_t> dataIn(512*512), dataOut1(512*512), dataOut2(512*512); |
| std::generate(dataIn.begin(), dataIn.end(), [](){ static uint32_t val = 0; return val++; }); |
| hidl_vec<uint8_t> _data; |
| _data.setToExternal((uint8_t*)dataIn.data(), dataIn.size()*sizeof(uint32_t)); |
| // 512 x 512 x uint8x4 |
| Allocation allocationRecv1 = context->allocationCreateTyped(type, AllocationMipmapControl::NONE, |
| (int)(AllocationUsageType::SCRIPT |
| | AllocationUsageType::IO_INPUT), |
| (Ptr)nullptr); |
| ASSERT_NE(Allocation(0), allocationRecv1); |
| |
| Allocation allocationRecv2 = context->allocationCreateTyped(type, AllocationMipmapControl::NONE, |
| (int)(AllocationUsageType::SCRIPT |
| | AllocationUsageType::IO_INPUT), |
| (Ptr)nullptr); |
| ASSERT_NE(Allocation(0), allocationRecv2); |
| |
| Allocation allocationSend = context->allocationCreateTyped(type, AllocationMipmapControl::NONE, |
| (int)(AllocationUsageType::SCRIPT |
| | AllocationUsageType::IO_INPUT), |
| (Ptr)nullptr); |
| ASSERT_NE(Allocation(0), allocationSend); |
| |
| context->allocationSetupBufferQueue(allocationRecv1, 2); |
| context->allocationShareBufferQueue(allocationRecv2, allocationRecv1); |
| |
| NativeWindow nativeWindow1 = context->allocationGetNativeWindow(allocationRecv1); |
| ASSERT_NE(NativeWindow(0), nativeWindow1); |
| |
| NativeWindow nativeWindow2 = context->allocationGetNativeWindow(allocationRecv2); |
| ASSERT_NE(NativeWindow(0), nativeWindow2); |
| EXPECT_EQ(nativeWindow2, nativeWindow1); |
| |
| ((ANativeWindow *)nativeWindow1)->incStrong(nullptr); |
| native_window_api_connect((ANativeWindow*)nativeWindow1, |
| NATIVE_WINDOW_API_CPU); |
| |
| context->allocationSetNativeWindow(allocationSend, nativeWindow1); |
| context->allocation2DWrite(allocationSend, 0, 0, 0, AllocationCubemapFace::POSITIVE_X, 512, 512, |
| _data, 0); |
| context->allocationIoSend(allocationSend); |
| context->allocationIoReceive(allocationRecv1); |
| context->allocation2DRead(allocationRecv1, 0, 0, 0, AllocationCubemapFace::POSITIVE_X, 512, 512, |
| (Ptr)dataOut1.data(), (Size)dataOut1.size()*sizeof(uint32_t), 0); |
| EXPECT_EQ(dataIn, dataOut1); |
| |
| context->allocation2DWrite(allocationSend, 0, 0, 0, AllocationCubemapFace::POSITIVE_X, 512, 512, |
| _data, 0); |
| context->allocationIoSend(allocationSend); |
| context->allocationIoReceive(allocationRecv2); |
| context->allocation2DRead(allocationRecv2, 0, 0, 0, AllocationCubemapFace::POSITIVE_X, 512, 512, |
| (Ptr)dataOut2.data(), (Size)dataOut2.size()*sizeof(uint32_t), 0); |
| EXPECT_EQ(dataIn, dataOut2); |
| } |
| |
| /* |
| * This test sets up the message queue, sends a message, peeks at the message, |
| * and reads it back. |
| * |
| * Calls: contextInitToClient, contextSendMessage, contextPeekMessage, |
| * contextGetMessage, contextDeinitToClient, contextLog |
| */ |
| TEST_F(RenderscriptHidlTest, ContextMessageTest) { |
| context->contextInitToClient(); |
| |
| const char * message = "correct"; |
| std::vector<char> messageSend(message, message + sizeof(message)); |
| hidl_vec<uint8_t> _data; |
| _data.setToExternal((uint8_t*)messageSend.data(), messageSend.size()); |
| context->contextSendMessage(0, _data); |
| MessageToClientType messageType; |
| size_t size; |
| uint32_t subID; |
| context->contextPeekMessage([&](MessageToClientType _type, Size _size, uint32_t _subID){ |
| messageType = _type; size = (uint32_t)_size; subID = _subID; }); |
| std::vector<char> messageRecv(size, '\0'); |
| context->contextGetMessage(messageRecv.data(), messageRecv.size(), |
| [&](MessageToClientType _type, Size _size){ |
| messageType = _type; size = (uint32_t)_size; }); |
| EXPECT_EQ(messageSend, messageRecv); |
| |
| context->contextDeinitToClient(); |
| context->contextLog(); |
| } |
| |
| /* |
| * Call through a bunch of APIs and make sure they don’t crash. Assign the name |
| * of a object and check getName returns the name just set. |
| * |
| * Calls: contextSetPriority, contextSetCacheDir, elementCreate, assignName, |
| * contextFinish, getName, objDestroy, samplerCreate |
| */ |
| TEST_F(RenderscriptHidlTest, MiscellaneousTests) { |
| context->contextSetPriority(ThreadPriorities::NORMAL); |
| context->contextSetCacheDir("/data/local/tmp/temp/"); |
| |
| Element element = context->elementCreate(DataType::UNSIGNED_8, DataKind::USER, false, 1); |
| ASSERT_NE(Element(0), element); |
| |
| std::string nameIn = "element_test_name"; |
| std::string nameOut = "not_name"; |
| hidl_string _nameIn; |
| _nameIn.setToExternal(nameIn.c_str(), nameIn.length()); |
| context->assignName(element, _nameIn); |
| context->contextFinish(); |
| context->getName(element, [&](const hidl_string& _name){ nameOut = _name.c_str(); }); |
| EXPECT_EQ("element_test_name", nameOut); |
| |
| context->objDestroy(element); |
| |
| Sampler sampler = context->samplerCreate(SamplerValue::LINEAR, SamplerValue::LINEAR, |
| SamplerValue::LINEAR, SamplerValue::LINEAR, |
| SamplerValue::LINEAR, 8.0f); |
| EXPECT_NE(Sampler(0), sampler); |
| } |
