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=db22b8638bbaa96b72bf8c8ba808e12914affc51;hp=5ece3f1966eab664df4695de9f622448dd96cc95;hb=a0034fa37cd0c88ec14b8f0e49bbcf158deeb1bc;hpb=4bf366c7c657eacb5cf150fa52e34263ca16218f

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 5ece3f1..db22b86 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
@@ -22,24 +22,18 @@
 namespace Dali
 {
 
-namespace
-{
-const unsigned int NANOSECONDS_PER_MILLISECOND = 1000000u;
-const unsigned int NANOSECONDS_PER_SECOND = 1000000000u;
-}
-
 TestPlatformAbstraction::TestPlatformAbstraction()
 : mTrace(),
-  mSeconds( 0u ),
-  mNanoSeconds( 0u ),
   mIsLoadingResult( false ),
   mGetDefaultFontSizeResult( 0 ),
-  mResources(),
-  mRequest( NULL ),
+  mLoadedResourcesQueue(),
+  mFailedLoadQueue(),
+  mResourceRequests(),
   mSize(),
   mClosestSize(),
   mLoadFileResult(),
-  mSaveFileResult( false )
+  mSaveFileResult( false ),
+  mSynchronouslyLoadedResource()
 {
   Initialize();
 }
@@ -48,13 +42,6 @@ TestPlatformAbstraction::~TestPlatformAbstraction()
 {
 }
 
-void TestPlatformAbstraction::GetTimeNanoseconds( uint64_t& seconds, uint64_t& nanoseconds )
-{
-  seconds = mSeconds;
-  nanoseconds = mNanoSeconds;
-  mTrace.PushCall("GetTimeNanoseconds", "");
-}
-
 void TestPlatformAbstraction::Suspend()
 {
   mTrace.PushCall("Suspend", "");
@@ -93,18 +80,14 @@ void TestPlatformAbstraction::LoadResource(const Integration::ResourceRequest& r
   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);
+
+  mResourceRequests.PushBack( new Integration::ResourceRequest(request) );
 }
 
 Integration::ResourcePointer TestPlatformAbstraction::LoadResourceSynchronously( const Integration::ResourceType& 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 )
@@ -122,13 +105,19 @@ void TestPlatformAbstraction::GetResources(Integration::ResourceCache& cache)
 {
   mTrace.PushCall("GetResources", "");
 
-  if(mResources.loaded)
+  while( !mLoadedResourcesQueue.empty() )
   {
-    cache.LoadResponse( mResources.loadedId, mResources.loadedType, mResources.loadedResource, Integration::RESOURCE_COMPLETELY_LOADED );
+    LoadedResource loaded( *mLoadedResourcesQueue.begin() );
+    mLoadedResourcesQueue.erase( mLoadedResourcesQueue.begin() );
+    cache.LoadResponse( loaded.id, loaded.type, loaded.resource, Integration::RESOURCE_COMPLETELY_LOADED );
   }
-  if(mResources.loadFailed)
+
+  // iterate through the resources which failed to load
+  while( !mFailedLoadQueue.empty() )
   {
-    cache.LoadFailed( mResources.loadFailedId, mResources.loadFailure );
+    FailedLoad failed( *mFailedLoadQueue.begin() );
+    mFailedLoadQueue.erase( mFailedLoadQueue.begin() );
+    cache.LoadFailed( failed.id, failed.failure );
   }
 }
 
@@ -187,26 +176,21 @@ void TestPlatformAbstraction::Initialize()
 {
   mTrace.Reset();
   mTrace.Enable(true);
-  memset(&mResources, 0, sizeof(Resources));
-  mSeconds=0;
-  mNanoSeconds=0;
+  mLoadedResourcesQueue.clear();
+  mFailedLoadQueue.clear();
+  mResourceRequests.Clear();
   mIsLoadingResult=false;
-
-  if(mRequest)
-  {
-    delete mRequest;
-    mRequest = 0;
-  }
+  mSynchronouslyLoadedResource.Reset();
 }
 
 bool TestPlatformAbstraction::WasCalled(TestFuncEnum func)
 {
   switch(func)
   {
-    case GetTimeNanosecondsFunc:              return mTrace.FindMethod("GetTimeNanoseconds");
     case SuspendFunc:                         return mTrace.FindMethod("Suspend");
     case ResumeFunc:                          return mTrace.FindMethod("Resume");
     case LoadResourceFunc:                    return mTrace.FindMethod("LoadResource");
+    case LoadResourceSynchronouslyFunc:       return mTrace.FindMethod("LoadResourceSynchronously");
     case LoadFileFunc:                        return mTrace.FindMethod("LoadFile");
     case LoadShaderBinaryFileFunc:            return mTrace.FindMethod("LoadShaderBinaryFile");
     case SaveShaderBinaryFileFunc:            return mTrace.FindMethod("SaveShaderBinaryFile");
@@ -220,21 +204,6 @@ bool TestPlatformAbstraction::WasCalled(TestFuncEnum func)
   return false;
 }
 
-void TestPlatformAbstraction::SetGetTimeNanosecondsResult(size_t sec, size_t nsec)
-{
-  mSeconds = sec;
-  mNanoSeconds = nsec;
-}
-
-void TestPlatformAbstraction::IncrementGetTimeResult(size_t milliseconds)
-{
-  mNanoSeconds += milliseconds * NANOSECONDS_PER_MILLISECOND;
-  unsigned int additionalSeconds = mNanoSeconds / NANOSECONDS_PER_SECOND;
-
-  mSeconds += additionalSeconds;
-  mNanoSeconds -= additionalSeconds * NANOSECONDS_PER_SECOND;
-}
-
 void TestPlatformAbstraction::SetIsLoadingResult(bool result)
 {
   mIsLoadingResult = result;
@@ -242,36 +211,76 @@ void TestPlatformAbstraction::SetIsLoadingResult(bool result)
 
 void TestPlatformAbstraction::ClearReadyResources()
 {
-  memset(&mResources, 0, sizeof(Resources));
+  mLoadedResourcesQueue.clear();
+  mFailedLoadQueue.clear();
+  mSynchronouslyLoadedResource.Reset();
 }
 
 void TestPlatformAbstraction::SetResourceLoaded(Integration::ResourceId  loadedId,
                                                 Integration::ResourceTypeId  loadedType,
                                                 Integration::ResourcePointer loadedResource)
 {
-  mResources.loaded = true;
-  mResources.loadedId = loadedId;
-  mResources.loadedType = loadedType;
-  mResources.loadedResource = loadedResource;
+  LoadedResource loadedInfo;
+  loadedInfo.id = loadedId;
+  loadedInfo.type = loadedType;
+  loadedInfo.resource = loadedResource;
+  mLoadedResourcesQueue.push_back( loadedInfo );
 }
 
 void TestPlatformAbstraction::SetResourceLoadFailed(Integration::ResourceId  id,
                                                     Integration::ResourceFailure failure)
 {
-  mResources.loadFailed = true;
-  mResources.loadFailedId = id;
-  mResources.loadFailure = failure;
+  FailedLoad failedInfo;
+  failedInfo.id = id;
+  failedInfo.failure = failure;
+  mFailedLoadQueue.push_back( failedInfo );
 }
 
 Integration::ResourceRequest* TestPlatformAbstraction::GetRequest()
 {
-  return mRequest;
+  Integration::ResourceRequest* request = NULL;
+
+  // Return last request
+  if( ! mResourceRequests.Empty() )
+  {
+    request = *( mResourceRequests.End() - 1 );
+  }
+
+  return request;
+}
+
+const TestPlatformAbstraction::ResourceRequestContainer& TestPlatformAbstraction::GetAllRequests() const
+{
+  return mResourceRequests;
+}
+
+void TestPlatformAbstraction::SetAllResourceRequestsAsLoaded()
+{
+  for( ResourceRequestContainer::Iterator iter = mResourceRequests.Begin(), endIter = mResourceRequests.End();
+       iter != endIter; ++iter )
+  {
+    Integration::ResourceRequest* request = *iter;
+    Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD );
+    Integration::ResourcePointer resource(bitmap);
+    bitmap->GetPackedPixelsProfile()->ReserveBuffer(Pixel::RGBA8888, 80, 80, 80, 80);
+    SetResourceLoaded( request->GetId(), request->GetType()->id, resource );
+  }
+  mResourceRequests.Clear();
+}
+
+void TestPlatformAbstraction::SetAllResourceRequestsAsFailed( Integration::ResourceFailure failure )
+{
+  for( ResourceRequestContainer::Iterator iter = mResourceRequests.Begin(), endIter = mResourceRequests.End();
+       iter != endIter; ++iter )
+  {
+    SetResourceLoadFailed( (*iter)->GetId(), failure);
+  }
+  mResourceRequests.Clear();
 }
 
 void TestPlatformAbstraction::DiscardRequest()
 {
-  delete mRequest;
-  mRequest = NULL;
+  mResourceRequests.Clear();
 }
 
 void TestPlatformAbstraction::SetClosestImageSize(const Vector2& size)
@@ -293,4 +302,9 @@ void TestPlatformAbstraction::SetSaveFileResult( bool result )
   mSaveFileResult = result;
 }
 
+void TestPlatformAbstraction::SetSynchronouslyLoadedResource( Integration::ResourcePointer resource )
+{
+  mSynchronouslyLoadedResource = resource;
+}
+
 } // namespace Dali