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