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

   1 /*
   2  * Copyright (c) 2014 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 Integration::BitmapPtr();
  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 }
 186
 187 bool TestPlatformAbstraction::WasCalled(TestFuncEnum func)
 188 {
 189   switch(func)
 190   {
 191     case SuspendFunc:                         return mTrace.FindMethod("Suspend");
 192     case ResumeFunc:                          return mTrace.FindMethod("Resume");
 193     case LoadResourceFunc:                    return mTrace.FindMethod("LoadResource");
 194     case LoadResourceSynchronouslyFunc:       return mTrace.FindMethod("LoadResourceSynchronously");
 195     case LoadFileFunc:                        return mTrace.FindMethod("LoadFile");
 196     case LoadShaderBinaryFileFunc:            return mTrace.FindMethod("LoadShaderBinaryFile");
 197     case SaveShaderBinaryFileFunc:            return mTrace.FindMethod("SaveShaderBinaryFile");
 198     case SaveFileFunc:                        return mTrace.FindMethod("SaveFile");
 199     case CancelLoadFunc:                      return mTrace.FindMethod("CancelLoad");
 200     case GetResourcesFunc:                    return mTrace.FindMethod("GetResources");
 201     case IsLoadingFunc:                       return mTrace.FindMethod("IsLoading");
 202     case SetDpiFunc:                          return mTrace.FindMethod("SetDpi");
 203     case JoinLoaderThreadsFunc:               return mTrace.FindMethod("JoinLoaderThreads");
 204   }
 205   return false;
 206 }
 207
 208 void TestPlatformAbstraction::SetIsLoadingResult(bool result)
 209 {
 210   mIsLoadingResult = result;
 211 }
 212
 213 void TestPlatformAbstraction::ClearReadyResources()
 214 {
 215   mLoadedResourcesQueue.clear();
 216   mFailedLoadQueue.clear();
 217   mSynchronouslyLoadedResource.Reset();
 218 }
 219
 220 void TestPlatformAbstraction::SetResourceLoaded(Integration::ResourceId  loadedId,
 221                                                 Integration::ResourceTypeId  loadedType,
 222                                                 Integration::ResourcePointer loadedResource)
 223 {
 224   LoadedResource loadedInfo;
 225   loadedInfo.id = loadedId;
 226   loadedInfo.type = loadedType;
 227   loadedInfo.resource = loadedResource;
 228   mLoadedResourcesQueue.push_back( loadedInfo );
 229 }
 230
 231 void TestPlatformAbstraction::SetResourceLoadFailed(Integration::ResourceId  id,
 232                                                     Integration::ResourceFailure failure)
 233 {
 234   FailedLoad failedInfo;
 235   failedInfo.id = id;
 236   failedInfo.failure = failure;
 237   mFailedLoadQueue.push_back( failedInfo );
 238 }
 239
 240 Integration::ResourceRequest* TestPlatformAbstraction::GetRequest()
 241 {
 242   Integration::ResourceRequest* request = NULL;
 243
 244   // Return last request
 245   if( ! mResourceRequests.Empty() )
 246   {
 247     request = *( mResourceRequests.End() - 1 );
 248   }
 249
 250   return request;
 251 }
 252
 253 const TestPlatformAbstraction::ResourceRequestContainer& TestPlatformAbstraction::GetAllRequests() const
 254 {
 255   return mResourceRequests;
 256 }
 257
 258 void TestPlatformAbstraction::SetAllResourceRequestsAsLoaded()
 259 {
 260   for( ResourceRequestContainer::Iterator iter = mResourceRequests.Begin(), endIter = mResourceRequests.End();
 261        iter != endIter; ++iter )
 262   {
 263     Integration::ResourceRequest* request = *iter;
 264     Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD );
 265     Integration::ResourcePointer resource(bitmap);
 266     bitmap->GetPackedPixelsProfile()->ReserveBuffer(Pixel::RGBA8888, 80, 80, 80, 80);
 267     SetResourceLoaded( request->GetId(), request->GetType()->id, resource );
 268     delete request;
 269   }
 270   mResourceRequests.Clear();
 271 }
 272
 273 void TestPlatformAbstraction::SetAllResourceRequestsAsFailed( Integration::ResourceFailure failure )
 274 {
 275   for( ResourceRequestContainer::Iterator iter = mResourceRequests.Begin(), endIter = mResourceRequests.End();
 276        iter != endIter; ++iter )
 277   {
 278     Integration::ResourceRequest* request = *iter;
 279     SetResourceLoadFailed( (*iter)->GetId(), failure);
 280     delete request;
 281   }
 282   mResourceRequests.Clear();
 283 }
 284
 285 void TestPlatformAbstraction::DiscardRequest()
 286 {
 287   for( ResourceRequestContainer::Iterator iter = mResourceRequests.Begin(), endIter = mResourceRequests.End();
 288        iter != endIter; ++iter )
 289   {
 290     Integration::ResourceRequest* request = *iter;
 291     delete request;
 292   }
 293   mResourceRequests.Clear();
 294 }
 295
 296 void TestPlatformAbstraction::SetClosestImageSize(const Vector2& size)
 297 {
 298   mClosestSize = size;
 299 }
 300
 301 void TestPlatformAbstraction::SetLoadFileResult( bool result, Dali::Vector< unsigned char >& buffer )
 302 {
 303   mLoadFileResult.loadResult = result;
 304   if( result )
 305   {
 306     mLoadFileResult.buffer = buffer;
 307   }
 308 }
 309
 310 void TestPlatformAbstraction::SetSaveFileResult( bool result )
 311 {
 312   mSaveFileResult = result;
 313 }
 314
 315 void TestPlatformAbstraction::SetSynchronouslyLoadedResource( Integration::ResourcePointer resource )
 316 {
 317   mSynchronouslyLoadedResource = resource;
 318 }
 319
 320 } // namespace Dali