| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| package storagetesting; | |
| import com.sun.star.uno.UnoRuntime; | |
| import com.sun.star.uno.XInterface; | |
| import com.sun.star.uno.AnyConverter; | |
| import com.sun.star.lang.*; | |
| import com.sun.star.embed.*; | |
| import com.sun.star.packages.*; | |
| import com.sun.star.io.*; | |
| import com.sun.star.beans.*; | |
| public class TestHelper { | |
| String m_sTestPrefix; | |
| public TestHelper( String sTestPrefix ) | |
| { | |
| m_sTestPrefix = sTestPrefix; | |
| } | |
| public boolean WriteBytesToStream( XStream xStream, | |
| String sStreamName, | |
| String sMediaType, | |
| boolean bCompressed, | |
| byte[] pBytes ) | |
| { | |
| // get output stream of substream | |
| XOutputStream xOutput = xStream.getOutputStream(); | |
| if ( xOutput == null ) | |
| { | |
| Error( "Can't get XOutputStream implementation from substream '" + sStreamName + "'!" ); | |
| return false; | |
| } | |
| // get XTrucate implementation from output stream | |
| XTruncate xTruncate = UnoRuntime.queryInterface( XTruncate.class, xOutput ); | |
| if ( xTruncate == null ) | |
| { | |
| Error( "Can't get XTruncate implementation from substream '" + sStreamName + "'!" ); | |
| return false; | |
| } | |
| // write requested byte sequence | |
| try | |
| { | |
| xTruncate.truncate(); | |
| xOutput.writeBytes( pBytes ); | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Can't write to stream '" + sStreamName + "', exception: " + e ); | |
| return false; | |
| } | |
| // get access to the XPropertySet interface | |
| XPropertySet xPropSet = UnoRuntime.queryInterface( XPropertySet.class, xStream ); | |
| if ( xPropSet == null ) | |
| { | |
| Error( "Can't get XPropertySet implementation from substream '" + sStreamName + "'!" ); | |
| return false; | |
| } | |
| // set properties to the stream | |
| try | |
| { | |
| xPropSet.setPropertyValue( "MediaType", sMediaType ); | |
| xPropSet.setPropertyValue( "Compressed", new Boolean( bCompressed ) ); | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Can't set properties to substream '" + sStreamName + "', exception: " + e ); | |
| return false; | |
| } | |
| // check size property of the stream | |
| try | |
| { | |
| int nSize = AnyConverter.toInt( xPropSet.getPropertyValue( "Size" ) ); | |
| if ( nSize != pBytes.length ) | |
| { | |
| Error( "The 'Size' property of substream '" + sStreamName + "' contains wrong value!" ); | |
| return false; | |
| } | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Can't get 'Size' property from substream '" + sStreamName + "', exception: " + e ); | |
| return false; | |
| } | |
| // free the stream resources, garbage collector may remove the object too late | |
| XComponent xComponent = UnoRuntime.queryInterface( XComponent.class, xStream ); | |
| if ( xComponent == null ) | |
| { | |
| Error( "Can't get XComponent implementation from substream '" + sStreamName + "'!" ); | |
| return false; | |
| } | |
| xComponent.dispose(); | |
| return true; | |
| } | |
| public boolean WriteBytesToSubstream( XStorage xStorage, | |
| String sStreamName, | |
| String sMediaType, | |
| boolean bCompressed, | |
| byte[] pBytes ) | |
| { | |
| // open substream element | |
| XStream xSubStream = null; | |
| try | |
| { | |
| Object oSubStream = xStorage.openStreamElement( sStreamName, ElementModes.ELEMENT_WRITE ); | |
| xSubStream = UnoRuntime.queryInterface( XStream.class, oSubStream ); | |
| if ( xSubStream == null ) | |
| { | |
| Error( "Can't create substream '" + sStreamName + "'!" ); | |
| return false; | |
| } | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Can't create substream '" + sStreamName + "', exception : " + e + "!" ); | |
| return false; | |
| } | |
| return WriteBytesToStream( xSubStream, sStreamName, sMediaType, bCompressed, pBytes ); | |
| } | |
| public boolean WriteBytesToEncrSubstream( XStorage xStorage, | |
| String sStreamName, | |
| String sMediaType, | |
| boolean bCompressed, | |
| byte[] pBytes, | |
| byte[] pPass ) | |
| { | |
| // open substream element | |
| XStream xSubStream = null; | |
| try | |
| { | |
| Object oSubStream = xStorage.openEncryptedStreamElement( sStreamName, ElementModes.ELEMENT_WRITE, pPass ); | |
| xSubStream = UnoRuntime.queryInterface( XStream.class, oSubStream ); | |
| if ( xSubStream == null ) | |
| { | |
| Error( "Can't create substream '" + sStreamName + "'!" ); | |
| return false; | |
| } | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Can't create substream '" + sStreamName + "', exception : " + e + "!" ); | |
| return false; | |
| } | |
| return WriteBytesToStream( xSubStream, sStreamName, sMediaType, bCompressed, pBytes ); | |
| } | |
| public boolean WBToSubstrOfEncr( XStorage xStorage, | |
| String sStreamName, | |
| String sMediaType, | |
| boolean bCompressed, | |
| byte[] pBytes, | |
| boolean bEncrypted ) | |
| { | |
| // open substream element | |
| XStream xSubStream = null; | |
| try | |
| { | |
| Object oSubStream = xStorage.openStreamElement( sStreamName, ElementModes.ELEMENT_WRITE ); | |
| xSubStream = UnoRuntime.queryInterface( XStream.class, oSubStream ); | |
| if ( xSubStream == null ) | |
| { | |
| Error( "Can't create substream '" + sStreamName + "'!" ); | |
| return false; | |
| } | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Can't create substream '" + sStreamName + "', exception : " + e + "!" ); | |
| return false; | |
| } | |
| // get access to the XPropertySet interface | |
| XPropertySet xPropSet = UnoRuntime.queryInterface( XPropertySet.class, xSubStream ); | |
| if ( xPropSet == null ) | |
| { | |
| Error( "Can't get XPropertySet implementation from substream '" + sStreamName + "'!" ); | |
| return false; | |
| } | |
| // set properties to the stream | |
| try | |
| { | |
| xPropSet.setPropertyValue( "Encrypted", new Boolean( bEncrypted ) ); | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Can't set 'Encrypted' property to substream '" + sStreamName + "', exception: " + e ); | |
| return false; | |
| } | |
| return WriteBytesToStream( xSubStream, sStreamName, sMediaType, bCompressed, pBytes ); | |
| } | |
| public int ChangeStreamPass( XStorage xStorage, | |
| String sStreamName, | |
| byte[] pOldPass, | |
| byte[] pNewPass ) | |
| { | |
| // open substream element | |
| XStream xSubStream = null; | |
| try | |
| { | |
| Object oSubStream = xStorage.openEncryptedStreamElement( sStreamName, ElementModes.ELEMENT_WRITE, pOldPass ); | |
| xSubStream = UnoRuntime.queryInterface( XStream.class, oSubStream ); | |
| if ( xSubStream == null ) | |
| { | |
| Error( "Can't open substream '" + sStreamName + "'!" ); | |
| return 0; | |
| } | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Can't open substream '" + sStreamName + "', exception : " + e + "!" ); | |
| return 0; | |
| } | |
| // change the password for the stream | |
| XEncryptionProtectedSource xStreamEncryption = | |
| UnoRuntime.queryInterface( XEncryptionProtectedSource.class, xSubStream ); | |
| if ( xStreamEncryption == null ) | |
| { | |
| Message( "Optional interface XEncryptionProtectedSource is not implemented, feature can not be tested!" ); | |
| return -1; | |
| } | |
| try { | |
| xStreamEncryption.setEncryptionKey( pNewPass ); | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Can't change encryption key of the substream '" + sStreamName + "', exception:" + e ); | |
| return 0; | |
| } | |
| // free the stream resources, garbage collector may remove the object too late | |
| XComponent xComponent = UnoRuntime.queryInterface( XComponent.class, xSubStream ); | |
| if ( xComponent == null ) | |
| { | |
| Error( "Can't get XComponent implementation from substream '" + sStreamName + "'!" ); | |
| return 0; | |
| } | |
| xComponent.dispose(); | |
| return 1; | |
| } | |
| public boolean setStorageTypeAndCheckProps( XStorage xStorage, String sMediaType, boolean bIsRoot, int nMode ) | |
| { | |
| boolean bOk = false; | |
| // get access to the XPropertySet interface | |
| XPropertySet xPropSet = UnoRuntime.queryInterface( XPropertySet.class, xStorage ); | |
| if ( xPropSet != null ) | |
| { | |
| try | |
| { | |
| // set "MediaType" property to the stream | |
| xPropSet.setPropertyValue( "MediaType", sMediaType ); | |
| // get "IsRoot" and "OpenMode" properties and control there values | |
| boolean bPropIsRoot = AnyConverter.toBoolean( xPropSet.getPropertyValue( "IsRoot" ) ); | |
| int nPropMode = AnyConverter.toInt( xPropSet.getPropertyValue( "OpenMode" ) ); | |
| bOk = true; | |
| if ( bPropIsRoot != bIsRoot ) | |
| { | |
| Error( "'IsRoot' property contains wrong value!" ); | |
| bOk = false; | |
| } | |
| if ( ( bIsRoot && ( nPropMode | ElementModes.ELEMENT_READ ) != ( nMode | ElementModes.ELEMENT_READ ) ) | |
| || ( !bIsRoot && ( nPropMode & nMode ) != nMode ) ) | |
| { | |
| Error( "'OpenMode' property contains wrong value!" ); | |
| bOk = false; | |
| } | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Can't control properties of substorage, exception: " + e ); | |
| } | |
| } | |
| else | |
| { | |
| Error( "Can't get XPropertySet implementation from storage!" ); | |
| } | |
| return bOk; | |
| } | |
| public boolean checkStorageProperties( XStorage xStorage, String sMediaType, boolean bIsRoot, int nMode ) | |
| { | |
| boolean bOk = false; | |
| // get access to the XPropertySet interface | |
| XPropertySet xPropSet = UnoRuntime.queryInterface( XPropertySet.class, xStorage ); | |
| if ( xPropSet != null ) | |
| { | |
| try | |
| { | |
| // get "MediaType", "IsRoot" and "OpenMode" properties and control there values | |
| String sPropMediaType = AnyConverter.toString( xPropSet.getPropertyValue( "MediaType" ) ); | |
| boolean bPropIsRoot = AnyConverter.toBoolean( xPropSet.getPropertyValue( "IsRoot" ) ); | |
| int nPropMode = AnyConverter.toInt( xPropSet.getPropertyValue( "OpenMode" ) ); | |
| bOk = true; | |
| if ( !sPropMediaType.equals( sMediaType ) ) | |
| { | |
| Error( "'MediaType' property contains wrong value, expected '" | |
| + sMediaType + "', set '" + sPropMediaType + "' !" ); | |
| bOk = false; | |
| } | |
| if ( bPropIsRoot != bIsRoot ) | |
| { | |
| Error( "'IsRoot' property contains wrong value!" ); | |
| bOk = false; | |
| } | |
| if ( ( bIsRoot && ( nPropMode | ElementModes.ELEMENT_READ ) != ( nMode | ElementModes.ELEMENT_READ ) ) | |
| || ( !bIsRoot && ( nPropMode & nMode ) != nMode ) ) | |
| { | |
| Error( "'OpenMode' property contains wrong value!" ); | |
| bOk = false; | |
| } | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Can't get properties of substorage, exception: " + e ); | |
| } | |
| } | |
| else | |
| { | |
| Error( "Can't get XPropertySet implementation from storage!" ); | |
| } | |
| return bOk; | |
| } | |
| public boolean InternalCheckStream( XStream xStream, | |
| String sName, | |
| String sMediaType, | |
| byte[] pBytes ) | |
| { | |
| // get input stream of substream | |
| XInputStream xInput = xStream.getInputStream(); | |
| if ( xInput == null ) | |
| { | |
| Error( "Can't get XInputStream implementation from substream '" + sName + "'!" ); | |
| return false; | |
| } | |
| byte pContents[][] = new byte[1][]; // ??? | |
| // read contents | |
| try | |
| { | |
| xInput.readBytes( pContents, pBytes.length + 1 ); | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Can't read from stream '" + sName + "', exception: " + e ); | |
| return false; | |
| } | |
| // check size of stream data | |
| if ( pContents.length == 0 ) | |
| { | |
| Error( "SubStream '" + sName + "' reading produced disaster!" ); | |
| return false; | |
| } | |
| if ( pBytes.length != pContents[0].length ) | |
| { | |
| Error( "SubStream '" + sName + "' contains wrong amount of data! (" + pContents[0].length + "/" + pBytes.length + ")" ); | |
| return false; | |
| } | |
| // check stream data | |
| for ( int ind = 0; ind < pBytes.length; ind++ ) | |
| { | |
| if ( pBytes[ind] != pContents[0][ind] ) | |
| { | |
| Error( "SubStream '" + sName + "' contains wrong data!" ); | |
| return false; | |
| } | |
| } | |
| // check properties | |
| boolean bOk = false; | |
| // get access to the XPropertySet interface | |
| XPropertySet xPropSet = UnoRuntime.queryInterface( XPropertySet.class, xStream ); | |
| if ( xPropSet != null ) | |
| { | |
| try | |
| { | |
| // get "MediaType" and "Size" properties and control there values | |
| String sPropMediaType = AnyConverter.toString( xPropSet.getPropertyValue( "MediaType" ) ); | |
| int nPropSize = AnyConverter.toInt( xPropSet.getPropertyValue( "Size" ) ); | |
| bOk = true; | |
| if ( !sPropMediaType.equals( sMediaType ) ) | |
| { | |
| Error( "'MediaType' property contains wrong value for stream '" + sName + "',\nexpected: '" | |
| + sMediaType + "', set: '" + sPropMediaType + "'!" ); | |
| bOk = false; | |
| } | |
| if ( nPropSize != pBytes.length ) | |
| { | |
| Error( "'Size' property contains wrong value for stream'" + sName + "'!" ); | |
| bOk = false; | |
| } | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Can't get properties of substream '" + sName + "', exception: " + e ); | |
| } | |
| } | |
| else | |
| { | |
| Error( "Can't get XPropertySet implementation from stream '" + sName + "'!" ); | |
| } | |
| return bOk; | |
| } | |
| public boolean checkStream( XStorage xParentStorage, | |
| String sName, | |
| String sMediaType, | |
| byte[] pBytes ) | |
| { | |
| // open substream element first | |
| XStream xSubStream = null; | |
| try | |
| { | |
| Object oSubStream = xParentStorage.openStreamElement( sName, ElementModes.ELEMENT_READ ); | |
| xSubStream = UnoRuntime.queryInterface( XStream.class, oSubStream ); | |
| if ( xSubStream == null ) | |
| { | |
| Error( "Can't open substream '" + sName + "'!" ); | |
| return false; | |
| } | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Can't open substream '" + sName + "', exception : " + e + "!" ); | |
| return false; | |
| } | |
| return InternalCheckStream( xSubStream, sName, sMediaType, pBytes ); | |
| } | |
| public boolean checkEncrStream( XStorage xParentStorage, | |
| String sName, | |
| String sMediaType, | |
| byte[] pBytes, | |
| byte[] pPass ) | |
| { | |
| // Important: a common password for any of parent storage should not be set or | |
| // should be different from pPass | |
| if ( pPass.length == 0 ) | |
| { | |
| Error( "Wrong password is used in the test!" ); | |
| return false; | |
| } | |
| try | |
| { | |
| Object oSubStream = xParentStorage.openStreamElement( sName, ElementModes.ELEMENT_READ ); | |
| Error( "Encrypted stream '" + sName + "' was opened without password!" ); | |
| return false; | |
| } | |
| catch( WrongPasswordException wpe ) | |
| {} | |
| catch( Exception e ) | |
| { | |
| Error( "Unexpected exception in case of opening of encrypted stream '" + sName + "' without password: " + e + "!" ); | |
| return false; | |
| } | |
| byte pWrongPass[] = { 1, 1 }; | |
| pWrongPass[0] += pPass[0]; | |
| try | |
| { | |
| Object oSubStream = xParentStorage.openEncryptedStreamElement( sName, ElementModes.ELEMENT_READ, pWrongPass ); | |
| Error( "Encrypted stream '" + sName + "' was opened with wrong password!" ); | |
| return false; | |
| } | |
| catch( WrongPasswordException wpe ) | |
| {} | |
| catch( Exception e ) | |
| { | |
| Error( "Unexpected exception in case of opening of encrypted stream '" + sName + "' with wrong password: " + e + "!" ); | |
| return false; | |
| } | |
| XStream xSubStream = null; | |
| try | |
| { | |
| Object oSubStream = xParentStorage.openEncryptedStreamElement( sName, ElementModes.ELEMENT_READ, pPass ); | |
| xSubStream = UnoRuntime.queryInterface( XStream.class, oSubStream ); | |
| if ( xSubStream == null ) | |
| { | |
| Error( "Can't open encrypted substream '" + sName + "'!" ); | |
| return false; | |
| } | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Can't open encrypted substream '" + sName + "', exception : " + e + "!" ); | |
| return false; | |
| } | |
| return InternalCheckStream( xSubStream, sName, sMediaType, pBytes ); | |
| } | |
| public boolean copyStorage( XStorage xSourceStorage, XStorage xDestStorage ) | |
| { | |
| // copy xSourceStorage to xDestStorage | |
| try | |
| { | |
| xSourceStorage.copyToStorage( xDestStorage ); | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Storage copying failed, exception: " + e ); | |
| return false; | |
| } | |
| return true; | |
| } | |
| public boolean commitStorage( XStorage xStorage ) | |
| { | |
| // XTransactedObject must be supported by storages | |
| XTransactedObject xTransact = UnoRuntime.queryInterface( XTransactedObject.class, xStorage ); | |
| if ( xTransact == null ) | |
| { | |
| Error( "Storage doesn't implement transacted access!" ); | |
| return false; | |
| } | |
| try | |
| { | |
| xTransact.commit(); | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Storage commit failed, exception:" + e ); | |
| return false; | |
| } | |
| return true; | |
| } | |
| public boolean disposeStorage( XStorage xStorage ) | |
| { | |
| // dispose the storage | |
| XComponent xComponent = UnoRuntime.queryInterface( XComponent.class, xStorage ); | |
| if ( xComponent == null ) | |
| { | |
| Error( "Can't retrieve XComponent implementation from storage!" ); | |
| return false; | |
| } | |
| try | |
| { | |
| xComponent.dispose(); | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Storage disposing failed!" ); | |
| return false; | |
| } | |
| return true; | |
| } | |
| public XInputStream getInputStream( XStream xStream ) | |
| { | |
| XInputStream xInTemp = null; | |
| try | |
| { | |
| xInTemp = xStream.getInputStream(); | |
| if ( xInTemp == null ) | |
| Error( "Can't get the input part of a stream!" ); | |
| } | |
| catch ( Exception e ) | |
| { | |
| Error( "Can't get the input part of a stream, exception :" + e ); | |
| } | |
| return xInTemp; | |
| } | |
| public boolean closeOutput( XStream xStream ) | |
| { | |
| XOutputStream xOutTemp = null; | |
| try | |
| { | |
| xOutTemp = xStream.getOutputStream(); | |
| if ( xOutTemp == null ) | |
| { | |
| Error( "Can't get the output part of a stream!" ); | |
| return false; | |
| } | |
| } | |
| catch ( Exception e ) | |
| { | |
| Error( "Can't get the output part of a stream, exception :" + e ); | |
| return false; | |
| } | |
| try | |
| { | |
| xOutTemp.closeOutput(); | |
| } | |
| catch ( Exception e ) | |
| { | |
| Error( "Can't close output part of a stream, exception :" + e ); | |
| return false; | |
| } | |
| return true; | |
| } | |
| public XStorage openSubStorage( XStorage xStorage, String sName, int nMode ) | |
| { | |
| // open existing substorage | |
| try | |
| { | |
| Object oSubStorage = xStorage.openStorageElement( sName, nMode ); | |
| XStorage xSubStorage = UnoRuntime.queryInterface( XStorage.class, oSubStorage ); | |
| return xSubStorage; | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Can't open substorage '" + sName + "', exception: " + e ); | |
| } | |
| return null; | |
| } | |
| public XStream CreateTempFileStream( XMultiServiceFactory xMSF ) | |
| { | |
| // try to get temporary file representation | |
| XStream xTempFileStream = null; | |
| try | |
| { | |
| Object oTempFile = xMSF.createInstance( "com.sun.star.io.TempFile" ); | |
| xTempFileStream = UnoRuntime.queryInterface( XStream.class, oTempFile ); | |
| } | |
| catch( Exception e ) | |
| {} | |
| if ( xTempFileStream == null ) | |
| Error( "Can't create temporary file!" ); | |
| return xTempFileStream; | |
| } | |
| public String CreateTempFile( XMultiServiceFactory xMSF ) | |
| { | |
| String sResult = null; | |
| // try to get temporary file representation | |
| XPropertySet xTempFileProps = null; | |
| try | |
| { | |
| Object oTempFile = xMSF.createInstance( "com.sun.star.io.TempFile" ); | |
| xTempFileProps = UnoRuntime.queryInterface( XPropertySet.class, oTempFile ); | |
| } | |
| catch( Exception e ) | |
| {} | |
| if ( xTempFileProps != null ) | |
| { | |
| try | |
| { | |
| xTempFileProps.setPropertyValue( "RemoveFile", new Boolean( false ) ); | |
| sResult = AnyConverter.toString( xTempFileProps.getPropertyValue( "Uri" ) ); | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Can't control TempFile properties, exception: " + e ); | |
| } | |
| } | |
| else | |
| { | |
| Error( "Can't create temporary file representation!" ); | |
| } | |
| // close temporary file explicitly | |
| try | |
| { | |
| XStream xStream = UnoRuntime.queryInterface( XStream.class, xTempFileProps ); | |
| if ( xStream != null ) | |
| { | |
| XOutputStream xOut = xStream.getOutputStream(); | |
| if ( xOut != null ) | |
| xOut.closeOutput(); | |
| XInputStream xIn = xStream.getInputStream(); | |
| if ( xIn != null ) | |
| xIn.closeInput(); | |
| } | |
| else | |
| Error( "Can't close TempFile!" ); | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Can't close TempFile, exception: " + e ); | |
| } | |
| return sResult; | |
| } | |
| public boolean copyElementTo( XStorage xSource, String sName, XStorage xDest ) | |
| { | |
| // copy element with name sName from xSource to xDest | |
| try | |
| { | |
| xSource.copyElementTo( sName, xDest, sName ); | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Element copying failed, exception: " + e ); | |
| return false; | |
| } | |
| return true; | |
| } | |
| public boolean moveElementTo( XStorage xSource, String sName, XStorage xDest ) | |
| { | |
| // move element with name sName from xSource to xDest | |
| try | |
| { | |
| xSource.moveElementTo( sName, xDest, sName ); | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Element moving failed, exception: " + e ); | |
| return false; | |
| } | |
| return true; | |
| } | |
| public boolean renameElement( XStorage xStorage, String sOldName, String sNewName ) | |
| { | |
| // rename element with name sOldName to sNewName | |
| try | |
| { | |
| xStorage.renameElement( sOldName, sNewName ); | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Element renaming failed, exception: " + e ); | |
| return false; | |
| } | |
| return true; | |
| } | |
| public boolean removeElement( XStorage xStorage, String sName ) | |
| { | |
| // remove element with name sName | |
| try | |
| { | |
| xStorage.removeElement( sName ); | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Element removing failed, exception: " + e ); | |
| return false; | |
| } | |
| return true; | |
| } | |
| public XStream OpenStream( XStorage xStorage, | |
| String sStreamName, | |
| int nMode ) | |
| { | |
| // open substream element | |
| XStream xSubStream = null; | |
| try | |
| { | |
| Object oSubStream = xStorage.openStreamElement( sStreamName, nMode ); | |
| xSubStream = UnoRuntime.queryInterface( XStream.class, oSubStream ); | |
| if ( xSubStream == null ) | |
| Error( "Can't create substream '" + sStreamName + "'!" ); | |
| } | |
| catch( Exception e ) | |
| { | |
| Error( "Can't create substream '" + sStreamName + "', exception : " + e + "!" ); | |
| } | |
| return xSubStream; | |
| } | |
| public boolean cantOpenStorage( XStorage xStorage, String sName ) | |
| { | |
| // try to open an opened substorage, open call must fail | |
| try | |
| { | |
| Object oDummyStorage = xStorage.openStorageElement( sName, ElementModes.ELEMENT_READ ); | |
| Error( "The trying to reopen opened substorage '" + sName + "' must fail!" ); | |
| } | |
| catch( Exception e ) | |
| { | |
| return true; | |
| } | |
| return false; | |
| } | |
| public boolean cantOpenStream( XStorage xStorage, String sName, int nMode ) | |
| { | |
| // try to open the substream with specified mode must fail | |
| try | |
| { | |
| Object oDummyStream = xStorage.openStreamElement( sName, nMode ); | |
| Error( "The trying to open substoream '" + sName + "' must fail!" ); | |
| } | |
| catch( Exception e ) | |
| { | |
| return true; | |
| } | |
| return false; | |
| } | |
| public void Error( String sError ) | |
| { | |
| System.out.println( m_sTestPrefix + "Error: " + sError ); | |
| } | |
| public void Message( String sError ) | |
| { | |
| System.out.println( m_sTestPrefix + sError ); | |
| } | |
| } |