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%2Fdali-test-suite-utils.cpp;h=523bd8ce2226d65b73e98c27ee37c5994dfaa69c;hp=8877a509d99462bf49d03ebd2f51a88b9fbdc8a7;hb=8a647e87a01c5c78451653c1264a9eea81ac9b20;hpb=f781537e1453775663bb7f89adb495957dfa61ef

diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.cpp
index 8877a50..523bd8c 100644
--- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.cpp
+++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
@@ -26,97 +26,103 @@
 
 using namespace Dali;
 
-int test_return_value = TET_UNDEF;
+int32_t test_return_value = TET_UNDEF;
 
-void tet_result(int value)
+void tet_result(int32_t value)
 {
   // First TET_PASS should set to zero
   // first TET_FAIL should prevent any further TET_PASS from setting back to zero
   // Any TET_FAIL should set to fail or leave as fail
-  if( test_return_value != 1 )
+  if(test_return_value != 1)
     test_return_value = value;
 }
 
 #define END_TEST \
-  return ((test_return_value>0)?1:0)
+  return ((test_return_value > 0) ? 1 : 0)
 
-
-void tet_infoline(const char* str)
+extern "C"
 {
-  fprintf(stderr, "%s\n", str);
-}
+  void tet_infoline(const char* str)
+  {
+    fprintf(stderr, "%s\n", str);
+  }
 
-void tet_printf(const char *format, ...)
-{
-  va_list arg;
-  va_start(arg, format);
-  vfprintf(stderr, format, arg);
-  va_end(arg);
+  void tet_printf(const char* format, ...)
+  {
+    va_list arg;
+    va_start(arg, format);
+    vfprintf(stderr, format, arg);
+    va_end(arg);
+  }
 }
 
 bool operator==(TimePeriod a, TimePeriod b)
 {
-  return Equals(a.durationSeconds, b.durationSeconds) && Equals(a.delaySeconds, b.delaySeconds) ;
+  return Equals(a.durationSeconds, b.durationSeconds) && Equals(a.delaySeconds, b.delaySeconds);
 }
 
-std::ostream& operator<<( std::ostream& ostream, TimePeriod value )
+std::ostream& operator<<(std::ostream& ostream, TimePeriod value)
 {
   return ostream << "( Duration:" << value.durationSeconds << " Delay:" << value.delaySeconds << ")";
 }
 
-std::ostream& operator<<( std::ostream& ostream, Radian angle )
+std::ostream& operator<<(std::ostream& ostream, Radian angle)
 {
   ostream << angle.radian;
   return ostream;
 }
 
-std::ostream& operator<<( std::ostream& ostream, Degree angle )
+std::ostream& operator<<(std::ostream& ostream, Degree angle)
 {
   ostream << angle.degree;
   return ostream;
 }
 
-void DALI_TEST_EQUALS( const BaseHandle& baseHandle1, const BaseHandle& baseHandle2, const char* location )
+void DALI_TEST_EQUALS(const BaseHandle& baseHandle1, const BaseHandle& baseHandle2, const char* location)
 {
-  DALI_TEST_EQUALS< const BaseHandle& >( baseHandle1, baseHandle2, location );
+  DALI_TEST_EQUALS<const BaseHandle&>(baseHandle1, baseHandle2, location);
 }
 
-void DALI_TEST_EQUALS( const size_t value1, const unsigned int value2, const char* location )
+void DALI_TEST_EQUALS(const size_t value1, const uint32_t value2, const char* location)
 {
-  DALI_TEST_EQUALS< unsigned int>( ( unsigned int )( value1 ), value2, location );
+  DALI_TEST_EQUALS<uint32_t>((uint32_t)(value1), value2, location);
 }
 
-void DALI_TEST_EQUALS( const unsigned int value1, const size_t value2, const char* location )
+void DALI_TEST_EQUALS(const uint32_t value1, const size_t value2, const char* location)
 {
-  DALI_TEST_EQUALS< unsigned int >( value1, ( unsigned int )( value2 ), location );
+  DALI_TEST_EQUALS<uint32_t>(value1, (uint32_t)(value2), location);
 }
 
-void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, const char* location)
+void DALI_TEST_EQUALS(const Matrix3& matrix1, const Matrix3& matrix2, const char* location)
 {
-  const float* m1 = matrix1.AsFloat();
-  const float* m2 = matrix2.AsFloat();
-  bool equivalent = true;
+  const float* m1         = matrix1.AsFloat();
+  const float* m2         = matrix2.AsFloat();
+  bool         equivalent = true;
 
-  for (int i=0;i<9;++i)
+  for(int32_t i = 0; i < 9; ++i)
   {
-    if( ! (fabsf(m1[i] - m2[i])< GetRangedEpsilon(m1[i], m2[i])) )
+    if(!(fabsf(m1[i] - m2[i]) < GetRangedEpsilon(m1[i], m2[i])))
     {
       equivalent = false;
     }
   }
 
-  if( !equivalent )
+  if(!equivalent)
   {
+    // Align each float to 1234.67, i.e. 3.6 will be "   3.60"
+    // clang-format off
     fprintf(stderr, "%s, checking\n"
-               "(%f, %f, %f)    (%f, %f, %f)\n"
-               "(%f, %f, %f) == (%f, %f, %f)\n"
-               "(%f, %f, %f)    (%f, %f, %f)\n",
-               location,
-               m1[0],  m1[1], m1[2],   m2[0],  m2[1], m2[2],
-               m1[3],  m1[4], m1[5],   m2[3],  m2[4], m2[5],
-               m1[6],  m1[7], m1[8],   m2[6],  m2[7], m2[8]);
+            "%7.2f %7.2f %7.2f    %7.2f %7.2f %7.2f\n"
+            "%7.2f %7.2f %7.2f == %7.2f %7.2f %7.2f\n"
+            "%7.2f %7.2f %7.2f    %7.2f %7.2f %7.2f\n",
+            location,
+            m1[0],m1[3],m1[6],m2[0],m2[3],m2[6],
+            m1[1],m1[4],m1[7],m2[1],m2[4],m2[7],
+            m1[2],m1[5],m1[8],m2[2],m2[5],m2[8]);
+    // clang-format on
 
     tet_result(TET_FAIL);
+    throw("TET_FAIL");
   }
   else
   {
@@ -124,29 +130,33 @@ void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, const cha
   }
 }
 
-void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, float epsilon, const char* location)
+void DALI_TEST_EQUALS(const Matrix3& matrix1, const Matrix3& matrix2, float epsilon, const char* location)
 {
-  const float* m1 = matrix1.AsFloat();
-  const float* m2 = matrix2.AsFloat();
-  bool equivalent = true;
+  const float* m1         = matrix1.AsFloat();
+  const float* m2         = matrix2.AsFloat();
+  bool         equivalent = true;
 
-  for (int i=0;i<9;++i)
+  for(int32_t i = 0; i < 9; ++i)
   {
-    equivalent &= (fabsf(m1[i] - m2[i])<epsilon);
+    equivalent &= (fabsf(m1[i] - m2[i]) < epsilon);
   }
 
-  if (!equivalent)
+  if(!equivalent)
   {
+    // Align each float to 1234.67, i.e. 3.6 will be "   3.60"
+    // clang-format off
     fprintf(stderr, "%s, checking\n"
-               "(%f, %f, %f)    (%f, %f, %f)\n"
-               "(%f, %f, %f) == (%f, %f, %f)\n"
-               "(%f, %f, %f)    (%f, %f, %f)\n",
-               location,
-               m1[0],  m1[1], m1[2],   m2[0],  m2[1], m2[2],
-               m1[3],  m1[4], m1[5],   m2[3],  m2[4], m2[5],
-               m1[6],  m1[7], m1[8],   m2[6],  m2[7], m2[8]);
+            "%7.2f %7.2f %7.2f    %7.2f %7.2f %7.2f\n"
+            "%7.2f %7.2f %7.2f == %7.2f %7.2f %7.2f\n"
+            "%7.2f %7.2f %7.2f    %7.2f %7.2f %7.2f\n",
+            location,
+            m1[0],m1[3],m1[6],m2[0],m2[3],m2[6],
+            m1[1],m1[4],m1[7],m2[1],m2[4],m2[7],
+            m1[2],m1[5],m1[8],m2[2],m2[5],m2[8]);
+    // clang-format on
 
     tet_result(TET_FAIL);
+    throw("TET_FAIL");
   }
   else
   {
@@ -154,14 +164,14 @@ void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, float eps
   }
 }
 
-void DALI_TEST_EQUALS( const Matrix& matrix1, const Matrix& matrix2, const char* location)
+void DALI_TEST_EQUALS(const Matrix& matrix1, const Matrix& matrix2, const char* location)
 {
-  const float* m1 = matrix1.AsFloat();
-  const float* m2 = matrix2.AsFloat();
-  bool identical = true;
+  const float* m1        = matrix1.AsFloat();
+  const float* m2        = matrix2.AsFloat();
+  bool         identical = true;
 
-  int i;
-  for (i=0;i<16;++i)
+  int32_t i;
+  for(i = 0; i < 16; ++i)
   {
     if(m1[i] != m2[i])
     {
@@ -170,19 +180,24 @@ void DALI_TEST_EQUALS( const Matrix& matrix1, const Matrix& matrix2, const char*
     }
   }
 
-  if (!identical)
+  if(!identical)
   {
+    // Align each float to 1234.67, i.e. 3.6 will be "   3.60"
+    // clang-format off
     fprintf(stderr, "%s, checking\n"
-               "(%f, %f, %f, %f)    (%f, %f, %f, %f)\n"
-               "(%f, %f, %f, %f) == (%f, %f, %f, %f)\n"
-               "(%f, %f, %f, %f)    (%f, %f, %f, %f)\n"
-               "(%f, %f, %f, %f)    (%f, %f, %f, %f)\n", location,
-               m1[0],  m1[1],  m1[2],  m1[3],   m2[0],  m2[1],  m2[2],  m2[3],
-               m1[4],  m1[5],  m1[6],  m1[7],   m2[4],  m2[5],  m2[6],  m2[7],
-               m1[8],  m1[9], m1[10], m1[11],   m2[8],  m2[9], m2[10], m2[11],
-              m1[12], m1[13], m1[14], m1[15],  m2[12], m2[13], m2[14], m2[15]);
+            "%7.2f %7.2f %7.2f %7.2f    %7.2f %7.2f %7.2f %7.2f\n"
+            "%7.2f %7.2f %7.2f %7.2f == %7.2f %7.2f %7.2f %7.2f\n"
+            "%7.2f %7.2f %7.2f %7.2f    %7.2f %7.2f %7.2f %7.2f\n"
+            "%7.2f %7.2f %7.2f %7.2f    %7.2f %7.2f %7.2f %7.2f\n",
+            location,
+            m1[0],m1[4],m1[8],m1[12],m2[0],m2[4],m2[8],m2[12],
+            m1[1],m1[5],m1[9],m1[13],m2[1],m2[5],m2[9],m2[13],
+            m1[2],m1[6],m1[10],m1[14],m2[2],m2[6],m2[10],m2[14],
+            m1[3],m1[7],m1[11],m1[15],m2[3],m2[7],m2[11],m2[15]);
+    // clang-format on
 
     tet_result(TET_FAIL);
+    throw("TET_FAIL");
   }
   else
   {
@@ -190,30 +205,35 @@ void DALI_TEST_EQUALS( const Matrix& matrix1, const Matrix& matrix2, const char*
   }
 }
 
-void DALI_TEST_EQUALS( const Matrix& matrix1, const Matrix& matrix2, float epsilon, const char* location)
+void DALI_TEST_EQUALS(const Matrix& matrix1, const Matrix& matrix2, float epsilon, const char* location)
 {
-  const float* m1 = matrix1.AsFloat();
-  const float* m2 = matrix2.AsFloat();
-  bool equivalent = true;
+  const float* m1         = matrix1.AsFloat();
+  const float* m2         = matrix2.AsFloat();
+  bool         equivalent = true;
 
-  for (int i=0;i<16;++i)
+  for(int32_t i = 0; i < 16; ++i)
   {
-    equivalent &= (fabsf(m1[i] - m2[i])<epsilon);
+    equivalent &= (fabsf(m1[i] - m2[i]) < epsilon);
   }
 
-  if (!equivalent)
+  if(!equivalent)
   {
+    // Align each float to 1234.67, i.e. 3.6 will be "   3.60"
+    // clang-format off
     fprintf(stderr, "%s, checking\n"
-               "(%f, %f, %f, %f)    (%f, %f, %f, %f)\n"
-               "(%f, %f, %f, %f) == (%f, %f, %f, %f)\n"
-               "(%f, %f, %f, %f)    (%f, %f, %f, %f)\n"
-               "(%f, %f, %f, %f)    (%f, %f, %f, %f)\n", location,
-               m1[0],  m1[1],  m1[2],  m1[3],   m2[0],  m2[1],  m2[2],  m2[3],
-               m1[4],  m1[5],  m1[6],  m1[7],   m2[4],  m2[5],  m2[6],  m2[7],
-               m1[8],  m1[9], m1[10], m1[11],   m2[8],  m2[9], m2[10], m2[11],
-              m1[12], m1[13], m1[14], m1[15],  m2[12], m2[13], m2[14], m2[15]);
+            "%7.2f %7.2f %7.2f %7.2f    %7.2f %7.2f %7.2f %7.2f\n"
+            "%7.2f %7.2f %7.2f %7.2f == %7.2f %7.2f %7.2f %7.2f\n"
+            "%7.2f %7.2f %7.2f %7.2f    %7.2f %7.2f %7.2f %7.2f\n"
+            "%7.2f %7.2f %7.2f %7.2f    %7.2f %7.2f %7.2f %7.2f\n",
+            location,
+            m1[0],m1[4],m1[8],m1[12],m2[0],m2[4],m2[8],m2[12],
+            m1[1],m1[5],m1[9],m1[13],m2[1],m2[5],m2[9],m2[13],
+            m1[2],m1[6],m1[10],m1[14],m2[2],m2[6],m2[10],m2[14],
+            m1[3],m1[7],m1[11],m1[15],m2[3],m2[7],m2[11],m2[15]);
+    // clang-format on
 
     tet_result(TET_FAIL);
+    throw("TET_FAIL");
   }
   else
   {
@@ -221,50 +241,51 @@ void DALI_TEST_EQUALS( const Matrix& matrix1, const Matrix& matrix2, float epsil
   }
 }
 
-
 /**
  * Test whether two strings are equal.
  * @param[in] str1 The first string
  * @param[in] str2 The second string
  * @param[in] location The TEST_LOCATION macro should be used here
  */
-void DALI_TEST_EQUALS( const std::string &str1, const char* str2, const char* location)
+void DALI_TEST_EQUALS(const std::string& str1, const char* str2, const char* location)
 {
   DALI_TEST_EQUALS(str1.c_str(), str2, location);
 }
 
-void DALI_TEST_EQUALS( Property::Value& str1, const char* str2, const char* location)
+void DALI_TEST_EQUALS(Property::Value& str1, const char* str2, const char* location)
 {
   bool result = false;
 
-  if( str1.GetType() == Property::STRING )
+  if(str1.GetType() == Property::STRING)
   {
     std::string string;
     str1.Get(string);
     result = !string.compare(str2);
   }
 
-  if( result )
+  if(result)
   {
     tet_result(TET_PASS);
   }
   else
   {
     tet_result(TET_FAIL);
+    throw("TET_FAIL");
   }
 }
 
-void DALI_TEST_EQUALS( const char* str1, const std::string &str2, const char* location)
+void DALI_TEST_EQUALS(const char* str1, const std::string& str2, const char* location)
 {
   DALI_TEST_EQUALS(str1, str2.c_str(), location);
 }
 
-void DALI_TEST_ASSERT( DaliException& e, std::string conditionSubString, const char* location )
+void DALI_TEST_ASSERT(DaliException& e, std::string conditionSubString, const char* location)
 {
-  if( NULL == strstr( e.condition, conditionSubString.c_str() ) )
+  if(NULL == strstr(e.condition, conditionSubString.c_str()))
   {
-    fprintf(stderr, "Expected substring '%s' : actual exception string '%s' : location %s\n", conditionSubString.c_str(), e.condition, location );
+    fprintf(stderr, "Expected substring '%s' : actual exception string '%s' : location %s\n", conditionSubString.c_str(), e.condition, location);
     tet_result(TET_FAIL);
+    throw("TET_FAIL");
   }
   else
   {
@@ -273,12 +294,12 @@ void DALI_TEST_ASSERT( DaliException& e, std::string conditionSubString, const c
 }
 
 // Functor to test whether an Applied signal is emitted
-ConstraintAppliedCheck::ConstraintAppliedCheck( bool& signalReceived )
-: mSignalReceived( signalReceived )
+ConstraintAppliedCheck::ConstraintAppliedCheck(bool& signalReceived)
+: mSignalReceived(signalReceived)
 {
 }
 
-void ConstraintAppliedCheck::operator()( Constraint& constraint )
+void ConstraintAppliedCheck::operator()(Constraint& constraint)
 {
   mSignalReceived = true;
 }
@@ -290,113 +311,74 @@ void ConstraintAppliedCheck::Reset()
 
 void ConstraintAppliedCheck::CheckSignalReceived()
 {
-  if ( !mSignalReceived )
+  if(!mSignalReceived)
   {
-    fprintf(stderr,  "Expected Applied signal was not received\n" );
-    tet_result( TET_FAIL );
+    fprintf(stderr, "Expected Applied signal was not received\n");
+    tet_result(TET_FAIL);
+    throw("TET_FAIL");
   }
   else
   {
-    tet_result( TET_PASS );
+    tet_result(TET_PASS);
   }
 }
 
 void ConstraintAppliedCheck::CheckSignalNotReceived()
 {
-  if ( mSignalReceived )
+  if(mSignalReceived)
   {
-    fprintf(stderr,  "Unexpected Applied signal was received\n" );
-    tet_result( TET_FAIL );
+    fprintf(stderr, "Unexpected Applied signal was received\n");
+    tet_result(TET_FAIL);
+    throw("TET_FAIL");
   }
   else
   {
-    tet_result( TET_PASS );
-  }
-}
-
-BufferImage CreateBufferImage(int width, int height, const Vector4& color)
-{
-  BufferImage image = BufferImage::New(width, height, Pixel::RGBA8888);
-
-  PixelBuffer* pixbuf = image.GetBuffer();
-
-  // Using a 4x4 image gives a better blend with the GL implementation
-  // than a 3x3 image
-  for(size_t i=0; i<16; i++)
-  {
-    pixbuf[i*4+0] = color.r*255;
-    pixbuf[i*4+1] = color.g*255;
-    pixbuf[i*4+2] = color.b*255;
-    pixbuf[i*4+3] = color.a*255;
+    tet_result(TET_PASS);
   }
-
-  return image;
-}
-
-BufferImage CreateBufferImage()
-{
-  return CreateBufferImage(4, 4, Color::WHITE);
-}
-
-void PrepareResourceImage( TestApplication& application, unsigned int imageWidth, unsigned int imageHeight, Pixel::Format pixelFormat )
-{
-  TestPlatformAbstraction& platform = application.GetPlatform();
-  platform.SetClosestImageSize(Vector2( imageWidth, imageHeight));
-
-  Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_RETAIN );
-  Integration::PixelBuffer* pixbuffer = bitmap->GetPackedPixelsProfile()->ReserveBuffer( pixelFormat, imageWidth, imageHeight, imageWidth, imageHeight );
-  unsigned int bytesPerPixel = GetBytesPerPixel(  pixelFormat );
-  unsigned int initialColor = 0xFF;
-  memset( pixbuffer, initialColor, imageHeight*imageWidth*bytesPerPixel);
-
-  Integration::ResourcePointer resourcePtr(bitmap);
-  platform.SetSynchronouslyLoadedResource( resourcePtr );
 }
 
 namespace Test
 {
-
 struct ObjectDestructionFunctor
 {
   // Create a ObjectDestructionFunctor passing in a Dali::RefObject* to be monitored and a bool variable.
   // Create ObjectRegistry instance and connect to the ObjectDestroyedSignal passing in the above functor for the callback.
   // Get the ObjectPointer (Actor::GetObjectPtr) of the Actor to be checked for destruction and assign it to the Dali::RefObject*
   // Check the bool variable which would be true when object destroyed.
-  ObjectDestructionFunctor( Dali::RefObject* objectPtr, bool& refObjectDestroyed )
-  : refObjectPointerToCheck( objectPtr ),
-    refObjectDestroyedBoolean( refObjectDestroyed )
+  ObjectDestructionFunctor(Dali::RefObject* objectPtr, bool& refObjectDestroyed)
+  : refObjectPointerToCheck(objectPtr),
+    refObjectDestroyedBoolean(refObjectDestroyed)
   {
     refObjectDestroyed = false;
   }
 
-  void operator()( const Dali::RefObject* objectPointer )
+  void operator()(const Dali::RefObject* objectPointer)
   {
-    if ( refObjectPointerToCheck == objectPointer )
+    if(refObjectPointerToCheck == objectPointer)
     {
       refObjectDestroyedBoolean = true;
     }
   }
 
   Dali::RefObject* refObjectPointerToCheck;
-  bool& refObjectDestroyedBoolean;
+  bool&            refObjectDestroyedBoolean;
 };
 
-ObjectDestructionTracker::ObjectDestructionTracker()
-  :mRefObjectDestroyed( false)
+ObjectDestructionTracker::ObjectDestructionTracker(ObjectRegistry objectRegistry)
+: mObjectRegistry(objectRegistry),
+  mRefObjectDestroyed(false)
 {
 }
 
-void ObjectDestructionTracker::Start( Actor actor )
+void ObjectDestructionTracker::Start(Actor actor)
 {
-  ObjectDestructionFunctor destructionFunctor( actor.GetObjectPtr(), mRefObjectDestroyed );
-
-  ObjectRegistry objectRegistry = Stage::GetCurrent().GetObjectRegistry();
-  objectRegistry.ObjectDestroyedSignal().Connect( this, destructionFunctor );
+  ObjectDestructionFunctor destructionFunctor(actor.GetObjectPtr(), mRefObjectDestroyed);
+  mObjectRegistry.ObjectDestroyedSignal().Connect(this, destructionFunctor);
 }
 
 bool ObjectDestructionTracker::IsDestroyed()
 {
-   return mRefObjectDestroyed;
+  return mRefObjectDestroyed;
 }
 
 } // namespace Test