automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-platform-abstraction.cpp

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include "test-platform-abstraction.h"
  19 #include "dali-test-suite-utils.h"
  20 #include <dali/integration-api/bitmap.h>
  21
  22 namespace Dali
  23 {
  24
  25 TestPlatformAbstraction::TestPlatformAbstraction()
  26 : mTrace(),
  27   mIsLoadingResult( false ),
  28   mGetDefaultFontSizeResult( 0 ),
  29   mLoadedResourcesQueue(),
  30   mFailedLoadQueue(),
  31   mResourceRequests(),
  32   mSize(),
  33   mClosestSize(),
  34   mLoadFileResult(),
  35   mSaveFileResult( false ),
  36   mSynchronouslyLoadedResource()
  37 {
  38   Initialize();
  39 }
  40
  41 TestPlatformAbstraction::~TestPlatformAbstraction()
  42 {
  43   DiscardRequest();
  44 }
  45
  46 void TestPlatformAbstraction::Suspend()
  47 {
  48   mTrace.PushCall("Suspend", "");
  49 }
  50
  51 void TestPlatformAbstraction::Resume()
  52 {
  53   mTrace.PushCall("Resume", "");
  54 }
  55
  56 ImageDimensions TestPlatformAbstraction::GetClosestImageSize( const std::string& filename,
  57                                                               ImageDimensions size,
  58                                                               FittingMode::Type fittingMode,
  59                                                               SamplingMode::Type samplingMode,
  60                                                               bool orientationCorrection )
  61 {
  62   ImageDimensions closestSize = ImageDimensions( mClosestSize.x, mClosestSize.y );
  63   mTrace.PushCall("GetClosestImageSize", "");
  64   return closestSize;
  65 }
  66
  67 ImageDimensions TestPlatformAbstraction::GetClosestImageSize( Integration::ResourcePointer resourceBuffer,
  68                                                    ImageDimensions size,
  69                                                    FittingMode::Type fittingMode,
  70                                                    SamplingMode::Type samplingMode,
  71                                                    bool orientationCorrection )
  72 {
  73   ImageDimensions closestSize = ImageDimensions( mClosestSize.x, mClosestSize.y );
  74   mTrace.PushCall("GetClosestImageSize", "");
  75   return closestSize;
  76 }
  77
  78 void TestPlatformAbstraction::LoadResource(const Integration::ResourceRequest& request)
  79 {
  80   std::ostringstream out;
  81   out << "Type:" << request.GetType()->id << ", Path: " << request.GetPath() << std::endl ;
  82
  83   mTrace.PushCall("LoadResource", out.str());
  84
  85   mResourceRequests.PushBack( new Integration::ResourceRequest(request) );
  86 }
  87
  88 Integration::ResourcePointer TestPlatformAbstraction::LoadResourceSynchronously( const Integration::ResourceType& resourceType, const std::string& resourcePath )
  89 {
  90   mTrace.PushCall("LoadResourceSynchronously", "");
  91   return mSynchronouslyLoadedResource;
  92 }
  93
  94 Integration::BitmapPtr TestPlatformAbstraction::DecodeBuffer( const Integration::ResourceType& resourceType, uint8_t * buffer, size_t size )
  95 {
  96   mTrace.PushCall("DecodeBuffer", "");
  97   return mDecodedBitmap;
  98 }
  99
 100 void TestPlatformAbstraction::CancelLoad(Integration::ResourceId id, Integration::ResourceTypeId typeId)
 101 {
 102   mTrace.PushCall("CancelLoad", "");
 103 }
 104
 105 void TestPlatformAbstraction::GetResources(Integration::ResourceCache& cache)
 106 {
 107   mTrace.PushCall("GetResources", "");
 108
 109   while( !mLoadedResourcesQueue.empty() )
 110   {
 111     LoadedResource loaded( *mLoadedResourcesQueue.begin() );
 112     mLoadedResourcesQueue.erase( mLoadedResourcesQueue.begin() );
 113     cache.LoadResponse( loaded.id, loaded.type, loaded.resource, Integration::RESOURCE_COMPLETELY_LOADED );
 114   }
 115
 116   // iterate through the resources which failed to load
 117   while( !mFailedLoadQueue.empty() )
 118   {
 119     FailedLoad failed( *mFailedLoadQueue.begin() );
 120     mFailedLoadQueue.erase( mFailedLoadQueue.begin() );
 121     cache.LoadFailed( failed.id, failed.failure );
 122   }
 123 }
 124
 125 bool TestPlatformAbstraction::IsLoading()
 126 {
 127   mTrace.PushCall("IsLoading", "");
 128   return mIsLoadingResult;
 129 }
 130
 131 int TestPlatformAbstraction::GetDefaultFontSize() const
 132 {
 133   mTrace.PushCall("GetDefaultFontSize", "");
 134   return mGetDefaultFontSizeResult;
 135 }
 136
 137 void TestPlatformAbstraction::SetDpi (unsigned int dpiHorizontal, unsigned int dpiVertical)
 138 {
 139   mTrace.PushCall("SetDpi", "");
 140 }
 141
 142 bool TestPlatformAbstraction::LoadFile( const std::string& filename, Dali::Vector< unsigned char >& buffer ) const
 143 {
 144   mTrace.PushCall("LoadFile", "");
 145   if( mLoadFileResult.loadResult )
 146   {
 147     buffer = mLoadFileResult.buffer;
 148   }
 149
 150   return mLoadFileResult.loadResult;
 151 }
 152
 153 bool TestPlatformAbstraction::LoadShaderBinaryFile( const std::string& filename, Dali::Vector< unsigned char >& buffer ) const
 154 {
 155   mTrace.PushCall("LoadShaderBinaryFile", "");
 156   if( mLoadFileResult.loadResult )
 157   {
 158     buffer = mLoadFileResult.buffer;
 159   }
 160
 161   return mLoadFileResult.loadResult;
 162 }
 163
 164 bool TestPlatformAbstraction::SaveFile(const std::string& filename, const unsigned char * buffer, unsigned int numBytes ) const
 165 {
 166   mTrace.PushCall("SaveFile", "");
 167   return false;
 168 }
 169
 170 void TestPlatformAbstraction::JoinLoaderThreads()
 171 {
 172   mTrace.PushCall("JoinLoaderThreads", "");
 173 }
 174
 175 /** Call this every test */
 176 void TestPlatformAbstraction::Initialize()
 177 {
 178   mTrace.Reset();
 179   mTrace.Enable(true);
 180   mLoadedResourcesQueue.clear();
 181   mFailedLoadQueue.clear();
 182   mResourceRequests.Clear();
 183   mIsLoadingResult=false;
 184   mSynchronouslyLoadedResource.Reset();
 185   mDecodedBitmap.Reset();
 186 }
 187
 188 bool TestPlatformAbstraction::WasCalled(TestFuncEnum func)
 189 {
 190   switch(func)
 191   {
 192     case SuspendFunc:                         return mTrace.FindMethod("Suspend");
 193     case ResumeFunc:                          return mTrace.FindMethod("Resume");
 194     case LoadResourceFunc:                    return mTrace.FindMethod("LoadResource");
 195     case LoadResourceSynchronouslyFunc:       return mTrace.FindMethod("LoadResourceSynchronously");
 196     case LoadFileFunc:                        return mTrace.FindMethod("LoadFile");
 197     case LoadShaderBinaryFileFunc:            return mTrace.FindMethod("LoadShaderBinaryFile");
 198     case SaveShaderBinaryFileFunc:            return mTrace.FindMethod("SaveShaderBinaryFile");
 199     case SaveFileFunc:                        return mTrace.FindMethod("SaveFile");
 200     case CancelLoadFunc:                      return mTrace.FindMethod("CancelLoad");
 201     case GetResourcesFunc:                    return mTrace.FindMethod("GetResources");
 202     case IsLoadingFunc:                       return mTrace.FindMethod("IsLoading");
 203     case SetDpiFunc:                          return mTrace.FindMethod("SetDpi");
 204     case JoinLoaderThreadsFunc:               return mTrace.FindMethod("JoinLoaderThreads");
 205   }
 206   return false;
 207 }
 208
 209 void TestPlatformAbstraction::SetIsLoadingResult(bool result)
 210 {
 211   mIsLoadingResult = result;
 212 }
 213
 214 void TestPlatformAbstraction::ClearReadyResources()
 215 {
 216   mLoadedResourcesQueue.clear();
 217   mFailedLoadQueue.clear();
 218   mSynchronouslyLoadedResource.Reset();
 219   mDecodedBitmap.Reset();
 220 }
 221
 222 void TestPlatformAbstraction::SetResourceLoaded(Integration::ResourceId  loadedId,
 223                                                 Integration::ResourceTypeId  loadedType,
 224                                                 Integration::ResourcePointer loadedResource)
 225 {
 226   LoadedResource loadedInfo;
 227   loadedInfo.id = loadedId;
 228   loadedInfo.type = loadedType;
 229   loadedInfo.resource = loadedResource;
 230   mLoadedResourcesQueue.push_back( loadedInfo );
 231 }
 232
 233 void TestPlatformAbstraction::SetResourceLoadFailed(Integration::ResourceId  id,
 234                                                     Integration::ResourceFailure failure)
 235 {
 236   FailedLoad failedInfo;
 237   failedInfo.id = id;
 238   failedInfo.failure = failure;
 239   mFailedLoadQueue.push_back( failedInfo );
 240 }
 241
 242 Integration::ResourceRequest* TestPlatformAbstraction::GetRequest()
 243 {
 244   Integration::ResourceRequest* request = NULL;
 245
 246   // Return last request
 247   if( ! mResourceRequests.Empty() )
 248   {
 249     request = *( mResourceRequests.End() - 1 );
 250   }
 251
 252   return request;
 253 }
 254
 255 const TestPlatformAbstraction::ResourceRequestContainer& TestPlatformAbstraction::GetAllRequests() const
 256 {
 257   return mResourceRequests;
 258 }
 259
 260 void TestPlatformAbstraction::SetAllResourceRequestsAsLoaded()
 261 {
 262   for( ResourceRequestContainer::Iterator iter = mResourceRequests.Begin(), endIter = mResourceRequests.End();
 263        iter != endIter; ++iter )
 264   {
 265     Integration::ResourceRequest* request = *iter;
 266     Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD );
 267     Integration::ResourcePointer resource(bitmap);
 268     bitmap->GetPackedPixelsProfile()->ReserveBuffer(Pixel::RGBA8888, 80, 80, 80, 80);
 269     SetResourceLoaded( request->GetId(), request->GetType()->id, resource );
 270     delete request;
 271   }
 272   mResourceRequests.Clear();
 273 }
 274
 275 void TestPlatformAbstraction::SetAllResourceRequestsAsFailed( Integration::ResourceFailure failure )
 276 {
 277   for( ResourceRequestContainer::Iterator iter = mResourceRequests.Begin(), endIter = mResourceRequests.End();
 278        iter != endIter; ++iter )
 279   {
 280     Integration::ResourceRequest* request = *iter;
 281     SetResourceLoadFailed( (*iter)->GetId(), failure);
 282     delete request;
 283   }
 284   mResourceRequests.Clear();
 285 }
 286
 287 void TestPlatformAbstraction::DiscardRequest()
 288 {
 289   for( ResourceRequestContainer::Iterator iter = mResourceRequests.Begin(), endIter = mResourceRequests.End();
 290        iter != endIter; ++iter )
 291   {
 292     Integration::ResourceRequest* request = *iter;
 293     delete request;
 294   }
 295   mResourceRequests.Clear();
 296 }
 297
 298 void TestPlatformAbstraction::SetClosestImageSize(const Vector2& size)
 299 {
 300   mClosestSize = size;
 301 }
 302
 303 void TestPlatformAbstraction::SetLoadFileResult( bool result, Dali::Vector< unsigned char >& buffer )
 304 {
 305   mLoadFileResult.loadResult = result;
 306   if( result )
 307   {
 308     mLoadFileResult.buffer = buffer;
 309   }
 310 }
 311
 312 void TestPlatformAbstraction::SetSaveFileResult( bool result )
 313 {
 314   mSaveFileResult = result;
 315 }
 316
 317 void TestPlatformAbstraction::SetSynchronouslyLoadedResource( Integration::ResourcePointer resource )
 318 {
 319   mSynchronouslyLoadedResource = resource;
 320 }
 321
 322 void TestPlatformAbstraction::SetDecodedBitmap( Integration::BitmapPtr bitmap )
 323 {
 324   mDecodedBitmap = bitmap;
 325 }
 326
 327 } // namespace Dali