automated-tests/src/dali/utc-Dali-Vector3.cpp

   1 //
   2 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.0 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://floralicense.org/license/
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an AS IS BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16
  17 #include <iostream>
  18 #include <sstream>
  19
  20 #include <stdlib.h>
  21 #include <dali/dali.h>
  22 #include <dali-test-suite-utils.h>
  23
  24 using namespace Dali;
  25
  26 void utc_dali_vector3_startup(void)
  27 {
  28   test_return_value = TET_UNDEF;
  29 }
  30
  31 void utc_dali_vector3_cleanup(void)
  32 {
  33   test_return_value = TET_PASS;
  34 }
  35
  36 int UtcDaliVector3Cons(void)
  37 {
  38   Vector3 va;
  39   Vector3 vb(Vector2(1.0f, 2.0f));
  40   Vector3 vc(Vector4(5.63f, 2.31f, 9.83f, 11.23f));
  41   float array[] = {1.0f, 2.0f, 3.0f};
  42   Vector3 vd(array);
  43
  44   DALI_TEST_EQUALS(va.x, 0.0f, 0.001f, TEST_LOCATION);
  45   DALI_TEST_EQUALS(va.y, 0.0f, 0.001f, TEST_LOCATION);
  46   DALI_TEST_EQUALS(va.z, 0.0f, 0.001f, TEST_LOCATION);
  47
  48   DALI_TEST_EQUALS(vb.x, 1.0f, 0.001f, TEST_LOCATION);
  49   DALI_TEST_EQUALS(vb.y, 2.0f, 0.001f, TEST_LOCATION);
  50   DALI_TEST_EQUALS(vb.z, 0.0f, 0.001f, TEST_LOCATION);
  51
  52   DALI_TEST_EQUALS(vc.x, 5.63f, 0.001f, TEST_LOCATION);
  53   DALI_TEST_EQUALS(vc.y, 2.31f, 0.001f, TEST_LOCATION);
  54   DALI_TEST_EQUALS(vc.z, 9.83f, 0.001f, TEST_LOCATION);
  55
  56   DALI_TEST_EQUALS(vd.x, 1.0f, 0.001f, TEST_LOCATION);
  57   DALI_TEST_EQUALS(vd.y, 2.0f, 0.001f, TEST_LOCATION);
  58   DALI_TEST_EQUALS(vd.z, 3.0f, 0.001f, TEST_LOCATION);
  59
  60   Vector3* vecPtr = new Vector3(1.0f, 2.0f, 3.0f);
  61   DALI_TEST_CHECK( vecPtr != NULL );
  62   DALI_TEST_EQUALS(vecPtr->x, 1.0f, 0.001f, TEST_LOCATION);
  63   DALI_TEST_EQUALS(vecPtr->y, 2.0f, 0.001f, TEST_LOCATION);
  64   DALI_TEST_EQUALS(vecPtr->z, 3.0f, 0.001f, TEST_LOCATION);
  65
  66   Vector3 vec3;
  67   vec3 = *vecPtr;
  68   delete vecPtr;
  69
  70   Vector3 vec3b(vd);
  71   DALI_TEST_EQUALS(vec3b.x, 1.0f, 0.001f, TEST_LOCATION);
  72   DALI_TEST_EQUALS(vec3b.y, 2.0f, 0.001f, TEST_LOCATION);
  73   DALI_TEST_EQUALS(vec3b.z, 3.0f, 0.001f, TEST_LOCATION);
  74
  75   Vector3 vec3c = vd;
  76   DALI_TEST_EQUALS(vec3c.x, 1.0f, 0.001f, TEST_LOCATION);
  77   DALI_TEST_EQUALS(vec3c.y, 2.0f, 0.001f, TEST_LOCATION);
  78   DALI_TEST_EQUALS(vec3c.z, 3.0f, 0.001f, TEST_LOCATION);
  79   END_TEST;
  80 }
  81
  82 int UtcDaliVector3Assign(void)
  83 {
  84   Vector3 v0;
  85   const float array[] = { 1.0f, 2.0f, 3.0f };
  86   v0 = (const float*)array;
  87
  88   DALI_TEST_EQUALS(v0.x, 1.0f, 0.001f, TEST_LOCATION);
  89   DALI_TEST_EQUALS(v0.y, 2.0f, 0.001f, TEST_LOCATION);
  90   DALI_TEST_EQUALS(v0.z, 3.0f, 0.001f, TEST_LOCATION);
  91
  92   Vector2 vec2_q(1.0f, 2.0f);
  93   Vector3 vec3a;
  94   vec3a = vec2_q;
  95
  96   DALI_TEST_EQUALS(vec3a.x, 1.0f, 0.001f, TEST_LOCATION);
  97   DALI_TEST_EQUALS(vec3a.y, 2.0f, 0.001f, TEST_LOCATION);
  98   DALI_TEST_EQUALS(vec3a.z, 0.0f, 0.001f, TEST_LOCATION);
  99
 100   Vector4 vec4_q(4.0f, 3.0f, 2.0f, 1.0f);
 101   Vector3 vec3b;
 102   vec3b = vec4_q;
 103
 104   DALI_TEST_EQUALS(vec3b.x, 4.0f, 0.001f, TEST_LOCATION);
 105   DALI_TEST_EQUALS(vec3b.y, 3.0f, 0.001f, TEST_LOCATION);
 106   DALI_TEST_EQUALS(vec3b.z, 2.0f, 0.001f, TEST_LOCATION);
 107   END_TEST;
 108 }
 109
 110
 111 // Add
 112 int UtcDaliVector3Add(void)
 113 {
 114   Vector3 v0(1.0f, 2.0f, 3.0f);
 115   Vector3 v1(10.0f, 20.0f, 30.0f);
 116   Vector3 r0(11.0f, 22.0f, 33.0f);
 117
 118   Vector3 v2 = v0+v1;
 119   DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
 120
 121   v0 += v1;
 122   DALI_TEST_EQUALS(v0, r0, TEST_LOCATION);
 123   END_TEST;
 124 }
 125
 126 // Constants
 127 int UtcDaliVector3Constants(void)
 128 {
 129   Vector3 va = Vector3::ZERO;
 130   Vector3 vb = Vector3::ONE;
 131   Vector3 vc = Vector3::XAXIS;
 132
 133   DALI_TEST_EQUALS(va.x, 0.0f, 0.001f, TEST_LOCATION);
 134   DALI_TEST_EQUALS(va.y, 0.0f, 0.001f, TEST_LOCATION);
 135   DALI_TEST_EQUALS(va.z, 0.0f, 0.001f, TEST_LOCATION);
 136
 137   DALI_TEST_EQUALS(vb.x, 1.0f, 0.001f, TEST_LOCATION);
 138   DALI_TEST_EQUALS(vb.y, 1.0f, 0.001f, TEST_LOCATION);
 139   DALI_TEST_EQUALS(vb.z, 1.0f, 0.001f, TEST_LOCATION);
 140
 141   DALI_TEST_EQUALS(vc.x, 1.0f, 0.001f, TEST_LOCATION);
 142   DALI_TEST_EQUALS(vc.y, 0.0f, 0.001f, TEST_LOCATION);
 143   DALI_TEST_EQUALS(vc.z, 0.0f, 0.001f, TEST_LOCATION);
 144   END_TEST;
 145 }
 146
 147 // Cross
 148 int UtcDaliVector3Cross(void)
 149 {
 150   DALI_TEST_EQUALS(Vector3::XAXIS.Cross(Vector3::YAXIS), Vector3::ZAXIS, 0.0001f, TEST_LOCATION);
 151   DALI_TEST_EQUALS(Vector3::YAXIS.Cross(Vector3::ZAXIS), Vector3::XAXIS, 0.0001f, TEST_LOCATION);
 152   DALI_TEST_EQUALS(Vector3::ZAXIS.Cross(Vector3::XAXIS), Vector3::YAXIS, 0.0001f, TEST_LOCATION);
 153
 154   DALI_TEST_EQUALS(Vector3::XAXIS.Cross(Vector3::ZAXIS), -Vector3::YAXIS, 0.0001f, TEST_LOCATION);
 155   DALI_TEST_EQUALS(Vector3::YAXIS.Cross(Vector3::XAXIS), -Vector3::ZAXIS, 0.0001f, TEST_LOCATION);
 156   DALI_TEST_EQUALS(Vector3::ZAXIS.Cross(Vector3::YAXIS), -Vector3::XAXIS, 0.0001f, TEST_LOCATION);
 157
 158   Vector3 v0(2.0f, 3.0f, 4.0f);
 159   Vector3 v1(10.0f, 20.0f, 30.0f);
 160   Vector3 result(   (v0.y * v1.z) - (v0.z * v1.y),
 161                     (v0.z * v1.x) - (v0.x * v1.z),
 162                     (v0.x * v1.y) - (v0.y * v1.x) );
 163
 164
 165   DALI_TEST_EQUALS(v0.Cross(v1), result, 0.001f, TEST_LOCATION);
 166   END_TEST;
 167 }
 168
 169 // Dot
 170 int UtcDaliVector3Dot(void)
 171 {
 172   DALI_TEST_EQUALS(Vector3::XAXIS.Dot(Vector3::YAXIS), 0.0f, TEST_LOCATION);
 173   DALI_TEST_EQUALS(Vector3::XAXIS.Dot(Vector3::ZAXIS), 0.0f, TEST_LOCATION);
 174   DALI_TEST_EQUALS(Vector3::XAXIS.Dot(Vector3::XAXIS), 1.0f, TEST_LOCATION);
 175   DALI_TEST_EQUALS(Vector3::YAXIS.Dot(Vector3::YAXIS), 1.0f, TEST_LOCATION);
 176   DALI_TEST_EQUALS(Vector3::ZAXIS.Dot(Vector3::ZAXIS), 1.0f, TEST_LOCATION);
 177
 178   DALI_TEST_EQUALS(Vector3(1.0f, 0.0f, 0.0f).Dot(Vector3(1.0f, 0.0f, 0.0f)), 1.0f, TEST_LOCATION);
 179
 180   for (float x = 0; x<6.0f; x+=1.0f)
 181   {
 182     Vector3 v0(cosf(x), sinf(x), 0.0f);
 183     Vector3 v1(sinf(x), -cosf(x), 0.0f);
 184     DALI_TEST_EQUALS(v0.Dot(v1), 0.0f, 0.0001f, TEST_LOCATION);
 185     DALI_TEST_EQUALS(v0.Dot(v0), 1.0f, 0.0001f, TEST_LOCATION);
 186
 187     v0 = Vector3(cosf(x), 0.0f, sinf(x));
 188     v1 = Vector3(sinf(x), 0.0f, -cosf(x));
 189     DALI_TEST_EQUALS(v0.Dot(v0), 1.0f, 0.0001f, TEST_LOCATION);
 190   }
 191
 192   Vector3 v0 = Vector3(12.0f, 7.0f, 9.0f);
 193   v0.Normalize();
 194
 195   Vector3 v1 = v0 * 2.0f;
 196   DALI_TEST_EQUALS(v0.Dot(v1), 2.0f, 0.001f, TEST_LOCATION);
 197   END_TEST;
 198 }
 199
 200
 201 // Equals
 202 int UtcDaliVector3Equals(void)
 203 {
 204   Vector3 v0(1.0f, 2.0f,  3.0f);
 205   Vector3 v1(1.0f, 2.0f,  3.0f);
 206
 207   DALI_TEST_CHECK(v0 == v1);
 208
 209   Vector3 v2 = Vector3(0.0f, 2.0f, 3.0f);
 210   DALI_TEST_CHECK(v0 != v2);
 211
 212   v2 = Vector3(1.0f, 0.0f, 3.0f);
 213   DALI_TEST_CHECK(v0 != v2);
 214
 215   v2 = Vector3(1.0f, 2.0f, 0.0f);
 216   DALI_TEST_CHECK(v0 != v2);
 217
 218   v2 = Vector3(11.0f, 22.0f, 33.0f);
 219   DALI_TEST_CHECK(v0 != v2);
 220   END_TEST;
 221 }
 222
 223
 224 // Length
 225 int UtcDaliVector3Length(void)
 226 {
 227   Vector3 v(1.0f, 2.0f, 3.0f);
 228   DALI_TEST_EQUALS(v.Length(), sqrtf(v.x*v.x + v.y*v.y + v.z*v.z), 0.001f, TEST_LOCATION);
 229
 230   Vector3 v1(0.0f, 0.0f, 0.0f);
 231   DALI_TEST_EQUALS(v1.Length(), 0.0f, TEST_LOCATION);
 232   END_TEST;
 233 }
 234
 235 // Length squared
 236 int UtcDaliVector3LengthSquared(void)
 237 {
 238   Vector3 v(1.0f, 2.0f, 3.0f);
 239   DALI_TEST_EQUALS(v.LengthSquared(), v.x*v.x + v.y*v.y + v.z*v.z, 0.001f, TEST_LOCATION);
 240
 241   Vector3 v1(0.0f, 0.0f, 0.0f);
 242   DALI_TEST_EQUALS(v1.LengthSquared(), 0.0f, TEST_LOCATION);
 243   END_TEST;
 244 }
 245
 246 // Max
 247 int UtcDaliVector3Max(void)
 248 {
 249   Vector3 v0(2.0f, 1.0f, 3.0f);
 250   Vector3 v1(1.0f, 2.0f, 3.0f);
 251
 252   DALI_TEST_EQUALS(Max(v0, v1), Vector3(2.0f, 2.0f, 3.0f), 0.01f, TEST_LOCATION);
 253   END_TEST;
 254 }
 255
 256 // Min
 257 int UtcDaliVector3Min(void)
 258 {
 259   Vector3 v0(2.0f, 2.0f, 1.0f);
 260   Vector3 v1(1.0f, 1.0f, 2.0f);
 261
 262   DALI_TEST_EQUALS(Min(v0, v1), Vector3(1.0f, 1.0f, 1.0f), 0.01f, TEST_LOCATION);
 263   END_TEST;
 264 }
 265
 266 int UtcDaliVector3Clamp(void)
 267 {
 268   tet_infoline("Testing Dali::Vector3::Clamp()");
 269
 270   Vector3 v0( 2.0f, 1.0f, 0.0f );
 271   Vector3 v1( -1.0f, 2.0f, 1.0f );
 272
 273   DALI_TEST_EQUALS( Clamp( v0, 0.9f, 1.1f ), Vector3(1.1f, 1.0f, 0.9f), 0.01f, TEST_LOCATION );
 274   DALI_TEST_EQUALS( Clamp( v1, 1.0f, 1.0f ), Vector3(1.0f, 1.0f, 1.0f), 0.01f, TEST_LOCATION );
 275   END_TEST;
 276 }
 277
 278 int UtcDaliVector3ClampVector3(void)
 279 {
 280   tet_infoline("Testing Dali::Vector3::Clamp( const Vector3& v, const Vector3& min, const Vector3& max )");
 281
 282   Vector3 v0(2.0f, 0.8f, 0.0f);
 283   Vector3 v1(-1.0f, 2.0f, 10.0f);
 284   Vector3 v2(10.0f, 5.0f, 0.0f);
 285   Vector3 v3(8.0f, 10.0f, 5.0f);
 286   Vector3 v4(4.9f, 5.1f, 10.0f);
 287   Vector3 min(1.0f, 4.0f, 1.5f);
 288   Vector3 max(9.0f, 6.0f, 8.0f);
 289
 290   v0.Clamp( min, max );
 291   v1.Clamp( min, max );
 292   v2.Clamp( min, max );
 293   v3.Clamp( min, max );
 294   v4.Clamp( min, max );
 295
 296   DALI_TEST_EQUALS( v0, Vector3(2.0f, 4.0f, 1.5f), 0.01f, TEST_LOCATION );
 297   DALI_TEST_EQUALS( v1, Vector3(1.0f, 4.0f, 8.0f), 0.01f, TEST_LOCATION );
 298   DALI_TEST_EQUALS( v2, Vector3(9.0f, 5.0f, 1.5f), 0.01f, TEST_LOCATION );
 299   DALI_TEST_EQUALS( v3, Vector3(8.0f, 6.0f, 5.0f), 0.01f, TEST_LOCATION );
 300   DALI_TEST_EQUALS( v4, Vector3(4.9f, 5.1f, 8.0f), 0.01f, TEST_LOCATION );
 301   END_TEST;
 302 }
 303
 304 // Multiply
 305 int UtcDaliVector3Multiply(void)
 306 {
 307   Vector3 v0(2.0f, 3.0f, 4.0f);
 308   Vector3 v1(10.0f, 20.0f,  30.0f);
 309   Vector3 r0(20.0f, 60.0f, 120.0f);
 310
 311   Vector3 v2 = v0 * v1;
 312   DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
 313
 314   v0 *= v1;
 315   DALI_TEST_EQUALS(v0, r0, TEST_LOCATION);
 316   END_TEST;
 317 }
 318
 319
 320 // Divide
 321 int UtcDaliVector3Divide(void)
 322 {
 323   Vector3 v0(1.0f, 1.0f, 1.0f);
 324   Vector3 v1(2.0f, 3.0f, 5.0f);
 325   Vector3 v2(4.0f, 9.0f, 25.0f);
 326
 327   DALI_TEST_EQUALS( v0/v0, v0, TEST_LOCATION);
 328   DALI_TEST_EQUALS( v1/v0, v1, TEST_LOCATION);
 329   DALI_TEST_EQUALS( v1/v1, v0, TEST_LOCATION);
 330   DALI_TEST_EQUALS( v2/v1, v1, TEST_LOCATION);
 331
 332   Vector3 v4(v0);
 333   v4 /= v0;
 334   DALI_TEST_EQUALS(v4, v0, TEST_LOCATION);
 335
 336   Vector3 v5(v1);
 337   v5 /= v0;
 338   DALI_TEST_EQUALS(v5, v1, TEST_LOCATION);
 339
 340   Vector3 v6(v1);
 341   v6 /= v6;
 342   DALI_TEST_EQUALS(v6, v0, TEST_LOCATION);
 343
 344   v2 /= v1;
 345   DALI_TEST_EQUALS(v2, v1, TEST_LOCATION);
 346
 347   END_TEST;
 348 }
 349
 350 int UtcDaliVector3Scale(void)
 351 {
 352   Vector3 v0(2.0f,   4.0f,  8.0f);
 353   const Vector3 r0(20.0f, 40.0f, 80.0f);
 354   const Vector3 r1(10.0f, 20.0f, 40.0f);
 355   const Vector3 r2( 1.0f,  2.0f,  4.0f);
 356   const Vector3 r3(2.0f,   4.0f,  8.0f);
 357
 358   Vector3 v2 = v0 * 10.0f;
 359   DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
 360
 361   v0 *= 5.0f;
 362   DALI_TEST_EQUALS(v0, r1, TEST_LOCATION);
 363
 364   v2 = r0 / 10.0f;
 365   DALI_TEST_EQUALS(v2, r3, TEST_LOCATION);
 366
 367   v2 = r1;
 368   v2 /= 10.0f;
 369   DALI_TEST_EQUALS(v2, r2, TEST_LOCATION);
 370   END_TEST;
 371 }
 372
 373
 374
 375 // Normalize
 376 int UtcDaliVector3Normalize(void)
 377 {
 378   for (float f=0.0f; f<6.0f; f+=1.0f)
 379   {
 380     Vector3 v(cosf(f)*10.0f, cosf(f+1.0f)*10.0f, cosf(f+2.0f)*10.0f);
 381     v.Normalize();
 382     DALI_TEST_EQUALS(v.LengthSquared(), 1.0f, 0.001f, TEST_LOCATION);
 383   }
 384
 385   Vector3 v(0.0f, 0.0f, 0.0f);
 386   v.Normalize();
 387   DALI_TEST_EQUALS(v.LengthSquared(), 0.0f, 0.00001f, TEST_LOCATION);
 388   END_TEST;
 389 }
 390
 391 // Subtract
 392 int UtcDaliVector3Subtract(void)
 393 {
 394   Vector3 v0(11.0f, 22.0f, 33.0f);
 395   Vector3 v1(10.0f, 20.0f, 30.0f);
 396   Vector3 r0(1.0f, 2.0f, 3.0f);
 397
 398   Vector3 v2 = v0-v1;
 399   DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
 400
 401   v0 -= v1;
 402   DALI_TEST_EQUALS(v0, r0, TEST_LOCATION);
 403   END_TEST;
 404 }
 405
 406 int UtcDaliVector3OperatorSubscript(void)
 407 {
 408   Vector3 testVector(1.0f, 2.0f, 3.0f);
 409
 410   // read array subscripts
 411   DALI_TEST_EQUALS( testVector[0], 1.0f, TEST_LOCATION );
 412   DALI_TEST_EQUALS( testVector[1], 2.0f, TEST_LOCATION );
 413   DALI_TEST_EQUALS( testVector[2], 3.0f, TEST_LOCATION );
 414
 415   // write array subscripts/read struct memebers
 416   testVector[0] = 4.0f;
 417   testVector[1] = 5.0f;
 418   testVector[2] = 6.0f;
 419
 420   DALI_TEST_EQUALS( testVector.x, 4.0f, TEST_LOCATION );
 421   DALI_TEST_EQUALS( testVector.y, 5.0f, TEST_LOCATION );
 422   DALI_TEST_EQUALS( testVector.z, 6.0f, TEST_LOCATION );
 423
 424   // write struct members/read array subscripts
 425   testVector.x = 7.0f;
 426   testVector.y = 8.0f;
 427   testVector.z = 9.0f;
 428
 429   DALI_TEST_EQUALS( testVector[0], 7.0f, TEST_LOCATION );
 430   DALI_TEST_EQUALS( testVector[1], 8.0f, TEST_LOCATION );
 431   DALI_TEST_EQUALS( testVector[2], 9.0f, TEST_LOCATION );
 432
 433   // write struct members/read array subscripts
 434   const Vector3 testVector2(1.0f, 2.0f, 3.0f);
 435   const float& x = testVector2[0];
 436   const float& y = testVector2[1];
 437   const float& z ( testVector2[2] );
 438
 439   DALI_TEST_EQUALS( x, 1.0f, TEST_LOCATION );
 440   DALI_TEST_EQUALS( y, 2.0f, TEST_LOCATION );
 441   DALI_TEST_EQUALS( z, 3.0f, TEST_LOCATION );
 442
 443   try
 444   {
 445     float& w = testVector[4];
 446     if(w==0.0f);
 447     tet_result(TET_FAIL);
 448   }
 449   catch (Dali::DaliException& e)
 450   {
 451     tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
 452     DALI_TEST_ASSERT( e, "index < 3", TEST_LOCATION );
 453   }
 454
 455   try
 456   {
 457     const float& w = testVector2[4];
 458     if(w==0.0f);
 459     tet_result(TET_FAIL);
 460   }
 461   catch (Dali::DaliException& e)
 462   {
 463     tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
 464     DALI_TEST_ASSERT(e, "index < 3", TEST_LOCATION);
 465   }
 466
 467   END_TEST;
 468 }
 469
 470 int UtcDaliVector3OStreamOperator(void)
 471 {
 472   std::ostringstream oss;
 473
 474   Vector3 vector(1, 2, 3);
 475
 476   oss << vector;
 477
 478   std::string expectedOutput = "[1, 2, 3]";
 479
 480   DALI_TEST_EQUALS( oss.str(), expectedOutput, TEST_LOCATION);
 481   END_TEST;
 482 }
 483
 484 int UtcDaliVector3Rotate(void)
 485 {
 486   TestApplication application;
 487
 488   Vector3 vec3(Vector3::YAXIS);
 489   Quaternion rotation(Math::PI_2, Vector3::ZAXIS);
 490   Vector3 result(-Vector3::XAXIS);
 491   vec3 *= rotation;
 492   DALI_TEST_EQUALS( vec3, result, 0.001, TEST_LOCATION );
 493   END_TEST;
 494 }
 495
 496 int UtcDaliVector3AsFloat(void)
 497 {
 498   float values[] = {0.0f,  1.0f,  2.0f};
 499   Vector3 v0(values);
 500
 501   for (int i=0;i<3;++i)
 502   {
 503     DALI_TEST_EQUALS(v0.AsFloat()[i], values[i], TEST_LOCATION);
 504   }
 505
 506   const Vector3 v1(values);
 507   for (int i=0;i<3;++i)
 508   {
 509     DALI_TEST_EQUALS(v1.AsFloat()[i], values[i], TEST_LOCATION);
 510   }
 511   END_TEST;
 512 }
 513
 514 int UtcDaliVector3AsVectorXY(void)
 515 {
 516   float values[] = {0.0f,  1.0f,  2.0f};
 517   Vector3 v0(values);
 518   const Vector3 v1(5.0f, 10.0f, 15.0f);
 519   // X = 0.0
 520   // Y = 1.0
 521   // Z = 2.0
 522
 523   DALI_TEST_EQUALS(v0.GetVectorXY().x, values[0], TEST_LOCATION);
 524   DALI_TEST_EQUALS(v0.GetVectorXY().y, values[1], TEST_LOCATION);
 525
 526   v0.GetVectorXY() = v1.GetVectorYZ();
 527   // X = y
 528   // Y = z
 529   // Z = 2.0
 530   DALI_TEST_EQUALS(v0.GetVectorXY().x, v1.y, TEST_LOCATION);
 531   DALI_TEST_EQUALS(v0.GetVectorXY().y, v1.z, TEST_LOCATION);
 532   DALI_TEST_EQUALS(v0.z, values[2], TEST_LOCATION);
 533
 534   v0.GetVectorYZ() = v1.GetVectorXY();
 535   // X = y
 536   // Y = x
 537   // Z = y
 538   DALI_TEST_EQUALS(v0.x, v1.y, TEST_LOCATION);
 539   DALI_TEST_EQUALS(v0.y, v1.x, TEST_LOCATION);
 540   DALI_TEST_EQUALS(v0.z, v1.y, TEST_LOCATION);
 541   END_TEST;
 542 }
 543
 544
 545 int UtcDaliVector3FitKeepAspectRatio(void)
 546 {
 547   TestApplication application;
 548   Vector3 target(10.0f, 20.0f, 30.0f);
 549   Vector3 source1(1.0f, 2.0f, 3.0f);
 550   Vector3 source2(1.0f, 1.0f, 1.0f);
 551
 552   DALI_TEST_EQUALS( FitKeepAspectRatio( target, target ), Vector3(1.0f, 1.0f, 1.0f), 0.001, TEST_LOCATION );
 553   DALI_TEST_EQUALS( FitKeepAspectRatio( target, source1 ), Vector3(10.0f, 10.0f, 10.0f), 0.001, TEST_LOCATION );
 554   DALI_TEST_EQUALS( FitKeepAspectRatio( target, source2 ), Vector3(10.0f, 10.0f, 10.0f), 0.001, TEST_LOCATION );
 555   DALI_TEST_EQUALS( FitKeepAspectRatio( source2, target ), Vector3(0.0333f, 0.0333f, 0.0333f), 0.001, TEST_LOCATION );
 556   END_TEST;
 557 }
 558
 559 int UtcDaliVector3FillKeepAspectRatio(void)
 560 {
 561   TestApplication application;
 562   Vector3 target(10.0f, 20.0f, 30.0f);
 563   Vector3 source1(1.0f, 2.0f, 3.0f);
 564   Vector3 source2(1.0f, 1.0f, 1.0f);
 565
 566   DALI_TEST_EQUALS( FillKeepAspectRatio( target, target ), Vector3(1.0f, 1.0f, 1.0f), 0.001, TEST_LOCATION );
 567   DALI_TEST_EQUALS( FillKeepAspectRatio( target, source1 ), Vector3(10.0f, 10.0f, 10.0f), 0.001, TEST_LOCATION );
 568   DALI_TEST_EQUALS( FillKeepAspectRatio( target, source2 ), Vector3(30.0f, 30.0f, 30.0f), 0.001, TEST_LOCATION );
 569   DALI_TEST_EQUALS( FillKeepAspectRatio( source2, target ), Vector3(0.1f, 0.1f, 0.1f), 0.001, TEST_LOCATION );
 570
 571   END_TEST;
 572 }
 573
 574 int UtcDaliVector3FillXYKeepAspectRatio(void)
 575 {
 576   TestApplication application;
 577   Vector3 target(10.0f, 20.0f, 30.0f);
 578   Vector3 source1(1.0f, 2.0f, 3.0f);
 579   Vector3 source2(1.0f, 1.0f, 1.0f);
 580
 581   DALI_TEST_EQUALS( FillXYKeepAspectRatio( target, target ), Vector3(1.0f, 1.0f, 1.0f), 0.001, TEST_LOCATION );
 582   DALI_TEST_EQUALS( FillXYKeepAspectRatio( target, source1 ), Vector3(10.0f, 10.0f, 10.0f), 0.001, TEST_LOCATION );
 583   DALI_TEST_EQUALS( FillXYKeepAspectRatio( target, source2 ), Vector3(20.0f, 20.0f, 20.0f), 0.001, TEST_LOCATION );
 584   DALI_TEST_EQUALS( FillXYKeepAspectRatio( source2, target ), Vector3(0.1f, 0.1f, 0.1f), 0.001, TEST_LOCATION );
 585
 586   END_TEST;
 587 }
 588
 589 int UtcDaliVector3ShrinkInsideKeepAspectRatio(void)
 590 {
 591   TestApplication application;
 592   Vector3 target(1.0f, 2.0f, 3.0f);
 593   Vector3 source1(10.0f, 20.0f, 30.0f);
 594   Vector3 source2(10.0f, 10.0f, 10.0f);
 595
 596   DALI_TEST_EQUALS( ShrinkInsideKeepAspectRatio( target, target ), Vector3(1.0f, 1.0f, 1.0f), 0.001, TEST_LOCATION );
 597   DALI_TEST_EQUALS( ShrinkInsideKeepAspectRatio( target, source1 ), Vector3(0.1f, 0.1f, 0.1f), 0.001, TEST_LOCATION );
 598   DALI_TEST_EQUALS( ShrinkInsideKeepAspectRatio( target, source2 ), Vector3(0.1f, 0.1f, 0.1f), 0.001, TEST_LOCATION );
 599   DALI_TEST_EQUALS( ShrinkInsideKeepAspectRatio( source2, target ), Vector3::ONE, 0.001, TEST_LOCATION );
 600   END_TEST;
 601 }