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