automated-tests/src/dali/dali-test-suite-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 }
  44
  45 void TestPlatformAbstraction::Suspend()
  46 {
  47   mTrace.PushCall("Suspend", "");
  48 }
  49
  50 void TestPlatformAbstraction::Resume()
  51 {
  52   mTrace.PushCall("Resume", "");
  53 }
  54
  55 ImageDimensions TestPlatformAbstraction::GetClosestImageSize( const std::string& filename,
  56                                                               ImageDimensions size,
  57                                                               FittingMode::Type fittingMode,
  58                                                               SamplingMode::Type samplingMode,
  59                                                               bool orientationCorrection )
  60 {
  61   ImageDimensions closestSize = ImageDimensions( mClosestSize.x, mClosestSize.y );
  62   mTrace.PushCall("GetClosestImageSize", "");
  63   return closestSize;
  64 }
  65
  66 ImageDimensions TestPlatformAbstraction::GetClosestImageSize( Integration::ResourcePointer resourceBuffer,
  67                                                    ImageDimensions size,
  68                                                    FittingMode::Type fittingMode,
  69                                                    SamplingMode::Type samplingMode,
  70                                                    bool orientationCorrection )
  71 {
  72   ImageDimensions closestSize = ImageDimensions( mClosestSize.x, mClosestSize.y );
  73   mTrace.PushCall("GetClosestImageSize", "");
  74   return closestSize;
  75 }
  76
  77 void TestPlatformAbstraction::LoadResource(const Integration::ResourceRequest& request)
  78 {
  79   std::ostringstream out;
  80   out << "Type:" << request.GetType()->id << ", Path: " << request.GetPath() << std::endl ;
  81
  82   mTrace.PushCall("LoadResource", out.str());
  83
  84   mResourceRequests.PushBack( new Integration::ResourceRequest(request) );
  85 }
  86
  87 Integration::ResourcePointer TestPlatformAbstraction::LoadResourceSynchronously( const Integration::ResourceType& resourceType, const std::string& resourcePath )
  88 {
  89   mTrace.PushCall("LoadResourceSynchronously", "");
  90   return mSynchronouslyLoadedResource;
  91 }
  92
  93 Integration::BitmapPtr TestPlatformAbstraction::DecodeBuffer( const Integration::ResourceType& resourceType, uint8_t * buffer, size_t size )
  94 {
  95   mTrace.PushCall("DecodeBuffer", "");
  96   return mDecodedBitmap;
  97 }
  98
  99 void TestPlatformAbstraction::CancelLoad(Integration::ResourceId id, Integration::ResourceTypeId typeId)
 100 {
 101   mTrace.PushCall("CancelLoad", "");
 102 }
 103
 104 void TestPlatformAbstraction::GetResources(Integration::ResourceCache& cache)
 105 {
 106   mTrace.PushCall("GetResources", "");
 107
 108   while( !mLoadedResourcesQueue.empty() )
 109   {
 110     LoadedResource loaded( *mLoadedResourcesQueue.begin() );
 111     mLoadedResourcesQueue.erase( mLoadedResourcesQueue.begin() );
 112     cache.LoadResponse( loaded.id, loaded.type, loaded.resource, Integration::RESOURCE_COMPLETELY_LOADED );
 113   }
 114
 115   // iterate through the resources which failed to load
 116   while( !mFailedLoadQueue.empty() )
 117   {
 118     FailedLoad failed( *mFailedLoadQueue.begin() );
 119     mFailedLoadQueue.erase( mFailedLoadQueue.begin() );
 120     cache.LoadFailed( failed.id, failed.failure );
 121   }
 122 }
 123
 124 bool TestPlatformAbstraction::IsLoading()
 125 {
 126   mTrace.PushCall("IsLoading", "");
 127   return mIsLoadingResult;
 128 }
 129
 130 int TestPlatformAbstraction::GetDefaultFontSize() const
 131 {
 132   mTrace.PushCall("GetDefaultFontSize", "");
 133   return mGetDefaultFontSizeResult;
 134 }
 135
 136 void TestPlatformAbstraction::SetDpi (unsigned int dpiHorizontal, unsigned int dpiVertical)
 137 {
 138   mTrace.PushCall("SetDpi", "");
 139 }
 140
 141 bool TestPlatformAbstraction::LoadFile( const std::string& filename, Dali::Vector< unsigned char >& buffer ) const
 142 {
 143   mTrace.PushCall("LoadFile", "");
 144   if( mLoadFileResult.loadResult )
 145   {
 146     buffer = mLoadFileResult.buffer;
 147   }
 148
 149   return mLoadFileResult.loadResult;
 150 }
 151
 152 bool TestPlatformAbstraction::LoadShaderBinaryFile( const std::string& filename, Dali::Vector< unsigned char >& buffer ) const
 153 {
 154   mTrace.PushCall("LoadShaderBinaryFile", "");
 155   if( mLoadFileResult.loadResult )
 156   {
 157     buffer = mLoadFileResult.buffer;
 158   }
 159
 160   return mLoadFileResult.loadResult;
 161 }
 162
 163 bool TestPlatformAbstraction::SaveFile(const std::string& filename, const unsigned char * buffer, unsigned int numBytes ) const
 164 {
 165   mTrace.PushCall("SaveFile", "");
 166   return false;
 167 }
 168
 169 void TestPlatformAbstraction::JoinLoaderThreads()
 170 {
 171   mTrace.PushCall("JoinLoaderThreads", "");
 172 }
 173
 174 /** Call this every test */
 175 void TestPlatformAbstraction::Initialize()
 176 {
 177   mTrace.Reset();
 178   mTrace.Enable(true);
 179   mLoadedResourcesQueue.clear();
 180   mFailedLoadQueue.clear();
 181   mResourceRequests.Clear();
 182   mIsLoadingResult=false;
 183   mSynchronouslyLoadedResource.Reset();
 184   mDecodedBitmap.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   mDecodedBitmap.Reset();
 219 }
 220
 221 void TestPlatformAbstraction::SetResourceLoaded(Integration::ResourceId  loadedId,
 222                                                 Integration::ResourceTypeId  loadedType,
 223                                                 Integration::ResourcePointer loadedResource)
 224 {
 225   LoadedResource loadedInfo;
 226   loadedInfo.id = loadedId;
 227   loadedInfo.type = loadedType;
 228   loadedInfo.resource = loadedResource;
 229   mLoadedResourcesQueue.push_back( loadedInfo );
 230 }
 231
 232 void TestPlatformAbstraction::SetResourceLoadFailed(Integration::ResourceId  id,
 233                                                     Integration::ResourceFailure failure)
 234 {
 235   FailedLoad failedInfo;
 236   failedInfo.id = id;
 237   failedInfo.failure = failure;
 238   mFailedLoadQueue.push_back( failedInfo );
 239 }
 240
 241 Integration::ResourceRequest* TestPlatformAbstraction::GetRequest()
 242 {
 243   Integration::ResourceRequest* request = NULL;
 244
 245   // Return last request
 246   if( ! mResourceRequests.Empty() )
 247   {
 248     request = *( mResourceRequests.End() - 1 );
 249   }
 250
 251   return request;
 252 }
 253
 254 const TestPlatformAbstraction::ResourceRequestContainer& TestPlatformAbstraction::GetAllRequests() const
 255 {
 256   return mResourceRequests;
 257 }
 258
 259 void TestPlatformAbstraction::SetAllResourceRequestsAsLoaded()
 260 {
 261   for( ResourceRequestContainer::Iterator iter = mResourceRequests.Begin(), endIter = mResourceRequests.End();
 262        iter != endIter; ++iter )
 263   {
 264     Integration::ResourceRequest* request = *iter;
 265     Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD );
 266     Integration::ResourcePointer resource(bitmap);
 267     bitmap->GetPackedPixelsProfile()->ReserveBuffer(Pixel::RGBA8888, 80, 80, 80, 80);
 268     SetResourceLoaded( request->GetId(), request->GetType()->id, resource );
 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     SetResourceLoadFailed( (*iter)->GetId(), failure);
 279   }
 280   mResourceRequests.Clear();
 281 }
 282
 283 void TestPlatformAbstraction::DiscardRequest()
 284 {
 285   mResourceRequests.Clear();
 286 }
 287
 288 void TestPlatformAbstraction::SetClosestImageSize(const Vector2& size)
 289 {
 290   mClosestSize = size;
 291 }
 292
 293 void TestPlatformAbstraction::SetLoadFileResult( bool result, Dali::Vector< unsigned char >& buffer )
 294 {
 295   mLoadFileResult.loadResult = result;
 296   if( result )
 297   {
 298     mLoadFileResult.buffer = buffer;
 299   }
 300 }
 301
 302 void TestPlatformAbstraction::SetSaveFileResult( bool result )
 303 {
 304   mSaveFileResult = result;
 305 }
 306
 307 void TestPlatformAbstraction::SetSynchronouslyLoadedResource( Integration::ResourcePointer resource )
 308 {
 309   mSynchronouslyLoadedResource = resource;
 310 }
 311
 312 void TestPlatformAbstraction::SetDecodedBitmap( Integration::BitmapPtr bitmap )
 313 {
 314   mDecodedBitmap = bitmap;
 315 }
 316
 317 } // namespace Dali