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

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