X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=automated-tests%2Fsrc%2Fdali-toolkit-internal%2Futc-Dali-TextureManager.cpp;h=d27948240e368a06924b50cf5ab8c8f42b3caf92;hb=fdd98f05f6ca6fbb01b5f3b6cddbb09e121abf78;hp=04c51af30c76a3158412d6f14ed6de441a956d8a;hpb=a4b26c19783f73d4e0f3a9fdd23f5a1810406734;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git

diff --git a/automated-tests/src/dali-toolkit-internal/utc-Dali-TextureManager.cpp b/automated-tests/src/dali-toolkit-internal/utc-Dali-TextureManager.cpp
index 04c51af..d279482 100644
--- a/automated-tests/src/dali-toolkit-internal/utc-Dali-TextureManager.cpp
+++ b/automated-tests/src/dali-toolkit-internal/utc-Dali-TextureManager.cpp
@@ -71,28 +71,30 @@ public:
   TestObserver()
   : mCompleteType( CompleteType::NOT_COMPLETED ),
     mLoaded(false),
-    mObserverCalled(false)
+    mObserverCalled(false),
+    mTextureSet()
   {
   }
 
-  virtual void UploadComplete( bool loadSuccess, int32_t textureId, TextureSet textureSet,
-                               bool useAtlasing, const Vector4& atlasRect, bool preMultiplied ) override
+  virtual void LoadComplete( bool loadSuccess, TextureInformation textureInformation ) override
   {
-    mCompleteType = CompleteType::UPLOAD_COMPLETE;
-    mLoaded = loadSuccess;
-    mObserverCalled = true;
-  }
-
-  virtual void LoadComplete( bool loadSuccess, Devel::PixelBuffer pixelBuffer, const VisualUrl& url, bool preMultiplied ) override
-  {
-    mCompleteType = CompleteType::LOAD_COMPLETE;
+    if(textureInformation.returnType == TextureUploadObserver::ReturnType::TEXTURE)
+    {
+      mCompleteType = CompleteType::UPLOAD_COMPLETE;
+    }
+    else
+    {
+      mCompleteType = CompleteType::LOAD_COMPLETE;
+    }
     mLoaded = loadSuccess;
     mObserverCalled = true;
+    mTextureSet = textureInformation.textureSet;
   }
 
   CompleteType mCompleteType;
   bool mLoaded;
   bool mObserverCalled;
+  TextureSet mTextureSet;
 };
 
 
@@ -590,3 +592,305 @@ int UtcTextureManagerUseInvalidMask(void)
 
   END_TEST;
 }
+
+int UtcTextureManagerSynchronousLoadingFail(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( "UtcTextureManagerSynchronousLoadingFail" );
+
+  TextureManager textureManager; // Create new texture manager
+
+  std::string maskname("");
+  TextureManager::MaskingDataPointer maskInfo = nullptr;
+  maskInfo.reset(new TextureManager::MaskingData());
+  maskInfo->mAlphaMaskUrl = maskname;
+  maskInfo->mAlphaMaskId = TextureManager::INVALID_TEXTURE_ID;
+  maskInfo->mCropToMask = true;
+  maskInfo->mContentScaleFactor = 1.0f;
+
+  std::string filename("dummy");
+  auto textureId( TextureManager::INVALID_TEXTURE_ID );
+  Vector4 atlasRect( 0.f, 0.f, 0.f, 0.f );
+  Dali::ImageDimensions atlasRectSize( 0,0 );
+  bool atlasingStatus(false);
+  bool loadingStatus(false);
+  auto preMultiply = TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY;
+  ImageAtlasManagerPtr atlasManager = nullptr;
+  Toolkit::AtlasUploadObserver* atlasUploadObserver = nullptr;
+
+  // load image synchronously.
+  TestObserver observer;
+  TextureSet textureSet = textureManager.LoadTexture(
+    filename,
+    ImageDimensions(),
+    FittingMode::SCALE_TO_FILL,
+    SamplingMode::BOX_THEN_LINEAR,
+    maskInfo,
+    true, // synchronous loading.
+    textureId,
+    atlasRect,
+    atlasRectSize,
+    atlasingStatus,
+    loadingStatus,
+    WrapMode::DEFAULT,
+    WrapMode::DEFAULT,
+    &observer,
+    atlasUploadObserver,
+    atlasManager,
+    true,
+    TextureManager::ReloadPolicy::CACHED,
+    preMultiply
+  );
+
+  DALI_TEST_EQUALS(loadingStatus, false, TEST_LOCATION);
+  DALI_TEST_CHECK(!textureSet);  // texture loading fail.
+  DALI_TEST_CHECK(textureId == TextureManager::INVALID_TEXTURE_ID); // invalid texture id is returned.
+
+  END_TEST;
+}
+
+int UtcTextureManagerCachingSynchronousLoading(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( "UtcTextureManagerCachingSynchronousLoading" );
+
+  TextureManager textureManager; // Create new texture manager
+
+  std::string filename( TEST_IMAGE_FILE_NAME );
+
+  std::string maskname("");
+  TextureManager::MaskingDataPointer maskInfo = nullptr;
+  maskInfo.reset(new TextureManager::MaskingData());
+  maskInfo->mAlphaMaskUrl = maskname;
+  maskInfo->mAlphaMaskId = TextureManager::INVALID_TEXTURE_ID;
+  maskInfo->mCropToMask = true;
+  maskInfo->mContentScaleFactor = 1.0f;
+
+  Vector4 atlasRect( 0.f, 0.f, 0.f, 0.f );
+  Dali::ImageDimensions atlasRectSize( 0,0 );
+  bool atlasingStatus(false);
+  bool loadingStatus(false);
+  auto preMultiply = TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY;
+  ImageAtlasManagerPtr atlasManager = nullptr;
+  Toolkit::AtlasUploadObserver* atlasUploadObserver = nullptr;
+
+  // load image synchronously.
+  TestObserver observer;
+  auto textureId( TextureManager::INVALID_TEXTURE_ID );
+  TextureSet textureSet = textureManager.LoadTexture(
+    filename,
+    ImageDimensions(),
+    FittingMode::SCALE_TO_FILL,
+    SamplingMode::BOX_THEN_LINEAR,
+    maskInfo,
+    true, // synchronous loading.
+    textureId,
+    atlasRect,
+    atlasRectSize,
+    atlasingStatus,
+    loadingStatus,
+    WrapMode::DEFAULT,
+    WrapMode::DEFAULT,
+    &observer,
+    atlasUploadObserver,
+    atlasManager,
+    true,
+    TextureManager::ReloadPolicy::CACHED,
+    preMultiply
+  );
+
+  DALI_TEST_EQUALS(loadingStatus, false, TEST_LOCATION);
+  DALI_TEST_CHECK(textureSet);  // texture is loaded.
+
+  // observer isn't called in synchronous loading.
+  DALI_TEST_EQUALS(observer.mLoaded, false, TEST_LOCATION);
+  DALI_TEST_EQUALS(observer.mObserverCalled, false, TEST_LOCATION);
+
+
+  // load same image asynchronously.
+  TestObserver asyncObserver;
+  auto asyncTextureId( TextureManager::INVALID_TEXTURE_ID );
+  loadingStatus = false;
+  TextureSet asyncTextureSet = textureManager.LoadTexture(
+    filename,
+    ImageDimensions(),
+    FittingMode::SCALE_TO_FILL,
+    SamplingMode::BOX_THEN_LINEAR,
+    maskInfo,
+    false, // asynchronous loading.
+    asyncTextureId,
+    atlasRect,
+    atlasRectSize,
+    atlasingStatus,
+    loadingStatus,
+    WrapMode::DEFAULT,
+    WrapMode::DEFAULT,
+    &asyncObserver,
+    atlasUploadObserver,
+    atlasManager,
+    true,
+    TextureManager::ReloadPolicy::CACHED,
+    preMultiply
+  );
+
+  DALI_TEST_EQUALS(asyncTextureId, textureId, TEST_LOCATION); // texture is loaded.
+  DALI_TEST_EQUALS(loadingStatus, false, TEST_LOCATION);
+  DALI_TEST_CHECK(asyncTextureSet);  // Cached texture.
+
+  // observer is directly called because textureSet is retrieved by cache.
+  DALI_TEST_EQUALS(asyncObserver.mLoaded, true, TEST_LOCATION);
+  DALI_TEST_EQUALS(asyncObserver.mObserverCalled, true, TEST_LOCATION);
+
+  END_TEST;
+}
+
+int UtcTextureManagerAsyncSyncAsync(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( "UtcTextureManagerAsyncSyncAsync" );
+
+  TextureManager textureManager; // Create new texture manager
+
+  std::string filename( TEST_IMAGE_FILE_NAME );
+
+  std::string maskname("");
+  TextureManager::MaskingDataPointer maskInfo = nullptr;
+  maskInfo.reset(new TextureManager::MaskingData());
+  maskInfo->mAlphaMaskUrl = maskname;
+  maskInfo->mAlphaMaskId = TextureManager::INVALID_TEXTURE_ID;
+  maskInfo->mCropToMask = true;
+  maskInfo->mContentScaleFactor = 1.0f;
+
+  Vector4 atlasRect( 0.f, 0.f, 0.f, 0.f );
+  Dali::ImageDimensions atlasRectSize( 0,0 );
+  bool atlasingStatus(false);
+  auto preMultiply = TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY;
+  ImageAtlasManagerPtr atlasManager = nullptr;
+  Toolkit::AtlasUploadObserver* atlasUploadObserver = nullptr;
+
+  // load image asynchronously.
+  TestObserver asyncObserver1;
+  auto asyncTextureId1( TextureManager::INVALID_TEXTURE_ID );
+  bool asyncLoadingStatus1 = false;
+  TextureSet asyncTextureSet1 = textureManager.LoadTexture(
+    filename,
+    ImageDimensions(),
+    FittingMode::SCALE_TO_FILL,
+    SamplingMode::BOX_THEN_LINEAR,
+    maskInfo,
+    false, // asynchronous loading.
+    asyncTextureId1,
+    atlasRect,
+    atlasRectSize,
+    atlasingStatus,
+    asyncLoadingStatus1,
+    WrapMode::DEFAULT,
+    WrapMode::DEFAULT,
+    &asyncObserver1,
+    atlasUploadObserver,
+    atlasManager,
+    true,
+    TextureManager::ReloadPolicy::CACHED,
+    preMultiply
+  );
+
+  DALI_TEST_EQUALS(asyncLoadingStatus1, true, TEST_LOCATION); // texture is loading now.
+  DALI_TEST_CHECK(!asyncTextureSet1);  // texture is not loaded yet.
+
+  // observer is still not called.
+  DALI_TEST_EQUALS(asyncObserver1.mLoaded, false, TEST_LOCATION);
+  DALI_TEST_EQUALS(asyncObserver1.mObserverCalled, false, TEST_LOCATION);
+
+
+  // load same image synchronously just after asynchronous loading.
+  TestObserver syncObserver;
+  auto textureId( TextureManager::INVALID_TEXTURE_ID );
+  bool syncLoadingStatus = false;
+  TextureSet syncTextureSet = textureManager.LoadTexture(
+    filename,
+    ImageDimensions(),
+    FittingMode::SCALE_TO_FILL,
+    SamplingMode::BOX_THEN_LINEAR,
+    maskInfo,
+    true, // synchronous loading.
+    textureId,
+    atlasRect,
+    atlasRectSize,
+    atlasingStatus,
+    syncLoadingStatus,
+    WrapMode::DEFAULT,
+    WrapMode::DEFAULT,
+    &syncObserver,
+    atlasUploadObserver,
+    atlasManager,
+    true,
+    TextureManager::ReloadPolicy::CACHED,
+    preMultiply
+  );
+
+  DALI_TEST_EQUALS(asyncTextureId1, textureId, TEST_LOCATION); // texture is loaded.
+  DALI_TEST_EQUALS(syncLoadingStatus, false, TEST_LOCATION); // texture is loaded.
+  DALI_TEST_CHECK(syncTextureSet);  // texture is loaded.
+
+  // syncObserver isn't called in synchronous loading.
+  DALI_TEST_EQUALS(syncObserver.mLoaded, false, TEST_LOCATION);
+  DALI_TEST_EQUALS(syncObserver.mObserverCalled, false, TEST_LOCATION);
+
+  // asyncObserver1 is still not called too.
+  DALI_TEST_EQUALS(asyncObserver1.mLoaded, false, TEST_LOCATION);
+  DALI_TEST_EQUALS(asyncObserver1.mObserverCalled, false, TEST_LOCATION);
+
+
+
+  // load image asynchronously.
+  TestObserver asyncObserver2;
+  auto asyncTextureId2( TextureManager::INVALID_TEXTURE_ID );
+  bool asyncLoadingStatus2 = false;
+  TextureSet asyncTextureSet2 = textureManager.LoadTexture(
+    filename,
+    ImageDimensions(),
+    FittingMode::SCALE_TO_FILL,
+    SamplingMode::BOX_THEN_LINEAR,
+    maskInfo,
+    false, // asynchronous loading.
+    asyncTextureId2,
+    atlasRect,
+    atlasRectSize,
+    atlasingStatus,
+    asyncLoadingStatus2,
+    WrapMode::DEFAULT,
+    WrapMode::DEFAULT,
+    &asyncObserver2,
+    atlasUploadObserver,
+    atlasManager,
+    true,
+    TextureManager::ReloadPolicy::CACHED,
+    preMultiply
+  );
+
+  DALI_TEST_EQUALS(asyncLoadingStatus2, false, TEST_LOCATION); // texture is loaded by previous sync request
+  DALI_TEST_CHECK(asyncTextureSet2); // texture is loaded
+  DALI_TEST_CHECK(asyncTextureSet2 == syncTextureSet);  // check loaded two texture is same.
+
+  // observer is called synchronously because the texture is cached.
+  DALI_TEST_EQUALS(asyncObserver2.mLoaded, true, TEST_LOCATION);
+  DALI_TEST_EQUALS(asyncObserver2.mObserverCalled, true, TEST_LOCATION);
+
+  asyncObserver2.mLoaded = false;
+  asyncObserver2.mObserverCalled = false;
+
+  application.SendNotification();
+  application.Render();
+
+  // Requested asynchronous loading at first is finished now and async observer is called now.
+  DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
+  DALI_TEST_EQUALS(asyncObserver1.mLoaded, true, TEST_LOCATION);
+  DALI_TEST_EQUALS(asyncObserver1.mObserverCalled, true, TEST_LOCATION);
+  DALI_TEST_CHECK(asyncObserver1.mTextureSet == asyncTextureSet2);  // check loaded two texture is same.
+
+  // asyncObserver2 was already called so it isn't called here.
+  DALI_TEST_EQUALS(asyncObserver2.mLoaded, false, TEST_LOCATION);
+  DALI_TEST_EQUALS(asyncObserver2.mObserverCalled, false, TEST_LOCATION);
+
+  END_TEST;
+}