qadevOOo/tests/java/ifc/ucb/_XSimpleFileAccess.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.ucb;
  20
  21 import lib.MultiMethodTest;
  22 import lib.Status;
  23 import lib.StatusException;
  24
  25 import com.sun.star.task.XInteractionHandler;
  26 import com.sun.star.ucb.XSimpleFileAccess;
  27 import com.sun.star.uno.UnoRuntime;
  28 import com.sun.star.util.DateTime;
  29
  30 import java.util.Calendar;
  31 import java.util.GregorianCalendar;
  32
  33 /**
  34 * Testing <code>com.sun.star.ucb.XSimpleFileAccess</code>
  35 * interface methods. <p>
  36 * The following predefined files needed to complete the test:
  37 * <ul>
  38 *  <li> <code>XSimpleFileAccess/XSimpleFileAccess.txt</code> :
  39 *   text file of length 17 and 2000 year created .</li>
  40 *  <li> <code>XSimpleFileAccess/XSimpleFileAccess2.txt</code> :
  41 *   text file for <code>openFileReadWrite</code> method test.</li>
  42 * <ul> <p>
  43 * This test needs the following object relations :
  44 * <ul>
  45 *  <li> <code>'InteractionHandler'</code>
  46 *  (of type <code>XInteractionHandler</code>)
  47 *  instance of <code>com.sun.star.sdb.InteractionHandler</code>
  48 *  </li>
  49 * </ul> <p>
  50 * Test is <b> NOT </b> multithread compliant. <p>
  51 * @see com.sun.star.ucb.XSimpleFileAccess
  52 */
  53 public class _XSimpleFileAccess extends MultiMethodTest {
  54
  55     public static XSimpleFileAccess oObj = null;
  56
  57     /**
  58     * Copies <b>XSimpleFileAccess.txt</b> to a new file, checks
  59     * if it was successfully copied and then deletes it. <p>
  60     * Has <b> OK </b> status if after method call new copy of file
  61     * exists and no exceptions were thrown. <p>
  62     */
  63     public void _copy() {
  64         try {
  65             String copiedFile = "";
  66             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
  67             String dirnameTo = util.utils.getOfficeTemp(tParam.getMSF()) ;
  68             String filename = dirname+"XSimpleFileAccess.txt";
  69             copiedFile = dirnameTo + "XSimpleFileAccess_copy.txt";
  70
  71             if (oObj.exists(copiedFile))
  72                 oObj.kill(copiedFile);
  73
  74             oObj.copy(filename,copiedFile);
  75             tRes.tested("copy()",oObj.exists(copiedFile));
  76             oObj.kill(copiedFile);
  77         }
  78         catch (com.sun.star.uno.Exception ex) {
  79             log.println("Exception occurred while testing 'copy()'");
  80             ex.printStackTrace(log);
  81             tRes.tested("copy()",false);
  82         }
  83
  84     } //EOF copy()
  85
  86     /**
  87     * Copies <b>XSimpleFileAccess.txt</b> to a new file, tries to
  88     * rename it, then checks
  89     * if it was successfully renamed and then deletes it. <p>
  90     * Has <b> OK </b> status if after method call new file
  91     * exists and no exceptions were thrown. <p>
  92     */
  93     public void _move() {
  94         try {
  95             String copiedFile = "";
  96             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
  97             String dirnameTo = util.utils.getOfficeTemp(tParam.getMSF()) ;
  98             String filename = dirname+"XSimpleFileAccess.txt";
  99             copiedFile = dirnameTo + "XSimpleFileAccess_copy.txt";
 100
 101             if (oObj.exists(copiedFile))
 102                 oObj.kill(copiedFile);
 103
 104             oObj.copy(filename,copiedFile);
 105             filename = copiedFile;
 106             copiedFile = dirnameTo + "XSimpleFileAccess_move.txt";
 107             oObj.move(filename,copiedFile);
 108             tRes.tested("move()",oObj.exists(copiedFile));
 109             oObj.kill(copiedFile);
 110         }
 111         catch (com.sun.star.uno.Exception ex) {
 112             log.println("Exception occurred while testing 'move()'");
 113             ex.printStackTrace(log);
 114             tRes.tested("move()",false);
 115         }
 116
 117     } //EOF move()
 118
 119     /**
 120     * Copies <b>XSimpleFileAccess.txt</b> to a new file, deletes it
 121     * and checks if it isn't exist. <p>
 122     * Has <b> OK </b> status if after method call new copy of file
 123     * doesn't exist and no exceptions were thrown. <p>
 124     */
 125     public void _kill() {
 126         try {
 127             String copiedFile = "";
 128             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
 129             String dirnameTo = util.utils.getOfficeTemp(tParam.getMSF()) ;
 130             String filename = dirname+"XSimpleFileAccess.txt";
 131             copiedFile = dirnameTo + "XSimpleFileAccess_copy.txt";
 132
 133             if (oObj.exists(copiedFile))
 134                 oObj.kill(copiedFile);
 135
 136             oObj.copy(filename,copiedFile);
 137             oObj.kill(copiedFile);
 138             tRes.tested("kill()",!oObj.exists(copiedFile));
 139         }
 140         catch (com.sun.star.uno.Exception ex) {
 141             log.println("Exception occurred while testing 'kill()'");
 142             ex.printStackTrace(log);
 143             tRes.tested("kill()",false);
 144         }
 145
 146     } //EOF kill()
 147
 148     /**
 149     * Tries to check if <b>XSimpleFileAccess</b> is folder. <p>
 150     * Has <b>OK</b> status if the method returns <code>true</code>
 151     */
 152     public void _isFolder() {
 153         try {
 154             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
 155             tRes.tested("isFolder()",oObj.isFolder(dirname));
 156         }
 157         catch (com.sun.star.uno.Exception ex) {
 158             log.println("Exception occurred while testing 'isFolder()'");
 159             ex.printStackTrace(log);
 160             tRes.tested("isFolder()",false);
 161         }
 162
 163     } //EOF isFolder()
 164
 165     /**
 166      * Copies <b>XSimpleFileAccess.txt</b> to a new file, sets
 167      * 'READONLY' attribute and checks it. Second clears 'READONLY'
 168      * attribute and checks it again. The copy of file is deleted
 169      * finally.<p>
 170      *
 171      * Has <b> OK </b> status if in the first case method returns
 172      * <code></code>, and in the second case - <code>false</code>
 173      * and no exceptions were thrown. <p>
 174      *
 175      * The following method tests are to be completed successfully before :
 176      * <ul>
 177      *  <li> <code> setReadOnly </code> </li>
 178      * </ul>
 179      */
 180     public void _isReadOnly() {
 181         requiredMethod("setReadOnly()");
 182         try {
 183             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
 184             String filename = dirname+"XSimpleFileAccess.txt";
 185             boolean result = true;
 186
 187             String dirnameTo = util.utils.getOfficeTemp(tParam.getMSF()) ;
 188             String readonlyCopy = dirnameTo + "XSimpleFileAccess_copy.txt" ;
 189
 190             if (oObj.exists(readonlyCopy))
 191                 oObj.kill(readonlyCopy);
 192
 193             oObj.copy(filename, readonlyCopy);
 194
 195             oObj.setReadOnly(readonlyCopy, true);
 196             result &= oObj.isReadOnly(readonlyCopy);
 197             oObj.setReadOnly(readonlyCopy, false);
 198             result &= !oObj.isReadOnly(readonlyCopy);
 199
 200             oObj.kill(readonlyCopy);
 201             tRes.tested("isReadOnly()",result);
 202         } catch (com.sun.star.uno.Exception ex) {
 203             log.println("Exception occurred while testing 'isReadOnly()'");
 204             ex.printStackTrace(log);
 205             tRes.tested("isReadOnly()",false);
 206         }
 207
 208     } //EOF isReadOnly()
 209
 210
 211     /**
 212      * Copies <b>XSimpleFileAccess.txt</b> to a new file, sets
 213      * 'READONLY' attribute and checks it. Second clears 'READONLY'
 214      * attribute and checks it again. The copy of file is deleted
 215      * finally.<p>
 216      *
 217      * Has <b> OK </b> status if in the first case method returns
 218      * <code></code>, and in the second case - <code>false</code>
 219      * and no exceptions were thrown. <p>
 220      *
 221      * The following method tests are to be completed successfully before :
 222      * <ul>
 223      *  <li> <code> setReadOnly </code> </li>
 224      * </ul>
 225      */
 226     public void _setReadOnly() {
 227         boolean result = true ;
 228
 229         try {
 230             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
 231             String filename = dirname+"XSimpleFileAccess.txt";
 232
 233             String dirnameTo = util.utils.getOfficeTemp(tParam.getMSF()) ;
 234             String readonlyCopy = dirnameTo + "XSimpleFileAccess_copy.txt" ;
 235
 236             if (oObj.exists(readonlyCopy))
 237                 oObj.kill(readonlyCopy);
 238
 239             oObj.copy(filename, readonlyCopy);
 240
 241             oObj.setReadOnly(readonlyCopy, true);
 242             result &= oObj.isReadOnly(readonlyCopy) ;
 243             oObj.setReadOnly(readonlyCopy, false);
 244             result &= !oObj.isReadOnly(readonlyCopy) ;
 245             tRes.tested("setReadOnly()", result);
 246
 247             oObj.kill(readonlyCopy);
 248         }
 249         catch (Exception ex) {
 250             log.println("Exception occurred while testing 'setReadOnly()'");
 251             ex.printStackTrace(log);
 252             tRes.tested("setReadOnly()",false);
 253         }
 254     } //EOF setReadOnly()
 255
 256     /**
 257      * Creates folder and then checks if it was successfully created. <p>
 258      * Has <b>OK</b> status if folder was created and no exceptions
 259      * were thrown.
 260      */
 261     public void _createFolder() {
 262         try {
 263             String tmpdirname = util.utils.getOfficeTemp(tParam.getMSF()) ;
 264             String newFolder = tmpdirname+"SimpleSubFolder";
 265
 266             if (oObj.exists(newFolder))
 267                 oObj.kill(newFolder);
 268
 269             oObj.createFolder(newFolder);
 270             tRes.tested("createFolder()",oObj.isFolder(newFolder));
 271             oObj.kill(newFolder);
 272         }
 273         catch (com.sun.star.uno.Exception ex) {
 274             log.println("Exception occurred while testing 'createFolder()'");
 275             ex.printStackTrace(log);
 276             tRes.tested("createFolder()",false);
 277         }
 278
 279     } //EOF createFolder()
 280
 281     /**
 282     * Test calls the method and checks return value and that
 283     * no exceptions were thrown. <b>XSimpleFileAccess.txt</b>
 284     * file tested.<p>
 285     * Has <b> OK </b> status if the method returns <code>17</code>
 286     * and no exceptions were thrown. <p>
 287     */
 288     public void _getSize() {
 289         try {
 290             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
 291             String filename = dirname+"XSimpleFileAccess.txt";
 292             int fSize = oObj.getSize(filename);
 293             tRes.tested("getSize()", fSize == 17 );
 294         }
 295         catch (com.sun.star.uno.Exception ex) {
 296             log.println("Exception occurred while testing 'getSize()'");
 297             ex.printStackTrace(log);
 298             tRes.tested("getSize()",false);
 299         }
 300
 301     } //EOF getSize()
 302
 303     /**
 304     * Test calls the method and checks return value and that
 305     * no exceptions were thrown. <b>XSimpleFileAccess.txt</b>
 306     * file tested.<p>
 307     * Has <b> OK </b> status if the method returns String
 308     * <code>'application/vnd.sun.staroffice.fsys-file'</code>
 309     * and no exceptions were thrown. <p>
 310     */
 311     public void _getContentType() {
 312         try {
 313             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
 314             String filename = dirname+"XSimpleFileAccess.txt";
 315             String fType = oObj.getContentType(filename);
 316             tRes.tested("getContentType()",
 317                 "application/vnd.sun.staroffice.fsys-file".equals(fType) );
 318         }
 319         catch (com.sun.star.uno.Exception ex) {
 320             log.println("Exception occurred while testing 'getContentType()'");
 321             ex.printStackTrace(log);
 322             tRes.tested("getContentType()",false);
 323         }
 324
 325     } //EOF getContentType()
 326
 327     /**
 328     * Test calls the method and checks return value and that
 329     * no exceptions were thrown. <b>XSimpleFileAccess.txt</b>
 330     * file tested.<p>
 331     * Has <b> OK </b> status if the method returns date with
 332     * 2001 year and no exceptions were thrown. <p>
 333     */
 334     public void _getDateTimeModified() {
 335         try {
 336             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
 337             String filename = dirname+"XSimpleFileAccess.txt";
 338             DateTime fTime = oObj.getDateTimeModified(filename);
 339
 340             java.io.File the_file = new java.io.File(filename);
 341             long lastModified = the_file.lastModified();
 342             java.util.Date lastMod = new java.util.Date(lastModified);
 343             GregorianCalendar lastModCal = new GregorianCalendar();
 344             lastModCal.setTime(lastMod);
 345
 346             //compare the dates gained by java with those gained by this method
 347             boolean res = true;
 348             boolean partResult = (fTime.Day == lastModCal.get(Calendar.DAY_OF_WEEK));
 349             if (!partResult) {
 350                 log.println("Wrong Day");
 351                 log.println("Expected: "+lastModCal.get(Calendar.DAY_OF_WEEK));
 352                 log.println("Gained: "+fTime.Day);
 353                 log.println("------------------------------");
 354             }
 355             partResult = (fTime.Month == lastModCal.get(Calendar.MONTH));
 356             if (!partResult) {
 357                 log.println("Wrong Month");
 358                 log.println("Expected: "+lastModCal.get(Calendar.MONTH));
 359                 log.println("Gained: "+fTime.Month);
 360                 log.println("------------------------------");
 361             }
 362
 363             partResult = (fTime.Year == (lastModCal.get(Calendar.MONTH) - 1900));
 364             if (!partResult) {
 365                 log.println("Wrong Year");
 366                 log.println("Expected: "+(lastModCal.get(Calendar.MONTH) - 1900));
 367                 log.println("Gained: "+fTime.Year);
 368                 log.println("------------------------------");
 369             }
 370
 371             tRes.tested("getDateTimeModified()", res);
 372         }
 373         catch (com.sun.star.uno.Exception ex) {
 374             log.println("Exception occurred while testing 'getDateTimeModified()'");
 375             ex.printStackTrace(log);
 376             tRes.tested("getDateTimeModified()",false);
 377         }
 378
 379     } //EOF getDateTimeModified()
 380
 381     /**
 382     * Test calls the method and checks return value and that
 383     * no exceptions were thrown. <b>XSimpleFileAccess</b>
 384     * directory used.<p>
 385     * Has <b> OK </b> status if the method returns non zero length
 386     * array and no exceptions were thrown. <p>
 387     */
 388     public void _getFolderContents() {
 389         try {
 390             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
 391             String[] cont = oObj.getFolderContents(dirname,false);
 392             tRes.tested("getFolderContents()", cont.length>0);
 393         }
 394         catch (com.sun.star.uno.Exception ex) {
 395             log.println("Exception occurred while testing 'getFolderContents()'");
 396             ex.printStackTrace(log);
 397             tRes.tested("getFolderContents()",false);
 398         }
 399
 400     } //EOF getFolderContents()
 401
 402     /**
 403     * First it check file <b>XSimpleFileAccess.txt</b> for
 404     * existence, second file <b>I_do_not_exists.txt</b> is checked
 405     * for existence. <p>
 406     * Has <b> OK </b> status if in the first case method returns
 407     * <code>true</code> and in the second - <code>false</code>
 408     * and no exceptions were thrown. <p>
 409     */
 410     public void _exists() {
 411         try {
 412             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
 413             String filename = dirname+"XSimpleFileAccess.txt";
 414             String wrongname = dirname+"I_do_not_exists.txt";
 415             tRes.tested("exists()",
 416                 oObj.exists(filename) && !oObj.exists(wrongname));
 417         }
 418         catch (com.sun.star.uno.Exception ex) {
 419             log.println("Exception occurred while testing 'exists()'");
 420             ex.printStackTrace(log);
 421             tRes.tested("exists()",false);
 422         }
 423
 424     } //EOF exists()
 425
 426     /**
 427     * Test calls the method and checks return value and that
 428     * no exceptions were thrown. <b>XSimpleFileAccess.txt</b>
 429     * file used.<p>
 430     * Has <b> OK </b> status if the method returns not
 431     * <code>null</code> value and no exceptions were thrown. <p>
 432     */
 433     public void _openFileRead() {
 434         try {
 435             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
 436             String filename = dirname+"XSimpleFileAccess.txt";
 437             com.sun.star.io.XInputStream iStream = oObj.openFileRead(filename);
 438             tRes.tested("openFileRead()", iStream != null);
 439         }
 440         catch (com.sun.star.uno.Exception ex) {
 441             log.println("Exception occurred while testing 'openFileRead()'");
 442             ex.printStackTrace(log);
 443             tRes.tested("openFileRead()",false);
 444         }
 445
 446     } //EOF openFileRead()
 447
 448     /**
 449     * Test calls the method and checks return value and that
 450     * no exceptions were thrown. <b>XSimpleFileAccess.txt</b>
 451     * file used.<p>
 452     * Has <b> OK </b> status if the method returns not
 453     * <code>null</code> value and no exceptions were thrown. <p>
 454     */
 455     public void _openFileWrite() {
 456         try {
 457             String tmpdirname = util.utils.getOfficeTemp(tParam.getMSF()) ;
 458
 459             String copiedFile = tmpdirname+"XSimpleFileAccess_openWrite.txt";
 460
 461             if (oObj.exists(copiedFile))
 462                 oObj.kill(copiedFile);
 463
 464             com.sun.star.io.XOutputStream oStream =
 465                 oObj.openFileWrite(copiedFile);
 466
 467             oStream.closeOutput();
 468             oObj.kill(copiedFile);
 469
 470             tRes.tested("openFileWrite()", true);
 471         }
 472         catch (com.sun.star.uno.Exception ex) {
 473             log.println("Exception occurred while testing 'openFileWrite()'");
 474             ex.printStackTrace(log);
 475             tRes.tested("openFileWrite()", false);
 476         }
 477
 478     } //EOF openFileWrite()
 479
 480     /**
 481     * Test calls the method and checks return value and that
 482     * no exceptions were thrown. <b>XSimpleFileAccess2.txt</b>
 483     * file used.<p>
 484     * Has <b> OK </b> status if the method returns not
 485     * <code>null</code> value and no exceptions were thrown. <p>
 486     */
 487     public void _openFileReadWrite() {
 488         try {
 489             String dirnameTo = util.utils.getOfficeTemp(tParam.getMSF()) ;
 490             String copiedFile = dirnameTo + "XSimpleFileAccess2.txt" ;
 491
 492             if (oObj.exists(copiedFile))
 493                 oObj.kill(copiedFile);
 494
 495             com.sun.star.io.XStream aStream =
 496                 oObj.openFileReadWrite(copiedFile);
 497
 498             aStream.getInputStream().closeInput();
 499             aStream.getOutputStream().closeOutput();
 500
 501             oObj.kill(copiedFile);
 502
 503             tRes.tested("openFileReadWrite()", true);
 504         }
 505         catch (com.sun.star.uno.Exception ex) {
 506             log.println("Exception occurred while testing 'openFileReadWrite()'");
 507             ex.printStackTrace(log);
 508             tRes.tested("openFileReadWrite()", false);
 509         }
 510
 511     } //EOF openFileReadWrite()
 512
 513     /**
 514     * Test calls the method and checks that no exceptions were thrown.
 515     * Has <b> OK </b> status if no exceptions were thrown. <p>
 516     */
 517     public void _setInteractionHandler() {
 518         XInteractionHandler handler = null;
 519         Object oHandler = tEnv.getObjRelation("InteractionHandler");
 520
 521         if (oHandler == null)
 522             throw new StatusException
 523                 (Status.failed("Relation InteractionHandler not found"));
 524
 525         try {
 526             handler = UnoRuntime.queryInterface
 527                 (XInteractionHandler.class, oHandler);
 528             oObj.setInteractionHandler(handler);
 529             tRes.tested("setInteractionHandler()", true);
 530         } catch (Exception ex) {
 531             log.println("Exception occurred while testing 'setInteractionHandler()'");
 532             ex.printStackTrace(log);
 533             tRes.tested("setInteractionHandler()", false);
 534         }
 535
 536     } //EOF setInteractionHandler()
 537
 538 }  // finish class _XSimpleFileAccess
 539