qadevOOo/tests/java/ifc/ucb/_XSimpleFileAccess.java

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