qadevOOo/tests/java/ifc/i18n/_XCalendar.java

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18
  19 package ifc.i18n;
  20
  21 import lib.MultiMethodTest;
  22
  23 import com.sun.star.i18n.CalendarDisplayIndex;
  24 import com.sun.star.i18n.CalendarFieldIndex;
  25 import com.sun.star.i18n.CalendarItem;
  26 import com.sun.star.i18n.XCalendar;
  27 import com.sun.star.i18n.XLocaleData;
  28 import com.sun.star.lang.Locale;
  29 import com.sun.star.lang.XMultiServiceFactory;
  30 import com.sun.star.uno.UnoRuntime;
  31
  32 /**
  33 * Testing <code>com.sun.star.i18n.XCalendar</code>
  34 * interface methods :
  35 * <ul>
  36 *  <li><code> loadDefaultCalendar()</code></li>
  37 *  <li><code> loadCalendar()</code></li>
  38 *  <li><code> getLoadedCalendar()</code></li>
  39 *  <li><code> getAllCalendars()</code></li>
  40 *  <li><code> getUniqueID()</code></li>
  41 *  <li><code> setDateTime()</code></li>
  42 *  <li><code> getDateTime()</code></li>
  43 *  <li><code> setValue()</code></li>
  44 *  <li><code> getValue()</code></li>
  45 *  <li><code> isValid()</code></li>
  46 *  <li><code> addValue()</code></li>
  47 *  <li><code> getFirstDayOfWeek()</code></li>
  48 *  <li><code> setFirstDayOfWeek()</code></li>
  49 *  <li><code> setMinimumNumberOfDaysForFirstWeek()</code></li>
  50 *  <li><code> getMinimumNumberOfDaysForFirstWeek()</code></li>
  51 *  <li><code> getNumberOfMonthsInYear()</code></li>
  52 *  <li><code> getNumberOfDaysInWeek()</code></li>
  53 *  <li><code> getMonths()</code></li>
  54 *  <li><code> getDays()</code></li>
  55 *  <li><code> getDisplayName()</code></li>
  56 * </ul> <p>
  57 * Test is <b> NOT </b> multithread compilant. <p>
  58 * @see com.sun.star.i18n.XCalendar
  59 */
  60 public class _XCalendar extends MultiMethodTest {
  61     private boolean debug = false;
  62     public XCalendar oObj = null;
  63     public String[][] calendars;
  64     public int[] count;
  65     public double newDTime = 1000.75;
  66     public short newValue = 2;
  67     public short firstDay = 2;
  68     public short mdfw = 3;
  69     double aOriginalDTime = 0;
  70     Locale[] installed_locales;
  71
  72     public void before() {
  73         XLocaleData locData = null;
  74         try {
  75             locData = UnoRuntime.queryInterface(
  76                 XLocaleData.class,
  77                     ((XMultiServiceFactory)tParam.getMSF()).createInstance(
  78                     "com.sun.star.i18n.LocaleData"));
  79         } catch (com.sun.star.uno.Exception e) {
  80
  81         }
  82         installed_locales = locData.getAllInstalledLocaleNames();
  83         calendars = new String[installed_locales.length][];
  84         count = new int[installed_locales.length];
  85         oObj.loadDefaultCalendar(installed_locales[0]);
  86         aOriginalDTime = oObj.getDateTime();
  87
  88         debug = tParam.getBool("DebugIsActive");
  89     }
  90
  91     /**
  92      * Restore the changed time during the test to the original value of the
  93      * machine: has to be correct for the following interface tests.
  94      */
  95     public void after() {
  96         oObj.loadDefaultCalendar(installed_locales[0]);
  97         oObj.setDateTime(aOriginalDTime);
  98     }
  99
 100     /**
 101     * Loads default calendar for different locales. <p>
 102     * Has <b> OK </b> status if method loads calendar, that is
 103     * default for a given locale.
 104     */
 105     public void _loadDefaultCalendar() {
 106         boolean res = true;
 107
 108         for (int i=0; i<installed_locales.length; i++) {
 109             String lang = "Language: "+installed_locales[i].Language +
 110                           ", Country: "+ installed_locales[i].Country +
 111                           ", Variant: "+ installed_locales[i].Country;
 112             oObj.loadDefaultCalendar(installed_locales[i]);
 113             if (oObj.getLoadedCalendar().Default) {
 114                 //log.println(lang + " ... OK");
 115             } else {
 116                 log.println(lang + " ... FAILED");
 117             }
 118             res &= oObj.getLoadedCalendar().Default;
 119         }
 120
 121         tRes.tested("loadDefaultCalendar()", res);
 122     }
 123
 124     /**
 125     * Tries to obtain calendars for a number of locales. <p>
 126     * Has <b> OK </b> status if the method returns more than zero calendars for
 127     * every locale.
 128     */
 129     public void _getAllCalendars() {
 130         boolean res = true;
 131
 132         for (int i=0; i<installed_locales.length; i++) {
 133             String lang = "Language: "+installed_locales[i].Language +
 134                           ", Country: "+ installed_locales[i].Country +
 135                           ", Variant: "+ installed_locales[i].Country;
 136             calendars[i] = oObj.getAllCalendars(installed_locales[i]);
 137             count[i] = calendars[i].length-1;
 138             if (calendars[i].length > 0) {
 139                 //log.println(lang + " ... OK");
 140             } else {
 141                 log.println(lang + " ... FAILED");
 142             }
 143             res &= (calendars[i].length > 0);
 144         }
 145         tRes.tested("getAllCalendars()", res);
 146     }
 147
 148     /**
 149     * Loads calendars for a number of locales. <p>
 150     * Has <b> OK </b> status if loaded calendar names are equal to gotten
 151     * calendar names after loading.<p>
 152     * The following method tests are to be completed successfully before :
 153     * <ul>
 154     *  <li> <code> getAllCalendars() </code> : gets all calendars for a given
 155     *  locale </li>
 156     * </ul>
 157     */
 158     public void _loadCalendar() {
 159         boolean res = true;
 160         requiredMethod("getAllCalendars()");
 161
 162         for (int i=0; i<installed_locales.length; i++) {
 163             String lang = "Language: "+installed_locales[i].Language +
 164                           ", Country: "+ installed_locales[i].Country +
 165                           ", Variant: "+ installed_locales[i].Country;
 166             oObj.loadCalendar(calendars[i][0], installed_locales[i]);
 167             if (calendars[i][0].equals(oObj.getLoadedCalendar().Name)) {
 168                 //log.println(lang + " ... OK");
 169             } else {
 170                 log.println(lang + " ... FAILED");
 171             }
 172             res &= calendars[i][0].equals(oObj.getLoadedCalendar().Name);
 173         }
 174
 175         tRes.tested("loadCalendar()", res);
 176     }
 177
 178     /**
 179     * Test calls the method, then result is checked. <p>
 180     * Has <b> OK </b> status if loaded calendar names are equal to gotten
 181     * calendar names after loading.<p>
 182     * The following method tests are to be completed successfully before :
 183     * <ul>
 184     *  <li> <code> loadCalendar() </code> : loads calendar using a given name
 185     *  and locale </li>
 186     * </ul>
 187     */
 188     public void _getLoadedCalendar() {
 189         boolean res = true;
 190
 191         requiredMethod("loadCalendar()");
 192         for (int i=0; i<installed_locales.length; i++) {
 193             String lang = "Language: "+installed_locales[i].Language +
 194                           ", Country: "+ installed_locales[i].Country +
 195                           ", Variant: "+ installed_locales[i].Country;
 196             oObj.loadCalendar(calendars[i][0], installed_locales[i]);
 197             if (calendars[i][0].equals(oObj.getLoadedCalendar().Name)) {
 198                 //log.println(lang + " ... OK");
 199             } else {
 200                 log.println(lang + " ... FAILED");
 201             }
 202             res &= calendars[i][0].equals(oObj.getLoadedCalendar().Name);
 203         }
 204         tRes.tested("getLoadedCalendar()", res);
 205     }
 206
 207     /**
 208     * Test calls the method, then result is checked. <p>
 209     * Has <b> OK </b> status if the method returns value that's equal to a
 210     * calendar name. <p>
 211     * The following method tests are to be completed successfully before :
 212     * <ul>
 213     *  <li> <code> loadCalendar() </code> :  loads calendar using a given name
 214     *  and locale </li>
 215     * </ul>
 216     */
 217     public void _getUniqueID() {
 218         boolean res = true;
 219         for (int i=0; i<installed_locales.length; i++) {
 220             String lang = "Language: "+installed_locales[i].Language +
 221                           ", Country: "+ installed_locales[i].Country +
 222                           ", Variant: "+ installed_locales[i].Country;
 223             oObj.loadCalendar(calendars[i][0], installed_locales[i]);
 224             String uID = oObj.getUniqueID();
 225             if (uID.equals(calendars[i][0])) {
 226                 //log.println(lang + " ... OK");
 227             } else {
 228                 log.println(lang + " ... FAILED");
 229             }
 230             res &= uID.equals(calendars[i][0]);
 231         }
 232
 233         tRes.tested("getUniqueID()",res);
 234     }
 235
 236     /**
 237     * Test calls the method, then result is checked. <p>
 238     * Has <b> OK </b> status if the method returns value, that's equal to
 239     * value set before. <p>
 240     */
 241
 242     public void _setDateTime() {
 243         boolean res = true;
 244
 245         for (int i=0; i<installed_locales.length; i++) {
 246             String lang = "Language: "+installed_locales[i].Language +
 247                           ", Country: "+ installed_locales[i].Country +
 248                           ", Variant: "+ installed_locales[i].Country;
 249             oObj.setDateTime(newDTime);
 250             double aDTime = oObj.getDateTime();
 251             if (aDTime == newDTime) {
 252                 //log.println(lang + " ... OK");
 253             } else {
 254                 log.println(lang + " ... FAILED");
 255             }
 256             res &= (aDTime == newDTime);
 257         }
 258
 259         tRes.tested("setDateTime()", res);
 260     }
 261
 262     /**
 263     * Test calls the method, then result is checked. <p>
 264     * Has <b> OK </b> status if the method returns value, that's equal to
 265     * value set before. <p>
 266     */
 267
 268     public void _getDateTime() {
 269         boolean res = true;
 270
 271         for (int i=0; i<installed_locales.length; i++) {
 272             String lang = "Language: "+installed_locales[i].Language +
 273                           ", Country: "+ installed_locales[i].Country +
 274                           ", Variant: "+ installed_locales[i].Country;
 275             oObj.setDateTime(newDTime);
 276             double aDTime = oObj.getDateTime();
 277             if (aDTime == newDTime) {
 278                 //log.println(lang + " ... OK");
 279             } else {
 280                 log.println(lang + " ... FAILED");
 281             }
 282             res &= (aDTime == newDTime);
 283         }
 284         tRes.tested("getDateTime()", res);
 285     }
 286
 287     /**
 288     * Test calls the method, then result is checked. <p>
 289     * Has <b> OK </b> status if the method returns value, that's equal to
 290     * value set before. <p>
 291     */
 292
 293     public void _setValue() {
 294         boolean res = true;
 295         for (int i=0; i<installed_locales.length; i++) {
 296             String error = "";
 297             String lang = "Language: "+installed_locales[i].Language +
 298                           ", Country: "+ installed_locales[i].Country +
 299                           ", Variant: "+ installed_locales[i].Variant +
 300                           ", Name: "+calendars[i][count[i]];
 301             String[] names = new String[]{"DAY_OF_MONTH",
 302                 "HOUR","MINUTE","SECOND","MILLISECOND",
 303                 "YEAR","MONTH"};
 304             oObj.loadCalendar(calendars[i][count[i]],installed_locales[i]);
 305             short[] fields = new short[]{CalendarFieldIndex.DAY_OF_MONTH,
 306                                          CalendarFieldIndex.HOUR,
 307                                          CalendarFieldIndex.MINUTE,
 308                                          CalendarFieldIndex.SECOND,
 309                                          CalendarFieldIndex.MILLISECOND,
 310                                          CalendarFieldIndex.YEAR,
 311                                          CalendarFieldIndex.MONTH
 312             };
 313             for (int k=0; k<fields.length;k++) {
 314
 315                 oObj.setDateTime(0.0);
 316
 317                 // save the current values for debug purposes
 318                 short[] oldValues = new short[fields.length];
 319                 for (int n=0; n < oldValues.length; n++){
 320                     oldValues[n] = oObj.getValue(fields[n]);
 321                 }
 322
 323                 short set = oObj.getValue(fields[k]);
 324                 if (fields[k] == CalendarFieldIndex.MONTH) set = newValue;
 325                 oObj.setValue(fields[k],set);
 326                 short get = oObj.getValue(fields[k]);
 327                 if (get != set) {
 328                     if (debug)
 329                         log.println("ERROR occurred: tried to set " + names[k] + " to value " + set);
 330                         log.println("list of values BEFORE set " + names[k] + " to value " + set + ":");
 331                         for (int n=0; n < oldValues.length; n++){
 332                             log.println(names[n] + ":" + oldValues[n]);
 333                         }
 334                         log.println("list of values AFTER set " + names[k] + " to value " + set + ":");
 335                         for (int n=0; n < fields.length;n++){
 336                             log.println(names[n] + ":" + oObj.getValue(fields[n]));
 337                         }
 338
 339                     error += "failed for "+names[k]+" expected "+
 340                                 set+" gained "+get+" ; \n";
 341                 }
 342             }
 343             if (error.equals("")) {
 344                 log.println(lang + " ... OK");
 345             } else {
 346                 log.println("*** "+lang + " ... FAILED ***");
 347                 log.println(error);
 348             }
 349             res &= (error.equals(""));
 350         }
 351
 352         tRes.tested("setValue()", res);
 353     }
 354
 355     /**
 356     * Test calls the method, then result is checked. <p>
 357     * Has <b> OK </b> status if the method returns value, that's equal to
 358     * value set before. <p>
 359     */
 360
 361     public void _getValue() {
 362         boolean res = true;
 363
 364         requiredMethod("setValue()");
 365         short aValue = oObj.getValue(CalendarFieldIndex.MONTH);
 366         res &= (aValue == newValue);
 367         if (!res){
 368             log.println("the returned value is not the expected value:");
 369             log.println("expexted: " + newValue + "  returned value: " + aValue);
 370         }
 371         tRes.tested("getValue()", res);
 372     }
 373
 374     /**
 375     * Test calls the method, then result is checked. <p>
 376     * Has <b> OK </b> status if value, added by the method is greater than
 377     * previously defined "newValue".
 378     * <p>
 379     * The following method tests are to be completed successfully before :
 380     * <ul>
 381     *  <li> <code> getValue() </code> : gets the value of a field </li>
 382     * </ul>
 383     */
 384     public void _addValue() {
 385         boolean res = true;
 386
 387         requiredMethod("getValue()");
 388         oObj.addValue(CalendarFieldIndex.MONTH, 1);
 389         short aValue = oObj.getValue(CalendarFieldIndex.MONTH);
 390         res &= (aValue > newValue);
 391         if (!res){
 392             log.println("the returned value is not the expected value:");
 393             log.println("expexted: " + newValue + "  returned value: " + aValue);
 394         }
 395         tRes.tested("addValue()", res);
 396     }
 397
 398     /**
 399     * Test calls the method. <p>
 400     * Has <b> OK </b> status if the method successfully returns
 401     * and no exceptions were thrown.
 402     */
 403     public void _setFirstDayOfWeek() {
 404         boolean res = true;
 405
 406         oObj.setFirstDayOfWeek(firstDay);
 407         res &= true;
 408         tRes.tested("setFirstDayOfWeek()", res);
 409     }
 410
 411     /**
 412     * Test calls the method, then result is checked. <p>
 413     * Has <b> OK </b> status if the method returns value that is equal to
 414     * value set before. <p>
 415     * The following method tests are to be completed successfully before :
 416     * <ul>
 417     *  <li> <code> setFirstDayOfWeek() </code> : set the first day of a
 418     *  week</li>
 419     * </ul>
 420     */
 421     public void _getFirstDayOfWeek() {
 422         boolean res = true;
 423
 424         requiredMethod("setFirstDayOfWeek()");
 425         short aFirstDayOfWeek = oObj.getFirstDayOfWeek();
 426         res &= (aFirstDayOfWeek == firstDay);
 427         tRes.tested("getFirstDayOfWeek()", res);
 428     }
 429
 430     /**
 431     * Test calls the method. <p>
 432     * Has <b> OK </b> status if the method successfully returns
 433     * and no exceptions were thrown.
 434     */
 435     public void _setMinimumNumberOfDaysForFirstWeek() {
 436         boolean res = true;
 437
 438         oObj.setMinimumNumberOfDaysForFirstWeek(mdfw);
 439         res &= true;
 440         tRes.tested("setMinimumNumberOfDaysForFirstWeek()", res);
 441     }
 442
 443     /**
 444     * Test calls the method, then result is checked. <p>
 445     * Has <b> OK </b> status if the method returns value that is equal to
 446     * value set before. <p>
 447     * The following method tests are to be completed successfully before :
 448     * <ul>
 449     *  <li> <code> setMinimumNumberOfDaysForFirstWeek() </code> : sets how
 450     *  many days of a week must reside in the first week of a year</li>
 451     * </ul>
 452     */
 453     public void _getMinimumNumberOfDaysForFirstWeek() {
 454         boolean res = true;
 455
 456         requiredMethod("setMinimumNumberOfDaysForFirstWeek()");
 457         short aShort = oObj.getMinimumNumberOfDaysForFirstWeek();
 458         res &= (aShort == mdfw);
 459         tRes.tested("getMinimumNumberOfDaysForFirstWeek()", res);
 460     }
 461
 462     /**
 463     * Test calls the method, then result is checked. <p>
 464     * Has <b> OK </b> status if the method returns 12.
 465     */
 466     public void _getNumberOfMonthsInYear() {
 467         boolean res = true;
 468         short aShort = oObj.getNumberOfMonthsInYear();
 469
 470         res &= (aShort == (short) 12);
 471         tRes.tested("getNumberOfMonthsInYear()", res);
 472     }
 473
 474     /**
 475     * Test calls the method, then result is checked. <p>
 476     * Has <b> OK </b> status if the method returns 7.
 477     */
 478     public void _getNumberOfDaysInWeek() {
 479         boolean res = true;
 480         short aShort = oObj.getNumberOfDaysInWeek();
 481
 482         res &= (aShort == (short) 7);
 483         tRes.tested("getNumberOfDaysInWeek()", res);
 484     }
 485
 486     /**
 487     * Test calls the method, then result is checked. <p>
 488     * Has <b> OK </b> status if length of array, returned by the method is 12.
 489     */
 490     public void _getMonths() {
 491         boolean res = true;
 492         CalendarItem[] months = oObj.getMonths();
 493
 494         res &= (months.length == 12);
 495         tRes.tested("getMonths()", res);
 496     }
 497
 498     /**
 499     * Test calls the method, then result is checked. <p>
 500     * Has <b> OK </b> status if length of array, returned by the method is 7.
 501     */
 502     public void _getDays() {
 503         boolean res = true;
 504         CalendarItem[] Days = oObj.getDays();
 505
 506         res &= (Days.length == 7);
 507         tRes.tested("getDays()", res);
 508     }
 509
 510     /**
 511     * After loading calendar, test calls the method, then result is checked.<p>
 512     * Has <b> OK </b> status if length of string, returned by the method is 3.
 513     */
 514     public void _getDisplayName() {
 515         boolean res = true;
 516
 517         oObj.loadCalendar(calendars[0][0],installed_locales[0]);
 518         String DisplayName = oObj.getDisplayName(CalendarDisplayIndex.MONTH,
 519             newValue, (short) 0);
 520         res &= (DisplayName.length() == 3);
 521         tRes.tested("getDisplayName()", res);
 522     }
 523
 524
 525     /**
 526     * The test sets obviously wrong value, then calls a method. After that the
 527     * test sets correct value, and again calls a method. <p>
 528     * Has <b> OK </b> status if the method returns true when valid month is
 529     * set, and if the method returns false when set month is not valid.
 530     */
 531     public void _isValid() {
 532         boolean res = true;
 533
 534         oObj.loadDefaultCalendar(installed_locales[0]);
 535         oObj.setValue(CalendarFieldIndex.MONTH, (short) 37);
 536         res &= !oObj.isValid();
 537         oObj.setValue(CalendarFieldIndex.MONTH, (short) 10);
 538         res &= oObj.isValid();
 539
 540         tRes.tested("isValid()", res);
 541     }
 542
 543     /**
 544     * Method returns locale for a given language and country.
 545     * @param localeIndex index of needed locale.
 546     */
 547 /*    public Locale getLocale(int localeIndex) {
 548         return new Locale(languages[localeIndex], countries[localeIndex], "");
 549     }*/
 550
 551 }
 552