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 <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_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
 286   END_TEST;
 287 }
 288
 289 int UtcDaliVector4Divide02P(void)
 290 {
 291   Vector4 v0(2.0f,   4.0f,  8.0f,  16.0f);
 292   const Vector4 r0(20.0f, 40.0f, 80.0f, 160.0f);
 293   const Vector4 r1(10.0f, 20.0f, 40.0f,  80.0f);
 294   const Vector4 r2( 1.0f,  2.0f,  4.0f,   8.0f);
 295   const Vector4 r3(2.0f,   4.0f,  8.0f,  16.0f);
 296
 297   Vector4 v2 = r0 / 10.0f;
 298   DALI_TEST_EQUALS(v2, r3, TEST_LOCATION);
 299
 300   END_TEST;
 301 }
 302
 303 int UtcDaliVector4Divide03P(void)
 304 {
 305   Vector4 v0(1.0f, 1.0f, 1.0f, 1.0f);
 306   Vector4 v1(2.0f, 3.0f, 5.0f, 7.0f);
 307   Vector4 v2(4.0f, 9.0f, 25.0f, 49.0f);
 308
 309   Vector4 v4(v0);
 310   v4 /= v0;
 311   DALI_TEST_EQUALS(v4, v0, TEST_LOCATION);
 312
 313   Vector4 v5(v1);
 314   v5 /= v0;
 315   DALI_TEST_EQUALS(v5, v1, TEST_LOCATION);
 316
 317   Vector4 v6(v1);
 318   v6 /= v6;
 319   DALI_TEST_EQUALS(v6, v0, TEST_LOCATION);
 320
 321   v2 /= v1;
 322   DALI_TEST_EQUALS(v2, v1, TEST_LOCATION);
 323
 324   END_TEST;
 325 }
 326
 327 int UtcDaliVector4Divide04P(void)
 328 {
 329   Vector4 v0(2.0f,   4.0f,  8.0f,  16.0f);
 330   const Vector4 r0(20.0f, 40.0f, 80.0f, 160.0f);
 331   const Vector4 r1(10.0f, 20.0f, 40.0f,  80.0f);
 332   const Vector4 r2( 1.0f,  2.0f,  4.0f,   8.0f);
 333   const Vector4 r3(2.0f,   4.0f,  8.0f,  16.0f);
 334
 335   Vector4 v2(r0);
 336   v2 /= 10.0f;
 337   DALI_TEST_EQUALS(v2, r3, TEST_LOCATION);
 338
 339   END_TEST;
 340 }
 341
 342 int UtcDaliVector4NegateP(void)
 343 {
 344   TestApplication application;
 345   Vector4 v1(10.0f, 20.0f, 30.f, 40.f);
 346   Vector4 r0(-10.0f, -20.0f, -30.f, -40.f);
 347
 348   Vector4 v2 = -v1;
 349   DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
 350   END_TEST;
 351 }
 352
 353 int UtcDaliVector4EqualsP(void)
 354 {
 355   Vector4 v0(1.0f, 2.0f,  3.0f, 4.0f);
 356   Vector4 v1(1.0f, 2.0f,  3.0f, 4.0f);
 357
 358   DALI_TEST_CHECK(v0 == v1);
 359   END_TEST;
 360 }
 361
 362 int UtcDaliVector4NotEqualsP(void)
 363 {
 364   Vector4 v0(1.0f, 2.0f,  3.0f, 4.0f);
 365   Vector4 v1(1.0f, 2.0f,  3.0f, 4.0f);
 366
 367   Vector4 v2 = Vector4(0.0f, 2.0f, 3.0f, 4.0f);
 368   DALI_TEST_CHECK(v0 != v2);
 369
 370   v2 = Vector4(1.0f, 0.0f, 3.0f, 4.0f);
 371   DALI_TEST_CHECK(v0 != v2);
 372
 373   v2 = Vector4(1.0f, 2.0f, 0.0f, 4.0f);
 374   DALI_TEST_CHECK(v0 != v2);
 375
 376   v2 = Vector4(1.0f, 2.0f, 3.0f, 0.0f);
 377   DALI_TEST_CHECK(v0 != v2);
 378   END_TEST;
 379 }
 380
 381 int UtcDaliVector4OperatorSubscriptP(void)
 382 {
 383   Vector4 testVector(1.0f, 2.0f, 3.0f, 4.0f);
 384
 385   // read array subscripts
 386   DALI_TEST_EQUALS( testVector[0], 1.0f, TEST_LOCATION );
 387   DALI_TEST_EQUALS( testVector[1], 2.0f, TEST_LOCATION );
 388   DALI_TEST_EQUALS( testVector[2], 3.0f, TEST_LOCATION );
 389   DALI_TEST_EQUALS( testVector[3], 4.0f, TEST_LOCATION );
 390
 391   // write array subscripts/read struct memebers
 392   testVector[0] = 5.0f;
 393   testVector[1] = 6.0f;
 394   testVector[2] = 7.0f;
 395   testVector[3] = 8.0f;
 396
 397   DALI_TEST_EQUALS( testVector.x, 5.0f, TEST_LOCATION );
 398   DALI_TEST_EQUALS( testVector.y, 6.0f, TEST_LOCATION );
 399   DALI_TEST_EQUALS( testVector.z, 7.0f, TEST_LOCATION );
 400   DALI_TEST_EQUALS( testVector.w, 8.0f, TEST_LOCATION );
 401
 402   // write struct members/read array subscripts
 403   testVector.x = 9.0f;
 404   testVector.y = 10.0f;
 405   testVector.z = 11.0f;
 406   testVector.w = 12.0f;
 407
 408   DALI_TEST_EQUALS( testVector[0],  9.0f, TEST_LOCATION );
 409   DALI_TEST_EQUALS( testVector[1], 10.0f, TEST_LOCATION );
 410   DALI_TEST_EQUALS( testVector[2], 11.0f, TEST_LOCATION );
 411   DALI_TEST_EQUALS( testVector[3], 12.0f, TEST_LOCATION );
 412
 413   END_TEST;
 414 }
 415
 416
 417 int UtcDaliVector4ConstOperatorSubscriptP(void)
 418 {
 419   Vector4 testVector(1.0f, 2.0f, 3.0f, 4.0f);
 420
 421   // write struct members/read array subscripts
 422   const Vector4 testVector2(1.0f, 2.0f, 3.0f, 4.0f);
 423   const float& x = testVector2[0];
 424   const float& y = testVector2[1];
 425   const float& z ( testVector2[2] );
 426   const float& w ( testVector2[3] );
 427
 428   DALI_TEST_EQUALS( x, 1.0f, TEST_LOCATION );
 429   DALI_TEST_EQUALS( y, 2.0f, TEST_LOCATION );
 430   DALI_TEST_EQUALS( z, 3.0f, TEST_LOCATION );
 431   DALI_TEST_EQUALS( w, 4.0f, TEST_LOCATION );
 432
 433   try
 434   {
 435     float& w = testVector[4];
 436     (void)w; // Suppress unused variable warning
 437     tet_result(TET_FAIL);
 438   }
 439   catch (Dali::DaliException& e)
 440   {
 441     DALI_TEST_PRINT_ASSERT( e );
 442     DALI_TEST_ASSERT( e, "index < 4", TEST_LOCATION );
 443   }
 444
 445   try
 446   {
 447     const float& w = testVector2[4];
 448     (void)w; // Suppress unused variable warning
 449     tet_result(TET_FAIL);
 450   }
 451   catch (Dali::DaliException& e)
 452   {
 453     DALI_TEST_PRINT_ASSERT( e );
 454     DALI_TEST_ASSERT( e, "index < 4", TEST_LOCATION );
 455   }
 456   END_TEST;
 457 }
 458
 459 int UtcDaliVector4Dot01P(void)
 460 {
 461   DALI_TEST_EQUALS(Vector4::XAXIS.Dot(Vector4::YAXIS), 0.0f, TEST_LOCATION);
 462   DALI_TEST_EQUALS(Vector4::XAXIS.Dot(Vector4::ZAXIS), 0.0f, TEST_LOCATION);
 463   DALI_TEST_EQUALS(Vector4::XAXIS.Dot(Vector4::XAXIS), 1.0f, TEST_LOCATION);
 464   DALI_TEST_EQUALS(Vector4::YAXIS.Dot(Vector4::YAXIS), 1.0f, TEST_LOCATION);
 465   DALI_TEST_EQUALS(Vector4::ZAXIS.Dot(Vector4::ZAXIS), 1.0f, TEST_LOCATION);
 466
 467   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);
 468
 469   // Test v0 . v0 and v0 . v1 (v1 is always 90 degrees out of phase with v0)
 470   for (float x = 0; x<6.0f; x+=1.0f)
 471   {
 472     // vectors rotating in the XY plane.
 473     Vector4 v0(cosf(x), sinf(x), 0.0f, 1.0f);
 474     Vector4 v1(sinf(x), -cosf(x), 0.0f, 1.0f);
 475     DALI_TEST_EQUALS(v0.Dot(v1), 0.0f, 0.0001f, TEST_LOCATION);
 476     DALI_TEST_EQUALS(v0.Dot(v0), 1.0f, 0.0001f, TEST_LOCATION);
 477
 478     // vectors rotating in the XZ plane.
 479     v0 = Vector4(cosf(x), 0.0f, sinf(x), 0.0f);
 480     v1 = Vector4(sinf(x), 0.0f, -cosf(x), 0.0f);
 481     DALI_TEST_EQUALS(v0.Dot(v1), 0.0f, 0.0001f, TEST_LOCATION);
 482     DALI_TEST_EQUALS(v0.Dot(v0), 1.0f, 0.0001f, TEST_LOCATION);
 483   }
 484
 485   Vector4 v0 = Vector4(12.0f, 7.0f, 9.0f, 14.0f);
 486   v0.Normalize();
 487
 488   Vector4 v1 = v0 * 2.0f;
 489   DALI_TEST_EQUALS(v0.Dot(v1), 2.0f, 0.001f, TEST_LOCATION);
 490   END_TEST;
 491 }
 492
 493 int UtcDaliVector4DotVector302P(void)
 494 {
 495   DALI_TEST_EQUALS(Vector4::XAXIS.Dot(Vector3::YAXIS), 0.0f, TEST_LOCATION);
 496   DALI_TEST_EQUALS(Vector4::XAXIS.Dot(Vector3::ZAXIS), 0.0f, TEST_LOCATION);
 497   DALI_TEST_EQUALS(Vector4::XAXIS.Dot(Vector3::XAXIS), 1.0f, TEST_LOCATION);
 498   DALI_TEST_EQUALS(Vector4::YAXIS.Dot(Vector3::YAXIS), 1.0f, TEST_LOCATION);
 499   DALI_TEST_EQUALS(Vector4::ZAXIS.Dot(Vector3::ZAXIS), 1.0f, TEST_LOCATION);
 500
 501   DALI_TEST_EQUALS(Vector4(1.0f, 0.0f, 0.0f, 1.0f).Dot(Vector3(1.0f, 0.0f, 0.0f)), 1.0f, TEST_LOCATION);
 502
 503   // Test v0 . v0b and v0 . v1 (v1 is always 90 degrees out of phase with v0)
 504   for (float x = 0; x<6.0f; x+=1.0f)
 505   {
 506     // vectors rotating in the XY plane.
 507     Vector4 v0(cosf(x), sinf(x), 0.0f, 1.0f);
 508     Vector3 v0b(cosf(x), sinf(x), 0.0f);
 509     Vector3 v1(sinf(x), -cosf(x), 0.0f);
 510     DALI_TEST_EQUALS(v0.Dot(v1), 0.0f, 0.0001f, TEST_LOCATION);
 511     DALI_TEST_EQUALS(v0.Dot(v0b), 1.0f, 0.0001f, TEST_LOCATION);
 512
 513     // vectors rotating in the XZ plane.
 514     v0 = Vector4(cosf(x), 0.0f, sinf(x), 0.0f);
 515     v0b = Vector3(cosf(x), 0.0f, sinf(x));
 516     v1 = Vector3(sinf(x), 0.0f, -cosf(x));
 517     DALI_TEST_EQUALS(v0.Dot(v1), 0.0f, 0.0001f, TEST_LOCATION);
 518     DALI_TEST_EQUALS(v0.Dot(v0b), 1.0f, 0.0001f, TEST_LOCATION);
 519   }
 520
 521   Vector4 v0 = Vector4(12.0f, 7.0f, 9.0f, 14.0f);
 522   v0.Normalize();
 523
 524   Vector3 v1(v0 * 2.0f);
 525   DALI_TEST_EQUALS(v0.Dot(v1), 2.0f, 0.001f, TEST_LOCATION);
 526   END_TEST;
 527 }
 528
 529 int UtcDaliVector4Dot4P(void)
 530 {
 531   DALI_TEST_EQUALS(Vector4::XAXIS.Dot4(Vector4::YAXIS), 0.0f, TEST_LOCATION);
 532   DALI_TEST_EQUALS(Vector4::XAXIS.Dot4(Vector4::ZAXIS), 0.0f, TEST_LOCATION);
 533   DALI_TEST_EQUALS(Vector4::YAXIS.Dot4(Vector4::ZAXIS), 0.0f, TEST_LOCATION);
 534
 535   DALI_TEST_EQUALS(Vector4::XAXIS.Dot4(Vector4::XAXIS), 1.0f, TEST_LOCATION);
 536   DALI_TEST_EQUALS(Vector4::YAXIS.Dot4(Vector4::YAXIS), 1.0f, TEST_LOCATION);
 537   DALI_TEST_EQUALS(Vector4::ZAXIS.Dot4(Vector4::ZAXIS), 1.0f, TEST_LOCATION);
 538
 539   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);
 540
 541   for (float x = 0; x<6.0f; x+=1.0f)
 542   {
 543     Vector4 v0(cosf(x), sinf(x), 0.0f, 1.0f);
 544     Vector4 v1(sinf(x), -cosf(x), 0.0f, 1.0f);
 545     DALI_TEST_EQUALS(v0.Dot4(v1), 1.0f, 0.0001f, TEST_LOCATION);
 546     DALI_TEST_EQUALS(v0.Dot4(v0), 2.0f, 0.0001f, TEST_LOCATION);
 547
 548     v0 = Vector4(cosf(x), 0.0f, sinf(x), 0.0f);
 549     v1 = Vector4(sinf(x), 0.0f, -cosf(x), 0.0f);
 550     DALI_TEST_EQUALS(v0.Dot4(v1), 0.0f, 0.0001f, TEST_LOCATION);
 551     DALI_TEST_EQUALS(v0.Dot4(v0), 1.0f, 0.0001f, TEST_LOCATION);
 552   }
 553
 554   Vector4 v0(12.0f, 7.0f, 9.0f, 3.0f);
 555   v0.Normalize();
 556
 557   Vector4 v1 = v0 * 2.0f;
 558   DALI_TEST_EQUALS(v0.Dot4(v1), 2.0f + 3.0f*6.0f, 0.001f, TEST_LOCATION);
 559   END_TEST;
 560 }
 561
 562 int UtcDaliVector4CrossP(void)
 563 {
 564   DALI_TEST_EQUALS(Vector4::XAXIS.Cross(Vector4::YAXIS), Vector4::ZAXIS, 0.0001f, TEST_LOCATION);
 565   DALI_TEST_EQUALS(Vector4::YAXIS.Cross(Vector4::ZAXIS), Vector4::XAXIS, 0.0001f, TEST_LOCATION);
 566   DALI_TEST_EQUALS(Vector4::ZAXIS.Cross(Vector4::XAXIS), Vector4::YAXIS, 0.0001f, TEST_LOCATION);
 567
 568   DALI_TEST_EQUALS(Vector4::XAXIS.Cross(Vector4::ZAXIS), -Vector4::YAXIS, 0.0001f, TEST_LOCATION);
 569   DALI_TEST_EQUALS(Vector4::YAXIS.Cross(Vector4::XAXIS), -Vector4::ZAXIS, 0.0001f, TEST_LOCATION);
 570   DALI_TEST_EQUALS(Vector4::ZAXIS.Cross(Vector4::YAXIS), -Vector4::XAXIS, 0.0001f, TEST_LOCATION);
 571
 572   Vector4 v0(2.0f, 3.0f, 4.0f, 5.0f);
 573   Vector4 v1(10.0f, 20.0f, 30.0f, 40.0f);
 574   Vector4 result(   (v0.y * v1.z) - (v0.z * v1.y),
 575                     (v0.z * v1.x) - (v0.x * v1.z),
 576                     (v0.x * v1.y) - (v0.y * v1.x),
 577                     0.0f);
 578
 579   DALI_TEST_EQUALS(v0.Cross(v1), result, 0.001f, TEST_LOCATION);
 580   END_TEST;
 581 }
 582
 583 int UtcDaliVector4LengthP(void)
 584 {
 585   Vector4 v(1.0f, 2.0f, 3.0f, 4.0f);
 586   DALI_TEST_EQUALS(v.Length(), sqrtf(v.x*v.x + v.y*v.y + v.z*v.z), 0.001f, TEST_LOCATION);
 587
 588   Vector4 v1(0.0f, 0.0f, 0.0f, 0.0f);
 589   DALI_TEST_EQUALS(v1.Length(), 0.0f, TEST_LOCATION);
 590   END_TEST;
 591 }
 592
 593 int UtcDaliVector4LengthSquaredP(void)
 594 {
 595   Vector4 v(1.0f, 2.0f, 3.0f, 4.0f);
 596   DALI_TEST_EQUALS(v.LengthSquared(), v.x*v.x + v.y*v.y + v.z*v.z, 0.001f, TEST_LOCATION);
 597
 598   Vector4 v1(0.0f, 0.0f, 0.0f, 0.0f);
 599   DALI_TEST_EQUALS(v1.LengthSquared(), 0.0f, TEST_LOCATION);
 600   END_TEST;
 601 }
 602
 603 int UtcDaliVector4NormalizeP(void)
 604 {
 605   for (float f=0.0f; f<6.0f; f+=1.0f)
 606   {
 607     Vector4 v(cosf(f)*10.0f, cosf(f+1.0f)*10.0f, cosf(f+2.0f)*10.0f, 1.0f);
 608     v.Normalize();
 609     DALI_TEST_EQUALS(v.LengthSquared(), 1.0f, 0.001f, TEST_LOCATION);
 610   }
 611
 612   Vector4 v(0.0f, 0.0f, 0.0f, 1.0f);
 613   v.Normalize();
 614   DALI_TEST_EQUALS(v.LengthSquared(), 0.0f, 0.00001f, TEST_LOCATION);
 615   END_TEST;
 616 }
 617
 618 int UtcDaliVector4ClampVector4P(void)
 619 {
 620   tet_infoline("Testing Dali::Vector4::Clamp( const Vector4& v, const Vector4& min, const Vector4& max )");
 621
 622   Vector4 v0(2.0f, 0.8f, 0.0f, 5.0f);
 623   Vector4 v1(-1.0f, 2.0f, 10.0f, -10.0f);
 624   Vector4 v2(10.0f, 5.0f, 0.0f, 10.0f);
 625   Vector4 v3(8.0f, 10.0f, 5.0f, -20.0f);
 626   Vector4 v4(4.9f, 5.1f, 10.0f, 0.0f);
 627
 628   Vector4 min(1.0f, -2.0f, -8.0f, -16.0f);
 629   Vector4 max(2.0f, 4.0f, 4.0f, -8.0f);
 630
 631   v0.Clamp( min, max );
 632   v1.Clamp( min, max );
 633   v2.Clamp( min, max );
 634   v3.Clamp( min, max );
 635   v4.Clamp( min, max );
 636
 637   DALI_TEST_EQUALS( v0, Vector4( 2.0f, 0.8f, 0.0f, -8.0f), 0.01f, TEST_LOCATION );
 638   DALI_TEST_EQUALS( v1, Vector4( 1.0f, 2.0f, 4.0f, -10.0f), 0.01f, TEST_LOCATION );
 639   DALI_TEST_EQUALS( v2, Vector4( 2.0f, 4.0f, 0.0f, -8.0f), 0.01f, TEST_LOCATION );
 640   DALI_TEST_EQUALS( v3, Vector4( 2.0f, 4.0f, 4.0f, -16.0f), 0.01f, TEST_LOCATION );
 641   DALI_TEST_EQUALS( v4, Vector4( 2.0f, 4.0f, 4.0f, -8.0f), 0.01f, TEST_LOCATION );
 642   END_TEST;
 643 }
 644
 645 int UtcDaliVector4AsFloatP(void)
 646 {
 647   float values[] = {0.0f,  1.0f,  2.0f, 3.0f};
 648   Vector4 v0(values);
 649
 650   for (int i=0;i<4;++i)
 651   {
 652     DALI_TEST_EQUALS(v0.AsFloat()[i], values[i], TEST_LOCATION);
 653   }
 654
 655   END_TEST;
 656 }
 657
 658 int UtcDaliVector4ConstAsFloatP(void)
 659 {
 660   float values[] = {0.0f,  1.0f,  2.0f, 3.0f};
 661   Vector4 v0(values);
 662
 663   const Vector4 v1(values);
 664   for (int i=0;i<4;++i)
 665   {
 666     DALI_TEST_EQUALS(v1.AsFloat()[i], values[i], TEST_LOCATION);
 667   }
 668   END_TEST;
 669 }
 670
 671 int UtcDaliVector4OStreamOperatorP(void)
 672 {
 673   std::ostringstream oss;
 674
 675   Vector4 vector(1.0f, 2.0f, 3.0f, 4.0f);
 676
 677   oss << vector;
 678
 679   std::string expectedOutput = "[1, 2, 3, 4]";
 680
 681   DALI_TEST_EQUALS( oss.str(), expectedOutput, TEST_LOCATION);
 682   END_TEST;
 683 }
 684
 685 int UtcDaliVector4MaxP(void)
 686 {
 687   Vector4 v0(2.0f, 2.0f, 1.0f, 1.0f);
 688   Vector4 v1(1.0f, 1.0f, 2.0f, 2.0f);
 689
 690   DALI_TEST_EQUALS(Max(v0, v1), Vector4(2.0f, 2.0f, 2.0f, 2.0f), 0.01f, TEST_LOCATION);
 691   END_TEST;
 692 }
 693
 694 int UtcDaliVector4MinP(void)
 695 {
 696   Vector4 v0(2.0f, 2.0f, 1.0f, 1.0f);
 697   Vector4 v1(1.0f, 1.0f, 2.0f, 2.0f);
 698
 699   DALI_TEST_EQUALS(Min(v0, v1), Vector4(1.0f, 1.0f, 1.0f, 1.0f), 0.01f, TEST_LOCATION);
 700   END_TEST;
 701 }
 702
 703 int UtcDaliVector4ClampP(void)
 704 {
 705   tet_infoline("Testing Dali::Vector4::Clamp()");
 706
 707   Vector4 v0(2.0f, 2.0f, -2.0f, -2.0f);
 708   DALI_TEST_EQUALS(Clamp(v0, -1.0f, 1.0f), Vector4(1.0f, 1.0f, -1.0f, -1.0f), 0.01f, TEST_LOCATION);
 709
 710   Vector4 v1(1.0f, 0.0f, 0.0f, -1.0f);
 711   DALI_TEST_EQUALS(Clamp(v1, -1.0f, 1.0f), v1, 0.01f, TEST_LOCATION);
 712
 713   END_TEST;
 714 }
 715
 716 int UtcDaliVector4ConstantsP(void)
 717 {
 718   float f[] = {2.0f, 3.0f, 4.0f, 5.0f};
 719   Vector4 v0(f);
 720   Vector4 v1(f[0], f[1], f[2], f[3]);
 721   Vector4 v2(v0);
 722
 723   DALI_TEST_EQUALS(v0, v1, TEST_LOCATION);
 724   DALI_TEST_EQUALS(v0, v2, TEST_LOCATION);
 725   DALI_TEST_CHECK(v0 == v1);
 726   END_TEST;
 727 }