X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=automated-tests%2Fsrc%2Fdali-toolkit%2Fdali-toolkit-test-utils%2Ftest-platform-abstraction.cpp;h=190aa63c1fb645c981a61288e2885af17184d741;hp=1e56f8d3f7921bfaebea3933606d049145db84d1;hb=46378e74ac2f46a4ca7c6a038de9c42639d60faa;hpb=7723d36f437a6aaa6867938a01ca961305fae454

diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-platform-abstraction.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-platform-abstraction.cpp
index 1e56f8d..190aa63 100644
--- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-platform-abstraction.cpp
+++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-platform-abstraction.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,13 +25,10 @@ namespace Dali
 TestPlatformAbstraction::TestPlatformAbstraction()
 : mTrace(),
   mIsLoadingResult( false ),
-  mGetDefaultFontSizeResult( 0 ),
-  mResources(),
-  mRequest( NULL ),
-  mSize(),
   mClosestSize(),
   mLoadFileResult(),
-  mSaveFileResult( false )
+  mSaveFileResult( false ),
+  mSynchronouslyLoadedResource()
 {
   Initialize();
 }
@@ -40,23 +37,13 @@ TestPlatformAbstraction::~TestPlatformAbstraction()
 {
 }
 
-void TestPlatformAbstraction::Suspend()
-{
-  mTrace.PushCall("Suspend", "");
-}
-
-void TestPlatformAbstraction::Resume()
-{
-  mTrace.PushCall("Resume", "");
-}
-
 ImageDimensions TestPlatformAbstraction::GetClosestImageSize( const std::string& filename,
                                                               ImageDimensions size,
                                                               FittingMode::Type fittingMode,
                                                               SamplingMode::Type samplingMode,
                                                               bool orientationCorrection )
 {
-  ImageDimensions closestSize = ImageDimensions( mClosestSize.x, mClosestSize.y );
+  ImageDimensions closestSize = ImageDimensions( mClosestSize );
   mTrace.PushCall("GetClosestImageSize", "");
   return closestSize;
 }
@@ -67,82 +54,21 @@ ImageDimensions TestPlatformAbstraction::GetClosestImageSize( Integration::Resou
                                                    SamplingMode::Type samplingMode,
                                                    bool orientationCorrection )
 {
-  ImageDimensions closestSize = ImageDimensions( mClosestSize.x, mClosestSize.y );
+  ImageDimensions closestSize = ImageDimensions( mClosestSize );
   mTrace.PushCall("GetClosestImageSize", "");
   return closestSize;
 }
 
-void TestPlatformAbstraction::LoadResource(const Integration::ResourceRequest& request)
-{
-  std::ostringstream out;
-  out << "Type:" << request.GetType()->id << ", Path: " << request.GetPath() << std::endl ;
-
-  mTrace.PushCall("LoadResource", out.str());
-  if(mRequest != NULL)
-  {
-    delete mRequest;
-    tet_infoline ("Warning: multiple resource requests not handled by Test Suite. You may see unexpected errors");
-  }
-  mRequest = new Integration::ResourceRequest(request);
-}
-
-Integration::ResourcePointer TestPlatformAbstraction::LoadResourceSynchronously( const Integration::ResourceType& resourceType, const std::string& resourcePath )
+Integration::ResourcePointer TestPlatformAbstraction::LoadImageSynchronously( const Integration::BitmapResourceType& resourceType, const std::string& resourcePath )
 {
   mTrace.PushCall("LoadResourceSynchronously", "");
-  return mResources.loadedResource;
+  return mSynchronouslyLoadedResource;
 }
 
-Integration::BitmapPtr TestPlatformAbstraction::DecodeBuffer( const Integration::ResourceType& resourceType, uint8_t * buffer, size_t size )
+Integration::BitmapPtr TestPlatformAbstraction::DecodeBuffer( const Integration::BitmapResourceType& resourceType, uint8_t * buffer, size_t size )
 {
   mTrace.PushCall("DecodeBuffer", "");
-  return Integration::BitmapPtr();
-}
-
-void TestPlatformAbstraction::CancelLoad(Integration::ResourceId id, Integration::ResourceTypeId typeId)
-{
-  mTrace.PushCall("CancelLoad", "");
-}
-
-void TestPlatformAbstraction::GetResources(Integration::ResourceCache& cache)
-{
-  mTrace.PushCall("GetResources", "");
-
-  if(mResources.loaded)
-  {
-    cache.LoadResponse( mResources.loadedId, mResources.loadedType, mResources.loadedResource, Integration::RESOURCE_COMPLETELY_LOADED );
-  }
-  if(mResources.loadFailed)
-  {
-    cache.LoadFailed( mResources.loadFailedId, mResources.loadFailure );
-  }
-}
-
-bool TestPlatformAbstraction::IsLoading()
-{
-  mTrace.PushCall("IsLoading", "");
-  return mIsLoadingResult;
-}
-
-int TestPlatformAbstraction::GetDefaultFontSize() const
-{
-  mTrace.PushCall("GetDefaultFontSize", "");
-  return mGetDefaultFontSizeResult;
-}
-
-void TestPlatformAbstraction::SetDpi (unsigned int dpiHorizontal, unsigned int dpiVertical)
-{
-  mTrace.PushCall("SetDpi", "");
-}
-
-bool TestPlatformAbstraction::LoadFile( const std::string& filename, Dali::Vector< unsigned char >& buffer ) const
-{
-  mTrace.PushCall("LoadFile", "");
-  if( mLoadFileResult.loadResult )
-  {
-    buffer = mLoadFileResult.buffer;
-  }
-
-  return mLoadFileResult.loadResult;
+  return mDecodedBitmap;
 }
 
 bool TestPlatformAbstraction::LoadShaderBinaryFile( const std::string& filename, Dali::Vector< unsigned char >& buffer ) const
@@ -156,48 +82,24 @@ bool TestPlatformAbstraction::LoadShaderBinaryFile( const std::string& filename,
   return mLoadFileResult.loadResult;
 }
 
-bool TestPlatformAbstraction::SaveFile(const std::string& filename, const unsigned char * buffer, unsigned int numBytes ) const
-{
-  mTrace.PushCall("SaveFile", "");
-  return false;
-}
-
-void TestPlatformAbstraction::JoinLoaderThreads()
-{
-  mTrace.PushCall("JoinLoaderThreads", "");
-}
 
 /** Call this every test */
 void TestPlatformAbstraction::Initialize()
 {
   mTrace.Reset();
   mTrace.Enable(true);
-  memset(&mResources, 0, sizeof(Resources));
   mIsLoadingResult=false;
-
-  if(mRequest)
-  {
-    delete mRequest;
-    mRequest = 0;
-  }
+  mSynchronouslyLoadedResource.Reset();
+  mDecodedBitmap.Reset();
 }
 
 bool TestPlatformAbstraction::WasCalled(TestFuncEnum func)
 {
   switch(func)
   {
-    case SuspendFunc:                         return mTrace.FindMethod("Suspend");
-    case ResumeFunc:                          return mTrace.FindMethod("Resume");
-    case LoadResourceFunc:                    return mTrace.FindMethod("LoadResource");
-    case LoadFileFunc:                        return mTrace.FindMethod("LoadFile");
+    case LoadResourceSynchronouslyFunc:       return mTrace.FindMethod("LoadResourceSynchronously");
     case LoadShaderBinaryFileFunc:            return mTrace.FindMethod("LoadShaderBinaryFile");
     case SaveShaderBinaryFileFunc:            return mTrace.FindMethod("SaveShaderBinaryFile");
-    case SaveFileFunc:                        return mTrace.FindMethod("SaveFile");
-    case CancelLoadFunc:                      return mTrace.FindMethod("CancelLoad");
-    case GetResourcesFunc:                    return mTrace.FindMethod("GetResources");
-    case IsLoadingFunc:                       return mTrace.FindMethod("IsLoading");
-    case SetDpiFunc:                          return mTrace.FindMethod("SetDpi");
-    case JoinLoaderThreadsFunc:               return mTrace.FindMethod("JoinLoaderThreads");
   }
   return false;
 }
@@ -209,41 +111,13 @@ void TestPlatformAbstraction::SetIsLoadingResult(bool result)
 
 void TestPlatformAbstraction::ClearReadyResources()
 {
-  memset(&mResources, 0, sizeof(Resources));
-}
-
-void TestPlatformAbstraction::SetResourceLoaded(Integration::ResourceId  loadedId,
-                                                Integration::ResourceTypeId  loadedType,
-                                                Integration::ResourcePointer loadedResource)
-{
-  mResources.loaded = true;
-  mResources.loadedId = loadedId;
-  mResources.loadedType = loadedType;
-  mResources.loadedResource = loadedResource;
-}
-
-void TestPlatformAbstraction::SetResourceLoadFailed(Integration::ResourceId  id,
-                                                    Integration::ResourceFailure failure)
-{
-  mResources.loadFailed = true;
-  mResources.loadFailedId = id;
-  mResources.loadFailure = failure;
+  mSynchronouslyLoadedResource.Reset();
+  mDecodedBitmap.Reset();
 }
 
-Integration::ResourceRequest* TestPlatformAbstraction::GetRequest()
+void TestPlatformAbstraction::SetClosestImageSize( const Vector2& size )
 {
-  return mRequest;
-}
-
-void TestPlatformAbstraction::DiscardRequest()
-{
-  delete mRequest;
-  mRequest = NULL;
-}
-
-void TestPlatformAbstraction::SetClosestImageSize(const Vector2& size)
-{
-  mClosestSize = size;
+  mClosestSize = ImageDimensions( static_cast<uint32_t>( size.x ), static_cast<uint32_t>( size.y ) );
 }
 
 void TestPlatformAbstraction::SetLoadFileResult( bool result, Dali::Vector< unsigned char >& buffer )
@@ -260,4 +134,14 @@ void TestPlatformAbstraction::SetSaveFileResult( bool result )
   mSaveFileResult = result;
 }
 
+void TestPlatformAbstraction::SetSynchronouslyLoadedResource( Integration::ResourcePointer resource )
+{
+  mSynchronouslyLoadedResource = resource;
+}
+
+void TestPlatformAbstraction::SetDecodedBitmap( Integration::BitmapPtr bitmap )
+{
+  mDecodedBitmap = bitmap;
+}
+
 } // namespace Dali