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 /**
  26  * Constructor
  27  */
  28 TestPlatformAbstraction::TestPlatformAbstraction()
  29 : mTrace(),
  30   mSeconds( 0u ),
  31   mMicroSeconds( 0u ),
  32   mIsLoadingResult( false ),
  33   mGetDefaultFontFamilyResult(),
  34   mGetDefaultFontStyleResult(),
  35   mGetDefaultFontSizeResult( 0 ),
  36   mResources(),
  37   mRequest( NULL ),
  38   mSize(),
  39   mClosestSize(),
  40   mLoadFileResult(),
  41   mSaveFileResult( false ),
  42   mDynamicsFactory( NULL )
  43 {
  44   Initialize();
  45 }
  46
  47 /**
  48  * Destructor
  49  */
  50 TestPlatformAbstraction::~TestPlatformAbstraction()
  51 {
  52   delete mDynamicsFactory;
  53 }
  54
  55 /**
  56  * @copydoc PlatformAbstraction::GetTimeMicroseconds()
  57  */
  58 void TestPlatformAbstraction::GetTimeMicroseconds(unsigned int &seconds, unsigned int &microSeconds)
  59 {
  60   seconds = mSeconds;
  61   microSeconds = mMicroSeconds;
  62   mTrace.PushCall("GetTimeMicroseconds", "");
  63 }
  64
  65 /**
  66  * @copydoc PlatformAbstraction::Suspend()
  67  */
  68 void TestPlatformAbstraction::Suspend()
  69 {
  70   mTrace.PushCall("Suspend", "");
  71 }
  72
  73 /**
  74  * @copydoc PlatformAbstraction::Resume()
  75  */
  76 void TestPlatformAbstraction::Resume()
  77 {
  78   mTrace.PushCall("Resume", "");
  79 }
  80
  81 ImageDimensions TestPlatformAbstraction::GetClosestImageSize( const std::string& filename,
  82                                                               ImageDimensions size,
  83                                                               FittingMode::Type fittingMode,
  84                                                               SamplingMode::Type samplingMode,
  85                                                               bool orientationCorrection )
  86 {
  87   ImageDimensions closestSize = ImageDimensions( mClosestSize.x, mClosestSize.y );
  88   mTrace.PushCall("GetClosestImageSize", "");
  89   return closestSize;
  90 }
  91
  92 ImageDimensions TestPlatformAbstraction::GetClosestImageSize( Integration::ResourcePointer resourceBuffer,
  93                                                    ImageDimensions size,
  94                                                    FittingMode::Type fittingMode,
  95                                                    SamplingMode::Type samplingMode,
  96                                                    bool orientationCorrection )
  97 {
  98   ImageDimensions closestSize = ImageDimensions( mClosestSize.x, mClosestSize.y );
  99   mTrace.PushCall("GetClosestImageSize", "");
 100   return closestSize;
 101 }
 102
 103
 104 /**
 105  * @copydoc PlatformAbstraction::LoadResource()
 106  */
 107 void TestPlatformAbstraction::LoadResource(const Integration::ResourceRequest& request)
 108 {
 109   std::ostringstream out;
 110   out << "Type:" << request.GetType()->id << ", Path: " << request.GetPath() << std::endl ;
 111
 112   mTrace.PushCall("LoadResource", out.str());
 113   if(mRequest != NULL)
 114   {
 115     delete mRequest;
 116     tet_infoline ("Warning: multiple resource requests not handled by Test Suite. You may see unexpected errors");
 117   }
 118   mRequest = new Integration::ResourceRequest(request);
 119 }
 120
 121 Integration::ResourcePointer TestPlatformAbstraction::LoadResourceSynchronously( const Integration::ResourceType& resourceType, const std::string& resourcePath )
 122 {
 123   mTrace.PushCall("LoadResourceSynchronously", "");
 124   return mResources.loadedResource;
 125 }
 126
 127 /**
 128  * @copydoc PlatformAbstraction::SaveResource()
 129  */
 130 void TestPlatformAbstraction::SaveResource(const Integration::ResourceRequest& request)
 131 {
 132   mTrace.PushCall("SaveResource", "");
 133   if(mRequest != NULL)
 134   {
 135     delete mRequest;
 136     tet_infoline ("Warning: multiple resource requests not handled by Test Suite. You may see unexpected errors");
 137   }
 138   mRequest = new Integration::ResourceRequest(request);
 139 }
 140
 141 /**
 142  * @copydoc PlatformAbstraction::CancelLoad()
 143  */
 144 void TestPlatformAbstraction::CancelLoad(Integration::ResourceId id, Integration::ResourceTypeId typeId)
 145 {
 146   mTrace.PushCall("CancelLoad", "");
 147 }
 148
 149 /**
 150  * @copydoc PlatformAbstraction::GetResources()
 151  */
 152 void TestPlatformAbstraction::GetResources(Integration::ResourceCache& cache)
 153 {
 154   mTrace.PushCall("GetResources", "");
 155
 156   if(mResources.loaded)
 157   {
 158     cache.LoadResponse( mResources.loadedId, mResources.loadedType, mResources.loadedResource, Integration::RESOURCE_COMPLETELY_LOADED );
 159   }
 160   if(mResources.loadFailed)
 161   {
 162     cache.LoadFailed( mResources.loadFailedId, mResources.loadFailure );
 163   }
 164   if(mResources.saved)
 165   {
 166     cache.SaveComplete( mResources.savedId, mResources.savedType );
 167   }
 168   if(mResources.saveFailed)
 169   {
 170     cache.SaveFailed( mResources.saveFailedId, mResources.saveFailure );
 171   }
 172 }
 173
 174 /**
 175  * @copydoc PlatformAbstraction::IsLoading()
 176  */
 177 bool TestPlatformAbstraction::IsLoading()
 178 {
 179   mTrace.PushCall("IsLoading", "");
 180   return mIsLoadingResult;
 181 }
 182
 183 /**
 184  * @copydoc PlatformAbstraction::GetDefaultFontDescription()
 185  */
 186 void TestPlatformAbstraction::GetDefaultFontDescription( std::string& family, std::string& style ) const
 187 {
 188   mTrace.PushCall("GetDefaultFontFamily", "");
 189   family = mGetDefaultFontFamilyResult;
 190   style = mGetDefaultFontStyleResult;
 191 }
 192
 193 /**
 194  * @copydoc PlatformAbstraction::GetDefaultFontSize()
 195  */
 196 int TestPlatformAbstraction::GetDefaultFontSize() const
 197 {
 198   mTrace.PushCall("GetDefaultFontSize", "");
 199   return mGetDefaultFontSizeResult;
 200 }
 201
 202 /**
 203  * @copydoc PlatformAbstraction::SetDpi()
 204  */
 205 void TestPlatformAbstraction::SetDpi (unsigned int dpiHorizontal, unsigned int dpiVertical)
 206 {
 207   mTrace.PushCall("SetDpi", "");
 208 }
 209
 210 /**
 211  * @copydoc PlatformAbstraction::LoadFile()
 212  */
 213 bool TestPlatformAbstraction::LoadFile( const std::string& filename, std::vector< unsigned char >& buffer ) const
 214 {
 215   mTrace.PushCall("LoadFile", "");
 216   if( mLoadFileResult.loadResult )
 217   {
 218     buffer = mLoadFileResult.buffer;
 219   }
 220
 221   return mLoadFileResult.loadResult;
 222 }
 223
 224 /**
 225  * @copydoc PlatformAbstraction::LoadShaderBinFile()
 226  */
 227 bool TestPlatformAbstraction::LoadShaderBinFile( const std::string& filename, std::vector< unsigned char >& buffer ) const
 228 {
 229   mTrace.PushCall("LoadShaderBinFile", "");
 230   if( mLoadFileResult.loadResult )
 231   {
 232     buffer = mLoadFileResult.buffer;
 233   }
 234
 235   return mLoadFileResult.loadResult;
 236 }
 237
 238 /**
 239  * @copydoc PlatformAbstraction::SaveFile()
 240  */
 241 bool TestPlatformAbstraction::SaveFile(const std::string& filename, std::vector< unsigned char >& buffer) const
 242 {
 243   mTrace.PushCall("SaveFile", "");
 244   return false;
 245 }
 246
 247 void TestPlatformAbstraction::JoinLoaderThreads()
 248 {
 249   mTrace.PushCall("JoinLoaderThreads", "");
 250 }
 251
 252 Integration::DynamicsFactory* TestPlatformAbstraction::GetDynamicsFactory()
 253 {
 254   mTrace.PushCall("GetDynamicsFactory", "");
 255   if( mDynamicsFactory == NULL )
 256   {
 257     mDynamicsFactory = new TestDynamicsFactory( mTrace );
 258   }
 259   return mDynamicsFactory;
 260 }
 261
 262 /** Call this every test */
 263 void TestPlatformAbstraction::Initialize()
 264 {
 265   mTrace.Reset();
 266   mTrace.Enable(true);
 267   memset(&mResources, 0, sizeof(Resources));
 268   mSeconds=0;
 269   mMicroSeconds=0;
 270   mIsLoadingResult=false;
 271
 272   if(mRequest)
 273   {
 274     delete mRequest;
 275     mRequest = 0;
 276   }
 277 }
 278
 279 bool TestPlatformAbstraction::WasCalled(TestFuncEnum func)
 280 {
 281   switch(func)
 282   {
 283     case GetTimeMicrosecondsFunc:             return mTrace.FindMethod("GetTimeMicroseconds");
 284     case SuspendFunc:                         return mTrace.FindMethod("Suspend");
 285     case ResumeFunc:                          return mTrace.FindMethod("Resume");
 286     case LoadResourceFunc:                    return mTrace.FindMethod("LoadResource");
 287     case SaveResourceFunc:                    return mTrace.FindMethod("SaveResource");
 288     case LoadFileFunc:                        return mTrace.FindMethod("LoadFile");
 289     case SaveFileFunc:                        return mTrace.FindMethod("SaveFile");
 290     case CancelLoadFunc:                      return mTrace.FindMethod("CancelLoad");
 291     case GetResourcesFunc:                    return mTrace.FindMethod("GetResources");
 292     case IsLoadingFunc:                       return mTrace.FindMethod("IsLoading");
 293     case SetDpiFunc:                          return mTrace.FindMethod("SetDpi");
 294     case JoinLoaderThreadsFunc:               return mTrace.FindMethod("JoinLoaderThreads");
 295     case GetDynamicsFactoryFunc:              return mTrace.FindMethod("GetDynamicsFactory");
 296   }
 297   return false;
 298 }
 299
 300 void TestPlatformAbstraction::SetGetTimeMicrosecondsResult(size_t sec, size_t usec)
 301 {
 302   mSeconds = sec;
 303   mMicroSeconds = usec;
 304 }
 305
 306 void TestPlatformAbstraction::IncrementGetTimeResult(size_t milliseconds)
 307 {
 308   mMicroSeconds += milliseconds * 1000u;
 309   unsigned int additionalSeconds = mMicroSeconds / 1000000u;
 310
 311   mSeconds += additionalSeconds;
 312   mMicroSeconds -= additionalSeconds * 1000000u;
 313 }
 314
 315 void TestPlatformAbstraction::SetIsLoadingResult(bool result)
 316 {
 317   mIsLoadingResult = result;
 318 }
 319
 320 void TestPlatformAbstraction::ClearReadyResources()
 321 {
 322   memset(&mResources, 0, sizeof(Resources));
 323 }
 324
 325 void TestPlatformAbstraction::SetResourceLoaded(Integration::ResourceId  loadedId,
 326                                                 Integration::ResourceTypeId  loadedType,
 327                                                 Integration::ResourcePointer loadedResource)
 328 {
 329   mResources.loaded = true;
 330   mResources.loadedId = loadedId;
 331   mResources.loadedType = loadedType;
 332   mResources.loadedResource = loadedResource;
 333 }
 334
 335 void TestPlatformAbstraction::SetResourceLoadFailed(Integration::ResourceId  id,
 336                                                     Integration::ResourceFailure failure)
 337 {
 338   mResources.loadFailed = true;
 339   mResources.loadFailedId = id;
 340   mResources.loadFailure = failure;
 341 }
 342
 343 void TestPlatformAbstraction::SetResourceSaved(Integration::ResourceId      savedId,
 344                                                Integration::ResourceTypeId  savedType)
 345 {
 346   mResources.saved = true;
 347   mResources.savedId = savedId;
 348   mResources.savedType = savedType;
 349 }
 350
 351 void TestPlatformAbstraction::SetResourceSaveFailed(Integration::ResourceId  id,
 352                                                     Integration::ResourceFailure failure)
 353 {
 354   mResources.saveFailed = true;
 355   mResources.saveFailedId = id;
 356   mResources.saveFailure = failure;
 357 }
 358
 359 Integration::ResourceRequest* TestPlatformAbstraction::GetRequest()
 360 {
 361   return mRequest;
 362 }
 363
 364 void TestPlatformAbstraction::DiscardRequest()
 365 {
 366   delete mRequest;
 367   mRequest = NULL;
 368 }
 369
 370 void TestPlatformAbstraction::SetClosestImageSize(const Vector2& size)
 371 {
 372   mClosestSize = size;
 373 }
 374
 375 void TestPlatformAbstraction::SetLoadFileResult( bool result, std::vector< unsigned char >& buffer )
 376 {
 377   mLoadFileResult.loadResult = result;
 378   if( result )
 379   {
 380     mLoadFileResult.buffer = buffer;
 381   }
 382 }
 383
 384 void TestPlatformAbstraction::SetSaveFileResult( bool result )
 385 {
 386   mSaveFileResult = result;
 387 }
 388
 389 } // namespace Dali