/*
- * Copyright (c) 2015 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.
return ostream;
}
+void DALI_TEST_EQUALS( const BaseHandle& baseHandle1, const BaseHandle& baseHandle2, const char* location )
+{
+ DALI_TEST_EQUALS< const BaseHandle& >( baseHandle1, baseHandle2, location );
+}
+
+void DALI_TEST_EQUALS( const size_t value1, const unsigned int value2, const char* location )
+{
+ DALI_TEST_EQUALS< unsigned int>( ( unsigned int )( value1 ), value2, location );
+}
+
+void DALI_TEST_EQUALS( const unsigned int value1, const size_t value2, const char* location )
+{
+ DALI_TEST_EQUALS< unsigned int >( value1, ( unsigned int )( value2 ), location );
+}
+
void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, const char* location)
{
const float* m1 = matrix1.AsFloat();
for (int i=0;i<9;++i)
{
- equivalent &= (m1[i] != m2[i]);
+ if( ! (fabsf(m1[i] - m2[i])< GetRangedEpsilon(m1[i], m2[i])) )
+ {
+ equivalent = false;
+ }
}
- if (!equivalent)
+ if( !equivalent )
{
fprintf(stderr, "%s, checking\n"
"(%f, %f, %f) (%f, %f, %f)\n"
m1[6], m1[7], m1[8], m2[6], m2[7], m2[8]);
tet_result(TET_FAIL);
+ throw("TET_FAIL");
}
else
{
m1[6], m1[7], m1[8], m2[6], m2[7], m2[8]);
tet_result(TET_FAIL);
+ throw("TET_FAIL");
}
else
{
m1[12], m1[13], m1[14], m1[15], m2[12], m2[13], m2[14], m2[15]);
tet_result(TET_FAIL);
+ throw("TET_FAIL");
}
else
{
m1[12], m1[13], m1[14], m1[15], m2[12], m2[13], m2[14], m2[15]);
tet_result(TET_FAIL);
+ throw("TET_FAIL");
}
else
{
DALI_TEST_EQUALS(str1.c_str(), str2, location);
}
-/**
- * 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( Property::Value& str1, const char* str2, const char* location)
+{
+ bool result = false;
+
+ if( str1.GetType() == Property::STRING )
+ {
+ std::string string;
+ str1.Get(string);
+ result = !string.compare(str2);
+ }
+
+ 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)
{
DALI_TEST_EQUALS(str1, str2.c_str(), 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
{
{
fprintf(stderr, "Expected Applied signal was not received\n" );
tet_result( TET_FAIL );
+ throw("TET_FAIL");
}
else
{
{
fprintf(stderr, "Unexpected Applied signal was received\n" );
tet_result( TET_FAIL );
+ throw("TET_FAIL");
}
else
{
}
}
-BufferImage CreateBufferImage()
+BufferImage CreateBufferImage(int width, int height, const Vector4& color)
{
- BufferImage image = BufferImage::New(4,4,Pixel::RGBA8888);
+ BufferImage image = BufferImage::New(width, height, Pixel::RGBA8888);
PixelBuffer* pixbuf = image.GetBuffer();
// than a 3x3 image
for(size_t i=0; i<16; i++)
{
- pixbuf[i*4+0] = 0xFF;
- pixbuf[i*4+1] = 0xFF;
- pixbuf[i*4+2] = 0xFF;
- pixbuf[i*4+3] = 0xFF;
+ 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;
}
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 )
+ {
+ refObjectDestroyed = false;
+ }
+
+ void operator()( const Dali::RefObject* objectPointer )
+ {
+ if ( refObjectPointerToCheck == objectPointer )
+ {
+ refObjectDestroyedBoolean = true;
+ }
+ }
+
+ Dali::RefObject* refObjectPointerToCheck;
+ bool& refObjectDestroyedBoolean;
+};
+
+ObjectDestructionTracker::ObjectDestructionTracker()
+ :mRefObjectDestroyed( false)
+{
+}
+
+void ObjectDestructionTracker::Start( Actor actor )
+{
+ ObjectDestructionFunctor destructionFunctor( actor.GetObjectPtr(), mRefObjectDestroyed );
+
+ ObjectRegistry objectRegistry = Stage::GetCurrent().GetObjectRegistry();
+ objectRegistry.ObjectDestroyedSignal().Connect( this, destructionFunctor );
+}
+
+bool ObjectDestructionTracker::IsDestroyed()
+{
+ return mRefObjectDestroyed;
+}
+
+} // namespace Test
projects / platform / core / uifw / dali-core.git / blobdiff