odk/examples/java/Storage/TestHelper.java

   1 /* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 import com.sun.star.uno.UnoRuntime;
  21 import com.sun.star.uno.AnyConverter;
  22
  23 import com.sun.star.lang.*;
  24 import com.sun.star.embed.*;
  25 import com.sun.star.packages.*;
  26 import com.sun.star.io.*;
  27 import com.sun.star.beans.*;
  28
  29 public class TestHelper  {
  30
  31     String m_sTestPrefix;
  32
  33     public TestHelper( String sTestPrefix )
  34     {
  35         m_sTestPrefix = sTestPrefix;
  36     }
  37
  38     public boolean WriteBytesToStream( XStream xStream,
  39                                         String sStreamName,
  40                                         String sMediaType,
  41                                         boolean bCompressed,
  42                                         byte[] pBytes )
  43     {
  44         // get output stream of substream
  45         XOutputStream xOutput = xStream.getOutputStream();
  46         if ( xOutput == null )
  47         {
  48             Error( "Can't get XOutputStream implementation from substream '" + sStreamName + "'!" );
  49             return false;
  50         }
  51
  52         // get XTruncate implementation from output stream
  53         XTruncate xTruncate = UnoRuntime.queryInterface( XTruncate.class, xOutput );
  54         if ( xTruncate == null )
  55         {
  56             Error( "Can't get XTruncate implementation from substream '" + sStreamName + "'!" );
  57             return false;
  58         }
  59
  60         // write requested byte sequence
  61         try
  62         {
  63             xTruncate.truncate();
  64             xOutput.writeBytes( pBytes );
  65         }
  66         catch( Exception e )
  67         {
  68             Error( "Can't write to stream '" + sStreamName + "', exception: " + e );
  69             return false;
  70         }
  71
  72         // get access to the XPropertySet interface
  73         XPropertySet xPropSet = UnoRuntime.queryInterface( XPropertySet.class, xStream );
  74         if ( xPropSet == null )
  75         {
  76             Error( "Can't get XPropertySet implementation from substream '" + sStreamName + "'!" );
  77             return false;
  78         }
  79
  80         // set properties to the stream
  81         try
  82         {
  83             xPropSet.setPropertyValue( "MediaType", sMediaType );
  84             xPropSet.setPropertyValue( "Compressed", Boolean.valueOf( bCompressed ) );
  85         }
  86         catch( Exception e )
  87         {
  88             Error( "Can't set properties to substream '" + sStreamName + "', exception: " + e );
  89             return false;
  90         }
  91
  92         // check size property of the stream
  93         try
  94         {
  95             int nSize = AnyConverter.toInt( xPropSet.getPropertyValue( "Size" ) );
  96             if ( nSize != pBytes.length )
  97             {
  98                 Error( "The 'Size' property of substream '" + sStreamName + "' contains wrong value!" );
  99                 return false;
 100             }
 101         }
 102         catch( Exception e )
 103         {
 104             Error( "Can't get 'Size' property from substream '" + sStreamName + "', exception: " + e );
 105             return false;
 106         }
 107
 108         // free the stream resources, garbage collector may remove the object too late
 109         XComponent xComponent = UnoRuntime.queryInterface( XComponent.class, xStream );
 110         if ( xComponent == null )
 111         {
 112             Error( "Can't get XComponent implementation from substream '" + sStreamName + "'!" );
 113             return false;
 114         }
 115         xComponent.dispose();
 116
 117         return true;
 118     }
 119
 120
 121     public boolean WriteBytesToSubstream( XStorage xStorage,
 122                                           String sStreamName,
 123                                           String sMediaType,
 124                                           boolean bCompressed,
 125                                           byte[] pBytes )
 126     {
 127         // open substream element
 128         XStream xSubStream = null;
 129         try
 130         {
 131             Object oSubStream = xStorage.openStreamElement( sStreamName, ElementModes.WRITE );
 132             xSubStream = UnoRuntime.queryInterface( XStream.class, oSubStream );
 133             if ( xSubStream == null )
 134             {
 135                 Error( "Can't create substream '" + sStreamName + "'!" );
 136                 return false;
 137             }
 138         }
 139         catch( Exception e )
 140         {
 141             Error( "Can't create substream '" + sStreamName + "', exception : " + e + "!" );
 142             return false;
 143         }
 144
 145         return WriteBytesToStream( xSubStream, sStreamName, sMediaType, bCompressed, pBytes );
 146     }
 147
 148     public boolean WriteBytesToEncrSubstream( XStorage xStorage,
 149                                               String sStreamName,
 150                                               String sMediaType,
 151                                               boolean bCompressed,
 152                                               byte[] pBytes,
 153                                               byte[] pPass )
 154     {
 155         // open substream element
 156         XStream xSubStream = null;
 157         try
 158         {
 159             Object oSubStream = xStorage.openEncryptedStreamElement( sStreamName, ElementModes.WRITE, new String(pPass) );
 160             xSubStream = UnoRuntime.queryInterface( XStream.class, oSubStream );
 161             if ( xSubStream == null )
 162             {
 163                 Error( "Can't create substream '" + sStreamName + "'!" );
 164                 return false;
 165             }
 166         }
 167         catch( Exception e )
 168         {
 169             Error( "Can't create substream '" + sStreamName + "', exception : " + e + "!" );
 170             return false;
 171         }
 172
 173         return WriteBytesToStream( xSubStream, sStreamName, sMediaType, bCompressed, pBytes );
 174     }
 175
 176     public boolean WBToSubstrOfEncr( XStorage xStorage,
 177                                               String sStreamName,
 178                                               String sMediaType,
 179                                               boolean bCompressed,
 180                                               byte[] pBytes,
 181                                               boolean bEncrypted )
 182     {
 183         // open substream element
 184         XStream xSubStream = null;
 185         try
 186         {
 187             Object oSubStream = xStorage.openStreamElement( sStreamName, ElementModes.WRITE );
 188             xSubStream = UnoRuntime.queryInterface( XStream.class, oSubStream );
 189             if ( xSubStream == null )
 190             {
 191                 Error( "Can't create substream '" + sStreamName + "'!" );
 192                 return false;
 193             }
 194         }
 195         catch( Exception e )
 196         {
 197             Error( "Can't create substream '" + sStreamName + "', exception : " + e + "!" );
 198             return false;
 199         }
 200
 201         // get access to the XPropertySet interface
 202         XPropertySet xPropSet = UnoRuntime.queryInterface( XPropertySet.class, xSubStream );
 203         if ( xPropSet == null )
 204         {
 205             Error( "Can't get XPropertySet implementation from substream '" + sStreamName + "'!" );
 206             return false;
 207         }
 208
 209         // set properties to the stream
 210         try
 211         {
 212             xPropSet.setPropertyValue( "Encrypted", Boolean.valueOf( bEncrypted ) );
 213         }
 214         catch( Exception e )
 215         {
 216             Error( "Can't set 'Encrypted' property to substream '" + sStreamName + "', exception: " + e );
 217             return false;
 218         }
 219
 220         return WriteBytesToStream( xSubStream, sStreamName, sMediaType, bCompressed, pBytes );
 221     }
 222
 223     public int ChangeStreamPass( XStorage xStorage,
 224                                  String sStreamName,
 225                                  byte[] pOldPass,
 226                                  byte[] pNewPass )
 227     {
 228         // open substream element
 229         XStream xSubStream = null;
 230         try
 231         {
 232             Object oSubStream = xStorage.openEncryptedStreamElement( sStreamName, ElementModes.WRITE, new String(pOldPass) );
 233             xSubStream = UnoRuntime.queryInterface( XStream.class, oSubStream );
 234             if ( xSubStream == null )
 235             {
 236                 Error( "Can't open substream '" + sStreamName + "'!" );
 237                 return 0;
 238             }
 239         }
 240         catch( Exception e )
 241         {
 242             Error( "Can't open substream '" + sStreamName + "', exception : " + e + "!" );
 243             return 0;
 244         }
 245
 246
 247         // change the password for the stream
 248         XEncryptionProtectedSource xStreamEncryption =
 249                 UnoRuntime.queryInterface( XEncryptionProtectedSource.class, xSubStream );
 250
 251         if ( xStreamEncryption == null )
 252         {
 253             Message( "Optional interface XEncryptionProtectedSource is not implemented, feature can not be tested!" );
 254             return -1;
 255         }
 256
 257         try {
 258             xStreamEncryption.setEncryptionPassword( new String(pNewPass) );
 259         }
 260         catch( Exception e )
 261         {
 262             Error( "Can't change encryption key of the substream '" + sStreamName + "', exception:" + e );
 263             return 0;
 264         }
 265
 266         // free the stream resources, garbage collector may remove the object too late
 267         XComponent xComponent = UnoRuntime.queryInterface( XComponent.class, xSubStream );
 268         if ( xComponent == null )
 269         {
 270             Error( "Can't get XComponent implementation from substream '" + sStreamName + "'!" );
 271             return 0;
 272         }
 273         xComponent.dispose();
 274
 275         return 1;
 276     }
 277
 278     public boolean setStorageTypeAndCheckProps( XStorage xStorage, String sMediaType, boolean bIsRoot, int nMode )
 279     {
 280         boolean bOk = false;
 281
 282         // get access to the XPropertySet interface
 283         XPropertySet xPropSet = UnoRuntime.queryInterface( XPropertySet.class, xStorage );
 284         if ( xPropSet != null )
 285         {
 286             try
 287             {
 288                 // set "MediaType" property to the stream
 289                 xPropSet.setPropertyValue( "MediaType", sMediaType );
 290
 291                 // get "IsRoot" and "OpenMode" properties and control there values
 292                 boolean bPropIsRoot = AnyConverter.toBoolean( xPropSet.getPropertyValue( "IsRoot" ) );
 293                 int nPropMode = AnyConverter.toInt( xPropSet.getPropertyValue( "OpenMode" ) );
 294
 295                 bOk = true;
 296                 if ( bPropIsRoot != bIsRoot )
 297                 {
 298                     Error( "'IsRoot' property contains wrong value!" );
 299                     bOk = false;
 300                 }
 301
 302                 if ( ( bIsRoot && ( nPropMode | ElementModes.READ ) != ( nMode | ElementModes.READ ) )
 303                   || ( !bIsRoot && ( nPropMode & nMode ) != nMode ) )
 304                 {
 305                     Error( "'OpenMode' property contains wrong value!" );
 306                     bOk = false;
 307                 }
 308             }
 309             catch( Exception e )
 310             {
 311                 Error( "Can't control properties of substorage, exception: " + e );
 312             }
 313         }
 314         else
 315         {
 316             Error( "Can't get XPropertySet implementation from storage!" );
 317         }
 318
 319         return bOk;
 320     }
 321
 322     public boolean checkStorageProperties( XStorage xStorage, String sMediaType, boolean bIsRoot, int nMode )
 323     {
 324         boolean bOk = false;
 325
 326         // get access to the XPropertySet interface
 327         XPropertySet xPropSet = UnoRuntime.queryInterface( XPropertySet.class, xStorage );
 328         if ( xPropSet != null )
 329         {
 330             try
 331             {
 332                 // get "MediaType", "IsRoot" and "OpenMode" properties and control there values
 333                 String sPropMediaType = AnyConverter.toString( xPropSet.getPropertyValue( "MediaType" ) );
 334                 boolean bPropIsRoot = AnyConverter.toBoolean( xPropSet.getPropertyValue( "IsRoot" ) );
 335                 int nPropMode = AnyConverter.toInt( xPropSet.getPropertyValue( "OpenMode" ) );
 336
 337                 bOk = true;
 338                 if ( !sPropMediaType.equals( sMediaType ) )
 339                 {
 340                     Error( "'MediaType' property contains wrong value, expected '"
 341                             + sMediaType + "', set '" + sPropMediaType + "' !" );
 342                     bOk = false;
 343                 }
 344
 345                 if ( bPropIsRoot != bIsRoot )
 346                 {
 347                     Error( "'IsRoot' property contains wrong value!" );
 348                     bOk = false;
 349                 }
 350
 351                 if ( ( bIsRoot && ( nPropMode | ElementModes.READ ) != ( nMode | ElementModes.READ ) )
 352                   || ( !bIsRoot && ( nPropMode & nMode ) != nMode ) )
 353                 {
 354                     Error( "'OpenMode' property contains wrong value!" );
 355                     bOk = false;
 356                 }
 357             }
 358             catch( Exception e )
 359             {
 360                 Error( "Can't get properties of substorage, exception: " + e );
 361             }
 362         }
 363         else
 364         {
 365             Error( "Can't get XPropertySet implementation from storage!" );
 366         }
 367
 368         return bOk;
 369     }
 370
 371     public boolean InternalCheckStream( XStream xStream,
 372                                         String sName,
 373                                         String sMediaType,
 374                                         byte[] pBytes )
 375     {
 376         // get input stream of substream
 377         XInputStream xInput = xStream.getInputStream();
 378         if ( xInput == null )
 379         {
 380             Error( "Can't get XInputStream implementation from substream '" + sName + "'!" );
 381             return false;
 382         }
 383
 384         byte pContents[][] = new byte[1][]; // ???
 385
 386         // read contents
 387         try
 388         {
 389             xInput.readBytes( pContents, pBytes.length + 1 );
 390         }
 391         catch( Exception e )
 392         {
 393             Error( "Can't read from stream '" + sName + "', exception: " + e );
 394             return false;
 395         }
 396
 397         // check size of stream data
 398         if ( pContents.length == 0 )
 399         {
 400             Error( "SubStream '" + sName + "' reading produced disaster!"  );
 401             return false;
 402         }
 403
 404         if ( pBytes.length != pContents[0].length )
 405         {
 406             Error( "SubStream '" + sName + "' contains wrong amount of data! (" + pContents[0].length + "/" + pBytes.length + ")" );
 407             return false;
 408         }
 409
 410         // check stream data
 411         for ( int ind = 0; ind < pBytes.length; ind++ )
 412         {
 413             if ( pBytes[ind] != pContents[0][ind] )
 414             {
 415                 Error( "SubStream '" + sName + "' contains wrong data!" );
 416                 return false;
 417             }
 418         }
 419
 420
 421         // check properties
 422         boolean bOk = false;
 423
 424         // get access to the XPropertySet interface
 425         XPropertySet xPropSet = UnoRuntime.queryInterface( XPropertySet.class, xStream );
 426         if ( xPropSet != null )
 427         {
 428             try
 429             {
 430                 // get "MediaType" and "Size" properties and control there values
 431                 String sPropMediaType = AnyConverter.toString( xPropSet.getPropertyValue( "MediaType" ) );
 432                 long nPropSize = AnyConverter.toLong( xPropSet.getPropertyValue( "Size" ) );
 433
 434                 bOk = true;
 435                 if ( !sPropMediaType.equals( sMediaType ) )
 436                 {
 437                     Error( "'MediaType' property contains wrong value for stream '" + sName + "',\nexpected: '"
 438                             + sMediaType + "', set: '" + sPropMediaType + "'!" );
 439                     bOk = false;
 440                 }
 441
 442                 if ( nPropSize != pBytes.length )
 443                 {
 444                     Error( "'Size' property contains wrong value for stream'" + sName + "'!" );
 445                     bOk = false;
 446                 }
 447             }
 448             catch( Exception e )
 449             {
 450                 Error( "Can't get properties of substream '" + sName + "', exception: " + e );
 451             }
 452         }
 453         else
 454         {
 455             Error( "Can't get XPropertySet implementation from stream '" + sName + "'!" );
 456         }
 457
 458         return bOk;
 459     }
 460
 461     public boolean checkStream( XStorage xParentStorage,
 462                                 String sName,
 463                                 String sMediaType,
 464                                 byte[] pBytes )
 465     {
 466         // open substream element first
 467         XStream xSubStream = null;
 468         try
 469         {
 470             Object oSubStream = xParentStorage.openStreamElement( sName, ElementModes.READ );
 471             xSubStream = UnoRuntime.queryInterface( XStream.class, oSubStream );
 472             if ( xSubStream == null )
 473             {
 474                 Error( "Can't open substream '" + sName + "'!" );
 475                 return false;
 476             }
 477         }
 478         catch( Exception e )
 479         {
 480             Error( "Can't open substream '" + sName + "', exception : " + e + "!" );
 481             return false;
 482         }
 483
 484         return InternalCheckStream( xSubStream, sName, sMediaType, pBytes );
 485     }
 486
 487     public boolean checkEncrStream( XStorage xParentStorage,
 488                                     String sName,
 489                                     String sMediaType,
 490                                     byte[] pBytes,
 491                                     byte[] pPass )
 492     {
 493         // Important: a common password for any of parent storage should not be set or
 494         //            should be different from pPass
 495
 496         if ( pPass.length == 0 )
 497         {
 498             Error( "Wrong password is used in the test!" );
 499             return false;
 500         }
 501
 502         try
 503         {
 504             xParentStorage.openStreamElement( sName, ElementModes.READ );
 505             Error( "Encrypted stream '" + sName + "' was opened without password!" );
 506             return false;
 507         }
 508         catch( WrongPasswordException wpe )
 509         {}
 510         catch( Exception e )
 511         {
 512             Error( "Unexpected exception in case of opening of encrypted stream '" + sName + "' without password: " + e + "!" );
 513             return false;
 514         }
 515
 516         byte pWrongPass[] = { 1, 1 };
 517         pWrongPass[0] += pPass[0];
 518         try
 519         {
 520             xParentStorage.openEncryptedStreamElement( sName, ElementModes.READ, new String(pWrongPass) );
 521             Error( "Encrypted stream '" + sName + "' was opened with wrong password!" );
 522             return false;
 523         }
 524         catch( WrongPasswordException wpe )
 525         {}
 526         catch( Exception e )
 527         {
 528             Error( "Unexpected exception in case of opening of encrypted stream '" + sName + "' with wrong password: " + e + "!" );
 529             return false;
 530         }
 531
 532         XStream xSubStream = null;
 533         try
 534         {
 535             Object oSubStream = xParentStorage.openEncryptedStreamElement( sName, ElementModes.READ, new String(pPass) );
 536             xSubStream = UnoRuntime.queryInterface( XStream.class, oSubStream );
 537             if ( xSubStream == null )
 538             {
 539                 Error( "Can't open encrypted substream '" + sName + "'!" );
 540                 return false;
 541             }
 542         }
 543         catch( Exception e )
 544         {
 545             Error( "Can't open encrypted substream '" + sName + "', exception : " + e + "!" );
 546             return false;
 547         }
 548
 549         return InternalCheckStream( xSubStream, sName, sMediaType, pBytes );
 550     }
 551
 552     public boolean copyStorage( XStorage xSourceStorage, XStorage xDestStorage )
 553     {
 554         // copy xSourceStorage to xDestStorage
 555         try
 556         {
 557             xSourceStorage.copyToStorage( xDestStorage );
 558         }
 559         catch( Exception e )
 560         {
 561             Error( "Storage copying failed, exception: " + e );
 562             return false;
 563         }
 564
 565         return true;
 566     }
 567
 568     public boolean commitStorage( XStorage xStorage )
 569     {
 570         // XTransactedObject must be supported by storages
 571         XTransactedObject xTransact = UnoRuntime.queryInterface( XTransactedObject.class, xStorage );
 572         if ( xTransact == null )
 573         {
 574             Error( "Storage doesn't implement transacted access!" );
 575             return false;
 576         }
 577
 578         try
 579         {
 580             xTransact.commit();
 581         }
 582         catch( Exception e )
 583         {
 584             Error( "Storage commit failed, exception:" + e );
 585             return false;
 586         }
 587
 588         return true;
 589     }
 590
 591     public boolean disposeStorage( XStorage xStorage )
 592     {
 593         // dispose the storage
 594         XComponent xComponent = UnoRuntime.queryInterface( XComponent.class, xStorage );
 595         if ( xComponent == null )
 596         {
 597             Error( "Can't retrieve XComponent implementation from storage!" );
 598             return false;
 599         }
 600
 601         try
 602         {
 603             xComponent.dispose();
 604         }
 605         catch( Exception e )
 606         {
 607             Error( "Storage disposing failed!" );
 608             return false;
 609         }
 610
 611         return true;
 612     }
 613
 614     public XInputStream getInputStream( XStream xStream )
 615     {
 616         XInputStream xInTemp = null;
 617         try
 618         {
 619             xInTemp = xStream.getInputStream();
 620             if ( xInTemp == null )
 621                 Error( "Can't get the input part of a stream!" );
 622         }
 623         catch ( Exception e )
 624         {
 625             Error( "Can't get the input part of a stream, exception :" + e );
 626         }
 627
 628         return xInTemp;
 629     }
 630
 631     public boolean closeOutput( XStream xStream )
 632     {
 633         XOutputStream xOutTemp = null;
 634         try
 635         {
 636             xOutTemp = xStream.getOutputStream();
 637             if ( xOutTemp == null )
 638             {
 639                 Error( "Can't get the output part of a stream!" );
 640                 return false;
 641             }
 642         }
 643         catch ( Exception e )
 644         {
 645             Error( "Can't get the output part of a stream, exception :" + e );
 646             return false;
 647         }
 648
 649         try
 650         {
 651             xOutTemp.closeOutput();
 652         }
 653         catch ( Exception e )
 654         {
 655             Error( "Can't close output part of a stream, exception :" + e );
 656             return false;
 657         }
 658
 659         return true;
 660     }
 661
 662     public XStorage openSubStorage( XStorage xStorage, String sName, int nMode )
 663     {
 664         // open existing substorage
 665         try
 666         {
 667             Object oSubStorage = xStorage.openStorageElement( sName, nMode );
 668             XStorage xSubStorage = UnoRuntime.queryInterface( XStorage.class, oSubStorage );
 669             return xSubStorage;
 670         }
 671         catch( Exception e )
 672         {
 673             Error( "Can't open substorage '" + sName + "', exception: " + e );
 674         }
 675
 676         return null;
 677     }
 678
 679     public XStream CreateTempFileStream( XMultiServiceFactory xMSF )
 680     {
 681         // try to get temporary file representation
 682         XStream xTempFileStream = null;
 683         try
 684         {
 685             Object oTempFile = xMSF.createInstance( "com.sun.star.io.TempFile" );
 686             xTempFileStream = UnoRuntime.queryInterface( XStream.class, oTempFile );
 687         }
 688         catch( Exception e )
 689         {}
 690
 691         if ( xTempFileStream == null )
 692             Error( "Can't create temporary file!" );
 693
 694         return xTempFileStream;
 695     }
 696
 697     public String CreateTempFile( XMultiServiceFactory xMSF )
 698     {
 699         String sResult = null;
 700
 701         // try to get temporary file representation
 702         XPropertySet xTempFileProps = null;
 703         try
 704         {
 705             Object oTempFile = xMSF.createInstance( "com.sun.star.io.TempFile" );
 706             xTempFileProps = UnoRuntime.queryInterface( XPropertySet.class, oTempFile );
 707         }
 708         catch( Exception e )
 709         {}
 710
 711         if ( xTempFileProps != null )
 712         {
 713             try
 714             {
 715                 xTempFileProps.setPropertyValue( "RemoveFile", Boolean.FALSE );
 716                 sResult = AnyConverter.toString( xTempFileProps.getPropertyValue( "Uri" ) );
 717             }
 718             catch( Exception e )
 719             {
 720                 Error( "Can't control TempFile properties, exception: " + e );
 721             }
 722         }
 723         else
 724         {
 725             Error( "Can't create temporary file representation!" );
 726         }
 727
 728         // close temporary file explicitly
 729         try
 730         {
 731             XStream xStream = UnoRuntime.queryInterface( XStream.class, xTempFileProps );
 732             if ( xStream != null )
 733             {
 734                 XOutputStream xOut = xStream.getOutputStream();
 735                 if ( xOut != null )
 736                     xOut.closeOutput();
 737
 738                 XInputStream xIn = xStream.getInputStream();
 739                 if ( xIn != null )
 740                     xIn.closeInput();
 741             }
 742             else
 743                 Error( "Can't close TempFile!" );
 744         }
 745         catch( Exception e )
 746         {
 747             Error( "Can't close TempFile, exception: " + e );
 748         }
 749
 750         return sResult;
 751     }
 752
 753     public boolean copyElementTo( XStorage xSource, String sName, XStorage xDest )
 754     {
 755         // copy element with name sName from xSource to xDest
 756         try
 757         {
 758             xSource.copyElementTo( sName, xDest, sName );
 759         }
 760         catch( Exception e )
 761         {
 762             Error( "Element copying failed, exception: " + e );
 763             return false;
 764         }
 765
 766         return true;
 767     }
 768
 769     public boolean moveElementTo( XStorage xSource, String sName, XStorage xDest )
 770     {
 771         // move element with name sName from xSource to xDest
 772         try
 773         {
 774             xSource.moveElementTo( sName, xDest, sName );
 775         }
 776         catch( Exception e )
 777         {
 778             Error( "Element moving failed, exception: " + e );
 779             return false;
 780         }
 781
 782         return true;
 783     }
 784
 785     public boolean renameElement( XStorage xStorage, String sOldName, String sNewName )
 786     {
 787         // rename element with name sOldName to sNewName
 788         try
 789         {
 790             xStorage.renameElement( sOldName, sNewName );
 791         }
 792         catch( Exception e )
 793         {
 794             Error( "Element renaming failed, exception: " + e );
 795             return false;
 796         }
 797
 798         return true;
 799     }
 800
 801     public boolean removeElement( XStorage xStorage, String sName )
 802     {
 803         // remove element with name sName
 804         try
 805         {
 806             xStorage.removeElement( sName );
 807         }
 808         catch( Exception e )
 809         {
 810             Error( "Element removing failed, exception: " + e );
 811             return false;
 812         }
 813
 814         return true;
 815     }
 816
 817     public XStream OpenStream( XStorage xStorage,
 818                                 String sStreamName,
 819                                 int nMode )
 820     {
 821         // open substream element
 822         XStream xSubStream = null;
 823         try
 824         {
 825             Object oSubStream = xStorage.openStreamElement( sStreamName, nMode );
 826             xSubStream = UnoRuntime.queryInterface( XStream.class, oSubStream );
 827             if ( xSubStream == null )
 828                 Error( "Can't create substream '" + sStreamName + "'!" );
 829         }
 830         catch( Exception e )
 831         {
 832             Error( "Can't create substream '" + sStreamName + "', exception : " + e + "!" );
 833         }
 834
 835         return xSubStream;
 836     }
 837
 838     public boolean cantOpenStorage( XStorage xStorage, String sName )
 839     {
 840         // try to open an opened substorage, open call must fail
 841         try
 842         {
 843             Object oDummyStorage = xStorage.openStorageElement( sName, ElementModes.READ );
 844             Error( "The trying to reopen opened substorage '" + sName + "' must fail!" );
 845         }
 846         catch( Exception e )
 847         {
 848             return true;
 849         }
 850
 851         return false;
 852     }
 853
 854     public boolean cantOpenStream( XStorage xStorage, String sName, int nMode )
 855     {
 856         // try to open the substream with specified mode must fail
 857         try
 858         {
 859             Object oDummyStream = xStorage.openStreamElement( sName, nMode );
 860             Error( "The trying to open substream '" + sName + "' must fail!" );
 861         }
 862         catch( Exception e )
 863         {
 864             return true;
 865         }
 866
 867         return false;
 868     }
 869
 870     public void Error( String sError )
 871     {
 872         System.out.println( m_sTestPrefix + "Error: " + sError );
 873     }
 874
 875     public void Message( String sError )
 876     {
 877         System.out.println( m_sTestPrefix + sError );
 878     }
 879 }
 880
 881 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */