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

   1 /*
   2  * Copyright (c) 2019 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
  20 #include <stdlib.h>
  21 #include <string>
  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_property_array_startup(void)
  28 {
  29   test_return_value = TET_UNDEF;
  30 }
  31
  32 void utc_dali_property_array_cleanup(void)
  33 {
  34   test_return_value = TET_PASS;
  35 }
  36
  37 int UtcDaliPropertyArrayPushBackP(void)
  38 {
  39   Property::Array array;
  40
  41   DALI_TEST_CHECK( 0 == array.Size() );
  42
  43   array.PushBack( 1 );
  44
  45   DALI_TEST_CHECK( 1 == array.Size() );
  46
  47   DALI_TEST_CHECK( array[0].Get<int>() == 1 );
  48
  49   END_TEST;
  50 }
  51
  52 int UtcDaliPropertyArrayAddP(void)
  53 {
  54   Property::Array array;
  55
  56   DALI_TEST_CHECK( 0 == array.Size() );
  57
  58   array.Add( 1 );
  59
  60   DALI_TEST_CHECK( 1 == array.Size() );
  61   DALI_TEST_CHECK( array[0].Get<int>() == 1 );
  62
  63   array.Add( 2 )
  64        .Add( 3 )
  65        .Add( 4.f );
  66
  67   DALI_TEST_EQUALS( 4u, array.Size(), TEST_LOCATION );
  68   DALI_TEST_EQUALS( array[1].Get<int>(), 2, TEST_LOCATION );
  69   DALI_TEST_EQUALS( array[2].Get<int>(), 3, TEST_LOCATION );
  70   DALI_TEST_EQUALS( array[3].Get<float>(), 4.f, Math::MACHINE_EPSILON_1, TEST_LOCATION );
  71
  72   END_TEST;
  73 }
  74
  75 int UtcDaliPropertyArrayCapacityP(void)
  76 {
  77   Property::Array array;
  78   DALI_TEST_CHECK( array.Empty() );
  79
  80   array.Reserve(3);
  81
  82   DALI_TEST_CHECK( 3 == array.Capacity() );
  83   END_TEST;
  84 }
  85
  86 int UtcDaliPropertyArrayReserveP(void)
  87 {
  88   Property::Array array;
  89   DALI_TEST_CHECK( array.Empty() );
  90
  91   array.Reserve(3);
  92
  93   DALI_TEST_CHECK( 3 == array.Capacity() );
  94   DALI_TEST_CHECK( 0 == array.Size() );
  95
  96   array.PushBack( 1 );
  97   array.PushBack( "world" );
  98   array.PushBack( 3 );
  99   END_TEST;
 100 }
 101
 102 int UtcDaliPropertyArraySizeP(void)
 103 {
 104   Property::Array array;
 105   DALI_TEST_CHECK( 0 == array.Capacity() );
 106   DALI_TEST_CHECK( 0 == array.Size() );
 107
 108   array.Reserve(3);
 109
 110   DALI_TEST_CHECK( 3 == array.Capacity() );
 111   DALI_TEST_CHECK( 0 == array.Size() );
 112
 113   array.PushBack( 1 );
 114   array.PushBack( "world" );
 115   array.PushBack( 3 );
 116
 117   DALI_TEST_CHECK( 3 == array.Size() );
 118
 119   END_TEST;
 120 }
 121
 122 int UtcDaliPropertyArrayCountP(void)
 123 {
 124   Property::Array array;
 125   DALI_TEST_CHECK( 0 == array.Capacity() );
 126   DALI_TEST_CHECK( 0 == array.Count() );
 127
 128   array.Reserve(3);
 129
 130   DALI_TEST_CHECK( 3 == array.Capacity() );
 131   DALI_TEST_CHECK( 0 == array.Count() );
 132
 133   array.PushBack( 1 );
 134   array.PushBack( "world" );
 135   array.PushBack( 3 );
 136
 137   DALI_TEST_CHECK( 3 == array.Count() );
 138
 139   END_TEST;
 140 }
 141
 142 int UtcDaliPropertyArrayEmptyP(void)
 143 {
 144   Property::Array array;
 145   DALI_TEST_CHECK( array.Empty() );
 146
 147   array.Reserve(3);
 148
 149   DALI_TEST_CHECK( array.Empty() );
 150
 151   array.PushBack( 1 );
 152   array.PushBack( "world" );
 153   array.PushBack( 3 );
 154
 155   DALI_TEST_CHECK( !array.Empty() );
 156
 157   END_TEST;
 158 }
 159
 160 int UtcDaliPropertyArrayClearP(void)
 161 {
 162   Property::Array array;
 163   DALI_TEST_CHECK( array.Empty() );
 164
 165   array.Reserve(3);
 166
 167   DALI_TEST_CHECK( array.Empty() );
 168
 169   array.PushBack( 1 );
 170   array.PushBack( "world" );
 171   array.PushBack( 3 );
 172
 173   DALI_TEST_CHECK( !array.Empty() );
 174
 175   array.Clear();
 176
 177   DALI_TEST_CHECK( array.Empty() );
 178
 179   END_TEST;
 180 }
 181
 182 int UtcDaliPropertyArrayIndexOperatorP(void)
 183 {
 184   Property::Array array;
 185
 186   array.Reserve(3);
 187   array.PushBack( 1 );
 188   array.PushBack( "world" );
 189   array.PushBack( 3 );
 190
 191   DALI_TEST_CHECK( array[0].Get<int>() == 1 );
 192   DALI_TEST_CHECK( array[1].Get<std::string>() == "world" );
 193   DALI_TEST_CHECK( array[2].Get<int>() == 3 );
 194
 195   END_TEST;
 196 }
 197
 198 int UtcDaliPropertyArrayConstIndexOperatorP(void)
 199 {
 200   Property::Array anArray;
 201
 202   anArray.Reserve(3);
 203   anArray.PushBack( 1 );
 204   anArray.PushBack( "world" );
 205   anArray.PushBack( 3 );
 206
 207   const Property::Array array(anArray);
 208
 209   DALI_TEST_CHECK( array[0].Get<int>() == 1 );
 210   DALI_TEST_CHECK( array[1].Get<std::string>() == "world" );
 211   DALI_TEST_CHECK( array[2].Get<int>() == 3 );
 212
 213   END_TEST;
 214 }
 215
 216 int UtcDaliPropertyArrayAssignmentOperatorP(void)
 217 {
 218   Property::Array anArray;
 219
 220   anArray.Reserve(3);
 221   anArray.PushBack( 1 );
 222   anArray.PushBack( "world" );
 223   anArray.PushBack( 3 );
 224
 225   Property::Array array = anArray;
 226
 227   DALI_TEST_CHECK( array[0].Get<int>() == 1 );
 228   DALI_TEST_CHECK( array[1].Get<std::string>() == "world" );
 229   DALI_TEST_CHECK( array[2].Get<int>() == 3 );
 230
 231   END_TEST;
 232 }
 233
 234 int UtcDaliPropertyArrayResize(void)
 235 {
 236   Property::Array array;
 237
 238   array.Resize(3);
 239   DALI_TEST_CHECK( array.Count() == 3 );
 240
 241   array.Resize(5);
 242   DALI_TEST_CHECK( array.Count() == 5 );
 243
 244   END_TEST;
 245 }
 246
 247 int UtcDaliPropertyArrayOstream01(void)
 248 {
 249   std::ostringstream oss;
 250
 251   Property::Array array;
 252   array.PushBack( 0 );
 253   array.PushBack( 1 );
 254   array.PushBack( 2 );
 255
 256   oss << array;
 257   DALI_TEST_EQUALS( oss.str().compare("Array(3) = [0, 1, 2]"), 0, TEST_LOCATION );
 258
 259   END_TEST;
 260 }
 261
 262 int UtcDaliPropertyArrayOstream02(void)
 263 {
 264   std::ostringstream oss;
 265
 266   Property::Array array1;
 267   array1.PushBack( 0 );
 268   array1.PushBack( 1 );
 269   array1.PushBack( 2 );
 270
 271   Property::Array array2;
 272   array2.PushBack(array1);
 273   array2.PushBack( 1 );
 274   array2.PushBack( 2 );
 275
 276   oss << array2;
 277   DALI_TEST_EQUALS( oss.str().compare("Array(3) = [Array(3) = [0, 1, 2], 1, 2]"), 0, TEST_LOCATION );
 278
 279   END_TEST;
 280 }
 281
 282 int UtcDaliPropertyArrayCopyConstructor(void)
 283 {
 284   Property::Array array1;
 285   array1.PushBack( 0 );
 286   array1.PushBack( 1 );
 287   array1.PushBack( 2 );
 288   DALI_TEST_EQUALS( 3u, array1.Size(), TEST_LOCATION );
 289
 290   Property::Array array2( array1 );
 291   DALI_TEST_EQUALS( 3u, array1.Size(), TEST_LOCATION );
 292   DALI_TEST_EQUALS( 3u, array2.Size(), TEST_LOCATION );
 293
 294   END_TEST;
 295 }
 296
 297 int UtcDaliPropertyArrayAssignmentOperator(void)
 298 {
 299   Property::Array array1;
 300   array1.PushBack( 0 );
 301   array1.PushBack( 1 );
 302   array1.PushBack( 2 );
 303   DALI_TEST_EQUALS( 3u, array1.Size(), TEST_LOCATION );
 304
 305   Property::Array array2;
 306   array2.PushBack( 4 );
 307   DALI_TEST_EQUALS( 1u, array2.Size(), TEST_LOCATION );
 308
 309   array2 = array1;
 310   DALI_TEST_EQUALS( 3u, array1.Size(), TEST_LOCATION );
 311   DALI_TEST_EQUALS( 3u, array2.Size(), TEST_LOCATION );
 312
 313   END_TEST;
 314 }
 315
 316 int UtcDaliPropertyArrayMoveConstructor(void)
 317 {
 318   Property::Array array1;
 319   array1.PushBack( 0 );
 320   array1.PushBack( 1 );
 321   array1.PushBack( 2 );
 322   DALI_TEST_EQUALS( 3u, array1.Size(), TEST_LOCATION );
 323
 324   Property::Array array2( std::move( array1 ) );
 325   DALI_TEST_EQUALS( 3u, array2.Size(), TEST_LOCATION );
 326
 327   // Calling any methods on array1 will debug assert
 328   const char * exceptionMessage = "Cannot use an object previously used as an r-value";
 329   DALI_TEST_ASSERTION( array1.Count(),                                      exceptionMessage );
 330   DALI_TEST_ASSERTION( array1.PushBack( Property::Value() ),                exceptionMessage );
 331   DALI_TEST_ASSERTION( array1.Count(),                                      exceptionMessage );
 332   DALI_TEST_ASSERTION( array1.Clear(),                                      exceptionMessage );
 333   DALI_TEST_ASSERTION( array1.Reserve( 1 ),                                 exceptionMessage );
 334   DALI_TEST_ASSERTION( array1.Resize( 1 ),                                  exceptionMessage );
 335   DALI_TEST_ASSERTION( array1.Capacity(),                                   exceptionMessage );
 336   DALI_TEST_ASSERTION( array1[ 0 ],                                         exceptionMessage );
 337   DALI_TEST_ASSERTION( const_cast< const Property::Array& >( array1 )[ 0 ], exceptionMessage );
 338   DALI_TEST_ASSERTION( Property::Array temp; array1 = temp,                 exceptionMessage );
 339
 340   END_TEST;
 341 }
 342
 343 int UtcDaliPropertyArrayMoveAssignmentOperator(void)
 344 {
 345   Property::Array array1;
 346   array1.PushBack( 0 );
 347   array1.PushBack( 1 );
 348   array1.PushBack( 2 );
 349   DALI_TEST_EQUALS( 3u, array1.Size(), TEST_LOCATION );
 350
 351   Property::Array array2;
 352   array2.PushBack( 4 );
 353   DALI_TEST_EQUALS( 1u, array2.Size(), TEST_LOCATION );
 354
 355   array2 = std::move( array1 );
 356   DALI_TEST_EQUALS( 3u, array2.Size(), TEST_LOCATION );
 357
 358   // Calling any methods on array1 will debug assert
 359   const char * exceptionMessage = "Cannot use an object previously used as an r-value";
 360   DALI_TEST_ASSERTION( array1.Count(),                                      exceptionMessage );
 361   DALI_TEST_ASSERTION( array1.PushBack( Property::Value() ),                exceptionMessage );
 362   DALI_TEST_ASSERTION( array1.Count(),                                      exceptionMessage );
 363   DALI_TEST_ASSERTION( array1.Clear(),                                      exceptionMessage );
 364   DALI_TEST_ASSERTION( array1.Reserve( 1 ),                                 exceptionMessage );
 365   DALI_TEST_ASSERTION( array1.Resize( 1 ),                                  exceptionMessage );
 366   DALI_TEST_ASSERTION( array1.Capacity(),                                   exceptionMessage );
 367   DALI_TEST_ASSERTION( array1[ 0 ],                                         exceptionMessage );
 368   DALI_TEST_ASSERTION( const_cast< const Property::Array& >( array1 )[ 0 ], exceptionMessage );
 369   DALI_TEST_ASSERTION( Property::Array temp; array1 = temp,                 exceptionMessage );
 370
 371   // Self assignemnt
 372   array2 = std::move( array2 );
 373   DALI_TEST_EQUALS( 3u, array2.Size(), TEST_LOCATION ); // still works, no debug assert
 374
 375   END_TEST;
 376 }
 377
 378 int UtcDaliPropertyArrayInitializerListConstructor(void)
 379 {
 380   Property::Array array{ 1, 2, "hello" };
 381   DALI_TEST_EQUALS( 3u, array.Size(), TEST_LOCATION );
 382   DALI_TEST_EQUALS( Property::INTEGER, array.GetElementAt( 0 ).GetType(), TEST_LOCATION );
 383   DALI_TEST_EQUALS( Property::INTEGER, array.GetElementAt( 1 ).GetType(), TEST_LOCATION );
 384   DALI_TEST_EQUALS( Property::STRING,  array.GetElementAt( 2 ).GetType(), TEST_LOCATION );
 385
 386   END_TEST;
 387 }