automated-tests/src/dali/utc-Dali-Vector4.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_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
  38
  39 // Constructor
  40 int UtcDaliVector4Vector4(void)
  41 {
  42   float f[] = {2.0f, 3.0f, 4.0f, 5.0f};
  43   Vector2 vec2(1.0f, 2.0f);
  44   Vector3 vec3(1.0f, 2.0f, 3.0f);
  45   Vector4 v0(f);
  46   Vector4 v1(f[0], f[1], f[2], f[3]);
  47   Vector4 v2(v0);
  48   Vector4 v3;
  49   v3 = (const float*) f;
  50   Vector4 v4(vec2);
  51   Vector4 v5(vec3);
  52
  53   DALI_TEST_EQUALS(v0, v1, TEST_LOCATION);
  54   DALI_TEST_EQUALS(v0, v2, TEST_LOCATION);
  55   DALI_TEST_EQUALS(v3, v0, TEST_LOCATION);
  56   DALI_TEST_EQUALS(v4, Vector4(1.0f, 2.0f, 0.0f, 0.0f), TEST_LOCATION);
  57   DALI_TEST_EQUALS(v5, Vector4(1.0f, 2.0f, 3.0f, 0.0f), TEST_LOCATION);
  58   DALI_TEST_CHECK(v0 == v1);
  59
  60   v1 = vec2;
  61   v2 = vec3;
  62   DALI_TEST_EQUALS(v1.x, 1.0f, TEST_LOCATION);
  63   DALI_TEST_EQUALS(v1.y, 2.0f, TEST_LOCATION);
  64   DALI_TEST_EQUALS(v2.x, 1.0f, TEST_LOCATION);
  65   DALI_TEST_EQUALS(v2.y, 2.0f, TEST_LOCATION);
  66   DALI_TEST_EQUALS(v2.z, 3.0f, TEST_LOCATION);
  67   END_TEST;
  68 }
  69
  70 // Add
  71 int UtcDaliVector4Add(void)
  72 {
  73   Vector4 v0(1.0f, 2.0f, 3.0f, 4.0f);
  74   Vector4 v1(10.0f, 20.0f, 30.0f, 40.0f);
  75   Vector4 r0(11.0f, 22.0f, 33.0f, 44.0f);
  76
  77   Vector4 v2 = v0+v1;
  78   DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
  79
  80   v0 += v1;
  81   DALI_TEST_EQUALS(v0, r0, TEST_LOCATION);
  82   END_TEST;
  83 }
  84
  85 // Constants
  86 int UtcDaliVector4Constants(void)
  87 {
  88   float f[] = {2.0f, 3.0f, 4.0f, 5.0f};
  89   Vector4 v0(f);
  90   Vector4 v1(f[0], f[1], f[2], f[3]);
  91   Vector4 v2(v0);
  92
  93   DALI_TEST_EQUALS(v0, v1, TEST_LOCATION);
  94   DALI_TEST_EQUALS(v0, v2, TEST_LOCATION);
  95   DALI_TEST_CHECK(v0 == v1);
  96   END_TEST;
  97 }
  98
  99 // Cross
 100 int UtcDaliVector4Cross(void)
 101 {
 102   DALI_TEST_EQUALS(Vector4::XAXIS.Cross(Vector4::YAXIS), Vector4::ZAXIS, 0.0001f, TEST_LOCATION);
 103   DALI_TEST_EQUALS(Vector4::YAXIS.Cross(Vector4::ZAXIS), Vector4::XAXIS, 0.0001f, TEST_LOCATION);
 104   DALI_TEST_EQUALS(Vector4::ZAXIS.Cross(Vector4::XAXIS), Vector4::YAXIS, 0.0001f, TEST_LOCATION);
 105
 106   DALI_TEST_EQUALS(Vector4::XAXIS.Cross(Vector4::ZAXIS), -Vector4::YAXIS, 0.0001f, TEST_LOCATION);
 107   DALI_TEST_EQUALS(Vector4::YAXIS.Cross(Vector4::XAXIS), -Vector4::ZAXIS, 0.0001f, TEST_LOCATION);
 108   DALI_TEST_EQUALS(Vector4::ZAXIS.Cross(Vector4::YAXIS), -Vector4::XAXIS, 0.0001f, TEST_LOCATION);
 109
 110   Vector4 v0(2.0f, 3.0f, 4.0f, 5.0f);
 111   Vector4 v1(10.0f, 20.0f, 30.0f, 40.0f);
 112   Vector4 result(   (v0.y * v1.z) - (v0.z * v1.y),
 113                     (v0.z * v1.x) - (v0.x * v1.z),
 114                     (v0.x * v1.y) - (v0.y * v1.x),
 115                     0.0f);
 116
 117   DALI_TEST_EQUALS(v0.Cross(v1), result, 0.001f, TEST_LOCATION);
 118   END_TEST;
 119 }
 120
 121 // Dot
 122 int UtcDaliVector4Dot(void)
 123 {
 124   DALI_TEST_EQUALS(Vector4::XAXIS.Dot(Vector4::YAXIS), 0.0f, TEST_LOCATION);
 125   DALI_TEST_EQUALS(Vector4::XAXIS.Dot(Vector4::ZAXIS), 0.0f, TEST_LOCATION);
 126   DALI_TEST_EQUALS(Vector4::XAXIS.Dot(Vector4::XAXIS), 1.0f, TEST_LOCATION);
 127   DALI_TEST_EQUALS(Vector4::YAXIS.Dot(Vector4::YAXIS), 1.0f, TEST_LOCATION);
 128   DALI_TEST_EQUALS(Vector4::ZAXIS.Dot(Vector4::ZAXIS), 1.0f, TEST_LOCATION);
 129
 130   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);
 131
 132   // Test v0 . v0 and v0 . v1 (v1 is always 90 degrees out of phase with v0)
 133   for (float x = 0; x<6.0f; x+=1.0f)
 134   {
 135     // vectors rotating in the XY plane.
 136     Vector4 v0(cosf(x), sinf(x), 0.0f, 1.0f);
 137     Vector4 v1(sinf(x), -cosf(x), 0.0f, 1.0f);
 138     DALI_TEST_EQUALS(v0.Dot(v1), 0.0f, 0.0001f, TEST_LOCATION);
 139     DALI_TEST_EQUALS(v0.Dot(v0), 1.0f, 0.0001f, TEST_LOCATION);
 140
 141     // vectors rotating in the XZ plane.
 142     v0 = Vector4(cosf(x), 0.0f, sinf(x), 0.0f);
 143     v1 = Vector4(sinf(x), 0.0f, -cosf(x), 0.0f);
 144     DALI_TEST_EQUALS(v0.Dot(v1), 0.0f, 0.0001f, TEST_LOCATION);
 145     DALI_TEST_EQUALS(v0.Dot(v0), 1.0f, 0.0001f, TEST_LOCATION);
 146   }
 147
 148   Vector4 v0 = Vector4(12.0f, 7.0f, 9.0f, 14.0f);
 149   v0.Normalize();
 150
 151   Vector4 v1 = v0 * 2.0f;
 152   DALI_TEST_EQUALS(v0.Dot(v1), 2.0f, 0.001f, TEST_LOCATION);
 153   END_TEST;
 154 }
 155
 156 // Dot (with vector3)
 157 int UtcDaliVector4DotVector3(void)
 158 {
 159   DALI_TEST_EQUALS(Vector4::XAXIS.Dot(Vector3::YAXIS), 0.0f, TEST_LOCATION);
 160   DALI_TEST_EQUALS(Vector4::XAXIS.Dot(Vector3::ZAXIS), 0.0f, TEST_LOCATION);
 161   DALI_TEST_EQUALS(Vector4::XAXIS.Dot(Vector3::XAXIS), 1.0f, TEST_LOCATION);
 162   DALI_TEST_EQUALS(Vector4::YAXIS.Dot(Vector3::YAXIS), 1.0f, TEST_LOCATION);
 163   DALI_TEST_EQUALS(Vector4::ZAXIS.Dot(Vector3::ZAXIS), 1.0f, TEST_LOCATION);
 164
 165   DALI_TEST_EQUALS(Vector4(1.0f, 0.0f, 0.0f, 1.0f).Dot(Vector3(1.0f, 0.0f, 0.0f)), 1.0f, TEST_LOCATION);
 166
 167   // Test v0 . v0b and v0 . v1 (v1 is always 90 degrees out of phase with v0)
 168   for (float x = 0; x<6.0f; x+=1.0f)
 169   {
 170     // vectors rotating in the XY plane.
 171     Vector4 v0(cosf(x), sinf(x), 0.0f, 1.0f);
 172     Vector3 v0b(cosf(x), sinf(x), 0.0f);
 173     Vector3 v1(sinf(x), -cosf(x), 0.0f);
 174     DALI_TEST_EQUALS(v0.Dot(v1), 0.0f, 0.0001f, TEST_LOCATION);
 175     DALI_TEST_EQUALS(v0.Dot(v0b), 1.0f, 0.0001f, TEST_LOCATION);
 176
 177     // vectors rotating in the XZ plane.
 178     v0 = Vector4(cosf(x), 0.0f, sinf(x), 0.0f);
 179     v0b = Vector3(cosf(x), 0.0f, sinf(x));
 180     v1 = Vector3(sinf(x), 0.0f, -cosf(x));
 181     DALI_TEST_EQUALS(v0.Dot(v1), 0.0f, 0.0001f, TEST_LOCATION);
 182     DALI_TEST_EQUALS(v0.Dot(v0b), 1.0f, 0.0001f, TEST_LOCATION);
 183   }
 184
 185   Vector4 v0 = Vector4(12.0f, 7.0f, 9.0f, 14.0f);
 186   v0.Normalize();
 187
 188   Vector3 v1(v0 * 2.0f);
 189   DALI_TEST_EQUALS(v0.Dot(v1), 2.0f, 0.001f, TEST_LOCATION);
 190   END_TEST;
 191 }
 192
 193 // Dot4
 194 int UtcDaliVector4Dot4(void)
 195 {
 196   DALI_TEST_EQUALS(Vector4::XAXIS.Dot4(Vector4::YAXIS), 0.0f, TEST_LOCATION);
 197   DALI_TEST_EQUALS(Vector4::XAXIS.Dot4(Vector4::ZAXIS), 0.0f, TEST_LOCATION);
 198   DALI_TEST_EQUALS(Vector4::YAXIS.Dot4(Vector4::ZAXIS), 0.0f, TEST_LOCATION);
 199
 200   DALI_TEST_EQUALS(Vector4::XAXIS.Dot4(Vector4::XAXIS), 1.0f, TEST_LOCATION);
 201   DALI_TEST_EQUALS(Vector4::YAXIS.Dot4(Vector4::YAXIS), 1.0f, TEST_LOCATION);
 202   DALI_TEST_EQUALS(Vector4::ZAXIS.Dot4(Vector4::ZAXIS), 1.0f, TEST_LOCATION);
 203
 204   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);
 205
 206   for (float x = 0; x<6.0f; x+=1.0f)
 207   {
 208     Vector4 v0(cosf(x), sinf(x), 0.0f, 1.0f);
 209     Vector4 v1(sinf(x), -cosf(x), 0.0f, 1.0f);
 210     DALI_TEST_EQUALS(v0.Dot4(v1), 1.0f, 0.0001f, TEST_LOCATION);
 211     DALI_TEST_EQUALS(v0.Dot4(v0), 2.0f, 0.0001f, TEST_LOCATION);
 212
 213     v0 = Vector4(cosf(x), 0.0f, sinf(x), 0.0f);
 214     v1 = Vector4(sinf(x), 0.0f, -cosf(x), 0.0f);
 215     DALI_TEST_EQUALS(v0.Dot4(v1), 0.0f, 0.0001f, TEST_LOCATION);
 216     DALI_TEST_EQUALS(v0.Dot4(v0), 1.0f, 0.0001f, TEST_LOCATION);
 217   }
 218
 219   Vector4 v0(12.0f, 7.0f, 9.0f, 3.0f);
 220   v0.Normalize();
 221
 222   Vector4 v1 = v0 * 2.0f;
 223   DALI_TEST_EQUALS(v0.Dot4(v1), 2.0f + 3.0f*6.0f, 0.001f, TEST_LOCATION);
 224   END_TEST;
 225 }
 226
 227 // Equals
 228 int UtcDaliVector4Equals(void)
 229 {
 230   Vector4 v0(1.0f, 2.0f,  3.0f, 4.0f);
 231   Vector4 v1(1.0f, 2.0f,  3.0f, 4.0f);
 232
 233   DALI_TEST_CHECK(v0 == v1);
 234
 235   Vector4 v2 = Vector4(0.0f, 2.0f, 3.0f, 4.0f);
 236   DALI_TEST_CHECK(v0 != v2);
 237
 238   v2 = Vector4(1.0f, 0.0f, 3.0f, 4.0f);
 239   DALI_TEST_CHECK(v0 != v2);
 240
 241   v2 = Vector4(1.0f, 2.0f, 0.0f, 4.0f);
 242   DALI_TEST_CHECK(v0 != v2);
 243
 244   v2 = Vector4(1.0f, 2.0f, 3.0f, 0.0f);
 245   DALI_TEST_CHECK(v0 != v2);
 246   END_TEST;
 247 }
 248
 249 // Length
 250 int UtcDaliVector4Length(void)
 251 {
 252   Vector4 v(1.0f, 2.0f, 3.0f, 4.0f);
 253   DALI_TEST_EQUALS(v.Length(), sqrtf(v.x*v.x + v.y*v.y + v.z*v.z), 0.001f, TEST_LOCATION);
 254
 255   Vector4 v1(0.0f, 0.0f, 0.0f, 0.0f);
 256   DALI_TEST_EQUALS(v1.Length(), 0.0f, TEST_LOCATION);
 257   END_TEST;
 258 }
 259
 260 // Length squared
 261 int UtcDaliVector4LengthSquared(void)
 262 {
 263   Vector4 v(1.0f, 2.0f, 3.0f, 4.0f);
 264   DALI_TEST_EQUALS(v.LengthSquared(), v.x*v.x + v.y*v.y + v.z*v.z, 0.001f, TEST_LOCATION);
 265
 266   Vector4 v1(0.0f, 0.0f, 0.0f, 0.0f);
 267   DALI_TEST_EQUALS(v1.LengthSquared(), 0.0f, TEST_LOCATION);
 268   END_TEST;
 269 }
 270
 271 // Max
 272 int UtcDaliVector4Max(void)
 273 {
 274   Vector4 v0(2.0f, 2.0f, 1.0f, 1.0f);
 275   Vector4 v1(1.0f, 1.0f, 2.0f, 2.0f);
 276
 277   DALI_TEST_EQUALS(Max(v0, v1), Vector4(2.0f, 2.0f, 2.0f, 2.0f), 0.01f, TEST_LOCATION);
 278   END_TEST;
 279 }
 280
 281 // Min
 282 int UtcDaliVector4Min(void)
 283 {
 284   Vector4 v0(2.0f, 2.0f, 1.0f, 1.0f);
 285   Vector4 v1(1.0f, 1.0f, 2.0f, 2.0f);
 286
 287   DALI_TEST_EQUALS(Min(v0, v1), Vector4(1.0f, 1.0f, 1.0f, 1.0f), 0.01f, TEST_LOCATION);
 288   END_TEST;
 289 }
 290
 291 // Clamp
 292 int UtcDaliVector4Clamp(void)
 293 {
 294   tet_infoline("Testing Dali::Vector4::Clamp()");
 295
 296   Vector4 v0(2.0f, 2.0f, -2.0f, -2.0f);
 297   DALI_TEST_EQUALS(Clamp(v0, -1.0f, 1.0f), Vector4(1.0f, 1.0f, -1.0f, -1.0f), 0.01f, TEST_LOCATION);
 298
 299   Vector4 v1(1.0f, 0.0f, 0.0f, -1.0f);
 300   DALI_TEST_EQUALS(Clamp(v1, -1.0f, 1.0f), v1, 0.01f, TEST_LOCATION);
 301
 302   END_TEST;
 303 }
 304
 305 int UtcDaliVector4ClampVector4(void)
 306 {
 307   tet_infoline("Testing Dali::Vector4::Clamp( const Vector4& v, const Vector4& min, const Vector4& max )");
 308
 309   Vector4 v0(2.0f, 0.8f, 0.0f, 5.0f);
 310   Vector4 v1(-1.0f, 2.0f, 10.0f, -10.0f);
 311   Vector4 v2(10.0f, 5.0f, 0.0f, 10.0f);
 312   Vector4 v3(8.0f, 10.0f, 5.0f, -20.0f);
 313   Vector4 v4(4.9f, 5.1f, 10.0f, 0.0f);
 314
 315   Vector4 min(1.0f, -2.0f, -8.0f, -16.0f);
 316   Vector4 max(2.0f, 4.0f, 4.0f, -8.0f);
 317
 318   v0.Clamp( min, max );
 319   v1.Clamp( min, max );
 320   v2.Clamp( min, max );
 321   v3.Clamp( min, max );
 322   v4.Clamp( min, max );
 323
 324   DALI_TEST_EQUALS( v0, Vector4( 2.0f, 0.8f, 0.0f, -8.0f), 0.01f, TEST_LOCATION );
 325   DALI_TEST_EQUALS( v1, Vector4( 1.0f, 2.0f, 4.0f, -10.0f), 0.01f, TEST_LOCATION );
 326   DALI_TEST_EQUALS( v2, Vector4( 2.0f, 4.0f, 0.0f, -8.0f), 0.01f, TEST_LOCATION );
 327   DALI_TEST_EQUALS( v3, Vector4( 2.0f, 4.0f, 4.0f, -16.0f), 0.01f, TEST_LOCATION );
 328   DALI_TEST_EQUALS( v4, Vector4( 2.0f, 4.0f, 4.0f, -8.0f), 0.01f, TEST_LOCATION );
 329   END_TEST;
 330 }
 331
 332 // Multiply
 333 int UtcDaliVector4Multiply(void)
 334 {
 335   Vector4 v0(2.0f, 3.0f, 4.0f, 5.0f);
 336   Vector4 v1(10.0f, 20.0f,  30.0f,  40.0f);
 337   Vector4 r0(20.0f, 60.0f, 120.0f, 200.0f);
 338
 339   Vector4 v2 = v0 * v1;
 340   DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
 341
 342   v0 *= v1;
 343   DALI_TEST_EQUALS(v0, r0, TEST_LOCATION);
 344   END_TEST;
 345 }
 346
 347 // Divide
 348 int UtcDaliVector4Divide(void)
 349 {
 350   Vector4 v0(1.0f, 1.0f, 1.0f, 1.0f);
 351   Vector4 v1(2.0f, 3.0f, 5.0f, 7.0f);
 352   Vector4 v2(4.0f, 9.0f, 25.0f, 49.0f);
 353
 354   DALI_TEST_EQUALS( v0/v0, v0, TEST_LOCATION);
 355   DALI_TEST_EQUALS( v1/v0, v1, TEST_LOCATION);
 356   DALI_TEST_EQUALS( v1/v1, v0, TEST_LOCATION);
 357   DALI_TEST_EQUALS( v2/v1, v1, TEST_LOCATION);
 358
 359   Vector4 v4(v0);
 360   v4 /= v0;
 361   DALI_TEST_EQUALS(v4, v0, TEST_LOCATION);
 362
 363   Vector4 v5(v1);
 364   v5 /= v0;
 365   DALI_TEST_EQUALS(v5, v1, TEST_LOCATION);
 366
 367   Vector4 v6(v1);
 368   v6 /= v6;
 369   DALI_TEST_EQUALS(v6, v0, TEST_LOCATION);
 370
 371   v2 /= v1;
 372   DALI_TEST_EQUALS(v2, v1, TEST_LOCATION);
 373
 374   END_TEST;
 375 }
 376
 377 int UtcDaliVector4Scale(void)
 378 {
 379   Vector4 v0(2.0f,   4.0f,  8.0f,  16.0f);
 380   const Vector4 r0(20.0f, 40.0f, 80.0f, 160.0f);
 381   const Vector4 r1(10.0f, 20.0f, 40.0f,  80.0f);
 382   const Vector4 r2( 1.0f,  2.0f,  4.0f,   8.0f);
 383   const Vector4 r3(2.0f,   4.0f,  8.0f,  16.0f);
 384
 385   Vector4 v2 = v0 * 10.0f;
 386   DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
 387
 388   v0 *= 5.0f;
 389   DALI_TEST_EQUALS(v0, r1, TEST_LOCATION);
 390
 391   v2 = r0 / 10.0f;
 392   DALI_TEST_EQUALS(v2, r3, TEST_LOCATION);
 393
 394   v2 = r1;
 395   v2 /= 10.0f;
 396   DALI_TEST_EQUALS(v2, r2, TEST_LOCATION);
 397   END_TEST;
 398 }
 399
 400
 401 // Normalize
 402 int UtcDaliVector4Normalize(void)
 403 {
 404   for (float f=0.0f; f<6.0f; f+=1.0f)
 405   {
 406     Vector4 v(cosf(f)*10.0f, cosf(f+1.0f)*10.0f, cosf(f+2.0f)*10.0f, 1.0f);
 407     v.Normalize();
 408     DALI_TEST_EQUALS(v.LengthSquared(), 1.0f, 0.001f, TEST_LOCATION);
 409   }
 410
 411   Vector4 v(0.0f, 0.0f, 0.0f, 1.0f);
 412   v.Normalize();
 413   DALI_TEST_EQUALS(v.LengthSquared(), 0.0f, 0.00001f, TEST_LOCATION);
 414   END_TEST;
 415 }
 416
 417 // Subtract
 418 int UtcDaliVector4Subtract(void)
 419 {
 420   Vector4 v0(11.0f, 22.0f, 33.0f, 44.0f);
 421   Vector4 v1(10.0f, 20.0f, 30.0f, 40.0f);
 422   Vector4 r0(1.0f, 2.0f, 3.0f, 4.0f);
 423
 424   Vector4 v2 = v0-v1;
 425   DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
 426
 427   v0 -= v1;
 428   DALI_TEST_EQUALS(v0, r0, TEST_LOCATION);
 429   END_TEST;
 430 }
 431
 432 int UtcDaliVector4OperatorSubscript(void)
 433 {
 434   Vector4 testVector(1.0f, 2.0f, 3.0f, 4.0f);
 435
 436   // read array subscripts
 437   DALI_TEST_EQUALS( testVector[0], 1.0f, TEST_LOCATION );
 438   DALI_TEST_EQUALS( testVector[1], 2.0f, TEST_LOCATION );
 439   DALI_TEST_EQUALS( testVector[2], 3.0f, TEST_LOCATION );
 440   DALI_TEST_EQUALS( testVector[3], 4.0f, TEST_LOCATION );
 441
 442   // write array subscripts/read struct memebers
 443   testVector[0] = 5.0f;
 444   testVector[1] = 6.0f;
 445   testVector[2] = 7.0f;
 446   testVector[3] = 8.0f;
 447
 448   DALI_TEST_EQUALS( testVector.x, 5.0f, TEST_LOCATION );
 449   DALI_TEST_EQUALS( testVector.y, 6.0f, TEST_LOCATION );
 450   DALI_TEST_EQUALS( testVector.z, 7.0f, TEST_LOCATION );
 451   DALI_TEST_EQUALS( testVector.w, 8.0f, TEST_LOCATION );
 452
 453   // write struct members/read array subscripts
 454   testVector.x = 9.0f;
 455   testVector.y = 10.0f;
 456   testVector.z = 11.0f;
 457   testVector.w = 12.0f;
 458
 459   DALI_TEST_EQUALS( testVector[0],  9.0f, TEST_LOCATION );
 460   DALI_TEST_EQUALS( testVector[1], 10.0f, TEST_LOCATION );
 461   DALI_TEST_EQUALS( testVector[2], 11.0f, TEST_LOCATION );
 462   DALI_TEST_EQUALS( testVector[3], 12.0f, TEST_LOCATION );
 463
 464
 465   // write struct members/read array subscripts
 466   const Vector4 testVector2(1.0f, 2.0f, 3.0f, 4.0f);
 467   const float& x = testVector2[0];
 468   const float& y = testVector2[1];
 469   const float& z ( testVector2[2] );
 470   const float& w ( testVector2[3] );
 471
 472   DALI_TEST_EQUALS( x, 1.0f, TEST_LOCATION );
 473   DALI_TEST_EQUALS( y, 2.0f, TEST_LOCATION );
 474   DALI_TEST_EQUALS( z, 3.0f, TEST_LOCATION );
 475   DALI_TEST_EQUALS( w, 4.0f, TEST_LOCATION );
 476
 477   try
 478   {
 479     float& w = testVector[4];
 480     if(w==0.0f);
 481     tet_result(TET_FAIL);
 482   }
 483   catch (Dali::DaliException& e)
 484   {
 485     tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
 486     DALI_TEST_ASSERT( e, "index < 4", TEST_LOCATION );
 487   }
 488
 489   try
 490   {
 491     const float& w = testVector2[4];
 492     if(w==0.0f);
 493     tet_result(TET_FAIL);
 494   }
 495   catch (Dali::DaliException& e)
 496   {
 497     tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
 498     DALI_TEST_ASSERT( e, "index < 4", TEST_LOCATION );
 499   }
 500   END_TEST;
 501 }
 502
 503 int UtcDaliVector4OStreamOperator(void)
 504 {
 505   std::ostringstream oss;
 506
 507   Vector4 vector(1.0f, 2.0f, 3.0f, 4.0f);
 508
 509   oss << vector;
 510
 511   std::string expectedOutput = "[1, 2, 3, 4]";
 512
 513   DALI_TEST_EQUALS( oss.str(), expectedOutput, TEST_LOCATION);
 514   END_TEST;
 515 }
 516
 517 int UtcDaliVector4AsFloat(void)
 518 {
 519   float values[] = {0.0f,  1.0f,  2.0f, 3.0f};
 520   Vector4 v0(values);
 521
 522   for (int i=0;i<4;++i)
 523   {
 524     DALI_TEST_EQUALS(v0.AsFloat()[i], values[i], TEST_LOCATION);
 525   }
 526
 527   const Vector4 v1(values);
 528   for (int i=0;i<4;++i)
 529   {
 530     DALI_TEST_EQUALS(v1.AsFloat()[i], values[i], TEST_LOCATION);
 531   }
 532   END_TEST;
 533 }