package/qa/ofopxmlstorages/TestHelper.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 complex.ofopxmlstorages;
  20
  21 import com.sun.star.uno.UnoRuntime;
  22 import com.sun.star.uno.XInterface;
  23 import com.sun.star.uno.AnyConverter;
  24
  25 import com.sun.star.lang.*;
  26 import com.sun.star.embed.*;
  27 import com.sun.star.packages.*;
  28 import com.sun.star.io.*;
  29 import com.sun.star.beans.*;
  30
  31 import share.LogWriter;
  32
  33 public class TestHelper  {
  34
  35     LogWriter m_aLogWriter;
  36     String m_sTestPrefix;
  37
  38     public TestHelper( LogWriter aLogWriter, String sTestPrefix )
  39     {
  40         m_aLogWriter = aLogWriter;
  41         m_sTestPrefix = sTestPrefix;
  42     }
  43
  44     public boolean WriteBytesToStream( XStream xStream,
  45                                         String sStreamName,
  46                                         String sMediaType,
  47                                         boolean bCompressed,
  48                                         byte[] pBytes,
  49                                         StringPair[][] aRelations )
  50     {
  51         // get output stream of substream
  52         XOutputStream xOutput = xStream.getOutputStream();
  53         if ( xOutput == null )
  54         {
  55             Error( "Can't get XOutputStream implementation from substream '" + sStreamName + "'!" );
  56             return false;
  57         }
  58
  59         // get XTrucate implementation from output stream
  60         XTruncate xTruncate = (XTruncate) UnoRuntime.queryInterface( XTruncate.class, xOutput );
  61         if ( xTruncate == null )
  62         {
  63             Error( "Can't get XTruncate implementation from substream '" + sStreamName + "'!" );
  64             return false;
  65         }
  66
  67         // write requested byte sequence
  68         try
  69         {
  70             xTruncate.truncate();
  71             xOutput.writeBytes( pBytes );
  72         }
  73         catch( Exception e )
  74         {
  75             Error( "Can't write to stream '" + sStreamName + "', exception: " + e );
  76             return false;
  77         }
  78
  79         // get access to the XPropertySet interface
  80         XPropertySet xPropSet = (XPropertySet) UnoRuntime.queryInterface( XPropertySet.class, xStream );
  81         if ( xPropSet == null )
  82         {
  83             Error( "Can't get XPropertySet implementation from substream '" + sStreamName + "'!" );
  84             return false;
  85         }
  86
  87         // set properties to the stream
  88         try
  89         {
  90             xPropSet.setPropertyValue( "MediaType", sMediaType );
  91             xPropSet.setPropertyValue( "Compressed", Boolean.valueOf( bCompressed ) );
  92         }
  93         catch( Exception e )
  94         {
  95             Error( "Can't set properties to substream '" + sStreamName + "', exception: " + e );
  96             return false;
  97         }
  98
  99         // check size property of the stream
 100         try
 101         {
 102             long nSize = AnyConverter.toLong( xPropSet.getPropertyValue( "Size" ) );
 103             if ( nSize != pBytes.length )
 104             {
 105                 Error( "The 'Size' property of substream '" + sStreamName + "' contains wrong value!" );
 106                 return false;
 107             }
 108         }
 109         catch( Exception e )
 110         {
 111             Error( "Can't get 'Size' property from substream '" + sStreamName + "', exception: " + e );
 112             return false;
 113         }
 114
 115         // get access to the relationship information
 116         XRelationshipAccess xRelAccess = (XRelationshipAccess) UnoRuntime.queryInterface( XRelationshipAccess.class, xStream );
 117         if ( xRelAccess == null )
 118         {
 119             Error( "Can't get XRelationshipAccess implementation from substream '" + sStreamName + "'!" );
 120             return false;
 121         }
 122
 123         // set the relationship information
 124         try
 125         {
 126             xRelAccess.insertRelationships( aRelations, false );
 127         }
 128         catch( Exception e )
 129         {
 130             Error( "Can't set relationships to substream '" + sStreamName + "', exception: " + e );
 131             return false;
 132         }
 133
 134         // free the stream resources, garbage collector may remove the object too late
 135         if ( !disposeStream( xStream, sStreamName ) )
 136             return false;
 137
 138         return true;
 139     }
 140
 141     public boolean WriteBytesToSubstream( XStorage xStorage,
 142                                           String sStreamName,
 143                                           String sMediaType,
 144                                           boolean bCompressed,
 145                                           byte[] pBytes,
 146                                           StringPair[][] aRelations )
 147     {
 148         // open substream element
 149         XStream xSubStream = null;
 150         try
 151         {
 152             Object oSubStream = xStorage.openStreamElement( sStreamName, ElementModes.WRITE );
 153             xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream );
 154             if ( xSubStream == null )
 155             {
 156                 Error( "Can't create substream '" + sStreamName + "'!" );
 157                 return false;
 158             }
 159         }
 160         catch( Exception e )
 161         {
 162             Error( "Can't create substream '" + sStreamName + "', exception : " + e + "!" );
 163             return false;
 164         }
 165
 166         return WriteBytesToStream( xSubStream, sStreamName, sMediaType, bCompressed, pBytes, aRelations );
 167     }
 168
 169     public boolean setStorageTypeAndCheckProps( XStorage xStorage,
 170                                                 boolean bIsRoot,
 171                                                 int nMode,
 172                                                 StringPair[][] aRelations )
 173     {
 174         boolean bOk = false;
 175
 176         // get access to the XPropertySet interface
 177         XPropertySet xPropSet = (XPropertySet) UnoRuntime.queryInterface( XPropertySet.class, xStorage );
 178         if ( xPropSet != null )
 179         {
 180             try
 181             {
 182                 // get "IsRoot" and "OpenMode" properties and control there values
 183                 boolean bPropIsRoot = AnyConverter.toBoolean( xPropSet.getPropertyValue( "IsRoot" ) );
 184                 int nPropMode = AnyConverter.toInt( xPropSet.getPropertyValue( "OpenMode" ) );
 185
 186                 bOk = true;
 187                 if ( bPropIsRoot != bIsRoot )
 188                 {
 189                     Error( "'IsRoot' property contains wrong value!" );
 190                     bOk = false;
 191                 }
 192
 193                 if ( ( bIsRoot
 194                   && ( nPropMode | ElementModes.READ ) != ( nMode | ElementModes.READ ) )
 195                   || ( !bIsRoot && ( nPropMode & nMode ) != nMode ) )
 196                 {
 197                     Error( "'OpenMode' property contains wrong value, expected " + nMode + ", in reality " + nPropMode + "!" );
 198                     bOk = false;
 199                 }
 200             }
 201             catch( Exception e )
 202             {
 203                 Error( "Can't control properties of substorage, exception: " + e );
 204             }
 205         }
 206         else
 207         {
 208             Error( "Can't get XPropertySet implementation from storage!" );
 209         }
 210
 211         // get access to the relationship information
 212         XRelationshipAccess xRelAccess = (XRelationshipAccess) UnoRuntime.queryInterface( XRelationshipAccess.class, xStorage );
 213
 214         if ( xRelAccess == null )
 215         {
 216             Error( "Can't get XRelationshipAccess implementation from the storage!" );
 217             return false;
 218         }
 219
 220         // set the relationship information
 221         try
 222         {
 223             xRelAccess.insertRelationships( aRelations, false );
 224         }
 225         catch( Exception e )
 226         {
 227             Error( "Can't set relationships to the storage, exception: " + e );
 228             return false;
 229         }
 230
 231
 232         return bOk;
 233     }
 234
 235     public boolean checkRelations( StringPair[][] aStorRels, StringPair[][] aTestRels )
 236     {
 237         if ( aStorRels.length != aTestRels.length )
 238         {
 239             Error( "The provided relations sequence has different size than the storage's one!" );
 240             return false;
 241         }
 242
 243         for ( int nStorInd = 0; nStorInd < aStorRels.length; nStorInd++ )
 244         {
 245             int nStorIDInd = -1;
 246             for ( int nStorTagInd = 0; nStorTagInd < aStorRels[nStorInd].length; nStorTagInd++ )
 247             {
 248                 if ( aStorRels[nStorInd][nStorTagInd].First.equals( "Id" ) )
 249                 {
 250                     nStorIDInd = nStorTagInd;
 251                     break;
 252                 }
 253             }
 254
 255             if ( nStorIDInd == -1 )
 256             {
 257                 Error( "One of the storage relations entries has no ID!" );
 258                 return false;
 259             }
 260
 261             for ( int nInd = 0; nInd < aTestRels.length; nInd++ )
 262             {
 263                 int nIDInd = -1;
 264                 for ( int nTagInd = 0; nTagInd < aTestRels[nInd].length; nTagInd++ )
 265                 {
 266                     if ( aTestRels[nInd][nTagInd].First.equals( "Id" ) )
 267                     {
 268                         nIDInd = nTagInd;
 269                         break;
 270                     }
 271                 }
 272
 273                 if ( nIDInd == -1 )
 274                 {
 275                     Error( "One of the test hardcoded entries has no ID, num = " + nInd + ", length = " + aTestRels[nInd].length + ", global length = " + aTestRels.length + "!" );
 276                     return false;
 277                 }
 278
 279                 if ( aStorRels[nStorInd][nStorIDInd].Second.equals( aTestRels[nInd][nIDInd].Second ) )
 280                 {
 281                     boolean[] pRelCheckMark = new boolean[ aTestRels[nInd].length ];
 282                     for ( int nCheckInd = 0; nCheckInd < pRelCheckMark.length; nCheckInd++ )
 283                     {
 284                         pRelCheckMark[nCheckInd] = false;
 285                     }
 286
 287                     for ( int nStorTagInd = 0; nStorTagInd < aStorRels[nStorInd].length; nStorTagInd++ )
 288                     {
 289                         boolean bFound = false;
 290                         for ( int nTagInd = 0; nTagInd < aTestRels[nInd].length; nTagInd++ )
 291                         {
 292                             if ( aTestRels[nInd][nTagInd].First.equals( aStorRels[nStorInd][nStorTagInd].First ) )
 293                             {
 294                                 if ( !aTestRels[nInd][nTagInd].Second.equals( aStorRels[nStorInd][nStorTagInd].Second ) )
 295                                 {
 296                                     Error( "Test rel. num. " + nInd + " has different tag \"" + aTestRels[nInd][nTagInd].First + "\" value!" );
 297                                     return false;
 298                                 }
 299
 300                                 bFound = true;
 301                                 pRelCheckMark[nTagInd] = true;
 302                                 break;
 303                             }
 304                         }
 305
 306                         if ( !bFound )
 307                         {
 308                             Error( "Stor rel. num. " + nStorInd + " has unexpected tag \"" + aStorRels[nStorInd][nStorTagInd].First + "\", ID = \"" + aStorRels[nStorInd][nStorIDInd].Second + "\"!" );
 309                             return false;
 310                         }
 311                     }
 312
 313                     for ( int nCheckInd = 0; nCheckInd < pRelCheckMark.length; nCheckInd++ )
 314                     {
 315                         if ( !pRelCheckMark[nCheckInd] && !aTestRels[nInd][nCheckInd].Second.equals( "" ) )
 316                         {
 317                             Error( "Test rel. num. " + nInd + " has unexpected tag \"" + aTestRels[nInd][nCheckInd].First + "\" with nonempty value!" );
 318                             return false;
 319                         }
 320                     }
 321
 322                     break;
 323                 }
 324             }
 325         }
 326
 327         return true;
 328     }
 329
 330     public boolean checkStorageProperties( XStorage xStorage,
 331                                             boolean bIsRoot,
 332                                             int nMode,
 333                                             StringPair[][] aRelations )
 334     {
 335         boolean bOk = false;
 336
 337         // get access to the XPropertySet interface
 338         XPropertySet xPropSet = (XPropertySet) UnoRuntime.queryInterface( XPropertySet.class, xStorage );
 339         if ( xPropSet != null )
 340         {
 341             try
 342             {
 343                 // get "IsRoot" and "OpenMode" properties and control there values
 344                 boolean bPropIsRoot = AnyConverter.toBoolean( xPropSet.getPropertyValue( "IsRoot" ) );
 345                 int nPropMode = AnyConverter.toInt( xPropSet.getPropertyValue( "OpenMode" ) );
 346
 347                 bOk = true;
 348                 if ( bPropIsRoot != bIsRoot )
 349                 {
 350                     Error( "'IsRoot' property contains wrong value!" );
 351                     bOk = false;
 352                 }
 353
 354                 if ( ( bIsRoot
 355                   && ( nPropMode | ElementModes.READ ) != ( nMode | ElementModes.READ ) )
 356                   || ( !bIsRoot && ( nPropMode & nMode ) != nMode ) )
 357                 {
 358                     Error( "'OpenMode' property contains wrong value, expected " + nMode + ", in reality " + nPropMode + "!" );
 359                     bOk = false;
 360                 }
 361             }
 362             catch( Exception e )
 363             {
 364                 Error( "Can't get properties of substorage, exception: " + e );
 365             }
 366         }
 367         else
 368         {
 369             Error( "Can't get XPropertySet implementation from storage!" );
 370         }
 371
 372         // get access to the relationship information
 373         XRelationshipAccess xRelAccess = (XRelationshipAccess) UnoRuntime.queryInterface( XRelationshipAccess.class, xStorage );
 374
 375         if ( xRelAccess == null )
 376         {
 377             Error( "Can't get XRelationshipAccess implementation from the checked storage!" );
 378             return false;
 379         }
 380
 381         // get the relationship information
 382         StringPair[][] aStorRels;
 383         try
 384         {
 385             aStorRels = xRelAccess.getAllRelationships();
 386         }
 387         catch( Exception e )
 388         {
 389             Error( "Can't get relationships of the checked storage, exception: " + e );
 390             return false;
 391         }
 392
 393         if ( !checkRelations( aStorRels, aRelations ) )
 394         {
 395             Error( "StorageRelationsChecking has failed!" );
 396             return false;
 397         }
 398
 399         return bOk;
 400     }
 401
 402     public boolean InternalCheckStream( XStream xStream,
 403                                         String sName,
 404                                         String sMediaType,
 405                                         byte[] pBytes,
 406                                         StringPair[][] aRelations )
 407     {
 408         // get input stream of substream
 409         XInputStream xInput = xStream.getInputStream();
 410         if ( xInput == null )
 411         {
 412             Error( "Can't get XInputStream implementation from substream '" + sName + "'!" );
 413             return false;
 414         }
 415
 416         byte pContents[][] = new byte[1][]; // ???
 417
 418         // read contents
 419         try
 420         {
 421             xInput.readBytes( pContents, pBytes.length + 1 );
 422         }
 423         catch( Exception e )
 424         {
 425             Error( "Can't read from stream '" + sName + "', exception: " + e );
 426             return false;
 427         }
 428
 429         // check size of stream data
 430         if ( pContents.length == 0 )
 431         {
 432             Error( "SubStream '" + sName + "' reading produced disaster!"  );
 433             return false;
 434         }
 435
 436         if ( pBytes.length != pContents[0].length )
 437         {
 438             Error( "SubStream '" + sName + "' contains wrong amount of data! (" + pContents[0].length + "/" + pBytes.length + ")" );
 439             return false;
 440         }
 441
 442         // check stream data
 443         for ( int ind = 0; ind < pBytes.length; ind++ )
 444         {
 445             if ( pBytes[ind] != pContents[0][ind] )
 446             {
 447                 Error( "SubStream '" + sName + "' contains wrong data! ( byte num. "
 448                         + ind + " should be" + pBytes[ind] + " but it is " + pContents[0][ind] + ")" );
 449                 return false;
 450             }
 451         }
 452
 453         // check properties
 454         boolean bOk = false;
 455
 456         // get access to the XPropertySet interface
 457         XPropertySet xPropSet = (XPropertySet) UnoRuntime.queryInterface( XPropertySet.class, xStream );
 458         if ( xPropSet != null )
 459         {
 460             try
 461             {
 462                 // get "MediaType" and "Size" properties and control there values
 463                 String sPropMediaType = AnyConverter.toString( xPropSet.getPropertyValue( "MediaType" ) );
 464                 long nPropSize = AnyConverter.toLong( xPropSet.getPropertyValue( "Size" ) );
 465
 466                 bOk = true;
 467                 if ( !sPropMediaType.equals( sMediaType ) )
 468                 {
 469                     Error( "'MediaType' property contains wrong value for stream '" + sName + "',\nexpected: '"
 470                             + sMediaType + "', set: '" + sPropMediaType + "'!" );
 471                     bOk = false;
 472                 }
 473
 474                 if ( nPropSize != pBytes.length )
 475                 {
 476                     Error( "'Size' property contains wrong value for stream'" + sName + "'!" );
 477                     bOk = false;
 478                 }
 479             }
 480             catch( Exception e )
 481             {
 482                 Error( "Can't get properties of substream '" + sName + "', exception: " + e );
 483             }
 484         }
 485         else
 486         {
 487             Error( "Can't get XPropertySet implementation from stream '" + sName + "'!" );
 488         }
 489
 490
 491         // get access to the relationship information
 492         XRelationshipAccess xRelAccess = (XRelationshipAccess) UnoRuntime.queryInterface( XRelationshipAccess.class, xStream );
 493
 494         if ( xRelAccess == null )
 495         {
 496             Error( "Can't get XRelationshipAccess implementation from the stream\"" + sName + "\"!" );
 497             return false;
 498         }
 499
 500         // get the relationship information
 501         StringPair[][] aStorRels;
 502         try
 503         {
 504             aStorRels = xRelAccess.getAllRelationships();
 505         }
 506         catch( Exception e )
 507         {
 508             Error( "Can't get relationships of the substream '" + sName + "', exception: " + e );
 509             return false;
 510         }
 511
 512         if ( !checkRelations( aStorRels, aRelations ) )
 513         {
 514             Error( "Stream '" + sName + "' RelationsChecking has failed!" );
 515             return false;
 516         }
 517
 518         return bOk;
 519     }
 520
 521     public boolean checkStream( XStorage xParentStorage,
 522                                 String sName,
 523                                 String sMediaType,
 524                                 byte[] pBytes,
 525                                 StringPair[][] aRelations )
 526     {
 527         // open substream element first
 528         XStream xSubStream = null;
 529         try
 530         {
 531             Object oSubStream = xParentStorage.openStreamElement( sName, ElementModes.READ );
 532             xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream );
 533             if ( xSubStream == null )
 534             {
 535                 Error( "Can't open substream '" + sName + "'!" );
 536                 return false;
 537             }
 538         }
 539         catch( Exception e )
 540         {
 541             Error( "Can't open substream '" + sName + "', exception : " + e + "!" );
 542             return false;
 543         }
 544
 545         boolean bResult = InternalCheckStream( xSubStream, sName, sMediaType, pBytes, aRelations );
 546
 547         // free the stream resources, garbage collector may remove the object too late
 548         if ( !disposeStream( xSubStream, sName ) )
 549             return false;
 550
 551         return bResult;
 552     }
 553
 554     public boolean copyStorage( XStorage xSourceStorage, XStorage xDestStorage )
 555     {
 556         // copy xSourceStorage to xDestStorage
 557         try
 558         {
 559             xSourceStorage.copyToStorage( xDestStorage );
 560         }
 561         catch( Exception e )
 562         {
 563             Error( "Storage copying failed, exception: " + e );
 564             return false;
 565         }
 566
 567         return true;
 568     }
 569
 570     public boolean commitStorage( XStorage xStorage )
 571     {
 572         // XTransactedObject must be supported by storages
 573         XTransactedObject xTransact = (XTransactedObject) UnoRuntime.queryInterface( XTransactedObject.class, xStorage );
 574         if ( xTransact == null )
 575         {
 576             Error( "Storage doesn't implement transacted access!" );
 577             return false;
 578         }
 579
 580         try
 581         {
 582             xTransact.commit();
 583         }
 584         catch( Exception e )
 585         {
 586             Error( "Storage commit failed, exception:" + e );
 587             return false;
 588         }
 589
 590         return true;
 591     }
 592
 593     public boolean disposeStream( XStream xStream, String sStreamName )
 594     {
 595         XComponent xComponent = (XComponent) UnoRuntime.queryInterface( XComponent.class, xStream );
 596         if ( xComponent == null )
 597         {
 598             Error( "Can't get XComponent implementation from substream '" + sStreamName + "'!" );
 599             return false;
 600         }
 601
 602         try
 603         {
 604             xComponent.dispose();
 605         }
 606         catch( Exception e )
 607         {
 608             Error( "Substream '" + sStreamName + "' disposing throws exception: " + e );
 609             return false;
 610         }
 611
 612         return true;
 613     }
 614
 615     public boolean disposeStorage( XStorage xStorage )
 616     {
 617         // dispose the storage
 618         XComponent xComponent = (XComponent) UnoRuntime.queryInterface( XComponent.class, xStorage );
 619         if ( xComponent == null )
 620         {
 621             Error( "Can't retrieve XComponent implementation from storage!" );
 622             return false;
 623         }
 624
 625         try
 626         {
 627             xComponent.dispose();
 628         }
 629         catch( Exception e )
 630         {
 631             Error( "Storage disposing failed!" );
 632             return false;
 633         }
 634
 635         return true;
 636     }
 637
 638     public XInputStream getInputStream( XStream xStream )
 639     {
 640         XInputStream xInTemp = null;
 641         try
 642         {
 643             xInTemp = xStream.getInputStream();
 644             if ( xInTemp == null )
 645                 Error( "Can't get the input part of a stream!" );
 646         }
 647         catch ( Exception e )
 648         {
 649             Error( "Can't get the input part of a stream, exception :" + e );
 650         }
 651
 652         return xInTemp;
 653     }
 654
 655     public boolean closeOutput( XStream xStream )
 656     {
 657         XOutputStream xOutTemp = null;
 658         try
 659         {
 660             xOutTemp = xStream.getOutputStream();
 661             if ( xOutTemp == null )
 662             {
 663                 Error( "Can't get the output part of a stream!" );
 664                 return false;
 665             }
 666         }
 667         catch ( Exception e )
 668         {
 669             Error( "Can't get the output part of a stream, exception :" + e );
 670             return false;
 671         }
 672
 673         try
 674         {
 675             xOutTemp.closeOutput();
 676         }
 677         catch ( Exception e )
 678         {
 679             Error( "Can't close output part of a stream, exception :" + e );
 680             return false;
 681         }
 682
 683         return true;
 684     }
 685
 686     public XStorage openSubStorage( XStorage xStorage, String sName, int nMode )
 687     {
 688         // open existing substorage
 689         try
 690         {
 691             Object oSubStorage = xStorage.openStorageElement( sName, nMode );
 692             XStorage xSubStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oSubStorage );
 693             return xSubStorage;
 694         }
 695         catch( Exception e )
 696         {
 697             Error( "Can't open substorage '" + sName + "', exception: " + e );
 698         }
 699
 700         return null;
 701     }
 702
 703     public XStream CreateTempFileStream( XMultiServiceFactory xMSF )
 704     {
 705         // try to get temporary file representation
 706         XStream xTempFileStream = null;
 707         try
 708         {
 709             Object oTempFile = xMSF.createInstance( "com.sun.star.io.TempFile" );
 710             xTempFileStream = (XStream)UnoRuntime.queryInterface( XStream.class, oTempFile );
 711         }
 712         catch( Exception e )
 713         {}
 714
 715         if ( xTempFileStream == null )
 716             Error( "Can't create temporary file!" );
 717
 718         return xTempFileStream;
 719     }
 720
 721     public String CreateTempFile( XMultiServiceFactory xMSF )
 722     {
 723         String sResult = null;
 724
 725         // try to get temporary file representation
 726         XPropertySet xTempFileProps = null;
 727         try
 728         {
 729             Object oTempFile = xMSF.createInstance( "com.sun.star.io.TempFile" );
 730             xTempFileProps = (XPropertySet)UnoRuntime.queryInterface( XPropertySet.class, oTempFile );
 731         }
 732         catch( Exception e )
 733         {}
 734
 735         if ( xTempFileProps != null )
 736         {
 737             try
 738             {
 739                 xTempFileProps.setPropertyValue( "RemoveFile", Boolean.FALSE );
 740                 sResult = AnyConverter.toString( xTempFileProps.getPropertyValue( "Uri" ) );
 741             }
 742             catch( Exception e )
 743             {
 744                 Error( "Can't control TempFile properties, exception: " + e );
 745             }
 746         }
 747         else
 748         {
 749             Error( "Can't create temporary file representation!" );
 750         }
 751
 752         // close temporary file explicitly
 753         try
 754         {
 755             XStream xStream = (XStream)UnoRuntime.queryInterface( XStream.class, xTempFileProps );
 756             if ( xStream != null )
 757             {
 758                 XOutputStream xOut = xStream.getOutputStream();
 759                 if ( xOut != null )
 760                     xOut.closeOutput();
 761
 762                 XInputStream xIn = xStream.getInputStream();
 763                 if ( xIn != null )
 764                     xIn.closeInput();
 765             }
 766             else
 767                 Error( "Can't close TempFile!" );
 768         }
 769         catch( Exception e )
 770         {
 771             Error( "Can't close TempFile, exception: " + e );
 772         }
 773
 774         return sResult;
 775     }
 776
 777     public boolean copyElementTo( XStorage xSource, String sName, XStorage xDest )
 778     {
 779         // copy element with name sName from xSource to xDest
 780         try
 781         {
 782             xSource.copyElementTo( sName, xDest, sName );
 783         }
 784         catch( Exception e )
 785         {
 786             Error( "Element copying failed, exception: " + e );
 787             return false;
 788         }
 789
 790         return true;
 791     }
 792
 793     public boolean copyElementTo( XStorage xSource, String sName, XStorage xDest, String sTargetName )
 794     {
 795         // copy element with name sName from xSource to xDest
 796         try
 797         {
 798             xSource.copyElementTo( sName, xDest, sTargetName );
 799         }
 800         catch( Exception e )
 801         {
 802             Error( "Element copying failed, exception: " + e );
 803             return false;
 804         }
 805
 806         return true;
 807     }
 808
 809     public boolean moveElementTo( XStorage xSource, String sName, XStorage xDest )
 810     {
 811         // move element with name sName from xSource to xDest
 812         try
 813         {
 814             xSource.moveElementTo( sName, xDest, sName );
 815         }
 816         catch( Exception e )
 817         {
 818             Error( "Element moving failed, exception: " + e );
 819             return false;
 820         }
 821
 822         return true;
 823     }
 824
 825     public boolean renameElement( XStorage xStorage, String sOldName, String sNewName )
 826     {
 827         // rename element with name sOldName to sNewName
 828         try
 829         {
 830             xStorage.renameElement( sOldName, sNewName );
 831         }
 832         catch( Exception e )
 833         {
 834             Error( "Element renaming failed, exception: " + e );
 835             return false;
 836         }
 837
 838         return true;
 839     }
 840
 841     public boolean removeElement( XStorage xStorage, String sName )
 842     {
 843         // remove element with name sName
 844         try
 845         {
 846             xStorage.removeElement( sName );
 847         }
 848         catch( Exception e )
 849         {
 850             Error( "Element removing failed, exception: " + e );
 851             return false;
 852         }
 853
 854         return true;
 855     }
 856
 857     public XStream OpenStream( XStorage xStorage,
 858                                 String sStreamName,
 859                                 int nMode )
 860     {
 861         // open substream element
 862         XStream xSubStream = null;
 863         try
 864         {
 865             Object oSubStream = xStorage.openStreamElement( sStreamName, nMode );
 866             xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream );
 867             if ( xSubStream == null )
 868                 Error( "Can't create substream '" + sStreamName + "'!" );
 869         }
 870         catch( Exception e )
 871         {
 872             Error( "Can't create substream '" + sStreamName + "', exception : " + e + "!" );
 873         }
 874
 875         return xSubStream;
 876     }
 877
 878     public boolean cantOpenStorage( XStorage xStorage, String sName )
 879     {
 880         // try to open an opened substorage, open call must fail
 881         try
 882         {
 883             Object oDummyStorage = xStorage.openStorageElement( sName, ElementModes.READ );
 884             Error( "The trying to reopen opened substorage '" + sName + "' must fail!" );
 885         }
 886         catch( Exception e )
 887         {
 888             return true;
 889         }
 890
 891         return false;
 892     }
 893
 894     public boolean cantOpenStream( XStorage xStorage, String sName, int nMode )
 895     {
 896         // try to open the substream with specified mode must fail
 897         try
 898         {
 899             Object oDummyStream = xStorage.openStreamElement( sName, nMode );
 900             Error( "The trying to open substoream '" + sName + "' must fail!" );
 901         }
 902         catch( Exception e )
 903         {
 904             return true;
 905         }
 906
 907         return false;
 908     }
 909
 910     public XStorage createStorageFromURL(
 911                                 XSingleServiceFactory xFactory,
 912                                 String aURL,
 913                                 int nMode )
 914     {
 915         XStorage xResult = null;
 916
 917         try
 918         {
 919             PropertyValue[] aAddArgs = new PropertyValue[1];
 920             aAddArgs[0] = new PropertyValue();
 921             aAddArgs[0].Name = "StorageFormat";
 922             aAddArgs[0].Value = "OFOPXMLFormat";
 923
 924             Object pArgs[] = new Object[3];
 925             pArgs[0] = (Object) aURL;
 926             pArgs[1] = Integer.valueOf( nMode );
 927             pArgs[2] = (Object) aAddArgs;
 928
 929             Object oTempStorage = xFactory.createInstanceWithArguments( pArgs );
 930             xResult = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage );
 931         }
 932         catch( Exception e )
 933         {
 934             Error( "Can't create storage from URL, exception: " + e );
 935             return null;
 936         }
 937
 938         if ( xResult == null )
 939             Error( "Can't create storage from URL!" );
 940
 941         return xResult;
 942     }
 943
 944     public XStorage createStorageFromStream(
 945                                 XSingleServiceFactory xFactory,
 946                                 XStream xStream,
 947                                 int nMode )
 948     {
 949         XStorage xResult = null;
 950
 951         try
 952         {
 953             PropertyValue[] aAddArgs = new PropertyValue[1];
 954             aAddArgs[0] = new PropertyValue();
 955             aAddArgs[0].Name = "StorageFormat";
 956             aAddArgs[0].Value = "OFOPXMLFormat";
 957
 958             Object pArgs[] = new Object[3];
 959             pArgs[0] = (Object) xStream;
 960             pArgs[1] = Integer.valueOf( nMode );
 961             pArgs[2] = (Object) aAddArgs;
 962
 963             Object oTempStorage = xFactory.createInstanceWithArguments( pArgs );
 964             xResult = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage );
 965         }
 966         catch( Exception e )
 967         {
 968             Error( "Can't create storage from stream, exception: " + e );
 969             return null;
 970         }
 971
 972         if ( xResult == null )
 973             Error( "Can't create storage from stream!" );
 974
 975         return xResult;
 976     }
 977
 978     public XStorage createStorageFromInputStream(
 979                                 XSingleServiceFactory xFactory,
 980                                 XInputStream xInStream )
 981     {
 982         XStorage xResult = null;
 983
 984         try
 985         {
 986             PropertyValue[] aAddArgs = new PropertyValue[1];
 987             aAddArgs[0] = new PropertyValue();
 988             aAddArgs[0].Name = "StorageFormat";
 989             aAddArgs[0].Value = "OFOPXMLFormat";
 990
 991             Object pArgs[] = new Object[3];
 992             pArgs[0] = (Object) xInStream;
 993             pArgs[1] = Integer.valueOf( ElementModes.READ );
 994             pArgs[2] = (Object) aAddArgs;
 995
 996             Object oTempStorage = xFactory.createInstanceWithArguments( pArgs );
 997             xResult = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage );
 998         }
 999         catch( Exception e )
1000         {
1001             Error( "Can't create storage from input stream, exception: " + e );
1002             return null;
1003         }
1004
1005         if ( xResult == null )
1006             Error( "Can't create storage from input stream!" );
1007
1008         return xResult;
1009     }
1010
1011     public XStorage createTempStorage( XMultiServiceFactory xMSF, XSingleServiceFactory xFactory )
1012     {
1013         // create a temporary storage
1014         XStorage xResult = null;
1015         XStream xStream = CreateTempFileStream( xMSF );
1016         if ( xStream == null )
1017         {
1018             Error( "Can't create temp file stream!" );
1019             return null;
1020         }
1021
1022         try
1023         {
1024             xResult = createStorageFromStream( xFactory, xStream, ElementModes.WRITE );
1025         }
1026         catch( Exception e )
1027         {
1028             Error( "Can't create temp storage, exception: " + e );
1029         }
1030
1031         return xResult;
1032     }
1033
1034     public XStorage cloneStorage( XMultiServiceFactory xMSF, XSingleServiceFactory xFactory, XStorage xStorage )
1035     {
1036         // create a copy of a last committed version of specified storage
1037         XStorage xResult = null;
1038         try
1039         {
1040             xResult = createTempStorage( xMSF, xFactory );
1041             if ( xResult != null )
1042                 xStorage.copyLastCommitTo( xResult );
1043         }
1044         catch( Exception e )
1045         {
1046             Error( "Can't clone storage, exception: " + e );
1047             return null;
1048         }
1049
1050         return xResult;
1051     }
1052
1053     public XStorage cloneSubStorage( XMultiServiceFactory xMSF, XSingleServiceFactory xFactory, XStorage xStorage, String sName )
1054     {
1055         // create a copy of a last committed version of specified substorage
1056         XStorage xResult = null;
1057         try
1058         {
1059             xResult = createTempStorage( xMSF, xFactory );
1060             if ( xResult != null )
1061                 xStorage.copyStorageElementLastCommitTo( sName, xResult );
1062         }
1063         catch( Exception e )
1064         {
1065             Error( "Can't clone substorage '" + sName + "', exception: " + e );
1066             return null;
1067         }
1068
1069         return xResult;
1070     }
1071
1072     public XStream cloneSubStream( XStorage xStorage, String sName )
1073     {
1074         // clone existing substream
1075         try
1076         {
1077             XStream xStream = xStorage.cloneStreamElement( sName );
1078             return xStream;
1079         }
1080         catch( Exception e )
1081         {
1082             Error( "Can't clone substream '" + sName + "', exception: " + e );
1083         }
1084
1085         return null;
1086     }
1087
1088     public void Error( String sError )
1089     {
1090         m_aLogWriter.println( m_sTestPrefix + "Error: " + sError );
1091     }
1092
1093     public void Message( String sMessage )
1094     {
1095         m_aLogWriter.println( m_sTestPrefix + sMessage );
1096     }
1097
1098     public void PrintRelations( StringPair[][] aRels )
1099     {
1100         m_aLogWriter.println( "========" );
1101         for ( int nInd1 = 0; nInd1 < aRels.length; nInd1++ )
1102         {
1103             for ( int nInd2 = 0; nInd2 < aRels[nInd1].length; nInd2++ )
1104             {
1105                 m_aLogWriter.println( "\"" + aRels[nInd1][nInd2].First + "\" = \"" + aRels[nInd1][nInd2].Second + "\", " );
1106             }
1107             m_aLogWriter.println( "========" );
1108         }
1109     }
1110 }
1111