1 /* 2 * Copyright (c) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <gtest/gtest.h> 17 #include <vector> 18 19 #include "surface.h" 20 #include "sync_fence.h" 21 22 using namespace testing; 23 using namespace testing::ext; 24 25 namespace OHOS::Rosen { 26 class BaseSurface : public Surface { 27 public: IsConsumer() const28 bool IsConsumer() const override 29 { 30 return false; 31 } GetProducer() const32 sptr<IBufferProducer> GetProducer() const override 33 { 34 return nullptr; 35 } AttachBuffer(sptr<SurfaceBuffer> & buffer)36 GSError AttachBuffer(sptr<SurfaceBuffer> &buffer) override 37 { 38 (void)buffer; 39 return GSERROR_NOT_SUPPORT; 40 } DetachBuffer(sptr<SurfaceBuffer> & buffer)41 GSError DetachBuffer(sptr<SurfaceBuffer> &buffer) override 42 { 43 (void)buffer; 44 return GSERROR_NOT_SUPPORT; 45 } GetQueueSize()46 uint32_t GetQueueSize() override 47 { 48 return 0; 49 } SetQueueSize(uint32_t queueSize)50 GSError SetQueueSize(uint32_t queueSize) override 51 { 52 (void)queueSize; 53 return GSERROR_NOT_SUPPORT; 54 } GetDefaultWidth()55 int32_t GetDefaultWidth() override 56 { 57 return 0; 58 } GetDefaultHeight()59 int32_t GetDefaultHeight() override 60 { 61 return 0; 62 } SetDefaultUsage(uint64_t usage)63 GSError SetDefaultUsage(uint64_t usage) override 64 { 65 (void)usage; 66 return GSERROR_NOT_SUPPORT; 67 } GetDefaultUsage()68 uint64_t GetDefaultUsage() override 69 { 70 return 0; 71 } SetUserData(const std::string & key,const std::string & val)72 GSError SetUserData(const std::string &key, const std::string &val) override 73 { 74 (void)key; 75 (void)val; 76 return GSERROR_NOT_SUPPORT; 77 } GetUserData(const std::string & key)78 std::string GetUserData(const std::string &key) override 79 { 80 (void)key; 81 return std::string(""); 82 } GetName()83 const std::string &GetName() override 84 { 85 return name_; 86 } GetUniqueId() const87 uint64_t GetUniqueId() const override 88 { 89 return 0; 90 } GoBackground()91 GSError GoBackground() override 92 { 93 return GSERROR_NOT_SUPPORT; 94 } SetTransform(GraphicTransformType transform)95 GSError SetTransform(GraphicTransformType transform) override 96 { 97 (void)transform; 98 return GSERROR_NOT_SUPPORT; 99 } GetTransform() const100 GraphicTransformType GetTransform() const override 101 { 102 return GRAPHIC_ROTATE_NONE; 103 } SetScalingMode(uint32_t sequence,ScalingMode scalingMode)104 GSError SetScalingMode(uint32_t sequence, ScalingMode scalingMode) override 105 { 106 (void)sequence; 107 (void)scalingMode; 108 return GSERROR_NOT_SUPPORT; 109 } SetMetaData(uint32_t sequence,const std::vector<GraphicHDRMetaData> & metaData)110 GSError SetMetaData(uint32_t sequence, const std::vector<GraphicHDRMetaData> &metaData) override 111 { 112 (void)sequence; 113 (void)metaData; 114 return GSERROR_NOT_SUPPORT; 115 } SetMetaDataSet(uint32_t sequence,GraphicHDRMetadataKey key,const std::vector<uint8_t> & metaData)116 GSError SetMetaDataSet( 117 uint32_t sequence, GraphicHDRMetadataKey key, const std::vector<uint8_t> &metaData) override 118 { 119 (void)sequence; 120 (void)key; 121 (void)metaData; 122 return GSERROR_NOT_SUPPORT; 123 } SetTunnelHandle(const GraphicExtDataHandle * handle)124 GSError SetTunnelHandle(const GraphicExtDataHandle *handle) override 125 { 126 (void)handle; 127 return GSERROR_NOT_SUPPORT; 128 } Dump(std::string & result) const129 void Dump(std::string &result) const override 130 { 131 (void)result; 132 } AttachBuffer(sptr<SurfaceBuffer> & buffer,int32_t timeOut)133 GSError AttachBuffer(sptr<SurfaceBuffer> &buffer, int32_t timeOut) override 134 { 135 (void)buffer; 136 (void)timeOut; 137 return GSERROR_NOT_SUPPORT; 138 } RegisterSurfaceDelegator(sptr<IRemoteObject> client)139 GSError RegisterSurfaceDelegator(sptr<IRemoteObject> client) override 140 { 141 (void)client; 142 return GSERROR_NOT_SUPPORT; 143 } RegisterReleaseListener(OnReleaseFuncWithFence func)144 GSError RegisterReleaseListener(OnReleaseFuncWithFence func) override 145 { 146 (void)func; 147 return GSERROR_NOT_SUPPORT; 148 } RegisterUserDataChangeListener(const std::string & funcName,OnUserDataChangeFunc func)149 GSError RegisterUserDataChangeListener(const std::string &funcName, OnUserDataChangeFunc func) override 150 { 151 (void)funcName; 152 (void)func; 153 return GSERROR_NOT_SUPPORT; 154 } UnRegisterUserDataChangeListener(const std::string & funcName)155 GSError UnRegisterUserDataChangeListener(const std::string &funcName) override 156 { 157 (void)funcName; 158 return GSERROR_NOT_SUPPORT; 159 } ClearUserDataChangeListener()160 GSError ClearUserDataChangeListener() override 161 { 162 return GSERROR_NOT_SUPPORT; 163 } AttachBufferToQueue(sptr<SurfaceBuffer> buffer)164 GSError AttachBufferToQueue(sptr<SurfaceBuffer> buffer) override 165 { 166 (void)buffer; 167 return GSERROR_NOT_SUPPORT; 168 } DetachBufferFromQueue(sptr<SurfaceBuffer> buffer,bool isReserveSlot=false)169 GSError DetachBufferFromQueue(sptr<SurfaceBuffer> buffer, bool isReserveSlot = false) override 170 { 171 (void)buffer; 172 return GSERROR_NOT_SUPPORT; 173 } GetTransformHint() const174 GraphicTransformType GetTransformHint() const override 175 { 176 return GRAPHIC_ROTATE_NONE; 177 } SetTransformHint(GraphicTransformType transformHint)178 GSError SetTransformHint(GraphicTransformType transformHint) override 179 { 180 (void)transformHint; 181 return GSERROR_NOT_SUPPORT; 182 } SetBufferHold(bool hold)183 void SetBufferHold(bool hold) override 184 { 185 (void)hold; 186 } SetScalingMode(ScalingMode scalingMode)187 GSError SetScalingMode(ScalingMode scalingMode) override 188 { 189 (void)scalingMode; 190 return GSERROR_NOT_SUPPORT; 191 } SetSurfaceSourceType(OHSurfaceSource sourceType)192 GSError SetSurfaceSourceType(OHSurfaceSource sourceType) override 193 { 194 (void)sourceType; 195 return GSERROR_NOT_SUPPORT; 196 } GetSurfaceSourceType() const197 OHSurfaceSource GetSurfaceSourceType() const override 198 { 199 return OH_SURFACE_SOURCE_DEFAULT; 200 } SetSurfaceAppFrameworkType(std::string appFrameworkType)201 GSError SetSurfaceAppFrameworkType(std::string appFrameworkType) override 202 { 203 (void)appFrameworkType; 204 return GSERROR_NOT_SUPPORT; 205 } GetSurfaceAppFrameworkType() const206 std::string GetSurfaceAppFrameworkType() const override 207 { 208 return std::string(""); 209 } 210 211 private: 212 const std::string name_ = ""; 213 }; 214 215 class SurfaceTest : public testing::Test { 216 public: SetUpTestCase()217 static void SetUpTestCase() {} TearDownTestCase()218 static void TearDownTestCase() {} 219 static inline sptr<BaseSurface> surface = new BaseSurface(); 220 static inline ProducerInitInfo info; 221 static inline sptr<SurfaceBuffer> buffer = nullptr; 222 static inline int32_t fence = 0; 223 static inline sptr<SyncFence> fencePtr = nullptr; 224 static inline BufferRequestConfig bufferRequestConfig; 225 static inline std::vector<sptr<SurfaceBuffer>> buffers = {}; 226 static inline std::vector<sptr<SyncFence>> fences = {}; 227 static inline BufferFlushConfig bufferFlushConfig; 228 static inline int64_t timestamp = 0; 229 static inline Rect damage; 230 static inline int32_t width = 0; 231 static inline int32_t height = 0; 232 static inline sptr<IBufferConsumerListener> listener = nullptr; 233 static inline OnReleaseFunc onReleaseFunc = nullptr; 234 static inline OnDeleteBufferFunc onDeleteBufferFunc = nullptr; 235 static inline uint32_t sequence = 0; 236 static inline ScalingMode scalingMode; 237 static inline HDRMetaDataType hdrMetaDataType; 238 static inline std::vector<GraphicHDRMetaData> graphicHDRMetaDatas = {}; 239 static inline GraphicHDRMetadataKey key; 240 static inline std::vector<uint8_t> metaDatas = {}; 241 static inline GraphicPresentTimestamp graphicPresentTimestamp; 242 static inline GraphicPresentTimestampType graphicPresentTimestampType; 243 static inline int64_t time = 0; 244 static inline int32_t format = 0; 245 static inline int32_t colorGamut = 0; 246 static inline BufferFlushConfigWithDamages bufferFlushConfigWithDamages; 247 static inline std::vector<BufferFlushConfigWithDamages> bufferFlushConfigWithDamagesVector = {}; 248 static inline float matrix[16]; 249 static inline int32_t stride = 0; 250 static inline uint64_t usage = 0; 251 static inline int32_t timeout = 0; 252 static inline GraphicColorGamut graphicColorGamut; 253 static inline GraphicTransformType transform; 254 static inline float brightness = 0.0f; 255 static inline uint32_t matrixSize = 0; 256 static inline int32_t alpha = 0; 257 static inline std::string bufferName = ""; 258 }; 259 260 /* 261 * Function: SurfaceTest 262 * Type: Function 263 * Rank: Important(2) 264 * EnvConditions: N/A 265 * CaseDescription: test functions from Surface 266 */ 267 HWTEST_F(SurfaceTest, SurfaceTest001, Function | MediumTest | Level2) 268 { 269 EXPECT_EQ(surface->GetProducerInitInfo(info), GSERROR_NOT_SUPPORT); 270 EXPECT_EQ(surface->RequestBuffer(buffer, fence, bufferRequestConfig), GSERROR_NOT_SUPPORT); 271 EXPECT_EQ(surface->RequestBuffers(buffers, fences, bufferRequestConfig), GSERROR_NOT_SUPPORT); 272 EXPECT_EQ(surface->CancelBuffer(buffer), GSERROR_NOT_SUPPORT); 273 EXPECT_EQ(surface->FlushBuffer(buffer, fence, bufferFlushConfig), GSERROR_NOT_SUPPORT); 274 EXPECT_EQ(surface->AcquireBuffer(buffer, fence, timestamp, damage), GSERROR_NOT_SUPPORT); 275 EXPECT_EQ(surface->ReleaseBuffer(buffer, fence), GSERROR_NOT_SUPPORT); 276 EXPECT_EQ(surface->RequestBuffer(buffer, fencePtr, bufferRequestConfig), GSERROR_NOT_SUPPORT); 277 EXPECT_EQ(surface->FlushBuffer(buffer, fencePtr, bufferFlushConfig), GSERROR_NOT_SUPPORT); 278 EXPECT_EQ(surface->AcquireBuffer(buffer, fencePtr, timestamp, damage), GSERROR_NOT_SUPPORT); 279 EXPECT_EQ(surface->ReleaseBuffer(buffer, fencePtr), GSERROR_NOT_SUPPORT); 280 EXPECT_EQ(surface->SetDefaultWidthAndHeight(width, height), GSERROR_NOT_SUPPORT); 281 EXPECT_EQ(surface->RegisterConsumerListener(listener), GSERROR_NOT_SUPPORT); 282 EXPECT_EQ(surface->Surface::RegisterReleaseListener(onReleaseFunc), GSERROR_NOT_SUPPORT); 283 EXPECT_EQ(surface->RegisterDeleteBufferListener(onDeleteBufferFunc, false), GSERROR_NOT_SUPPORT); 284 EXPECT_EQ(surface->UnregisterConsumerListener(), GSERROR_NOT_SUPPORT); 285 EXPECT_EQ(surface->CleanCache(false), GSERROR_NOT_SUPPORT); 286 EXPECT_EQ(surface->Connect(), GSERROR_NOT_SUPPORT); 287 EXPECT_EQ(surface->Disconnect(), GSERROR_NOT_SUPPORT); 288 EXPECT_EQ(surface->GetScalingMode(sequence, scalingMode), GSERROR_NOT_SUPPORT); 289 EXPECT_EQ(surface->QueryMetaDataType(sequence, hdrMetaDataType), GSERROR_NOT_SUPPORT); 290 EXPECT_EQ(surface->GetMetaData(sequence, graphicHDRMetaDatas), GSERROR_NOT_SUPPORT); 291 EXPECT_EQ(surface->GetMetaDataSet(sequence, key, metaDatas), GSERROR_NOT_SUPPORT); 292 EXPECT_EQ(surface->GetTunnelHandle(), nullptr); 293 EXPECT_EQ(surface->SetPresentTimestamp(sequence, graphicPresentTimestamp), GSERROR_NOT_SUPPORT); 294 EXPECT_EQ(surface->GetPresentTimestamp(sequence, graphicPresentTimestampType, time), GSERROR_NOT_SUPPORT); 295 EXPECT_EQ(surface->GetDefaultFormat(), 0); 296 EXPECT_EQ(surface->SetDefaultFormat(format), GSERROR_NOT_SUPPORT); 297 EXPECT_EQ(surface->GetDefaultColorGamut(), 0); 298 EXPECT_EQ(surface->SetDefaultColorGamut(colorGamut), GSERROR_NOT_SUPPORT); 299 EXPECT_EQ(surface->SetBufferName(bufferName), GSERROR_NOT_SUPPORT); 300 } 301 302 /* 303 * Function: SurfaceTest 304 * Type: Function 305 * Rank: Important(2) 306 * EnvConditions: N/A 307 * CaseDescription: test functions from Surface 308 */ 309 HWTEST_F(SurfaceTest, SurfaceTest002, Function | MediumTest | Level2) 310 { 311 EXPECT_EQ(surface->GetNativeSurface(), nullptr); 312 EXPECT_EQ(surface->QueryIfBufferAvailable(), false); 313 EXPECT_EQ(surface->FlushBuffer(buffer, fencePtr, bufferFlushConfigWithDamages), GSERROR_NOT_SUPPORT); 314 EXPECT_EQ(surface->FlushBuffers(buffers, fences, bufferFlushConfigWithDamagesVector), GSERROR_NOT_SUPPORT); 315 EXPECT_EQ(surface->UnRegisterReleaseListener(), GSERROR_NOT_SUPPORT); 316 EXPECT_EQ(surface->SetWptrNativeWindowToPSurface(nullptr), GSERROR_NOT_SUPPORT); 317 EXPECT_EQ(surface->GetLastFlushedBuffer(buffer, fencePtr, matrix, false), GSERROR_NOT_SUPPORT); 318 surface->SetRequestWidthAndHeight(width, height); 319 EXPECT_EQ(surface->GetRequestWidth(), 0); 320 EXPECT_EQ(surface->GetRequestHeight(), 0); 321 surface->SetWindowConfig(bufferRequestConfig); 322 surface->SetWindowConfigWidthAndHeight(width, height); 323 surface->SetWindowConfigStride(stride); 324 surface->SetWindowConfigFormat(format); 325 surface->SetWindowConfigUsage(usage); 326 surface->SetWindowConfigTimeout(timeout); 327 surface->SetWindowConfigColorGamut(graphicColorGamut); 328 surface->SetWindowConfigTransform(transform); 329 surface->GetWindowConfig(); 330 EXPECT_EQ(surface->SetHdrWhitePointBrightness(brightness), GSERROR_NOT_SUPPORT); 331 EXPECT_EQ(surface->SetSdrWhitePointBrightness(brightness), GSERROR_NOT_SUPPORT); 332 EXPECT_EQ(surface->AcquireLastFlushedBuffer(buffer, fencePtr, matrix, matrixSize, false), GSERROR_NOT_SUPPORT); 333 EXPECT_EQ(surface->ReleaseLastFlushedBuffer(buffer), GSERROR_NOT_SUPPORT); 334 EXPECT_EQ(surface->SetGlobalAlpha(alpha), GSERROR_NOT_SUPPORT); 335 EXPECT_EQ(surface->IsInHebcList(), false); 336 } 337 } // namespace OHOS::Rosen