git.maemo.org Git - hildon/blob - tests/check-hildon-time-editor.c

   1 /*
   2  * This file is a part of hildon tests
   3  *
   4  * Copyright (C) 2006, 2007 Nokia Corporation, all rights reserved.
   5  *
   6  * Contact: Michael Dominic Kostrzewa <michael.kostrzewa@nokia.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public License
  10  * as published by the Free Software Foundation; version 2.1 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  21  * 02110-1301 USA
  22  *
  23  */
  24
  25 #include <stdlib.h>
  26 #include <check.h>
  27 #include <gtk/gtkmain.h>
  28 #include <gtk/gtkhbox.h>
  29 #include <gtk/gtkcontainer.h>
  30 #include "test_suites.h"
  31 #include "check_utils.h"
  32
  33 #include <unistd.h>
  34
  35 #include <hildon/hildon-time-editor.h>
  36
  37 #define MIN_DURATION 0
  38 #define MAX_DURATION 359999
  39
  40 /* -------------------- Fixtures -------------------- */
  41
  42 static GtkWidget *showed_window = NULL;
  43 /* static HildonTimeEditor *time_editor = NULL;  */
  44
  45 static void
  46 fx_setup_default_time_editor ()
  47 {
  48   int argc = 0;
  49
  50   gtk_init(&argc, NULL);
  51
  52   showed_window =  create_test_window ();
  53 }
  54
  55 static void
  56 fx_teardown_default_time_editor ()
  57 {
  58   /* Destroy the window */
  59   gtk_widget_destroy (showed_window);
  60 }
  61
  62 static HildonTimeEditor *create_and_show_time_editor(GtkWidget *window, gboolean seconds,gboolean duration)
  63 {
  64   HildonTimeEditor *time_editor = NULL;
  65
  66   time_editor = HILDON_TIME_EDITOR(hildon_time_editor_new());
  67
  68   hildon_time_editor_set_show_seconds(time_editor,seconds);
  69   hildon_time_editor_set_duration_mode(time_editor,duration);
  70
  71   /* Add some widgets to the window and displays the window */
  72   gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET(time_editor));
  73   show_all_test_window (window);
  74
  75   hildon_time_editor_set_duration_mode(time_editor,duration);
  76
  77   fail_if( !HILDON_IS_TIME_EDITOR(time_editor),"hildon-time-editor: Creation failed.");
  78   return time_editor;
  79 }
  80
  81 static void remove_and_destroy_time_editor(GtkWidget *window,HildonTimeEditor ** time_editor)
  82 {
  83
  84   gtk_container_remove (GTK_CONTAINER (window), GTK_WIDGET(*time_editor));
  85   gtk_widget_hide_all (window);
  86
  87 }
  88
  89 /* -------------------- Test cases -------------------- */
  90
  91 /* ----- Test case for set_time -----*/
  92
  93 /**
  94  * Purpose: Check that regular time values are set and get properly
  95  * Cases considered:
  96  *    - Set and get time to 5h 30m using time editor object.
  97  *    - Set and get time to 18h 2m using time editor object.
  98  *    - Set and get time to 5h 30m 45s using time editor object.
  99  *    - Set and get time to 18h 2m 5s using time editor object.
 100  *    - Set and get time to 5:30:45 using time editor object with duration mode.
 101  *    - Set and get time to 50:40:30 using time editor object with duration mode.
 102  */
 103 START_TEST (test_set_time_regular)
 104 {
 105   guint initial_hours;
 106   guint initial_minutes;
 107   guint initial_seconds;
 108   guint hours;
 109   guint minutes;
 110   guint seconds;
 111   HildonTimeEditor *time_editor = NULL;
 112
 113   /* Test 1: Set time value to 5h 30m 0s to test time (am) without seconds */
 114   initial_hours=5;
 115   initial_minutes=30;
 116   initial_seconds=0;
 117
 118   time_editor = create_and_show_time_editor(showed_window,FALSE,FALSE);
 119
 120   hildon_time_editor_set_time(time_editor,initial_hours,initial_minutes,initial_seconds);
 121
 122   hildon_time_editor_get_time(time_editor,&hours,&minutes,&seconds);
 123   fail_if((hours != initial_hours) || (minutes != initial_minutes) || (seconds != initial_seconds),
 124           "hildon-time-editor: set_time or get_time failed with values (%dh %dm). Result values are: (%dh %dm)",
 125           initial_hours,initial_minutes,hours,minutes);
 126
 127   remove_and_destroy_time_editor(showed_window,&time_editor);
 128
 129
 130   /* Test 2: Set time value to 18h 2m 0s to test time (pm) without seconds*/
 131   initial_hours=18;
 132   initial_minutes=2;
 133   initial_seconds=0;
 134
 135   time_editor = create_and_show_time_editor(showed_window,FALSE,FALSE);
 136
 137   hildon_time_editor_set_time(time_editor,initial_hours,initial_minutes,initial_seconds);
 138
 139   hildon_time_editor_get_time(time_editor,&hours,&minutes,&seconds);
 140
 141   fail_if((hours != initial_hours) || (minutes != initial_minutes) || (seconds != initial_seconds),
 142           "hildon-time-editor: set_time or get_time failed with values (%dh %dm). Result values are: (%dh %dm)",
 143           initial_hours,initial_minutes,hours,minutes);
 144
 145   remove_and_destroy_time_editor(showed_window,&time_editor);
 146
 147
 148   /* Test 3: Set time value to 5h 30m 45s to test time (am) with seconds*/
 149   initial_hours=5;
 150   initial_minutes=30;
 151   initial_seconds=45;
 152
 153   time_editor = create_and_show_time_editor(showed_window,TRUE,FALSE);
 154
 155   hildon_time_editor_set_time(time_editor,initial_hours,initial_minutes,initial_seconds);
 156
 157   hildon_time_editor_get_time(time_editor,&hours,&minutes,&seconds);
 158
 159   fail_if((hours != initial_hours) || (minutes != initial_minutes) || (seconds != initial_seconds),
 160           "hildon-time-editor: set_time or get_time failed with values (%dh %dm %ds). Result values are: (%dh %dm %ds)",
 161           initial_hours,initial_minutes,initial_seconds,hours,minutes,seconds);
 162
 163   remove_and_destroy_time_editor(showed_window,&time_editor);
 164
 165   /* Test 4: Set time value to 18h 2m 5s to test time (pm) with seconds */
 166   initial_hours=18;
 167   initial_minutes=2;
 168   initial_seconds=5;
 169
 170
 171   time_editor = create_and_show_time_editor(showed_window,TRUE,FALSE);
 172
 173   hildon_time_editor_set_time(time_editor,initial_hours,initial_minutes,initial_seconds);
 174
 175   hildon_time_editor_get_time(time_editor,&hours,&minutes,&seconds);
 176
 177   fail_if((hours != initial_hours) || (minutes != initial_minutes) || (seconds != initial_seconds),
 178           "hildon-time-editor: set_time or get_time failed with values (%dh %dm %ds). Result values are: (%dh %dm %ds)",
 179           initial_hours,initial_minutes,initial_seconds,hours,minutes,seconds);
 180
 181   remove_and_destroy_time_editor(showed_window,&time_editor);
 182
 183
 184   /* Test 5: Set time value to 5:30:45 to test duration*/
 185   initial_hours=5;
 186   initial_minutes=30;
 187   initial_seconds=45;
 188
 189   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
 190   hildon_time_editor_set_time(time_editor,initial_hours,initial_minutes,initial_seconds);
 191
 192   hildon_time_editor_get_time(time_editor,&hours,&minutes,&seconds);
 193
 194
 195   fail_if((hours != initial_hours) || (minutes != initial_minutes) || (seconds != initial_seconds),
 196           "hildon-time-editor: set_time or get_time failed with values (%d:%d:%d). Result values are: (%d:%d:%d)",
 197           initial_hours,initial_minutes,initial_seconds,hours,minutes,seconds);
 198
 199   remove_and_destroy_time_editor(showed_window,&time_editor);
 200
 201   /* Test 6: Set time value to 50:40:30 to test duration */
 202   initial_hours=50;
 203   initial_minutes=40;
 204   initial_seconds=30;
 205
 206   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
 207
 208   hildon_time_editor_set_time(time_editor,initial_hours,initial_minutes,initial_seconds);
 209
 210   hildon_time_editor_get_time(time_editor,&hours,&minutes,&seconds);
 211
 212   fail_if((hours != initial_hours) || (minutes != initial_minutes) || (seconds != initial_seconds),
 213           "hildon-time-editor: set_time or get_time failed with values (%d:%d:%d). Result values are: (%d:%d:%d)",
 214           initial_hours,initial_minutes,initial_seconds,hours,minutes,seconds);
 215
 216   remove_and_destroy_time_editor(showed_window,&time_editor);
 217
 218
 219 }
 220 END_TEST
 221
 222 /**
 223  * Purpose: Check that limit time values are set and get properly
 224  * Cases considered:
 225  *    - Set and get time to 0h 0m using time editor object.
 226  *    - Set and get time to 23h 59m using time editor object.
 227  *    - Set and get time to 23h 59m 59s using time editor object.
 228  *    - Set and get time to 0h 59m 59s using time editor object.
 229  *    - Set and get time to 99:59:59 using time editor object on duration mode.
 230  *    - Set and get time to 0:0:0 using time editor object on duration mode.
 231  */
 232 START_TEST (test_set_time_limits)
 233 {
 234   guint initial_hours;
 235   guint initial_minutes;
 236   guint initial_seconds;
 237   guint hours;
 238   guint minutes;
 239   guint seconds;
 240   HildonTimeEditor *time_editor = NULL;
 241
 242   /* Test 1: Set time value to 00h 00m 00s to test time (am) without seconds*/
 243   initial_hours=0;
 244   initial_minutes=0;
 245   initial_seconds=0;
 246
 247   time_editor = create_and_show_time_editor(showed_window,FALSE,FALSE);
 248
 249   hildon_time_editor_set_time(time_editor,initial_hours,initial_minutes,initial_seconds);
 250
 251   hildon_time_editor_get_time(time_editor,&hours,&minutes,&seconds);
 252
 253   fail_if((hours != initial_hours) || (minutes != initial_minutes) || (seconds != initial_seconds),
 254           "hildon-time-editor: set_time or get_time failed with values (%dh %dm). Result values are: (%dh %dm)",
 255           initial_hours,initial_minutes,hours,minutes);
 256
 257   remove_and_destroy_time_editor(showed_window,&time_editor);
 258
 259   /* Test 2: Set time value to 23h 59m 0s to test time (pm) without seconds*/
 260   initial_hours=23;
 261   initial_minutes=59;
 262   initial_seconds=0;
 263
 264   time_editor = create_and_show_time_editor(showed_window,FALSE,FALSE);
 265
 266   hildon_time_editor_set_time(time_editor,initial_hours,initial_minutes,initial_seconds);
 267
 268   hildon_time_editor_get_time(time_editor,&hours,&minutes,&seconds);
 269
 270   fail_if((hours != initial_hours) || (minutes != initial_minutes) || (seconds != initial_seconds),
 271           "hildon-time-editor: set_time or get_time failed with values (%dh %dm). Result values are: (%dh %dm)",
 272           initial_hours,initial_minutes,hours,minutes);
 273
 274   remove_and_destroy_time_editor(showed_window,&time_editor);
 275
 276   /* Test 3: Set time value to 23h 59m 59s to test time (am) with seconds*/
 277   initial_hours=23;
 278   initial_minutes=59;
 279   initial_seconds=59;
 280
 281   time_editor = create_and_show_time_editor(showed_window,TRUE,FALSE);
 282
 283   hildon_time_editor_set_time(time_editor,initial_hours,initial_minutes,initial_seconds);
 284
 285   hildon_time_editor_get_time(time_editor,&hours,&minutes,&seconds);
 286
 287   fail_if((hours != initial_hours) || (minutes != initial_minutes) || (seconds != initial_seconds),
 288           "hildon-time-editor: set_time or get_time failed with values (%dh %dm %ds). Result values are: (%dh %dm %ds)",
 289           initial_hours,initial_minutes,initial_seconds,hours,minutes,seconds);
 290
 291   remove_and_destroy_time_editor(showed_window,&time_editor);
 292
 293   /* Test 4: Set time value to 0h 59m 59s to test time (am) with seconds */
 294   initial_hours=0;
 295   initial_minutes=59;
 296   initial_seconds=59;
 297   time_editor = create_and_show_time_editor(showed_window,TRUE,FALSE);
 298
 299   hildon_time_editor_set_time(time_editor,initial_hours,initial_minutes,initial_seconds);
 300
 301   hildon_time_editor_get_time(time_editor,&hours,&minutes,&seconds);
 302
 303   fail_if((hours != initial_hours) || (minutes != initial_minutes) || (seconds != initial_seconds),
 304           "hildon-time-editor: set_time or get_time failed with values (%dh %dm %ds). Result values are: (%dh %dm %ds)",
 305           initial_hours,initial_minutes,initial_seconds,hours,minutes,seconds);
 306
 307   remove_and_destroy_time_editor(showed_window,&time_editor);
 308
 309   /* Test 5: Set time value to 99:59:59 to test with duration mode */
 310   initial_hours=99;
 311   initial_minutes=59;
 312   initial_seconds=59;
 313   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
 314
 315   hildon_time_editor_set_time(time_editor,initial_hours,initial_minutes,initial_seconds);
 316
 317   hildon_time_editor_get_time(time_editor,&hours,&minutes,&seconds);
 318
 319   fail_if((hours != initial_hours) || (minutes != initial_minutes) || (seconds != initial_seconds),
 320           "hildon-time-editor: set_time or get_time failed with values (%dh %dm %ds). Result values are: (%dh %dm %ds)",
 321           initial_hours,initial_minutes,initial_seconds,hours,minutes,seconds);
 322
 323   remove_and_destroy_time_editor(showed_window,&time_editor);
 324
 325   /* Test 6: Set time value to 0:0:0 to test with duration mode */
 326   initial_hours=0;
 327   initial_minutes=0;
 328   initial_seconds=0;
 329
 330   time_editor = create_and_show_time_editor(showed_window,FALSE,TRUE);
 331
 332   hildon_time_editor_set_time(time_editor,initial_hours,initial_minutes,initial_seconds);
 333
 334   hildon_time_editor_get_time(time_editor,&hours,&minutes,&seconds);
 335
 336   fail_if((hours != initial_hours) || (minutes != initial_minutes) || (seconds != initial_seconds),
 337           "hildon-time-editor: set_time or get_time failed with values (%dh %dm %ds). Result values are: (%dh %dm %ds)",
 338           initial_hours,initial_minutes,initial_seconds,hours,minutes,seconds);
 339
 340   remove_and_destroy_time_editor(showed_window,&time_editor);
 341
 342
 343 }
 344 END_TEST
 345
 346 /**
 347  * Purpose: Check that invalid time values are set and get properly
 348  * Cases considered:
 349  *    - Set NULL the editor time object.
 350  *    - Test NULL (time object) on get_time
 351  *    - Set and get time to 0h 60m using time editor object.
 352  *    - Set and get time to 0h 0m 60s using time editor object.
 353  *    - Set and get time to 24h 60m 60s using time editor object.
 354  *    - Set and get time to 50h 100m 100s using time editor object.
 355  *    - Set and get time to 0:80:80 using time editor object.
 356  *    - Set and get time to 110:80:80 using time editor object.
 357  */
 358 START_TEST (test_set_time_invalid)
 359 {
 360   guint initial_hours;
 361   guint initial_minutes;
 362   guint initial_seconds;
 363   guint expected_hours;
 364   guint expected_minutes;
 365   guint expected_seconds;
 366   guint hours;
 367   guint minutes;
 368   guint seconds;
 369   HildonTimeEditor *time_editor = NULL;
 370
 371   /* Initialization to test 1, test 2 and test 3*/
 372   initial_hours=0;
 373   initial_minutes=60;
 374   initial_seconds=0;
 375   expected_hours=1;
 376   expected_minutes=0;
 377   expected_seconds=0;
 378
 379   /* Test 1: Set NULL (set_time) */
 380   hildon_time_editor_set_time (NULL,initial_hours,initial_minutes,initial_seconds);
 381
 382   /* Test 2: Set NULL (get_time) */
 383   hildon_time_editor_get_time(NULL,&hours,&minutes,&seconds);
 384
 385   /* Test 3: Set time value to 00h 60m 00s to test time (am) without seconds and expect the correct value 01h 00m 00s */
 386
 387   time_editor = create_and_show_time_editor(showed_window,FALSE,FALSE);
 388
 389   hildon_time_editor_set_time(time_editor,initial_hours,initial_minutes,initial_seconds);
 390
 391   hildon_time_editor_get_time(time_editor,&hours,&minutes,&seconds);
 392
 393   remove_and_destroy_time_editor(showed_window,&time_editor);
 394
 395   fail_if((expected_hours != hours) || (expected_minutes != minutes) || (expected_seconds != seconds),
 396           "hildon-time-editor: set_time/get_time failed with (%dh %dm). Result values are (%dh %dm) and expected values are (%dh %dm)",
 397           initial_hours,initial_minutes,hours,minutes,expected_hours,expected_minutes);
 398
 399   /* Test 4: Set time value to 0h 0m 60s to test time (pm) without seconds and expect the correct value 00h 01m 00s*/
 400   initial_hours=0;
 401   initial_minutes=0;
 402   initial_seconds=60;
 403   expected_hours=0;
 404   expected_minutes=1;
 405   expected_seconds=0;
 406
 407   time_editor = create_and_show_time_editor(showed_window,FALSE,TRUE);
 408
 409   hildon_time_editor_set_time(time_editor,initial_hours,initial_minutes,initial_seconds);
 410
 411   hildon_time_editor_get_time(time_editor,&hours,&minutes,&seconds);
 412
 413   fail_if((expected_hours != hours) || (expected_minutes != minutes) || (expected_seconds != seconds),
 414           "hildon-time-editor: set_time/get_time failed with (%dh %dm %ds). Result values are (%dh %dm %ds) and expected values are (%dh %dm %ds)",
 415           initial_hours,initial_minutes,initial_seconds,hours,minutes,seconds,expected_hours,expected_minutes,expected_seconds);
 416
 417   remove_and_destroy_time_editor(showed_window,&time_editor);
 418
 419   /* Test 5: Set time value to 24h 60m 60s to test time (am) with seconds*/
 420   initial_hours=24;
 421   initial_minutes=60;
 422   initial_seconds=60;
 423   expected_hours=23;
 424   expected_minutes=1;
 425   expected_seconds=0;
 426
 427   time_editor = create_and_show_time_editor(showed_window,TRUE,FALSE);
 428
 429   hildon_time_editor_set_time(time_editor,initial_hours,initial_minutes,initial_seconds);
 430
 431   hildon_time_editor_get_time(time_editor,&hours,&minutes,&seconds);
 432
 433   fail_if((expected_hours != hours) || (expected_minutes != minutes) || (expected_seconds != seconds),
 434           "hildon-time-editor: set_time/get_time failed with values (%dh %dm %ds). Result values are (%dh %dm %ds) and expected values are (%dh %dm %ds)",
 435           initial_hours,initial_minutes,initial_seconds,hours,minutes,seconds,expected_hours,expected_minutes,expected_seconds);
 436
 437   remove_and_destroy_time_editor(showed_window,&time_editor);
 438
 439   /* Test 6: Set time value to 50h 100m 100s to test time (am) with seconds */
 440   initial_hours=50;
 441   initial_minutes=100;
 442   initial_seconds=100;
 443   expected_hours=23;
 444   expected_minutes=41;
 445   expected_seconds=40;
 446
 447   time_editor = create_and_show_time_editor(showed_window,TRUE,FALSE);
 448
 449   hildon_time_editor_set_time(time_editor,initial_hours,initial_minutes,initial_seconds);
 450
 451   hildon_time_editor_get_time(time_editor,&hours,&minutes,&seconds);
 452
 453   fail_if((expected_hours != hours) || (expected_minutes != minutes) || (expected_seconds != seconds),
 454           "hildon-time-editor: set_time/get_time failed with values (%d:%dm:%ds). Result values are (%d:%dm:%ds) and expected values are (%d:%dm:%ds)",
 455           initial_hours,initial_minutes,initial_seconds,hours,minutes,seconds,expected_hours,expected_minutes,expected_seconds);
 456
 457   remove_and_destroy_time_editor(showed_window,&time_editor);
 458
 459
 460   /* Test 7: Set time value to 0:80:80 to test with duration mode */
 461   initial_hours=0;
 462   initial_minutes=80;
 463   initial_seconds=80;
 464   expected_hours=1;
 465   expected_minutes=21;
 466   expected_seconds=20;
 467
 468   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
 469
 470   hildon_time_editor_set_time(time_editor,initial_hours,initial_minutes,initial_seconds);
 471
 472   hildon_time_editor_get_time(time_editor,&hours,&minutes,&seconds);
 473
 474   fail_if((expected_hours != hours) || (expected_minutes != minutes) || (expected_seconds != seconds),
 475           "hildon-time-editor: set_time/get_time failed with values (%d:%d:%d). Result values are (%d:%d:%d) and expected values are (%d:%d:%d)",
 476           initial_hours,initial_minutes,initial_seconds,hours,minutes,seconds,expected_hours,expected_minutes,expected_seconds);
 477
 478   remove_and_destroy_time_editor(showed_window,&time_editor);
 479
 480   /* Test 8: Set time value to 110:80:80 to test with duration mode */
 481   initial_hours=110;
 482   initial_minutes=80;
 483   initial_seconds=80;
 484   expected_hours=99;
 485   expected_minutes=59;
 486   expected_seconds=59;
 487
 488   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
 489
 490   hildon_time_editor_set_time(time_editor,initial_hours,initial_minutes,initial_seconds);
 491
 492   hildon_time_editor_get_time(time_editor,&hours,&minutes,&seconds);
 493
 494
 495   fail_if((expected_hours != hours) || (expected_minutes != minutes) || (expected_seconds != seconds),
 496           "hildon-time-editor: set_time/get_time failed with values (%d:%d:%d). Result values are (%d:%d:%d) and expected values are (%d:%d:%d)",
 497           initial_hours,initial_minutes,initial_seconds,hours,minutes,seconds,expected_hours,expected_minutes,expected_seconds);
 498
 499   remove_and_destroy_time_editor(showed_window,&time_editor);
 500
 501 }
 502 END_TEST
 503
 504
 505 /* ----- Test case for set_ticks -----*/
 506
 507 /**
 508  * Purpose: Check that regular ticks values are set and get properly
 509  * Cases considered:
 510  *    - Set and get ticks to 45660s using time editor object with time mode.
 511  *    - Set and get ticks to 124860s using time editor object with duration mode.
 512  */
 513 START_TEST (test_set_ticks_regular)
 514 {
 515   guint initial_ticks;
 516   guint ticks;
 517   HildonTimeEditor *time_editor = NULL;
 518
 519   /* Test 1: Set tick to 45660 seconds to test set_ticks */
 520
 521   initial_ticks=45660;
 522   time_editor = create_and_show_time_editor(showed_window,FALSE,FALSE);
 523
 524   hildon_time_editor_set_ticks(time_editor,initial_ticks);
 525
 526   ticks = hildon_time_editor_get_ticks(time_editor);
 527
 528   fail_if(( initial_ticks!=ticks ),
 529           "hildon-time-editor: set_ticks or get_ticks failed with %d. Expected result is %d",initial_ticks,ticks);
 530
 531   remove_and_destroy_time_editor(showed_window,&time_editor);
 532
 533
 534   /* Test 2: Set tick to 124860 seconds to test set_ticks */
 535
 536   initial_ticks=124860;
 537
 538   time_editor = create_and_show_time_editor(showed_window,FALSE,TRUE);
 539
 540   hildon_time_editor_set_ticks(time_editor,initial_ticks);
 541
 542   ticks = hildon_time_editor_get_ticks(time_editor);
 543
 544   fail_if(( initial_ticks!=ticks ),
 545           "hildon-time-editor: set_ticks or get_ticks failed with %d. Expected result is %d",initial_ticks,ticks);
 546
 547   remove_and_destroy_time_editor(showed_window,&time_editor);
 548
 549 }
 550 END_TEST
 551
 552 /**
 553  * Purpose: Check that limit ticks values are set and get properly
 554  * Cases considered:
 555  *    - Set and get ticks to 0s using time editor object with time mode.
 556  *    - Set and get ticks to 86399s  using time editor object with time mode. 86399 seconds are 23h 59m 59s.
 557  *    - Set and get ticks to 0s using time editor object with duration mode.
 558  *    - Set and get ticks to 359999s using time editor object with duration mode. 359999 seconds are 99:59:59.
 559  */
 560 START_TEST (test_set_ticks_limits)
 561 {
 562   guint initial_ticks;
 563   guint ticks;
 564   HildonTimeEditor *time_editor = NULL;
 565
 566   /* Test 1: Set ticks to 0 seconds to test set_ticks with */
 567
 568   initial_ticks=0;
 569   time_editor = create_and_show_time_editor(showed_window,FALSE,FALSE);
 570
 571   hildon_time_editor_set_ticks(time_editor,initial_ticks);
 572
 573   ticks = hildon_time_editor_get_ticks(time_editor);
 574
 575   fail_if(( initial_ticks!=ticks ),
 576           "hildon-time-editor: set_ticks or get_ticks failed with %d. Expected result is %d",initial_ticks,ticks);
 577
 578   remove_and_destroy_time_editor(showed_window,&time_editor);
 579
 580   /* Test 2: Set ticks to 86399 seconds to test set_ticks */
 581   initial_ticks=86399;
 582   time_editor = create_and_show_time_editor(showed_window,TRUE,FALSE);
 583
 584   hildon_time_editor_set_ticks(time_editor,initial_ticks);
 585
 586   ticks = hildon_time_editor_get_ticks(time_editor);
 587
 588   fail_if(( initial_ticks!=ticks ),
 589           "hildon-time-editor: set_ticks or get_ticks failed with %d. Expected result is %d",initial_ticks,ticks);
 590
 591   remove_and_destroy_time_editor(showed_window,&time_editor);
 592
 593
 594   /* Test 3: Set ticks to 0 seconds to test set_ticks */
 595
 596   initial_ticks=0;
 597   time_editor = create_and_show_time_editor(showed_window,FALSE,TRUE);
 598
 599   hildon_time_editor_set_ticks(time_editor,initial_ticks);
 600
 601   ticks = hildon_time_editor_get_ticks(time_editor);
 602
 603   fail_if(( initial_ticks!=ticks ),
 604           "hildon-time-editor: set_ticks or get_ticks failed with %d. Expected result is %d",initial_ticks,ticks);
 605
 606   remove_and_destroy_time_editor(showed_window,&time_editor);
 607
 608   /* Test 4: Set ticks to 359999 seconds to test set_ticks */
 609
 610   initial_ticks=359999;
 611   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
 612
 613   hildon_time_editor_set_ticks(time_editor,initial_ticks);
 614
 615   ticks = hildon_time_editor_get_ticks(time_editor);
 616
 617   fail_if(( initial_ticks!=ticks ),
 618           "hildon-time-editor: set_ticks or get_ticks failed with %d. Expected result is %d",initial_ticks,ticks);
 619   remove_and_destroy_time_editor(showed_window,&time_editor);
 620
 621 }
 622 END_TEST
 623
 624 /**
 625  * Purpose: Check that invalid ticks values are set and get properly. In this tests we'll test several invalid
 626  *          values with the same case because the "mod" operator will define the time set.
 627  * Cases considered:
 628  *    - Set and get ticks to 86400s using time editor object with time mode. 86399 seconds are 23h 59m 59s.
 629  *    - Set and get ticks to 360000s using time editor object with time mode.
 630  *    - Set and get ticks to 90060s using time editor object with time.
 631  *    - Set and get ticks to 360000s using time editor object with duration mode. 359999 seconds are 99:59:59.
 632  *    - Set and get ticks to 654333s using time editor object with duration mode.
 633  *    - Set ticks on NULL object.
 634  */
 635 START_TEST (test_set_ticks_invalid)
 636 {
 637   guint initial_ticks;
 638   guint expected_ticks;
 639   guint ticks;
 640   HildonTimeEditor *time_editor = NULL;
 641
 642   initial_ticks=86400;
 643   expected_ticks=82800;
 644
 645   /* Test 1: Set ticks to 86400 seconds to test set_ticks */
 646   time_editor = create_and_show_time_editor(showed_window,TRUE,FALSE);
 647
 648   hildon_time_editor_set_ticks(time_editor,initial_ticks);
 649
 650   ticks = hildon_time_editor_get_ticks(time_editor);
 651
 652   fail_if(( expected_ticks!=ticks ),
 653           "hildon-time-editor: set_ticks or get_ticks failed with %d. Expected result is %d and result is %d",
 654           initial_ticks,expected_ticks,ticks);
 655
 656   remove_and_destroy_time_editor(showed_window,&time_editor);
 657
 658   /* Test 2: Set ticks to 360000 seconds to test set_ticks */
 659   initial_ticks=360001;
 660   expected_ticks=82801;
 661
 662   time_editor = create_and_show_time_editor(showed_window,TRUE,FALSE);
 663
 664   hildon_time_editor_set_ticks(time_editor,initial_ticks);
 665
 666   ticks = hildon_time_editor_get_ticks(time_editor);
 667
 668   fail_if(( expected_ticks!=ticks ),
 669           "hildon-time-editor: set_ticks or get_ticks failed with %d. Expected result is %d and result is %d",
 670           initial_ticks,expected_ticks,ticks);
 671
 672   remove_and_destroy_time_editor(showed_window,&time_editor);
 673
 674   /* Test 3: Set ticks to 90060 seconds to test set_ticks */
 675   initial_ticks=90060;
 676   expected_ticks=82860;
 677
 678   time_editor = create_and_show_time_editor(showed_window,TRUE,FALSE);
 679
 680   hildon_time_editor_set_ticks(time_editor,initial_ticks);
 681
 682   ticks = hildon_time_editor_get_ticks(time_editor);
 683
 684   fail_if(( expected_ticks!=ticks ),
 685           "hildon-time-editor: set_ticks or get_ticks failed with %d. Expected result is %d and result is %d",
 686           initial_ticks,expected_ticks,ticks);
 687
 688   remove_and_destroy_time_editor(showed_window,&time_editor);
 689
 690   /* Test 4: Set ticks to 360000 seconds to test set_ticks */
 691
 692   initial_ticks=360000;
 693   expected_ticks=359999;
 694
 695   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
 696
 697   hildon_time_editor_set_ticks(time_editor,initial_ticks);
 698
 699   ticks = hildon_time_editor_get_ticks(time_editor);
 700
 701   fail_if(( expected_ticks!=ticks ),
 702           "hildon-time-editor: set_ticks or get_ticks failed with %d. Expected result is %d and result is %d",
 703           initial_ticks,expected_ticks,ticks);
 704
 705   remove_and_destroy_time_editor(showed_window,&time_editor);
 706
 707   /* Test 5: Set ticks to 654333 seconds to test set_ticks */
 708
 709   initial_ticks=654333;
 710   expected_ticks=359999;
 711
 712   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
 713
 714   hildon_time_editor_set_ticks(time_editor,initial_ticks);
 715
 716   ticks = hildon_time_editor_get_ticks(time_editor);
 717
 718   fail_if(( expected_ticks!=ticks ),
 719           "hildon-time-editor: set_ticks or get_ticks failed with %d. Expected result is %d and result is %d",
 720           initial_ticks,expected_ticks,ticks);
 721
 722   remove_and_destroy_time_editor(showed_window,&time_editor);
 723
 724   /* Test 6: Set initial_ticks on NULL */
 725   hildon_time_editor_set_ticks(NULL,initial_ticks);
 726 }
 727 END_TEST
 728
 729
 730 /* ----- Test case for set_duration_min_set_duration_max -----*/
 731
 732 /**
 733  * Purpose: Check that regular minimum/maximum values are set/get properly and check that set_duration_mode works well,
 734  *          because min and max can not be set without duration mode set.
 735  * Cases considered:
 736  *    - Set and get minimum duration to 100000 having ticks under 100000 using time editor object with duration mode.
 737  *    - Set and get minimum duration to 100000 having ticks over 100000 using time editor object with duration mode.
 738  *    - Set and get maximum duration to 200000 having ticks under 200000 using time editor object with duration mode.
 739  *    - Set and get maximum duration to 200000 having ticks over 200000 using time editor object with duration mode.
 740  */
 741 START_TEST (test_set_duration_min_set_duration_max_regular)
 742 {
 743   guint initial_duration_min;
 744   guint duration_min;
 745   guint initial_duration_max;
 746   guint duration_max;
 747   guint expected_ticks;
 748   guint ticks;
 749   HildonTimeEditor *time_editor = NULL;
 750
 751   time_editor = create_and_show_time_editor(showed_window,FALSE,TRUE);
 752   /* Initialize values in order to avoid side effects from previous tests */
 753   hildon_time_editor_set_duration_min(time_editor,MIN_DURATION);
 754   hildon_time_editor_set_duration_max(time_editor,MAX_DURATION);
 755
 756   /* set_min tests*/
 757
 758   /* Test 1: Set and get minimum duration to 100000 having ticks under 100000 using time editor object with duration mode. */
 759   initial_duration_min=100000;
 760   expected_ticks=initial_duration_min;
 761
 762   hildon_time_editor_set_ticks(time_editor,initial_duration_min-1000);
 763   hildon_time_editor_set_duration_min(time_editor,initial_duration_min);
 764   duration_min = hildon_time_editor_get_duration_min(time_editor);
 765   ticks = hildon_time_editor_get_ticks(time_editor);
 766
 767   fail_if(( initial_duration_min!=duration_min) | (ticks!=expected_ticks),
 768           "hildon-time-editor: set_duration_min or get_duration_min failed with %d. Expected result is %d. Set ticks to %d, expected ticks are %d and result is %d",
 769           initial_duration_min,duration_min,initial_duration_min-1000,expected_ticks,ticks);
 770
 771   remove_and_destroy_time_editor(showed_window,&time_editor);
 772
 773   /* Test 2: Set and get minimum duration to 100000 having ticks over 100000 using time editor object with duration mode.*/
 774   initial_duration_min=100000;
 775   expected_ticks=initial_duration_min+980;
 776
 777   time_editor = create_and_show_time_editor(showed_window,FALSE,TRUE);
 778
 779   hildon_time_editor_set_ticks(time_editor,expected_ticks);
 780   hildon_time_editor_set_duration_min(time_editor,initial_duration_min);
 781   duration_min = hildon_time_editor_get_duration_min(time_editor);
 782   ticks = hildon_time_editor_get_ticks(time_editor);
 783
 784   fail_if(( initial_duration_min!=duration_min) | (ticks!=expected_ticks),
 785           "hildon-time-editor: set_duration_min or get_duration_min failed with %d. Expected result is %d. Set ticks to %d and result is %d",
 786           initial_duration_min,duration_min,ticks,expected_ticks);
 787
 788   remove_and_destroy_time_editor(showed_window,&time_editor);
 789
 790
 791
 792   /* Test 3: Set and get maximum duration to 200000 having ticks under 200000 using time editor object with duration mode. */
 793   initial_duration_max=200000;
 794   expected_ticks=initial_duration_max-1040;
 795   time_editor = create_and_show_time_editor(showed_window,FALSE,TRUE);
 796
 797   hildon_time_editor_set_ticks(time_editor,expected_ticks);
 798   hildon_time_editor_set_duration_max(time_editor,initial_duration_max);
 799   duration_max = hildon_time_editor_get_duration_max(time_editor);
 800   ticks = hildon_time_editor_get_ticks(time_editor);
 801
 802   fail_if(( initial_duration_max!=duration_max) | (ticks!=expected_ticks),
 803           "hildon-time-editor: set_duration_max or get_duration_max failed with %d. Expected result is %d. Set ticks to %d and result is %d",
 804           initial_duration_max,duration_max,ticks,expected_ticks);
 805
 806   remove_and_destroy_time_editor(showed_window,&time_editor);
 807
 808   /* Test 4: Set and get maximum duration to 200000 having ticks over 200000 using time editor object with duration mode.*/
 809   initial_duration_max=200000;
 810   expected_ticks=initial_duration_max+1000;
 811   time_editor = create_and_show_time_editor(showed_window,FALSE,TRUE);
 812
 813   hildon_time_editor_set_ticks(time_editor,expected_ticks);
 814   hildon_time_editor_set_duration_max(time_editor,initial_duration_max);
 815   duration_max = hildon_time_editor_get_duration_max(time_editor);
 816   ticks = hildon_time_editor_get_ticks(time_editor);
 817
 818   fail_if(( initial_duration_max!=duration_max) | (ticks!=initial_duration_max),
 819           "hildon-time-editor: set_duration_max or get_duration_max failed with %d. Expected result is %d. Set ticks to %d, expected result is %d and result is %d",
 820           initial_duration_max,duration_max,expected_ticks,initial_duration_max,ticks);
 821
 822   remove_and_destroy_time_editor(showed_window,&time_editor);
 823
 824 }
 825 END_TEST
 826
 827
 828 /**
 829  * Purpose: Check that limits duration minimum/maximum values are set and get properly.
 830  * Cases considered:
 831  *    - Set and get minimum duration to MIN_DURATION having ticks over MIN_DURATION using time editor object with duration mode.
 832  *    - Set and get maximum duration to MAX_DURATION having ticks under MAX_DURATION.
 833  *      using time editor object with duration mode. 359940 seconds are 99:59:00.
 834  *    - Set and get maximum duration to MIN_DURATION having ticks over MIN_DURATION using time editor object with duration mode.
 835  *    - Set and get minimum duration to MAX_DURATION having ticks under MAX_DURATION.
 836  *      using time editor object with duration mode. 359999 seconds are 99:59:59.
 837  */
 838 START_TEST (test_set_duration_min_set_duration_max_limits)
 839 {
 840   guint initial_duration_min;
 841   guint duration_min;
 842   guint initial_duration_max;
 843   guint duration_max;
 844   guint expected_ticks;
 845   guint ticks;
 846      HildonTimeEditor *time_editor = NULL;
 847
 848
 849   /* Test 1: Set minimum duration to MAX_DURATION seconds having ticks under MAX_DURATION. */
 850   expected_ticks=MIN_DURATION+1;
 851   initial_duration_min=MIN_DURATION;
 852
 853   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
 854
 855   hildon_time_editor_set_ticks(time_editor,expected_ticks);
 856   hildon_time_editor_set_duration_min(time_editor,initial_duration_min);
 857   duration_min = hildon_time_editor_get_duration_min(time_editor);
 858   ticks = hildon_time_editor_get_ticks(time_editor);
 859
 860   fail_if(( initial_duration_min!=duration_min) | (ticks!=expected_ticks),
 861           "hildon-time-editor: set_duration_min or get_duration_min failed with %d. Expected result is %d. Set ticks to %d and result is %d",
 862           initial_duration_min,duration_min,expected_ticks,ticks);
 863
 864   remove_and_destroy_time_editor(showed_window,&time_editor);
 865
 866   /* Test 2: Set maximum duration to MAX_DURATION seconds having ticks under MAX_DURATION. */
 867   expected_ticks=MAX_DURATION-59;
 868   initial_duration_max=MAX_DURATION;
 869
 870   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
 871
 872   hildon_time_editor_set_ticks(time_editor,expected_ticks);
 873   hildon_time_editor_set_duration_max(time_editor,initial_duration_max);
 874   duration_max = hildon_time_editor_get_duration_max(time_editor);
 875   ticks = hildon_time_editor_get_ticks(time_editor);
 876
 877   fail_if(( initial_duration_max!=duration_max) | (ticks!=expected_ticks),
 878           "hildon-time-editor: set_duration_max or get_duration_max failed with %d. Expected result is %d. Set ticks to %d and result is %d",
 879           initial_duration_max,duration_max,expected_ticks,ticks);
 880
 881   remove_and_destroy_time_editor(showed_window,&time_editor);
 882
 883   /* Test 3:  Set and get maximum duration to MIN_DURATION having ticks over MIN_DURATION
 884      using time editor object with duration mode. */
 885   expected_ticks=MIN_DURATION+1;
 886   initial_duration_max=MIN_DURATION;
 887
 888   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
 889
 890   hildon_time_editor_set_ticks(time_editor,expected_ticks);
 891   hildon_time_editor_set_duration_max(time_editor,initial_duration_max);
 892   duration_max = hildon_time_editor_get_duration_max(time_editor);
 893   ticks = hildon_time_editor_get_ticks(time_editor);
 894
 895   fail_if(( initial_duration_max!=duration_max) | (ticks!=MIN_DURATION),
 896           "hildon-time-editor: set_duration_max or get_duration_max failed with %d. Expected result is %d. Set ticks to %d and result is %d",
 897           initial_duration_max,duration_max,expected_ticks,ticks);
 898
 899   remove_and_destroy_time_editor(showed_window,&time_editor);
 900
 901   /* Test 4: Set and get minimum duration to MIN_DURATION having ticks over MIN_DURATION
 902      using time editor object with duration mode. */
 903   expected_ticks=MAX_DURATION-1;
 904   initial_duration_min=MAX_DURATION;
 905
 906   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
 907
 908   hildon_time_editor_set_ticks(time_editor,expected_ticks);
 909   hildon_time_editor_set_duration_min(time_editor,initial_duration_min);
 910   duration_min = hildon_time_editor_get_duration_min(time_editor);
 911   ticks = hildon_time_editor_get_ticks(time_editor);
 912
 913   fail_if(( initial_duration_min!=duration_min) | (ticks!=MAX_DURATION),
 914           "hildon-time-editor: set_duration_min or get_duration_min failed with %d. Expected result is %d. Set ticks to %d and result is %d",
 915           initial_duration_min,duration_min,ticks,MAX_DURATION);
 916
 917   remove_and_destroy_time_editor(showed_window,&time_editor);
 918
 919 }
 920 END_TEST
 921
 922 /**
 923  * Purpose: Check that invalid minimum/maximum duration values are set and get properly.
 924  * Cases considered:
 925  *    - Set duration_min on NULL object.
 926  *    - Set and get minimum duration to MAX_DURATION+1 using time editor object with duration mode
 927  *      setting ticks previously with a value under MAX_DURATION.
 928  *    - Set and get minimum duration to MAX_DURATION+1 using time editor object with duration mode
 929  *      setting ticks previously with a value over MAX_DURATION.
 930  *    - Set duration_max on NULL object.
 931  *    - Set and get maximum duration to MAX_DURATION+1 using time editor object with duration mode
 932  *      setting ticks previously with a value under MAX_DURATION.
 933  *    - Set and get maximum duration to MAX_DURATION+1 using time editor object with duration mode
 934  *      setting ticks previously with a value over MAX_DURATION.
 935  */
 936 START_TEST (test_set_duration_min_set_duration_max_invalid)
 937 {
 938   guint initial_duration_min;
 939   guint expected_duration_min;
 940   guint duration_min;
 941   guint initial_duration_max;
 942   guint expected_duration_max;
 943   guint duration_max;
 944   guint expected_ticks;
 945   guint ticks;
 946   HildonTimeEditor *time_editor = NULL;
 947
 948
 949   /* Test 1: Set minimum duration on NULL object */
 950   hildon_time_editor_set_duration_min(NULL,MIN_DURATION);
 951
 952   /* Test 2: Set minimum duration to MAX_DURATION+1 seconds to test set_duration_min */
 953   initial_duration_min=MAX_DURATION+1;
 954   expected_duration_min=MAX_DURATION+1;
 955   expected_ticks=MAX_DURATION-1;
 956
 957   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
 958
 959   hildon_time_editor_set_ticks(time_editor,expected_ticks);
 960   hildon_time_editor_set_duration_min(time_editor,initial_duration_min);
 961   duration_min = hildon_time_editor_get_duration_min(time_editor);
 962   ticks = hildon_time_editor_get_ticks(time_editor);
 963
 964   fail_if(( expected_duration_min!=duration_min) | (ticks!=MAX_DURATION),
 965           "hildon-time-editor: set_duration_min or get_duration_min failed with %d. Expected result is %d and result is %d. Set ticks to %d, expected result is %d and result is %d",
 966           initial_duration_min,duration_min,expected_duration_min,expected_ticks,MAX_DURATION,ticks);
 967
 968   remove_and_destroy_time_editor(showed_window,&time_editor);
 969
 970   /* Test 3: Set minimum duration to MAX_DURATION+1 seconds to test set_duration_min */
 971   initial_duration_min=MAX_DURATION+1;
 972   expected_duration_min=MAX_DURATION+1;
 973   expected_ticks=MAX_DURATION+2;
 974
 975   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
 976
 977   hildon_time_editor_set_ticks(time_editor,expected_ticks);
 978   hildon_time_editor_set_duration_min(time_editor,initial_duration_min);
 979   duration_min = hildon_time_editor_get_duration_min(time_editor);
 980   ticks = hildon_time_editor_get_ticks(time_editor);
 981
 982   fail_if(( expected_duration_min!=duration_min) | (ticks!=MAX_DURATION),
 983           "hildon-time-editor: set_duration_min or get_duration_min failed with %d. Expected result is %d and result is %d. Set ticks to %d, expected result is %d and result is %d",
 984           initial_duration_min,duration_min,expected_duration_min,expected_ticks,MAX_DURATION,ticks);
 985
 986   remove_and_destroy_time_editor(showed_window,&time_editor);
 987
 988   /* Test 4: Set maximum duration on NULL object */
 989   hildon_time_editor_set_duration_max(NULL,MAX_DURATION);
 990
 991   /* Test 5: Set maximum duration to MAX_DURATION+1 seconds to test set_duration_max settings ticks under MAX_DURATION*/
 992   initial_duration_max=MAX_DURATION+1;
 993   expected_duration_max=MAX_DURATION;
 994   expected_ticks=MAX_DURATION-59;
 995
 996   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
 997
 998   hildon_time_editor_set_ticks(time_editor,expected_ticks);
 999   hildon_time_editor_set_duration_max(time_editor,initial_duration_max);
1000   duration_max = hildon_time_editor_get_duration_max(time_editor);
1001   ticks = hildon_time_editor_get_ticks(time_editor);
1002
1003   fail_if(( expected_duration_max!=duration_max) | (ticks!=expected_ticks),
1004           "hildon-time-editor: set_duration_max or get_duration_max failed with %d. Expected result is %d and result is %d. Set ticks to %d, expected result is %d and result is %d",
1005           initial_duration_max,duration_max,expected_duration_max,expected_ticks,expected_ticks,ticks);
1006
1007   remove_and_destroy_time_editor(showed_window,&time_editor);
1008
1009   /* Initialize values in order to avoid side effects from previous tests */
1010   initial_duration_max=MAX_DURATION+1;
1011   expected_duration_max=MAX_DURATION;
1012   expected_ticks=MAX_DURATION+1;
1013
1014   /* Test 6: Set maximum duration to MAX_DURATION+1 seconds to test set_duration_max setting ticks over MAX_DURATION */
1015   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
1016
1017   hildon_time_editor_set_ticks(time_editor,expected_ticks);
1018   hildon_time_editor_set_duration_max(time_editor,initial_duration_max);
1019   duration_max = hildon_time_editor_get_duration_max(time_editor);
1020   ticks = hildon_time_editor_get_ticks(time_editor);
1021   fail_if(( expected_duration_max!=duration_max),
1022           "hildon-time-editor: set_duration_max or get_duration_max failed with %d. Expected result is %d and result is %d. Set ticks to %d, expected result is %d and result is %d",
1023           initial_duration_max,duration_max,expected_duration_max,expected_ticks,MAX_DURATION,ticks);
1024
1025   /*  fail_if(( expected_duration_max!=duration_max) | (ticks!=MAX_DURATION),
1026           "hildon-time-editor: set_duration_max or get_duration_max failed with %d. Expected result is %d and result is %d. Set ticks to %d, expected result is %d and result is %d",
1027           initial_duration_max,duration_max,expected_duration_max,expected_ticks,MAX_DURATION,ticks);
1028   */
1029   remove_and_destroy_time_editor(showed_window,&time_editor);
1030
1031
1032 }
1033 END_TEST
1034
1035 /* ----- Test case for set_duration_range  -----*/
1036
1037 /**
1038  * Purpose: Check that regular range values are set and get properly
1039  * Cases considered:
1040  *    - Set and get duration range (100000,200000) having ticks under 100000 using time editor object with duration mode.
1041  *    - Set and get duration range (100000,200000) having ticks between 100000 and 200000 using time editor object with duration mode.
1042  *    - Set and get duration range (100000,200000) having ticks over 200000 using time editor object with duration mode.
1043  *    - Set and get duration range (100000,100000) having ticks under 100000 using time editor object with duration mode.
1044  *    - Set and get duration range (100000,100000) having ticks equal to 100000 using time editor object with duration mode.
1045  *    - Set and get duration range (100000,100000) having ticks over 100000 using time editor object with duration mode.
1046  *
1047  */
1048 START_TEST (test_set_duration_range_regular)
1049 {
1050   guint initial_duration_min;
1051   guint initial_duration_max;
1052   guint duration_min;
1053   guint duration_max;
1054   guint expected_ticks;
1055   guint ticks;
1056   HildonTimeEditor *time_editor = NULL;
1057
1058   /* Test 1: Set duration range to (100000,200000) seconds to test set_duration_range having ticks under 100000 */
1059   initial_duration_min=100000;
1060   initial_duration_max=200000;
1061   expected_ticks=90000;
1062
1063   /* Initialize values in order to avoid side effects from previous tests */
1064   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
1065
1066   hildon_time_editor_set_ticks(time_editor,expected_ticks);
1067   hildon_time_editor_set_duration_range(time_editor,initial_duration_min,initial_duration_max);
1068   hildon_time_editor_get_duration_range(time_editor,&duration_min,&duration_max);
1069   ticks = hildon_time_editor_get_ticks(time_editor);
1070
1071   fail_if( ( (initial_duration_min!=duration_min) | (initial_duration_max!=duration_max) | ( ticks!=initial_duration_min )),
1072            "hildon-time-editor: set_duration_range or get_duration_range failed with (minimum,maximum) as (%d,%d). Expected range is (%d,%d). Set ticks to %d and expected ticks are %d ",
1073            initial_duration_min,initial_duration_max,duration_min,duration_max,ticks,initial_duration_min);
1074
1075   remove_and_destroy_time_editor(showed_window,&time_editor);
1076
1077   /* Test 2: Set duration range to (100000,200000) seconds to test set_duration_range having ticks between 100000 and 200000 */
1078   initial_duration_min=100000;
1079   initial_duration_max=200000;
1080   expected_ticks=150000;
1081   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
1082
1083   hildon_time_editor_set_ticks(time_editor,expected_ticks);
1084   hildon_time_editor_set_duration_range(time_editor,initial_duration_min,initial_duration_max);
1085   hildon_time_editor_get_duration_range(time_editor,&duration_min,&duration_max);
1086   ticks = hildon_time_editor_get_ticks(time_editor);
1087
1088   fail_if( ( (initial_duration_min!=duration_min) | (initial_duration_max!=duration_max) | ( ticks!=initial_duration_min )),
1089            "hildon-time-editor: set_duration_range or get_duration_range failed with (minimum,maximum) as (%d,%d). Expected range is (%d,%d). Set ticks to %d and expected ticks are %d ",
1090            initial_duration_min,initial_duration_max,duration_min,duration_max,ticks,initial_duration_min);
1091
1092   remove_and_destroy_time_editor(showed_window,&time_editor);
1093
1094
1095   /* Test 3: Set duration range to (100000,200000) seconds to test set_duration_range having ticks over 200000*/
1096   initial_duration_min=100000;
1097   initial_duration_max=200000;
1098   expected_ticks=220000;
1099
1100   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
1101
1102   hildon_time_editor_set_ticks(time_editor,expected_ticks);
1103   hildon_time_editor_set_duration_range(time_editor,initial_duration_min,initial_duration_max);
1104   hildon_time_editor_get_duration_range(time_editor,&duration_min,&duration_max);
1105   ticks = hildon_time_editor_get_ticks(time_editor);
1106
1107   fail_if( ( (initial_duration_min!=duration_min) | (initial_duration_max!=duration_max) | ( ticks!=initial_duration_min )),
1108            "hildon-time-editor: set_duration_range or get_duration_range failed with (minimum,maximum) as (%d,%d). Expected range is (%d,%d). Set ticks to %d and expected ticks are %d ",
1109            initial_duration_min,initial_duration_max,duration_min,duration_max,ticks,initial_duration_min);
1110
1111   remove_and_destroy_time_editor(showed_window,&time_editor);
1112
1113   /* Test 4: Set duration range to (100000,100000) seconds to test set_duration_range having ticks under 100000 */
1114   initial_duration_min=100000;
1115   initial_duration_max=100000;
1116   expected_ticks=90000;
1117
1118   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
1119
1120   hildon_time_editor_set_ticks(time_editor,expected_ticks);
1121   hildon_time_editor_set_duration_range(time_editor,initial_duration_min,initial_duration_max);
1122   hildon_time_editor_get_duration_range(time_editor,&duration_min,&duration_max);
1123   ticks = hildon_time_editor_get_ticks(time_editor);
1124
1125   fail_if( ( (initial_duration_min!=duration_min) | (initial_duration_max!=duration_max) | ( ticks!=initial_duration_min )),
1126            "hildon-time-editor: set_duration_range or get_duration_range failed with (minimum,maximum) as (%d,%d). Expected range is (%d,%d). Set ticks to %d and expected ticks are %d ",
1127            initial_duration_min,initial_duration_max,duration_min,duration_max,ticks,initial_duration_min);
1128
1129   remove_and_destroy_time_editor(showed_window,&time_editor);
1130
1131   /* Test 5: Set duration range to (100000,100000) seconds to test set_duration_range having ticks equal to 100000 */
1132   initial_duration_min=100000;
1133   initial_duration_max=100000;
1134   expected_ticks=100000;
1135
1136   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
1137
1138   hildon_time_editor_set_ticks(time_editor,expected_ticks);
1139   hildon_time_editor_set_duration_range(time_editor,initial_duration_min,initial_duration_max);
1140   hildon_time_editor_get_duration_range(time_editor,&duration_min,&duration_max);
1141   ticks = hildon_time_editor_get_ticks(time_editor);
1142
1143   fail_if( ( (initial_duration_min!=duration_min) | (initial_duration_max!=duration_max) | ( ticks!=initial_duration_min )),
1144            "hildon-time-editor: set_duration_range or get_duration_range failed with (minimum,maximum) as (%d,%d). Expected range is (%d,%d). Set ticks to %d and expected ticks are %d ",
1145            initial_duration_min,initial_duration_max,duration_min,duration_max,ticks,initial_duration_min);
1146
1147   remove_and_destroy_time_editor(showed_window,&time_editor);
1148
1149   /* Test 6: Set duration range to (100000,100000) seconds to test set_duration_range having ticks over 100000 */
1150   initial_duration_min=100000;
1151   initial_duration_max=100000;
1152   expected_ticks=120000;
1153
1154   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
1155
1156   hildon_time_editor_set_ticks(time_editor,expected_ticks);
1157   hildon_time_editor_set_duration_range(time_editor,initial_duration_min,initial_duration_max);
1158   hildon_time_editor_get_duration_range(time_editor,&duration_min,&duration_max);
1159   ticks = hildon_time_editor_get_ticks(time_editor);
1160
1161   fail_if( ( (initial_duration_min!=duration_min) | (initial_duration_max!=duration_max) | ( ticks!=initial_duration_min )),
1162            "hildon-time-editor: set_duration_range or get_duration_range failed with (minimum,maximum) as (%d,%d). Expected range is (%d,%d). Set ticks to %d and expected ticks are %d ",
1163            initial_duration_min,initial_duration_max,duration_min,duration_max,ticks,initial_duration_min);
1164
1165   remove_and_destroy_time_editor(showed_window,&time_editor);
1166
1167
1168 }
1169 END_TEST
1170
1171 /**
1172  * Purpose: Check that limits range values are set and get properly
1173  * Cases considered:
1174  *    - Set and get duration range to (MIN_DURATION,MAX_DURATION) having ticks between MIN_DURATION and MAX_DURATION
1175  *      using time editor object with duration mode.
1176  *    - Set and get duration range to (MIN_DURATION,MIN_DURATION) having ticks over MIN_DURATION
1177  *      using time editor object with duration mode.
1178  *    - Set and get duration range to (MAX_DURATION,MAX_DURATION) having ticks under MAX_DURATION
1179  *      using time editor object with duration mode.
1180  *
1181  */
1182 START_TEST (test_set_duration_range_limits)
1183 {
1184   guint initial_duration_min;
1185   guint initial_duration_max;
1186   guint duration_min;
1187   guint duration_max;
1188   guint expected_ticks;
1189   guint ticks;
1190   HildonTimeEditor *time_editor = NULL;
1191
1192
1193   /* Test 1: Set duration range to (MIN_DURATION,MAX_DURATION) seconds to test set_duration_range having ticks under MIN_DURATION */
1194   initial_duration_min=MIN_DURATION;
1195   initial_duration_max=MAX_DURATION;
1196   expected_ticks=MIN_DURATION+1;
1197
1198   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
1199
1200   /* Initialize values in order to avoid side effects from previous tests */
1201   hildon_time_editor_set_duration_min(time_editor,MIN_DURATION);
1202   hildon_time_editor_set_duration_max(time_editor,MAX_DURATION);
1203
1204   hildon_time_editor_set_ticks(time_editor,expected_ticks);
1205   hildon_time_editor_set_duration_range(time_editor,initial_duration_min,initial_duration_max);
1206   hildon_time_editor_get_duration_range(time_editor,&duration_min,&duration_max);
1207   ticks = hildon_time_editor_get_ticks(time_editor);
1208
1209   fail_if( ( (initial_duration_min!=duration_min) | (initial_duration_max!=duration_max) | ( ticks!=initial_duration_min )),
1210            "hildon-time-editor: set_duration_range or get_duration_range failed with (minimum,maximum) as (%d,%d). Expected range is (%d,%d). Set ticks to %d and expected ticks are %d ",
1211            initial_duration_min,initial_duration_max,duration_min,duration_max,ticks,initial_duration_min);
1212
1213   remove_and_destroy_time_editor(showed_window,&time_editor);
1214
1215
1216   /* Test 2: Set duration range to (MIN_DURATION,MIN_DURATION) seconds to test set_duration_range having ticks over MIN_DURATION */
1217   initial_duration_min=MIN_DURATION;
1218   initial_duration_max=MIN_DURATION;
1219   expected_ticks=MIN_DURATION+1;
1220
1221   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
1222
1223   hildon_time_editor_set_ticks(time_editor,expected_ticks);
1224   hildon_time_editor_set_duration_range(time_editor,initial_duration_min,initial_duration_max);
1225   hildon_time_editor_get_duration_range(time_editor,&duration_min,&duration_max);
1226   ticks = hildon_time_editor_get_ticks(time_editor);
1227
1228   fail_if( ( (initial_duration_min!=duration_min) | (initial_duration_max!=duration_max) | ( ticks!=initial_duration_min )),
1229            "hildon-time-editor: set_duration_range or get_duration_range failed with (minimum,maximum) as (%d,%d). Expected range is (%d,%d). Set ticks to %d and expected ticks are %d ",
1230            initial_duration_min,initial_duration_max,duration_min,duration_max,ticks,initial_duration_min);
1231
1232   remove_and_destroy_time_editor(showed_window,&time_editor);
1233
1234   /* Test 3: Set duration range to (MAX_DURATION,MAX_DURATION) seconds to test set_duration_range having ticks under MAX_DURATION */
1235   initial_duration_min=MAX_DURATION;
1236   initial_duration_max=MAX_DURATION;
1237   expected_ticks=MAX_DURATION-1;
1238
1239   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
1240
1241   hildon_time_editor_set_ticks(time_editor,expected_ticks);
1242   hildon_time_editor_set_duration_range(time_editor,initial_duration_min,initial_duration_max);
1243   hildon_time_editor_get_duration_range(time_editor,&duration_min,&duration_max);
1244   ticks = hildon_time_editor_get_ticks(time_editor);
1245
1246   fail_if( ( (initial_duration_min!=duration_min) | (initial_duration_max!=duration_max) | ( ticks!=initial_duration_min )),
1247            "hildon-time-editor: set_duration_range or get_duration_range failed with (minimum,maximum) as (%d,%d). Expected range is (%d,%d). Set ticks to %d and expected ticks are %d ",
1248            initial_duration_min,initial_duration_max,duration_min,duration_max,ticks,initial_duration_min);
1249
1250   remove_and_destroy_time_editor(showed_window,&time_editor);
1251
1252
1253 }
1254 END_TEST
1255
1256 /**
1257  * Purpose: Check that invalid range values are set and get properly
1258  * Cases considered:
1259  *    - Set duration_range on NULL object.
1260  *    - Set and get duration range to (MAX_DURATION,MIN_DURATION) using time editor object with duration mode.
1261  *    - Set and get duration range to (MIN_DURATION,MAX_DURATION+1) having ticks between MIN_DURATION and MAX_DURATION
1262  *      using time editor object with duration mode.
1263  *    - Set and get duration range to (MAX_DURATION+1,MIN_DURATION) using time editor object with duration mode.
1264  *    - Set and get duration range to (MAX_DURATION+1,MAX_DURATION+3)
1265  *      using time editor object with duration mode.
1266  *    - Set and get duration range to (MAX_DURATION+3,MAX_DURATION+1)
1267  *      using time editor object with duration mode.
1268  *
1269  */
1270 START_TEST (test_set_duration_range_invalid)
1271 {
1272   guint initial_duration_min;
1273   guint initial_duration_max;
1274   guint duration_min;
1275   guint duration_max;
1276   guint expected_ticks;
1277   guint ticks;
1278   HildonTimeEditor *time_editor = NULL;
1279
1280
1281   /* Test 1: Set duration range on NULL */
1282   hildon_time_editor_set_duration_range(NULL,MIN_DURATION,MAX_DURATION);
1283
1284   /* Test 2: Set duration range to (MAX_DURATION,MIN_DURATION) seconds to test set_duration_range */
1285   initial_duration_min=MAX_DURATION;
1286   initial_duration_max=MIN_DURATION;
1287   expected_ticks=MIN_DURATION+1;
1288   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
1289
1290   hildon_time_editor_set_ticks(time_editor,expected_ticks);
1291   hildon_time_editor_set_duration_range(time_editor,initial_duration_min,initial_duration_max);
1292   hildon_time_editor_get_duration_range(time_editor,&duration_min,&duration_max);
1293   ticks = hildon_time_editor_get_ticks(time_editor);
1294
1295   fail_if( ( (MIN_DURATION!=duration_min) | (MAX_DURATION!=duration_max) | ( ticks!=MIN_DURATION )),
1296            "hildon-time-editor: set_duration_range or get_duration_range failed with (minimum,maximum) as (%d,%d). Expected range is (%d,%d). Set ticks to %d and expected ticks are %d ",
1297            MIN_DURATION,MAX_DURATION,duration_min,duration_max,ticks,MIN_DURATION);
1298
1299   remove_and_destroy_time_editor(showed_window,&time_editor);
1300
1301   /* Test 3: Set duration range to (MIN_DURATION,MAX_DURATION+1) seconds to test set_duration_range */
1302   initial_duration_min=MIN_DURATION;
1303   initial_duration_max=MAX_DURATION+1;
1304   expected_ticks=MAX_DURATION-59;
1305   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
1306
1307   hildon_time_editor_set_ticks(time_editor,expected_ticks);
1308   hildon_time_editor_set_duration_range(time_editor,initial_duration_min,initial_duration_max);
1309   hildon_time_editor_get_duration_range(time_editor,&duration_min,&duration_max);
1310   ticks = hildon_time_editor_get_ticks(time_editor);
1311
1312   fail_if( ( (MIN_DURATION!=duration_min) | (MAX_DURATION!=duration_max) | ( ticks!=MIN_DURATION )),
1313            "hildon-time-editor: set_duration_range or get_duration_range failed with (minimum,maximum) as (%d,%d). Expected range is (%d,%d). Set ticks to %d and expected ticks are %d ",
1314            MIN_DURATION,MAX_DURATION,duration_min,duration_max,ticks,MIN_DURATION);
1315
1316   remove_and_destroy_time_editor(showed_window,&time_editor);
1317
1318
1319   /* Test 4: Set duration range to (MAX_DURATION+1,MIN_DURATION) seconds to test set_duration_range */
1320   initial_duration_min=MAX_DURATION+1;
1321   initial_duration_max=MIN_DURATION;
1322   expected_ticks=MIN_DURATION-1;
1323   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
1324
1325   hildon_time_editor_set_duration_range(time_editor,initial_duration_min,initial_duration_max);
1326   hildon_time_editor_get_duration_range(time_editor,&duration_min,&duration_max);
1327
1328   fail_if( ( (MIN_DURATION!=duration_min) | (MAX_DURATION!=duration_max) ),
1329            "hildon-time-editor: set_duration_range or get_duration_range failed with (minimum,maximum) as (%d,%d). Expected range is (%d,%d). ",
1330            MIN_DURATION,MAX_DURATION,duration_min,duration_max);
1331
1332   remove_and_destroy_time_editor(showed_window,&time_editor);
1333
1334
1335   /* Test 5: Set duration range to (MAX_DURATION+1,MIN_DURATION+3) seconds to test set_duration_range */
1336   initial_duration_min=MAX_DURATION+1;
1337   initial_duration_max=MAX_DURATION+3;
1338   expected_ticks=MAX_DURATION+1;
1339
1340   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
1341
1342   hildon_time_editor_set_ticks(time_editor,expected_ticks);
1343   hildon_time_editor_set_duration_range(time_editor,initial_duration_min,initial_duration_max);
1344   hildon_time_editor_get_duration_range(time_editor,&duration_min,&duration_max);
1345   ticks = hildon_time_editor_get_ticks(time_editor);
1346
1347 /*   fail_if( ( (initial_duration_min!=duration_min) | (MAX_DURATION!=duration_max) | ( ticks!=MAX_DURATION )), */
1348 /*            "hildon-time-editor: set_duration_range or get_duration_range failed with (minimum,maximum) as (%d,%d). Expected range is (%d,%d). Set ticks to %d and expected ticks are %d ", */
1349 /*            initial_duration_min,MAX_DURATION,duration_min,duration_max,ticks,MAX_DURATION); */
1350
1351   fail_if( ( (initial_duration_min!=duration_min) | (MAX_DURATION!=duration_max) ),
1352            "hildon-time-editor: set_duration_range or get_duration_range failed with (minimum,maximum) as (%d,%d). Expected range is (%d,%d). Set ticks to %d and expected ticks are %d ",
1353            initial_duration_min,MAX_DURATION,duration_min,duration_max,ticks,MAX_DURATION);
1354
1355   remove_and_destroy_time_editor(showed_window,&time_editor);
1356
1357   /* Test 6: Set duration range to (MAX_DURATION+3,MIN_DURATION+1) seconds to test set_duration_range */
1358   initial_duration_min=MAX_DURATION+3;
1359   initial_duration_max=MAX_DURATION+1;
1360   expected_ticks=MAX_DURATION+1;
1361
1362   time_editor = create_and_show_time_editor(showed_window,TRUE,TRUE);
1363
1364   hildon_time_editor_set_ticks(time_editor,expected_ticks);
1365   hildon_time_editor_set_duration_range(time_editor,initial_duration_min,initial_duration_max);
1366   hildon_time_editor_get_duration_range(time_editor,&duration_min,&duration_max);
1367   ticks = hildon_time_editor_get_ticks(time_editor);
1368
1369   fail_if( ( (initial_duration_max!=duration_min) | (MAX_DURATION!=duration_max) | ( ticks!=MAX_DURATION )),
1370            "hildon-time-editor: set_duration_range or get_duration_range failed with (minimum,maximum) as (%d,%d). Expected range is (%d,%d). Set ticks to %d and expected ticks are %d ",
1371            initial_duration_max,MAX_DURATION,duration_min,duration_max,ticks,MAX_DURATION);
1372
1373   remove_and_destroy_time_editor(showed_window,&time_editor);
1374
1375
1376 }
1377 END_TEST
1378
1379
1380 /* ---------- Suite creation ---------- */
1381
1382 Suite *create_hildon_time_editor_suite()
1383 {
1384   /* Create the suite */
1385   Suite *s = suite_create("HildonTimeEditor");
1386
1387   /* Create test cases */
1388   TCase *tc1 = tcase_create("set_time");
1389   TCase *tc2 = tcase_create("set_ticks");
1390   TCase *tc3 = tcase_create("set_duration_min_set_duration_max");
1391   TCase *tc4 = tcase_create("set_duration_range");
1392
1393   /* Create test case for hildon_time_editor_set_time and add it to the suite */
1394   tcase_add_checked_fixture(tc1, fx_setup_default_time_editor, fx_teardown_default_time_editor);
1395   tcase_add_test(tc1, test_set_time_regular);
1396   tcase_add_test(tc1, test_set_time_limits);
1397   tcase_add_test(tc1, test_set_time_invalid);
1398   suite_add_tcase (s, tc1);
1399
1400   /* Create test case for hildon_time_editor_set_ticks and add it to the suite */
1401   tcase_add_checked_fixture(tc2, fx_setup_default_time_editor, fx_teardown_default_time_editor);
1402   tcase_add_test(tc2, test_set_ticks_regular);
1403   tcase_add_test(tc2, test_set_ticks_limits);
1404   tcase_add_test(tc2, test_set_ticks_invalid);
1405   suite_add_tcase (s, tc2);
1406
1407   /* Create test case for hildon_time_editor_set_duration_max and add it to the suite */
1408   tcase_add_checked_fixture(tc3, fx_setup_default_time_editor, fx_teardown_default_time_editor);
1409   tcase_add_test(tc3, test_set_duration_min_set_duration_max_regular);
1410   tcase_add_test(tc3, test_set_duration_min_set_duration_max_limits);
1411   tcase_add_test(tc3, test_set_duration_min_set_duration_max_invalid);
1412   suite_add_tcase (s, tc3);
1413
1414   /* Create test case for hildon_time_editor_set_duration_range and add it to the suite */
1415   tcase_add_checked_fixture(tc4, fx_setup_default_time_editor, fx_teardown_default_time_editor);
1416   tcase_add_test(tc4, test_set_duration_range_regular);
1417   tcase_add_test(tc4, test_set_duration_range_limits);
1418   tcase_add_test(tc4, test_set_duration_range_invalid);
1419   suite_add_tcase (s, tc4);
1420
1421   /* Return created suite */
1422   return s;
1423 }