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

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