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

   1 /*
   2  * Copyright (c) 2020 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 <dali-test-suite-utils.h>
  19 #include <dali/public-api/dali-core.h>
  20 #include <stdlib.h>
  21
  22 #include <cmath> // isfinite
  23 #include <iostream>
  24 #include <sstream>
  25
  26 using namespace Dali;
  27
  28 void utc_dali_vector3_startup(void)
  29 {
  30   test_return_value = TET_UNDEF;
  31 }
  32
  33 void utc_dali_vector3_cleanup(void)
  34 {
  35   test_return_value = TET_PASS;
  36 }
  37
  38 int UtcDaliVector3Constructor01P(void)
  39 {
  40   TestApplication application;
  41   Vector3         va;
  42   DALI_TEST_EQUALS(va.x, 0.0f, 0.001f, TEST_LOCATION);
  43   DALI_TEST_EQUALS(va.y, 0.0f, 0.001f, TEST_LOCATION);
  44   DALI_TEST_EQUALS(va.z, 0.0f, 0.001f, TEST_LOCATION);
  45   END_TEST;
  46 }
  47
  48 int UtcDaliVector3Constructor02P(void)
  49 {
  50   TestApplication application;
  51   Vector3         va(1.f, 1.f, 1.f);
  52   DALI_TEST_EQUALS(va.x, 1.0f, 0.001f, TEST_LOCATION);
  53   DALI_TEST_EQUALS(va.y, 1.0f, 0.001f, TEST_LOCATION);
  54   DALI_TEST_EQUALS(va.z, 1.0f, 0.001f, TEST_LOCATION);
  55   END_TEST;
  56 }
  57
  58 int UtcDaliVector3Constructor03P(void)
  59 {
  60   TestApplication application;
  61   float           array[] = {1.f, 1.f, 1.f};
  62   Vector3         va(array);
  63   DALI_TEST_EQUALS(va.x, 1.0f, 0.001f, TEST_LOCATION);
  64   DALI_TEST_EQUALS(va.y, 1.0f, 0.001f, TEST_LOCATION);
  65   DALI_TEST_EQUALS(va.z, 1.0f, 0.001f, TEST_LOCATION);
  66   END_TEST;
  67 }
  68
  69 int UtcDaliVector3Constructor04P(void)
  70 {
  71   TestApplication application;
  72   Vector2         vec2(1.f, 1.f);
  73   Vector3         va(vec2);
  74   DALI_TEST_EQUALS(va.x, 1.0f, 0.001f, TEST_LOCATION);
  75   DALI_TEST_EQUALS(va.y, 1.0f, 0.001f, TEST_LOCATION);
  76   DALI_TEST_EQUALS(va.z, 0.0f, 0.001f, TEST_LOCATION);
  77   END_TEST;
  78 }
  79
  80 int UtcDaliVector3Constructor05P(void)
  81 {
  82   TestApplication application;
  83   Vector4         vec4(1.f, 1.f, 1.f, 1.f);
  84   Vector3         va(vec4);
  85   DALI_TEST_EQUALS(va.x, 1.0f, 0.001f, TEST_LOCATION);
  86   DALI_TEST_EQUALS(va.y, 1.0f, 0.001f, TEST_LOCATION);
  87   DALI_TEST_EQUALS(va.z, 1.0f, 0.001f, TEST_LOCATION);
  88   END_TEST;
  89 }
  90
  91 int UtcDaliVector3CopyConstructor(void)
  92 {
  93   TestApplication application;
  94   Vector3         vec0(10.f, 20.f, 30.0f);
  95   Vector3         vec1(vec0);
  96   DALI_TEST_EQUALS(vec1.x, 10.0f, 0.001, TEST_LOCATION);
  97   DALI_TEST_EQUALS(vec1.y, 20.0f, 0.001, TEST_LOCATION);
  98   DALI_TEST_EQUALS(vec1.z, 30.0f, 0.001, TEST_LOCATION);
  99   END_TEST;
 100 }
 101
 102 int UtcDaliVector3MoveConstructor(void)
 103 {
 104   TestApplication application;
 105   Vector3         vec0(10.f, 20.f, 30.0f);
 106   Vector3         vec1 = std::move(vec0);
 107   DALI_TEST_EQUALS(vec1.x, 10.0f, 0.001, TEST_LOCATION);
 108   DALI_TEST_EQUALS(vec1.y, 20.0f, 0.001, TEST_LOCATION);
 109   DALI_TEST_EQUALS(vec1.z, 30.0f, 0.001, TEST_LOCATION);
 110
 111   END_TEST;
 112 }
 113
 114 int UtcDaliVector3CopyAssignment(void)
 115 {
 116   TestApplication application;
 117   Vector3         vec0(10.f, 20.f, 30.0f);
 118   Vector3         vec1;
 119   vec1 = vec0;
 120   DALI_TEST_EQUALS(vec1.x, 10.0f, 0.001, TEST_LOCATION);
 121   DALI_TEST_EQUALS(vec1.y, 20.0f, 0.001, TEST_LOCATION);
 122   DALI_TEST_EQUALS(vec1.z, 30.0f, 0.001, TEST_LOCATION);
 123
 124   END_TEST;
 125 }
 126
 127 int UtcDaliVector3MoveAssignment(void)
 128 {
 129   TestApplication application;
 130   Vector3         vec0(10.f, 20.f, 30.0f);
 131   Vector3         vec1;
 132   vec1 = std::move(vec0);
 133   DALI_TEST_EQUALS(vec1.x, 10.0f, 0.001, TEST_LOCATION);
 134   DALI_TEST_EQUALS(vec1.y, 20.0f, 0.001, TEST_LOCATION);
 135   DALI_TEST_EQUALS(vec1.z, 30.0f, 0.001, TEST_LOCATION);
 136
 137   END_TEST;
 138 }
 139
 140 int UtcDaliVector3Assign01P(void)
 141 {
 142   TestApplication application;
 143   Vector3         v0;
 144   const float     array[] = {1.0f, 2.0f, 3.0f};
 145   v0                      = (const float*)array;
 146
 147   DALI_TEST_EQUALS(v0.x, 1.0f, 0.001f, TEST_LOCATION);
 148   DALI_TEST_EQUALS(v0.y, 2.0f, 0.001f, TEST_LOCATION);
 149   DALI_TEST_EQUALS(v0.z, 3.0f, 0.001f, TEST_LOCATION);
 150   END_TEST;
 151 }
 152
 153 int UtcDaliVector3Assign02P(void)
 154 {
 155   TestApplication application;
 156   Vector2         vec2_q(1.0f, 2.0f);
 157   Vector3         vec3a;
 158   vec3a = vec2_q;
 159
 160   DALI_TEST_EQUALS(vec3a.x, 1.0f, 0.001f, TEST_LOCATION);
 161   DALI_TEST_EQUALS(vec3a.y, 2.0f, 0.001f, TEST_LOCATION);
 162   DALI_TEST_EQUALS(vec3a.z, 0.0f, 0.001f, TEST_LOCATION);
 163   END_TEST;
 164 }
 165
 166 int UtcDaliVector3Assign03P(void)
 167 {
 168   TestApplication application;
 169   Vector4         vec4_q(4.0f, 3.0f, 2.0f, 1.0f);
 170   Vector3         vec3b;
 171   vec3b = vec4_q;
 172
 173   DALI_TEST_EQUALS(vec3b.x, 4.0f, 0.001f, TEST_LOCATION);
 174   DALI_TEST_EQUALS(vec3b.y, 3.0f, 0.001f, TEST_LOCATION);
 175   DALI_TEST_EQUALS(vec3b.z, 2.0f, 0.001f, TEST_LOCATION);
 176   END_TEST;
 177 }
 178
 179 int UtcDaliVector3Add01P(void)
 180 {
 181   TestApplication application;
 182   Vector3         v0(1.0f, 2.0f, 3.0f);
 183   Vector3         v1(10.0f, 20.0f, 30.0f);
 184   Vector3         r0(11.0f, 22.0f, 33.0f);
 185
 186   Vector3 v2 = v0 + v1;
 187   DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
 188
 189   END_TEST;
 190 }
 191
 192 int UtcDaliVector3Add02P(void)
 193 {
 194   TestApplication application;
 195   Vector3         v0(1.0f, 2.0f, 3.0f);
 196   Vector3         v1(10.0f, 20.0f, 30.0f);
 197   Vector3         r0(11.0f, 22.0f, 33.0f);
 198
 199   v0 += v1;
 200   DALI_TEST_EQUALS(v0, r0, TEST_LOCATION);
 201
 202   END_TEST;
 203 }
 204
 205 int UtcDaliVector3Subtract01P(void)
 206 {
 207   TestApplication application;
 208   Vector3         v0(11.0f, 22.0f, 33.0f);
 209   Vector3         v1(10.0f, 20.0f, 30.0f);
 210   Vector3         r0(1.0f, 2.0f, 3.0f);
 211
 212   Vector3 v2 = v0 - v1;
 213   DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
 214
 215   END_TEST;
 216 }
 217
 218 int UtcDaliVector3Subtract02P(void)
 219 {
 220   TestApplication application;
 221   Vector3         v0(11.0f, 22.0f, 33.0f);
 222   Vector3         v1(10.0f, 20.0f, 30.0f);
 223   Vector3         r0(1.0f, 2.0f, 3.0f);
 224
 225   v0 -= v1;
 226   DALI_TEST_EQUALS(v0, r0, TEST_LOCATION);
 227   END_TEST;
 228 }
 229
 230 int UtcDaliVector3Multiply01P(void)
 231 {
 232   TestApplication application;
 233   Vector3         v0(2.0f, 3.0f, 4.0f);
 234   Vector3         v1(10.0f, 20.0f, 30.0f);
 235   Vector3         r0(20.0f, 60.0f, 120.0f);
 236
 237   Vector3 v2 = v0 * v1;
 238   DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
 239   END_TEST;
 240 }
 241
 242 int UtcDaliVector3Multiply02P(void)
 243 {
 244   TestApplication application;
 245   Vector3         v0(2.0f, 3.0f, 4.0f);
 246   Vector3         r0(20.0f, 30.0f, 40.0f);
 247   Vector3         v2 = v0 * 10.f;
 248   DALI_TEST_EQUALS(v2, r0, 0.001, TEST_LOCATION);
 249   END_TEST;
 250 }
 251
 252 int UtcDaliVector3Multiply03P(void)
 253 {
 254   TestApplication application;
 255   Vector3         v0(2.0f, 3.0f, 4.0f);
 256   Vector3         v1(10.0f, 20.0f, 30.0f);
 257   Vector3         r0(20.0f, 60.0f, 120.0f);
 258   v0 *= v1;
 259   DALI_TEST_EQUALS(v0, r0, 0.001, TEST_LOCATION);
 260   END_TEST;
 261 }
 262
 263 int UtcDaliVector3Multiply04P(void)
 264 {
 265   TestApplication application;
 266   Vector3         v0(2.0f, 3.0f, 4.0f);
 267   Vector3         r0(20.0f, 30.0f, 40.0f);
 268   v0 *= 10.f;
 269   DALI_TEST_EQUALS(v0, r0, TEST_LOCATION);
 270   END_TEST;
 271 }
 272
 273 int UtcDaliVector3Multiply05P(void)
 274 {
 275   TestApplication application;
 276   Vector3         vec3(Vector3::YAXIS);
 277   Quaternion      rotation(Radian(Math::PI_2), Vector3::ZAXIS);
 278   Vector3         result(-Vector3::XAXIS);
 279   vec3 *= rotation;
 280   DALI_TEST_EQUALS(vec3, result, 0.001, TEST_LOCATION);
 281   END_TEST;
 282 }
 283
 284 int UtcDaliVector3Divide01P(void)
 285 {
 286   TestApplication application;
 287   Vector3         v0(1.0f, 1.0f, 1.0f);
 288   Vector3         v1(2.0f, 3.0f, 5.0f);
 289   Vector3         v2(4.0f, 9.0f, 25.0f);
 290
 291   DALI_TEST_EQUALS(v0 / v0, v0, TEST_LOCATION);
 292   DALI_TEST_EQUALS(v1 / v0, v1, TEST_LOCATION);
 293   DALI_TEST_EQUALS(v1 / v1, v0, TEST_LOCATION);
 294   DALI_TEST_EQUALS(v2 / v1, v1, TEST_LOCATION);
 295
 296   END_TEST;
 297 }
 298
 299 int UtcDaliVector3Divide02P(void)
 300 {
 301   TestApplication application;
 302   Vector3         v0(3.0f, 6.0f, 9.0f);
 303   Vector3         v1(1.0f, 2.0f, 3.0f);
 304   Vector3         r(3.0f, 3.0f, 3.0f);
 305   Vector3         v2 = v0 / v1;
 306   DALI_TEST_EQUALS(v2, r, TEST_LOCATION);
 307   END_TEST;
 308 }
 309
 310 int UtcDaliVector3Divide03P(void)
 311 {
 312   TestApplication application;
 313   Vector3         v0(3.0f, 6.0f, 9.0f);
 314   Vector3         v1(1.0f, 2.0f, 3.0f);
 315   Vector3         v2 = v0 / 3.f;
 316   DALI_TEST_EQUALS(v2, v1, TEST_LOCATION);
 317   END_TEST;
 318 }
 319
 320 int UtcDaliVector3Divide04P(void)
 321 {
 322   TestApplication application;
 323   Vector3         v0(3.0f, 6.0f, 9.0f);
 324   Vector3         v1(1.0f, 1.0f, 1.0f);
 325   Vector3         v4(v0);
 326   v4 /= v0;
 327   DALI_TEST_EQUALS(v4, v1, TEST_LOCATION);
 328   END_TEST;
 329 }
 330
 331 int UtcDaliVector3Divide05P(void)
 332 {
 333   TestApplication application;
 334   Vector3         v0(3.0f, 6.0f, 9.0f);
 335   Vector3         v1(1.0f, 2.0f, 3.0f);
 336   Vector3         v4(v0);
 337   v4 /= 3.f;
 338   DALI_TEST_EQUALS(v4, v1, TEST_LOCATION);
 339   END_TEST;
 340 }
 341
 342 int UtcDaliVector3NegateP(void)
 343 {
 344   TestApplication application;
 345   Vector3         v1(10.0f, 20.0f, 30.f);
 346   Vector3         r0(-10.0f, -20.0f, -30.f);
 347
 348   Vector3 v2 = -v1;
 349   DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
 350   END_TEST;
 351 }
 352
 353 int UtcDaliVector3EqualsP(void)
 354 {
 355   TestApplication application;
 356   Vector3         v0(1.0f, 2.0f, 3.0f);
 357   Vector3         v1(1.0f, 2.0f, 3.0f);
 358
 359   DALI_TEST_CHECK(v0 == v1);
 360   END_TEST;
 361 }
 362
 363 int UtcDaliVector3NotEqualsP(void)
 364 {
 365   TestApplication application;
 366   Vector3         v0(1.0f, 2.0f, 3.0f);
 367   Vector3         v1(1.0f, 2.0f, 3.0f);
 368   Vector3         v2 = Vector3(0.0f, 2.0f, 3.0f);
 369   DALI_TEST_CHECK(v0 != v2);
 370
 371   v2 = Vector3(1.0f, 0.0f, 3.0f);
 372   DALI_TEST_CHECK(v0 != v2);
 373
 374   v2 = Vector3(1.0f, 2.0f, 0.0f);
 375   DALI_TEST_CHECK(v0 != v2);
 376
 377   v2 = Vector3(11.0f, 22.0f, 33.0f);
 378   DALI_TEST_CHECK(v0 != v2);
 379   END_TEST;
 380 }
 381
 382 int UtcDaliVector3OperatorSubscriptP(void)
 383 {
 384   TestApplication application;
 385   Vector3         testVector(1.0f, 2.0f, 3.0f);
 386
 387   // read array subscripts
 388   DALI_TEST_EQUALS(testVector[0], 1.0f, TEST_LOCATION);
 389   DALI_TEST_EQUALS(testVector[1], 2.0f, TEST_LOCATION);
 390   DALI_TEST_EQUALS(testVector[2], 3.0f, TEST_LOCATION);
 391
 392   // write array subscripts/read struct memebers
 393   testVector[0] = 4.0f;
 394   testVector[1] = 5.0f;
 395   testVector[2] = 6.0f;
 396
 397   DALI_TEST_EQUALS(testVector.x, 4.0f, TEST_LOCATION);
 398   DALI_TEST_EQUALS(testVector.y, 5.0f, TEST_LOCATION);
 399   DALI_TEST_EQUALS(testVector.z, 6.0f, TEST_LOCATION);
 400
 401   // write struct members/read array subscripts
 402   testVector.x = 7.0f;
 403   testVector.y = 8.0f;
 404   testVector.z = 9.0f;
 405
 406   DALI_TEST_EQUALS(testVector[0], 7.0f, TEST_LOCATION);
 407   DALI_TEST_EQUALS(testVector[1], 8.0f, TEST_LOCATION);
 408   DALI_TEST_EQUALS(testVector[2], 9.0f, TEST_LOCATION);
 409   END_TEST;
 410 }
 411
 412 int UtcDaliVector3ConstOperatorSubscriptP(void)
 413 {
 414   TestApplication application;
 415   Vector3         testVector(1.0f, 2.0f, 3.0f);
 416
 417   // write struct members/read array subscripts
 418   const Vector3 testVector2(1.0f, 2.0f, 3.0f);
 419   const float&  x = testVector2[0];
 420   const float&  y = testVector2[1];
 421   const float&  z(testVector2[2]);
 422
 423   DALI_TEST_EQUALS(x, 1.0f, TEST_LOCATION);
 424   DALI_TEST_EQUALS(y, 2.0f, TEST_LOCATION);
 425   DALI_TEST_EQUALS(z, 3.0f, TEST_LOCATION);
 426
 427   try
 428   {
 429     float& w = testVector[4];
 430     (void)w; // Suppress unused variable warning
 431     tet_result(TET_FAIL);
 432   }
 433   catch(Dali::DaliException& e)
 434   {
 435     DALI_TEST_PRINT_ASSERT(e);
 436     DALI_TEST_ASSERT(e, "index < 3", TEST_LOCATION);
 437   }
 438
 439   try
 440   {
 441     const float& w = testVector2[4];
 442     (void)w; // Suppress unused variable warning
 443     tet_result(TET_FAIL);
 444   }
 445   catch(Dali::DaliException& e)
 446   {
 447     DALI_TEST_PRINT_ASSERT(e);
 448     DALI_TEST_ASSERT(e, "index < 3", TEST_LOCATION);
 449   }
 450
 451   END_TEST;
 452 }
 453
 454 int UtcDaliVector3DotP(void)
 455 {
 456   TestApplication application;
 457   DALI_TEST_EQUALS(Vector3::XAXIS.Dot(Vector3::YAXIS), 0.0f, TEST_LOCATION);
 458   DALI_TEST_EQUALS(Vector3::XAXIS.Dot(Vector3::ZAXIS), 0.0f, TEST_LOCATION);
 459   DALI_TEST_EQUALS(Vector3::XAXIS.Dot(Vector3::XAXIS), 1.0f, TEST_LOCATION);
 460   DALI_TEST_EQUALS(Vector3::YAXIS.Dot(Vector3::YAXIS), 1.0f, TEST_LOCATION);
 461   DALI_TEST_EQUALS(Vector3::ZAXIS.Dot(Vector3::ZAXIS), 1.0f, TEST_LOCATION);
 462
 463   DALI_TEST_EQUALS(Vector3(1.0f, 0.0f, 0.0f).Dot(Vector3(1.0f, 0.0f, 0.0f)), 1.0f, TEST_LOCATION);
 464
 465   for(float x = 0; x < 6.0f; x += 1.0f)
 466   {
 467     Vector3 v0(cosf(x), sinf(x), 0.0f);
 468     Vector3 v1(sinf(x), -cosf(x), 0.0f);
 469     DALI_TEST_EQUALS(v0.Dot(v1), 0.0f, 0.0001f, TEST_LOCATION);
 470     DALI_TEST_EQUALS(v0.Dot(v0), 1.0f, 0.0001f, TEST_LOCATION);
 471
 472     v0 = Vector3(cosf(x), 0.0f, sinf(x));
 473     v1 = Vector3(sinf(x), 0.0f, -cosf(x));
 474     DALI_TEST_EQUALS(v0.Dot(v0), 1.0f, 0.0001f, TEST_LOCATION);
 475   }
 476
 477   Vector3 v0 = Vector3(12.0f, 7.0f, 9.0f);
 478   v0.Normalize();
 479
 480   Vector3 v1 = v0 * 2.0f;
 481   DALI_TEST_EQUALS(v0.Dot(v1), 2.0f, 0.001f, TEST_LOCATION);
 482   END_TEST;
 483 }
 484
 485 int UtcDaliVector3CrossP(void)
 486 {
 487   TestApplication application;
 488   DALI_TEST_EQUALS(Vector3::XAXIS.Cross(Vector3::YAXIS), Vector3::ZAXIS, 0.0001f, TEST_LOCATION);
 489   DALI_TEST_EQUALS(Vector3::YAXIS.Cross(Vector3::ZAXIS), Vector3::XAXIS, 0.0001f, TEST_LOCATION);
 490   DALI_TEST_EQUALS(Vector3::ZAXIS.Cross(Vector3::XAXIS), Vector3::YAXIS, 0.0001f, TEST_LOCATION);
 491
 492   DALI_TEST_EQUALS(Vector3::XAXIS.Cross(Vector3::ZAXIS), -Vector3::YAXIS, 0.0001f, TEST_LOCATION);
 493   DALI_TEST_EQUALS(Vector3::YAXIS.Cross(Vector3::XAXIS), -Vector3::ZAXIS, 0.0001f, TEST_LOCATION);
 494   DALI_TEST_EQUALS(Vector3::ZAXIS.Cross(Vector3::YAXIS), -Vector3::XAXIS, 0.0001f, TEST_LOCATION);
 495
 496   Vector3 v0(2.0f, 3.0f, 4.0f);
 497   Vector3 v1(10.0f, 20.0f, 30.0f);
 498   Vector3 result((v0.y * v1.z) - (v0.z * v1.y),
 499                  (v0.z * v1.x) - (v0.x * v1.z),
 500                  (v0.x * v1.y) - (v0.y * v1.x));
 501
 502   DALI_TEST_EQUALS(v0.Cross(v1), result, 0.001f, TEST_LOCATION);
 503   END_TEST;
 504 }
 505
 506 int UtcDaliVector3LengthP(void)
 507 {
 508   TestApplication application;
 509   Vector3         v(1.0f, 2.0f, 3.0f);
 510   DALI_TEST_EQUALS(v.Length(), sqrtf(v.x * v.x + v.y * v.y + v.z * v.z), 0.001f, TEST_LOCATION);
 511
 512   Vector3 v1(0.0f, 0.0f, 0.0f);
 513   DALI_TEST_EQUALS(v1.Length(), 0.0f, TEST_LOCATION);
 514   END_TEST;
 515 }
 516
 517 int UtcDaliVector3LengthSquaredP(void)
 518 {
 519   TestApplication application;
 520   Vector3         v(1.0f, 2.0f, 3.0f);
 521   DALI_TEST_EQUALS(v.LengthSquared(), v.x * v.x + v.y * v.y + v.z * v.z, 0.001f, TEST_LOCATION);
 522
 523   Vector3 v1(0.0f, 0.0f, 0.0f);
 524   DALI_TEST_EQUALS(v1.LengthSquared(), 0.0f, TEST_LOCATION);
 525   END_TEST;
 526 }
 527
 528 int UtcDaliVector3NormalizeP(void)
 529 {
 530   TestApplication application;
 531   for(float f = 0.0f; f < 6.0f; f += 1.0f)
 532   {
 533     Vector3 v(cosf(f) * 10.0f, cosf(f + 1.0f) * 10.0f, cosf(f + 2.0f) * 10.0f);
 534     v.Normalize();
 535     DALI_TEST_EQUALS(v.LengthSquared(), 1.0f, 0.001f, TEST_LOCATION);
 536   }
 537
 538   Vector3 v(0.0f, 0.0f, 0.0f);
 539   v.Normalize();
 540   DALI_TEST_EQUALS(v.LengthSquared(), 0.0f, 0.00001f, TEST_LOCATION);
 541   END_TEST;
 542 }
 543
 544 int UtcDaliVector3ClampVector3P(void)
 545 {
 546   TestApplication application;
 547
 548   Vector3 v0(2.0f, 0.8f, 0.0f);
 549   Vector3 v1(-1.0f, 2.0f, 10.0f);
 550   Vector3 v2(10.0f, 5.0f, 0.0f);
 551   Vector3 v3(8.0f, 10.0f, 5.0f);
 552   Vector3 v4(4.9f, 5.1f, 10.0f);
 553   Vector3 min(1.0f, 4.0f, 1.5f);
 554   Vector3 max(9.0f, 6.0f, 8.0f);
 555
 556   v0.Clamp(min, max);
 557   v1.Clamp(min, max);
 558   v2.Clamp(min, max);
 559   v3.Clamp(min, max);
 560   v4.Clamp(min, max);
 561
 562   DALI_TEST_EQUALS(v0, Vector3(2.0f, 4.0f, 1.5f), 0.01f, TEST_LOCATION);
 563   DALI_TEST_EQUALS(v1, Vector3(1.0f, 4.0f, 8.0f), 0.01f, TEST_LOCATION);
 564   DALI_TEST_EQUALS(v2, Vector3(9.0f, 5.0f, 1.5f), 0.01f, TEST_LOCATION);
 565   DALI_TEST_EQUALS(v3, Vector3(8.0f, 6.0f, 5.0f), 0.01f, TEST_LOCATION);
 566   DALI_TEST_EQUALS(v4, Vector3(4.9f, 5.1f, 8.0f), 0.01f, TEST_LOCATION);
 567   END_TEST;
 568 }
 569
 570 int UtcDaliVector3AsFloatP(void)
 571 {
 572   TestApplication application;
 573   float           values[] = {0.0f, 1.0f, 2.0f};
 574   Vector3         v0(values);
 575
 576   for(int i = 0; i < 3; ++i)
 577   {
 578     DALI_TEST_EQUALS(v0.AsFloat()[i], values[i], TEST_LOCATION);
 579   }
 580
 581   END_TEST;
 582 }
 583
 584 int UtcDaliVector3ConstAsFloatP(void)
 585 {
 586   TestApplication application;
 587   float           values[] = {0.0f, 1.0f, 2.0f};
 588   Vector3         v0(values);
 589
 590   const Vector3 v1(values);
 591   for(int i = 0; i < 3; ++i)
 592   {
 593     DALI_TEST_EQUALS(v1.AsFloat()[i], values[i], TEST_LOCATION);
 594   }
 595   END_TEST;
 596 }
 597
 598 int UtcDaliVector3ConstAsVectorXYP(void)
 599 {
 600   TestApplication application;
 601   float           values[] = {0.0f, 1.0f, 2.0f};
 602   const Vector3   v0(values);
 603   DALI_TEST_EQUALS(v0.GetVectorXY().x, values[0], TEST_LOCATION);
 604   DALI_TEST_EQUALS(v0.GetVectorXY().y, values[1], TEST_LOCATION);
 605   END_TEST;
 606 }
 607
 608 int UtcDaliVector3AsVectorXYP(void)
 609 {
 610   TestApplication application;
 611   float           values[] = {0.0f, 1.0f, 2.0f};
 612   Vector3         v0(values);
 613
 614   DALI_TEST_EQUALS(v0.GetVectorXY().x, values[0], TEST_LOCATION);
 615   DALI_TEST_EQUALS(v0.GetVectorXY().y, values[1], TEST_LOCATION);
 616   END_TEST;
 617 }
 618
 619 int UtcDaliVector3ConstAsVectorXZP(void)
 620 {
 621   TestApplication application;
 622   float           values[] = {0.0f, 1.0f, 2.0f};
 623   const Vector3   v0(values);
 624
 625   DALI_TEST_EQUALS(v0.GetVectorYZ().x, values[1], TEST_LOCATION);
 626   DALI_TEST_EQUALS(v0.GetVectorYZ().y, values[2], TEST_LOCATION);
 627   END_TEST;
 628 }
 629
 630 int UtcDaliVector3AsVectorXZP(void)
 631 {
 632   TestApplication application;
 633   float           values[] = {0.0f, 1.0f, 2.0f};
 634   Vector3         v0(values);
 635
 636   DALI_TEST_EQUALS(v0.GetVectorYZ().x, values[1], TEST_LOCATION);
 637   DALI_TEST_EQUALS(v0.GetVectorYZ().y, values[2], TEST_LOCATION);
 638   END_TEST;
 639 }
 640
 641 int UtcDaliVector3OStreamOperatorP(void)
 642 {
 643   TestApplication    application;
 644   std::ostringstream oss;
 645
 646   Vector3 vector(1, 2, 3);
 647
 648   oss << vector;
 649
 650   std::string expectedOutput = "[1, 2, 3]";
 651
 652   DALI_TEST_EQUALS(oss.str(), expectedOutput, TEST_LOCATION);
 653   END_TEST;
 654 }
 655
 656 int UtcDaliVector3MinP(void)
 657 {
 658   TestApplication application;
 659   Vector3         v0(2.0f, 2.0f, 1.0f);
 660   Vector3         v1(1.0f, 1.0f, 2.0f);
 661
 662   DALI_TEST_EQUALS(Min(v0, v1), Vector3(1.0f, 1.0f, 1.0f), 0.01f, TEST_LOCATION);
 663   END_TEST;
 664 }
 665
 666 int UtcDaliVector3MaxP(void)
 667 {
 668   TestApplication application;
 669   Vector3         v0(2.0f, 1.0f, 3.0f);
 670   Vector3         v1(1.0f, 2.0f, 3.0f);
 671
 672   DALI_TEST_EQUALS(Max(v0, v1), Vector3(2.0f, 2.0f, 3.0f), 0.01f, TEST_LOCATION);
 673   END_TEST;
 674 }
 675
 676 int UtcDaliVector3ClampP(void)
 677 {
 678   TestApplication application;
 679   Vector3         v0(2.0f, 1.0f, 0.0f);
 680   Vector3         v1(-1.0f, 2.0f, 1.0f);
 681
 682   DALI_TEST_EQUALS(Clamp(v0, 0.9f, 1.1f), Vector3(1.1f, 1.0f, 0.9f), 0.01f, TEST_LOCATION);
 683   DALI_TEST_EQUALS(Clamp(v1, 1.0f, 1.0f), Vector3(1.0f, 1.0f, 1.0f), 0.01f, TEST_LOCATION);
 684   END_TEST;
 685 }
 686
 687 int UtcDaliVector3ConstantsP(void)
 688 {
 689   TestApplication application;
 690   Vector3         va = Vector3::ZERO;
 691   Vector3         vb = Vector3::ONE;
 692   Vector3         vc = Vector3::XAXIS;
 693
 694   DALI_TEST_EQUALS(va.x, 0.0f, 0.001f, TEST_LOCATION);
 695   DALI_TEST_EQUALS(va.y, 0.0f, 0.001f, TEST_LOCATION);
 696   DALI_TEST_EQUALS(va.z, 0.0f, 0.001f, TEST_LOCATION);
 697
 698   DALI_TEST_EQUALS(vb.x, 1.0f, 0.001f, TEST_LOCATION);
 699   DALI_TEST_EQUALS(vb.y, 1.0f, 0.001f, TEST_LOCATION);
 700   DALI_TEST_EQUALS(vb.z, 1.0f, 0.001f, TEST_LOCATION);
 701
 702   DALI_TEST_EQUALS(vc.x, 1.0f, 0.001f, TEST_LOCATION);
 703   DALI_TEST_EQUALS(vc.y, 0.0f, 0.001f, TEST_LOCATION);
 704   DALI_TEST_EQUALS(vc.z, 0.0f, 0.001f, TEST_LOCATION);
 705   END_TEST;
 706 }